RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-24 03:33:20 +01:00
Code Issues Projects Releases Wiki Activity

The only clients of the slot calculator are now the asmwriter and bcwriter.

Browse Source 
Since this really only makes sense for these two, change hte instance variable
to reflect whether we are writing a bytecode file or not.  This makes it
reasonable to add bcwriter specific stuff to it as necessary.

llvm-svn: 10837
This commit is contained in:
Chris Lattner 2004-01-14 02:49:34 +00:00
parent c4225e2f09
commit bcd7372d19
3 changed files with 25 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/llvm/SlotCalculator.h
View File

@ -32,7 +32,12 @@ class SymbolTable;
class SlotCalculator {
const Module *TheModule;
bool IgnoreNamedNodes; // Shall we not count named nodes?
// BuildBytecodeInfo - If true, this is the creating information for the
// bytecode writer, if false, we are building information for the assembly
// emitter. The assembly emitter doesn't need named objects numbered, among
// other differences.
bool BuildBytecodeInfo;
typedef std::vector<const Value*> TypePlane;
std::vector<TypePlane> Table;
@ -44,9 +49,9 @@ class SlotCalculator {
std::vector<unsigned> ModuleLevel;
public:
SlotCalculator(const Module *M, bool IgnoreNamed);
SlotCalculator(const Module *M, bool BuildBytecodeInfo);
// Start out in incorp state
SlotCalculator(const Function *M, bool IgnoreNamed);
SlotCalculator(const Function *M, bool BuildBytecodeInfo);
inline ~SlotCalculator() {}
// getSlot returns < 0 on error!

12
lib/VMCore/AsmWriter.cpp
View File

@ -60,15 +60,15 @@ static const Module *getModuleFromVal(const Value *V) {
static SlotCalculator *createSlotCalculator(const Value *V) {
assert(!isa<Type>(V) && "Can't create an SC for a type!");
if (const Argument *FA = dyn_cast<Argument>(V)) {
return new SlotCalculator(FA->getParent(), true);
return new SlotCalculator(FA->getParent(), false);
} else if (const Instruction *I = dyn_cast<Instruction>(V)) {
return new SlotCalculator(I->getParent()->getParent(), true);
return new SlotCalculator(I->getParent()->getParent(), false);
} else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) {
return new SlotCalculator(BB->getParent(), true);
return new SlotCalculator(BB->getParent(), false);
} else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){
return new SlotCalculator(GV->getParent(), true);
return new SlotCalculator(GV->getParent(), false);
} else if (const Function *Func = dyn_cast<Function>(V)) {
return new SlotCalculator(Func, true);
return new SlotCalculator(Func, false);
}
return 0;
}
@ -1037,7 +1037,7 @@ void Value::dump() const { print(std::cerr); }
void CachedWriter::setModule(const Module *M) {
delete SC; delete AW;
if (M) {
SC = new SlotCalculator(M, true);
SC = new SlotCalculator(M, false);
AW = new AssemblyWriter(Out, *SC, M, 0);
} else {
SC = 0; AW = 0;

22
lib/VMCore/SlotCalculator.cpp
View File

@ -34,8 +34,8 @@ using namespace llvm;
#define SC_DEBUG(X)
#endif
SlotCalculator::SlotCalculator(const Module *M, bool IgnoreNamed) {
IgnoreNamedNodes = IgnoreNamed;
SlotCalculator::SlotCalculator(const Module *M, bool buildBytecodeInfo) {
BuildBytecodeInfo = buildBytecodeInfo;
TheModule = M;
// Preload table... Make sure that all of the primitive types are in the table
@ -51,8 +51,8 @@ SlotCalculator::SlotCalculator(const Module *M, bool IgnoreNamed) {
processModule();
}
SlotCalculator::SlotCalculator(const Function *M, bool IgnoreNamed) {
IgnoreNamedNodes = IgnoreNamed;
SlotCalculator::SlotCalculator(const Function *M, bool buildBytecodeInfo) {
BuildBytecodeInfo = buildBytecodeInfo;
TheModule = M ? M->getParent() : 0;
// Preload table... Make sure that all of the primitive types are in the table
@ -106,7 +106,7 @@ void SlotCalculator::processModule() {
// constants, which allows us to emit more compact modules. This is optional,
// and is just used to compactify the constants used by different functions
// together.
if (!IgnoreNamedNodes) {
if (BuildBytecodeInfo) {
SC_DEBUG("Inserting function constants:\n");
for (Module::const_iterator F = TheModule->begin(), E = TheModule->end();
F != E; ++F)
@ -118,7 +118,7 @@ void SlotCalculator::processModule() {
// Insert constants that are named at module level into the slot pool so that
// the module symbol table can refer to them...
//
if (!IgnoreNamedNodes) {
if (BuildBytecodeInfo) {
SC_DEBUG("Inserting SymbolTable values:\n");
processSymbolTable(&TheModule->getSymbolTable());
}
@ -132,7 +132,7 @@ void SlotCalculator::processModule() {
// all non-value types are pushed to the end of the type table, giving nice
// low numbers to the types that can be used by instructions, thus reducing
// the amount of explodage we suffer.
if (!IgnoreNamedNodes && Table[Type::TypeTyID].size() >= 64) {
if (BuildBytecodeInfo && Table[Type::TypeTyID].size() >= 64) {
// Scan through the type table moving value types to the start of the table.
TypePlane *Types = &Table[Type::TypeTyID];
unsigned FirstNonValueTypeID = 0;
@ -205,7 +205,7 @@ void SlotCalculator::incorporateFunction(const Function *F) {
// nonconstant values. This will be turned into the constant pool for the
// bytecode writer.
//
if (!IgnoreNamedNodes) { // Assembly writer does not need this!
if (BuildBytecodeInfo) { // Assembly writer does not need this!
SC_DEBUG("Inserting function constants:\n";
for (constant_iterator I = constant_begin(F), E = constant_end(F);
I != E; ++I) {
@ -242,7 +242,7 @@ void SlotCalculator::incorporateFunction(const Function *F) {
getOrCreateSlot(VAN->getArgType());
}
if (!IgnoreNamedNodes) {
if (BuildBytecodeInfo) {
SC_DEBUG("Inserting SymbolTable values:\n");
processSymbolTable(&F->getSymbolTable());
}
@ -327,7 +327,7 @@ int SlotCalculator::insertValue(const Value *D, bool dontIgnore) {
//
if (!dontIgnore) // Don't ignore nonignorables!
if (D->getType() == Type::VoidTy || // Ignore void type nodes
(IgnoreNamedNodes && // Ignore named and constants
(!BuildBytecodeInfo && // Ignore named and constants
(D->hasName() || isa<Constant>(D)) && !isa<Type>(D))) {
SC_DEBUG("ignored value " << *D << "\n");
return -1; // We do need types unconditionally though
@ -398,7 +398,7 @@ int SlotCalculator::doInsertValue(const Value *D) {
// If this is the first value to get inserted into the type plane, make sure
// to insert the implicit null value...
if (Table[Ty].empty() && Ty >= Type::FirstDerivedTyID && !IgnoreNamedNodes) {
if (Table[Ty].empty() && Ty >= Type::FirstDerivedTyID && BuildBytecodeInfo) {
Value *ZeroInitializer = Constant::getNullValue(Typ);
// If we are pushing zeroinit, it will be handled below.