Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 1 of 2.

1 files changed, 94 insertions, 94 deletions

diff --git a/contrib/libs/llvm12/lib/Transforms/Utils/SimplifyLibCalls.cpp b/contrib/libs/llvm12/lib/Transforms/Utils/SimplifyLibCalls.cpp
index f9a9dd237b..7217405b70 100644
--- a/contrib/libs/llvm12/lib/Transforms/Utils/SimplifyLibCalls.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/Utils/SimplifyLibCalls.cpp
@@ -541,8 +541,8 @@ Value *LibCallSimplifier::optimizeStrCpy(CallInst *CI, IRBuilderBase &B) {
       B.CreateMemCpy(Dst, Align(1), Src, Align(1),
                      ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len));
   NewCI->setAttributes(CI->getAttributes());
-  NewCI->removeAttributes(AttributeList::ReturnIndex,
-                          AttributeFuncs::typeIncompatible(NewCI->getType()));
+  NewCI->removeAttributes(AttributeList::ReturnIndex, 
+                          AttributeFuncs::typeIncompatible(NewCI->getType())); 
   return Dst;
 }
 
@@ -570,8 +570,8 @@ Value *LibCallSimplifier::optimizeStpCpy(CallInst *CI, IRBuilderBase &B) {
   // copy for us.  Make a memcpy to copy the nul byte with align = 1.
   CallInst *NewCI = B.CreateMemCpy(Dst, Align(1), Src, Align(1), LenV);
   NewCI->setAttributes(CI->getAttributes());
-  NewCI->removeAttributes(AttributeList::ReturnIndex,
-                          AttributeFuncs::typeIncompatible(NewCI->getType()));
+  NewCI->removeAttributes(AttributeList::ReturnIndex, 
+                          AttributeFuncs::typeIncompatible(NewCI->getType())); 
   return DstEnd;
 }
 
@@ -612,27 +612,27 @@ Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilderBase &B) {
     return Dst;
   }
 
-  // strncpy(a, "a", 4) - > memcpy(a, "a\0\0\0", 4)
-  if (Len > SrcLen + 1) {
-    if (Len <= 128) {
-      StringRef Str;
-      if (!getConstantStringInfo(Src, Str))
-        return nullptr;
-      std::string SrcStr = Str.str();
-      SrcStr.resize(Len, '\0');
-      Src = B.CreateGlobalString(SrcStr, "str");
-    } else {
-      return nullptr;
-    }
-  }
+  // strncpy(a, "a", 4) - > memcpy(a, "a\0\0\0", 4) 
+  if (Len > SrcLen + 1) { 
+    if (Len <= 128) { 
+      StringRef Str; 
+      if (!getConstantStringInfo(Src, Str)) 
+        return nullptr; 
+      std::string SrcStr = Str.str(); 
+      SrcStr.resize(Len, '\0'); 
+      Src = B.CreateGlobalString(SrcStr, "str"); 
+    } else { 
+      return nullptr; 
+    } 
+  } 
 
   Type *PT = Callee->getFunctionType()->getParamType(0);
   // strncpy(x, s, c) -> memcpy(align 1 x, align 1 s, c) [s and c are constant]
   CallInst *NewCI = B.CreateMemCpy(Dst, Align(1), Src, Align(1),
                                    ConstantInt::get(DL.getIntPtrType(PT), Len));
   NewCI->setAttributes(CI->getAttributes());
-  NewCI->removeAttributes(AttributeList::ReturnIndex,
-                          AttributeFuncs::typeIncompatible(NewCI->getType()));
+  NewCI->removeAttributes(AttributeList::ReturnIndex, 
+                          AttributeFuncs::typeIncompatible(NewCI->getType())); 
   return Dst;
 }
 
@@ -1108,8 +1108,8 @@ Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilderBase &B) {
   CallInst *NewCI = B.CreateMemCpy(CI->getArgOperand(0), Align(1),
                                    CI->getArgOperand(1), Align(1), Size);
   NewCI->setAttributes(CI->getAttributes());
-  NewCI->removeAttributes(AttributeList::ReturnIndex,
-                          AttributeFuncs::typeIncompatible(NewCI->getType()));
+  NewCI->removeAttributes(AttributeList::ReturnIndex, 
+                          AttributeFuncs::typeIncompatible(NewCI->getType())); 
   return CI->getArgOperand(0);
 }
 
@@ -1158,12 +1158,12 @@ Value *LibCallSimplifier::optimizeMemPCpy(CallInst *CI, IRBuilderBase &B) {
   // mempcpy(x, y, n) -> llvm.memcpy(align 1 x, align 1 y, n), x + n
   CallInst *NewCI =
       B.CreateMemCpy(Dst, Align(1), CI->getArgOperand(1), Align(1), N);
-  // Propagate attributes, but memcpy has no return value, so make sure that
-  // any return attributes are compliant.
-  // TODO: Attach return value attributes to the 1st operand to preserve them?
+  // Propagate attributes, but memcpy has no return value, so make sure that 
+  // any return attributes are compliant. 
+  // TODO: Attach return value attributes to the 1st operand to preserve them? 
   NewCI->setAttributes(CI->getAttributes());
-  NewCI->removeAttributes(AttributeList::ReturnIndex,
-                          AttributeFuncs::typeIncompatible(NewCI->getType()));
+  NewCI->removeAttributes(AttributeList::ReturnIndex, 
+                          AttributeFuncs::typeIncompatible(NewCI->getType())); 
   return B.CreateInBoundsGEP(B.getInt8Ty(), Dst, N);
 }
 
@@ -1177,8 +1177,8 @@ Value *LibCallSimplifier::optimizeMemMove(CallInst *CI, IRBuilderBase &B) {
   CallInst *NewCI = B.CreateMemMove(CI->getArgOperand(0), Align(1),
                                     CI->getArgOperand(1), Align(1), Size);
   NewCI->setAttributes(CI->getAttributes());
-  NewCI->removeAttributes(AttributeList::ReturnIndex,
-                          AttributeFuncs::typeIncompatible(NewCI->getType()));
+  NewCI->removeAttributes(AttributeList::ReturnIndex, 
+                          AttributeFuncs::typeIncompatible(NewCI->getType())); 
   return CI->getArgOperand(0);
 }
 
@@ -1239,8 +1239,8 @@ Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilderBase &B) {
   Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
   CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val, Size, Align(1));
   NewCI->setAttributes(CI->getAttributes());
-  NewCI->removeAttributes(AttributeList::ReturnIndex,
-                          AttributeFuncs::typeIncompatible(NewCI->getType()));
+  NewCI->removeAttributes(AttributeList::ReturnIndex, 
+                          AttributeFuncs::typeIncompatible(NewCI->getType())); 
   return CI->getArgOperand(0);
 }
 
@@ -1653,14 +1653,14 @@ Value *LibCallSimplifier::replacePowWithSqrt(CallInst *Pow, IRBuilderBase &B) {
   if (ExpoF->isNegative() && (!Pow->hasApproxFunc() && !Pow->hasAllowReassoc()))
     return nullptr;
 
-  // If we have a pow() library call (accesses memory) and we can't guarantee
-  // that the base is not an infinity, give up:
-  // pow(-Inf, 0.5) is optionally required to have a result of +Inf (not setting
-  // errno), but sqrt(-Inf) is required by various standards to set errno.
-  if (!Pow->doesNotAccessMemory() && !Pow->hasNoInfs() &&
-      !isKnownNeverInfinity(Base, TLI))
-    return nullptr;
-
+  // If we have a pow() library call (accesses memory) and we can't guarantee 
+  // that the base is not an infinity, give up: 
+  // pow(-Inf, 0.5) is optionally required to have a result of +Inf (not setting 
+  // errno), but sqrt(-Inf) is required by various standards to set errno. 
+  if (!Pow->doesNotAccessMemory() && !Pow->hasNoInfs() && 
+      !isKnownNeverInfinity(Base, TLI)) 
+    return nullptr; 
+ 
   Sqrt = getSqrtCall(Base, Attrs, Pow->doesNotAccessMemory(), Mod, B, TLI);
   if (!Sqrt)
     return nullptr;
@@ -1747,8 +1747,8 @@ Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilderBase &B) {
 
   // pow(x, n) -> x * x * x * ...
   const APFloat *ExpoF;
-  if (AllowApprox && match(Expo, m_APFloat(ExpoF)) &&
-      !ExpoF->isExactlyValue(0.5) && !ExpoF->isExactlyValue(-0.5)) {
+  if (AllowApprox && match(Expo, m_APFloat(ExpoF)) && 
+      !ExpoF->isExactlyValue(0.5) && !ExpoF->isExactlyValue(-0.5)) { 
     // We limit to a max of 7 multiplications, thus the maximum exponent is 32.
     // If the exponent is an integer+0.5 we generate a call to sqrt and an
     // additional fmul.
@@ -1774,8 +1774,8 @@ Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilderBase &B) {
 
         Sqrt = getSqrtCall(Base, Pow->getCalledFunction()->getAttributes(),
                            Pow->doesNotAccessMemory(), M, B, TLI);
-        if (!Sqrt)
-          return nullptr;
+        if (!Sqrt) 
+          return nullptr; 
       }
 
       // We will memoize intermediate products of the Addition Chain.
@@ -2199,7 +2199,7 @@ Value *LibCallSimplifier::optimizeSinCosPi(CallInst *CI, IRBuilderBase &B) {
     classifyArgUse(U, F, IsFloat, SinCalls, CosCalls, SinCosCalls);
 
   // It's only worthwhile if both sinpi and cospi are actually used.
-  if (SinCalls.empty() || CosCalls.empty())
+  if (SinCalls.empty() || CosCalls.empty()) 
     return nullptr;
 
   Value *Sin, *Cos, *SinCos;
@@ -2225,7 +2225,7 @@ void LibCallSimplifier::classifyArgUse(
     SmallVectorImpl<CallInst *> &SinCosCalls) {
   CallInst *CI = dyn_cast<CallInst>(Val);
 
-  if (!CI || CI->use_empty())
+  if (!CI || CI->use_empty()) 
     return;
 
   // Don't consider calls in other functions.
@@ -2522,30 +2522,30 @@ Value *LibCallSimplifier::optimizeSPrintFString(CallInst *CI,
     if (!CI->getArgOperand(2)->getType()->isPointerTy())
       return nullptr;
 
-    if (CI->use_empty())
-      // sprintf(dest, "%s", str) -> strcpy(dest, str)
-      return emitStrCpy(CI->getArgOperand(0), CI->getArgOperand(2), B, TLI);
-
-    uint64_t SrcLen = GetStringLength(CI->getArgOperand(2));
-    if (SrcLen) {
-      B.CreateMemCpy(
-          CI->getArgOperand(0), Align(1), CI->getArgOperand(2), Align(1),
-          ConstantInt::get(DL.getIntPtrType(CI->getContext()), SrcLen));
-      // Returns total number of characters written without null-character.
-      return ConstantInt::get(CI->getType(), SrcLen - 1);
-    } else if (Value *V = emitStpCpy(CI->getArgOperand(0), CI->getArgOperand(2),
-                                     B, TLI)) {
-      // sprintf(dest, "%s", str) -> stpcpy(dest, str) - dest
-      Value *PtrDiff = B.CreatePtrDiff(V, CI->getArgOperand(0));
-      return B.CreateIntCast(PtrDiff, CI->getType(), false);
-    }
-
-    bool OptForSize = CI->getFunction()->hasOptSize() ||
-                      llvm::shouldOptimizeForSize(CI->getParent(), PSI, BFI,
-                                                  PGSOQueryType::IRPass);
-    if (OptForSize)
-      return nullptr;
-
+    if (CI->use_empty()) 
+      // sprintf(dest, "%s", str) -> strcpy(dest, str) 
+      return emitStrCpy(CI->getArgOperand(0), CI->getArgOperand(2), B, TLI); 
+ 
+    uint64_t SrcLen = GetStringLength(CI->getArgOperand(2)); 
+    if (SrcLen) { 
+      B.CreateMemCpy( 
+          CI->getArgOperand(0), Align(1), CI->getArgOperand(2), Align(1), 
+          ConstantInt::get(DL.getIntPtrType(CI->getContext()), SrcLen)); 
+      // Returns total number of characters written without null-character. 
+      return ConstantInt::get(CI->getType(), SrcLen - 1); 
+    } else if (Value *V = emitStpCpy(CI->getArgOperand(0), CI->getArgOperand(2), 
+                                     B, TLI)) { 
+      // sprintf(dest, "%s", str) -> stpcpy(dest, str) - dest 
+      Value *PtrDiff = B.CreatePtrDiff(V, CI->getArgOperand(0)); 
+      return B.CreateIntCast(PtrDiff, CI->getType(), false); 
+    } 
+ 
+    bool OptForSize = CI->getFunction()->hasOptSize() || 
+                      llvm::shouldOptimizeForSize(CI->getParent(), PSI, BFI, 
+                                                  PGSOQueryType::IRPass); 
+    if (OptForSize) 
+      return nullptr; 
+ 
     Value *Len = emitStrLen(CI->getArgOperand(2), B, DL, TLI);
     if (!Len)
       return nullptr;
@@ -3278,8 +3278,8 @@ Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(CallInst *CI,
         B.CreateMemCpy(CI->getArgOperand(0), Align(1), CI->getArgOperand(1),
                        Align(1), CI->getArgOperand(2));
     NewCI->setAttributes(CI->getAttributes());
-    NewCI->removeAttributes(AttributeList::ReturnIndex,
-                            AttributeFuncs::typeIncompatible(NewCI->getType()));
+    NewCI->removeAttributes(AttributeList::ReturnIndex, 
+                            AttributeFuncs::typeIncompatible(NewCI->getType())); 
     return CI->getArgOperand(0);
   }
   return nullptr;
@@ -3292,8 +3292,8 @@ Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(CallInst *CI,
         B.CreateMemMove(CI->getArgOperand(0), Align(1), CI->getArgOperand(1),
                         Align(1), CI->getArgOperand(2));
     NewCI->setAttributes(CI->getAttributes());
-    NewCI->removeAttributes(AttributeList::ReturnIndex,
-                            AttributeFuncs::typeIncompatible(NewCI->getType()));
+    NewCI->removeAttributes(AttributeList::ReturnIndex, 
+                            AttributeFuncs::typeIncompatible(NewCI->getType())); 
     return CI->getArgOperand(0);
   }
   return nullptr;
@@ -3308,29 +3308,29 @@ Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI,
     CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val,
                                      CI->getArgOperand(2), Align(1));
     NewCI->setAttributes(CI->getAttributes());
-    NewCI->removeAttributes(AttributeList::ReturnIndex,
-                            AttributeFuncs::typeIncompatible(NewCI->getType()));
+    NewCI->removeAttributes(AttributeList::ReturnIndex, 
+                            AttributeFuncs::typeIncompatible(NewCI->getType())); 
     return CI->getArgOperand(0);
   }
   return nullptr;
 }
 
-Value *FortifiedLibCallSimplifier::optimizeMemPCpyChk(CallInst *CI,
-                                                      IRBuilderBase &B) {
-  const DataLayout &DL = CI->getModule()->getDataLayout();
-  if (isFortifiedCallFoldable(CI, 3, 2))
-    if (Value *Call = emitMemPCpy(CI->getArgOperand(0), CI->getArgOperand(1),
-                                  CI->getArgOperand(2), B, DL, TLI)) {
-      CallInst *NewCI = cast<CallInst>(Call);
-      NewCI->setAttributes(CI->getAttributes());
-      NewCI->removeAttributes(
-          AttributeList::ReturnIndex,
-          AttributeFuncs::typeIncompatible(NewCI->getType()));
-      return NewCI;
-    }
-  return nullptr;
-}
-
+Value *FortifiedLibCallSimplifier::optimizeMemPCpyChk(CallInst *CI, 
+                                                      IRBuilderBase &B) { 
+  const DataLayout &DL = CI->getModule()->getDataLayout(); 
+  if (isFortifiedCallFoldable(CI, 3, 2)) 
+    if (Value *Call = emitMemPCpy(CI->getArgOperand(0), CI->getArgOperand(1), 
+                                  CI->getArgOperand(2), B, DL, TLI)) { 
+      CallInst *NewCI = cast<CallInst>(Call); 
+      NewCI->setAttributes(CI->getAttributes()); 
+      NewCI->removeAttributes( 
+          AttributeList::ReturnIndex, 
+          AttributeFuncs::typeIncompatible(NewCI->getType())); 
+      return NewCI; 
+    } 
+  return nullptr; 
+} 
+ 
 Value *FortifiedLibCallSimplifier::optimizeStrpCpyChk(CallInst *CI,
                                                       IRBuilderBase &B,
                                                       LibFunc Func) {
@@ -3411,7 +3411,7 @@ Value *FortifiedLibCallSimplifier::optimizeMemCCpyChk(CallInst *CI,
 Value *FortifiedLibCallSimplifier::optimizeSNPrintfChk(CallInst *CI,
                                                        IRBuilderBase &B) {
   if (isFortifiedCallFoldable(CI, 3, 1, None, 2)) {
-    SmallVector<Value *, 8> VariadicArgs(drop_begin(CI->args(), 5));
+    SmallVector<Value *, 8> VariadicArgs(drop_begin(CI->args(), 5)); 
     return emitSNPrintf(CI->getArgOperand(0), CI->getArgOperand(1),
                         CI->getArgOperand(4), VariadicArgs, B, TLI);
   }
@@ -3422,7 +3422,7 @@ Value *FortifiedLibCallSimplifier::optimizeSNPrintfChk(CallInst *CI,
 Value *FortifiedLibCallSimplifier::optimizeSPrintfChk(CallInst *CI,
                                                       IRBuilderBase &B) {
   if (isFortifiedCallFoldable(CI, 2, None, None, 1)) {
-    SmallVector<Value *, 8> VariadicArgs(drop_begin(CI->args(), 4));
+    SmallVector<Value *, 8> VariadicArgs(drop_begin(CI->args(), 4)); 
     return emitSPrintf(CI->getArgOperand(0), CI->getArgOperand(3), VariadicArgs,
                        B, TLI);
   }
@@ -3520,8 +3520,8 @@ Value *FortifiedLibCallSimplifier::optimizeCall(CallInst *CI,
   switch (Func) {
   case LibFunc_memcpy_chk:
     return optimizeMemCpyChk(CI, Builder);
-  case LibFunc_mempcpy_chk:
-    return optimizeMemPCpyChk(CI, Builder);
+  case LibFunc_mempcpy_chk: 
+    return optimizeMemPCpyChk(CI, Builder); 
   case LibFunc_memmove_chk:
     return optimizeMemMoveChk(CI, Builder);
   case LibFunc_memset_chk: