6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-18 12:29:27 +00:00
Code Issues Projects Releases Wiki Activity

Finegrainify namespacification

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10131 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-11-21 20:23:48 +00:00
parent 23e1492bb1
commit 31f8499e83
13 changed files with 152 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lib/Bytecode/Writer/SlotCalculator.cpp
View File

@ -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 @@ int SlotCalculator::doInsertValue(const Value *D) {
SC_DEBUG("]\n");
return (int)DestSlot;
}
} // End llvm namespace

16
lib/VMCore/AsmWriter.cpp
View File

@ -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 @@ 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,
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 @@ 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

228
lib/VMCore/Constants.cpp
View File

@ -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 @@ 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>
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 @@ ConstantFP *ConstantFP::get(const Type *Ty, double V) {
//---- 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 @@ std::string ConstantArray::getAsString() const {
//---- 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 @@ void ConstantStruct::destroyConstant() {
//---- 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 @@ void ConstantPointerRef::destroyConstant() {
//
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 @@ unsigned Constant::mutateReferences(Value *OldV, Value *NewV) {
}
}
} // End llvm namespace

7
lib/VMCore/Dominators.cpp
View File

@ -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 @@ 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

5
lib/VMCore/Function.cpp
View File

@ -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 @@ void GlobalVariable::setName(const std::string &name, SymbolTable *ST) {
Value::setName(name);
if (P && getName() != "") P->getSymbolTable().insert(this);
}
} // End llvm namespace

16
lib/VMCore/Module.cpp
View File

@ -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 @@ 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 {
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 @@ void Module::mutateConstantPointerRef(GlobalValue *OldGV, GlobalValue *NewGV) {
}
}
} // End llvm namespace

5
lib/VMCore/ModuleProvider.cpp
View File

@ -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 @@ Module* ModuleProvider::materializeModule() {
return TheModule;
}
} // End llvm namespace

5
lib/VMCore/Pass.cpp
View File

@ -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 @@ void PassRegistrationListener::enumeratePasses() {
E = PassInfoMap->end(); I != E; ++I)
passEnumerate(I->second);
}
} // End llvm namespace

5
lib/VMCore/SlotCalculator.cpp
View File

@ -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 @@ int SlotCalculator::doInsertValue(const Value *D) {
SC_DEBUG("]\n");
return (int)DestSlot;
}
} // End llvm namespace

5
lib/VMCore/SymbolTable.cpp
View File

@ -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 @@ void SymbolTable::dump() const {
std::cout << "Symbol table dump:\n";
for_each(begin(), end(), DumpPlane);
}
} // End llvm namespace

5
lib/VMCore/Value.cpp
View File

@ -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 @@ void User::replaceUsesOfWith(Value *From, Value *To) {
setOperand(i, To); // Fix it now...
}
}
} // End llvm namespace

20
lib/VMCore/Verifier.cpp
View File

@ -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 @@ 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

1
lib/VMCore/iMemory.cpp
View File

@ -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,