//
// 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"
#include "llvm/Support/LeakDetector.h"
-#include "llvm/Constants.h"
-#include "llvm/InlineAsm.h"
-#include "llvm/Instructions.h"
-#include "llvm/IntrinsicInst.h"
-#include "llvm/InstrTypes.h"
#include <algorithm>
using namespace llvm;
}
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!");
}
-Value::~Value()
-{
- switch(SubclassID)
- {
- case ArgumentVal:
- Argument::destroyThis(cast<Argument>(this));
- break;
- case BasicBlockVal:
- BasicBlock::destroyThis(cast<BasicBlock>(this));
- break;
- case FunctionVal:
- Function::destroyThis(cast<Function>(this));
- break;
- case GlobalAliasVal:
- GlobalAlias::destroyThis(cast<GlobalAlias>(this));
- break;
- case GlobalVariableVal:
- GlobalVariable::destroyThis(cast<GlobalVariable>(this));
- break;
- case UndefValueVal:
- UndefValue::destroyThis(cast<UndefValue>(this));
- break;
- case ConstantExprVal:
- {
- ConstantExpr* CE = dyn_cast<ConstantExpr>(this);
- if(CE->getOpcode() == Instruction::GetElementPtr)
- {
- GetElementPtrConstantExpr* GECE =
- dyn_cast<GetElementPtrConstantExpr>(CE);
- GetElementPtrConstantExpr::destroyThis(GECE);
- }
- else if(CE->getOpcode() == Instruction::ExtractElement)
- {
- ExtractElementConstantExpr* EECE =
- dyn_cast<ExtractElementConstantExpr>(CE);
- ExtractElementConstantExpr::destroyThis(EECE);
- }
- else if(CE->getOpcode() == Instruction::InsertElement)
- {
- InsertElementConstantExpr* IECE =
- dyn_cast<InsertElementConstantExpr>(CE);
- InsertElementConstantExpr::destroyThis(IECE);
- }
- else if(CE->getOpcode() == Instruction::Select)
- {
- SelectConstantExpr* SCE = dyn_cast<SelectConstantExpr>(CE);
- SelectConstantExpr::destroyThis(SCE);
- }
- else if(CE->getOpcode() == Instruction::ShuffleVector)
- {
- ShuffleVectorConstantExpr* SVCE =
- dyn_cast<ShuffleVectorConstantExpr>(CE);
- ShuffleVectorConstantExpr::destroyThis(SVCE);
- }
- else if(BinaryConstantExpr* BCE = dyn_cast<BinaryConstantExpr>(this))
- BinaryConstantExpr::destroyThis(BCE);
- else if(UnaryConstantExpr* UCE = dyn_cast<UnaryConstantExpr>(this))
- UnaryConstantExpr::destroyThis(UCE);
- else if(CompareConstantExpr* CCE = dyn_cast<CompareConstantExpr>(this))
- CompareConstantExpr::destroyThis(CCE);
- else
- assert(0 && "Unknown ConstantExpr-inherited class in ~Value.");
- }
- break;
- case ConstantAggregateZeroVal:
- ConstantAggregateZero::destroyThis(cast<ConstantAggregateZero>(this));
- break;
- case ConstantIntVal:
- ConstantInt::destroyThis(cast<ConstantInt>(this));
- break;
- case ConstantFPVal:
- ConstantFP::destroyThis(cast<ConstantFP>(this));
- break;
- case ConstantArrayVal:
- ConstantArray::destroyThis(cast<ConstantArray>(this));
- break;
- case ConstantStructVal:
- ConstantStruct::destroyThis(cast<ConstantStruct>(this));
- break;
- case ConstantVectorVal:
- ConstantVector::destroyThis(cast<ConstantVector>(this));
- break;
- case ConstantPointerNullVal:
- ConstantPointerNull::destroyThis(cast<ConstantPointerNull>(this));
- break;
- case InlineAsmVal:
- InlineAsm::destroyThis(cast<InlineAsm>(this));
- break;
-
- default:
- if (BinaryOperator *BO = dyn_cast<BinaryOperator>(this))
- BinaryOperator::destroyThis(BO);
- else if (CallInst *CI = dyn_cast<CallInst>(this))
- CallInst::destroyThis(CI);
- else if (CmpInst *CI = dyn_cast<CmpInst>(this))
- {
- if (FCmpInst *FCI = dyn_cast<FCmpInst>(this))
- FCmpInst::destroyThis(FCI);
- else if (ICmpInst *ICI = dyn_cast<ICmpInst>(this))
- ICmpInst::destroyThis(ICI);
- else
- assert(0 && "Unknown CmpInst-inherited class in ~Value.");
- }
- else if (ExtractElementInst *EEI = dyn_cast<ExtractElementInst>(this))
- ExtractElementInst::destroyThis(EEI);
- else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(this))
- GetElementPtrInst::destroyThis(GEP);
- else if (InsertElementInst* IE = dyn_cast<InsertElementInst>(this))
- InsertElementInst::destroyThis(IE);
- else if (PHINode *PN = dyn_cast<PHINode>(this))
- PHINode::destroyThis(PN);
- else if (SelectInst *SI = dyn_cast<SelectInst>(this))
- SelectInst::destroyThis(SI);
- else if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(this))
- ShuffleVectorInst::destroyThis(SVI);
- else if (StoreInst *SI = dyn_cast<StoreInst>(this))
- StoreInst::destroyThis(SI);
- else if (TerminatorInst *TI = dyn_cast<TerminatorInst>(this))
- {
- if (BranchInst* BI = dyn_cast<BranchInst>(this))
- BranchInst::destroyThis(BI);
- else if (InvokeInst* II = dyn_cast<InvokeInst>(this))
- InvokeInst::destroyThis(II);
- else if (ReturnInst* RI = dyn_cast<ReturnInst>(this))
- ReturnInst::destroyThis(RI);
- else if (SwitchInst *SI = dyn_cast<SwitchInst>(this))
- SwitchInst::destroyThis(SI);
- else if (UnreachableInst *UI = dyn_cast<UnreachableInst>(this))
- UnreachableInst::destroyThis(UI);
- else if (UnwindInst *UI = dyn_cast<UnwindInst>(this))
- UnwindInst::destroyThis(UI);
- else
- assert(0 && "Unknown TerminatorInst-inherited class in ~Value.");
- }
- else if(UnaryInstruction* UI = dyn_cast<UnaryInstruction>(this))
- {
- if(AllocationInst* AI = dyn_cast<AllocationInst>(this))
- {
- if(AllocaInst* AI = dyn_cast<AllocaInst>(this))
- AllocaInst::destroyThis(AI);
- else if(MallocInst* MI = dyn_cast<MallocInst>(this))
- MallocInst::destroyThis(MI);
- else
- assert(0 && "Unknown AllocationInst-inherited class in ~Value.");
- } else if(CastInst* CI = dyn_cast<CastInst>(this)) {
- if(BitCastInst* BCI = dyn_cast<BitCastInst>(CI))
- BitCastInst::destroyThis(BCI);
- else if(FPExtInst* FPEI = dyn_cast<FPExtInst>(CI))
- FPExtInst::destroyThis(FPEI);
- else if(FPToSIInst* FPSII = dyn_cast<FPToSIInst>(CI))
- FPToSIInst::destroyThis(FPSII);
- else if(FPToUIInst* FPUII = dyn_cast<FPToUIInst>(CI))
- FPToUIInst::destroyThis(FPUII);
- else if(FPTruncInst* FPTI = dyn_cast<FPTruncInst>(CI))
- FPTruncInst::destroyThis(FPTI);
- else if(IntToPtrInst* I2PI = dyn_cast<IntToPtrInst>(CI))
- IntToPtrInst::destroyThis(I2PI);
- else if(PtrToIntInst* P2II = dyn_cast<PtrToIntInst>(CI))
- PtrToIntInst::destroyThis(P2II);
- else if(SExtInst* SEI = dyn_cast<SExtInst>(CI))
- SExtInst::destroyThis(SEI);
- else if(SIToFPInst* SIFPI = dyn_cast<SIToFPInst>(CI))
- SIToFPInst::destroyThis(SIFPI);
- else if(TruncInst* TI = dyn_cast<TruncInst>(CI))
- TruncInst::destroyThis(TI);
- else if(UIToFPInst* UIFPI = dyn_cast<UIToFPInst>(CI))
- UIToFPInst::destroyThis(UIFPI);
- else if(ZExtInst* ZEI = dyn_cast<ZExtInst>(CI))
- ZExtInst::destroyThis(ZEI);
- else
- assert(0 && "Unknown CastInst-inherited class in ~Value.");
- }
- else if(FreeInst* FI = dyn_cast<FreeInst>(this))
- FreeInst::destroyThis(FI);
- else if(LoadInst* LI = dyn_cast<LoadInst>(this))
- LoadInst::destroyThis(LI);
- else if(VAArgInst* VAI = dyn_cast<VAArgInst>(this))
- VAArgInst::destroyThis(VAI);
- else
- assert(0 && "Unknown UnaryInstruction-inherited class in ~Value.");
- }
- else if (DummyInst *DI = dyn_cast<DummyInst>(this))
- DummyInst::destroyThis(DI);
- else
- assert(0 && "Unknown Instruction-inherited class in ~Value.");
- break;
- }
-}
-
-void Value::destroyThis(Value*v)
-{
+Value::~Value() {
#ifndef NDEBUG // Only in -g mode...
// Check to make sure that there are no uses of this value that are still
// around when the value is destroyed. If there are, then we have a dangling
// still being referenced. The value in question should be printed as
// a <badref>
//
- if (!v->use_empty()) {
- DOUT << "While deleting: " << *v->Ty << " %" << v->Name << "\n";
- for (use_iterator I = v->use_begin(), E = v->use_end(); I != E; ++I)
+ if (!use_empty()) {
+ 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";
}
#endif
- assert(v->use_empty() && "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 (v->Name)
- v->Name->Destroy();
+ if (Name)
+ Name->Destroy();
// There should be no uses of this object anymore, remove it.
- LeakDetector::removeGarbageObject(v);
+ LeakDetector::removeGarbageObject(this);
}
/// hasNUses - Return true if this Value has exactly N users.
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 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 "";
// 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.
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
//===----------------------------------------------------------------------===//
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);
+}
projects / oota-llvm.git / blobdiff