Verify prefetch arguments, PR2576.

[oota-llvm.git] / lib / VMCore / Value.cpp

diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp
index a61a1a02472765c08af97da068790177a5542176..0976a7459915ad8c4822fcb995e65594b0e4e50e 100644 (file)
--- a/lib/VMCore/Value.cpp
+++ b/lib/VMCore/Value.cpp
@@ -12,6 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Constant.h"
+#include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/InstrTypes.h"
 #include "llvm/Instructions.h"
@@ -32,14 +33,14 @@ static inline const Type *checkType(const Type *Ty) {
 }
 
 Value::Value(const Type *ty, unsigned scid)
-  : SubclassID(scid), SubclassData(0), Ty(checkType(ty)),
+  : SubclassID(scid), SubclassData(0), VTy(checkType(ty)),
     UseList(0), Name(0) {
   if (isa<CallInst>(this) || isa<InvokeInst>(this))
-    assert((Ty->isFirstClassType() || Ty == Type::VoidTy ||
-            isa<OpaqueType>(ty) || Ty->getTypeID() == Type::StructTyID) &&
+    assert((VTy->isFirstClassType() || VTy == Type::VoidTy ||
+            isa<OpaqueType>(ty) || VTy->getTypeID() == Type::StructTyID) &&
            "invalid CallInst  type!");
   else if (!isa<Constant>(this) && !isa<BasicBlock>(this))
-    assert((Ty->isFirstClassType() || Ty == Type::VoidTy ||
+    assert((VTy->isFirstClassType() || VTy == Type::VoidTy ||
            isa<OpaqueType>(ty)) &&
            "Cannot create non-first-class values except for constants!");
 }
@@ -53,7 +54,7 @@ Value::~Value() {
   // a <badref>
   //
   if (!use_empty()) {
-    DOUT << "While deleting: " << *Ty << " %" << getNameStr() << "\n";
+    DOUT << "While deleting: " << *VTy << " %" << getNameStr() << "\n";
     for (use_iterator I = use_begin(), E = use_end(); I != E; ++I)
       DOUT << "Use still stuck around after Def is destroyed:"
            << **I << "\n";
@@ -92,6 +93,17 @@ bool Value::hasNUsesOrMore(unsigned N) const {
   return true;
 }
 
+/// isUsedInBasicBlock - Return true if this value is used in the specified
+/// basic block.
+bool Value::isUsedInBasicBlock(const BasicBlock *BB) const {
+  for (use_const_iterator I = use_begin(), E = use_end(); I != E; ++I) {
+    const Instruction *User = dyn_cast<Instruction>(*I);
+    if (User && User->getParent() == BB)
+      return true;
+  }
+  return false;
+}
+
 
 /// getNumUses - This method computes the number of uses of this Value.  This
 /// is a linear time operation.  Use hasOneUse or hasNUses to check for specific
@@ -136,6 +148,13 @@ unsigned Value::getNameLen() const {
   return Name ? Name->getKeyLength() : 0;
 }
 
+/// isName - Return true if this value has the name specified by the provided
+/// nul terminated string.
+bool Value::isName(const char *N) const {
+  unsigned InLen = strlen(N);
+  return InLen == getNameLen() && memcmp(getNameStart(), N, InLen) == 0;
+}
+
 
 std::string Value::getNameStr() const {
   if (Name == 0) return "";
@@ -245,7 +264,7 @@ void Value::takeName(Value *V) {
   // Get V's ST, this should always succed, because V has a name.
   ValueSymbolTable *VST;
   bool Failure = getSymTab(V, VST);
-  assert(!Failure && "V has a name, so it should have a ST!");
+  assert(!Failure && "V has a name, so it should have a ST!"); Failure=Failure;
   
   // If these values are both in the same symtab, we can do this very fast.
   // This works even if both values have no symtab yet.
@@ -302,6 +321,43 @@ void Value::replaceAllUsesWith(Value *New) {
   uncheckedReplaceAllUsesWith(New);
 }
 
+Value *Value::stripPointerCasts() {
+  if (!isa<PointerType>(getType()))
+    return this;
+
+  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(this)) {
+    if (CE->getOpcode() == Instruction::BitCast) {
+      return CE->getOperand(0)->stripPointerCasts();
+    } else if (CE->getOpcode() == Instruction::GetElementPtr) {
+      for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i)
+        if (!CE->getOperand(i)->isNullValue())
+          return this;
+      return CE->getOperand(0)->stripPointerCasts();
+    }
+  } else if (BitCastInst *CI = dyn_cast<BitCastInst>(this)) {
+    return CI->getOperand(0)->stripPointerCasts();
+  } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(this)) {
+    if (GEP->hasAllZeroIndices())
+      return GEP->getOperand(0)->stripPointerCasts();
+  }
+  return this;
+}
+
+Value *Value::getUnderlyingObject() {
+  if (!isa<PointerType>(getType()))
+    return this;
+
+  if (Instruction *I = dyn_cast<Instruction>(this)) {
+    if (isa<BitCastInst>(I) || isa<GetElementPtrInst>(I))
+      return I->getOperand(0)->getUnderlyingObject();
+  } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(this)) {
+    if (CE->getOpcode() == Instruction::BitCast ||
+        CE->getOpcode() == Instruction::GetElementPtr)
+      return CE->getOperand(0)->getUnderlyingObject();
+  }
+  return this;
+}
+
 //===----------------------------------------------------------------------===//
 //                                 User Class
 //===----------------------------------------------------------------------===//
@@ -324,3 +380,21 @@ void User::replaceUsesOfWith(Value *From, Value *To) {
     }
 }
 
+void *User::operator new(size_t s, unsigned Us) {
+  void *Storage = ::operator new(s + sizeof(Use) * Us);
+  Use *Start = static_cast<Use*>(Storage);
+  Use *End = Start + Us;
+  User *Obj = reinterpret_cast<User*>(End);
+  Obj->OperandList = Start;
+  Obj->NumOperands = Us;
+  Use::initTags(Start, End);
+  return Obj;
+}
+
+void User::operator delete(void *Usr) {
+  User *Start = static_cast<User*>(Usr);
+  Use *Storage = static_cast<Use*>(Usr) - Start->NumOperands;
+  ::operator delete(Storage == Start->OperandList
+                    ? Storage
+                    : Usr);
+}