Make iostream #inclusion explicit

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

diff --git a/lib/VMCore/Globals.cpp b/lib/VMCore/Globals.cpp
index cfecbc91ce064f2bf882553534359848ad8a0783..be6c6eb05378999350c0d785cc362fbeb63f201a 100644 (file)
--- a/lib/VMCore/Globals.cpp
+++ b/lib/VMCore/Globals.cpp
@@ -1,10 +1,10 @@
 //===-- Globals.cpp - Implement the Global object classes -----------------===//
-// 
+//
 //                     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 implements the GlobalValue & GlobalVariable classes for the VMCore
@@ -16,14 +16,14 @@
 #include "llvm/GlobalVariable.h"
 #include "llvm/Module.h"
 #include "llvm/SymbolTable.h"
-#include "Support/LeakDetector.h"
+#include "llvm/Support/LeakDetector.h"
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 //                            GlobalValue Class
 //===----------------------------------------------------------------------===//
 
-/// This could be named "SafeToDestroyGlobalValue". It just makes sure that 
+/// This could be named "SafeToDestroyGlobalValue". It just makes sure that
 /// there are no non-constant uses of this GlobalValue. If there aren't then
 /// this and the transitive closure of the constants can be deleted. See the
 /// destructor for details.
@@ -32,7 +32,7 @@ static bool removeDeadConstantUsers(Constant* C) {
 
   while (!C->use_empty())
     if (Constant *User = dyn_cast<Constant>(C->use_back())) {
-      if (!removeDeadConstantUsers(User)) 
+      if (!removeDeadConstantUsers(User))
         return false; // Constant wasn't dead
     } else {
       return false; // Non-constant usage;
@@ -47,7 +47,7 @@ static bool removeDeadConstantUsers(Constant* C) {
 /// that want to check to see if a global is unused, but don't want to deal
 /// with potentially dead constants hanging off of the globals.
 ///
-/// This function returns true if the global value is now dead.  If all 
+/// This function returns true if the global value is now dead.  If all
 /// users of this global are not dead, this method may return false and
 /// leave some of them around.
 void GlobalValue::removeDeadConstantUsers() {
@@ -61,7 +61,7 @@ void GlobalValue::removeDeadConstantUsers() {
   }
 }
 
-/// Override destroyConstant to make sure it doesn't get called on 
+/// Override destroyConstant to make sure it doesn't get called on
 /// GlobalValue's because they shouldn't be treated like other constants.
 void GlobalValue::destroyConstant() {
   assert(0 && "You can't GV->destroyConstant()!");
@@ -72,14 +72,17 @@ void GlobalValue::destroyConstant() {
 //===----------------------------------------------------------------------===//
 
 GlobalVariable::GlobalVariable(const Type *Ty, bool constant, LinkageTypes Link,
-                               Constant *Initializer,
+                               Constant *InitVal,
                                const std::string &Name, Module *ParentModule)
-  : GlobalValue(PointerType::get(Ty), Value::GlobalVariableVal, Link, Name),
+  : GlobalValue(PointerType::get(Ty), Value::GlobalVariableVal,
+                &Initializer, InitVal != 0, Link, Name),
     isConstantGlobal(constant) {
-  if (Initializer) {
-    assert(Initializer->getType() == Ty &&
+  if (InitVal) {
+    assert(InitVal->getType() == Ty &&
            "Initializer should be the same type as the GlobalVariable!");
-    Operands.push_back(Use((Value*)Initializer, this));
+    Initializer.init(InitVal, this);
+  } else {
+    Initializer.init(0, this);
   }
 
   LeakDetector::addGarbageObject(this);
@@ -96,22 +99,19 @@ void GlobalVariable::setParent(Module *parent) {
     LeakDetector::removeGarbageObject(this);
 }
 
-// Specialize setName to take care of symbol table majik
-void GlobalVariable::setName(const std::string &name, SymbolTable *ST) {
-  Module *P;
-  assert((ST == 0 || (!getParent() || ST == &getParent()->getSymbolTable())) &&
-         "Invalid symtab argument!");
-  if ((P = getParent()) && hasName()) P->getSymbolTable().remove(this);
-  Value::setName(name);
-  if (P && hasName()) P->getSymbolTable().insert(this);
+void GlobalVariable::removeFromParent() {
+  getParent()->getGlobalList().remove(this);
+}
+
+void GlobalVariable::eraseFromParent() {
+  getParent()->getGlobalList().erase(this);
 }
 
 void GlobalVariable::replaceUsesOfWithOnConstant(Value *From, Value *To,
-                                                 bool DisableChecking )
-{
+                                                 Use *U) {
   // If you call this, then you better know this GVar has a constant
   // initializer worth replacing. Enforce that here.
-  assert(getNumOperands() == 1 && 
+  assert(getNumOperands() == 1 &&
          "Attempt to replace uses of Constants on a GVar with no initializer");
 
   // And, since you know it has an initializer, the From value better be
@@ -122,10 +122,7 @@ void GlobalVariable::replaceUsesOfWithOnConstant(Value *From, Value *To,
   // And, you better have a constant for the replacement value
   assert(isa<Constant>(To) &&
          "Attempt to replace GVar initializer with non-constant");
-  
+
   // Okay, preconditions out of the way, replace the constant initializer.
   this->setOperand(0, cast<Constant>(To));
 }
-
-// vim: sw=2 ai
-