//
// 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 is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
//===----------------------------------------------------------------------===//
#include "llvm/Constant.h"
+#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/InstrTypes.h"
+#include "llvm/Instructions.h"
#include "llvm/Module.h"
#include "llvm/ValueSymbolTable.h"
#include "llvm/Support/Debug.h"
}
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<Constant>(this) && !isa<BasicBlock>(this))
- assert((Ty->isFirstClassType() || Ty == Type::VoidTy ||
+ if (isa<CallInst>(this) || isa<InvokeInst>(this))
+ 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((VTy->isFirstClassType() || VTy == Type::VoidTy ||
isa<OpaqueType>(ty)) &&
"Cannot create non-first-class values except for constants!");
}
// still being referenced. The value in question should be printed as
// a <badref>
//
- if (use_begin() != use_end()) {
- DOUT << "While deleting: " << *Ty << " %" << Name << "\n";
+ if (!use_empty()) {
+ cerr << "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:"
+ cerr << "Use still stuck around after Def is destroyed:"
<< **I << "\n";
}
#endif
- assert(use_begin() == use_end() && "Uses remain when a value is destroyed!");
+ assert(use_empty() && "Uses remain when a value is destroyed!");
+ // If this value is named, destroy the name. This should not be in a symtab
+ // at this point.
+ if (Name)
+ Name->Destroy();
+
// There should be no uses of this object anymore, remove it.
LeakDetector::removeGarbageObject(this);
}
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
return false;
}
+/// getNameStart - Return a pointer to a null terminated string for this name.
+/// Note that names can have null characters within the string as well as at
+/// their end. This always returns a non-null pointer.
+const char *Value::getNameStart() const {
+ if (Name == 0) return "";
+ return Name->getKeyData();
+}
+
+/// getNameLen - Return the length of the string, correctly handling nul
+/// characters embedded into them.
+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 "";
return std::string(Name->getKeyData(),
// 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.
while (!use_empty()) {
Use &U = *UseList;
// Must handle Constants specially, we cannot call replaceUsesOfWith on a
- // constant!
+ // constant because they are uniqued.
if (Constant *C = dyn_cast<Constant>(U.getUser())) {
- if (!isa<GlobalValue>(C))
+ if (!isa<GlobalValue>(C)) {
C->replaceUsesOfWithOnConstant(this, New, &U);
- else
- U.set(New);
- } else {
- U.set(New);
+ continue;
+ }
}
+
+ U.set(New);
}
}
uncheckedReplaceAllUsesWith(New);
}
+Value *Value::stripPointerCasts() {
+ if (!isa<PointerType>(getType()))
+ return this;
+ Value *V = this;
+ do {
+ if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
+ if (CE->getOpcode() == Instruction::GetElementPtr) {
+ for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i)
+ if (!CE->getOperand(i)->isNullValue())
+ return V;
+ V = CE->getOperand(0);
+ } else if (CE->getOpcode() == Instruction::BitCast) {
+ V = CE->getOperand(0);
+ } else {
+ return V;
+ }
+ } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(V)) {
+ if (!GEP->hasAllZeroIndices())
+ return V;
+ V = GEP->getOperand(0);
+ } else if (BitCastInst *CI = dyn_cast<BitCastInst>(V)) {
+ V = CI->getOperand(0);
+ } else {
+ return V;
+ }
+ assert(isa<PointerType>(V->getType()) && "Unexpected operand type!");
+ } while (1);
+}
+
+Value *Value::getUnderlyingObject() {
+ if (!isa<PointerType>(getType()))
+ return this;
+ Value *V = this;
+ do {
+ if (Instruction *I = dyn_cast<Instruction>(V)) {
+ if (!isa<BitCastInst>(I) && !isa<GetElementPtrInst>(I))
+ return V;
+ V = I->getOperand(0);
+ } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
+ if (CE->getOpcode() != Instruction::BitCast &&
+ CE->getOpcode() != Instruction::GetElementPtr)
+ return V;
+ V = CE->getOperand(0);
+ } else {
+ return V;
+ }
+ assert(isa<PointerType>(V->getType()) && "Unexpected operand type!");
+ } while (1);
+}
+
+/// DoPHITranslation - If this value is a PHI node with CurBB as its parent,
+/// return the value in the PHI node corresponding to PredBB. If not, return
+/// ourself. This is useful if you want to know the value something has in a
+/// predecessor block.
+Value *Value::DoPHITranslation(const BasicBlock *CurBB,
+ const BasicBlock *PredBB) {
+ PHINode *PN = dyn_cast<PHINode>(this);
+ if (PN && PN->getParent() == CurBB)
+ return PN->getIncomingValueForBlock(PredBB);
+ return this;
+}
+
+
//===----------------------------------------------------------------------===//
// User Class
//===----------------------------------------------------------------------===//
void User::replaceUsesOfWith(Value *From, Value *To) {
if (From == To) return; // Duh what?
- assert(!isa<Constant>(this) || isa<GlobalValue>(this) &&
+ assert((!isa<Constant>(this) || isa<GlobalValue>(this)) &&
"Cannot call User::replaceUsesofWith on a constant!");
for (unsigned i = 0, E = getNumOperands(); i != E; ++i)
}
}
+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);
+}