1 //===- MappingInfo.cpp - create LLVM info and output to .s file -----------===//
3 // The LLVM Compiler Infrastructure
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.
8 //===----------------------------------------------------------------------===//
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").
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.
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
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.
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.
43 //===--------------------------------------------------------------------===//
45 #include "MappingInfo.h"
46 #include "llvm/Pass.h"
47 #include "llvm/Module.h"
48 #include "llvm/CodeGen/MachineFunction.h"
49 #include "llvm/CodeGen/MachineCodeForInstruction.h"
50 #include "Support/StringExtras.h"
55 class MappingInfoAsmPrinter : public FunctionPass {
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;
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);
77 /// getMappingInfoAsmPrinterPass - Static factory method: returns a new
78 /// MappingInfoAsmPrinter Pass object, which uses OUT as its output
79 /// stream for assembly output.
81 Pass *getMappingInfoAsmPrinterPass(std::ostream &out){
82 return (new MappingInfoAsmPrinter(out));
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.
89 bool MappingInfoAsmPrinter::runOnFunction(Function &FI) {
90 unsigned num = Fkey[&FI]; // Function number for the current function.
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);
96 // Now, build the maps.
97 buildLMIMap (FI, LMIMap);
98 buildBBMIMap (FI, BBMIMap);
100 // Now, write out the maps.
101 LMIMap.dumpAssembly (Out);
102 BBMIMap.dumpAssembly (Out);
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.
111 void MappingInfoAsmPrinter::writeNumber(unsigned X) {
114 unsigned tmp = X & 127;
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.)
129 bool MappingInfoAsmPrinter::doInitialization(Module &M) {
131 for (Module::iterator FI = M.begin(), FE = M.end(); FI != FE; ++FI) {
132 if (FI->isExternal()) continue;
136 return false; // Success.
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.
149 void MappingInfoAsmPrinter::create_BB_to_MInumber_Key(Function &FI,
150 InstructionKey &key) {
152 MachineFunction &MF = MachineFunction::get(&FI);
153 for (MachineFunction::iterator BI = MF.begin(), BE = MF.end();
155 MachineBasicBlock &miBB = *BI;
156 key[&miBB.front()] = i;
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.
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;
175 for(MachineBasicBlock::iterator miI = miBB.begin(), miE = miBB.end();
176 miI != miE; ++miI, ++j) {
182 /// buildBBMIMap - Build the BB TO MI MAP for the function FI,
183 /// and save it into the parameter MAP.
185 void MappingInfoAsmPrinter::buildBBMIMap(Function &FI, MappingInfo &Map) {
188 // First build temporary table used to write out the map.
189 InstructionKey BBkey;
190 create_BB_to_MInumber_Key(FI, BBkey);
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;
198 writeNumber(BBkey[&miBB.front()]);
199 writeNumber(miBB.size());
203 /// buildLMIMap - Build the LLVM I TO MI MAP for the function FI,
204 /// and save it into the parameter MAP.
206 void MappingInfoAsmPrinter::buildLMIMap(Function &FI, MappingInfo &Map) {
208 // First build temporary table used to write out the map.
209 InstructionKey MIkey;
210 create_MI_to_number_Key(FI, MIkey);
212 selectOutputMap (Map);
213 for (Function::iterator BI = FI.begin(), BE = FI.end();
214 BI != BE; ++BI, ++bb) {
217 writeNumber(BI->size());
218 for (BasicBlock::iterator II = BI->begin(), IE = BI->end(); II != IE;
220 MachineCodeForInstruction& miI = MachineCodeForInstruction::get(II);
222 writeNumber(miI.size());
223 for (MachineCodeForInstruction::iterator miII = miI.begin(),
224 miIE = miI.end(); miII != miIE; ++miII) {
225 writeNumber(MIkey[*miII]);
231 void MappingInfo::byteVector::dumpAssembly (std::ostream &Out) {
232 for (iterator i = begin (), e = end (); i != e; ++i)
233 Out << ".byte " << (int)*i << "\n";
236 static void writePrologue (std::ostream &Out, const std::string &comment,
237 const std::string &symName) {
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";
249 static void writeEpilogue (std::ostream &Out, const std::string &symName) {
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
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);
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.)
272 bool MappingInfoAsmPrinter::doFinalization (Module &M) {
275 writePrologue(Out, "FUNCTION TO BB MAP", "FunctionBB");
277 for(Module::iterator FI = M.begin (), FE = M.end (); FE != FI; ++FI) {
278 if (FI->isExternal ())
280 Out << "\t.xword BBMIMap" << f << "\n";
283 writeEpilogue(Out, "FunctionBB");
285 writePrologue(Out, "FUNCTION TO LI MAP", "FunctionLI");
287 for(Module::iterator FI = M.begin (), FE = M.end (); FE != FI; ++FI) {
288 if (FI->isExternal ())
290 Out << "\t.xword LMIMap" << f << "\n";
293 writeEpilogue(Out, "FunctionLI");
298 } // End llvm namespace