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 45602 : 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 3910 : virtual MCSection *getNonexecutableStackSection(MCContext &Ctx) const {
429 3910 : 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 550215 : return (ExceptionsType == ExceptionHandling::DwarfCFI ||
581 550215 : ExceptionsType == ExceptionHandling::ARM || usesWindowsCFI());
582 : }
583 :
584 0 : bool usesWindowsCFI() const {
585 18056178 : return ExceptionsType == ExceptionHandling::WinEH &&
586 22306 : (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 75858 : 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 49061 : virtual void setPreserveAsmComments(bool Value) {
622 49061 : PreserveAsmComments = Value;
623 49061 : }
624 :
625 0 : DebugCompressionType compressDebugSections() const {
626 0 : return CompressDebugSections;
627 : }
628 :
629 0 : void setCompressDebugSections(DebugCompressionType CompressDebugSections) {
630 40988 : this->CompressDebugSections = CompressDebugSections;
631 0 : }
632 :
633 0 : bool shouldUseLogicalShr() const { return UseLogicalShr; }
634 :
635 0 : bool canRelaxRelocations() const { return RelaxELFRelocations; }
636 49075 : 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
|
