add support for calloc to objectsize lowering

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156102 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 57 insertions, 5 deletions

diff --git a/lib/Analysis/MemoryBuiltins.cpp b/lib/Analysis/MemoryBuiltins.cpp
index b145650b0f..347a7ea7a8 100644
--- a/lib/Analysis/MemoryBuiltins.cpp
+++ b/lib/Analysis/MemoryBuiltins.cpp
@@ -180,6 +180,46 @@ Value *llvm::getMallocArraySize(CallInst *CI, const TargetData *TD,
   return computeArraySize(CI, TD, LookThroughSExt);
 }
 
+
+//===----------------------------------------------------------------------===//
+//  clloc Call Utility Functions.
+//
+
+static bool isCallocCall(const CallInst *CI) {
+  if (!CI)
+    return false;
+  
+  Function *Callee = CI->getCalledFunction();
+  if (Callee == 0 || !Callee->isDeclaration())
+    return false;
+  if (Callee->getName() != "calloc")
+    return false;
+  
+  // Check malloc prototype.
+  // FIXME: workaround for PR5130, this will be obsolete when a nobuiltin 
+  // attribute will exist.
+  FunctionType *FTy = Callee->getFunctionType();
+  return FTy->getReturnType() == Type::getInt8PtrTy(FTy->getContext()) &&
+  FTy->getNumParams() == 2 &&
+  ((FTy->getParamType(0)->isIntegerTy(32) &&
+    FTy->getParamType(1)->isIntegerTy(32)) ||
+   (FTy->getParamType(0)->isIntegerTy(64) &&
+    FTy->getParamType(1)->isIntegerTy(64)));
+}
+
+/// extractCallocCall - Returns the corresponding CallInst if the instruction
+/// is a calloc call.
+const CallInst *llvm::extractCallocCall(const Value *I) {
+  const CallInst *CI = dyn_cast<CallInst>(I);
+  return isCallocCall(CI) ? CI : 0;
+}
+
+CallInst *llvm::extractCallocCall(Value *I) {
+  CallInst *CI = dyn_cast<CallInst>(I);
+  return isCallocCall(CI) ? CI : 0;
+}
+
+
 //===----------------------------------------------------------------------===//
 //  free Call Utility Functions.
 //
diff --git a/lib/Transforms/InstCombine/InstCombineCalls.cpp b/lib/Transforms/InstCombine/InstCombineCalls.cpp
index 5be7997367..4196ca6cf7 100644
--- a/lib/Transforms/InstCombine/InstCombineCalls.cpp
+++ b/lib/Transforms/InstCombine/InstCombineCalls.cpp
@@ -300,11 +300,23 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) {
       }
     } else if (CallInst *MI = extractMallocCall(Op1)) {
       // Get allocation size.
-      Type* MallocType = getMallocAllocatedType(MI);
-      if (MallocType && MallocType->isSized())
-        if (Value *NElems = getMallocArraySize(MI, TD, true))
-          if (ConstantInt *NElements = dyn_cast<ConstantInt>(NElems))
-            Size = NElements->getZExtValue() * TD->getTypeAllocSize(MallocType);
+      Value *Arg = MI->getArgOperand(0);
+      if (ConstantInt *CI = dyn_cast<ConstantInt>(Arg))
+          Size = CI->getZExtValue();
+
+    } else if (CallInst *MI = extractCallocCall(Op1)) {
+      // Get allocation size.
+      Value *Arg1 = MI->getArgOperand(0);
+      Value *Arg2 = MI->getArgOperand(1);
+      if (ConstantInt *CI1 = dyn_cast<ConstantInt>(Arg1))
+        if (ConstantInt *CI2 = dyn_cast<ConstantInt>(Arg2)) {
+          bool overflow;
+          APInt SizeAP = CI1->getValue().umul_ov(CI2->getValue(), overflow);
+          if (!overflow)
+            Size = SizeAP.getZExtValue();
+          else
+            return ReplaceInstUsesWith(CI, ConstantInt::get(ReturnTy, DontKnow));
+        }
     }
 
     // Do not return "I don't know" here. Later optimization passes could