AsmPrinter.h revision 189f80dc253664627253b2d2cb07d0714feb12ba
1//===-- llvm/CodeGen/AsmPrinter.h - AsmPrinter Framework --------*- C++ -*-===// 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 class to be used as the base class for target specific 11// asm writers. This class primarily handles common functionality used by 12// all asm writers. 13// 14//===----------------------------------------------------------------------===// 15 16#ifndef LLVM_CODEGEN_ASMPRINTER_H 17#define LLVM_CODEGEN_ASMPRINTER_H 18 19#include "llvm/CodeGen/MachineFunctionPass.h" 20#include "llvm/Support/DataTypes.h" 21#include <set> 22 23namespace llvm { 24 class Constant; 25 class ConstantArray; 26 class GlobalVariable; 27 class GlobalAlias; 28 class MachineConstantPoolEntry; 29 class MachineConstantPoolValue; 30 class Mangler; 31 class TargetAsmInfo; 32 33 34 /// AsmPrinter - This class is intended to be used as a driving class for all 35 /// asm writers. 36 class AsmPrinter : public MachineFunctionPass { 37 static char ID; 38 39 /// FunctionNumber - This provides a unique ID for each function emitted in 40 /// this translation unit. It is autoincremented by SetupMachineFunction, 41 /// and can be accessed with getFunctionNumber() and 42 /// IncrementFunctionNumber(). 43 /// 44 unsigned FunctionNumber; 45 46 protected: 47 // Necessary for external weak linkage support 48 std::set<const GlobalValue*> ExtWeakSymbols; 49 50 public: 51 /// Output stream on which we're printing assembly code. 52 /// 53 std::ostream &O; 54 55 /// Target machine description. 56 /// 57 TargetMachine &TM; 58 59 /// Target Asm Printer information. 60 /// 61 const TargetAsmInfo *TAI; 62 63 /// Name-mangler for global names. 64 /// 65 Mangler *Mang; 66 67 /// Cache of mangled name for current function. This is recalculated at the 68 /// beginning of each call to runOnMachineFunction(). 69 /// 70 std::string CurrentFnName; 71 72 /// CurrentSection - The current section we are emitting to. This is 73 /// controlled and used by the SwitchSection method. 74 std::string CurrentSection; 75 76 protected: 77 AsmPrinter(std::ostream &o, TargetMachine &TM, const TargetAsmInfo *T); 78 79 public: 80 /// SwitchToTextSection - Switch to the specified section of the executable 81 /// if we are not already in it! If GV is non-null and if the global has an 82 /// explicitly requested section, we switch to the section indicated for the 83 /// global instead of NewSection. 84 /// 85 /// If the new section is an empty string, this method forgets what the 86 /// current section is, but does not emit a .section directive. 87 /// 88 /// This method is used when about to emit executable code. 89 /// 90 void SwitchToTextSection(const char *NewSection, const GlobalValue *GV = NULL); 91 92 /// SwitchToDataSection - Switch to the specified section of the executable 93 /// if we are not already in it! If GV is non-null and if the global has an 94 /// explicitly requested section, we switch to the section indicated for the 95 /// global instead of NewSection. 96 /// 97 /// If the new section is an empty string, this method forgets what the 98 /// current section is, but does not emit a .section directive. 99 /// 100 /// This method is used when about to emit data. For most assemblers, this 101 /// is the same as the SwitchToTextSection method, but not all assemblers 102 /// are the same. 103 /// 104 void SwitchToDataSection(const char *NewSection, const GlobalValue *GV = NULL); 105 106 /// getGlobalLinkName - Returns the asm/link name of of the specified 107 /// global variable. Should be overridden by each target asm printer to 108 /// generate the appropriate value. 109 virtual const std::string getGlobalLinkName(const GlobalVariable *GV) const; 110 111 /// EmitExternalGlobal - Emit the external reference to a global variable. 112 /// Should be overridden if an indirect reference should be used. 113 virtual void EmitExternalGlobal(const GlobalVariable *GV); 114 115 /// getCurrentFunctionEHName - Called to return (and cache) the 116 /// CurrentFnEHName. 117 /// 118 std::string getCurrentFunctionEHName(const MachineFunction *MF); 119 120 protected: 121 /// doInitialization - Set up the AsmPrinter when we are working on a new 122 /// module. If your pass overrides this, it must make sure to explicitly 123 /// call this implementation. 124 bool doInitialization(Module &M); 125 126 /// doFinalization - Shut down the asmprinter. If you override this in your 127 /// pass, you must make sure to call it explicitly. 128 bool doFinalization(Module &M); 129 130 /// PrintSpecial - Print information related to the specified machine instr 131 /// that is independent of the operand, and may be independent of the instr 132 /// itself. This can be useful for portably encoding the comment character 133 /// or other bits of target-specific knowledge into the asmstrings. The 134 /// syntax used is ${:comment}. Targets can override this to add support 135 /// for their own strange codes. 136 virtual void PrintSpecial(const MachineInstr *MI, const char *Code); 137 138 /// PrintAsmOperand - Print the specified operand of MI, an INLINEASM 139 /// instruction, using the specified assembler variant. Targets should 140 /// override this to format as appropriate. This method can return true if 141 /// the operand is erroneous. 142 virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 143 unsigned AsmVariant, const char *ExtraCode); 144 145 /// PrintAsmMemoryOperand - Print the specified operand of MI, an INLINEASM 146 /// instruction, using the specified assembler variant as an address. 147 /// Targets should override this to format as appropriate. This method can 148 /// return true if the operand is erroneous. 149 virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, 150 unsigned AsmVariant, 151 const char *ExtraCode); 152 153 /// getSectionForFunction - Return the section that we should emit the 154 /// specified function body into. This defaults to 'TextSection'. This 155 /// should most likely be overridden by the target to put linkonce/weak 156 /// functions into special sections. 157 virtual std::string getSectionForFunction(const Function &F) const; 158 159 /// SetupMachineFunction - This should be called when a new MachineFunction 160 /// is being processed from runOnMachineFunction. 161 void SetupMachineFunction(MachineFunction &MF); 162 163 /// getFunctionNumber - Return a unique ID for the current function. 164 /// 165 unsigned getFunctionNumber() const { return FunctionNumber; } 166 167 /// IncrementFunctionNumber - Increase Function Number. AsmPrinters should 168 /// not normally call this, as the counter is automatically bumped by 169 /// SetupMachineFunction. 170 void IncrementFunctionNumber() { FunctionNumber++; } 171 172 /// EmitConstantPool - Print to the current output stream assembly 173 /// representations of the constants in the constant pool MCP. This is 174 /// used to print out constants which have been "spilled to memory" by 175 /// the code generator. 176 /// 177 void EmitConstantPool(MachineConstantPool *MCP); 178 179 /// EmitJumpTableInfo - Print assembly representations of the jump tables 180 /// used by the current function to the current output stream. 181 /// 182 void EmitJumpTableInfo(MachineJumpTableInfo *MJTI, MachineFunction &MF); 183 184 /// EmitSpecialLLVMGlobal - Check to see if the specified global is a 185 /// special global used by LLVM. If so, emit it and return true, otherwise 186 /// do nothing and return false. 187 bool EmitSpecialLLVMGlobal(const GlobalVariable *GV); 188 189 public: 190 //===------------------------------------------------------------------===// 191 /// LEB 128 number encoding. 192 193 /// PrintULEB128 - Print a series of hexidecimal values(separated by commas) 194 /// representing an unsigned leb128 value. 195 void PrintULEB128(unsigned Value) const; 196 197 /// SizeULEB128 - Compute the number of bytes required for an unsigned 198 /// leb128 value. 199 static unsigned SizeULEB128(unsigned Value); 200 201 /// PrintSLEB128 - Print a series of hexidecimal values(separated by commas) 202 /// representing a signed leb128 value. 203 void PrintSLEB128(int Value) const; 204 205 /// SizeSLEB128 - Compute the number of bytes required for a signed leb128 206 /// value. 207 static unsigned SizeSLEB128(int Value); 208 209 //===------------------------------------------------------------------===// 210 // Emission and print routines 211 // 212 213 /// PrintHex - Print a value as a hexidecimal value. 214 /// 215 void PrintHex(int Value) const; 216 217 /// EOL - Print a newline character to asm stream. If a comment is present 218 /// then it will be printed first. Comments should not contain '\n'. 219 void EOL() const; 220 void EOL(const std::string &Comment) const; 221 222 /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an 223 /// unsigned leb128 value. 224 void EmitULEB128Bytes(unsigned Value) const; 225 226 /// EmitSLEB128Bytes - print an assembler byte data directive to compose a 227 /// signed leb128 value. 228 void EmitSLEB128Bytes(int Value) const; 229 230 /// EmitInt8 - Emit a byte directive and value. 231 /// 232 void EmitInt8(int Value) const; 233 234 /// EmitInt16 - Emit a short directive and value. 235 /// 236 void EmitInt16(int Value) const; 237 238 /// EmitInt32 - Emit a long directive and value. 239 /// 240 void EmitInt32(int Value) const; 241 242 /// EmitInt64 - Emit a long long directive and value. 243 /// 244 void EmitInt64(uint64_t Value) const; 245 246 /// EmitString - Emit a string with quotes and a null terminator. 247 /// Special characters are emitted properly. 248 /// @verbatim (Eg. '\t') @endverbatim 249 void EmitString(const std::string &String) const; 250 251 /// EmitFile - Emit a .file directive. 252 void EmitFile(unsigned Number, const std::string &Name) const; 253 254 //===------------------------------------------------------------------===// 255 256 /// EmitAlignment - Emit an alignment directive to the specified power of 257 /// two boundary. For example, if you pass in 3 here, you will get an 8 258 /// byte alignment. If a global value is specified, and if that global has 259 /// an explicit alignment requested, it will unconditionally override the 260 /// alignment request. However, if ForcedAlignBits is specified, this value 261 /// has final say: the ultimate alignment will be the max of ForcedAlignBits 262 /// and the alignment computed with NumBits and the global. If UseFillExpr 263 /// is true, it also emits an optional second value FillValue which the 264 /// assembler uses to fill gaps to match alignment. 265 /// 266 /// The algorithm is: 267 /// Align = NumBits; 268 /// if (GV && GV->hasalignment) Align = GV->getalignment(); 269 /// Align = std::max(Align, ForcedAlignBits); 270 /// 271 void EmitAlignment(unsigned NumBits, const GlobalValue *GV = 0, 272 unsigned ForcedAlignBits = 0, bool UseFillExpr = false, 273 unsigned FillValue = 0) const; 274 275 protected: 276 /// EmitZeros - Emit a block of zeros. 277 /// 278 void EmitZeros(uint64_t NumZeros) const; 279 280 /// EmitString - Emit a zero-byte-terminated string constant. 281 /// 282 virtual void EmitString(const ConstantArray *CVA) const; 283 284 /// EmitConstantValueOnly - Print out the specified constant, without a 285 /// storage class. Only constants of first-class type are allowed here. 286 void EmitConstantValueOnly(const Constant *CV); 287 288 /// EmitGlobalConstant - Print a general LLVM constant to the .s file. 289 /// 290 void EmitGlobalConstant(const Constant* CV); 291 292 virtual void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV); 293 294 /// printInlineAsm - This method formats and prints the specified machine 295 /// instruction that is an inline asm. 296 void printInlineAsm(const MachineInstr *MI) const; 297 298 /// printLabel - This method prints a local label used by debug and 299 /// exception handling tables. 300 void printLabel(const MachineInstr *MI) const; 301 302 /// printBasicBlockLabel - This method prints the label for the specified 303 /// MachineBasicBlock 304 virtual void printBasicBlockLabel(const MachineBasicBlock *MBB, 305 bool printColon = false, 306 bool printComment = true) const; 307 308 /// printSetLabel - This method prints a set label for the specified 309 /// MachineBasicBlock 310 void printSetLabel(unsigned uid, const MachineBasicBlock *MBB) const; 311 void printSetLabel(unsigned uid, unsigned uid2, 312 const MachineBasicBlock *MBB) const; 313 314 /// printDataDirective - This method prints the asm directive for the 315 /// specified type. 316 void printDataDirective(const Type *type); 317 318 private: 319 void EmitLLVMUsedList(Constant *List); 320 void EmitXXStructorList(Constant *List); 321 void EmitConstantPool(unsigned Alignment, const char *Section, 322 std::vector<std::pair<MachineConstantPoolEntry,unsigned> > &CP); 323 324 }; 325} 326 327#endif 328