[llvm-commits] CVS: llvm/lib/Bytecode/Writer/SlotCalculator.cpp SlotCalculator.h Writer.cpp
Reid Spencer
reid at x10sys.com
Tue Jan 30 11:37:05 PST 2007
Changes in directory llvm/lib/Bytecode/Writer:
SlotCalculator.cpp updated: 1.80 -> 1.81
SlotCalculator.h updated: 1.25 -> 1.26
Writer.cpp updated: 1.153 -> 1.154
---
Log message:
Bye, Bye Compaction Tables. The benefit compaction tables provides doesn't
outweight its computational costs. This patch removes all compaction
table handling from the bcreader and bcwriter. For the record, here's the
difference betweeen having and not having compaction tables for some tests:
Test With Without Size Chg
Olden/mst 5,602 5,598 +0.1%
viterbi 18,026 17,795 +1.3%
obsequi 162,133 166,663 -2.8%
burg 224,090 228,148 -1.8%
kimwitu++ 4,933,263 5,121,159 -3.8%
176.gcc 8,470,424 9,141,539 -7.3%
It seems that it is more beneficial to larger files, but even on the largest
test case we have (176.gcc) it only amounts ot an I/O saving of 7.3%.
---
Diffs of the changes: (+16 -492)
SlotCalculator.cpp | 379 +----------------------------------------------------
SlotCalculator.h | 51 -------
Writer.cpp | 78 ----------
3 files changed, 16 insertions(+), 492 deletions(-)
Index: llvm/lib/Bytecode/Writer/SlotCalculator.cpp
diff -u llvm/lib/Bytecode/Writer/SlotCalculator.cpp:1.80 llvm/lib/Bytecode/Writer/SlotCalculator.cpp:1.81
--- llvm/lib/Bytecode/Writer/SlotCalculator.cpp:1.80 Fri Jan 12 17:23:08 2007
+++ llvm/lib/Bytecode/Writer/SlotCalculator.cpp Tue Jan 30 13:36:46 2007
@@ -87,38 +87,7 @@
incorporateFunction(M); // Start out in incorporated state
}
-unsigned SlotCalculator::getGlobalSlot(const Value *V) const {
- assert(!CompactionTable.empty() &&
- "This method can only be used when compaction is enabled!");
- std::map<const Value*, unsigned>::const_iterator I = NodeMap.find(V);
- assert(I != NodeMap.end() && "Didn't find global slot entry!");
- return I->second;
-}
-
-unsigned SlotCalculator::getGlobalSlot(const Type* T) const {
- std::map<const Type*, unsigned>::const_iterator I = TypeMap.find(T);
- assert(I != TypeMap.end() && "Didn't find global slot entry!");
- return I->second;
-}
-
SlotCalculator::TypePlane &SlotCalculator::getPlane(unsigned Plane) {
- if (CompactionTable.empty()) { // No compaction table active?
- // fall out
- } else if (!CompactionTable[Plane].empty()) { // Compaction table active.
- assert(Plane < CompactionTable.size());
- return CompactionTable[Plane];
- } else {
- // Final case: compaction table active, but this plane is not
- // compactified. If the type plane is compactified, unmap back to the
- // global type plane corresponding to "Plane".
- if (!CompactionTypes.empty()) {
- const Type *Ty = CompactionTypes[Plane];
- TypeMapType::iterator It = TypeMap.find(Ty);
- assert(It != TypeMap.end() && "Type not in global constant map?");
- Plane = It->second;
- }
- }
-
// Okay we are just returning an entry out of the main Table. Make sure the
// plane exists and return it.
if (Plane >= Table.size())
@@ -284,10 +253,6 @@
SC_DEBUG("begin processFunction!\n");
- // If we emitted all of the function constants, build a compaction table.
- if (ModuleContainsAllFunctionConstants)
- buildCompactionTable(F);
-
// Update the ModuleLevel entries to be accurate.
ModuleLevel.resize(getNumPlanes());
for (unsigned i = 0, e = getNumPlanes(); i != e; ++i)
@@ -330,11 +295,6 @@
}
}
- // If we are building a compaction table, prune out planes that do not benefit
- // from being compactified.
- if (!CompactionTable.empty())
- pruneCompactionTable();
-
SC_DEBUG("end processFunction!\n");
}
@@ -345,10 +305,6 @@
SC_DEBUG("begin purgeFunction!\n");
- // First, free the compaction map if used.
- CompactionNodeMap.clear();
- CompactionTypeMap.clear();
-
// Next, remove values from existing type planes
for (unsigned i = 0; i != NumModuleTypes; ++i) {
// Size of plane before function came
@@ -371,23 +327,18 @@
ModuleTypeLevel = 0;
// Finally, remove any type planes defined by the function...
- CompactionTypes.clear();
- if (!CompactionTable.empty()) {
- CompactionTable.clear();
- } else {
- while (Table.size() > NumModuleTypes) {
- TypePlane &Plane = Table.back();
- SC_DEBUG("Removing Plane " << (Table.size()-1) << " of size "
- << Plane.size() << "\n");
- while (Plane.size()) {
- assert(!isa<GlobalValue>(Plane.back()) &&
- "Functions cannot define globals!");
- NodeMap.erase(Plane.back()); // Erase from nodemap
- Plane.pop_back(); // Shrink plane
- }
-
- Table.pop_back(); // Nuke the plane, we don't like it.
+ while (Table.size() > NumModuleTypes) {
+ TypePlane &Plane = Table.back();
+ SC_DEBUG("Removing Plane " << (Table.size()-1) << " of size "
+ << Plane.size() << "\n");
+ while (Plane.size()) {
+ assert(!isa<GlobalValue>(Plane.back()) &&
+ "Functions cannot define globals!");
+ NodeMap.erase(Plane.back()); // Erase from nodemap
+ Plane.pop_back(); // Shrink plane
}
+
+ Table.pop_back(); // Nuke the plane, we don't like it.
}
SC_DEBUG("end purgeFunction!\n");
@@ -397,278 +348,8 @@
return Ty != Type::LabelTy && Ty != Type::VoidTy && !isa<OpaqueType>(Ty);
}
-/// getOrCreateCompactionTableSlot - This method is used to build up the initial
-/// approximation of the compaction table.
-unsigned SlotCalculator::getOrCreateCompactionTableSlot(const Value *V) {
- std::map<const Value*, unsigned>::iterator I =
- CompactionNodeMap.lower_bound(V);
- if (I != CompactionNodeMap.end() && I->first == V)
- return I->second; // Already exists?
-
- // Make sure the type is in the table.
- unsigned Ty;
- if (!CompactionTypes.empty())
- Ty = getOrCreateCompactionTableSlot(V->getType());
- else // If the type plane was decompactified, use the global plane ID
- Ty = getSlot(V->getType());
- if (CompactionTable.size() <= Ty)
- CompactionTable.resize(Ty+1);
-
- TypePlane &TyPlane = CompactionTable[Ty];
-
- // Make sure to insert the null entry if the thing we are inserting is not a
- // null constant.
- if (TyPlane.empty() && hasNullValue(V->getType())) {
- Value *ZeroInitializer = Constant::getNullValue(V->getType());
- if (V != ZeroInitializer) {
- TyPlane.push_back(ZeroInitializer);
- CompactionNodeMap[ZeroInitializer] = 0;
- }
- }
-
- unsigned SlotNo = TyPlane.size();
- TyPlane.push_back(V);
- CompactionNodeMap.insert(std::make_pair(V, SlotNo));
- return SlotNo;
-}
-
-/// getOrCreateCompactionTableSlot - This method is used to build up the initial
-/// approximation of the compaction table.
-unsigned SlotCalculator::getOrCreateCompactionTableSlot(const Type *T) {
- CompactionTypeMapType::iterator I = CompactionTypeMap.lower_bound(T);
- if (I != CompactionTypeMap.end() && I->first == T)
- return I->second; // Already exists?
-
- unsigned SlotNo = CompactionTypes.size();
- SC_DEBUG("Inserting Compaction Type #" << SlotNo << ": " << *T << "\n");
- CompactionTypes.push_back(T);
- CompactionTypeMap.insert(I, std::make_pair(T, SlotNo));
- return SlotNo;
-}
-
-/// buildCompactionTable - Since all of the function constants and types are
-/// stored in the module-level constant table, we don't need to emit a function
-/// constant table. Also due to this, the indices for various constants and
-/// types might be very large in large programs. In order to avoid blowing up
-/// the size of instructions in the bytecode encoding, we build a compaction
-/// table, which defines a mapping from function-local identifiers to global
-/// identifiers.
-void SlotCalculator::buildCompactionTable(const Function *F) {
- assert(CompactionNodeMap.empty() && "Compaction table already built!");
- assert(CompactionTypeMap.empty() && "Compaction types already built!");
- // First step, insert the primitive types.
- CompactionTable.resize(Type::LastPrimitiveTyID+1);
- for (unsigned i = 0; i <= Type::LastPrimitiveTyID; ++i) {
- const Type *PrimTy = Type::getPrimitiveType((Type::TypeID)i);
- CompactionTypes.push_back(PrimTy);
- CompactionTypeMap[PrimTy] = i;
- }
- CompactionTypeMap[Type::Int1Ty] = CompactionTypes.size();
- CompactionTypes.push_back(Type::Int1Ty);
- CompactionTypeMap[Type::Int8Ty] = CompactionTypes.size();
- CompactionTypes.push_back(Type::Int8Ty);
- CompactionTypeMap[Type::Int16Ty] = CompactionTypes.size();
- CompactionTypes.push_back(Type::Int16Ty);
- CompactionTypeMap[Type::Int32Ty] = CompactionTypes.size();
- CompactionTypes.push_back(Type::Int32Ty);
- CompactionTypeMap[Type::Int64Ty] = CompactionTypes.size();
- CompactionTypes.push_back(Type::Int64Ty);
-
- // Next, include any types used by function arguments.
- for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
- I != E; ++I)
- getOrCreateCompactionTableSlot(I->getType());
-
- // Next, find all of the types and values that are referred to by the
- // instructions in the function.
- for (const_inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
- getOrCreateCompactionTableSlot(I->getType());
- for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op)
- if (isa<Constant>(I->getOperand(op)) || isa<InlineAsm>(I->getOperand(op)))
- getOrCreateCompactionTableSlot(I->getOperand(op));
- }
-
- // Now do the constants and global values
- const SymbolTable &ST = F->getValueSymbolTable();
- for (SymbolTable::plane_const_iterator PI = ST.plane_begin(),
- PE = ST.plane_end(); PI != PE; ++PI)
- for (SymbolTable::value_const_iterator VI = PI->second.begin(),
- VE = PI->second.end(); VI != VE; ++VI)
- if (isa<Constant>(VI->second) && !isa<GlobalValue>(VI->second))
- getOrCreateCompactionTableSlot(VI->second);
-
- // Now that we have all of the values in the table, and know what types are
- // referenced, make sure that there is at least the zero initializer in any
- // used type plane. Since the type was used, we will be emitting instructions
- // to the plane even if there are no constants in it.
- CompactionTable.resize(CompactionTypes.size());
- for (unsigned i = 0, e = CompactionTable.size(); i != e; ++i)
- if (CompactionTable[i].empty() && (i != Type::VoidTyID) &&
- i != Type::LabelTyID) {
- const Type *Ty = CompactionTypes[i];
- SC_DEBUG("Getting Null Value #" << i << " for Type " << *Ty << "\n");
- assert(Ty->getTypeID() != Type::VoidTyID);
- assert(Ty->getTypeID() != Type::LabelTyID);
- getOrCreateCompactionTableSlot(Constant::getNullValue(Ty));
- }
-
- // Okay, now at this point, we have a legal compaction table. Since we want
- // to emit the smallest possible binaries, do not compactify the type plane if
- // it will not save us anything. Because we have not yet incorporated the
- // function body itself yet, we don't know whether or not it's a good idea to
- // compactify other planes. We will defer this decision until later.
- TypeList &GlobalTypes = Types;
-
- // All of the values types will be scrunched to the start of the types plane
- // of the global table. Figure out just how many there are.
- assert(!GlobalTypes.empty() && "No global types???");
- unsigned NumFCTypes = GlobalTypes.size()-1;
- while (!GlobalTypes[NumFCTypes]->isFirstClassType())
- --NumFCTypes;
-
- // If there are fewer that 64 types, no instructions will be exploded due to
- // the size of the type operands. Thus there is no need to compactify types.
- // Also, if the compaction table contains most of the entries in the global
- // table, there really is no reason to compactify either.
- if (NumFCTypes < 64) {
- // Decompactifying types is tricky, because we have to move type planes all
- // over the place. At least we don't need to worry about updating the
- // CompactionNodeMap for non-types though.
- std::vector<TypePlane> TmpCompactionTable;
- std::swap(CompactionTable, TmpCompactionTable);
- TypeList TmpTypes;
- std::swap(TmpTypes, CompactionTypes);
-
- // Move each plane back over to the uncompactified plane
- while (!TmpTypes.empty()) {
- const Type *Ty = TmpTypes.back();
- TmpTypes.pop_back();
- CompactionTypeMap.erase(Ty); // Decompactify type!
-
- // Find the global slot number for this type.
- int TySlot = getSlot(Ty);
- assert(TySlot != -1 && "Type doesn't exist in global table?");
-
- // Now we know where to put the compaction table plane.
- if (CompactionTable.size() <= unsigned(TySlot))
- CompactionTable.resize(TySlot+1);
- // Move the plane back into the compaction table.
- std::swap(CompactionTable[TySlot], TmpCompactionTable[TmpTypes.size()]);
-
- // And remove the empty plane we just moved in.
- TmpCompactionTable.pop_back();
- }
- }
-}
-
-
-/// pruneCompactionTable - Once the entire function being processed has been
-/// incorporated into the current compaction table, look over the compaction
-/// table and check to see if there are any values whose compaction will not
-/// save us any space in the bytecode file. If compactifying these values
-/// serves no purpose, then we might as well not even emit the compactification
-/// information to the bytecode file, saving a bit more space.
-///
-/// Note that the type plane has already been compactified if possible.
-///
-void SlotCalculator::pruneCompactionTable() {
- TypeList &TyPlane = CompactionTypes;
- for (unsigned ctp = 0, e = CompactionTable.size(); ctp != e; ++ctp)
- if (!CompactionTable[ctp].empty()) {
- TypePlane &CPlane = CompactionTable[ctp];
- unsigned GlobalSlot = ctp;
- if (!TyPlane.empty())
- GlobalSlot = getGlobalSlot(TyPlane[ctp]);
-
- if (GlobalSlot >= Table.size())
- Table.resize(GlobalSlot+1);
- TypePlane &GPlane = Table[GlobalSlot];
-
- unsigned ModLevel = getModuleLevel(ctp);
- unsigned NumFunctionObjs = CPlane.size()-ModLevel;
-
- // If the maximum index required if all entries in this plane were merged
- // into the global plane is less than 64, go ahead and eliminate the
- // plane.
- bool PrunePlane = GPlane.size() + NumFunctionObjs < 64;
-
- // If there are no function-local values defined, and the maximum
- // referenced global entry is less than 64, we don't need to compactify.
- if (!PrunePlane && NumFunctionObjs == 0) {
- unsigned MaxIdx = 0;
- for (unsigned i = 0; i != ModLevel; ++i) {
- unsigned Idx = NodeMap[CPlane[i]];
- if (Idx > MaxIdx) MaxIdx = Idx;
- }
- PrunePlane = MaxIdx < 64;
- }
-
- // Ok, finally, if we decided to prune this plane out of the compaction
- // table, do so now.
- if (PrunePlane) {
- TypePlane OldPlane;
- std::swap(OldPlane, CPlane);
-
- // Loop over the function local objects, relocating them to the global
- // table plane.
- for (unsigned i = ModLevel, e = OldPlane.size(); i != e; ++i) {
- const Value *V = OldPlane[i];
- CompactionNodeMap.erase(V);
- assert(NodeMap.count(V) == 0 && "Value already in table??");
- getOrCreateSlot(V);
- }
-
- // For compactified global values, just remove them from the compaction
- // node map.
- for (unsigned i = 0; i != ModLevel; ++i)
- CompactionNodeMap.erase(OldPlane[i]);
-
- // Update the new modulelevel for this plane.
- assert(ctp < ModuleLevel.size() && "Cannot set modulelevel!");
- ModuleLevel[ctp] = GPlane.size()-NumFunctionObjs;
- assert((int)ModuleLevel[ctp] >= 0 && "Bad computation!");
- }
- }
-}
-
-/// Determine if the compaction table is actually empty. Because the
-/// compaction table always includes the primitive type planes, we
-/// can't just check getCompactionTable().size() because it will never
-/// be zero. Furthermore, the ModuleLevel factors into whether a given
-/// plane is empty or not. This function does the necessary computation
-/// to determine if its actually empty.
-bool SlotCalculator::CompactionTableIsEmpty() const {
- // Check a degenerate case, just in case.
- if (CompactionTable.empty())
- return true;
-
- // Check each plane
- for (unsigned i = 0, e = CompactionTable.size(); i < e; ++i) {
- // If the plane is not empty
- if (!CompactionTable[i].empty()) {
- // If the module level is non-zero then at least the
- // first element of the plane is valid and therefore not empty.
- unsigned End = getModuleLevel(i);
- if (End != 0)
- return false;
- }
- }
- // All the compaction table planes are empty so the table is
- // considered empty too.
- return true;
-}
int SlotCalculator::getSlot(const Value *V) const {
- // If there is a CompactionTable active...
- if (!CompactionNodeMap.empty()) {
- std::map<const Value*, unsigned>::const_iterator I =
- CompactionNodeMap.find(V);
- if (I != CompactionNodeMap.end())
- return (int)I->second;
- // Otherwise, if it's not in the compaction table, it must be in a
- // non-compactified plane.
- }
-
std::map<const Value*, unsigned>::const_iterator I = NodeMap.find(V);
if (I != NodeMap.end())
return (int)I->second;
@@ -677,16 +358,6 @@
}
int SlotCalculator::getSlot(const Type*T) const {
- // If there is a CompactionTable active...
- if (!CompactionTypeMap.empty()) {
- std::map<const Type*, unsigned>::const_iterator I =
- CompactionTypeMap.find(T);
- if (I != CompactionTypeMap.end())
- return (int)I->second;
- // Otherwise, if it's not in the compaction table, it must be in a
- // non-compactified plane.
- }
-
std::map<const Type*, unsigned>::const_iterator I = TypeMap.find(T);
if (I != TypeMap.end())
return (int)I->second;
@@ -705,8 +376,6 @@
if (!isa<GlobalValue>(V)) // Initializers for globals are handled explicitly
if (const Constant *C = dyn_cast<Constant>(V)) {
- assert(CompactionNodeMap.empty() &&
- "All needed constants should be in the compaction map already!");
// Do not index the characters that make up constant strings. We emit
// constant strings as special entities that don't require their
@@ -741,20 +410,6 @@
assert(D && "Can't insert a null value!");
assert(getSlot(D) == -1 && "Value is already in the table!");
- // If we are building a compaction map, and if this plane is being compacted,
- // insert the value into the compaction map, not into the global map.
- if (!CompactionNodeMap.empty()) {
- if (D->getType() == Type::VoidTy) return -1; // Do not insert void values
- assert(!isa<Constant>(D) &&
- "Types, constants, and globals should be in global table!");
-
- int Plane = getSlot(D->getType());
- assert(Plane != -1 && CompactionTable.size() > (unsigned)Plane &&
- "Didn't find value type!");
- if (!CompactionTable[Plane].empty())
- return getOrCreateCompactionTableSlot(D);
- }
-
// If this node does not contribute to a plane, or if the node has a
// name and we don't want names, then ignore the silly node... Note that types
// do need slot numbers so that we can keep track of where other values land.
@@ -773,12 +428,6 @@
assert(Ty && "Can't insert a null type!");
assert(getSlot(Ty) == -1 && "Type is already in the table!");
- // If we are building a compaction map, and if this plane is being compacted,
- // insert the value into the compaction map, not into the global map.
- if (!CompactionTypeMap.empty()) {
- getOrCreateCompactionTableSlot(Ty);
- }
-
// Insert the current type before any subtypes. This is important because
// recursive types elements are inserted in a bottom up order. Changing
// this here can break things. For example:
@@ -818,11 +467,7 @@
// llvm_cerr << "Inserting type '"<<cast<Type>(D)->getDescription() <<"'!\n";
if (Typ->isDerivedType()) {
- int ValSlot;
- if (CompactionTable.empty())
- ValSlot = getSlot(Typ);
- else
- ValSlot = getGlobalSlot(Typ);
+ int ValSlot = getSlot(Typ);
if (ValSlot == -1) { // Have we already entered this type?
// Nope, this is the first we have seen the type, process it.
ValSlot = insertType(Typ, true);
Index: llvm/lib/Bytecode/Writer/SlotCalculator.h
diff -u llvm/lib/Bytecode/Writer/SlotCalculator.h:1.25 llvm/lib/Bytecode/Writer/SlotCalculator.h:1.26
--- llvm/lib/Bytecode/Writer/SlotCalculator.h:1.25 Fri Jan 12 01:05:13 2007
+++ llvm/lib/Bytecode/Writer/SlotCalculator.h Tue Jan 30 13:36:46 2007
@@ -61,17 +61,6 @@
/// is only possible if building information for a bytecode file.
bool ModuleContainsAllFunctionConstants;
- /// CompactionTable/NodeMap - When function compaction has been performed,
- /// these entries provide a compacted view of the namespace needed to emit
- /// instructions in a function body. The 'getSlot()' method automatically
- /// returns these entries if applicable, or the global entries if not.
- std::vector<TypePlane> CompactionTable;
- TypeList CompactionTypes;
- typedef std::map<const Value*, unsigned> CompactionNodeMapType;
- CompactionNodeMapType CompactionNodeMap;
- typedef std::map<const Type*, unsigned> CompactionTypeMapType;
- CompactionTypeMapType CompactionTypeMap;
-
SlotCalculator(const SlotCalculator &); // DO NOT IMPLEMENT
void operator=(const SlotCalculator &); // DO NOT IMPLEMENT
public:
@@ -85,24 +74,8 @@
int getSlot(const Value *V) const;
int getSlot(const Type* T) const;
- /// getGlobalSlot - Return a slot number from the global table. This can only
- /// be used when a compaction table is active.
- unsigned getGlobalSlot(const Value *V) const;
- unsigned getGlobalSlot(const Type *V) const;
-
- inline unsigned getNumPlanes() const {
- if (CompactionTable.empty())
- return Table.size();
- else
- return CompactionTable.size();
- }
-
- inline unsigned getNumTypes() const {
- if (CompactionTypes.empty())
- return Types.size();
- else
- return CompactionTypes.size();
- }
+ inline unsigned getNumPlanes() const { return Table.size(); }
+ inline unsigned getNumTypes() const { return Types.size(); }
inline unsigned getModuleLevel(unsigned Plane) const {
return Plane < ModuleLevel.size() ? ModuleLevel[Plane] : 0;
@@ -114,11 +87,7 @@
}
TypePlane &getPlane(unsigned Plane);
- TypeList& getTypes() {
- if (!CompactionTypes.empty())
- return CompactionTypes;
- return Types;
- }
+ TypeList& getTypes() { return Types; }
/// incorporateFunction/purgeFunction - If you'd like to deal with a function,
/// use these two methods to get its data into the SlotCalculator!
@@ -133,15 +102,6 @@
string_iterator string_begin() const { return ConstantStrings.begin(); }
string_iterator string_end() const { return ConstantStrings.end(); }
- const std::vector<TypePlane> &getCompactionTable() const {
- return CompactionTable;
- }
-
- const TypeList& getCompactionTypes() const { return CompactionTypes; }
-
- /// @brief Determine if the compaction table (not types) is empty
- bool CompactionTableIsEmpty() const;
-
private:
// getOrCreateSlot - Values can be crammed into here at will... if
// they haven't been inserted already, they get inserted, otherwise
@@ -173,11 +133,6 @@
void processValueSymbolTable(const SymbolTable *ST);
void processSymbolTableConstants(const SymbolTable *ST);
- void buildCompactionTable(const Function *F);
- unsigned getOrCreateCompactionTableSlot(const Value *V);
- unsigned getOrCreateCompactionTableSlot(const Type *V);
- void pruneCompactionTable();
-
// insertPrimitives - helper for constructors to insert primitive types.
void insertPrimitives();
};
Index: llvm/lib/Bytecode/Writer/Writer.cpp
diff -u llvm/lib/Bytecode/Writer/Writer.cpp:1.153 llvm/lib/Bytecode/Writer/Writer.cpp:1.154
--- llvm/lib/Bytecode/Writer/Writer.cpp:1.153 Fri Jan 26 02:10:24 2007
+++ llvm/lib/Bytecode/Writer/Writer.cpp Tue Jan 30 13:36:46 2007
@@ -1112,14 +1112,7 @@
// Get slot information about the function...
Table.incorporateFunction(F);
- if (Table.getCompactionTable().empty()) {
- // Output information about the constants in the function if the compaction
- // table is not being used.
- outputConstants(true);
- } else {
- // Otherwise, emit the compaction table.
- outputCompactionTable();
- }
+ outputConstants(true);
// Output all of the instructions in the body of the function
outputInstructions(F);
@@ -1130,75 +1123,6 @@
Table.purgeFunction();
}
-void BytecodeWriter::outputCompactionTablePlane(unsigned PlaneNo,
- const std::vector<const Value*> &Plane,
- unsigned StartNo) {
- unsigned End = Table.getModuleLevel(PlaneNo);
- if (Plane.empty() || StartNo == End || End == 0) return; // Nothing to emit
- assert(StartNo < End && "Cannot emit negative range!");
- assert(StartNo < Plane.size() && End <= Plane.size());
-
- // Do not emit the null initializer!
- ++StartNo;
-
- // Figure out which encoding to use. By far the most common case we have is
- // to emit 0-2 entries in a compaction table plane.
- switch (End-StartNo) {
- case 0: // Avoid emitting two vbr's if possible.
- case 1:
- case 2:
- output_vbr((PlaneNo << 2) | End-StartNo);
- break;
- default:
- // Output the number of things.
- output_vbr((unsigned(End-StartNo) << 2) | 3);
- output_typeid(PlaneNo); // Emit the type plane this is
- break;
- }
-
- for (unsigned i = StartNo; i != End; ++i)
- output_vbr(Table.getGlobalSlot(Plane[i]));
-}
-
-void BytecodeWriter::outputCompactionTypes(unsigned StartNo) {
- // Get the compaction type table from the slot calculator
- const std::vector<const Type*> &CTypes = Table.getCompactionTypes();
-
- // The compaction types may have been uncompactified back to the
- // global types. If so, we just write an empty table
- if (CTypes.size() == 0) {
- output_vbr(0U);
- return;
- }
-
- assert(CTypes.size() >= StartNo && "Invalid compaction types start index");
-
- // Determine how many types to write
- unsigned NumTypes = CTypes.size() - StartNo;
-
- // Output the number of types.
- output_vbr(NumTypes);
-
- for (unsigned i = StartNo; i < StartNo+NumTypes; ++i)
- output_typeid(Table.getGlobalSlot(CTypes[i]));
-}
-
-void BytecodeWriter::outputCompactionTable() {
- // Avoid writing the compaction table at all if there is no content.
- if (Table.getCompactionTypes().size() >= Type::FirstDerivedTyID ||
- (!Table.CompactionTableIsEmpty())) {
- BytecodeBlock CTB(BytecodeFormat::CompactionTableBlockID, *this,
- true/*ElideIfEmpty*/);
- const std::vector<std::vector<const Value*> > &CT =
- Table.getCompactionTable();
-
- // First things first, emit the type compaction table if there is one.
- outputCompactionTypes(Type::FirstDerivedTyID);
-
- for (unsigned i = 0, e = CT.size(); i != e; ++i)
- outputCompactionTablePlane(i, CT[i], 0);
- }
-}
void BytecodeWriter::outputTypeSymbolTable(const TypeSymbolTable &TST) {
// Do not output the block for an empty symbol table, it just wastes
More information about the llvm-commits
mailing list