Finegrainify namespacification

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10131 91177308-0d34-0410-b5e6-96231b3b80d8

lib/Bytecode/Writer/SlotCalculator.cpp

@@ -26,8 +26,7 @@
 #include "Support/PostOrderIterator.h"
 #include "Support/STLExtras.h"
 #include <algorithm>
-
+using namespace llvm;
-namespace llvm {
 
 #if 0
 #define SC_DEBUG(X) std::cerr << X
@@ -363,5 +362,3 @@ int SlotCalculator::doInsertValue(const Value *D) {
   SC_DEBUG("]\n");
   return (int)DestSlot;
 }
-
-} // End llvm namespace

lib/VMCore/AsmWriter.cpp

@@ -32,8 +32,7 @@
 #include "Support/StringExtras.h"
 #include "Support/STLExtras.h"
 #include <algorithm>
-
+using namespace llvm;
-namespace llvm {
 
 static RegisterPass<PrintModulePass>
 X("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization);
@@ -233,8 +232,8 @@ static std::ostream &printTypeInt(std::ostream &Out, const Type *Ty,
 // type, iff there is an entry in the modules symbol table for the specified
 // type or one of it's component types.  This is slower than a simple x << Type;
 //
-std::ostream &WriteTypeSymbolic(std::ostream &Out, const Type *Ty,
+std::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty,
-                                const Module *M) {
+                                      const Module *M) {
   Out << " "; 
 
   // If they want us to print out a type, attempt to make it symbolic if there
@@ -447,7 +446,8 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
 // ostream.  This can be useful when you just want to print int %reg126, not the
 // whole instruction that generated it.
 //
-std::ostream &WriteAsOperand(std::ostream &Out, const Value *V, bool PrintType, 
+std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V,
+                                   bool PrintType, 
                              bool PrintName, const Module *Context) {
   std::map<const Type *, std::string> TypeNames;
   if (Context == 0) Context = getModuleFromVal(V);
@@ -465,7 +465,7 @@ std::ostream &WriteAsOperand(std::ostream &Out, const Value *V, bool PrintType,
   return Out;
 }
 
-
+namespace llvm {
 
 class AssemblyWriter {
   std::ostream &Out;
@@ -520,7 +520,7 @@ private :
   // which slot it occupies.
   void printInfoComment(const Value &V);
 };
-
+}  // end of anonymous namespace
 
 // printTypeAtLeastOneLevel - Print out one level of the possibly complex type
 // without considering any symbolic types that we may have equal to it.
@@ -1063,5 +1063,3 @@ CachedWriter &CachedWriter::operator<<(const Value *V) {
   }
   return *this;
 }
-
-} // End llvm namespace

lib/VMCore/Constants.cpp

@@ -19,8 +19,7 @@
 #include "llvm/Module.h"
 #include "Support/StringExtras.h"
 #include <algorithm>
-
+using namespace llvm;
-namespace llvm {
 
 ConstantBool *ConstantBool::True  = new ConstantBool(true);
 ConstantBool *ConstantBool::False = new ConstantBool(false);
@@ -540,20 +539,22 @@ void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV,
 // something strange that needs to be done to interface to the ctor for the
 // constant.
 //
-template<class ConstantClass, class TypeClass, class ValType>
+namespace llvm {
-struct ConstantCreator {
+  template<class ConstantClass, class TypeClass, class ValType>
-  static ConstantClass *create(const TypeClass *Ty, const ValType &V) {
+  struct ConstantCreator {
-    return new ConstantClass(Ty, V);
+    static ConstantClass *create(const TypeClass *Ty, const ValType &V) {
-  }
+      return new ConstantClass(Ty, V);
-};
+    }
+  };
   
-template<class ConstantClass, class TypeClass>
+  template<class ConstantClass, class TypeClass>
-struct ConvertConstantType {
+  struct ConvertConstantType {
-  static void convert(ConstantClass *OldC, const TypeClass *NewTy) {
+    static void convert(ConstantClass *OldC, const TypeClass *NewTy) {
-    assert(0 && "This type cannot be converted!\n");
+      assert(0 && "This type cannot be converted!\n");
-    abort();
+      abort();
-  }
+    }
-};
+  };
+}
 
 namespace {
   template<class ValType, class TypeClass, class ConstantClass>
@@ -712,21 +713,21 @@ ConstantFP *ConstantFP::get(const Type *Ty, double V) {
 
 //---- ConstantArray::get() implementation...
 //
-
+namespace llvm {
-template<>
+  template<>
-struct ConvertConstantType<ConstantArray, ArrayType> {
+  struct ConvertConstantType<ConstantArray, ArrayType> {
-  static void convert(ConstantArray *OldC, const ArrayType *NewTy) {
+    static void convert(ConstantArray *OldC, const ArrayType *NewTy) {
-    // Make everyone now use a constant of the new type...
+      // Make everyone now use a constant of the new type...
-    std::vector<Constant*> C;
+      std::vector<Constant*> C;
-    for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
+      for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
-      C.push_back(cast<Constant>(OldC->getOperand(i)));
+        C.push_back(cast<Constant>(OldC->getOperand(i)));
-    Constant *New = ConstantArray::get(NewTy, C);
+      Constant *New = ConstantArray::get(NewTy, C);
-    assert(New != OldC && "Didn't replace constant??");
+      assert(New != OldC && "Didn't replace constant??");
-    OldC->uncheckedReplaceAllUsesWith(New);
+      OldC->uncheckedReplaceAllUsesWith(New);
-    OldC->destroyConstant();    // This constant is now dead, destroy it.
+      OldC->destroyConstant();    // This constant is now dead, destroy it.
-  }
+    }
-};
+  };
-
+}
 
 static ValueMap<std::vector<Constant*>, ArrayType,
                 ConstantArray> ArrayConstants;
@@ -778,20 +779,22 @@ std::string ConstantArray::getAsString() const {
 //---- ConstantStruct::get() implementation...
 //
 
-template<>
+namespace llvm {
-struct ConvertConstantType<ConstantStruct, StructType> {
+  template<>
-  static void convert(ConstantStruct *OldC, const StructType *NewTy) {
+  struct ConvertConstantType<ConstantStruct, StructType> {
-    // Make everyone now use a constant of the new type...
+    static void convert(ConstantStruct *OldC, const StructType *NewTy) {
-    std::vector<Constant*> C;
+      // Make everyone now use a constant of the new type...
-    for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
+      std::vector<Constant*> C;
-      C.push_back(cast<Constant>(OldC->getOperand(i)));
+      for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
-    Constant *New = ConstantStruct::get(NewTy, C);
+        C.push_back(cast<Constant>(OldC->getOperand(i)));
-    assert(New != OldC && "Didn't replace constant??");
+      Constant *New = ConstantStruct::get(NewTy, C);
+      assert(New != OldC && "Didn't replace constant??");
       
-    OldC->uncheckedReplaceAllUsesWith(New);
+      OldC->uncheckedReplaceAllUsesWith(New);
-    OldC->destroyConstant();    // This constant is now dead, destroy it.
+      OldC->destroyConstant();    // This constant is now dead, destroy it.
-  }
+    }
-};
+  };
+}
 
 static ValueMap<std::vector<Constant*>, StructType, 
                 ConstantStruct> StructConstants;
@@ -811,24 +814,26 @@ void ConstantStruct::destroyConstant() {
 //---- ConstantPointerNull::get() implementation...
 //
 
-// ConstantPointerNull does not take extra "value" argument...
+namespace llvm {
-template<class ValType>
+  // ConstantPointerNull does not take extra "value" argument...
-struct ConstantCreator<ConstantPointerNull, PointerType, ValType> {
+  template<class ValType>
-  static ConstantPointerNull *create(const PointerType *Ty, const ValType &V){
+  struct ConstantCreator<ConstantPointerNull, PointerType, ValType> {
-    return new ConstantPointerNull(Ty);
+    static ConstantPointerNull *create(const PointerType *Ty, const ValType &V){
-  }
+      return new ConstantPointerNull(Ty);
-};
+    }
+  };
 
-template<>
+  template<>
-struct ConvertConstantType<ConstantPointerNull, PointerType> {
+  struct ConvertConstantType<ConstantPointerNull, PointerType> {
-  static void convert(ConstantPointerNull *OldC, const PointerType *NewTy) {
+    static void convert(ConstantPointerNull *OldC, const PointerType *NewTy) {
-    // Make everyone now use a constant of the new type...
+      // Make everyone now use a constant of the new type...
-    Constant *New = ConstantPointerNull::get(NewTy);
+      Constant *New = ConstantPointerNull::get(NewTy);
-    assert(New != OldC && "Didn't replace constant??");
+      assert(New != OldC && "Didn't replace constant??");
-    OldC->uncheckedReplaceAllUsesWith(New);
+      OldC->uncheckedReplaceAllUsesWith(New);
-    OldC->destroyConstant();     // This constant is now dead, destroy it.
+      OldC->destroyConstant();     // This constant is now dead, destroy it.
-  }
+    }
-};
+  };
+}
 
 static ValueMap<char, PointerType, ConstantPointerNull> NullPtrConstants;
 
@@ -865,56 +870,58 @@ void ConstantPointerRef::destroyConstant() {
 //
 typedef std::pair<unsigned, std::vector<Constant*> > ExprMapKeyType;
 
-template<>
+namespace llvm {
-struct ConstantCreator<ConstantExpr, Type, ExprMapKeyType> {
+  template<>
-  static ConstantExpr *create(const Type *Ty, const ExprMapKeyType &V) {
+  struct ConstantCreator<ConstantExpr, Type, ExprMapKeyType> {
-    if (V.first == Instruction::Cast)
+    static ConstantExpr *create(const Type *Ty, const ExprMapKeyType &V) {
-      return new ConstantExpr(Instruction::Cast, V.second[0], Ty);
+      if (V.first == Instruction::Cast)
-    if ((V.first >= Instruction::BinaryOpsBegin &&
+        return new ConstantExpr(Instruction::Cast, V.second[0], Ty);
-         V.first < Instruction::BinaryOpsEnd) ||
+      if ((V.first >= Instruction::BinaryOpsBegin &&
-        V.first == Instruction::Shl || V.first == Instruction::Shr)
+           V.first < Instruction::BinaryOpsEnd) ||
-      return new ConstantExpr(V.first, V.second[0], V.second[1]);
+          V.first == Instruction::Shl || V.first == Instruction::Shr)
+        return new ConstantExpr(V.first, V.second[0], V.second[1]);
       
-    assert(V.first == Instruction::GetElementPtr && "Invalid ConstantExpr!");
+      assert(V.first == Instruction::GetElementPtr && "Invalid ConstantExpr!");
       
-    std::vector<Constant*> IdxList(V.second.begin()+1, V.second.end());
+      std::vector<Constant*> IdxList(V.second.begin()+1, V.second.end());
-    return new ConstantExpr(V.second[0], IdxList, Ty);
+      return new ConstantExpr(V.second[0], IdxList, Ty);
-  }
-};
-
-template<>
-struct ConvertConstantType<ConstantExpr, Type> {
-  static void convert(ConstantExpr *OldC, const Type *NewTy) {
-    Constant *New;
-    switch (OldC->getOpcode()) {
-    case Instruction::Cast:
-      New = ConstantExpr::getCast(OldC->getOperand(0), NewTy);
-      break;
-    case Instruction::Shl:
-    case Instruction::Shr:
-      New = ConstantExpr::getShiftTy(NewTy, OldC->getOpcode(),
-                                     OldC->getOperand(0), OldC->getOperand(1));
-      break;
-    default:
-      assert(OldC->getOpcode() >= Instruction::BinaryOpsBegin &&
-             OldC->getOpcode() < Instruction::BinaryOpsEnd);
-      New = ConstantExpr::getTy(NewTy, OldC->getOpcode(), OldC->getOperand(0),
-                                OldC->getOperand(1));
-      break;
-    case Instruction::GetElementPtr:
-      // Make everyone now use a constant of the new type... 
-      std::vector<Constant*> C;
-      for (unsigned i = 1, e = OldC->getNumOperands(); i != e; ++i)
-        C.push_back(cast<Constant>(OldC->getOperand(i)));
-      New = ConstantExpr::getGetElementPtrTy(NewTy, OldC->getOperand(0), C);
-      break;
     }
+  };
 
-    assert(New != OldC && "Didn't replace constant??");
+  template<>
-    OldC->uncheckedReplaceAllUsesWith(New);
+  struct ConvertConstantType<ConstantExpr, Type> {
-    OldC->destroyConstant();    // This constant is now dead, destroy it.
+    static void convert(ConstantExpr *OldC, const Type *NewTy) {
-  }
+      Constant *New;
-};
+      switch (OldC->getOpcode()) {
+      case Instruction::Cast:
+        New = ConstantExpr::getCast(OldC->getOperand(0), NewTy);
+        break;
+      case Instruction::Shl:
+      case Instruction::Shr:
+        New = ConstantExpr::getShiftTy(NewTy, OldC->getOpcode(),
+                                     OldC->getOperand(0), OldC->getOperand(1));
+        break;
+      default:
+        assert(OldC->getOpcode() >= Instruction::BinaryOpsBegin &&
+               OldC->getOpcode() < Instruction::BinaryOpsEnd);
+        New = ConstantExpr::getTy(NewTy, OldC->getOpcode(), OldC->getOperand(0),
+                                  OldC->getOperand(1));
+        break;
+      case Instruction::GetElementPtr:
+        // Make everyone now use a constant of the new type... 
+        std::vector<Constant*> C;
+        for (unsigned i = 1, e = OldC->getNumOperands(); i != e; ++i)
+          C.push_back(cast<Constant>(OldC->getOperand(i)));
+        New = ConstantExpr::getGetElementPtrTy(NewTy, OldC->getOperand(0), C);
+        break;
+      }
+      
+      assert(New != OldC && "Didn't replace constant??");
+      OldC->uncheckedReplaceAllUsesWith(New);
+      OldC->destroyConstant();    // This constant is now dead, destroy it.
+    }
+  };
+} // end namespace llvm
 
 
 static ValueMap<ExprMapKeyType, Type, ConstantExpr> ExprConstants;
@@ -1039,4 +1046,3 @@ unsigned Constant::mutateReferences(Value *OldV, Value *NewV) {
   }
 }
 
-} // End llvm namespace

lib/VMCore/Dominators.cpp

@@ -19,8 +19,7 @@
 #include "llvm/Assembly/Writer.h"
 #include "Support/DepthFirstIterator.h"
 #include "Support/SetOperations.h"
-
+using namespace llvm;
-namespace llvm {
 
 //===----------------------------------------------------------------------===//
 //  DominatorSet Implementation
@@ -120,7 +119,7 @@ void DominatorSet::recalculate() {
   for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) Doms[I];
 }
 
-
+namespace llvm {
 static std::ostream &operator<<(std::ostream &o,
                                 const std::set<BasicBlock*> &BBs) {
   for (std::set<BasicBlock*>::const_iterator I = BBs.begin(), E = BBs.end();
@@ -131,6 +130,7 @@ static std::ostream &operator<<(std::ostream &o,
       o << " <<exit node>>";
   return o;
 }
+}
 
 void DominatorSetBase::print(std::ostream &o) const {
   for (const_iterator I = begin(), E = end(); I != E; ++I) {
@@ -361,4 +361,3 @@ void DominanceFrontierBase::print(std::ostream &o) const {
   }
 }
 
-} // End llvm namespace

lib/VMCore/Function.cpp

@@ -18,8 +18,7 @@
 #include "llvm/Intrinsics.h"
 #include "Support/LeakDetector.h"
 #include "SymbolTableListTraitsImpl.h"
-
+using namespace llvm;
-namespace llvm {
 
 BasicBlock *ilist_traits<BasicBlock>::createNode() {
   BasicBlock *Ret = new BasicBlock();
@@ -259,5 +258,3 @@ void GlobalVariable::setName(const std::string &name, SymbolTable *ST) {
   Value::setName(name);
   if (P && getName() != "") P->getSymbolTable().insert(this);
 }
-
-} // End llvm namespace

lib/VMCore/Module.cpp

@@ -21,8 +21,7 @@
 #include <algorithm>
 #include <cstdarg>
 #include <map>
-
+using namespace llvm;
-namespace llvm {
 
 Function *ilist_traits<Function>::createNode() {
   FunctionType *FTy =
@@ -55,11 +54,13 @@ template class SymbolTableListTraits<Function, Module, Module>;
 // Define the GlobalValueRefMap as a struct that wraps a map so that we don't
 // have Module.h depend on <map>
 //
-struct GlobalValueRefMap {
+namespace llvm {
-  typedef std::map<GlobalValue*, ConstantPointerRef*> MapTy;
+  struct GlobalValueRefMap {
-  typedef MapTy::iterator iterator;
+    typedef std::map<GlobalValue*, ConstantPointerRef*> MapTy;
-  std::map<GlobalValue*, ConstantPointerRef*> Map;
+    typedef MapTy::iterator iterator;
-};
+    std::map<GlobalValue*, ConstantPointerRef*> Map;
+  };
+}
 
 
 Module::Module(const std::string &MID)
@@ -310,4 +311,3 @@ void Module::mutateConstantPointerRef(GlobalValue *OldGV, GlobalValue *NewGV) {
   }
 }
 
-} // End llvm namespace

lib/VMCore/ModuleProvider.cpp

@@ -13,8 +13,7 @@
 
 #include "llvm/ModuleProvider.h"
 #include "llvm/Module.h"
-
+using namespace llvm;
-namespace llvm {
 
 /// ctor - always have a valid Module
 ///
@@ -37,5 +36,3 @@ Module* ModuleProvider::materializeModule() {
 
   return TheModule;
 }
-
-} // End llvm namespace

lib/VMCore/Pass.cpp

@@ -20,8 +20,7 @@
 #include "Support/STLExtras.h"
 #include "Support/TypeInfo.h"
 #include <set>
-
+using namespace llvm;
-namespace llvm {
 
 // IncludeFile - Stub function used to help linking out.
 IncludeFile::IncludeFile(void*) {}
@@ -469,5 +468,3 @@ void PassRegistrationListener::enumeratePasses() {
            E = PassInfoMap->end(); I != E; ++I)
       passEnumerate(I->second);
 }
-
-} // End llvm namespace

lib/VMCore/SlotCalculator.cpp

@@ -26,8 +26,7 @@
 #include "Support/PostOrderIterator.h"
 #include "Support/STLExtras.h"
 #include <algorithm>
-
+using namespace llvm;
-namespace llvm {
 
 #if 0
 #define SC_DEBUG(X) std::cerr << X
@@ -363,5 +362,3 @@ int SlotCalculator::doInsertValue(const Value *D) {
   SC_DEBUG("]\n");
   return (int)DestSlot;
 }
-
-} // End llvm namespace

lib/VMCore/SymbolTable.cpp

@@ -16,8 +16,7 @@
 #include "llvm/Module.h"
 #include "Support/StringExtras.h"
 #include <algorithm>
-
+using namespace llvm;
-namespace llvm {
 
 #define DEBUG_SYMBOL_TABLE 0
 #define DEBUG_ABSTYPE 0
@@ -363,5 +362,3 @@ void SymbolTable::dump() const {
   std::cout << "Symbol table dump:\n";
   for_each(begin(), end(), DumpPlane);
 }
-
-} // End llvm namespace

lib/VMCore/Value.cpp

@@ -17,8 +17,7 @@
 #include "llvm/Constant.h"
 #include "Support/LeakDetector.h"
 #include <algorithm>
-
+using namespace llvm;
-namespace llvm {
 
 //===----------------------------------------------------------------------===//
 //                                Value Class
@@ -109,5 +108,3 @@ void User::replaceUsesOfWith(Value *From, Value *To) {
       setOperand(i, To); // Fix it now...
     }
 }
-
-} // End llvm namespace

lib/VMCore/Verifier.cpp

@@ -57,8 +57,7 @@
 #include "llvm/Support/InstVisitor.h"
 #include "Support/STLExtras.h"
 #include <algorithm>
-
+using namespace llvm;
-namespace llvm {
 
 namespace {  // Anonymous namespace for class
 
@@ -158,9 +157,11 @@ namespace {  // Anonymous namespace for class
 
     void WriteValue(const Value *V) {
       if (!V) return;
-      if (isa<Instruction>(V))
+      if (isa<Instruction>(V)) {
         std::cerr << *V;
-      else {
+      } else if (const Type *Ty = dyn_cast<Type>(V)) {
+        WriteTypeSymbolic(std::cerr, Ty, Mod);
+      } else {
         WriteAsOperand (std::cerr, V, true, true, Mod);
         std::cerr << "\n";
       }
@@ -184,6 +185,8 @@ namespace {  // Anonymous namespace for class
   };
 
   RegisterOpt<Verifier> X("verify", "Module Verifier");
+} // End anonymous namespace
+
 
 // Assert - We know that cond should be true, if not print an error message.
 #define Assert(C, M) \
@@ -569,19 +572,18 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
           "Illegal # arguments for intrinsic function!", IF);
 }
 
-} // End anonymous namespace
 
 //===----------------------------------------------------------------------===//
 //  Implement the public interfaces to this file...
 //===----------------------------------------------------------------------===//
 
-FunctionPass *createVerifierPass() {
+FunctionPass *llvm::createVerifierPass() {
   return new Verifier();
 }
 
 
 // verifyFunction - Create 
-bool verifyFunction(const Function &f) {
+bool llvm::verifyFunction(const Function &f) {
   Function &F = (Function&)f;
   assert(!F.isExternal() && "Cannot verify external functions");
 
@@ -600,12 +602,10 @@ bool verifyFunction(const Function &f) {
 // verifyModule - Check a module for errors, printing messages on stderr.
 // Return true if the module is corrupt.
 //
-bool verifyModule(const Module &M) {
+bool llvm::verifyModule(const Module &M) {
   PassManager PM;
   Verifier *V = new Verifier();
   PM.add(V);
   PM.run((Module&)M);
   return V->Broken;
 }
-
-} // End llvm namespace

lib/VMCore/iMemory.cpp

@@ -14,7 +14,6 @@
 #include "llvm/iMemory.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
-
 using namespace llvm;
 
 AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,