add support for calloc to objectsize lowering

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

diff --git a/include/llvm/Analysis/MemoryBuiltins.h b/include/llvm/Analysis/MemoryBuiltins.h
index 865d236..e7dcbf3 100644 (file)
--- a/include/llvm/Analysis/MemoryBuiltins.h
+++ b/include/llvm/Analysis/MemoryBuiltins.h
@@ -68,6 +68,17 @@ Type *getMallocAllocatedType(const CallInst *CI);
 Value *getMallocArraySize(CallInst *CI, const TargetData *TD,
                           bool LookThroughSExt = false);
                           
+
+//===----------------------------------------------------------------------===//
+//  calloc Call Utility Functions.
+//
+
+/// extractCallocCall - Returns the corresponding CallInst if the instruction
+/// is a calloc call.
+const CallInst *extractCallocCall(const Value *I);
+CallInst *extractCallocCall(Value *I);
+
+
 //===----------------------------------------------------------------------===//
 //  free Call Utility Functions.
 //

diff --git a/lib/Analysis/MemoryBuiltins.cpp b/lib/Analysis/MemoryBuiltins.cpp
index b145650..347a7ea 100644 (file)
--- 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 5be7997..4196ca6 100644 (file)
--- 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

diff --git a/test/Transforms/InstCombine/objsize.ll b/test/Transforms/InstCombine/objsize.ll
index 28ceb68..6b5c0f5 100644 (file)
--- a/test/Transforms/InstCombine/objsize.ll
+++ b/test/Transforms/InstCombine/objsize.ll
@@ -158,3 +158,23 @@ define i32 @test7() {
   ret i32 %objsize
 }
 
+declare noalias i8* @calloc(i32, i32) nounwind
+
+define i32 @test8() {
+; CHECK: @test8
+  %alloc = call noalias i8* @calloc(i32 5, i32 7) nounwind
+  %gep = getelementptr inbounds i8* %alloc, i32 5
+  %objsize = call i32 @llvm.objectsize.i32(i8* %gep, i1 false) nounwind readonly
+; CHECK: ret i32 30
+  ret i32 %objsize
+}
+
+; test for overflow in calloc
+define i32 @test9() {
+; CHECK: @test9
+  %alloc = call noalias i8* @calloc(i32 100000000, i32 100000000) nounwind
+  %gep = getelementptr inbounds i8* %alloc, i32 2
+  %objsize = call i32 @llvm.objectsize.i32(i8* %gep, i1 true) nounwind readonly
+; CHECK: ret i32 0
+  ret i32 %objsize
+}