1 //===-- llvm/CodeGen/AsmPrinter.h - AsmPrinter Framework --------*- C++ -*-===//
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 class to be used as the base class for target specific
11 // asm writers. This class primarily handles common functionality used by
14 //===----------------------------------------------------------------------===//
16 #ifndef LLVM_CODEGEN_ASMPRINTER_H
17 #define LLVM_CODEGEN_ASMPRINTER_H
19 #include "llvm/CodeGen/MachineFunctionPass.h"
20 #include "llvm/Support/DataTypes.h"
27 class MachineConstantPoolEntry;
28 class MachineConstantPoolValue;
33 /// AsmPrinter - This class is intended to be used as a driving class for all
35 class AsmPrinter : public MachineFunctionPass {
36 /// FunctionNumber - This provides a unique ID for each function emitted in
37 /// this translation unit. It is autoincremented by SetupMachineFunction,
38 /// and can be accessed with getFunctionNumber() and
39 /// IncrementFunctionNumber().
41 unsigned FunctionNumber;
44 // Necessary for external weak linkage support
45 std::set<const GlobalValue*> ExtWeakSymbols;
48 /// Output stream on which we're printing assembly code.
52 /// Target machine description.
56 /// Target Asm Printer information.
58 const TargetAsmInfo *TAI;
60 /// Name-mangler for global names.
64 /// Cache of mangled name for current function. This is recalculated at the
65 /// beginning of each call to runOnMachineFunction().
67 std::string CurrentFnName;
69 /// CurrentSection - The current section we are emitting to. This is
70 /// controlled and used by the SwitchSection method.
71 std::string CurrentSection;
74 AsmPrinter(std::ostream &o, TargetMachine &TM, const TargetAsmInfo *T);
77 /// SwitchToTextSection - Switch to the specified section of the executable
78 /// if we are not already in it! If GV is non-null and if the global has an
79 /// explicitly requested section, we switch to the section indicated for the
80 /// global instead of NewSection.
82 /// If the new section is an empty string, this method forgets what the
83 /// current section is, but does not emit a .section directive.
85 /// This method is used when about to emit executable code.
87 void SwitchToTextSection(const char *NewSection, const GlobalValue *GV = NULL);
89 /// SwitchToDataSection - Switch to the specified section of the executable
90 /// if we are not already in it! If GV is non-null and if the global has an
91 /// explicitly requested section, we switch to the section indicated for the
92 /// global instead of NewSection.
94 /// If the new section is an empty string, this method forgets what the
95 /// current section is, but does not emit a .section directive.
97 /// This method is used when about to emit data. For most assemblers, this
98 /// is the same as the SwitchToTextSection method, but not all assemblers
101 void SwitchToDataSection(const char *NewSection, const GlobalValue *GV = NULL);
103 /// getGlobalLinkName - Returns the asm/link name of of the specified
104 /// global variable. Should be overridden by each target asm printer to
105 /// generate the appropriate value.
106 virtual const std::string getGlobalLinkName(const GlobalVariable *GV) const;
109 /// doInitialization - Set up the AsmPrinter when we are working on a new
110 /// module. If your pass overrides this, it must make sure to explicitly
111 /// call this implementation.
112 bool doInitialization(Module &M);
114 /// doFinalization - Shut down the asmprinter. If you override this in your
115 /// pass, you must make sure to call it explicitly.
116 bool doFinalization(Module &M);
118 /// PrintSpecial - Print information related to the specified machine instr
119 /// that is independent of the operand, and may be independent of the instr
120 /// itself. This can be useful for portably encoding the comment character
121 /// or other bits of target-specific knowledge into the asmstrings. The
122 /// syntax used is ${:comment}. Targets can override this to add support
123 /// for their own strange codes.
124 virtual void PrintSpecial(const MachineInstr *MI, const char *Code);
126 /// PrintAsmOperand - Print the specified operand of MI, an INLINEASM
127 /// instruction, using the specified assembler variant. Targets should
128 /// override this to format as appropriate. This method can return true if
129 /// the operand is erroneous.
130 virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
131 unsigned AsmVariant, const char *ExtraCode);
133 /// PrintAsmMemoryOperand - Print the specified operand of MI, an INLINEASM
134 /// instruction, using the specified assembler variant as an address.
135 /// Targets should override this to format as appropriate. This method can
136 /// return true if the operand is erroneous.
137 virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
139 const char *ExtraCode);
141 /// getSectionForFunction - Return the section that we should emit the
142 /// specified function body into. This defaults to 'TextSection'. This
143 /// should most likely be overridden by the target to put linkonce/weak
144 /// functions into special sections.
145 virtual std::string getSectionForFunction(const Function &F) const;
147 /// SetupMachineFunction - This should be called when a new MachineFunction
148 /// is being processed from runOnMachineFunction.
149 void SetupMachineFunction(MachineFunction &MF);
151 /// getFunctionNumber - Return a unique ID for the current function.
153 unsigned getFunctionNumber() const { return FunctionNumber; }
155 /// IncrementFunctionNumber - Increase Function Number. AsmPrinters should
156 /// not normally call this, as the counter is automatically bumped by
157 /// SetupMachineFunction.
158 void IncrementFunctionNumber() { FunctionNumber++; }
160 /// EmitConstantPool - Print to the current output stream assembly
161 /// representations of the constants in the constant pool MCP. This is
162 /// used to print out constants which have been "spilled to memory" by
163 /// the code generator.
165 void EmitConstantPool(MachineConstantPool *MCP);
167 /// EmitJumpTableInfo - Print assembly representations of the jump tables
168 /// used by the current function to the current output stream.
170 void EmitJumpTableInfo(MachineJumpTableInfo *MJTI, MachineFunction &MF);
172 /// EmitSpecialLLVMGlobal - Check to see if the specified global is a
173 /// special global used by LLVM. If so, emit it and return true, otherwise
174 /// do nothing and return false.
175 bool EmitSpecialLLVMGlobal(const GlobalVariable *GV);
178 //===------------------------------------------------------------------===//
179 /// LEB 128 number encoding.
181 /// PrintULEB128 - Print a series of hexidecimal values(separated by commas)
182 /// representing an unsigned leb128 value.
183 void PrintULEB128(unsigned Value) const;
185 /// SizeULEB128 - Compute the number of bytes required for an unsigned
187 static unsigned SizeULEB128(unsigned Value);
189 /// PrintSLEB128 - Print a series of hexidecimal values(separated by commas)
190 /// representing a signed leb128 value.
191 void PrintSLEB128(int Value) const;
193 /// SizeSLEB128 - Compute the number of bytes required for a signed leb128
195 static unsigned SizeSLEB128(int Value);
197 //===------------------------------------------------------------------===//
198 // Emission and print routines
201 /// PrintHex - Print a value as a hexidecimal value.
203 void PrintHex(int Value) const;
205 /// EOL - Print a newline character to asm stream. If a comment is present
206 /// then it will be printed first. Comments should not contain '\n'.
207 void EOL(const std::string &Comment) const;
209 /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an
210 /// unsigned leb128 value.
211 void EmitULEB128Bytes(unsigned Value) const;
213 /// EmitSLEB128Bytes - print an assembler byte data directive to compose a
214 /// signed leb128 value.
215 void EmitSLEB128Bytes(int Value) const;
217 /// EmitInt8 - Emit a byte directive and value.
219 void EmitInt8(int Value) const;
221 /// EmitInt16 - Emit a short directive and value.
223 void EmitInt16(int Value) const;
225 /// EmitInt32 - Emit a long directive and value.
227 void EmitInt32(int Value) const;
229 /// EmitInt64 - Emit a long long directive and value.
231 void EmitInt64(uint64_t Value) const;
233 /// EmitString - Emit a string with quotes and a null terminator.
234 /// Special characters are emitted properly.
235 /// \literal (Eg. '\t') \endliteral
236 void EmitString(const std::string &String) const;
238 //===------------------------------------------------------------------===//
240 /// EmitAlignment - Emit an alignment directive to the specified power of
241 /// two boundary. For example, if you pass in 3 here, you will get an 8
242 /// byte alignment. If a global value is specified, and if that global has
243 /// an explicit alignment requested, it will override the alignment request.
244 void EmitAlignment(unsigned NumBits, const GlobalValue *GV = 0) const;
247 /// EmitZeros - Emit a block of zeros.
249 void EmitZeros(uint64_t NumZeros) const;
251 /// EmitString - Emit a zero-byte-terminated string constant.
253 virtual void EmitString(const ConstantArray *CVA) const;
255 /// EmitConstantValueOnly - Print out the specified constant, without a
256 /// storage class. Only constants of first-class type are allowed here.
257 void EmitConstantValueOnly(const Constant *CV);
259 /// EmitGlobalConstant - Print a general LLVM constant to the .s file.
261 void EmitGlobalConstant(const Constant* CV);
263 virtual void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV);
265 /// printInlineAsm - This method formats and prints the specified machine
266 /// instruction that is an inline asm.
267 void printInlineAsm(const MachineInstr *MI) const;
269 /// printLabel - This method prints a local label used by debug and
270 /// exception handling tables.
271 void printLabel(const MachineInstr *MI) const;
273 /// printBasicBlockLabel - This method prints the label for the specified
274 /// MachineBasicBlock
275 virtual void printBasicBlockLabel(const MachineBasicBlock *MBB,
276 bool printColon = false,
277 bool printComment = true) const;
279 /// printSetLabel - This method prints a set label for the specified
280 /// MachineBasicBlock
281 void printSetLabel(unsigned uid, const MachineBasicBlock *MBB) const;
282 void printSetLabel(unsigned uid, unsigned uid2,
283 const MachineBasicBlock *MBB) const;
285 /// printDataDirective - This method prints the asm directive for the
287 void printDataDirective(const Type *type);
290 void EmitLLVMUsedList(Constant *List);
291 void EmitXXStructorList(Constant *List);
292 void EmitConstantPool(unsigned Alignment, const char *Section,
293 std::vector<std::pair<MachineConstantPoolEntry,unsigned> > &CP);