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 49bb713bb6e39b1f29c6c8057f803b1e4188da48..a7e2e05b93122c08be9d35cbe8d453040cfc28b2 100644 (file)
--- 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 6de1b3aeb73d08264b85b08174c62a7b83ef5e39..f233c18de3ba152a744af5d3cf1a0449cd57beec 100644 (file)
--- 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 c24a12d0cf84f5242fe6bc3ec8aa5da712f92570..7159f86e1e16a920a486825d16e0b0a2fddd725e 100644 (file)
--- 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 fd95014d4898a9f557c529c18134d2bdb1504266..683c1c2fd7089c8ef4ac82d6842a67956db233d7 100644 (file)
--- 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 (file)
index 9660e79..0000000
--- 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<ScalarEvolution>();
-      AU.addPreserved<ScalarEvolution>();
-    }
-  private:
-    bool LowerCall(IntrinsicInst *);
-    void ReplaceAllUsesWithUnknown(IntrinsicInst *, bool);
-  };
-}
-
-char ObjSizeLower::ID = 0;
-static RegisterPass<ObjSizeLower> 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<ScalarEvolution>();
-  TD = getAnalysisIfAvailable<TargetData>();
-  
-  // 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<CallInst>(I++);
-      if (!CI) continue;
-
-      // The only thing we care about are Intrinsic::objectsize calls
-      IntrinsicInst *II = dyn_cast<IntrinsicInst>(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<ConstantInt>(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<SCEVUnknown>(thisEV)) {
-    if (GlobalVariable *GV = dyn_cast<GlobalVariable>(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 (file)
index 0000000..41d0715
--- /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 (file)
index bcc1f83..0000000
--- 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