diff options
| -rw-r--r-- | lib/Target/SparcV9/MappingInfo.cpp | 125 |
1 files changed, 86 insertions, 39 deletions
diff --git a/lib/Target/SparcV9/MappingInfo.cpp b/lib/Target/SparcV9/MappingInfo.cpp index b681bfca4e..999b6030fb 100644 --- a/lib/Target/SparcV9/MappingInfo.cpp +++ b/lib/Target/SparcV9/MappingInfo.cpp @@ -1,6 +1,6 @@ //===- MappingInfo.cpp - create LLVM info and output to .s file ---------===// // -// This file contains a FunctionPass called MappingInfo, +// This file contains a FunctionPass called MappingInfoAsmPrinter, // which creates two maps: one between LLVM Instructions and MachineInstrs // (the "LLVM I TO MI MAP"), and another between MachineBasicBlocks and // MachineInstrs (the "BB TO MI MAP"). @@ -40,12 +40,13 @@ #include "llvm/Module.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineCodeForInstruction.h" +#include "Support/StringExtras.h" namespace { - class MappingInfoCollector : public FunctionPass { + class MappingInfoAsmPrinter : public FunctionPass { std::ostream &Out; public: - MappingInfoCollector(std::ostream &out) : Out(out){} + MappingInfoAsmPrinter(std::ostream &out) : Out(out){} const char *getPassName () const { return "Instr. Mapping Info Collector"; } bool runOnFunction(Function &FI); typedef std::map<const MachineInstr*, unsigned> InstructionKey; @@ -60,20 +61,23 @@ namespace { void writeNumber(unsigned X); void selectOutputMap (MappingInfo &m) { currentOutputMap = &m; } void outByte (unsigned char b) { currentOutputMap->outByte (b); } + bool doFinalization (Module &M); }; } -/// getMappingInfoCollector -- Static factory method: returns a new -/// MappingInfoCollector Pass object, which uses OUT as its -/// output stream for assembly output. -Pass *getMappingInfoCollector(std::ostream &out){ - return (new MappingInfoCollector(out)); +/// getMappingInfoAsmPrinterPass - Static factory method: returns a new +/// MappingInfoAsmPrinter Pass object, which uses OUT as its output +/// stream for assembly output. +/// +Pass *getMappingInfoAsmPrinterPass(std::ostream &out){ + return (new MappingInfoAsmPrinter(out)); } -/// runOnFunction -- Builds up the maps for the given function FI and then +/// runOnFunction - Builds up the maps for the given function FI and then /// writes them out as assembly code to the current output stream OUT. /// This is an entry point to the pass, called by the PassManager. -bool MappingInfoCollector::runOnFunction(Function &FI) { +/// +bool MappingInfoAsmPrinter::runOnFunction(Function &FI) { unsigned num = Fkey[&FI]; // Function number for the current function. // Create objects to hold the maps. @@ -91,10 +95,11 @@ bool MappingInfoCollector::runOnFunction(Function &FI) { return false; } -/// writeNumber -- Write out the number X as a sequence of .byte +/// writeNumber - Write out the number X as a sequence of .byte /// directives to the current output stream Out. This method performs a /// run-length encoding of the unsigned integers X that are output. -void MappingInfoCollector::writeNumber(unsigned X) { +/// +void MappingInfoAsmPrinter::writeNumber(unsigned X) { unsigned i=0; do { unsigned tmp = X & 127; @@ -105,13 +110,14 @@ void MappingInfoCollector::writeNumber(unsigned X) { } while(X); } -/// doInitialization -- Assign a number to each Function, as follows: +/// doInitialization - Assign a number to each Function, as follows: /// Functions are numbered starting at 0 at the begin() of each Module. /// Functions which are External (and thus have 0 basic blocks) are not /// inserted into the maps, and are not assigned a number. The side-effect /// of this method is to fill in Fkey to contain the mapping from Functions /// to numbers. (This method is called automatically by the PassManager.) -bool MappingInfoCollector::doInitialization(Module &M) { +/// +bool MappingInfoAsmPrinter::doInitialization(Module &M) { unsigned i = 0; for (Module::iterator FI = M.begin(), FE = M.end(); FI != FE; ++FI) { if (FI->isExternal()) continue; @@ -130,7 +136,8 @@ bool MappingInfoCollector::doInitialization(Module &M) { /// KEY with the mapping of MachineBasicBlocks to numbers. KEY /// is keyed on MachineInstrs, so each MachineBasicBlock is represented /// therein by its first MachineInstr. -void MappingInfoCollector::create_BB_to_MInumber_Key(Function &FI, +/// +void MappingInfoAsmPrinter::create_BB_to_MInumber_Key(Function &FI, InstructionKey &key) { unsigned i = 0; MachineFunction &MF = MachineFunction::get(&FI); @@ -142,14 +149,15 @@ void MappingInfoCollector::create_BB_to_MInumber_Key(Function &FI, } } -/// create_MI_to_number_Key -- Assign a number to each MachineInstr +/// create_MI_to_number_Key - Assign a number to each MachineInstr /// in the given Function with respect to its enclosing MachineBasicBlock, as /// follows: Numberings start at 0 in each MachineBasicBlock. MachineInstrs /// are numbered from begin() to end() in their MachineBasicBlock. Each /// MachineInstr is numbered, then the numbering is incremented by 1. The /// side-effect of this method is to fill in the parameter KEY /// with the mapping from MachineInstrs to numbers. -void MappingInfoCollector::create_MI_to_number_Key(Function &FI, +/// +void MappingInfoAsmPrinter::create_MI_to_number_Key(Function &FI, InstructionKey &key) { MachineFunction &MF = MachineFunction::get(&FI); for (MachineFunction::iterator BI=MF.begin(), BE=MF.end(); BI != BE; ++BI) { @@ -162,9 +170,10 @@ void MappingInfoCollector::create_MI_to_number_Key(Function &FI, } } -/// buildBBMIMap -- Build the BB TO MI MAP for the function FI, +/// buildBBMIMap - Build the BB TO MI MAP for the function FI, /// and save it into the parameter MAP. -void MappingInfoCollector::buildBBMIMap(Function &FI, MappingInfo &Map) { +/// +void MappingInfoAsmPrinter::buildBBMIMap(Function &FI, MappingInfo &Map) { unsigned bb = 0; // First build temporary table used to write out the map. @@ -182,9 +191,10 @@ void MappingInfoCollector::buildBBMIMap(Function &FI, MappingInfo &Map) { } } -/// buildLMIMap -- Build the LLVM I TO MI MAP for the function FI, +/// buildLMIMap - Build the LLVM I TO MI MAP for the function FI, /// and save it into the parameter MAP. -void MappingInfoCollector::buildLMIMap(Function &FI, MappingInfo &Map) { +/// +void MappingInfoAsmPrinter::buildLMIMap(Function &FI, MappingInfo &Map) { unsigned bb = 0; // First build temporary table used to write out the map. InstructionKey MIkey; @@ -214,28 +224,65 @@ void MappingInfo::byteVector::dumpAssembly (std::ostream &Out) { Out << ".byte " << (int)*i << "\n"; } -void MappingInfo::dumpAssembly (std::ostream &Out) { +static void writePrologue (std::ostream &Out, const std::string &comment, + const std::string &symName) { // Prologue: - // Output a comment describing the map. + // Output a comment describing the object. Out << "!" << comment << "\n"; // Switch the current section to .rodata in the assembly output: Out << "\t.section \".rodata\"\n\t.align 8\n"; - // Output a global symbol naming the map: - Out << "\t.global " << symbolPrefix << functionNumber << "\n"; - Out << "\t.type " << symbolPrefix << functionNumber << ",#object\n"; - Out << symbolPrefix << functionNumber << ":\n"; - // Output a word containing the length of the map: - Out << "\t.word .end_" << symbolPrefix << functionNumber << "-" - << symbolPrefix << functionNumber << "\n"; - - // Output the map data itself: - bytes.dumpAssembly (Out); + // Output a global symbol naming the object: + Out << "\t.global " << symName << "\n"; + Out << "\t.type " << symName << ",#object\n"; + Out << symName << ":\n"; +} +static void writeEpilogue (std::ostream &Out, const std::string &symName) { // Epilogue: - // Output a local symbol marking the end of the map: - Out << ".end_" << symbolPrefix << functionNumber << ":\n"; - // Output size directive giving the size of the map: - Out << "\t.size " << symbolPrefix << functionNumber << ", .end_" - << symbolPrefix << functionNumber << "-" << symbolPrefix - << functionNumber << "\n\n"; + // Output a local symbol marking the end of the object: + Out << ".end_" << symName << ":\n"; + // Output size directive giving the size of the object: + Out << "\t.size " << symName << ", .end_" << symName << "-" << symName + << "\n"; +} + +void MappingInfo::dumpAssembly (std::ostream &Out) { + const std::string &name (symbolPrefix + utostr (functionNumber)); + writePrologue (Out, comment, name); + // The LMIMap and BBMIMap are supposed to start with a length word: + Out << "\t.word .end_" << name << "-" << name << "\n"; + bytes.dumpAssembly (Out); + writeEpilogue (Out, name); +} + +/// doFinalization - This method writes out two tables, named +/// FunctionBB and FunctionLI, which map Function numbers (as in +/// doInitialization) to the BBMIMap and LMIMap tables. (This used to +/// be the "FunctionInfo" pass.) +/// +bool MappingInfoAsmPrinter::doFinalization (Module &M) { + unsigned f; + + writePrologue(Out, "FUNCTION TO BB MAP", "FunctionBB"); + f=0; + for(Module::iterator FI = M.begin (), FE = M.end (); FE != FI; ++FI) { + if (FI->isExternal ()) + continue; + Out << "\t.xword BBMIMap" << f << "\n"; + ++f; + } + writeEpilogue(Out, "FunctionBB"); + + writePrologue(Out, "FUNCTION TO LI MAP", "FunctionLI"); + f=0; + for(Module::iterator FI = M.begin (), FE = M.end (); FE != FI; ++FI) { + if (FI->isExternal ()) + continue; + Out << "\t.xword LMIMap" << f << "\n"; + ++f; + } + writeEpilogue(Out, "FunctionLI"); + + return false; } + |