Finegrainify namespacification
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10131 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Bytecode/Writer/SlotCalculator.cpp b/lib/Bytecode/Writer/SlotCalculator.cpp
index c6e44e8..f4414a5 100644
--- a/lib/Bytecode/Writer/SlotCalculator.cpp
+++ b/lib/Bytecode/Writer/SlotCalculator.cpp
@@ -26,8 +26,7 @@
#include "Support/PostOrderIterator.h"
#include "Support/STLExtras.h"
#include <algorithm>
-
-namespace llvm {
+using namespace llvm;
#if 0
#define SC_DEBUG(X) std::cerr << X
@@ -363,5 +362,3 @@
SC_DEBUG("]\n");
return (int)DestSlot;
}
-
-} // End llvm namespace
diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 1823412..6718649 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -32,8 +32,7 @@
#include "Support/StringExtras.h"
#include "Support/STLExtras.h"
#include <algorithm>
-
-namespace llvm {
+using namespace llvm;
static RegisterPass<PrintModulePass>
X("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization);
@@ -233,8 +232,8 @@
// 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,
- const Module *M) {
+std::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty,
+ const Module *M) {
Out << " ";
// If they want us to print out a type, attempt to make it symbolic if there
@@ -447,7 +446,8 @@
// 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 @@
return Out;
}
-
+namespace llvm {
class AssemblyWriter {
std::ostream &Out;
@@ -520,7 +520,7 @@
// 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 @@
}
return *this;
}
-
-} // End llvm namespace
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 05bbef1..2a9af77 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -19,8 +19,7 @@
#include "llvm/Module.h"
#include "Support/StringExtras.h"
#include <algorithm>
-
-namespace llvm {
+using namespace llvm;
ConstantBool *ConstantBool::True = new ConstantBool(true);
ConstantBool *ConstantBool::False = new ConstantBool(false);
@@ -540,20 +539,22 @@
// something strange that needs to be done to interface to the ctor for the
// constant.
//
-template<class ConstantClass, class TypeClass, class ValType>
-struct ConstantCreator {
- static ConstantClass *create(const TypeClass *Ty, const ValType &V) {
- return new ConstantClass(Ty, V);
- }
-};
-
-template<class ConstantClass, class TypeClass>
-struct ConvertConstantType {
- static void convert(ConstantClass *OldC, const TypeClass *NewTy) {
- assert(0 && "This type cannot be converted!\n");
- abort();
- }
-};
+namespace llvm {
+ template<class ConstantClass, class TypeClass, class ValType>
+ struct ConstantCreator {
+ static ConstantClass *create(const TypeClass *Ty, const ValType &V) {
+ return new ConstantClass(Ty, V);
+ }
+ };
+
+ template<class ConstantClass, class TypeClass>
+ struct ConvertConstantType {
+ static void convert(ConstantClass *OldC, const TypeClass *NewTy) {
+ assert(0 && "This type cannot be converted!\n");
+ abort();
+ }
+ };
+}
namespace {
template<class ValType, class TypeClass, class ConstantClass>
@@ -712,21 +713,21 @@
//---- ConstantArray::get() implementation...
//
-
-template<>
-struct ConvertConstantType<ConstantArray, ArrayType> {
- static void convert(ConstantArray *OldC, const ArrayType *NewTy) {
- // Make everyone now use a constant of the new type...
- std::vector<Constant*> C;
- for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
- C.push_back(cast<Constant>(OldC->getOperand(i)));
- Constant *New = ConstantArray::get(NewTy, C);
- assert(New != OldC && "Didn't replace constant??");
- OldC->uncheckedReplaceAllUsesWith(New);
- OldC->destroyConstant(); // This constant is now dead, destroy it.
- }
-};
-
+namespace llvm {
+ template<>
+ struct ConvertConstantType<ConstantArray, ArrayType> {
+ static void convert(ConstantArray *OldC, const ArrayType *NewTy) {
+ // Make everyone now use a constant of the new type...
+ std::vector<Constant*> C;
+ for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
+ C.push_back(cast<Constant>(OldC->getOperand(i)));
+ Constant *New = ConstantArray::get(NewTy, C);
+ assert(New != OldC && "Didn't replace constant??");
+ OldC->uncheckedReplaceAllUsesWith(New);
+ OldC->destroyConstant(); // This constant is now dead, destroy it.
+ }
+ };
+}
static ValueMap<std::vector<Constant*>, ArrayType,
ConstantArray> ArrayConstants;
@@ -778,20 +779,22 @@
//---- ConstantStruct::get() implementation...
//
-template<>
-struct ConvertConstantType<ConstantStruct, StructType> {
- static void convert(ConstantStruct *OldC, const StructType *NewTy) {
- // Make everyone now use a constant of the new type...
- std::vector<Constant*> C;
- for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
- C.push_back(cast<Constant>(OldC->getOperand(i)));
- Constant *New = ConstantStruct::get(NewTy, C);
- assert(New != OldC && "Didn't replace constant??");
-
- OldC->uncheckedReplaceAllUsesWith(New);
- OldC->destroyConstant(); // This constant is now dead, destroy it.
- }
-};
+namespace llvm {
+ template<>
+ struct ConvertConstantType<ConstantStruct, StructType> {
+ static void convert(ConstantStruct *OldC, const StructType *NewTy) {
+ // Make everyone now use a constant of the new type...
+ std::vector<Constant*> C;
+ for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
+ C.push_back(cast<Constant>(OldC->getOperand(i)));
+ Constant *New = ConstantStruct::get(NewTy, C);
+ assert(New != OldC && "Didn't replace constant??");
+
+ OldC->uncheckedReplaceAllUsesWith(New);
+ OldC->destroyConstant(); // This constant is now dead, destroy it.
+ }
+ };
+}
static ValueMap<std::vector<Constant*>, StructType,
ConstantStruct> StructConstants;
@@ -811,24 +814,26 @@
//---- ConstantPointerNull::get() implementation...
//
-// ConstantPointerNull does not take extra "value" argument...
-template<class ValType>
-struct ConstantCreator<ConstantPointerNull, PointerType, ValType> {
- static ConstantPointerNull *create(const PointerType *Ty, const ValType &V){
- return new ConstantPointerNull(Ty);
- }
-};
+namespace llvm {
+ // ConstantPointerNull does not take extra "value" argument...
+ template<class ValType>
+ struct ConstantCreator<ConstantPointerNull, PointerType, ValType> {
+ static ConstantPointerNull *create(const PointerType *Ty, const ValType &V){
+ return new ConstantPointerNull(Ty);
+ }
+ };
-template<>
-struct ConvertConstantType<ConstantPointerNull, PointerType> {
- static void convert(ConstantPointerNull *OldC, const PointerType *NewTy) {
- // Make everyone now use a constant of the new type...
- Constant *New = ConstantPointerNull::get(NewTy);
- assert(New != OldC && "Didn't replace constant??");
- OldC->uncheckedReplaceAllUsesWith(New);
- OldC->destroyConstant(); // This constant is now dead, destroy it.
- }
-};
+ template<>
+ struct ConvertConstantType<ConstantPointerNull, PointerType> {
+ static void convert(ConstantPointerNull *OldC, const PointerType *NewTy) {
+ // Make everyone now use a constant of the new type...
+ Constant *New = ConstantPointerNull::get(NewTy);
+ assert(New != OldC && "Didn't replace constant??");
+ OldC->uncheckedReplaceAllUsesWith(New);
+ OldC->destroyConstant(); // This constant is now dead, destroy it.
+ }
+ };
+}
static ValueMap<char, PointerType, ConstantPointerNull> NullPtrConstants;
@@ -865,56 +870,58 @@
//
typedef std::pair<unsigned, std::vector<Constant*> > ExprMapKeyType;
-template<>
-struct ConstantCreator<ConstantExpr, Type, ExprMapKeyType> {
- static ConstantExpr *create(const Type *Ty, const ExprMapKeyType &V) {
- if (V.first == Instruction::Cast)
- return new ConstantExpr(Instruction::Cast, V.second[0], Ty);
- if ((V.first >= Instruction::BinaryOpsBegin &&
- V.first < Instruction::BinaryOpsEnd) ||
- 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!");
-
- std::vector<Constant*> IdxList(V.second.begin()+1, V.second.end());
- 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;
+namespace llvm {
+ template<>
+ struct ConstantCreator<ConstantExpr, Type, ExprMapKeyType> {
+ static ConstantExpr *create(const Type *Ty, const ExprMapKeyType &V) {
+ if (V.first == Instruction::Cast)
+ return new ConstantExpr(Instruction::Cast, V.second[0], Ty);
+ if ((V.first >= Instruction::BinaryOpsBegin &&
+ V.first < Instruction::BinaryOpsEnd) ||
+ 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!");
+
+ std::vector<Constant*> IdxList(V.second.begin()+1, V.second.end());
+ return new ConstantExpr(V.second[0], IdxList, Ty);
}
+ };
- assert(New != OldC && "Didn't replace constant??");
- OldC->uncheckedReplaceAllUsesWith(New);
- OldC->destroyConstant(); // This constant is now dead, destroy it.
- }
-};
+ 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??");
+ 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 @@
}
}
-} // End llvm namespace
diff --git a/lib/VMCore/Dominators.cpp b/lib/VMCore/Dominators.cpp
index cad6685..dbdb409 100644
--- a/lib/VMCore/Dominators.cpp
+++ b/lib/VMCore/Dominators.cpp
@@ -19,8 +19,7 @@
#include "llvm/Assembly/Writer.h"
#include "Support/DepthFirstIterator.h"
#include "Support/SetOperations.h"
-
-namespace llvm {
+using namespace llvm;
//===----------------------------------------------------------------------===//
// DominatorSet Implementation
@@ -120,7 +119,7 @@
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 @@
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 @@
}
}
-} // End llvm namespace
diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp
index 364cc6f..9a4ac67 100644
--- a/lib/VMCore/Function.cpp
+++ b/lib/VMCore/Function.cpp
@@ -18,8 +18,7 @@
#include "llvm/Intrinsics.h"
#include "Support/LeakDetector.h"
#include "SymbolTableListTraitsImpl.h"
-
-namespace llvm {
+using namespace llvm;
BasicBlock *ilist_traits<BasicBlock>::createNode() {
BasicBlock *Ret = new BasicBlock();
@@ -259,5 +258,3 @@
Value::setName(name);
if (P && getName() != "") P->getSymbolTable().insert(this);
}
-
-} // End llvm namespace
diff --git a/lib/VMCore/Module.cpp b/lib/VMCore/Module.cpp
index 6b15929..b4b0925 100644
--- a/lib/VMCore/Module.cpp
+++ b/lib/VMCore/Module.cpp
@@ -21,8 +21,7 @@
#include <algorithm>
#include <cstdarg>
#include <map>
-
-namespace llvm {
+using namespace llvm;
Function *ilist_traits<Function>::createNode() {
FunctionType *FTy =
@@ -55,11 +54,13 @@
// Define the GlobalValueRefMap as a struct that wraps a map so that we don't
// have Module.h depend on <map>
//
-struct GlobalValueRefMap {
- typedef std::map<GlobalValue*, ConstantPointerRef*> MapTy;
- typedef MapTy::iterator iterator;
- std::map<GlobalValue*, ConstantPointerRef*> Map;
-};
+namespace llvm {
+ struct GlobalValueRefMap {
+ typedef std::map<GlobalValue*, ConstantPointerRef*> MapTy;
+ typedef MapTy::iterator iterator;
+ std::map<GlobalValue*, ConstantPointerRef*> Map;
+ };
+}
Module::Module(const std::string &MID)
@@ -310,4 +311,3 @@
}
}
-} // End llvm namespace
diff --git a/lib/VMCore/ModuleProvider.cpp b/lib/VMCore/ModuleProvider.cpp
index 8be0336..12a4fe6 100644
--- a/lib/VMCore/ModuleProvider.cpp
+++ b/lib/VMCore/ModuleProvider.cpp
@@ -13,8 +13,7 @@
#include "llvm/ModuleProvider.h"
#include "llvm/Module.h"
-
-namespace llvm {
+using namespace llvm;
/// ctor - always have a valid Module
///
@@ -37,5 +36,3 @@
return TheModule;
}
-
-} // End llvm namespace
diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp
index b387fc3..40a3b7d 100644
--- a/lib/VMCore/Pass.cpp
+++ b/lib/VMCore/Pass.cpp
@@ -20,8 +20,7 @@
#include "Support/STLExtras.h"
#include "Support/TypeInfo.h"
#include <set>
-
-namespace llvm {
+using namespace llvm;
// IncludeFile - Stub function used to help linking out.
IncludeFile::IncludeFile(void*) {}
@@ -469,5 +468,3 @@
E = PassInfoMap->end(); I != E; ++I)
passEnumerate(I->second);
}
-
-} // End llvm namespace
diff --git a/lib/VMCore/SlotCalculator.cpp b/lib/VMCore/SlotCalculator.cpp
index c6e44e8..f4414a5 100644
--- a/lib/VMCore/SlotCalculator.cpp
+++ b/lib/VMCore/SlotCalculator.cpp
@@ -26,8 +26,7 @@
#include "Support/PostOrderIterator.h"
#include "Support/STLExtras.h"
#include <algorithm>
-
-namespace llvm {
+using namespace llvm;
#if 0
#define SC_DEBUG(X) std::cerr << X
@@ -363,5 +362,3 @@
SC_DEBUG("]\n");
return (int)DestSlot;
}
-
-} // End llvm namespace
diff --git a/lib/VMCore/SymbolTable.cpp b/lib/VMCore/SymbolTable.cpp
index f2e5398..8c9e86c 100644
--- a/lib/VMCore/SymbolTable.cpp
+++ b/lib/VMCore/SymbolTable.cpp
@@ -16,8 +16,7 @@
#include "llvm/Module.h"
#include "Support/StringExtras.h"
#include <algorithm>
-
-namespace llvm {
+using namespace llvm;
#define DEBUG_SYMBOL_TABLE 0
#define DEBUG_ABSTYPE 0
@@ -363,5 +362,3 @@
std::cout << "Symbol table dump:\n";
for_each(begin(), end(), DumpPlane);
}
-
-} // End llvm namespace
diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp
index f389eb0..fcf0b7a 100644
--- a/lib/VMCore/Value.cpp
+++ b/lib/VMCore/Value.cpp
@@ -17,8 +17,7 @@
#include "llvm/Constant.h"
#include "Support/LeakDetector.h"
#include <algorithm>
-
-namespace llvm {
+using namespace llvm;
//===----------------------------------------------------------------------===//
// Value Class
@@ -109,5 +108,3 @@
setOperand(i, To); // Fix it now...
}
}
-
-} // End llvm namespace
diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index b517dac..48384e8 100644
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -57,8 +57,7 @@
#include "llvm/Support/InstVisitor.h"
#include "Support/STLExtras.h"
#include <algorithm>
-
-namespace llvm {
+using namespace llvm;
namespace { // Anonymous namespace for class
@@ -158,9 +157,11 @@
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 @@
};
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 @@
"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 @@
// 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
diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp
index c1a0657..917692e 100644
--- a/lib/VMCore/iMemory.cpp
+++ b/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,