Value.cpp revision ef9b9a793949469cdaa4ab6d0173136229dcab7b
1//===-- Value.cpp - Implement the Value class -----------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Value and User classes. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/Constant.h" 15#include "llvm/DerivedTypes.h" 16#include "llvm/InstrTypes.h" 17#include "llvm/Module.h" 18#include "llvm/ValueSymbolTable.h" 19#include "llvm/Support/Debug.h" 20#include "llvm/Support/LeakDetector.h" 21#include <algorithm> 22using namespace llvm; 23 24//===----------------------------------------------------------------------===// 25// Value Class 26//===----------------------------------------------------------------------===// 27 28static inline const Type *checkType(const Type *Ty) { 29 assert(Ty && "Value defined with a null type: Error!"); 30 return Ty; 31} 32 33Value::Value(const Type *ty, unsigned scid, const std::string &name) 34 : SubclassID(scid), SubclassData(0), Ty(checkType(ty)), 35 UseList(0), Name(name) { 36 if (!isa<Constant>(this) && !isa<BasicBlock>(this)) 37 assert((Ty->isFirstClassType() || Ty == Type::VoidTy || 38 isa<OpaqueType>(ty)) && 39 "Cannot create non-first-class values except for constants!"); 40 if (ty == Type::VoidTy) 41 assert(name.empty() && "Cannot have named void values!"); 42} 43 44Value::~Value() { 45#ifndef NDEBUG // Only in -g mode... 46 // Check to make sure that there are no uses of this value that are still 47 // around when the value is destroyed. If there are, then we have a dangling 48 // reference and something is wrong. This code is here to print out what is 49 // still being referenced. The value in question should be printed as 50 // a <badref> 51 // 52 if (use_begin() != use_end()) { 53 DOUT << "While deleting: " << *Ty << " %" << Name << "\n"; 54 for (use_iterator I = use_begin(), E = use_end(); I != E; ++I) 55 DOUT << "Use still stuck around after Def is destroyed:" 56 << **I << "\n"; 57 } 58#endif 59 assert(use_begin() == use_end() && "Uses remain when a value is destroyed!"); 60 61 // There should be no uses of this object anymore, remove it. 62 LeakDetector::removeGarbageObject(this); 63} 64 65/// hasNUses - Return true if this Value has exactly N users. 66/// 67bool Value::hasNUses(unsigned N) const { 68 use_const_iterator UI = use_begin(), E = use_end(); 69 70 for (; N; --N, ++UI) 71 if (UI == E) return false; // Too few. 72 return UI == E; 73} 74 75/// hasNUsesOrMore - Return true if this value has N users or more. This is 76/// logically equivalent to getNumUses() >= N. 77/// 78bool Value::hasNUsesOrMore(unsigned N) const { 79 use_const_iterator UI = use_begin(), E = use_end(); 80 81 for (; N; --N, ++UI) 82 if (UI == E) return false; // Too few. 83 84 return true; 85} 86 87 88/// getNumUses - This method computes the number of uses of this Value. This 89/// is a linear time operation. Use hasOneUse or hasNUses to check for specific 90/// values. 91unsigned Value::getNumUses() const { 92 return (unsigned)std::distance(use_begin(), use_end()); 93} 94 95 96void Value::setName(const std::string &name) { 97 if (Name == name) return; // Name is already set. 98 99 // Get the symbol table to update for this object. 100 ValueSymbolTable *ST = 0; 101 if (Instruction *I = dyn_cast<Instruction>(this)) { 102 if (BasicBlock *P = I->getParent()) 103 if (Function *PP = P->getParent()) 104 ST = &PP->getValueSymbolTable(); 105 } else if (BasicBlock *BB = dyn_cast<BasicBlock>(this)) { 106 if (Function *P = BB->getParent()) 107 ST = &P->getValueSymbolTable(); 108 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(this)) { 109 if (Module *P = GV->getParent()) 110 ST = &P->getValueSymbolTable(); 111 } else if (Argument *A = dyn_cast<Argument>(this)) { 112 if (Function *P = A->getParent()) 113 ST = &P->getValueSymbolTable(); 114 } else { 115 assert(isa<Constant>(this) && "Unknown value type!"); 116 return; // no name is setable for this. 117 } 118 119 if (!ST) // No symbol table to update? Just do the change. 120 Name = name; 121 else if (hasName()) { 122 if (!name.empty()) { // Replacing name. 123 ST->rename(this, name); 124 } else { // Transitioning from hasName -> noname. 125 ST->remove(this); 126 Name.clear(); 127 } 128 } else { // Transitioning from noname -> hasName. 129 Name = name; 130 ST->insert(this); 131 } 132} 133 134// uncheckedReplaceAllUsesWith - This is exactly the same as replaceAllUsesWith, 135// except that it doesn't have all of the asserts. The asserts fail because we 136// are half-way done resolving types, which causes some types to exist as two 137// different Type*'s at the same time. This is a sledgehammer to work around 138// this problem. 139// 140void Value::uncheckedReplaceAllUsesWith(Value *New) { 141 while (!use_empty()) { 142 Use &U = *UseList; 143 // Must handle Constants specially, we cannot call replaceUsesOfWith on a 144 // constant! 145 if (Constant *C = dyn_cast<Constant>(U.getUser())) { 146 if (!isa<GlobalValue>(C)) 147 C->replaceUsesOfWithOnConstant(this, New, &U); 148 else 149 U.set(New); 150 } else { 151 U.set(New); 152 } 153 } 154} 155 156void Value::replaceAllUsesWith(Value *New) { 157 assert(New && "Value::replaceAllUsesWith(<null>) is invalid!"); 158 assert(New != this && "this->replaceAllUsesWith(this) is NOT valid!"); 159 assert(New->getType() == getType() && 160 "replaceAllUses of value with new value of different type!"); 161 162 uncheckedReplaceAllUsesWith(New); 163} 164 165//===----------------------------------------------------------------------===// 166// User Class 167//===----------------------------------------------------------------------===// 168 169// replaceUsesOfWith - Replaces all references to the "From" definition with 170// references to the "To" definition. 171// 172void User::replaceUsesOfWith(Value *From, Value *To) { 173 if (From == To) return; // Duh what? 174 175 assert(!isa<Constant>(this) || isa<GlobalValue>(this) && 176 "Cannot call User::replaceUsesofWith on a constant!"); 177 178 for (unsigned i = 0, E = getNumOperands(); i != E; ++i) 179 if (getOperand(i) == From) { // Is This operand is pointing to oldval? 180 // The side effects of this setOperand call include linking to 181 // "To", adding "this" to the uses list of To, and 182 // most importantly, removing "this" from the use list of "From". 183 setOperand(i, To); // Fix it now... 184 } 185} 186 187