LCOV - code coverage report
Current view: top level - include/llvm/MC - MCAsmInfo.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 20 122 16.4 %
Date: 2018-09-23 13:06:45 Functions: 4 89 4.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/MC/MCAsmInfo.h - Asm info --------------------------*- 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 basis for target specific
      11             : // asm writers.  This class primarily takes care of global printing constants,
      12             : // which are used in very similar ways across all targets.
      13             : //
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_MC_MCASMINFO_H
      17             : #define LLVM_MC_MCASMINFO_H
      18             : 
      19             : #include "llvm/ADT/StringRef.h"
      20             : #include "llvm/MC/MCDirectives.h"
      21             : #include "llvm/MC/MCDwarf.h"
      22             : #include "llvm/MC/MCTargetOptions.h"
      23             : #include <vector>
      24             : 
      25             : namespace llvm {
      26             : 
      27             : class MCContext;
      28             : class MCExpr;
      29             : class MCSection;
      30             : class MCStreamer;
      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       45183 : class MCAsmInfo {
      57             : protected:
      58             :   //===------------------------------------------------------------------===//
      59             :   // Properties to be set by the target writer, used to configure asm printer.
      60             :   //
      61             : 
      62             :   /// Code pointer size in bytes.  Default is 4.
      63             :   unsigned CodePointerSize = 4;
      64             : 
      65             :   /// Size of the stack slot reserved for callee-saved registers, in bytes.
      66             :   /// Default is same as pointer size.
      67             :   unsigned CalleeSaveStackSlotSize = 4;
      68             : 
      69             :   /// True if target is little endian.  Default is true.
      70             :   bool IsLittleEndian = true;
      71             : 
      72             :   /// True if target stack grow up.  Default is false.
      73             :   bool StackGrowsUp = false;
      74             : 
      75             :   /// True if this target has the MachO .subsections_via_symbols directive.
      76             :   /// Default is false.
      77             :   bool HasSubsectionsViaSymbols = false;
      78             : 
      79             :   /// True if this is a MachO target that supports the macho-specific .zerofill
      80             :   /// directive for emitting BSS Symbols.  Default is false.
      81             :   bool HasMachoZeroFillDirective = false;
      82             : 
      83             :   /// True if this is a MachO target that supports the macho-specific .tbss
      84             :   /// directive for emitting thread local BSS Symbols.  Default is false.
      85             :   bool HasMachoTBSSDirective = false;
      86             : 
      87             :   /// True if this is a non-GNU COFF target. The COFF port of the GNU linker
      88             :   /// doesn't handle associative comdats in the way that we would like to use
      89             :   /// them.
      90             :   bool HasCOFFAssociativeComdats = false;
      91             : 
      92             :   /// True if this is a non-GNU COFF target. For GNU targets, we don't generate
      93             :   /// constants into comdat sections.
      94             :   bool HasCOFFComdatConstants = false;
      95             : 
      96             :   /// This is the maximum possible length of an instruction, which is needed to
      97             :   /// compute the size of an inline asm.  Defaults to 4.
      98             :   unsigned MaxInstLength = 4;
      99             : 
     100             :   /// Every possible instruction length is a multiple of this value.  Factored
     101             :   /// out in .debug_frame and .debug_line.  Defaults to 1.
     102             :   unsigned MinInstAlignment = 1;
     103             : 
     104             :   /// The '$' token, when not referencing an identifier or constant, refers to
     105             :   /// the current PC.  Defaults to false.
     106             :   bool DollarIsPC = false;
     107             : 
     108             :   /// This string, if specified, is used to separate instructions from each
     109             :   /// other when on the same line.  Defaults to ';'
     110             :   const char *SeparatorString;
     111             : 
     112             :   /// This indicates the comment character used by the assembler.  Defaults to
     113             :   /// "#"
     114             :   StringRef CommentString;
     115             : 
     116             :   /// This is appended to emitted labels.  Defaults to ":"
     117             :   const char *LabelSuffix;
     118             : 
     119             :   // Print the EH begin symbol with an assignment. Defaults to false.
     120             :   bool UseAssignmentForEHBegin = false;
     121             : 
     122             :   // Do we need to create a local symbol for .size?
     123             :   bool NeedsLocalForSize = false;
     124             : 
     125             :   /// This prefix is used for globals like constant pool entries that are
     126             :   /// completely private to the .s file and should not have names in the .o
     127             :   /// file.  Defaults to "L"
     128             :   StringRef PrivateGlobalPrefix;
     129             : 
     130             :   /// This prefix is used for labels for basic blocks. Defaults to the same as
     131             :   /// PrivateGlobalPrefix.
     132             :   StringRef PrivateLabelPrefix;
     133             : 
     134             :   /// This prefix is used for symbols that should be passed through the
     135             :   /// assembler but be removed by the linker.  This is 'l' on Darwin, currently
     136             :   /// used for some ObjC metadata.  The default of "" meast that for this system
     137             :   /// a plain private symbol should be used.  Defaults to "".
     138             :   StringRef LinkerPrivateGlobalPrefix;
     139             : 
     140             :   /// If these are nonempty, they contain a directive to emit before and after
     141             :   /// an inline assembly statement.  Defaults to "#APP\n", "#NO_APP\n"
     142             :   const char *InlineAsmStart;
     143             :   const char *InlineAsmEnd;
     144             : 
     145             :   /// These are assembly directives that tells the assembler to interpret the
     146             :   /// following instructions differently.  Defaults to ".code16", ".code32",
     147             :   /// ".code64".
     148             :   const char *Code16Directive;
     149             :   const char *Code32Directive;
     150             :   const char *Code64Directive;
     151             : 
     152             :   /// Which dialect of an assembler variant to use.  Defaults to 0
     153             :   unsigned AssemblerDialect = 0;
     154             : 
     155             :   /// This is true if the assembler allows @ characters in symbol names.
     156             :   /// Defaults to false.
     157             :   bool AllowAtInName = false;
     158             : 
     159             :   /// If this is true, symbol names with invalid characters will be printed in
     160             :   /// quotes.
     161             :   bool SupportsQuotedNames = true;
     162             : 
     163             :   /// This is true if data region markers should be printed as
     164             :   /// ".data_region/.end_data_region" directives. If false, use "$d/$a" labels
     165             :   /// instead.
     166             :   bool UseDataRegionDirectives = false;
     167             : 
     168             :   //===--- Data Emission Directives -------------------------------------===//
     169             : 
     170             :   /// This should be set to the directive used to get some number of zero bytes
     171             :   /// emitted to the current section.  Common cases are "\t.zero\t" and
     172             :   /// "\t.space\t".  If this is set to null, the Data*bitsDirective's will be
     173             :   /// used to emit zero bytes.  Defaults to "\t.zero\t"
     174             :   const char *ZeroDirective;
     175             : 
     176             :   /// This directive allows emission of an ascii string with the standard C
     177             :   /// escape characters embedded into it.  If a target doesn't support this, it
     178             :   /// can be set to null. Defaults to "\t.ascii\t"
     179             :   const char *AsciiDirective;
     180             : 
     181             :   /// If not null, this allows for special handling of zero terminated strings
     182             :   /// on this target.  This is commonly supported as ".asciz".  If a target
     183             :   /// doesn't support this, it can be set to null.  Defaults to "\t.asciz\t"
     184             :   const char *AscizDirective;
     185             : 
     186             :   /// These directives are used to output some unit of integer data to the
     187             :   /// current section.  If a data directive is set to null, smaller data
     188             :   /// directives will be used to emit the large sizes.  Defaults to "\t.byte\t",
     189             :   /// "\t.short\t", "\t.long\t", "\t.quad\t"
     190             :   const char *Data8bitsDirective;
     191             :   const char *Data16bitsDirective;
     192             :   const char *Data32bitsDirective;
     193             :   const char *Data64bitsDirective;
     194             : 
     195             :   /// If non-null, a directive that is used to emit a word which should be
     196             :   /// relocated as a 64-bit GP-relative offset, e.g. .gpdword on Mips.  Defaults
     197             :   /// to nullptr.
     198             :   const char *GPRel64Directive = nullptr;
     199             : 
     200             :   /// If non-null, a directive that is used to emit a word which should be
     201             :   /// relocated as a 32-bit GP-relative offset, e.g. .gpword on Mips or .gprel32
     202             :   /// on Alpha.  Defaults to nullptr.
     203             :   const char *GPRel32Directive = nullptr;
     204             : 
     205             :   /// If non-null, directives that are used to emit a word/dword which should
     206             :   /// be relocated as a 32/64-bit DTP/TP-relative offset, e.g. .dtprelword/
     207             :   /// .dtpreldword/.tprelword/.tpreldword on Mips.
     208             :   const char *DTPRel32Directive = nullptr;
     209             :   const char *DTPRel64Directive = nullptr;
     210             :   const char *TPRel32Directive = nullptr;
     211             :   const char *TPRel64Directive = nullptr;
     212             : 
     213             :   /// This is true if this target uses "Sun Style" syntax for section switching
     214             :   /// ("#alloc,#write" etc) instead of the normal ELF syntax (,"a,w") in
     215             :   /// .section directives.  Defaults to false.
     216             :   bool SunStyleELFSectionSwitchSyntax = false;
     217             : 
     218             :   /// This is true if this target uses ELF '.section' directive before the
     219             :   /// '.bss' one. It's used for PPC/Linux which doesn't support the '.bss'
     220             :   /// directive only.  Defaults to false.
     221             :   bool UsesELFSectionDirectiveForBSS = false;
     222             : 
     223             :   bool NeedsDwarfSectionOffsetDirective = false;
     224             : 
     225             :   //===--- Alignment Information ----------------------------------------===//
     226             : 
     227             :   /// If this is true (the default) then the asmprinter emits ".align N"
     228             :   /// directives, where N is the number of bytes to align to.  Otherwise, it
     229             :   /// emits ".align log2(N)", e.g. 3 to align to an 8 byte boundary.  Defaults
     230             :   /// to true.
     231             :   bool AlignmentIsInBytes = true;
     232             : 
     233             :   /// If non-zero, this is used to fill the executable space created as the
     234             :   /// result of a alignment directive.  Defaults to 0
     235             :   unsigned TextAlignFillValue = 0;
     236             : 
     237             :   //===--- Global Variable Emission Directives --------------------------===//
     238             : 
     239             :   /// This is the directive used to declare a global entity. Defaults to
     240             :   /// ".globl".
     241             :   const char *GlobalDirective;
     242             : 
     243             :   /// True if the expression
     244             :   ///   .long f - g
     245             :   /// uses a relocation but it can be suppressed by writing
     246             :   ///   a = f - g
     247             :   ///   .long a
     248             :   bool SetDirectiveSuppressesReloc = false;
     249             : 
     250             :   /// False if the assembler requires that we use
     251             :   /// \code
     252             :   ///   Lc = a - b
     253             :   ///   .long Lc
     254             :   /// \endcode
     255             :   //
     256             :   /// instead of
     257             :   //
     258             :   /// \code
     259             :   ///   .long a - b
     260             :   /// \endcode
     261             :   ///
     262             :   ///  Defaults to true.
     263             :   bool HasAggressiveSymbolFolding = true;
     264             : 
     265             :   /// True is .comm's and .lcomms optional alignment is to be specified in bytes
     266             :   /// instead of log2(n).  Defaults to true.
     267             :   bool COMMDirectiveAlignmentIsInBytes = true;
     268             : 
     269             :   /// Describes if the .lcomm directive for the target supports an alignment
     270             :   /// argument and how it is interpreted.  Defaults to NoAlignment.
     271             :   LCOMM::LCOMMType LCOMMDirectiveAlignmentType = LCOMM::NoAlignment;
     272             : 
     273             :   // True if the target allows .align directives on functions. This is true for
     274             :   // most targets, so defaults to true.
     275             :   bool HasFunctionAlignment = true;
     276             : 
     277             :   /// True if the target has .type and .size directives, this is true for most
     278             :   /// ELF targets.  Defaults to true.
     279             :   bool HasDotTypeDotSizeDirective = true;
     280             : 
     281             :   /// True if the target has a single parameter .file directive, this is true
     282             :   /// for ELF targets.  Defaults to true.
     283             :   bool HasSingleParameterDotFile = true;
     284             : 
     285             :   /// True if the target has a .ident directive, this is true for ELF targets.
     286             :   /// Defaults to false.
     287             :   bool HasIdentDirective = false;
     288             : 
     289             :   /// True if this target supports the MachO .no_dead_strip directive.  Defaults
     290             :   /// to false.
     291             :   bool HasNoDeadStrip = false;
     292             : 
     293             :   /// True if this target supports the MachO .alt_entry directive.  Defaults to
     294             :   /// false.
     295             :   bool HasAltEntry = false;
     296             : 
     297             :   /// Used to declare a global as being a weak symbol. Defaults to ".weak".
     298             :   const char *WeakDirective;
     299             : 
     300             :   /// This directive, if non-null, is used to declare a global as being a weak
     301             :   /// undefined symbol.  Defaults to nullptr.
     302             :   const char *WeakRefDirective = nullptr;
     303             : 
     304             :   /// True if we have a directive to declare a global as being a weak defined
     305             :   /// symbol.  Defaults to false.
     306             :   bool HasWeakDefDirective = false;
     307             : 
     308             :   /// True if we have a directive to declare a global as being a weak defined
     309             :   /// symbol that can be hidden (unexported).  Defaults to false.
     310             :   bool HasWeakDefCanBeHiddenDirective = false;
     311             : 
     312             :   /// True if we have a .linkonce directive.  This is used on cygwin/mingw.
     313             :   /// Defaults to false.
     314             :   bool HasLinkOnceDirective = false;
     315             : 
     316             :   /// This attribute, if not MCSA_Invalid, is used to declare a symbol as having
     317             :   /// hidden visibility.  Defaults to MCSA_Hidden.
     318             :   MCSymbolAttr HiddenVisibilityAttr = MCSA_Hidden;
     319             : 
     320             :   /// This attribute, if not MCSA_Invalid, is used to declare an undefined
     321             :   /// symbol as having hidden visibility. Defaults to MCSA_Hidden.
     322             :   MCSymbolAttr HiddenDeclarationVisibilityAttr = MCSA_Hidden;
     323             : 
     324             :   /// This attribute, if not MCSA_Invalid, is used to declare a symbol as having
     325             :   /// protected visibility.  Defaults to MCSA_Protected
     326             :   MCSymbolAttr ProtectedVisibilityAttr = MCSA_Protected;
     327             : 
     328             :   //===--- Dwarf Emission Directives -----------------------------------===//
     329             : 
     330             :   /// True if target supports emission of debugging information.  Defaults to
     331             :   /// false.
     332             :   bool SupportsDebugInformation = false;
     333             : 
     334             :   /// Exception handling format for the target.  Defaults to None.
     335             :   ExceptionHandling ExceptionsType = ExceptionHandling::None;
     336             : 
     337             :   /// Windows exception handling data (.pdata) encoding.  Defaults to Invalid.
     338             :   WinEH::EncodingType WinEHEncodingType = WinEH::EncodingType::Invalid;
     339             : 
     340             :   /// True if Dwarf2 output generally uses relocations for references to other
     341             :   /// .debug_* sections.
     342             :   bool DwarfUsesRelocationsAcrossSections = true;
     343             : 
     344             :   /// True if DWARF FDE symbol reference relocations should be replaced by an
     345             :   /// absolute difference.
     346             :   bool DwarfFDESymbolsUseAbsDiff = false;
     347             : 
     348             :   /// True if dwarf register numbers are printed instead of symbolic register
     349             :   /// names in .cfi_* directives.  Defaults to false.
     350             :   bool DwarfRegNumForCFI = false;
     351             : 
     352             :   /// True if target uses parens to indicate the symbol variant instead of @.
     353             :   /// For example, foo(plt) instead of foo@plt.  Defaults to false.
     354             :   bool UseParensForSymbolVariant = false;
     355             : 
     356             :   /// True if the target supports flags in ".loc" directive, false if only
     357             :   /// location is allowed.
     358             :   bool SupportsExtendedDwarfLocDirective = true;
     359             : 
     360             :   //===--- Prologue State ----------------------------------------------===//
     361             : 
     362             :   std::vector<MCCFIInstruction> InitialFrameState;
     363             : 
     364             :   //===--- Integrated Assembler Information ----------------------------===//
     365             : 
     366             :   /// Should we use the integrated assembler?
     367             :   /// The integrated assembler should be enabled by default (by the
     368             :   /// constructors) when failing to parse a valid piece of assembly (inline
     369             :   /// or otherwise) is considered a bug. It may then be overridden after
     370             :   /// construction (see LLVMTargetMachine::initAsmInfo()).
     371             :   bool UseIntegratedAssembler;
     372             : 
     373             :   /// Preserve Comments in assembly
     374             :   bool PreserveAsmComments;
     375             : 
     376             :   /// Compress DWARF debug sections. Defaults to no compression.
     377             :   DebugCompressionType CompressDebugSections = DebugCompressionType::None;
     378             : 
     379             :   /// True if the integrated assembler should interpret 'a >> b' constant
     380             :   /// expressions as logical rather than arithmetic.
     381             :   bool UseLogicalShr = true;
     382             : 
     383             :   // If true, emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL, on
     384             :   // X86_64 ELF.
     385             :   bool RelaxELFRelocations = true;
     386             : 
     387             :   // If true, then the lexer and expression parser will support %neg(),
     388             :   // %hi(), and similar unary operators.
     389             :   bool HasMipsExpressions = false;
     390             : 
     391             : public:
     392             :   explicit MCAsmInfo();
     393             :   virtual ~MCAsmInfo();
     394             : 
     395             :   /// Get the code pointer size in bytes.
     396           0 :   unsigned getCodePointerSize() const { return CodePointerSize; }
     397             : 
     398             :   /// Get the callee-saved register stack slot
     399             :   /// size in bytes.
     400           0 :   unsigned getCalleeSaveStackSlotSize() const {
     401           0 :     return CalleeSaveStackSlotSize;
     402             :   }
     403             : 
     404             :   /// True if the target is little endian.
     405           0 :   bool isLittleEndian() const { return IsLittleEndian; }
     406             : 
     407             :   /// True if target stack grow up.
     408           0 :   bool isStackGrowthDirectionUp() const { return StackGrowsUp; }
     409             : 
     410           0 :   bool hasSubsectionsViaSymbols() const { return HasSubsectionsViaSymbols; }
     411             : 
     412             :   // Data directive accessors.
     413             : 
     414           0 :   const char *getData8bitsDirective() const { return Data8bitsDirective; }
     415           0 :   const char *getData16bitsDirective() const { return Data16bitsDirective; }
     416           0 :   const char *getData32bitsDirective() const { return Data32bitsDirective; }
     417           0 :   const char *getData64bitsDirective() const { return Data64bitsDirective; }
     418           0 :   const char *getGPRel64Directive() const { return GPRel64Directive; }
     419           0 :   const char *getGPRel32Directive() const { return GPRel32Directive; }
     420           0 :   const char *getDTPRel64Directive() const { return DTPRel64Directive; }
     421           0 :   const char *getDTPRel32Directive() const { return DTPRel32Directive; }
     422           0 :   const char *getTPRel64Directive() const { return TPRel64Directive; }
     423           0 :   const char *getTPRel32Directive() const { return TPRel32Directive; }
     424             : 
     425             :   /// Targets can implement this method to specify a section to switch to if the
     426             :   /// translation unit doesn't have any trampolines that require an executable
     427             :   /// stack.
     428        3890 :   virtual MCSection *getNonexecutableStackSection(MCContext &Ctx) const {
     429        3890 :     return nullptr;
     430             :   }
     431             : 
     432             :   /// True if the section is atomized using the symbols in it.
     433             :   /// This is false if the section is not atomized at all (most ELF sections) or
     434             :   /// if it is atomized based on its contents (MachO' __TEXT,__cstring for
     435             :   /// example).
     436             :   virtual bool isSectionAtomizableBySymbols(const MCSection &Section) const;
     437             : 
     438             :   virtual const MCExpr *getExprForPersonalitySymbol(const MCSymbol *Sym,
     439             :                                                     unsigned Encoding,
     440             :                                                     MCStreamer &Streamer) const;
     441             : 
     442             :   virtual const MCExpr *getExprForFDESymbol(const MCSymbol *Sym,
     443             :                                             unsigned Encoding,
     444             :                                             MCStreamer &Streamer) const;
     445             : 
     446             :   /// Return true if the identifier \p Name does not need quotes to be
     447             :   /// syntactically correct.
     448             :   virtual bool isValidUnquotedName(StringRef Name) const;
     449             : 
     450             :   /// Return true if the .section directive should be omitted when
     451             :   /// emitting \p SectionName.  For example:
     452             :   ///
     453             :   /// shouldOmitSectionDirective(".text")
     454             :   ///
     455             :   /// returns false => .section .text,#alloc,#execinstr
     456             :   /// returns true  => .text
     457             :   virtual bool shouldOmitSectionDirective(StringRef SectionName) const;
     458             : 
     459           0 :   bool usesSunStyleELFSectionSwitchSyntax() const {
     460           0 :     return SunStyleELFSectionSwitchSyntax;
     461             :   }
     462             : 
     463           0 :   bool usesELFSectionDirectiveForBSS() const {
     464           0 :     return UsesELFSectionDirectiveForBSS;
     465             :   }
     466             : 
     467           0 :   bool needsDwarfSectionOffsetDirective() const {
     468           0 :     return NeedsDwarfSectionOffsetDirective;
     469             :   }
     470             : 
     471             :   // Accessors.
     472             : 
     473           0 :   bool hasMachoZeroFillDirective() const { return HasMachoZeroFillDirective; }
     474           0 :   bool hasMachoTBSSDirective() const { return HasMachoTBSSDirective; }
     475           0 :   bool hasCOFFAssociativeComdats() const { return HasCOFFAssociativeComdats; }
     476           0 :   bool hasCOFFComdatConstants() const { return HasCOFFComdatConstants; }
     477           0 :   unsigned getMaxInstLength() const { return MaxInstLength; }
     478           0 :   unsigned getMinInstAlignment() const { return MinInstAlignment; }
     479           0 :   bool getDollarIsPC() const { return DollarIsPC; }
     480           0 :   const char *getSeparatorString() const { return SeparatorString; }
     481             : 
     482             :   /// This indicates the column (zero-based) at which asm comments should be
     483             :   /// printed.
     484           0 :   unsigned getCommentColumn() const { return 40; }
     485             : 
     486           0 :   StringRef getCommentString() const { return CommentString; }
     487           0 :   const char *getLabelSuffix() const { return LabelSuffix; }
     488             : 
     489           0 :   bool useAssignmentForEHBegin() const { return UseAssignmentForEHBegin; }
     490           0 :   bool needsLocalForSize() const { return NeedsLocalForSize; }
     491           0 :   StringRef getPrivateGlobalPrefix() const { return PrivateGlobalPrefix; }
     492           0 :   StringRef getPrivateLabelPrefix() const { return PrivateLabelPrefix; }
     493             : 
     494             :   bool hasLinkerPrivateGlobalPrefix() const {
     495          87 :     return LinkerPrivateGlobalPrefix[0] != '\0';
     496             :   }
     497             : 
     498             :   StringRef getLinkerPrivateGlobalPrefix() const {
     499          87 :     if (hasLinkerPrivateGlobalPrefix())
     500          87 :       return LinkerPrivateGlobalPrefix;
     501             :     return getPrivateGlobalPrefix();
     502             :   }
     503             : 
     504           0 :   const char *getInlineAsmStart() const { return InlineAsmStart; }
     505           0 :   const char *getInlineAsmEnd() const { return InlineAsmEnd; }
     506           0 :   const char *getCode16Directive() const { return Code16Directive; }
     507           0 :   const char *getCode32Directive() const { return Code32Directive; }
     508           0 :   const char *getCode64Directive() const { return Code64Directive; }
     509           0 :   unsigned getAssemblerDialect() const { return AssemblerDialect; }
     510           0 :   bool doesAllowAtInName() const { return AllowAtInName; }
     511           0 :   bool supportsNameQuoting() const { return SupportsQuotedNames; }
     512             : 
     513           0 :   bool doesSupportDataRegionDirectives() const {
     514           0 :     return UseDataRegionDirectives;
     515             :   }
     516             : 
     517           0 :   const char *getZeroDirective() const { return ZeroDirective; }
     518           0 :   const char *getAsciiDirective() const { return AsciiDirective; }
     519           0 :   const char *getAscizDirective() const { return AscizDirective; }
     520           0 :   bool getAlignmentIsInBytes() const { return AlignmentIsInBytes; }
     521           0 :   unsigned getTextAlignFillValue() const { return TextAlignFillValue; }
     522           0 :   const char *getGlobalDirective() const { return GlobalDirective; }
     523             : 
     524           0 :   bool doesSetDirectiveSuppressReloc() const {
     525           0 :     return SetDirectiveSuppressesReloc;
     526             :   }
     527             : 
     528           0 :   bool hasAggressiveSymbolFolding() const { return HasAggressiveSymbolFolding; }
     529             : 
     530           0 :   bool getCOMMDirectiveAlignmentIsInBytes() const {
     531           0 :     return COMMDirectiveAlignmentIsInBytes;
     532             :   }
     533             : 
     534           0 :   LCOMM::LCOMMType getLCOMMDirectiveAlignmentType() const {
     535           0 :     return LCOMMDirectiveAlignmentType;
     536             :   }
     537             : 
     538           0 :   bool hasFunctionAlignment() const { return HasFunctionAlignment; }
     539           0 :   bool hasDotTypeDotSizeDirective() const { return HasDotTypeDotSizeDirective; }
     540           0 :   bool hasSingleParameterDotFile() const { return HasSingleParameterDotFile; }
     541           0 :   bool hasIdentDirective() const { return HasIdentDirective; }
     542           0 :   bool hasNoDeadStrip() const { return HasNoDeadStrip; }
     543           0 :   bool hasAltEntry() const { return HasAltEntry; }
     544           0 :   const char *getWeakDirective() const { return WeakDirective; }
     545           0 :   const char *getWeakRefDirective() const { return WeakRefDirective; }
     546           0 :   bool hasWeakDefDirective() const { return HasWeakDefDirective; }
     547             : 
     548           0 :   bool hasWeakDefCanBeHiddenDirective() const {
     549           0 :     return HasWeakDefCanBeHiddenDirective;
     550             :   }
     551             : 
     552           0 :   bool hasLinkOnceDirective() const { return HasLinkOnceDirective; }
     553             : 
     554           0 :   MCSymbolAttr getHiddenVisibilityAttr() const { return HiddenVisibilityAttr; }
     555             : 
     556           0 :   MCSymbolAttr getHiddenDeclarationVisibilityAttr() const {
     557           0 :     return HiddenDeclarationVisibilityAttr;
     558             :   }
     559             : 
     560           0 :   MCSymbolAttr getProtectedVisibilityAttr() const {
     561           0 :     return ProtectedVisibilityAttr;
     562             :   }
     563             : 
     564           0 :   bool doesSupportDebugInformation() const { return SupportsDebugInformation; }
     565             : 
     566           0 :   bool doesSupportExceptionHandling() const {
     567           0 :     return ExceptionsType != ExceptionHandling::None;
     568             :   }
     569             : 
     570           0 :   ExceptionHandling getExceptionHandlingType() const { return ExceptionsType; }
     571           0 :   WinEH::EncodingType getWinEHEncodingType() const { return WinEHEncodingType; }
     572             : 
     573           0 :   void setExceptionsType(ExceptionHandling EH) {
     574          83 :     ExceptionsType = EH;
     575           0 :   }
     576             : 
     577             :   /// Returns true if the exception handling method for the platform uses call
     578             :   /// frame information to unwind.
     579             :   bool usesCFIForEH() const {
     580      576290 :     return (ExceptionsType == ExceptionHandling::DwarfCFI ||
     581      576290 :             ExceptionsType == ExceptionHandling::ARM || usesWindowsCFI());
     582             :   }
     583             : 
     584           0 :   bool usesWindowsCFI() const {
     585    18317282 :     return ExceptionsType == ExceptionHandling::WinEH &&
     586       21897 :            (WinEHEncodingType != WinEH::EncodingType::Invalid &&
     587           0 :             WinEHEncodingType != WinEH::EncodingType::X86);
     588             :   }
     589             : 
     590           0 :   bool doesDwarfUseRelocationsAcrossSections() const {
     591           0 :     return DwarfUsesRelocationsAcrossSections;
     592             :   }
     593             : 
     594           0 :   bool doDwarfFDESymbolsUseAbsDiff() const { return DwarfFDESymbolsUseAbsDiff; }
     595           0 :   bool useDwarfRegNumForCFI() const { return DwarfRegNumForCFI; }
     596           0 :   bool useParensForSymbolVariant() const { return UseParensForSymbolVariant; }
     597           0 :   bool supportsExtendedDwarfLocDirective() const {
     598           0 :     return SupportsExtendedDwarfLocDirective;
     599             :   }
     600             : 
     601             :   void addInitialFrameState(const MCCFIInstruction &Inst) {
     602       77886 :     InitialFrameState.push_back(Inst);
     603             :   }
     604             : 
     605             :   const std::vector<MCCFIInstruction> &getInitialFrameState() const {
     606             :     return InitialFrameState;
     607             :   }
     608             : 
     609             :   /// Return true if assembly (inline or otherwise) should be parsed.
     610           0 :   bool useIntegratedAssembler() const { return UseIntegratedAssembler; }
     611             : 
     612             :   /// Set whether assembly (inline or otherwise) should be parsed.
     613         171 :   virtual void setUseIntegratedAssembler(bool Value) {
     614         171 :     UseIntegratedAssembler = Value;
     615         171 :   }
     616             : 
     617             :   /// Return true if assembly (inline or otherwise) should be parsed.
     618           0 :   bool preserveAsmComments() const { return PreserveAsmComments; }
     619             : 
     620             :   /// Set whether assembly (inline or otherwise) should be parsed.
     621       49791 :   virtual void setPreserveAsmComments(bool Value) {
     622       49791 :     PreserveAsmComments = Value;
     623       49791 :   }
     624             : 
     625           0 :   DebugCompressionType compressDebugSections() const {
     626           0 :     return CompressDebugSections;
     627             :   }
     628             : 
     629           0 :   void setCompressDebugSections(DebugCompressionType CompressDebugSections) {
     630       41857 :     this->CompressDebugSections = CompressDebugSections;
     631           0 :   }
     632             : 
     633           0 :   bool shouldUseLogicalShr() const { return UseLogicalShr; }
     634             : 
     635           0 :   bool canRelaxRelocations() const { return RelaxELFRelocations; }
     636       49805 :   void setRelaxELFRelocations(bool V) { RelaxELFRelocations = V; }
     637           0 :   bool hasMipsExpressions() const { return HasMipsExpressions; }
     638             : };
     639             : 
     640             : } // end namespace llvm
     641             : 
     642             : #endif // LLVM_MC_MCASMINFO_H

Generated by: LCOV version 1.13