1 //===-- Globals.cpp - Implement the Global object classes -----------------===//
3 // The LLVM Compiler Infrastructure
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.
8 //===----------------------------------------------------------------------===//
10 // This file implements the GlobalValue & GlobalVariable classes for the VMCore
13 //===----------------------------------------------------------------------===//
15 #include "llvm/DerivedTypes.h"
16 #include "llvm/GlobalVariable.h"
17 #include "llvm/Module.h"
18 #include "llvm/SymbolTable.h"
19 #include "Support/LeakDetector.h"
22 //===----------------------------------------------------------------------===//
24 //===----------------------------------------------------------------------===//
26 /// This could be named "SafeToDestroyGlobalValue". It just makes sure that
27 /// there are no non-constant uses of this GlobalValue. If there aren't then
28 /// this and the transitive closure of the constants can be deleted. See the
29 /// destructor for details.
30 static bool removeDeadConstantUsers(Constant* C) {
31 if (isa<GlobalValue>(C)) return false; // Cannot remove this
33 while (!C->use_empty())
34 if (Constant *User = dyn_cast<Constant>(C->use_back())) {
35 if (!removeDeadConstantUsers(User))
36 return false; // Constant wasn't dead
38 return false; // Non-constant usage;
45 /// removeDeadConstantUsers - If there are any dead constant users dangling
46 /// off of this global value, remove them. This method is useful for clients
47 /// that want to check to see if a global is unused, but don't want to deal
48 /// with potentially dead constants hanging off of the globals.
50 /// This function returns true if the global value is now dead. If all
51 /// users of this global are not dead, this method may return false and
52 /// leave some of them around.
53 void GlobalValue::removeDeadConstantUsers() {
55 if (Constant* User = dyn_cast<Constant>(use_back())) {
56 if (!::removeDeadConstantUsers(User))
57 return; // Constant wasn't dead
59 return; // Non-constant usage;
64 /// Override destroyConstant to make sure it doesn't get called on
65 /// GlobalValue's because they shouldn't be treated like other constants.
66 void GlobalValue::destroyConstant() {
67 assert(0 && "You can't GV->destroyConstant()!");
70 //===----------------------------------------------------------------------===//
71 // GlobalVariable Implementation
72 //===----------------------------------------------------------------------===//
74 GlobalVariable::GlobalVariable(const Type *Ty, bool constant, LinkageTypes Link,
75 Constant *Initializer,
76 const std::string &Name, Module *ParentModule)
77 : GlobalValue(PointerType::get(Ty), Value::GlobalVariableVal, Link, Name),
78 isConstantGlobal(constant) {
79 if (Initializer) Operands.push_back(Use((Value*)Initializer, this));
81 LeakDetector::addGarbageObject(this);
84 ParentModule->getGlobalList().push_back(this);
87 void GlobalVariable::setParent(Module *parent) {
89 LeakDetector::addGarbageObject(this);
92 LeakDetector::removeGarbageObject(this);
95 // Specialize setName to take care of symbol table majik
96 void GlobalVariable::setName(const std::string &name, SymbolTable *ST) {
98 assert((ST == 0 || (!getParent() || ST == &getParent()->getSymbolTable())) &&
99 "Invalid symtab argument!");
100 if ((P = getParent()) && hasName()) P->getSymbolTable().remove(this);
101 Value::setName(name);
102 if (P && hasName()) P->getSymbolTable().insert(this);
105 void GlobalVariable::replaceUsesOfWithOnConstant(Value *From, Value *To,
106 bool DisableChecking )
108 // If you call this, then you better know this GVar has a constant
109 // initializer worth replacing. Enforce that here.
110 assert(getNumOperands() == 1 &&
111 "Attempt to replace uses of Constants on a GVar with no initializer");
113 // And, since you know it has an initializer, the From value better be
114 // the initializer :)
115 assert(getOperand(0) == From &&
116 "Attempt to replace wrong constant initializer in GVar");
118 // And, you better have a constant for the replacement value
119 assert(isa<Constant>(To) &&
120 "Attempt to replace GVar initializer with non-constant");
122 // Okay, preconditions out of the way, replace the constant initializer.
123 this->setOperand(0, cast<Constant>(To));