AsmPrinter.h revision fe7b16fe6529a6890adf94ce3ccc463ea939992a
1//===-- llvm/CodeGen/AsmPrinter.h - AsmPrinter Framework --------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// 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/ADT/DenseMap.h" 20#include "llvm/CodeGen/MachineFunctionPass.h" 21#include "llvm/Support/DataTypes.h" 22#include "llvm/Target/TargetMachine.h" 23#include <set> 24 25namespace llvm { 26 class GCStrategy; 27 class Constant; 28 class ConstantArray; 29 class ConstantInt; 30 class ConstantStruct; 31 class ConstantVector; 32 class GCMetadataPrinter; 33 class GlobalVariable; 34 class MachineConstantPoolEntry; 35 class MachineConstantPoolValue; 36 class MachineModuleInfo; 37 class MCInst; 38 class DwarfWriter; 39 class Mangler; 40 class Section; 41 class TargetAsmInfo; 42 class Type; 43 class formatted_raw_ostream; 44 45 /// AsmPrinter - This class is intended to be used as a driving class for all 46 /// asm writers. 47 class AsmPrinter : public MachineFunctionPass { 48 static char ID; 49 50 /// FunctionNumber - This provides a unique ID for each function emitted in 51 /// this translation unit. It is autoincremented by SetupMachineFunction, 52 /// and can be accessed with getFunctionNumber() and 53 /// IncrementFunctionNumber(). 54 /// 55 unsigned FunctionNumber; 56 57 // GCMetadataPrinters - The garbage collection metadata printer table. 58 typedef DenseMap<GCStrategy*,GCMetadataPrinter*> gcp_map_type; 59 typedef gcp_map_type::iterator gcp_iterator; 60 gcp_map_type GCMetadataPrinters; 61 62 protected: 63 /// MMI - If available, this is a pointer to the current MachineModuleInfo. 64 MachineModuleInfo *MMI; 65 66 /// DW - If available, this is a pointer to the current dwarf writer. 67 DwarfWriter *DW; 68 69 public: 70 /// Output stream on which we're printing assembly code. 71 /// 72 formatted_raw_ostream &O; 73 74 /// Target machine description. 75 /// 76 TargetMachine &TM; 77 78 /// Target Asm Printer information. 79 /// 80 const TargetAsmInfo *TAI; 81 82 /// Target Register Information. 83 /// 84 const TargetRegisterInfo *TRI; 85 86 /// The current machine function. 87 const MachineFunction *MF; 88 89 /// Name-mangler for global names. 90 /// 91 Mangler *Mang; 92 93 /// Cache of mangled name for current function. This is recalculated at the 94 /// beginning of each call to runOnMachineFunction(). 95 /// 96 std::string CurrentFnName; 97 98 /// CurrentSection - The current section we are emitting to. This is 99 /// controlled and used by the SwitchSection method. 100 std::string CurrentSection; 101 const Section* CurrentSection_; 102 103 /// IsInTextSection - True if the current section we are emitting to is a 104 /// text section. 105 bool IsInTextSection; 106 107 /// VerboseAsm - Emit comments in assembly output if this is true. 108 /// 109 bool VerboseAsm; 110 111 /// Private state for PrintSpecial() 112 // Assign a unique ID to this machine instruction. 113 mutable const MachineInstr *LastMI; 114 mutable const Function *LastFn; 115 mutable unsigned Counter; 116 117 // Private state for processDebugLock() 118 mutable DebugLocTuple PrevDLT; 119 120 protected: 121 explicit AsmPrinter(formatted_raw_ostream &o, TargetMachine &TM, 122 const TargetAsmInfo *T, bool V); 123 124 public: 125 virtual ~AsmPrinter(); 126 127 /// isVerbose - Return true if assembly output should contain comments. 128 /// 129 bool isVerbose() const { return VerboseAsm; } 130 131 /// SwitchToTextSection - Switch to the specified section of the executable 132 /// if we are not already in it! If GV is non-null and if the global has an 133 /// explicitly requested section, we switch to the section indicated for the 134 /// global instead of NewSection. 135 /// 136 /// If the new section is an empty string, this method forgets what the 137 /// current section is, but does not emit a .section directive. 138 /// 139 /// This method is used when about to emit executable code. 140 /// 141 void SwitchToTextSection(const char *NewSection, 142 const GlobalValue *GV = NULL); 143 144 /// SwitchToDataSection - Switch to the specified section of the executable 145 /// if we are not already in it! If GV is non-null and if the global has an 146 /// explicitly requested section, we switch to the section indicated for the 147 /// global instead of NewSection. 148 /// 149 /// If the new section is an empty string, this method forgets what the 150 /// current section is, but does not emit a .section directive. 151 /// 152 /// This method is used when about to emit data. For most assemblers, this 153 /// is the same as the SwitchToTextSection method, but not all assemblers 154 /// are the same. 155 /// 156 void SwitchToDataSection(const char *NewSection, 157 const GlobalValue *GV = NULL); 158 159 /// SwitchToSection - Switch to the specified section of the executable if 160 /// we are not already in it! 161 void SwitchToSection(const Section* NS); 162 163 /// getGlobalLinkName - Returns the asm/link name of of the specified 164 /// global variable. Should be overridden by each target asm printer to 165 /// generate the appropriate value. 166 virtual const std::string &getGlobalLinkName(const GlobalVariable *GV, 167 std::string &LinkName) const; 168 169 /// EmitExternalGlobal - Emit the external reference to a global variable. 170 /// Should be overridden if an indirect reference should be used. 171 virtual void EmitExternalGlobal(const GlobalVariable *GV); 172 173 /// getCurrentFunctionEHName - Called to return (and cache) the 174 /// CurrentFnEHName. 175 /// 176 const std::string &getCurrentFunctionEHName(const MachineFunction *MF, 177 std::string &FuncEHName) const; 178 179 protected: 180 /// getAnalysisUsage - Record analysis usage. 181 /// 182 void getAnalysisUsage(AnalysisUsage &AU) const; 183 184 /// doInitialization - Set up the AsmPrinter when we are working on a new 185 /// module. If your pass overrides this, it must make sure to explicitly 186 /// call this implementation. 187 bool doInitialization(Module &M); 188 189 /// doFinalization - Shut down the asmprinter. If you override this in your 190 /// pass, you must make sure to call it explicitly. 191 bool doFinalization(Module &M); 192 193 /// PrintSpecial - Print information related to the specified machine instr 194 /// that is independent of the operand, and may be independent of the instr 195 /// itself. This can be useful for portably encoding the comment character 196 /// or other bits of target-specific knowledge into the asmstrings. The 197 /// syntax used is ${:comment}. Targets can override this to add support 198 /// for their own strange codes. 199 virtual void PrintSpecial(const MachineInstr *MI, const char *Code) const; 200 201 /// PrintAsmOperand - Print the specified operand of MI, an INLINEASM 202 /// instruction, using the specified assembler variant. Targets should 203 /// override this to format as appropriate. This method can return true if 204 /// the operand is erroneous. 205 virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 206 unsigned AsmVariant, const char *ExtraCode); 207 208 /// PrintAsmMemoryOperand - Print the specified operand of MI, an INLINEASM 209 /// instruction, using the specified assembler variant as an address. 210 /// Targets should override this to format as appropriate. This method can 211 /// return true if the operand is erroneous. 212 virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, 213 unsigned AsmVariant, 214 const char *ExtraCode); 215 216 /// SetupMachineFunction - This should be called when a new MachineFunction 217 /// is being processed from runOnMachineFunction. 218 void SetupMachineFunction(MachineFunction &MF); 219 220 /// getFunctionNumber - Return a unique ID for the current function. 221 /// 222 unsigned getFunctionNumber() const { return FunctionNumber; } 223 224 /// IncrementFunctionNumber - Increase Function Number. AsmPrinters should 225 /// not normally call this, as the counter is automatically bumped by 226 /// SetupMachineFunction. 227 void IncrementFunctionNumber() { FunctionNumber++; } 228 229 /// EmitConstantPool - Print to the current output stream assembly 230 /// representations of the constants in the constant pool MCP. This is 231 /// used to print out constants which have been "spilled to memory" by 232 /// the code generator. 233 /// 234 void EmitConstantPool(MachineConstantPool *MCP); 235 236 /// EmitJumpTableInfo - Print assembly representations of the jump tables 237 /// used by the current function to the current output stream. 238 /// 239 void EmitJumpTableInfo(MachineJumpTableInfo *MJTI, MachineFunction &MF); 240 241 /// EmitSpecialLLVMGlobal - Check to see if the specified global is a 242 /// special global used by LLVM. If so, emit it and return true, otherwise 243 /// do nothing and return false. 244 bool EmitSpecialLLVMGlobal(const GlobalVariable *GV); 245 246 public: 247 //===------------------------------------------------------------------===// 248 /// LEB 128 number encoding. 249 250 /// PrintULEB128 - Print a series of hexidecimal values(separated by commas) 251 /// representing an unsigned leb128 value. 252 void PrintULEB128(unsigned Value) const; 253 254 /// PrintSLEB128 - Print a series of hexidecimal values(separated by commas) 255 /// representing a signed leb128 value. 256 void PrintSLEB128(int Value) const; 257 258 //===------------------------------------------------------------------===// 259 // Emission and print routines 260 // 261 262 /// PrintHex - Print a value as a hexidecimal value. 263 /// 264 void PrintHex(int Value) const; 265 266 /// EOL - Print a newline character to asm stream. If a comment is present 267 /// then it will be printed first. Comments should not contain '\n'. 268 void EOL() const; 269 void EOL(const std::string &Comment) const; 270 void EOL(const char* Comment) const; 271 272 /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an 273 /// unsigned leb128 value. 274 void EmitULEB128Bytes(unsigned Value) const; 275 276 /// EmitSLEB128Bytes - print an assembler byte data directive to compose a 277 /// signed leb128 value. 278 void EmitSLEB128Bytes(int Value) const; 279 280 /// EmitInt8 - Emit a byte directive and value. 281 /// 282 void EmitInt8(int Value) const; 283 284 /// EmitInt16 - Emit a short directive and value. 285 /// 286 void EmitInt16(int Value) const; 287 288 /// EmitInt32 - Emit a long directive and value. 289 /// 290 void EmitInt32(int Value) const; 291 292 /// EmitInt64 - Emit a long long directive and value. 293 /// 294 void EmitInt64(uint64_t Value) const; 295 296 /// EmitString - Emit a string with quotes and a null terminator. 297 /// Special characters are emitted properly. 298 /// @verbatim (Eg. '\t') @endverbatim 299 void EmitString(const std::string &String) const; 300 void EmitString(const char *String, unsigned Size) const; 301 302 /// EmitFile - Emit a .file directive. 303 void EmitFile(unsigned Number, const std::string &Name) const; 304 305 //===------------------------------------------------------------------===// 306 307 /// EmitAlignment - Emit an alignment directive to the specified power of 308 /// two boundary. For example, if you pass in 3 here, you will get an 8 309 /// byte alignment. If a global value is specified, and if that global has 310 /// an explicit alignment requested, it will unconditionally override the 311 /// alignment request. However, if ForcedAlignBits is specified, this value 312 /// has final say: the ultimate alignment will be the max of ForcedAlignBits 313 /// and the alignment computed with NumBits and the global. If UseFillExpr 314 /// is true, it also emits an optional second value FillValue which the 315 /// assembler uses to fill gaps to match alignment for text sections if the 316 /// has specified a non-zero fill value. 317 /// 318 /// The algorithm is: 319 /// Align = NumBits; 320 /// if (GV && GV->hasalignment) Align = GV->getalignment(); 321 /// Align = std::max(Align, ForcedAlignBits); 322 /// 323 void EmitAlignment(unsigned NumBits, const GlobalValue *GV = 0, 324 unsigned ForcedAlignBits = 0, 325 bool UseFillExpr = true) const; 326 327 /// printLabel - This method prints a local label used by debug and 328 /// exception handling tables. 329 void printLabel(const MachineInstr *MI) const; 330 void printLabel(unsigned Id) const; 331 332 /// printDeclare - This method prints a local variable declaration used by 333 /// debug tables. 334 void printDeclare(const MachineInstr *MI) const; 335 336 /// EmitComments - Pretty-print comments for instructions 337 void EmitComments(const MachineInstr &MI) const; 338 /// EmitComments - Pretty-print comments for instructions 339 void EmitComments(const MCInst &MI) const; 340 341 protected: 342 /// EmitZeros - Emit a block of zeros. 343 /// 344 void EmitZeros(uint64_t NumZeros, unsigned AddrSpace = 0) const; 345 346 /// EmitString - Emit a zero-byte-terminated string constant. 347 /// 348 virtual void EmitString(const ConstantArray *CVA) const; 349 350 /// EmitConstantValueOnly - Print out the specified constant, without a 351 /// storage class. Only constants of first-class type are allowed here. 352 void EmitConstantValueOnly(const Constant *CV); 353 354 /// EmitGlobalConstant - Print a general LLVM constant to the .s file. 355 void EmitGlobalConstant(const Constant* CV, unsigned AddrSpace = 0); 356 357 virtual void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV); 358 359 /// processDebugLoc - Processes the debug information of each machine 360 /// instruction's DebugLoc. 361 void processDebugLoc(DebugLoc DL); 362 363 /// printInlineAsm - This method formats and prints the specified machine 364 /// instruction that is an inline asm. 365 void printInlineAsm(const MachineInstr *MI) const; 366 367 /// printImplicitDef - This method prints the specified machine instruction 368 /// that is an implicit def. 369 virtual void printImplicitDef(const MachineInstr *MI) const; 370 371 /// printBasicBlockLabel - This method prints the label for the specified 372 /// MachineBasicBlock 373 virtual void printBasicBlockLabel(const MachineBasicBlock *MBB, 374 bool printAlign = false, 375 bool printColon = false, 376 bool printComment = true) const; 377 378 /// printPICJumpTableSetLabel - This method prints a set label for the 379 /// specified MachineBasicBlock for a jumptable entry. 380 virtual void printPICJumpTableSetLabel(unsigned uid, 381 const MachineBasicBlock *MBB) const; 382 virtual void printPICJumpTableSetLabel(unsigned uid, unsigned uid2, 383 const MachineBasicBlock *MBB) const; 384 virtual void printPICJumpTableEntry(const MachineJumpTableInfo *MJTI, 385 const MachineBasicBlock *MBB, 386 unsigned uid) const; 387 388 /// printDataDirective - This method prints the asm directive for the 389 /// specified type. 390 void printDataDirective(const Type *type, unsigned AddrSpace = 0); 391 392 /// printVisibility - This prints visibility information about symbol, if 393 /// this is suported by the target. 394 void printVisibility(const std::string& Name, unsigned Visibility) const; 395 396 /// printOffset - This is just convenient handler for printing offsets. 397 void printOffset(int64_t Offset) const; 398 399 private: 400 const GlobalValue *findGlobalValue(const Constant* CV); 401 void EmitLLVMUsedList(Constant *List); 402 void EmitXXStructorList(Constant *List); 403 void EmitGlobalConstantStruct(const ConstantStruct* CVS, 404 unsigned AddrSpace); 405 void EmitGlobalConstantArray(const ConstantArray* CVA, unsigned AddrSpace); 406 void EmitGlobalConstantVector(const ConstantVector* CP); 407 void EmitGlobalConstantFP(const ConstantFP* CFP, unsigned AddrSpace); 408 void EmitGlobalConstantLargeInt(const ConstantInt* CI, unsigned AddrSpace); 409 GCMetadataPrinter *GetOrCreateGCPrinter(GCStrategy *C); 410 }; 411} 412 413#endif 414