From a6a089cd244033109a232c99cb09ac424703afff Mon Sep 17 00:00:00 2001 From: Eric Christopher Date: Tue, 2 Feb 2010 22:10:43 +0000 Subject: [PATCH] Re-add strcmp and known size object size checking optimization. Passed bootstrap and nightly test run here. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@95145 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/InstCombine/InstCombineCalls.cpp | 44 +++++++++++++++++++------ lib/Transforms/Scalar/SimplifyLibCalls.cpp | 9 +++-- test/Transforms/InstCombine/objsize.ll | 30 +++++++++++++++++ test/Transforms/SimplifyLibCalls/strcpy_chk.ll | 12 +++++++ 4 files changed, 83 insertions(+), 12 deletions(-) create mode 100644 test/Transforms/InstCombine/objsize.ll create mode 100644 test/Transforms/SimplifyLibCalls/strcpy_chk.ll diff --git a/lib/Transforms/InstCombine/InstCombineCalls.cpp b/lib/Transforms/InstCombine/InstCombineCalls.cpp index 5de846e90cf..d49f3b5b702 100644 --- a/lib/Transforms/InstCombine/InstCombineCalls.cpp +++ b/lib/Transforms/InstCombine/InstCombineCalls.cpp @@ -633,16 +633,40 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) { break; } case Intrinsic::objectsize: { - ConstantInt *Const = cast(II->getOperand(2)); - const Type *Ty = CI.getType(); - - // 0 is maximum number of bytes left, 1 is minimum number of bytes left. - // TODO: actually add these values, the current return values are "don't - // know". - if (Const->getZExtValue() == 0) - return ReplaceInstUsesWith(CI, Constant::getAllOnesValue(Ty)); - else - return ReplaceInstUsesWith(CI, ConstantInt::get(Ty, 0)); + 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 (ConstantExpr *CE = dyn_cast(Op1)) { + // If this isn't a GEP give up. + if (CE->getOpcode() != Instruction::GetElementPtr) return 0; + + const PointerType *ObjTy = + reinterpret_cast(CE->getOperand(0)->getType()); + + if (const ArrayType *AT = dyn_cast(ObjTy->getElementType())) { + + // Deal with multi-dimensional arrays + const ArrayType *SAT = AT; + while ((AT = dyn_cast(AT->getElementType()))) + SAT = AT; + + size_t numElems = SAT->getNumElements(); + // We return the remaining bytes, so grab the size of an element + // in bytes. + size_t sizeofElem = SAT->getElementType()->getPrimitiveSizeInBits() / 8; + + ConstantInt *Const = + cast(CE->getOperand(CE->getNumOperands() - 1)); + size_t indx = Const->getZExtValue(); + return ReplaceInstUsesWith(CI, + ConstantInt::get(ReturnTy, + ((numElems - indx) * sizeofElem))); + } + } + // TODO: Add more types here. } } diff --git a/lib/Transforms/Scalar/SimplifyLibCalls.cpp b/lib/Transforms/Scalar/SimplifyLibCalls.cpp index db6ff29200f..4216e8f995c 100644 --- a/lib/Transforms/Scalar/SimplifyLibCalls.cpp +++ b/lib/Transforms/Scalar/SimplifyLibCalls.cpp @@ -1213,8 +1213,13 @@ struct StrCpyChkOpt : public LibCallOptimization { if (!SizeCI) return 0; - // We don't have any length information, just lower to a plain strcpy. - if (SizeCI->isAllOnesValue()) + // If a) we don't have any length information, or b) we know this will + // fit then just lower to a plain strcpy. Otherwise we'll keep our + // strcpy_chk call which may fail at runtime if the size is too long. + // TODO: It might be nice to get a maximum length out of the possible + // string lengths for varying. + if (SizeCI->isAllOnesValue() || + SizeCI->getZExtValue() >= GetStringLength(CI->getOperand(2))) return EmitStrCpy(CI->getOperand(1), CI->getOperand(2), B); return 0; diff --git a/test/Transforms/InstCombine/objsize.ll b/test/Transforms/InstCombine/objsize.ll new file mode 100644 index 00000000000..13bb487c13e --- /dev/null +++ b/test/Transforms/InstCombine/objsize.ll @@ -0,0 +1,30 @@ +; RUN: opt < %s -instcombine -S | FileCheck %s +@a = common 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 { +; CHECK: @foo +; CHECK-NEXT: ret i32 60 + %1 = call i32 @llvm.objectsize.i32(i8* getelementptr inbounds ([60 x i8]* @a, i32 0, i32 0), i1 false) + ret i32 %1 +} + +define i8* @bar() nounwind { +; CHECK: @bar +entry: + %retval = alloca i8* + %0 = call i32 @llvm.objectsize.i32(i8* getelementptr inbounds ([60 x i8]* @a, i32 0, i32 0), i1 false) + %cmp = icmp ne i32 %0, -1 +; CHECK: br i1 true + br i1 %cmp, label %cond.true, label %cond.false + +cond.true: + %1 = load i8** %retval; + ret i8* %1; + +cond.false: + %2 = load i8** %retval; + ret i8* %2; +} + +declare i32 @llvm.objectsize.i32(i8*, i1) nounwind readonly \ No newline at end of file diff --git a/test/Transforms/SimplifyLibCalls/strcpy_chk.ll b/test/Transforms/SimplifyLibCalls/strcpy_chk.ll new file mode 100644 index 00000000000..422cbd9345a --- /dev/null +++ b/test/Transforms/SimplifyLibCalls/strcpy_chk.ll @@ -0,0 +1,12 @@ +; RUN: opt < %s -simplify-libcalls -S | FileCheck %s +@a = common global [60 x i8] zeroinitializer, align 1 ; <[60 x i8]*> [#uses=1] +@.str = private constant [8 x i8] c"abcdefg\00" ; <[8 x i8]*> [#uses=1] + +define i8* @foo() nounwind { +; CHECK: @foo +; CHECK-NEXT: call i8* @strcpy + %call = call i8* @__strcpy_chk(i8* getelementptr inbounds ([60 x i8]* @a, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8]* @.str, i32 0, i32 0), i32 60) ; [#uses=1] + ret i8* %call +} + +declare i8* @__strcpy_chk(i8*, i8*, i32) nounwind -- 2.11.0