Fix previous patch

[oota-llvm.git] / lib / Transforms / LevelRaise.cpp

diff --git a/lib/Transforms/LevelRaise.cpp b/lib/Transforms/LevelRaise.cpp
index b02106a21945047fda9f46aed0f17152576ed042..aeb836d4b7e4fbf9aba15e69d522227badaa413f 100644 (file)
--- a/lib/Transforms/LevelRaise.cpp
+++ b/lib/Transforms/LevelRaise.cpp
@@ -1,4 +1,11 @@
 //===- LevelRaise.cpp - Code to change LLVM to higher level ---------------===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
 //
 // This file implements the 'raising' part of the LevelChange API.  This is
 // useful because, in general, it makes the LLVM code terser and easier to
@@ -12,15 +19,13 @@
 #include "llvm/iOther.h"
 #include "llvm/iMemory.h"
 #include "llvm/Pass.h"
-#include "llvm/ConstantHandling.h"
-#include "llvm/Analysis/Expressions.h"
-#include "llvm/Analysis/Verifier.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "Support/CommandLine.h"
 #include "Support/Debug.h"
 #include "Support/Statistic.h"
 #include "Support/STLExtras.h"
 #include <algorithm>
+using namespace llvm;
 
 // StartInst - This enables the -raise-start-inst=foo option to cause the level
 // raising pass to start at instruction "foo", which is immensely useful for
@@ -48,7 +53,6 @@ NumDCEorCP("raise", "Number of insts DCEd or constprop'd");
 static Statistic<>
 NumVarargCallChanges("raise", "Number of vararg call peepholes");
 
-
 #define PRINT_PEEPHOLE(ID, NUM, I)            \
   DEBUG(std::cerr << "Inst P/H " << ID << "[" << NUM << "] " << I)
 
@@ -79,12 +83,12 @@ namespace {
   RegisterOpt<RPR> X("raise", "Raise Pointer References");
 }
 
-Pass *createRaisePointerReferencesPass() {
+
+Pass *llvm::createRaisePointerReferencesPass() {
   return new RPR();
 }
 
 
-
 // isReinterpretingCast - Return true if the cast instruction specified will
 // cause the operand to be "reinterpreted".  A value is reinterpreted if the
 // cast instruction would cause the underlying bits to change.
@@ -287,8 +291,6 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) {
                           << BB->getParent());
         }
 
-        DEBUG(assert(verifyFunction(*BB->getParent()) == false &&
-                     "Function broken!"));
         BI = BB->begin();  // Rescan basic block.  BI might be invalidated.
         ++NumExprTreesConv;
         return true;
@@ -312,8 +314,6 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) {
         PRINT_PEEPHOLE1("CAST-DEST-EXPR-CONV:out", Src);
         DEBUG(std::cerr << "DONE CONVERTING EXPR TYPE: \n\n" << BB->getParent());
 
-        DEBUG(assert(verifyFunction(*BB->getParent()) == false &&
-                     "Function broken!"));
         BI = BB->begin();  // Rescan basic block.  BI might be invalidated.
         ++NumExprTreesConv;
         return true;
@@ -369,22 +369,23 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) {
 
           // Build the index vector, full of all zeros
           std::vector<Value*> Indices;
-          Indices.push_back(ConstantSInt::get(Type::LongTy, 0));
+
+          Indices.push_back(Constant::getNullValue(Type::UIntTy));
           while (CurCTy && !isa<PointerType>(CurCTy)) {
             if (const StructType *CurSTy = dyn_cast<StructType>(CurCTy)) {
               // Check for a zero element struct type... if we have one, bail.
-              if (CurSTy->getElementTypes().size() == 0) break;
+              if (CurSTy->getNumElements() == 0) break;
             
               // Grab the first element of the struct type, which must lie at
               // offset zero in the struct.
               //
-              ElTy = CurSTy->getElementTypes()[0];
+              ElTy = CurSTy->getElementType(0);
             } else {
               ElTy = cast<ArrayType>(CurCTy)->getElementType();
             }
 
             // Insert a zero to index through this type...
-            Indices.push_back(Constant::getNullValue(CurCTy->getIndexType()));
+            Indices.push_back(Constant::getNullValue(Type::UIntTy));
 
             // Did we find what we're looking for?
             if (ElTy->isLosslesslyConvertibleTo(DestPointedTy)) break;
@@ -535,6 +536,10 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) {
         NewCast = new CastInst(CI->getCalledValue(), NewPFunTy,
                                CI->getCalledValue()->getName()+"_c",CI);
 
+      // Strip off unneeded CPR's.
+      if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(NewCast))
+        NewCast = CPR->getValue();
+
       // Create a new call instruction...
       CallInst *NewCall = new CallInst(NewCast,
                            std::vector<Value*>(CI->op_begin()+1, CI->op_end()));
@@ -610,3 +615,4 @@ bool RPR::runOnFunction(Function &F) {
 
   return Changed;
 }
+