lib/Target/SparcV9/MappingInfo.cpp

   1 //===- MappingInfo.cpp - create LLVM info and output to .s file -----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains a FunctionPass called MappingInfoAsmPrinter,
  11 // which creates two maps: one between LLVM Instructions and MachineInstrs
  12 // (the "LLVM I TO MI MAP"), and another between MachineBasicBlocks and
  13 // MachineInstrs (the "BB TO MI MAP").
  14 //
  15 // As a side effect, it outputs this information as .byte directives to
  16 // the assembly file. The output is designed to survive the SPARC assembler,
  17 // in order that the Reoptimizer may read it in from memory later when the
  18 // binary is loaded. Therefore, it may contain some hidden SPARC-architecture
  19 // dependencies. Currently this question is purely theoretical as the
  20 // Reoptimizer works only on the SPARC.
  21 //
  22 // The LLVM I TO MI MAP consists of a set of information for each
  23 // BasicBlock in a Function, ordered from begin() to end(). The information
  24 // for a BasicBlock consists of
  25 //  1) its (0-based) index in the Function,
  26 //  2) the number of LLVM Instructions it contains, and
  27 //  3) information for each Instruction, in sequence from the begin()
  28 //     to the end() of the BasicBlock. The information for an Instruction
  29 //     consists of
  30 //     1) its (0-based) index in the BasicBlock,
  31 //     2) the number of MachineInstrs that correspond to that Instruction
  32 //        (as reported by MachineCodeForInstruction), and
  33 //     3) the MachineInstr number calculated by create_MI_to_number_Key,
  34 //        for each of the MachineInstrs that correspond to that Instruction.
  35 //
  36 // The BB TO MI MAP consists of a three-element tuple for each
  37 // MachineBasicBlock in a function, ordered from begin() to end() of
  38 // its MachineFunction: first, the index of the MachineBasicBlock in the
  39 // function; second, the number of the MachineBasicBlock in the function
  40 // as computed by create_BB_to_MInumber_Key; and third, the number of
  41 // MachineInstrs in the MachineBasicBlock.
  42 //
  43 //===--------------------------------------------------------------------===//
  44
  45 #include "MappingInfo.h"
  46 #include "llvm/Pass.h"
  47 #include "llvm/Module.h"
  48 #include "llvm/CodeGen/MachineFunction.h"
  49 #include "MachineCodeForInstruction.h"
  50 #include "llvm/ADT/StringExtras.h"
  51
  52 namespace llvm {
  53
  54 namespace {
  55   class MappingInfoAsmPrinter : public FunctionPass {
  56     std::ostream &Out;
  57   public:
  58     MappingInfoAsmPrinter(std::ostream &out) : Out(out){}
  59     const char *getPassName () const { return "Instr. Mapping Info Collector"; }
  60     bool runOnFunction(Function &FI);
  61     typedef std::map<const MachineInstr*, unsigned> InstructionKey;
  62   private:
  63     MappingInfo *currentOutputMap;
  64     std::map<Function *, unsigned> Fkey; // Function # for all functions.
  65     bool doInitialization(Module &M);
  66     void create_BB_to_MInumber_Key(Function &FI, InstructionKey &key);
  67     void create_MI_to_number_Key(Function &FI, InstructionKey &key);
  68     void buildBBMIMap (Function &FI, MappingInfo &Map);
  69     void buildLMIMap (Function &FI, MappingInfo &Map);
  70     void writeNumber(unsigned X);
  71     void selectOutputMap (MappingInfo &m) { currentOutputMap = &m; }
  72     void outByte (unsigned char b) { currentOutputMap->outByte (b); }
  73     bool doFinalization (Module &M);
  74   };
  75 }
  76
  77 /// getMappingInfoAsmPrinterPass - Static factory method: returns a new
  78 /// MappingInfoAsmPrinter Pass object, which uses OUT as its output
  79 /// stream for assembly output.
  80 ///
  81 Pass *getMappingInfoAsmPrinterPass(std::ostream &out){
  82   return (new MappingInfoAsmPrinter(out));
  83 }
  84
  85 /// runOnFunction - Builds up the maps for the given function FI and then
  86 /// writes them out as assembly code to the current output stream OUT.
  87 /// This is an entry point to the pass, called by the PassManager.
  88 ///
  89 bool MappingInfoAsmPrinter::runOnFunction(Function &FI) {
  90   unsigned num = Fkey[&FI]; // Function number for the current function.
  91
  92   // Create objects to hold the maps.
  93   MappingInfo LMIMap ("LLVM I TO MI MAP", "LMIMap", num);
  94   MappingInfo BBMIMap ("BB TO MI MAP", "BBMIMap", num);
  95
  96   // Now, build the maps.
  97   buildLMIMap (FI, LMIMap);
  98   buildBBMIMap (FI, BBMIMap);
  99
 100   // Now, write out the maps.
 101   LMIMap.dumpAssembly (Out);
 102   BBMIMap.dumpAssembly (Out);
 103
 104   return false;
 105 }
 106
 107 /// writeNumber - Write out the number X as a sequence of .byte
 108 /// directives to the current output stream Out. This method performs a
 109 /// run-length encoding of the unsigned integers X that are output.
 110 ///
 111 void MappingInfoAsmPrinter::writeNumber(unsigned X) {
 112   unsigned i=0;
 113   do {
 114     unsigned tmp = X & 127;
 115     X >>= 7;
 116     if (X) tmp |= 128;
 117     outByte (tmp);
 118     ++i;
 119   } while(X);
 120 }
 121
 122 /// doInitialization - Assign a number to each Function, as follows:
 123 /// Functions are numbered starting at 0 at the begin() of each Module.
 124 /// Functions which are External (and thus have 0 basic blocks) are not
 125 /// inserted into the maps, and are not assigned a number.  The side-effect
 126 /// of this method is to fill in Fkey to contain the mapping from Functions
 127 /// to numbers. (This method is called automatically by the PassManager.)
 128 ///
 129 bool MappingInfoAsmPrinter::doInitialization(Module &M) {
 130   unsigned i = 0;
 131   for (Module::iterator FI = M.begin(), FE = M.end(); FI != FE; ++FI) {
 132     if (FI->isExternal()) continue;
 133     Fkey[FI] = i;
 134     ++i;
 135   }
 136   return false; // Success.
 137 }
 138
 139 /// create_BB_to_MInumber_Key -- Assign a number to each MachineBasicBlock
 140 /// in the given Function, as follows: Numbering starts at zero in each
 141 /// Function. MachineBasicBlocks are numbered from begin() to end()
 142 /// in the Function's corresponding MachineFunction. Each successive
 143 /// MachineBasicBlock increments the numbering by the number of instructions
 144 /// it contains. The side-effect of this method is to fill in the parameter
 145 /// KEY with the mapping of MachineBasicBlocks to numbers. KEY
 146 /// is keyed on MachineInstrs, so each MachineBasicBlock is represented
 147 /// therein by its first MachineInstr.
 148 ///
 149 void MappingInfoAsmPrinter::create_BB_to_MInumber_Key(Function &FI,
 150                                                      InstructionKey &key) {
 151   unsigned i = 0;
 152   MachineFunction &MF = MachineFunction::get(&FI);
 153   for (MachineFunction::iterator BI = MF.begin(), BE = MF.end();
 154        BI != BE; ++BI) {
 155     MachineBasicBlock &miBB = *BI;
 156     key[&miBB.front()] = i;
 157     i = i+(miBB.size());
 158   }
 159 }
 160
 161 /// create_MI_to_number_Key - Assign a number to each MachineInstr
 162 /// in the given Function with respect to its enclosing MachineBasicBlock, as
 163 /// follows: Numberings start at 0 in each MachineBasicBlock. MachineInstrs
 164 /// are numbered from begin() to end() in their MachineBasicBlock. Each
 165 /// MachineInstr is numbered, then the numbering is incremented by 1. The
 166 /// side-effect of this method is to fill in the parameter KEY
 167 /// with the mapping from MachineInstrs to numbers.
 168 ///
 169 void MappingInfoAsmPrinter::create_MI_to_number_Key(Function &FI,
 170                                                    InstructionKey &key) {
 171   MachineFunction &MF = MachineFunction::get(&FI);
 172   for (MachineFunction::iterator BI=MF.begin(), BE=MF.end(); BI != BE; ++BI) {
 173     MachineBasicBlock &miBB = *BI;
 174     unsigned j = 0;
 175     for(MachineBasicBlock::iterator miI = miBB.begin(), miE = miBB.end();
 176         miI != miE; ++miI, ++j) {
 177       key[miI] = j;
 178     }
 179   }
 180 }
 181
 182 /// buildBBMIMap - Build the BB TO MI MAP for the function FI,
 183 /// and save it into the parameter MAP.
 184 ///
 185 void MappingInfoAsmPrinter::buildBBMIMap(Function &FI, MappingInfo &Map) {
 186   unsigned bb = 0;
 187
 188   // First build temporary table used to write out the map.
 189   InstructionKey BBkey;
 190   create_BB_to_MInumber_Key(FI, BBkey);
 191
 192   selectOutputMap (Map);
 193   MachineFunction &MF = MachineFunction::get(&FI);
 194   for (MachineFunction::iterator BI = MF.begin(), BE = MF.end();
 195        BI != BE; ++BI, ++bb) {
 196     MachineBasicBlock &miBB = *BI;
 197     writeNumber(bb);
 198     writeNumber(BBkey[&miBB.front()]);
 199     writeNumber(miBB.size());
 200   }
 201 }
 202
 203 /// buildLMIMap - Build the LLVM I TO MI MAP for the function FI,
 204 /// and save it into the parameter MAP.
 205 ///
 206 void MappingInfoAsmPrinter::buildLMIMap(Function &FI, MappingInfo &Map) {
 207   unsigned bb = 0;
 208   // First build temporary table used to write out the map.
 209   InstructionKey MIkey;
 210   create_MI_to_number_Key(FI, MIkey);
 211
 212   selectOutputMap (Map);
 213   for (Function::iterator BI = FI.begin(), BE = FI.end();
 214        BI != BE; ++BI, ++bb) {
 215     unsigned li = 0;
 216     writeNumber(bb);
 217     writeNumber(BI->size());
 218     for (BasicBlock::iterator II = BI->begin(), IE = BI->end(); II != IE;
 219          ++II, ++li) {
 220       MachineCodeForInstruction& miI = MachineCodeForInstruction::get(II);
 221       writeNumber(li);
 222       writeNumber(miI.size());
 223       for (MachineCodeForInstruction::iterator miII = miI.begin(),
 224            miIE = miI.end(); miII != miIE; ++miII) {
 225              writeNumber(MIkey[*miII]);
 226       }
 227     }
 228   }
 229 }
 230
 231 void MappingInfo::byteVector::dumpAssembly (std::ostream &Out) {
 232   for (iterator i = begin (), e = end (); i != e; ++i)
 233         Out << ".byte " << (int)*i << "\n";
 234 }
 235
 236 static void writePrologue (std::ostream &Out, const std::string &comment,
 237                            const std::string &symName) {
 238   // Prologue:
 239   // Output a comment describing the object.
 240   Out << "!" << comment << "\n";
 241   // Switch the current section to .rodata in the assembly output:
 242   Out << "\t.section \".rodata\"\n\t.align 8\n";
 243   // Output a global symbol naming the object:
 244   Out << "\t.global " << symName << "\n";
 245   Out << "\t.type " << symName << ",#object\n";
 246   Out << symName << ":\n";
 247 }
 248
 249 static void writeEpilogue (std::ostream &Out, const std::string &symName) {
 250   // Epilogue:
 251   // Output a local symbol marking the end of the object:
 252   Out << ".end_" << symName << ":\n";
 253   // Output size directive giving the size of the object:
 254   Out << "\t.size " << symName << ", .end_" << symName << "-" << symName
 255       << "\n";
 256 }
 257
 258 void MappingInfo::dumpAssembly (std::ostream &Out) {
 259   const std::string &name (symbolPrefix + utostr (functionNumber));
 260   writePrologue (Out, comment, name);
 261   // The LMIMap and BBMIMap are supposed to start with a length word:
 262   Out << "\t.word .end_" << name << "-" << name << "\n";
 263   bytes.dumpAssembly (Out);
 264   writeEpilogue (Out, name);
 265 }
 266
 267 /// doFinalization - This method writes out two tables, named
 268 /// FunctionBB and FunctionLI, which map Function numbers (as in
 269 /// doInitialization) to the BBMIMap and LMIMap tables. (This used to
 270 /// be the "FunctionInfo" pass.)
 271 ///
 272 bool MappingInfoAsmPrinter::doFinalization (Module &M) {
 273   unsigned f;
 274
 275   writePrologue(Out, "FUNCTION TO BB MAP", "FunctionBB");
 276   f=0;
 277   for(Module::iterator FI = M.begin (), FE = M.end (); FE != FI; ++FI) {
 278     if (FI->isExternal ())
 279       continue;
 280     Out << "\t.xword BBMIMap" << f << "\n";
 281     ++f;
 282   }
 283   writeEpilogue(Out, "FunctionBB");
 284
 285   writePrologue(Out, "FUNCTION TO LI MAP", "FunctionLI");
 286   f=0;
 287   for(Module::iterator FI = M.begin (), FE = M.end (); FE != FI; ++FI) {
 288     if (FI->isExternal ())
 289       continue;
 290     Out << "\t.xword LMIMap" << f << "\n";
 291     ++f;
 292   }
 293   writeEpilogue(Out, "FunctionLI");
 294
 295   return false;
 296 }
 297
 298 } // End llvm namespace
 299