1 //===-- llvm/MC/MCAsmInfo.h - Asm info --------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file contains a class to be used as the basis for target specific 10 // asm writers. This class primarily takes care of global printing constants, 11 // which are used in very similar ways across all targets. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_MC_MCASMINFO_H 16 #define LLVM_MC_MCASMINFO_H 17 18 #include "llvm/ADT/StringRef.h" 19 #include "llvm/MC/MCDirectives.h" 20 #include "llvm/MC/MCTargetOptions.h" 21 #include <vector> 22 23 namespace llvm { 24 25 class MCContext; 26 class MCCFIInstruction; 27 class MCExpr; 28 class MCSection; 29 class MCStreamer; 30 class MCSubtargetInfo; 31 class MCSymbol; 32 33 namespace WinEH { 34 35 enum class EncodingType { 36 Invalid, /// Invalid 37 Alpha, /// Windows Alpha 38 Alpha64, /// Windows AXP64 39 ARM, /// Windows NT (Windows on ARM) 40 CE, /// Windows CE ARM, PowerPC, SH3, SH4 41 Itanium, /// Windows x64, Windows Itanium (IA-64) 42 X86, /// Windows x86, uses no CFI, just EH tables 43 MIPS = Alpha, 44 }; 45 46 } // end namespace WinEH 47 48 namespace LCOMM { 49 50 enum LCOMMType { NoAlignment, ByteAlignment, Log2Alignment }; 51 52 } // end namespace LCOMM 53 54 /// This class is intended to be used as a base class for asm 55 /// properties and features specific to the target. 56 class MCAsmInfo { 57 public: 58 /// Assembly character literal syntax types. 59 enum AsmCharLiteralSyntax { 60 ACLS_Unknown, /// Unknown; character literals not used by LLVM for this 61 /// target. 62 ACLS_SingleQuotePrefix, /// The desired character is prefixed by a single 63 /// quote, e.g., `'A`. 64 }; 65 66 protected: 67 //===------------------------------------------------------------------===// 68 // Properties to be set by the target writer, used to configure asm printer. 69 // 70 71 /// Code pointer size in bytes. Default is 4. 72 unsigned CodePointerSize = 4; 73 74 /// Size of the stack slot reserved for callee-saved registers, in bytes. 75 /// Default is same as pointer size. 76 unsigned CalleeSaveStackSlotSize = 4; 77 78 /// True if target is little endian. Default is true. 79 bool IsLittleEndian = true; 80 81 /// True if target stack grow up. Default is false. 82 bool StackGrowsUp = false; 83 84 /// True if this target has the MachO .subsections_via_symbols directive. 85 /// Default is false. 86 bool HasSubsectionsViaSymbols = false; 87 88 /// True if this is a MachO target that supports the macho-specific .zerofill 89 /// directive for emitting BSS Symbols. Default is false. 90 bool HasMachoZeroFillDirective = false; 91 92 /// True if this is a MachO target that supports the macho-specific .tbss 93 /// directive for emitting thread local BSS Symbols. Default is false. 94 bool HasMachoTBSSDirective = false; 95 96 /// True if this is a non-GNU COFF target. The COFF port of the GNU linker 97 /// doesn't handle associative comdats in the way that we would like to use 98 /// them. 99 bool HasCOFFAssociativeComdats = false; 100 101 /// True if this is a non-GNU COFF target. For GNU targets, we don't generate 102 /// constants into comdat sections. 103 bool HasCOFFComdatConstants = false; 104 105 /// True if this is an XCOFF target that supports visibility attributes as 106 /// part of .global, .weak, .extern, and .comm. Default is false. 107 bool HasVisibilityOnlyWithLinkage = false; 108 109 /// This is the maximum possible length of an instruction, which is needed to 110 /// compute the size of an inline asm. Defaults to 4. 111 unsigned MaxInstLength = 4; 112 113 /// Every possible instruction length is a multiple of this value. Factored 114 /// out in .debug_frame and .debug_line. Defaults to 1. 115 unsigned MinInstAlignment = 1; 116 117 /// The '$' token, when not referencing an identifier or constant, refers to 118 /// the current PC. Defaults to false. 119 bool DollarIsPC = false; 120 121 /// Allow '.' token, when not referencing an identifier or constant, to refer 122 /// to the current PC. Defaults to true. 123 bool DotIsPC = true; 124 125 /// Whether the '*' token refers to the current PC. This is used for the 126 /// HLASM dialect. 127 bool StarIsPC = false; 128 129 /// This string, if specified, is used to separate instructions from each 130 /// other when on the same line. Defaults to ';' 131 const char *SeparatorString; 132 133 /// This indicates the comment string used by the assembler. Defaults to 134 /// "#" 135 StringRef CommentString; 136 137 /// This indicates whether the comment string is only accepted as a comment 138 /// at the beginning of statements. Defaults to false. 139 bool RestrictCommentStringToStartOfStatement = false; 140 141 /// This indicates whether to allow additional "comment strings" to be lexed 142 /// as a comment. Setting this attribute to true, will ensure that C-style 143 /// line comments (// ..), C-style block comments (/* .. */), and "#" are 144 /// all treated as comments in addition to the string specified by the 145 /// CommentString attribute. 146 /// Default is true. 147 bool AllowAdditionalComments = true; 148 149 /// Should we emit the '\t' as the starting indentation marker for GNU inline 150 /// asm statements. Defaults to true. 151 bool EmitGNUAsmStartIndentationMarker = true; 152 153 /// This is appended to emitted labels. Defaults to ":" 154 const char *LabelSuffix; 155 156 /// Emit labels in purely upper case. Defaults to false. 157 bool EmitLabelsInUpperCase = false; 158 159 // Print the EH begin symbol with an assignment. Defaults to false. 160 bool UseAssignmentForEHBegin = false; 161 162 // Do we need to create a local symbol for .size? 163 bool NeedsLocalForSize = false; 164 165 /// This prefix is used for globals like constant pool entries that are 166 /// completely private to the .s file and should not have names in the .o 167 /// file. Defaults to "L" 168 StringRef PrivateGlobalPrefix; 169 170 /// This prefix is used for labels for basic blocks. Defaults to the same as 171 /// PrivateGlobalPrefix. 172 StringRef PrivateLabelPrefix; 173 174 /// This prefix is used for symbols that should be passed through the 175 /// assembler but be removed by the linker. This is 'l' on Darwin, currently 176 /// used for some ObjC metadata. The default of "" meast that for this system 177 /// a plain private symbol should be used. Defaults to "". 178 StringRef LinkerPrivateGlobalPrefix; 179 180 /// If these are nonempty, they contain a directive to emit before and after 181 /// an inline assembly statement. Defaults to "#APP\n", "#NO_APP\n" 182 const char *InlineAsmStart; 183 const char *InlineAsmEnd; 184 185 /// These are assembly directives that tells the assembler to interpret the 186 /// following instructions differently. Defaults to ".code16", ".code32", 187 /// ".code64". 188 const char *Code16Directive; 189 const char *Code32Directive; 190 const char *Code64Directive; 191 192 /// Which dialect of an assembler variant to use. Defaults to 0 193 unsigned AssemblerDialect = 0; 194 195 /// This is true if the assembler allows @ characters in symbol names. 196 /// Defaults to false. 197 bool AllowAtInName = false; 198 199 /// This is true if the assembler allows the "?" character at the start of 200 /// of a string to be lexed as an AsmToken::Identifier. 201 /// If the AsmLexer determines that the string can be lexed as a possible 202 /// comment, setting this option will have no effect, and the string will 203 /// still be lexed as a comment. 204 bool AllowQuestionAtStartOfIdentifier = false; 205 206 /// This is true if the assembler allows the "$" character at the start of 207 /// of a string to be lexed as an AsmToken::Identifier. 208 /// If the AsmLexer determines that the string can be lexed as a possible 209 /// comment, setting this option will have no effect, and the string will 210 /// still be lexed as a comment. 211 bool AllowDollarAtStartOfIdentifier = false; 212 213 /// This is true if the assembler allows the "@" character at the start of 214 /// a string to be lexed as an AsmToken::Identifier. 215 /// If the AsmLexer determines that the string can be lexed as a possible 216 /// comment, setting this option will have no effect, and the string will 217 /// still be lexed as a comment. 218 bool AllowAtAtStartOfIdentifier = false; 219 220 /// This is true if the assembler allows the "#" character at the start of 221 /// a string to be lexed as an AsmToken::Identifier. 222 /// If the AsmLexer determines that the string can be lexed as a possible 223 /// comment, setting this option will have no effect, and the string will 224 /// still be lexed as a comment. 225 bool AllowHashAtStartOfIdentifier = false; 226 227 /// If this is true, symbol names with invalid characters will be printed in 228 /// quotes. 229 bool SupportsQuotedNames = true; 230 231 /// This is true if data region markers should be printed as 232 /// ".data_region/.end_data_region" directives. If false, use "$d/$a" labels 233 /// instead. 234 bool UseDataRegionDirectives = false; 235 236 /// True if .align is to be used for alignment. Only power-of-two 237 /// alignment is supported. 238 bool UseDotAlignForAlignment = false; 239 240 /// True if the target supports LEB128 directives. 241 bool HasLEB128Directives = true; 242 243 //===--- Data Emission Directives -------------------------------------===// 244 245 /// This should be set to the directive used to get some number of zero (and 246 /// non-zero if supported by the directive) bytes emitted to the current 247 /// section. Common cases are "\t.zero\t" and "\t.space\t". Defaults to 248 /// "\t.zero\t" 249 const char *ZeroDirective; 250 251 /// This should be set to true if the zero directive supports a value to emit 252 /// other than zero. If this is set to false, the Data*bitsDirective's will be 253 /// used to emit these bytes. Defaults to true. 254 bool ZeroDirectiveSupportsNonZeroValue = true; 255 256 /// This directive allows emission of an ascii string with the standard C 257 /// escape characters embedded into it. If a target doesn't support this, it 258 /// can be set to null. Defaults to "\t.ascii\t" 259 const char *AsciiDirective; 260 261 /// If not null, this allows for special handling of zero terminated strings 262 /// on this target. This is commonly supported as ".asciz". If a target 263 /// doesn't support this, it can be set to null. Defaults to "\t.asciz\t" 264 const char *AscizDirective; 265 266 /// This directive accepts a comma-separated list of bytes for emission as a 267 /// string of bytes. For targets that do not support this, it shall be set to 268 /// null. Defaults to null. 269 const char *ByteListDirective = nullptr; 270 271 /// This directive allows emission of a zero-terminated ascii string without 272 /// the standard C escape characters embedded into it. If a target doesn't 273 /// support this, it can be set to null. Defaults to null. 274 const char *PlainStringDirective = nullptr; 275 276 /// Form used for character literals in the assembly syntax. Useful for 277 /// producing strings as byte lists. If a target does not use or support 278 /// this, it shall be set to ACLS_Unknown. Defaults to ACLS_Unknown. 279 AsmCharLiteralSyntax CharacterLiteralSyntax = ACLS_Unknown; 280 281 /// These directives are used to output some unit of integer data to the 282 /// current section. If a data directive is set to null, smaller data 283 /// directives will be used to emit the large sizes. Defaults to "\t.byte\t", 284 /// "\t.short\t", "\t.long\t", "\t.quad\t" 285 const char *Data8bitsDirective; 286 const char *Data16bitsDirective; 287 const char *Data32bitsDirective; 288 const char *Data64bitsDirective; 289 290 /// True if data directives support signed values 291 bool SupportsSignedData = true; 292 293 /// If non-null, a directive that is used to emit a word which should be 294 /// relocated as a 64-bit GP-relative offset, e.g. .gpdword on Mips. Defaults 295 /// to nullptr. 296 const char *GPRel64Directive = nullptr; 297 298 /// If non-null, a directive that is used to emit a word which should be 299 /// relocated as a 32-bit GP-relative offset, e.g. .gpword on Mips or .gprel32 300 /// on Alpha. Defaults to nullptr. 301 const char *GPRel32Directive = nullptr; 302 303 /// If non-null, directives that are used to emit a word/dword which should 304 /// be relocated as a 32/64-bit DTP/TP-relative offset, e.g. .dtprelword/ 305 /// .dtpreldword/.tprelword/.tpreldword on Mips. 306 const char *DTPRel32Directive = nullptr; 307 const char *DTPRel64Directive = nullptr; 308 const char *TPRel32Directive = nullptr; 309 const char *TPRel64Directive = nullptr; 310 311 /// This is true if this target uses "Sun Style" syntax for section switching 312 /// ("#alloc,#write" etc) instead of the normal ELF syntax (,"a,w") in 313 /// .section directives. Defaults to false. 314 bool SunStyleELFSectionSwitchSyntax = false; 315 316 /// This is true if this target uses ELF '.section' directive before the 317 /// '.bss' one. It's used for PPC/Linux which doesn't support the '.bss' 318 /// directive only. Defaults to false. 319 bool UsesELFSectionDirectiveForBSS = false; 320 321 bool NeedsDwarfSectionOffsetDirective = false; 322 323 //===--- Alignment Information ----------------------------------------===// 324 325 /// If this is true (the default) then the asmprinter emits ".align N" 326 /// directives, where N is the number of bytes to align to. Otherwise, it 327 /// emits ".align log2(N)", e.g. 3 to align to an 8 byte boundary. Defaults 328 /// to true. 329 bool AlignmentIsInBytes = true; 330 331 /// If non-zero, this is used to fill the executable space created as the 332 /// result of a alignment directive. Defaults to 0 333 unsigned TextAlignFillValue = 0; 334 335 //===--- Global Variable Emission Directives --------------------------===// 336 337 /// This is the directive used to declare a global entity. Defaults to 338 /// ".globl". 339 const char *GlobalDirective; 340 341 /// True if the expression 342 /// .long f - g 343 /// uses a relocation but it can be suppressed by writing 344 /// a = f - g 345 /// .long a 346 bool SetDirectiveSuppressesReloc = false; 347 348 /// False if the assembler requires that we use 349 /// \code 350 /// Lc = a - b 351 /// .long Lc 352 /// \endcode 353 // 354 /// instead of 355 // 356 /// \code 357 /// .long a - b 358 /// \endcode 359 /// 360 /// Defaults to true. 361 bool HasAggressiveSymbolFolding = true; 362 363 /// True is .comm's and .lcomms optional alignment is to be specified in bytes 364 /// instead of log2(n). Defaults to true. 365 bool COMMDirectiveAlignmentIsInBytes = true; 366 367 /// Describes if the .lcomm directive for the target supports an alignment 368 /// argument and how it is interpreted. Defaults to NoAlignment. 369 LCOMM::LCOMMType LCOMMDirectiveAlignmentType = LCOMM::NoAlignment; 370 371 /// True if the target only has basename for .file directive. False if the 372 /// target also needs the directory along with the basename. Defaults to true. 373 bool HasBasenameOnlyForFileDirective = true; 374 375 /// True if the target represents string constants as mostly raw characters in 376 /// paired double quotation with paired double quotation marks as the escape 377 /// mechanism to represent a double quotation mark within the string. Defaults 378 /// to false. 379 bool HasPairedDoubleQuoteStringConstants = false; 380 381 // True if the target allows .align directives on functions. This is true for 382 // most targets, so defaults to true. 383 bool HasFunctionAlignment = true; 384 385 /// True if the target has .type and .size directives, this is true for most 386 /// ELF targets. Defaults to true. 387 bool HasDotTypeDotSizeDirective = true; 388 389 /// True if the target has a single parameter .file directive, this is true 390 /// for ELF targets. Defaults to true. 391 bool HasSingleParameterDotFile = true; 392 393 /// True if the target has a four strings .file directive, strings seperated 394 /// by comma. Defaults to false. 395 bool HasFourStringsDotFile = false; 396 397 /// True if the target has a .ident directive, this is true for ELF targets. 398 /// Defaults to false. 399 bool HasIdentDirective = false; 400 401 /// True if this target supports the MachO .no_dead_strip directive. Defaults 402 /// to false. 403 bool HasNoDeadStrip = false; 404 405 /// True if this target supports the MachO .alt_entry directive. Defaults to 406 /// false. 407 bool HasAltEntry = false; 408 409 /// Used to declare a global as being a weak symbol. Defaults to ".weak". 410 const char *WeakDirective; 411 412 /// This directive, if non-null, is used to declare a global as being a weak 413 /// undefined symbol. Defaults to nullptr. 414 const char *WeakRefDirective = nullptr; 415 416 /// True if we have a directive to declare a global as being a weak defined 417 /// symbol. Defaults to false. 418 bool HasWeakDefDirective = false; 419 420 /// True if we have a directive to declare a global as being a weak defined 421 /// symbol that can be hidden (unexported). Defaults to false. 422 bool HasWeakDefCanBeHiddenDirective = false; 423 424 /// True if we should mark symbols as global instead of weak, for 425 /// weak*/linkonce*, if the symbol has a comdat. 426 /// Defaults to false. 427 bool AvoidWeakIfComdat = false; 428 429 /// This attribute, if not MCSA_Invalid, is used to declare a symbol as having 430 /// hidden visibility. Defaults to MCSA_Hidden. 431 MCSymbolAttr HiddenVisibilityAttr = MCSA_Hidden; 432 433 /// This attribute, if not MCSA_Invalid, is used to declare an undefined 434 /// symbol as having hidden visibility. Defaults to MCSA_Hidden. 435 MCSymbolAttr HiddenDeclarationVisibilityAttr = MCSA_Hidden; 436 437 /// This attribute, if not MCSA_Invalid, is used to declare a symbol as having 438 /// protected visibility. Defaults to MCSA_Protected 439 MCSymbolAttr ProtectedVisibilityAttr = MCSA_Protected; 440 441 //===--- Dwarf Emission Directives -----------------------------------===// 442 443 /// True if target supports emission of debugging information. Defaults to 444 /// false. 445 bool SupportsDebugInformation = false; 446 447 /// Exception handling format for the target. Defaults to None. 448 ExceptionHandling ExceptionsType = ExceptionHandling::None; 449 450 /// True if target uses CFI unwind information for debugging purpose when 451 /// `ExceptionsType == ExceptionHandling::None`. 452 bool UsesCFIForDebug = false; 453 454 /// Windows exception handling data (.pdata) encoding. Defaults to Invalid. 455 WinEH::EncodingType WinEHEncodingType = WinEH::EncodingType::Invalid; 456 457 /// True if Dwarf2 output generally uses relocations for references to other 458 /// .debug_* sections. 459 bool DwarfUsesRelocationsAcrossSections = true; 460 461 /// True if DWARF FDE symbol reference relocations should be replaced by an 462 /// absolute difference. 463 bool DwarfFDESymbolsUseAbsDiff = false; 464 465 /// True if the target supports generating the DWARF line table through using 466 /// the .loc/.file directives. Defaults to true. 467 bool UsesDwarfFileAndLocDirectives = true; 468 469 /// True if the target needs the DWARF section length in the header (if any) 470 /// of the DWARF section in the assembly file. Defaults to true. 471 bool DwarfSectionSizeRequired = true; 472 473 /// True if dwarf register numbers are printed instead of symbolic register 474 /// names in .cfi_* directives. Defaults to false. 475 bool DwarfRegNumForCFI = false; 476 477 /// True if target uses parens to indicate the symbol variant instead of @. 478 /// For example, foo(plt) instead of foo@plt. Defaults to false. 479 bool UseParensForSymbolVariant = false; 480 481 /// True if the target supports flags in ".loc" directive, false if only 482 /// location is allowed. 483 bool SupportsExtendedDwarfLocDirective = true; 484 485 //===--- Prologue State ----------------------------------------------===// 486 487 std::vector<MCCFIInstruction> InitialFrameState; 488 489 //===--- Integrated Assembler Information ----------------------------===// 490 491 // Generated object files can use all ELF features supported by GNU ld of 492 // this binutils version and later. INT_MAX means all features can be used, 493 // regardless of GNU ld support. The default value is referenced by 494 // clang/Driver/Options.td. 495 std::pair<int, int> BinutilsVersion = {2, 26}; 496 497 /// Should we use the integrated assembler? 498 /// The integrated assembler should be enabled by default (by the 499 /// constructors) when failing to parse a valid piece of assembly (inline 500 /// or otherwise) is considered a bug. It may then be overridden after 501 /// construction (see LLVMTargetMachine::initAsmInfo()). 502 bool UseIntegratedAssembler; 503 504 /// Use AsmParser to parse inlineAsm when UseIntegratedAssembler is not set. 505 bool ParseInlineAsmUsingAsmParser; 506 507 /// Preserve Comments in assembly 508 bool PreserveAsmComments; 509 510 /// Compress DWARF debug sections. Defaults to no compression. 511 DebugCompressionType CompressDebugSections = DebugCompressionType::None; 512 513 /// True if the integrated assembler should interpret 'a >> b' constant 514 /// expressions as logical rather than arithmetic. 515 bool UseLogicalShr = true; 516 517 // If true, emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL, on 518 // X86_64 ELF. 519 bool RelaxELFRelocations = true; 520 521 // If true, then the lexer and expression parser will support %neg(), 522 // %hi(), and similar unary operators. 523 bool HasMipsExpressions = false; 524 525 // If true, use Motorola-style integers in Assembly (ex. $0ac). 526 bool UseMotorolaIntegers = false; 527 528 // If true, emit function descriptor symbol on AIX. 529 bool NeedsFunctionDescriptors = false; 530 531 public: 532 explicit MCAsmInfo(); 533 virtual ~MCAsmInfo(); 534 535 /// Get the code pointer size in bytes. getCodePointerSize()536 unsigned getCodePointerSize() const { return CodePointerSize; } 537 538 /// Get the callee-saved register stack slot 539 /// size in bytes. getCalleeSaveStackSlotSize()540 unsigned getCalleeSaveStackSlotSize() const { 541 return CalleeSaveStackSlotSize; 542 } 543 544 /// True if the target is little endian. isLittleEndian()545 bool isLittleEndian() const { return IsLittleEndian; } 546 547 /// True if target stack grow up. isStackGrowthDirectionUp()548 bool isStackGrowthDirectionUp() const { return StackGrowsUp; } 549 hasSubsectionsViaSymbols()550 bool hasSubsectionsViaSymbols() const { return HasSubsectionsViaSymbols; } 551 552 // Data directive accessors. 553 getData8bitsDirective()554 const char *getData8bitsDirective() const { return Data8bitsDirective; } getData16bitsDirective()555 const char *getData16bitsDirective() const { return Data16bitsDirective; } getData32bitsDirective()556 const char *getData32bitsDirective() const { return Data32bitsDirective; } getData64bitsDirective()557 const char *getData64bitsDirective() const { return Data64bitsDirective; } supportsSignedData()558 bool supportsSignedData() const { return SupportsSignedData; } getGPRel64Directive()559 const char *getGPRel64Directive() const { return GPRel64Directive; } getGPRel32Directive()560 const char *getGPRel32Directive() const { return GPRel32Directive; } getDTPRel64Directive()561 const char *getDTPRel64Directive() const { return DTPRel64Directive; } getDTPRel32Directive()562 const char *getDTPRel32Directive() const { return DTPRel32Directive; } getTPRel64Directive()563 const char *getTPRel64Directive() const { return TPRel64Directive; } getTPRel32Directive()564 const char *getTPRel32Directive() const { return TPRel32Directive; } 565 566 /// Targets can implement this method to specify a section to switch to if the 567 /// translation unit doesn't have any trampolines that require an executable 568 /// stack. getNonexecutableStackSection(MCContext & Ctx)569 virtual MCSection *getNonexecutableStackSection(MCContext &Ctx) const { 570 return nullptr; 571 } 572 573 /// True if the section is atomized using the symbols in it. 574 /// This is false if the section is not atomized at all (most ELF sections) or 575 /// if it is atomized based on its contents (MachO' __TEXT,__cstring for 576 /// example). 577 virtual bool isSectionAtomizableBySymbols(const MCSection &Section) const; 578 579 virtual const MCExpr *getExprForPersonalitySymbol(const MCSymbol *Sym, 580 unsigned Encoding, 581 MCStreamer &Streamer) const; 582 583 virtual const MCExpr *getExprForFDESymbol(const MCSymbol *Sym, 584 unsigned Encoding, 585 MCStreamer &Streamer) const; 586 587 /// Return true if C is an acceptable character inside a symbol name. 588 virtual bool isAcceptableChar(char C) const; 589 590 /// Return true if the identifier \p Name does not need quotes to be 591 /// syntactically correct. 592 virtual bool isValidUnquotedName(StringRef Name) const; 593 594 /// Return true if the .section directive should be omitted when 595 /// emitting \p SectionName. For example: 596 /// 597 /// shouldOmitSectionDirective(".text") 598 /// 599 /// returns false => .section .text,#alloc,#execinstr 600 /// returns true => .text 601 virtual bool shouldOmitSectionDirective(StringRef SectionName) const; 602 usesSunStyleELFSectionSwitchSyntax()603 bool usesSunStyleELFSectionSwitchSyntax() const { 604 return SunStyleELFSectionSwitchSyntax; 605 } 606 usesELFSectionDirectiveForBSS()607 bool usesELFSectionDirectiveForBSS() const { 608 return UsesELFSectionDirectiveForBSS; 609 } 610 needsDwarfSectionOffsetDirective()611 bool needsDwarfSectionOffsetDirective() const { 612 return NeedsDwarfSectionOffsetDirective; 613 } 614 615 // Accessors. 616 hasMachoZeroFillDirective()617 bool hasMachoZeroFillDirective() const { return HasMachoZeroFillDirective; } hasMachoTBSSDirective()618 bool hasMachoTBSSDirective() const { return HasMachoTBSSDirective; } hasCOFFAssociativeComdats()619 bool hasCOFFAssociativeComdats() const { return HasCOFFAssociativeComdats; } hasCOFFComdatConstants()620 bool hasCOFFComdatConstants() const { return HasCOFFComdatConstants; } hasVisibilityOnlyWithLinkage()621 bool hasVisibilityOnlyWithLinkage() const { 622 return HasVisibilityOnlyWithLinkage; 623 } 624 625 /// Returns the maximum possible encoded instruction size in bytes. If \p STI 626 /// is null, this should be the maximum size for any subtarget. 627 virtual unsigned getMaxInstLength(const MCSubtargetInfo *STI = nullptr) const { 628 return MaxInstLength; 629 } 630 getMinInstAlignment()631 unsigned getMinInstAlignment() const { return MinInstAlignment; } getDollarIsPC()632 bool getDollarIsPC() const { return DollarIsPC; } getDotIsPC()633 bool getDotIsPC() const { return DotIsPC; } getStarIsPC()634 bool getStarIsPC() const { return StarIsPC; } getSeparatorString()635 const char *getSeparatorString() const { return SeparatorString; } 636 637 /// This indicates the column (zero-based) at which asm comments should be 638 /// printed. getCommentColumn()639 unsigned getCommentColumn() const { return 40; } 640 getCommentString()641 StringRef getCommentString() const { return CommentString; } getRestrictCommentStringToStartOfStatement()642 bool getRestrictCommentStringToStartOfStatement() const { 643 return RestrictCommentStringToStartOfStatement; 644 } shouldAllowAdditionalComments()645 bool shouldAllowAdditionalComments() const { return AllowAdditionalComments; } getEmitGNUAsmStartIndentationMarker()646 bool getEmitGNUAsmStartIndentationMarker() const { 647 return EmitGNUAsmStartIndentationMarker; 648 } getLabelSuffix()649 const char *getLabelSuffix() const { return LabelSuffix; } shouldEmitLabelsInUpperCase()650 bool shouldEmitLabelsInUpperCase() const { return EmitLabelsInUpperCase; } 651 useAssignmentForEHBegin()652 bool useAssignmentForEHBegin() const { return UseAssignmentForEHBegin; } needsLocalForSize()653 bool needsLocalForSize() const { return NeedsLocalForSize; } getPrivateGlobalPrefix()654 StringRef getPrivateGlobalPrefix() const { return PrivateGlobalPrefix; } getPrivateLabelPrefix()655 StringRef getPrivateLabelPrefix() const { return PrivateLabelPrefix; } 656 hasLinkerPrivateGlobalPrefix()657 bool hasLinkerPrivateGlobalPrefix() const { 658 return !LinkerPrivateGlobalPrefix.empty(); 659 } 660 getLinkerPrivateGlobalPrefix()661 StringRef getLinkerPrivateGlobalPrefix() const { 662 if (hasLinkerPrivateGlobalPrefix()) 663 return LinkerPrivateGlobalPrefix; 664 return getPrivateGlobalPrefix(); 665 } 666 getInlineAsmStart()667 const char *getInlineAsmStart() const { return InlineAsmStart; } getInlineAsmEnd()668 const char *getInlineAsmEnd() const { return InlineAsmEnd; } getCode16Directive()669 const char *getCode16Directive() const { return Code16Directive; } getCode32Directive()670 const char *getCode32Directive() const { return Code32Directive; } getCode64Directive()671 const char *getCode64Directive() const { return Code64Directive; } getAssemblerDialect()672 unsigned getAssemblerDialect() const { return AssemblerDialect; } doesAllowAtInName()673 bool doesAllowAtInName() const { return AllowAtInName; } doesAllowQuestionAtStartOfIdentifier()674 bool doesAllowQuestionAtStartOfIdentifier() const { 675 return AllowQuestionAtStartOfIdentifier; 676 } doesAllowAtAtStartOfIdentifier()677 bool doesAllowAtAtStartOfIdentifier() const { 678 return AllowAtAtStartOfIdentifier; 679 } doesAllowDollarAtStartOfIdentifier()680 bool doesAllowDollarAtStartOfIdentifier() const { 681 return AllowDollarAtStartOfIdentifier; 682 } doesAllowHashAtStartOfIdentifier()683 bool doesAllowHashAtStartOfIdentifier() const { 684 return AllowHashAtStartOfIdentifier; 685 } supportsNameQuoting()686 bool supportsNameQuoting() const { return SupportsQuotedNames; } 687 doesSupportDataRegionDirectives()688 bool doesSupportDataRegionDirectives() const { 689 return UseDataRegionDirectives; 690 } 691 useDotAlignForAlignment()692 bool useDotAlignForAlignment() const { 693 return UseDotAlignForAlignment; 694 } 695 hasLEB128Directives()696 bool hasLEB128Directives() const { return HasLEB128Directives; } 697 getZeroDirective()698 const char *getZeroDirective() const { return ZeroDirective; } doesZeroDirectiveSupportNonZeroValue()699 bool doesZeroDirectiveSupportNonZeroValue() const { 700 return ZeroDirectiveSupportsNonZeroValue; 701 } getAsciiDirective()702 const char *getAsciiDirective() const { return AsciiDirective; } getAscizDirective()703 const char *getAscizDirective() const { return AscizDirective; } getByteListDirective()704 const char *getByteListDirective() const { return ByteListDirective; } getPlainStringDirective()705 const char *getPlainStringDirective() const { return PlainStringDirective; } characterLiteralSyntax()706 AsmCharLiteralSyntax characterLiteralSyntax() const { 707 return CharacterLiteralSyntax; 708 } getAlignmentIsInBytes()709 bool getAlignmentIsInBytes() const { return AlignmentIsInBytes; } getTextAlignFillValue()710 unsigned getTextAlignFillValue() const { return TextAlignFillValue; } getGlobalDirective()711 const char *getGlobalDirective() const { return GlobalDirective; } 712 doesSetDirectiveSuppressReloc()713 bool doesSetDirectiveSuppressReloc() const { 714 return SetDirectiveSuppressesReloc; 715 } 716 hasAggressiveSymbolFolding()717 bool hasAggressiveSymbolFolding() const { return HasAggressiveSymbolFolding; } 718 getCOMMDirectiveAlignmentIsInBytes()719 bool getCOMMDirectiveAlignmentIsInBytes() const { 720 return COMMDirectiveAlignmentIsInBytes; 721 } 722 getLCOMMDirectiveAlignmentType()723 LCOMM::LCOMMType getLCOMMDirectiveAlignmentType() const { 724 return LCOMMDirectiveAlignmentType; 725 } 726 hasBasenameOnlyForFileDirective()727 bool hasBasenameOnlyForFileDirective() const { 728 return HasBasenameOnlyForFileDirective; 729 } hasPairedDoubleQuoteStringConstants()730 bool hasPairedDoubleQuoteStringConstants() const { 731 return HasPairedDoubleQuoteStringConstants; 732 } hasFunctionAlignment()733 bool hasFunctionAlignment() const { return HasFunctionAlignment; } hasDotTypeDotSizeDirective()734 bool hasDotTypeDotSizeDirective() const { return HasDotTypeDotSizeDirective; } hasSingleParameterDotFile()735 bool hasSingleParameterDotFile() const { return HasSingleParameterDotFile; } hasFourStringsDotFile()736 bool hasFourStringsDotFile() const { return HasFourStringsDotFile; } hasIdentDirective()737 bool hasIdentDirective() const { return HasIdentDirective; } hasNoDeadStrip()738 bool hasNoDeadStrip() const { return HasNoDeadStrip; } hasAltEntry()739 bool hasAltEntry() const { return HasAltEntry; } getWeakDirective()740 const char *getWeakDirective() const { return WeakDirective; } getWeakRefDirective()741 const char *getWeakRefDirective() const { return WeakRefDirective; } hasWeakDefDirective()742 bool hasWeakDefDirective() const { return HasWeakDefDirective; } 743 hasWeakDefCanBeHiddenDirective()744 bool hasWeakDefCanBeHiddenDirective() const { 745 return HasWeakDefCanBeHiddenDirective; 746 } 747 avoidWeakIfComdat()748 bool avoidWeakIfComdat() const { return AvoidWeakIfComdat; } 749 getHiddenVisibilityAttr()750 MCSymbolAttr getHiddenVisibilityAttr() const { return HiddenVisibilityAttr; } 751 getHiddenDeclarationVisibilityAttr()752 MCSymbolAttr getHiddenDeclarationVisibilityAttr() const { 753 return HiddenDeclarationVisibilityAttr; 754 } 755 getProtectedVisibilityAttr()756 MCSymbolAttr getProtectedVisibilityAttr() const { 757 return ProtectedVisibilityAttr; 758 } 759 doesSupportDebugInformation()760 bool doesSupportDebugInformation() const { return SupportsDebugInformation; } 761 getExceptionHandlingType()762 ExceptionHandling getExceptionHandlingType() const { return ExceptionsType; } getWinEHEncodingType()763 WinEH::EncodingType getWinEHEncodingType() const { return WinEHEncodingType; } 764 setExceptionsType(ExceptionHandling EH)765 void setExceptionsType(ExceptionHandling EH) { 766 ExceptionsType = EH; 767 } 768 doesUseCFIForDebug()769 bool doesUseCFIForDebug() const { return UsesCFIForDebug; } 770 771 /// Returns true if the exception handling method for the platform uses call 772 /// frame information to unwind. usesCFIForEH()773 bool usesCFIForEH() const { 774 return (ExceptionsType == ExceptionHandling::DwarfCFI || 775 ExceptionsType == ExceptionHandling::ARM || usesWindowsCFI()); 776 } 777 usesWindowsCFI()778 bool usesWindowsCFI() const { 779 return ExceptionsType == ExceptionHandling::WinEH && 780 (WinEHEncodingType != WinEH::EncodingType::Invalid && 781 WinEHEncodingType != WinEH::EncodingType::X86); 782 } 783 doesDwarfUseRelocationsAcrossSections()784 bool doesDwarfUseRelocationsAcrossSections() const { 785 return DwarfUsesRelocationsAcrossSections; 786 } 787 doDwarfFDESymbolsUseAbsDiff()788 bool doDwarfFDESymbolsUseAbsDiff() const { return DwarfFDESymbolsUseAbsDiff; } useDwarfRegNumForCFI()789 bool useDwarfRegNumForCFI() const { return DwarfRegNumForCFI; } useParensForSymbolVariant()790 bool useParensForSymbolVariant() const { return UseParensForSymbolVariant; } supportsExtendedDwarfLocDirective()791 bool supportsExtendedDwarfLocDirective() const { 792 return SupportsExtendedDwarfLocDirective; 793 } 794 usesDwarfFileAndLocDirectives()795 bool usesDwarfFileAndLocDirectives() const { 796 return UsesDwarfFileAndLocDirectives; 797 } 798 needsDwarfSectionSizeInHeader()799 bool needsDwarfSectionSizeInHeader() const { 800 return DwarfSectionSizeRequired; 801 } 802 803 void addInitialFrameState(const MCCFIInstruction &Inst); 804 getInitialFrameState()805 const std::vector<MCCFIInstruction> &getInitialFrameState() const { 806 return InitialFrameState; 807 } 808 setBinutilsVersion(std::pair<int,int> Value)809 void setBinutilsVersion(std::pair<int, int> Value) { 810 BinutilsVersion = Value; 811 } 812 813 /// Return true if assembly (inline or otherwise) should be parsed. useIntegratedAssembler()814 bool useIntegratedAssembler() const { return UseIntegratedAssembler; } 815 816 /// Return true if target want to use AsmParser to parse inlineasm. parseInlineAsmUsingAsmParser()817 bool parseInlineAsmUsingAsmParser() const { 818 return ParseInlineAsmUsingAsmParser; 819 } 820 binutilsIsAtLeast(int Major,int Minor)821 bool binutilsIsAtLeast(int Major, int Minor) const { 822 return BinutilsVersion >= std::make_pair(Major, Minor); 823 } 824 825 /// Set whether assembly (inline or otherwise) should be parsed. setUseIntegratedAssembler(bool Value)826 virtual void setUseIntegratedAssembler(bool Value) { 827 UseIntegratedAssembler = Value; 828 } 829 830 /// Set whether target want to use AsmParser to parse inlineasm. setParseInlineAsmUsingAsmParser(bool Value)831 virtual void setParseInlineAsmUsingAsmParser(bool Value) { 832 ParseInlineAsmUsingAsmParser = Value; 833 } 834 835 /// Return true if assembly (inline or otherwise) should be parsed. preserveAsmComments()836 bool preserveAsmComments() const { return PreserveAsmComments; } 837 838 /// Set whether assembly (inline or otherwise) should be parsed. setPreserveAsmComments(bool Value)839 virtual void setPreserveAsmComments(bool Value) { 840 PreserveAsmComments = Value; 841 } 842 compressDebugSections()843 DebugCompressionType compressDebugSections() const { 844 return CompressDebugSections; 845 } 846 setCompressDebugSections(DebugCompressionType CompressDebugSections)847 void setCompressDebugSections(DebugCompressionType CompressDebugSections) { 848 this->CompressDebugSections = CompressDebugSections; 849 } 850 shouldUseLogicalShr()851 bool shouldUseLogicalShr() const { return UseLogicalShr; } 852 canRelaxRelocations()853 bool canRelaxRelocations() const { return RelaxELFRelocations; } setRelaxELFRelocations(bool V)854 void setRelaxELFRelocations(bool V) { RelaxELFRelocations = V; } hasMipsExpressions()855 bool hasMipsExpressions() const { return HasMipsExpressions; } needsFunctionDescriptors()856 bool needsFunctionDescriptors() const { return NeedsFunctionDescriptors; } shouldUseMotorolaIntegers()857 bool shouldUseMotorolaIntegers() const { return UseMotorolaIntegers; } 858 }; 859 860 } // end namespace llvm 861 862 #endif // LLVM_MC_MCASMINFO_H 863