[llvm-commits] [llvm] r95283 - in /llvm/trunk: lib/Transforms/InstCombine/InstCombineCalls.cpp test/Transforms/InstCombine/objsize.ll
Eric Christopher
echristo at apple.com
Wed Feb 3 18:55:34 PST 2010
Author: echristo
Date: Wed Feb 3 20:55:34 2010
New Revision: 95283
URL: http://llvm.org/viewvc/llvm-project?rev=95283&view=rev
Log:
Rework constant expr and array handling for objectsize instcombining.
Fix bugs where we would compute out of bounds as in bounds, and where
we couldn't know that the linker could override the size of an array.
Add a few new testcases, change existing testcase to use a private
global array instead of extern.
Modified:
llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
llvm/trunk/test/Transforms/InstCombine/objsize.ll
Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp?rev=95283&r1=95282&r2=95283&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp (original)
+++ llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp Wed Feb 3 20:55:34 2010
@@ -635,43 +635,69 @@
case Intrinsic::objectsize: {
const Type *ReturnTy = CI.getType();
Value *Op1 = II->getOperand(1);
-
- // If we're a constant expr then we just return the number of bytes
- // left in whatever we're indexing. Since it's constant there's no
- // need for maximum or minimum bytes.
+
+ // If we've got a GEP we're going to do some calculations
+ size_t GEPindex = 0;
+
+ // Strip any casts we see and continue processing.
+ Op1 = Op1->stripPointerCasts();
+
+ // Make sure we can reliably know the size.
+ if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Op1))
+ if (!GV->hasDefinitiveInitializer()) break;
+
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Op1)) {
- // If this isn't a GEP give up.
- if (CE->getOpcode() != Instruction::GetElementPtr) return 0;
+ // If this isn't a GEP give up.
+ if (CE->getOpcode() != Instruction::GetElementPtr) break;
- const PointerType *ObjTy =
- reinterpret_cast<const PointerType*>(CE->getOperand(0)->getType());
+ // If this isn't guaranteed to be inbounds, give up.
+ bool OOB = false;
+ GEPOperator *GEPO = cast<GEPOperator>(Op1);
+ if (!GEPO->isInBounds()) OOB = true;
+
+ for (int i = GEPO->getNumIndices() - 1; i > 0; i--) {
+ if (Constant *C = dyn_cast<Constant>(GEPO->getOperand(i)))
+ if (C->isNullValue())
+ continue;
+
+ OOB = true;
+ }
+
+ // If we're guaranteed to be out of bounds just return that there's
+ // no room left.
+ if (OOB) return ReplaceInstUsesWith(CI, ConstantInt::get(ReturnTy, 0));
+
+ // Tell the later calculation that we have an offset and what
+ // it is.
+ Op1 = CE->getOperand(0);
+ ConstantInt *Const =
+ cast<ConstantInt>(CE->getOperand(CE->getNumOperands() - 1));
+ GEPindex = Const->getZExtValue();
+ }
- if (const ArrayType *AT = dyn_cast<ArrayType>(ObjTy->getElementType())) {
+ // This may be a pointer to an array. If we have an index from earlier
+ // use that too.
+ if (const PointerType *PT = dyn_cast<PointerType>(Op1->getType())) {
+ if (const ArrayType *AT = dyn_cast<ArrayType>(PT->getElementType())) {
// Deal with multi-dimensional arrays
const ArrayType *SAT = AT;
while ((AT = dyn_cast<ArrayType>(AT->getElementType())))
SAT = AT;
-
- size_t numElems = SAT->getNumElements();
-
- // If numElems is 0, we don't know how large the array is so we can't
- // make any determinations yet.
- if (numElems == 0) break;
// We return the remaining bytes, so grab the size of an element
- // in bytes.
- size_t sizeofElem = SAT->getElementType()->getPrimitiveSizeInBits() / 8;
+ // in bytes and the number of elements.
+ if (!SAT->isSized() || !TD) break;
- ConstantInt *Const =
- cast<ConstantInt>(CE->getOperand(CE->getNumOperands() - 1));
- size_t indx = Const->getZExtValue();
- return ReplaceInstUsesWith(CI,
- ConstantInt::get(ReturnTy,
- ((numElems - indx) * sizeofElem)));
+ size_t sizeofElem = TD->getTypeAllocSize(SAT->getElementType());
+ size_t numElems = SAT->getNumElements();
+ size_t remSize = (numElems - GEPindex) * sizeofElem;
+ return ReplaceInstUsesWith(CI, ConstantInt::get(ReturnTy, remSize));
}
}
+
// TODO: Add more types here.
+ // TODO: Check for type isSized() here as well.
}
}
Modified: llvm/trunk/test/Transforms/InstCombine/objsize.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstCombine/objsize.ll?rev=95283&r1=95282&r2=95283&view=diff
==============================================================================
--- llvm/trunk/test/Transforms/InstCombine/objsize.ll (original)
+++ llvm/trunk/test/Transforms/InstCombine/objsize.ll Wed Feb 3 20:55:34 2010
@@ -1,5 +1,9 @@
+; Test a pile of objectsize bounds checking.
; RUN: opt < %s -instcombine -S | FileCheck %s
- at a = common global [60 x i8] zeroinitializer, align 1 ; <[60 x i8]*>
+; We need target data to get the sizes of the arrays and structures.
+target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
+
+ at a = private global [60 x i8] zeroinitializer, align 1 ; <[60 x i8]*>
@.str = private constant [8 x i8] c"abcdefg\00" ; <[8 x i8]*>
define i32 @foo() nounwind {
@@ -27,6 +31,13 @@
ret i8* %2;
}
+define i32 @f() nounwind {
+; CHECK: @f
+; CHECK-NEXT: ret i32 0
+ %1 = call i32 @llvm.objectsize.i32(i8* getelementptr ([60 x i8]* @a, i32 1, i32 0), i1 false)
+ ret i32 %1
+}
+
@window = external global [0 x i8]
define i1 @baz() nounwind {
@@ -37,5 +48,4 @@
ret i1 %2
}
-
declare i32 @llvm.objectsize.i32(i8*, i1) nounwind readonly
\ No newline at end of file
More information about the llvm-commits
mailing list