X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FSlotCalculator.cpp;h=f0a549e81cc8d6e5a2e8bde0e908ec03ffe8ff79;hb=ce8a14915d2971039b576e03a32e0ba7c421dba7;hp=0ac371cbce7d2e77907a577c03196b3fb5bab350;hpb=d70684f7585a85c4248c1c224059478108741c70;p=oota-llvm.git diff --git a/lib/VMCore/SlotCalculator.cpp b/lib/VMCore/SlotCalculator.cpp index 0ac371cbce7..f0a549e81cc 100644 --- a/lib/VMCore/SlotCalculator.cpp +++ b/lib/VMCore/SlotCalculator.cpp @@ -9,18 +9,15 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Analysis/SlotCalculator.h" +#include "llvm/SlotCalculator.h" #include "llvm/Analysis/ConstantsScanner.h" -#include "llvm/Method.h" -#include "llvm/GlobalVariable.h" #include "llvm/Module.h" -#include "llvm/BasicBlock.h" -#include "llvm/ConstPoolVals.h" #include "llvm/iOther.h" +#include "llvm/Constant.h" #include "llvm/DerivedTypes.h" #include "llvm/SymbolTable.h" -#include "llvm/Support/STLExtras.h" -#include "llvm/CFG.h" +#include "Support/DepthFirstIterator.h" +#include "Support/STLExtras.h" #include #if 0 @@ -45,7 +42,7 @@ SlotCalculator::SlotCalculator(const Module *M, bool IgnoreNamed) { processModule(); } -SlotCalculator::SlotCalculator(const Method *M, bool IgnoreNamed) { +SlotCalculator::SlotCalculator(const Function *M, bool IgnoreNamed) { IgnoreNamedNodes = IgnoreNamed; TheModule = M ? M->getParent() : 0; @@ -60,26 +57,36 @@ SlotCalculator::SlotCalculator(const Method *M, bool IgnoreNamed) { if (TheModule == 0) return; // Empty table... processModule(); // Process module level stuff - incorporateMethod(M); // Start out in incorporated state + incorporateFunction(M); // Start out in incorporated state } -// processModule - Process all of the module level method declarations and +// processModule - Process all of the module level function declarations and // types that are available. // void SlotCalculator::processModule() { SC_DEBUG("begin processModule!\n"); + // Add all of the constants that the global variables might refer to first. + // + for (Module::const_giterator I = TheModule->gbegin(), E = TheModule->gend(); + I != E; ++I) { + if (I->hasInitializer()) + insertValue(I->getInitializer()); + } + // Add all of the global variables to the value table... // - for_each(TheModule->gbegin(), TheModule->gend(), - bind_obj(this, &SlotCalculator::insertValue)); + for(Module::const_giterator I = TheModule->gbegin(), E = TheModule->gend(); + I != E; ++I) + insertValue(I); - // Scavenge the types out of the methods, then add the methods themselves to - // the value table... + // Scavenge the types out of the functions, then add the functions themselves + // to the value table... // - for_each(TheModule->begin(), TheModule->end(), // Insert methods... - bind_obj(this, &SlotCalculator::insertValue)); + for(Module::const_iterator I = TheModule->begin(), E = TheModule->end(); + I != E; ++I) + insertValue(I); // Insert constants that are named at module level into the slot pool so that // the module symbol table can refer to them... @@ -106,41 +113,41 @@ void SlotCalculator::processSymbolTableConstants(const SymbolTable *ST) { for (SymbolTable::const_iterator I = ST->begin(), E = ST->end(); I != E; ++I) for (SymbolTable::type_const_iterator TI = I->second.begin(), TE = I->second.end(); TI != TE; ++TI) - if (TI->second->isConstant()) + if (isa(TI->second)) insertValue(TI->second); } -void SlotCalculator::incorporateMethod(const Method *M) { +void SlotCalculator::incorporateFunction(const Function *M) { assert(ModuleLevel.size() == 0 && "Module already incorporated!"); - SC_DEBUG("begin processMethod!\n"); + SC_DEBUG("begin processFunction!\n"); - // Save the Table state before we process the method... + // Save the Table state before we process the function... for (unsigned i = 0; i < Table.size(); ++i) ModuleLevel.push_back(Table[i].size()); - SC_DEBUG("Inserting method arguments\n"); + SC_DEBUG("Inserting function arguments\n"); - // Iterate over method arguments, adding them to the value table... - for_each(M->getArgumentList().begin(), M->getArgumentList().end(), - bind_obj(this, &SlotCalculator::insertValue)); + // Iterate over function arguments, adding them to the value table... + for(Function::const_aiterator I = M->abegin(), E = M->aend(); I != E; ++I) + insertValue(I); - // Iterate over all of the instructions in the method, looking for constant + // Iterate over all of the instructions in the function, looking for constant // values that are referenced. Add these to the value pools before any // nonconstant values. This will be turned into the constant pool for the // bytecode writer. // if (!IgnoreNamedNodes) { // Assembly writer does not need this! - SC_DEBUG("Inserting method constants:\n"; + SC_DEBUG("Inserting function constants:\n"; for (constant_iterator I = constant_begin(M), E = constant_end(M); I != E; ++I) { - cerr << " " << I->getType()->getDescription() - << " " << I->getStrValue() << endl; + cerr << " " << *I->getType() + << " " << *I << "\n"; }); // Emit all of the constants that are being used by the instructions in the - // method... + // function... for_each(constant_begin(M), constant_end(M), bind_obj(this, &SlotCalculator::insertValue)); @@ -157,13 +164,15 @@ void SlotCalculator::incorporateMethod(const Method *M) { SC_DEBUG("Inserting Labels:\n"); // Iterate over basic blocks, adding them to the value table... - for_each(M->begin(), M->end(), - bind_obj(this, &SlotCalculator::insertValue)); + for (Function::const_iterator I = M->begin(), E = M->end(); I != E; ++I) + insertValue(I); + /* for_each(M->begin(), M->end(), + bind_obj(this, &SlotCalculator::insertValue));*/ SC_DEBUG("Inserting Instructions:\n"); // Add all of the instructions to the type planes... - for_each(M->inst_begin(), M->inst_end(), + for_each(inst_begin(M), inst_end(M), bind_obj(this, &SlotCalculator::insertValue)); if (M->hasSymbolTable() && !IgnoreNamedNodes) { @@ -171,24 +180,25 @@ void SlotCalculator::incorporateMethod(const Method *M) { processSymbolTable(M->getSymbolTable()); } - SC_DEBUG("end processMethod!\n"); + SC_DEBUG("end processFunction!\n"); } -void SlotCalculator::purgeMethod() { +void SlotCalculator::purgeFunction() { assert(ModuleLevel.size() != 0 && "Module not incorporated!"); unsigned NumModuleTypes = ModuleLevel.size(); - SC_DEBUG("begin purgeMethod!\n"); + SC_DEBUG("begin purgeFunction!\n"); // First, remove values from existing type planes for (unsigned i = 0; i < NumModuleTypes; ++i) { - unsigned ModuleSize = ModuleLevel[i]; // Size of plane before method came + unsigned ModuleSize = ModuleLevel[i]; // Size of plane before function came TypePlane &CurPlane = Table[i]; - SC_DEBUG("Processing Plane " << i << " of size " << CurPlane.size() <::iterator NI = NodeMap.find(CurPlane.back()); + //SC_DEBUG(" Removing [" << i << "] Value=" << CurPlane.back() << "\n"); + std::map::iterator NI = + NodeMap.find(CurPlane.back()); assert(NI != NodeMap.end() && "Node not in nodemap?"); NodeMap.erase(NI); // Erase from nodemap CurPlane.pop_back(); // Shrink plane @@ -198,7 +208,7 @@ void SlotCalculator::purgeMethod() { // We don't need this state anymore, free it up. ModuleLevel.clear(); - // Next, remove any type planes defined by the method... + // Next, remove any type planes defined by the function... while (NumModuleTypes != Table.size()) { TypePlane &Plane = Table.back(); SC_DEBUG("Removing Plane " << (Table.size()-1) << " of size " @@ -211,11 +221,11 @@ void SlotCalculator::purgeMethod() { Table.pop_back(); // Nuke the plane, we don't like it. } - SC_DEBUG("end purgeMethod!\n"); + SC_DEBUG("end purgeFunction!\n"); } int SlotCalculator::getValSlot(const Value *D) const { - map::const_iterator I = NodeMap.find(D); + std::map::const_iterator I = NodeMap.find(D); if (I == NodeMap.end()) return -1; return (int)I->second; @@ -223,14 +233,15 @@ int SlotCalculator::getValSlot(const Value *D) const { int SlotCalculator::insertValue(const Value *D) { - if (D->isConstant() || D->isGlobal()) { - const User *U = (const User *)D; + if (isa(D) || isa(D)) { + const User *U = cast(D); // This makes sure that if a constant has uses (for example an array // of const ints), that they are inserted also. Same for global variable // initializers. // - for_each(U->op_begin(), U->op_end(), - bind_obj(this, &SlotCalculator::insertValue)); + for(User::const_op_iterator I = U->op_begin(), E = U->op_end(); I != E; ++I) + if (!isa(*I)) // Don't chain insert global values + insertValue(*I); } int SlotNo = getValSlot(D); // Check to see if it's already in! @@ -239,7 +250,7 @@ int SlotCalculator::insertValue(const Value *D) { } -int SlotCalculator::insertVal(const Value *D, bool dontIgnore = false) { +int SlotCalculator::insertVal(const Value *D, bool dontIgnore) { assert(D && "Can't insert a null value!"); assert(getValSlot(D) == -1 && "Value is already in the table!"); @@ -250,30 +261,45 @@ int SlotCalculator::insertVal(const Value *D, bool dontIgnore = false) { if (!dontIgnore) // Don't ignore nonignorables! if (D->getType() == Type::VoidTy || // Ignore void type nodes (IgnoreNamedNodes && // Ignore named and constants - (D->hasName() || D->isConstant()) && !D->isType())) { + (D->hasName() || isa(D)) && !isa(D))) { SC_DEBUG("ignored value " << D << endl); return -1; // We do need types unconditionally though } // If it's a type, make sure that all subtypes of the type are included... - if (const Type *TheTy = D->castType()) { - SC_DEBUG(" Inserted type: " << TheTy->getDescription() << endl); + if (const Type *TheTy = dyn_cast(D)) { + + // 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: + // + // global { \2 * } { { \2 }* null } + // + int ResultSlot; + if ((ResultSlot = getValSlot(TheTy)) == -1) { + ResultSlot = doInsertVal(TheTy); + SC_DEBUG(" Inserted type: " << TheTy->getDescription() << " slot=" << + ResultSlot << endl); + } // Loop over any contained types in the definition... in reverse depth first // order. This assures that all of the leafs of a type are output before // the type itself is. This also assures us that we will not hit infinite // recursion on recursive types... // - for (cfg::tdf_iterator I = cfg::tdf_begin(TheTy, true), - E = cfg::tdf_end(TheTy); I != E; ++I) + for (df_iterator I = df_begin(TheTy, true), + E = df_end(TheTy); I != E; ++I) if (*I != TheTy) { // If we haven't seen this sub type before, add it to our type table! const Type *SubTy = *I; if (getValSlot(SubTy) == -1) { SC_DEBUG(" Inserting subtype: " << SubTy->getDescription() << endl); - doInsertVal(SubTy); + int Slot = doInsertVal(SubTy); + SC_DEBUG(" Inserted subtype: " << SubTy->getDescription() << + " slot=" << Slot << endl); } } + return ResultSlot; } // Okay, everything is happy, actually insert the silly value now... @@ -289,7 +315,7 @@ int SlotCalculator::doInsertVal(const Value *D) { // Used for debugging DefSlot=-1 assertion... //if (Typ == Type::TypeTy) - // cerr << "Inserting type '" << D->castTypeAsserting()->getDescription() << "'!\n"; + // cerr << "Inserting type '" << cast(D)->getDescription() << "'!\n"; if (Typ->isDerivedType()) { int DefSlot = getValSlot(Typ); @@ -306,11 +332,15 @@ int SlotCalculator::doInsertVal(const Value *D) { if (Table.size() <= Ty) // Make sure we have the type plane allocated... Table.resize(Ty+1, TypePlane()); - SC_DEBUG(" Inserting value [" << Ty << "] = " << D << endl); - // Insert node into table and NodeMap... unsigned DestSlot = NodeMap[D] = Table[Ty].size(); Table[Ty].push_back(D); + SC_DEBUG(" Inserting value [" << Ty << "] = " << D << " slot=" << + DestSlot << " ["); + // G = Global, C = Constant, T = Type, F = Function, o = other + SC_DEBUG((isa(D) ? "G" : (isa(D) ? "C" : + (isa(D) ? "T" : (isa(D) ? "F" : "o"))))); + SC_DEBUG("]\n"); return (int)DestSlot; }