From: Eric Christopher Date: Tue, 9 Feb 2010 17:29:18 +0000 (+0000) Subject: Pull these back out, they're a little too aggressive and time X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=d2592ff69ba86d8d5da5b598429f373cb2842699;p=oota-llvm.git Pull these back out, they're a little too aggressive and time consuming for a simple optimization. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@95671 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/LinkAllPasses.h b/include/llvm/LinkAllPasses.h index 49bb713bb6e..a7e2e05b931 100644 --- a/include/llvm/LinkAllPasses.h +++ b/include/llvm/LinkAllPasses.h @@ -138,7 +138,6 @@ namespace { (void) llvm::createGEPSplitterPass(); (void) llvm::createSCCVNPass(); (void) llvm::createABCDPass(); - (void) llvm::createObjectSizeLoweringPass(); (void)new llvm::IntervalPartition(); (void)new llvm::FindUsedTypes(); diff --git a/include/llvm/Support/StandardPasses.h b/include/llvm/Support/StandardPasses.h index 6de1b3aeb73..f233c18de3b 100644 --- a/include/llvm/Support/StandardPasses.h +++ b/include/llvm/Support/StandardPasses.h @@ -118,6 +118,8 @@ namespace llvm { // Start of function pass. PM->add(createScalarReplAggregatesPass()); // Break up aggregate allocas + if (SimplifyLibCalls) + PM->add(createSimplifyLibCallsPass()); // Library Call Optimizations PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl. PM->add(createJumpThreadingPass()); // Thread jumps. PM->add(createCFGSimplificationPass()); // Merge & remove BBs @@ -126,9 +128,6 @@ namespace llvm { PM->add(createTailCallEliminationPass()); // Eliminate tail calls PM->add(createCFGSimplificationPass()); // Merge & remove BBs PM->add(createReassociatePass()); // Reassociate expressions - PM->add(createObjectSizeLoweringPass()); // Lower Intrinsic::objsize - if (SimplifyLibCalls) - PM->add(createSimplifyLibCallsPass()); // Library Call Optimizations PM->add(createLoopRotatePass()); // Rotate Loop PM->add(createLICMPass()); // Hoist loop invariants PM->add(createLoopUnswitchPass(OptimizeSize || OptimizationLevel < 3)); diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h index c24a12d0cf8..7159f86e1e1 100644 --- a/include/llvm/Transforms/Scalar.h +++ b/include/llvm/Transforms/Scalar.h @@ -336,12 +336,6 @@ FunctionPass *createSCCVNPass(); // FunctionPass *createABCDPass(); -//===----------------------------------------------------------------------===// -// -// ObjSizeLowering - Lower Intrinsic::objsize -// -FunctionPass *createObjectSizeLoweringPass(); - } // End llvm namespace #endif diff --git a/lib/Transforms/Scalar/CMakeLists.txt b/lib/Transforms/Scalar/CMakeLists.txt index fd95014d489..683c1c2fd70 100644 --- a/lib/Transforms/Scalar/CMakeLists.txt +++ b/lib/Transforms/Scalar/CMakeLists.txt @@ -18,7 +18,6 @@ add_llvm_library(LLVMScalarOpts LoopUnrollPass.cpp LoopUnswitch.cpp MemCpyOptimizer.cpp - ObjectSizeLowering.cpp Reassociate.cpp Reg2Mem.cpp SCCP.cpp diff --git a/lib/Transforms/Scalar/ObjectSizeLowering.cpp b/lib/Transforms/Scalar/ObjectSizeLowering.cpp deleted file mode 100644 index 9660e796c55..00000000000 --- a/lib/Transforms/Scalar/ObjectSizeLowering.cpp +++ /dev/null @@ -1,114 +0,0 @@ -//===-- ObjectSizeLowering.cpp - Loop unroller pass -----------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This pass lowers Intrinsic::objectsize using SCEV to determine minimum or -// maximum space left in an allocated object. -//===----------------------------------------------------------------------===// - -#define DEBUG_TYPE "objsize-lower" -#include "llvm/Constants.h" -#include "llvm/Module.h" -#include "llvm/Value.h" -#include "llvm/Target/TargetData.h" -#include "llvm/IntrinsicInst.h" -#include "llvm/Transforms/Scalar.h" -#include "llvm/Analysis/ScalarEvolution.h" -#include "llvm/Analysis/ScalarEvolutionExpander.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/Debug.h" -#include "llvm/Support/raw_ostream.h" - -using namespace llvm; - -namespace { - class ObjSizeLower : public FunctionPass { - ScalarEvolution *SE; - TargetData *TD; - public: - static char ID; // Pass identification, replacement for typeid - ObjSizeLower() : FunctionPass(&ID) {} - - bool runOnFunction(Function &F); - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.setPreservesCFG(); - AU.addRequired(); - AU.addPreserved(); - } - private: - bool LowerCall(IntrinsicInst *); - void ReplaceAllUsesWithUnknown(IntrinsicInst *, bool); - }; -} - -char ObjSizeLower::ID = 0; -static RegisterPass X("objsize-lower", - "Object Size Lowering"); - -// Public interface to the Object Size Lowering pass -FunctionPass *llvm::createObjectSizeLoweringPass() { - return new ObjSizeLower(); -} - -/// runOnFunction - Top level algorithm - Loop over each object size intrinsic -/// and use Scalar Evolutions to get the maximum or minimum size left in the -/// allocated object at any point. -bool ObjSizeLower::runOnFunction(Function &F) { - SE = &getAnalysis(); - TD = getAnalysisIfAvailable(); - - // We really need TargetData for size calculations. - if (!TD) return false; - - bool Changed = false; - for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { - for (BasicBlock::iterator I = BB->begin(), L = BB->end(); I != L; ) { - CallInst *CI = dyn_cast(I++); - if (!CI) continue; - - // The only thing we care about are Intrinsic::objectsize calls - IntrinsicInst *II = dyn_cast(CI); - if (!II || II->getIntrinsicID() != Intrinsic::objectsize) continue; - - Changed |= LowerCall(II); - } - } - return Changed; -} - -// Unknown for llvm.objsize is -1 for maximum size, and 0 for minimum size. -void ObjSizeLower::ReplaceAllUsesWithUnknown(IntrinsicInst *II, bool min) { - const Type *ReturnTy = II->getCalledFunction()->getReturnType(); - II->replaceAllUsesWith(ConstantInt::get(ReturnTy, min ? 0 : -1ULL)); - II->eraseFromParent(); -} - -bool ObjSizeLower::LowerCall(IntrinsicInst *II) { - ConstantInt *CI = cast(II->getOperand(2)); - bool minimum = (CI->getZExtValue() == 1); - Value *Op = II->getOperand(1); - const Type *ReturnTy = II->getCalledFunction()->getReturnType(); - - // Grab the SCEV for our access. - const SCEV *thisEV = SE->getSCEV(Op); - - if (const SCEVUnknown *SU = dyn_cast(thisEV)) { - if (GlobalVariable *GV = dyn_cast(SU->getValue())) { - if (GV->hasDefinitiveInitializer()) { - Constant *C = GV->getInitializer(); - size_t globalSize = TD->getTypeAllocSize(C->getType()); - II->replaceAllUsesWith(ConstantInt::get(ReturnTy, globalSize)); - II->eraseFromParent(); - return true; - } - } - } - - ReplaceAllUsesWithUnknown(II, minimum); - return true; -} diff --git a/test/Transforms/InstCombine/objsize.ll b/test/Transforms/InstCombine/objsize.ll new file mode 100644 index 00000000000..41d071517df --- /dev/null +++ b/test/Transforms/InstCombine/objsize.ll @@ -0,0 +1,52 @@ +; Test a pile of objectsize bounds checking. +; RUN: opt < %s -instcombine -S | FileCheck %s +; XFAIL: * +; 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" + +@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 { +; 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; +} + +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 { +; CHECK: @baz +; CHECK-NEXT: llvm.objectsize.i32 + %1 = tail call i32 @llvm.objectsize.i32(i8* getelementptr inbounds ([0 x i8]* @window, i32 0, i32 0), i1 false) + %2 = icmp eq i32 %1, -1 + ret i1 %2 +} + +declare i32 @llvm.objectsize.i32(i8*, i1) nounwind readonly \ No newline at end of file diff --git a/test/Transforms/ObjSizeLower/objsize.ll b/test/Transforms/ObjSizeLower/objsize.ll deleted file mode 100644 index bcc1f835df5..00000000000 --- a/test/Transforms/ObjSizeLower/objsize.ll +++ /dev/null @@ -1,52 +0,0 @@ -; Test a pile of objectsize bounds checking. -; RUN: opt < %s -objsize-lower -S | FileCheck %s -; 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" - -@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 { -; 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) -; CHECK: %cmp = icmp ne i32 60, -1 - %cmp = icmp ne i32 %0, -1 - 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; -} - -; FIXME: This should return 0. -define i32 @f() nounwind { -; CHECK: @f -; CHECK-NEXT: ret i32 -1 - %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 { -; CHECK: @baz -; CHECK-NEXT: icmp eq i32 -1, -1 - %1 = tail call i32 @llvm.objectsize.i32(i8* getelementptr inbounds ([0 x i8]* @window, i32 0, i32 0), i1 false) - %2 = icmp eq i32 %1, -1 - ret i1 %2 -} - -declare i32 @llvm.objectsize.i32(i8*, i1) nounwind readonly \ No newline at end of file