[llvm-commits] [llvm] r95294 - in /llvm/trunk: lib/Transforms/InstCombine/InstCombineCalls.cpp test/Transforms/InstCombine/objsize.ll

[Eric Christopher]

Author: echristo
Date: Thu Feb  4 00:41:27 2010
New Revision: 95294

URL: http://llvm.org/viewvc/llvm-project?rev=95294&view=rev
Log:
Temporarily revert this since it appears to have caused a build
failure.

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=95294&r1=95293&r2=95294&view=diff

==============================================================================
--- llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp (original)
+++ llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp Thu Feb  4 00:41:27 2010
@@ -635,69 +635,43 @@
   case Intrinsic::objectsize: {
     const Type *ReturnTy = CI.getType();
     Value *Op1 = II->getOperand(1);
-    
-    // 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 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<ConstantExpr>(Op1)) {
-      // If this isn't a GEP give up.
-      if (CE->getOpcode() != Instruction::GetElementPtr) break;
+          // If this isn't a GEP give up.
+      if (CE->getOpcode() != Instruction::GetElementPtr) return 0;
 
-      // 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();
-    }
+      const PointerType *ObjTy = 
+        reinterpret_cast<const PointerType*>(CE->getOperand(0)->getType());
 
-    // 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())) {
+      if (const ArrayType *AT = dyn_cast<ArrayType>(ObjTy->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 and the number of elements.
-        if (!SAT->isSized() || !TD) break;
+        // in bytes.
+        size_t sizeofElem = SAT->getElementType()->getPrimitiveSizeInBits() / 8;
 
-        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));
+        ConstantInt *Const = 
+          cast<ConstantInt>(CE->getOperand(CE->getNumOperands() - 1));
+        size_t indx = Const->getZExtValue();
+        return ReplaceInstUsesWith(CI,
+          ConstantInt::get(ReturnTy,
+          ((numElems - indx) * sizeofElem)));
       }
     }
-    
     // 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=95294&r1=95293&r2=95294&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/InstCombine/objsize.ll (original)
+++ llvm/trunk/test/Transforms/InstCombine/objsize.ll Thu Feb  4 00:41:27 2010
@@ -1,9 +1,5 @@
-; Test a pile of objectsize bounds checking.
 ; RUN: opt < %s -instcombine -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"
-
- at a = private global [60 x i8] zeroinitializer, align 1 ; <[60 x i8]*>
+ at 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 {
@@ -31,13 +27,6 @@
   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 {
@@ -48,4 +37,5 @@
   ret i1 %2
 }
 
+
 declare i32 @llvm.objectsize.i32(i8*, i1) nounwind readonly
\ No newline at end of file