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

Undo the last patch. It slowed down bcwriter by 1.8% but only sped up

Browse Source 
the bc reader by 0.8%. Deemed "not worth it"


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@34169 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Reid Spencer 2007-02-11 00:03:39 +00:00
parent a77600e861
commit b508987e84
1 changed files with 5 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -259,77 +259,14 @@ unsigned SlotCalculator::getOrCreateTypeSlot(const Type *Ty) {
TypeMapType::iterator TyIt = TypeMap.find(Ty);
if (TyIt != TypeMap.end()) return TyIt->second;
// Try to reduce the number of opaque types the reader has to process by
// first inserting any contained types that can't possibly recurse back to
// this type. Making those types concrete before creating the slot number for
// this type means the reader will not have to create OpaqueTy placeholders
// for the this type's sub-types. If the sub-type is a pointer, function
// type, structure with pointer/array/struct, or an array with a pointer
// element type, then we defer it. Otherwise, we can either ignore the
// primitive types (avoid recursion) or create the slot up front.
// Note that this is a trade-off. It slows writing (very slightly) but makes
// reading a little faster, especially for large complex types.
typedef SmallVector<const Type*, 16> DeferVecType;
DeferVecType DeferList;
for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end();
I != E; ++I)
switch ((*I)->getTypeID()) {
default: assert(0 && "Invalid TypeID?");
case Type::VoidTyID:
case Type::FloatTyID:
case Type::DoubleTyID:
case Type::LabelTyID:
// These are all primitive and have been inserted already, just ignore
// to avoid the recursion.
break;
case Type::FunctionTyID:
case Type::PointerTyID:
// Pointers and Functions can recurse to us, defer it.
DeferList.push_back(*I);
break;
case Type::StructTyID:
case Type::PackedStructTyID: {
// if any of the fields of the structure are pointers, structures or
// arrays with pointer element type, defer it.
const StructType *Ty = &cast<StructType>(*(*I));
Type::subtype_iterator EI = Ty->subtype_begin();
Type::subtype_iterator EE = Ty->subtype_end();
for ( ; EI != EE; ++EI) {
const Type* SubTy = *EI;
if (isa<PointerType>(SubTy) || isa<StructType>(SubTy) ||
(isa<ArrayType>(SubTy) &&
isa<PointerType>(cast<ArrayType>(SubTy)->getElementType())))
break;
}
if (EI != EE)
DeferList.push_back(*I);
else
getOrCreateTypeSlot(*I);
break;
}
case Type::ArrayTyID: {
const ArrayType* ArrayTy = &cast<ArrayType>(*(*I));
if (isa<PointerType>(ArrayTy->getElementType())) {
// this might recurse to us, defer it.
DeferList.push_back(*I);
break;
}
/* FALL THROUGH (others are okay) */
}
case Type::OpaqueTyID: // no elements
case Type::IntegerTyID: // no elements
case Type::PackedTyID: // can only have elements of non-recursing types
getOrCreateTypeSlot(*I);
break;
}
// Now we must create the slot for this type by inserting into TypeMap.
// Insert into TypeMap.
unsigned ResultSlot = TypeMap[Ty] = Types.size();
Types.push_back(Ty);
SC_DEBUG(" Inserting type [" << ResultSlot << "] = " << *Ty << "\n" );
// Finally, process any deferred sub-types and create their slots.
for (DeferVecType::iterator I = DeferList.begin(), E = DeferList.end();
// Loop over any contained types in the definition, ensuring they are also
// inserted.
for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end();
I != E; ++I)
getOrCreateTypeSlot(*I);
@ -337,6 +274,7 @@ unsigned SlotCalculator::getOrCreateTypeSlot(const Type *Ty) {
}
void SlotCalculator::incorporateFunction(const Function *F) {
SC_DEBUG("begin processFunction!\n");