LLVM  6.0.0svn
DarwinAsmParser.cpp
Go to the documentation of this file.
1 //===- DarwinAsmParser.cpp - Darwin (Mach-O) Assembly Parser --------------===//
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 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/ADT/SmallVector.h"
12 #include "llvm/ADT/StringRef.h"
13 #include "llvm/ADT/StringSwitch.h"
14 #include "llvm/ADT/Triple.h"
15 #include "llvm/ADT/Twine.h"
17 #include "llvm/MC/MCContext.h"
18 #include "llvm/MC/MCDirectives.h"
23 #include "llvm/MC/MCSectionMachO.h"
24 #include "llvm/MC/MCStreamer.h"
25 #include "llvm/MC/MCSymbol.h"
26 #include "llvm/MC/SectionKind.h"
29 #include "llvm/Support/SMLoc.h"
30 #include "llvm/Support/SourceMgr.h"
32 #include <algorithm>
33 #include <cstddef>
34 #include <cstdint>
35 #include <string>
36 #include <system_error>
37 #include <utility>
38 
39 using namespace llvm;
40 
41 namespace {
42 
43 /// \brief Implementation of directive handling which is shared across all
44 /// Darwin targets.
45 class DarwinAsmParser : public MCAsmParserExtension {
46  template<bool (DarwinAsmParser::*HandlerMethod)(StringRef, SMLoc)>
47  void addDirectiveHandler(StringRef Directive) {
48  MCAsmParser::ExtensionDirectiveHandler Handler = std::make_pair(
49  this, HandleDirective<DarwinAsmParser, HandlerMethod>);
50  getParser().addDirectiveHandler(Directive, Handler);
51  }
52 
53  bool parseSectionSwitch(StringRef Segment, StringRef Section,
54  unsigned TAA = 0, unsigned ImplicitAlign = 0,
55  unsigned StubSize = 0);
56 
57  SMLoc LastVersionMinDirective;
58 
59 public:
60  DarwinAsmParser() = default;
61 
62  void Initialize(MCAsmParser &Parser) override {
63  // Call the base implementation.
65 
66  addDirectiveHandler<&DarwinAsmParser::parseDirectiveAltEntry>(".alt_entry");
67  addDirectiveHandler<&DarwinAsmParser::parseDirectiveDesc>(".desc");
68  addDirectiveHandler<&DarwinAsmParser::parseDirectiveIndirectSymbol>(
69  ".indirect_symbol");
70  addDirectiveHandler<&DarwinAsmParser::parseDirectiveLsym>(".lsym");
71  addDirectiveHandler<&DarwinAsmParser::parseDirectiveSubsectionsViaSymbols>(
72  ".subsections_via_symbols");
73  addDirectiveHandler<&DarwinAsmParser::parseDirectiveDumpOrLoad>(".dump");
74  addDirectiveHandler<&DarwinAsmParser::parseDirectiveDumpOrLoad>(".load");
75  addDirectiveHandler<&DarwinAsmParser::parseDirectiveSection>(".section");
76  addDirectiveHandler<&DarwinAsmParser::parseDirectivePushSection>(
77  ".pushsection");
78  addDirectiveHandler<&DarwinAsmParser::parseDirectivePopSection>(
79  ".popsection");
80  addDirectiveHandler<&DarwinAsmParser::parseDirectivePrevious>(".previous");
81  addDirectiveHandler<&DarwinAsmParser::parseDirectiveSecureLogUnique>(
82  ".secure_log_unique");
83  addDirectiveHandler<&DarwinAsmParser::parseDirectiveSecureLogReset>(
84  ".secure_log_reset");
85  addDirectiveHandler<&DarwinAsmParser::parseDirectiveTBSS>(".tbss");
86  addDirectiveHandler<&DarwinAsmParser::parseDirectiveZerofill>(".zerofill");
87 
88  addDirectiveHandler<&DarwinAsmParser::parseDirectiveDataRegion>(
89  ".data_region");
90  addDirectiveHandler<&DarwinAsmParser::parseDirectiveDataRegionEnd>(
91  ".end_data_region");
92 
93  // Special section directives.
94  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveBss>(".bss");
95  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveConst>(".const");
96  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveConstData>(
97  ".const_data");
98  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveConstructor>(
99  ".constructor");
100  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveCString>(
101  ".cstring");
102  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveData>(".data");
103  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveDestructor>(
104  ".destructor");
105  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveDyld>(".dyld");
106  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveFVMLibInit0>(
107  ".fvmlib_init0");
108  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveFVMLibInit1>(
109  ".fvmlib_init1");
110  addDirectiveHandler<
111  &DarwinAsmParser::parseSectionDirectiveLazySymbolPointers>(
112  ".lazy_symbol_pointer");
113  addDirectiveHandler<&DarwinAsmParser::parseDirectiveLinkerOption>(
114  ".linker_option");
115  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveLiteral16>(
116  ".literal16");
117  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveLiteral4>(
118  ".literal4");
119  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveLiteral8>(
120  ".literal8");
121  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveModInitFunc>(
122  ".mod_init_func");
123  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveModTermFunc>(
124  ".mod_term_func");
125  addDirectiveHandler<
126  &DarwinAsmParser::parseSectionDirectiveNonLazySymbolPointers>(
127  ".non_lazy_symbol_pointer");
128  addDirectiveHandler<
129  &DarwinAsmParser::parseSectionDirectiveThreadLocalVariablePointers>(
130  ".thread_local_variable_pointer");
131  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCCatClsMeth>(
132  ".objc_cat_cls_meth");
133  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCCatInstMeth>(
134  ".objc_cat_inst_meth");
135  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCCategory>(
136  ".objc_category");
137  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClass>(
138  ".objc_class");
139  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClassNames>(
140  ".objc_class_names");
141  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClassVars>(
142  ".objc_class_vars");
143  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClsMeth>(
144  ".objc_cls_meth");
145  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClsRefs>(
146  ".objc_cls_refs");
147  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCInstMeth>(
148  ".objc_inst_meth");
149  addDirectiveHandler<
150  &DarwinAsmParser::parseSectionDirectiveObjCInstanceVars>(
151  ".objc_instance_vars");
152  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCMessageRefs>(
153  ".objc_message_refs");
154  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCMetaClass>(
155  ".objc_meta_class");
156  addDirectiveHandler<
157  &DarwinAsmParser::parseSectionDirectiveObjCMethVarNames>(
158  ".objc_meth_var_names");
159  addDirectiveHandler<
160  &DarwinAsmParser::parseSectionDirectiveObjCMethVarTypes>(
161  ".objc_meth_var_types");
162  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCModuleInfo>(
163  ".objc_module_info");
164  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCProtocol>(
165  ".objc_protocol");
166  addDirectiveHandler<
167  &DarwinAsmParser::parseSectionDirectiveObjCSelectorStrs>(
168  ".objc_selector_strs");
169  addDirectiveHandler<
170  &DarwinAsmParser::parseSectionDirectiveObjCStringObject>(
171  ".objc_string_object");
172  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCSymbols>(
173  ".objc_symbols");
174  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectivePICSymbolStub>(
175  ".picsymbol_stub");
176  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveStaticConst>(
177  ".static_const");
178  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveStaticData>(
179  ".static_data");
180  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveSymbolStub>(
181  ".symbol_stub");
182  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveTData>(".tdata");
183  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveText>(".text");
184  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveThreadInitFunc>(
185  ".thread_init_func");
186  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveTLV>(".tlv");
187 
188  addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveIdent>(".ident");
189  addDirectiveHandler<&DarwinAsmParser::parseVersionMin>(
190  ".watchos_version_min");
191  addDirectiveHandler<&DarwinAsmParser::parseVersionMin>(".tvos_version_min");
192  addDirectiveHandler<&DarwinAsmParser::parseVersionMin>(".ios_version_min");
193  addDirectiveHandler<&DarwinAsmParser::parseVersionMin>(
194  ".macosx_version_min");
195 
196  LastVersionMinDirective = SMLoc();
197  }
198 
199  bool parseDirectiveAltEntry(StringRef, SMLoc);
200  bool parseDirectiveDesc(StringRef, SMLoc);
201  bool parseDirectiveIndirectSymbol(StringRef, SMLoc);
202  bool parseDirectiveDumpOrLoad(StringRef, SMLoc);
203  bool parseDirectiveLsym(StringRef, SMLoc);
204  bool parseDirectiveLinkerOption(StringRef, SMLoc);
205  bool parseDirectiveSection(StringRef, SMLoc);
206  bool parseDirectivePushSection(StringRef, SMLoc);
207  bool parseDirectivePopSection(StringRef, SMLoc);
208  bool parseDirectivePrevious(StringRef, SMLoc);
209  bool parseDirectiveSecureLogReset(StringRef, SMLoc);
210  bool parseDirectiveSecureLogUnique(StringRef, SMLoc);
211  bool parseDirectiveSubsectionsViaSymbols(StringRef, SMLoc);
212  bool parseDirectiveTBSS(StringRef, SMLoc);
213  bool parseDirectiveZerofill(StringRef, SMLoc);
214  bool parseDirectiveDataRegion(StringRef, SMLoc);
215  bool parseDirectiveDataRegionEnd(StringRef, SMLoc);
216 
217  // Named Section Directive
218  bool parseSectionDirectiveBss(StringRef, SMLoc) {
219  return parseSectionSwitch("__DATA", "__bss");
220  }
221 
222  bool parseSectionDirectiveConst(StringRef, SMLoc) {
223  return parseSectionSwitch("__TEXT", "__const");
224  }
225 
226  bool parseSectionDirectiveStaticConst(StringRef, SMLoc) {
227  return parseSectionSwitch("__TEXT", "__static_const");
228  }
229 
230  bool parseSectionDirectiveCString(StringRef, SMLoc) {
231  return parseSectionSwitch("__TEXT","__cstring",
233  }
234 
235  bool parseSectionDirectiveLiteral4(StringRef, SMLoc) {
236  return parseSectionSwitch("__TEXT", "__literal4",
238  }
239 
240  bool parseSectionDirectiveLiteral8(StringRef, SMLoc) {
241  return parseSectionSwitch("__TEXT", "__literal8",
243  }
244 
245  bool parseSectionDirectiveLiteral16(StringRef, SMLoc) {
246  return parseSectionSwitch("__TEXT","__literal16",
248  }
249 
250  bool parseSectionDirectiveConstructor(StringRef, SMLoc) {
251  return parseSectionSwitch("__TEXT","__constructor");
252  }
253 
254  bool parseSectionDirectiveDestructor(StringRef, SMLoc) {
255  return parseSectionSwitch("__TEXT","__destructor");
256  }
257 
258  bool parseSectionDirectiveFVMLibInit0(StringRef, SMLoc) {
259  return parseSectionSwitch("__TEXT","__fvmlib_init0");
260  }
261 
262  bool parseSectionDirectiveFVMLibInit1(StringRef, SMLoc) {
263  return parseSectionSwitch("__TEXT","__fvmlib_init1");
264  }
265 
266  bool parseSectionDirectiveSymbolStub(StringRef, SMLoc) {
267  return parseSectionSwitch("__TEXT","__symbol_stub",
270  // FIXME: Different on PPC and ARM.
271  0, 16);
272  }
273 
274  bool parseSectionDirectivePICSymbolStub(StringRef, SMLoc) {
275  return parseSectionSwitch("__TEXT","__picsymbol_stub",
278  }
279 
280  bool parseSectionDirectiveData(StringRef, SMLoc) {
281  return parseSectionSwitch("__DATA", "__data");
282  }
283 
284  bool parseSectionDirectiveStaticData(StringRef, SMLoc) {
285  return parseSectionSwitch("__DATA", "__static_data");
286  }
287 
288  bool parseSectionDirectiveNonLazySymbolPointers(StringRef, SMLoc) {
289  return parseSectionSwitch("__DATA", "__nl_symbol_ptr",
291  }
292 
293  bool parseSectionDirectiveLazySymbolPointers(StringRef, SMLoc) {
294  return parseSectionSwitch("__DATA", "__la_symbol_ptr",
296  }
297 
298  bool parseSectionDirectiveThreadLocalVariablePointers(StringRef, SMLoc) {
299  return parseSectionSwitch("__DATA", "__thread_ptr",
301  }
302 
303  bool parseSectionDirectiveDyld(StringRef, SMLoc) {
304  return parseSectionSwitch("__DATA", "__dyld");
305  }
306 
307  bool parseSectionDirectiveModInitFunc(StringRef, SMLoc) {
308  return parseSectionSwitch("__DATA", "__mod_init_func",
310  }
311 
312  bool parseSectionDirectiveModTermFunc(StringRef, SMLoc) {
313  return parseSectionSwitch("__DATA", "__mod_term_func",
315  }
316 
317  bool parseSectionDirectiveConstData(StringRef, SMLoc) {
318  return parseSectionSwitch("__DATA", "__const");
319  }
320 
321  bool parseSectionDirectiveObjCClass(StringRef, SMLoc) {
322  return parseSectionSwitch("__OBJC", "__class",
324  }
325 
326  bool parseSectionDirectiveObjCMetaClass(StringRef, SMLoc) {
327  return parseSectionSwitch("__OBJC", "__meta_class",
329  }
330 
331  bool parseSectionDirectiveObjCCatClsMeth(StringRef, SMLoc) {
332  return parseSectionSwitch("__OBJC", "__cat_cls_meth",
334  }
335 
336  bool parseSectionDirectiveObjCCatInstMeth(StringRef, SMLoc) {
337  return parseSectionSwitch("__OBJC", "__cat_inst_meth",
339  }
340 
341  bool parseSectionDirectiveObjCProtocol(StringRef, SMLoc) {
342  return parseSectionSwitch("__OBJC", "__protocol",
344  }
345 
346  bool parseSectionDirectiveObjCStringObject(StringRef, SMLoc) {
347  return parseSectionSwitch("__OBJC", "__string_object",
349  }
350 
351  bool parseSectionDirectiveObjCClsMeth(StringRef, SMLoc) {
352  return parseSectionSwitch("__OBJC", "__cls_meth",
354  }
355 
356  bool parseSectionDirectiveObjCInstMeth(StringRef, SMLoc) {
357  return parseSectionSwitch("__OBJC", "__inst_meth",
359  }
360 
361  bool parseSectionDirectiveObjCClsRefs(StringRef, SMLoc) {
362  return parseSectionSwitch("__OBJC", "__cls_refs",
365  }
366 
367  bool parseSectionDirectiveObjCMessageRefs(StringRef, SMLoc) {
368  return parseSectionSwitch("__OBJC", "__message_refs",
371  }
372 
373  bool parseSectionDirectiveObjCSymbols(StringRef, SMLoc) {
374  return parseSectionSwitch("__OBJC", "__symbols",
376  }
377 
378  bool parseSectionDirectiveObjCCategory(StringRef, SMLoc) {
379  return parseSectionSwitch("__OBJC", "__category",
381  }
382 
383  bool parseSectionDirectiveObjCClassVars(StringRef, SMLoc) {
384  return parseSectionSwitch("__OBJC", "__class_vars",
386  }
387 
388  bool parseSectionDirectiveObjCInstanceVars(StringRef, SMLoc) {
389  return parseSectionSwitch("__OBJC", "__instance_vars",
391  }
392 
393  bool parseSectionDirectiveObjCModuleInfo(StringRef, SMLoc) {
394  return parseSectionSwitch("__OBJC", "__module_info",
396  }
397 
398  bool parseSectionDirectiveObjCClassNames(StringRef, SMLoc) {
399  return parseSectionSwitch("__TEXT", "__cstring",
401  }
402 
403  bool parseSectionDirectiveObjCMethVarTypes(StringRef, SMLoc) {
404  return parseSectionSwitch("__TEXT", "__cstring",
406  }
407 
408  bool parseSectionDirectiveObjCMethVarNames(StringRef, SMLoc) {
409  return parseSectionSwitch("__TEXT", "__cstring",
411  }
412 
413  bool parseSectionDirectiveObjCSelectorStrs(StringRef, SMLoc) {
414  return parseSectionSwitch("__OBJC", "__selector_strs",
416  }
417 
418  bool parseSectionDirectiveTData(StringRef, SMLoc) {
419  return parseSectionSwitch("__DATA", "__thread_data",
421  }
422 
423  bool parseSectionDirectiveText(StringRef, SMLoc) {
424  return parseSectionSwitch("__TEXT", "__text",
426  }
427 
428  bool parseSectionDirectiveTLV(StringRef, SMLoc) {
429  return parseSectionSwitch("__DATA", "__thread_vars",
431  }
432 
433  bool parseSectionDirectiveIdent(StringRef, SMLoc) {
434  // Darwin silently ignores the .ident directive.
435  getParser().eatToEndOfStatement();
436  return false;
437  }
438 
439  bool parseSectionDirectiveThreadInitFunc(StringRef, SMLoc) {
440  return parseSectionSwitch("__DATA", "__thread_init",
442  }
443 
444  bool parseVersionMin(StringRef, SMLoc);
445 };
446 
447 } // end anonymous namespace
448 
449 bool DarwinAsmParser::parseSectionSwitch(StringRef Segment, StringRef Section,
450  unsigned TAA, unsigned Align,
451  unsigned StubSize) {
452  if (getLexer().isNot(AsmToken::EndOfStatement))
453  return TokError("unexpected token in section switching directive");
454  Lex();
455 
456  // FIXME: Arch specific.
457  bool isText = TAA & MachO::S_ATTR_PURE_INSTRUCTIONS;
458  getStreamer().SwitchSection(getContext().getMachOSection(
459  Segment, Section, TAA, StubSize,
461 
462  // Set the implicit alignment, if any.
463  //
464  // FIXME: This isn't really what 'as' does; I think it just uses the implicit
465  // alignment on the section (e.g., if one manually inserts bytes into the
466  // section, then just issuing the section switch directive will not realign
467  // the section. However, this is arguably more reasonable behavior, and there
468  // is no good reason for someone to intentionally emit incorrectly sized
469  // values into the implicitly aligned sections.
470  if (Align)
471  getStreamer().EmitValueToAlignment(Align);
472 
473  return false;
474 }
475 
476 /// parseDirectiveAltEntry
477 /// ::= .alt_entry identifier
478 bool DarwinAsmParser::parseDirectiveAltEntry(StringRef, SMLoc) {
479  StringRef Name;
480  if (getParser().parseIdentifier(Name))
481  return TokError("expected identifier in directive");
482 
483  // Look up symbol.
484  MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
485 
486  if (Sym->isDefined())
487  return TokError(".alt_entry must preceed symbol definition");
488 
489  if (!getStreamer().EmitSymbolAttribute(Sym, MCSA_AltEntry))
490  return TokError("unable to emit symbol attribute");
491 
492  Lex();
493  return false;
494 }
495 
496 /// parseDirectiveDesc
497 /// ::= .desc identifier , expression
498 bool DarwinAsmParser::parseDirectiveDesc(StringRef, SMLoc) {
499  StringRef Name;
500  if (getParser().parseIdentifier(Name))
501  return TokError("expected identifier in directive");
502 
503  // Handle the identifier as the key symbol.
504  MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
505 
506  if (getLexer().isNot(AsmToken::Comma))
507  return TokError("unexpected token in '.desc' directive");
508  Lex();
509 
510  int64_t DescValue;
511  if (getParser().parseAbsoluteExpression(DescValue))
512  return true;
513 
514  if (getLexer().isNot(AsmToken::EndOfStatement))
515  return TokError("unexpected token in '.desc' directive");
516 
517  Lex();
518 
519  // Set the n_desc field of this Symbol to this DescValue
520  getStreamer().EmitSymbolDesc(Sym, DescValue);
521 
522  return false;
523 }
524 
525 /// parseDirectiveIndirectSymbol
526 /// ::= .indirect_symbol identifier
527 bool DarwinAsmParser::parseDirectiveIndirectSymbol(StringRef, SMLoc Loc) {
528  const MCSectionMachO *Current = static_cast<const MCSectionMachO *>(
529  getStreamer().getCurrentSectionOnly());
531  if (SectionType != MachO::S_NON_LAZY_SYMBOL_POINTERS &&
532  SectionType != MachO::S_LAZY_SYMBOL_POINTERS &&
534  SectionType != MachO::S_SYMBOL_STUBS)
535  return Error(Loc, "indirect symbol not in a symbol pointer or stub "
536  "section");
537 
538  StringRef Name;
539  if (getParser().parseIdentifier(Name))
540  return TokError("expected identifier in .indirect_symbol directive");
541 
542  MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
543 
544  // Assembler local symbols don't make any sense here. Complain loudly.
545  if (Sym->isTemporary())
546  return TokError("non-local symbol required in directive");
547 
548  if (!getStreamer().EmitSymbolAttribute(Sym, MCSA_IndirectSymbol))
549  return TokError("unable to emit indirect symbol attribute for: " + Name);
550 
551  if (getLexer().isNot(AsmToken::EndOfStatement))
552  return TokError("unexpected token in '.indirect_symbol' directive");
553 
554  Lex();
555 
556  return false;
557 }
558 
559 /// parseDirectiveDumpOrLoad
560 /// ::= ( .dump | .load ) "filename"
561 bool DarwinAsmParser::parseDirectiveDumpOrLoad(StringRef Directive,
562  SMLoc IDLoc) {
563  bool IsDump = Directive == ".dump";
564  if (getLexer().isNot(AsmToken::String))
565  return TokError("expected string in '.dump' or '.load' directive");
566 
567  Lex();
568 
569  if (getLexer().isNot(AsmToken::EndOfStatement))
570  return TokError("unexpected token in '.dump' or '.load' directive");
571 
572  Lex();
573 
574  // FIXME: If/when .dump and .load are implemented they will be done in the
575  // the assembly parser and not have any need for an MCStreamer API.
576  if (IsDump)
577  return Warning(IDLoc, "ignoring directive .dump for now");
578  else
579  return Warning(IDLoc, "ignoring directive .load for now");
580 }
581 
582 /// ParseDirectiveLinkerOption
583 /// ::= .linker_option "string" ( , "string" )*
584 bool DarwinAsmParser::parseDirectiveLinkerOption(StringRef IDVal, SMLoc) {
586  while (true) {
587  if (getLexer().isNot(AsmToken::String))
588  return TokError("expected string in '" + Twine(IDVal) + "' directive");
589 
590  std::string Data;
591  if (getParser().parseEscapedString(Data))
592  return true;
593 
594  Args.push_back(Data);
595 
596  if (getLexer().is(AsmToken::EndOfStatement))
597  break;
598 
599  if (getLexer().isNot(AsmToken::Comma))
600  return TokError("unexpected token in '" + Twine(IDVal) + "' directive");
601  Lex();
602  }
603 
604  getStreamer().EmitLinkerOptions(Args);
605  return false;
606 }
607 
608 /// parseDirectiveLsym
609 /// ::= .lsym identifier , expression
610 bool DarwinAsmParser::parseDirectiveLsym(StringRef, SMLoc) {
611  StringRef Name;
612  if (getParser().parseIdentifier(Name))
613  return TokError("expected identifier in directive");
614 
615  // Handle the identifier as the key symbol.
616  MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
617 
618  if (getLexer().isNot(AsmToken::Comma))
619  return TokError("unexpected token in '.lsym' directive");
620  Lex();
621 
622  const MCExpr *Value;
623  if (getParser().parseExpression(Value))
624  return true;
625 
626  if (getLexer().isNot(AsmToken::EndOfStatement))
627  return TokError("unexpected token in '.lsym' directive");
628 
629  Lex();
630 
631  // We don't currently support this directive.
632  //
633  // FIXME: Diagnostic location!
634  (void) Sym;
635  return TokError("directive '.lsym' is unsupported");
636 }
637 
638 /// parseDirectiveSection:
639 /// ::= .section identifier (',' identifier)*
640 bool DarwinAsmParser::parseDirectiveSection(StringRef, SMLoc) {
641  SMLoc Loc = getLexer().getLoc();
642 
644  if (getParser().parseIdentifier(SectionName))
645  return Error(Loc, "expected identifier after '.section' directive");
646 
647  // Verify there is a following comma.
648  if (!getLexer().is(AsmToken::Comma))
649  return TokError("unexpected token in '.section' directive");
650 
651  std::string SectionSpec = SectionName;
652  SectionSpec += ",";
653 
654  // Add all the tokens until the end of the line, ParseSectionSpecifier will
655  // handle this.
656  StringRef EOL = getLexer().LexUntilEndOfStatement();
657  SectionSpec.append(EOL.begin(), EOL.end());
658 
659  Lex();
660  if (getLexer().isNot(AsmToken::EndOfStatement))
661  return TokError("unexpected token in '.section' directive");
662  Lex();
663 
664  StringRef Segment, Section;
665  unsigned StubSize;
666  unsigned TAA;
667  bool TAAParsed;
668  std::string ErrorStr =
669  MCSectionMachO::ParseSectionSpecifier(SectionSpec, Segment, Section,
670  TAA, TAAParsed, StubSize);
671 
672  if (!ErrorStr.empty())
673  return Error(Loc, ErrorStr);
674 
675  // Issue a warning if the target is not powerpc and Section is a *coal* section.
676  Triple TT = getParser().getContext().getObjectFileInfo()->getTargetTriple();
677  Triple::ArchType ArchTy = TT.getArch();
678 
679  if (ArchTy != Triple::ppc && ArchTy != Triple::ppc64) {
680  StringRef NonCoalSection = StringSwitch<StringRef>(Section)
681  .Case("__textcoal_nt", "__text")
682  .Case("__const_coal", "__const")
683  .Case("__datacoal_nt", "__data")
684  .Default(Section);
685 
686  if (!Section.equals(NonCoalSection)) {
687  StringRef SectionVal(Loc.getPointer());
688  size_t B = SectionVal.find(',') + 1, E = SectionVal.find(',', B);
689  SMLoc BLoc = SMLoc::getFromPointer(SectionVal.data() + B);
690  SMLoc ELoc = SMLoc::getFromPointer(SectionVal.data() + E);
691  getParser().Warning(Loc, "section \"" + Section + "\" is deprecated",
692  SMRange(BLoc, ELoc));
693  getParser().Note(Loc, "change section name to \"" + NonCoalSection +
694  "\"", SMRange(BLoc, ELoc));
695  }
696  }
697 
698  // FIXME: Arch specific.
699  bool isText = Segment == "__TEXT"; // FIXME: Hack.
700  getStreamer().SwitchSection(getContext().getMachOSection(
701  Segment, Section, TAA, StubSize,
703  return false;
704 }
705 
706 /// ParseDirectivePushSection:
707 /// ::= .pushsection identifier (',' identifier)*
708 bool DarwinAsmParser::parseDirectivePushSection(StringRef S, SMLoc Loc) {
709  getStreamer().PushSection();
710 
711  if (parseDirectiveSection(S, Loc)) {
712  getStreamer().PopSection();
713  return true;
714  }
715 
716  return false;
717 }
718 
719 /// ParseDirectivePopSection:
720 /// ::= .popsection
721 bool DarwinAsmParser::parseDirectivePopSection(StringRef, SMLoc) {
722  if (!getStreamer().PopSection())
723  return TokError(".popsection without corresponding .pushsection");
724  return false;
725 }
726 
727 /// ParseDirectivePrevious:
728 /// ::= .previous
729 bool DarwinAsmParser::parseDirectivePrevious(StringRef DirName, SMLoc) {
730  MCSectionSubPair PreviousSection = getStreamer().getPreviousSection();
731  if (!PreviousSection.first)
732  return TokError(".previous without corresponding .section");
733  getStreamer().SwitchSection(PreviousSection.first, PreviousSection.second);
734  return false;
735 }
736 
737 /// ParseDirectiveSecureLogUnique
738 /// ::= .secure_log_unique ... message ...
739 bool DarwinAsmParser::parseDirectiveSecureLogUnique(StringRef, SMLoc IDLoc) {
740  StringRef LogMessage = getParser().parseStringToEndOfStatement();
741  if (getLexer().isNot(AsmToken::EndOfStatement))
742  return TokError("unexpected token in '.secure_log_unique' directive");
743 
744  if (getContext().getSecureLogUsed())
745  return Error(IDLoc, ".secure_log_unique specified multiple times");
746 
747  // Get the secure log path.
748  const char *SecureLogFile = getContext().getSecureLogFile();
749  if (!SecureLogFile)
750  return Error(IDLoc, ".secure_log_unique used but AS_SECURE_LOG_FILE "
751  "environment variable unset.");
752 
753  // Open the secure log file if we haven't already.
754  raw_fd_ostream *OS = getContext().getSecureLog();
755  if (!OS) {
756  std::error_code EC;
757  auto NewOS = llvm::make_unique<raw_fd_ostream>(
758  StringRef(SecureLogFile), EC, sys::fs::F_Append | sys::fs::F_Text);
759  if (EC)
760  return Error(IDLoc, Twine("can't open secure log file: ") +
761  SecureLogFile + " (" + EC.message() + ")");
762  OS = NewOS.get();
763  getContext().setSecureLog(std::move(NewOS));
764  }
765 
766  // Write the message.
767  unsigned CurBuf = getSourceManager().FindBufferContainingLoc(IDLoc);
768  *OS << getSourceManager().getBufferInfo(CurBuf).Buffer->getBufferIdentifier()
769  << ":" << getSourceManager().FindLineNumber(IDLoc, CurBuf) << ":"
770  << LogMessage + "\n";
771 
772  getContext().setSecureLogUsed(true);
773 
774  return false;
775 }
776 
777 /// ParseDirectiveSecureLogReset
778 /// ::= .secure_log_reset
779 bool DarwinAsmParser::parseDirectiveSecureLogReset(StringRef, SMLoc IDLoc) {
780  if (getLexer().isNot(AsmToken::EndOfStatement))
781  return TokError("unexpected token in '.secure_log_reset' directive");
782 
783  Lex();
784 
785  getContext().setSecureLogUsed(false);
786 
787  return false;
788 }
789 
790 /// parseDirectiveSubsectionsViaSymbols
791 /// ::= .subsections_via_symbols
792 bool DarwinAsmParser::parseDirectiveSubsectionsViaSymbols(StringRef, SMLoc) {
793  if (getLexer().isNot(AsmToken::EndOfStatement))
794  return TokError("unexpected token in '.subsections_via_symbols' directive");
795 
796  Lex();
797 
798  getStreamer().EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
799 
800  return false;
801 }
802 
803 /// ParseDirectiveTBSS
804 /// ::= .tbss identifier, size, align
805 bool DarwinAsmParser::parseDirectiveTBSS(StringRef, SMLoc) {
806  SMLoc IDLoc = getLexer().getLoc();
807  StringRef Name;
808  if (getParser().parseIdentifier(Name))
809  return TokError("expected identifier in directive");
810 
811  // Handle the identifier as the key symbol.
812  MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
813 
814  if (getLexer().isNot(AsmToken::Comma))
815  return TokError("unexpected token in directive");
816  Lex();
817 
818  int64_t Size;
819  SMLoc SizeLoc = getLexer().getLoc();
820  if (getParser().parseAbsoluteExpression(Size))
821  return true;
822 
823  int64_t Pow2Alignment = 0;
824  SMLoc Pow2AlignmentLoc;
825  if (getLexer().is(AsmToken::Comma)) {
826  Lex();
827  Pow2AlignmentLoc = getLexer().getLoc();
828  if (getParser().parseAbsoluteExpression(Pow2Alignment))
829  return true;
830  }
831 
832  if (getLexer().isNot(AsmToken::EndOfStatement))
833  return TokError("unexpected token in '.tbss' directive");
834 
835  Lex();
836 
837  if (Size < 0)
838  return Error(SizeLoc, "invalid '.tbss' directive size, can't be less than"
839  "zero");
840 
841  // FIXME: Diagnose overflow.
842  if (Pow2Alignment < 0)
843  return Error(Pow2AlignmentLoc, "invalid '.tbss' alignment, can't be less"
844  "than zero");
845 
846  if (!Sym->isUndefined())
847  return Error(IDLoc, "invalid symbol redefinition");
848 
849  getStreamer().EmitTBSSSymbol(getContext().getMachOSection(
850  "__DATA", "__thread_bss",
853  Sym, Size, 1 << Pow2Alignment);
854 
855  return false;
856 }
857 
858 /// ParseDirectiveZerofill
859 /// ::= .zerofill segname , sectname [, identifier , size_expression [
860 /// , align_expression ]]
861 bool DarwinAsmParser::parseDirectiveZerofill(StringRef, SMLoc) {
862  StringRef Segment;
863  if (getParser().parseIdentifier(Segment))
864  return TokError("expected segment name after '.zerofill' directive");
865 
866  if (getLexer().isNot(AsmToken::Comma))
867  return TokError("unexpected token in directive");
868  Lex();
869 
871  if (getParser().parseIdentifier(Section))
872  return TokError("expected section name after comma in '.zerofill' "
873  "directive");
874 
875  // If this is the end of the line all that was wanted was to create the
876  // the section but with no symbol.
877  if (getLexer().is(AsmToken::EndOfStatement)) {
878  // Create the zerofill section but no symbol
879  getStreamer().EmitZerofill(getContext().getMachOSection(
880  Segment, Section, MachO::S_ZEROFILL,
881  0, SectionKind::getBSS()));
882  return false;
883  }
884 
885  if (getLexer().isNot(AsmToken::Comma))
886  return TokError("unexpected token in directive");
887  Lex();
888 
889  SMLoc IDLoc = getLexer().getLoc();
890  StringRef IDStr;
891  if (getParser().parseIdentifier(IDStr))
892  return TokError("expected identifier in directive");
893 
894  // handle the identifier as the key symbol.
895  MCSymbol *Sym = getContext().getOrCreateSymbol(IDStr);
896 
897  if (getLexer().isNot(AsmToken::Comma))
898  return TokError("unexpected token in directive");
899  Lex();
900 
901  int64_t Size;
902  SMLoc SizeLoc = getLexer().getLoc();
903  if (getParser().parseAbsoluteExpression(Size))
904  return true;
905 
906  int64_t Pow2Alignment = 0;
907  SMLoc Pow2AlignmentLoc;
908  if (getLexer().is(AsmToken::Comma)) {
909  Lex();
910  Pow2AlignmentLoc = getLexer().getLoc();
911  if (getParser().parseAbsoluteExpression(Pow2Alignment))
912  return true;
913  }
914 
915  if (getLexer().isNot(AsmToken::EndOfStatement))
916  return TokError("unexpected token in '.zerofill' directive");
917 
918  Lex();
919 
920  if (Size < 0)
921  return Error(SizeLoc, "invalid '.zerofill' directive size, can't be less "
922  "than zero");
923 
924  // NOTE: The alignment in the directive is a power of 2 value, the assembler
925  // may internally end up wanting an alignment in bytes.
926  // FIXME: Diagnose overflow.
927  if (Pow2Alignment < 0)
928  return Error(Pow2AlignmentLoc, "invalid '.zerofill' directive alignment, "
929  "can't be less than zero");
930 
931  if (!Sym->isUndefined())
932  return Error(IDLoc, "invalid symbol redefinition");
933 
934  // Create the zerofill Symbol with Size and Pow2Alignment
935  //
936  // FIXME: Arch specific.
937  getStreamer().EmitZerofill(getContext().getMachOSection(
938  Segment, Section, MachO::S_ZEROFILL,
939  0, SectionKind::getBSS()),
940  Sym, Size, 1 << Pow2Alignment);
941 
942  return false;
943 }
944 
945 /// ParseDirectiveDataRegion
946 /// ::= .data_region [ ( jt8 | jt16 | jt32 ) ]
947 bool DarwinAsmParser::parseDirectiveDataRegion(StringRef, SMLoc) {
948  if (getLexer().is(AsmToken::EndOfStatement)) {
949  Lex();
950  getStreamer().EmitDataRegion(MCDR_DataRegion);
951  return false;
952  }
953  StringRef RegionType;
954  SMLoc Loc = getParser().getTok().getLoc();
955  if (getParser().parseIdentifier(RegionType))
956  return TokError("expected region type after '.data_region' directive");
957  int Kind = StringSwitch<int>(RegionType)
958  .Case("jt8", MCDR_DataRegionJT8)
959  .Case("jt16", MCDR_DataRegionJT16)
960  .Case("jt32", MCDR_DataRegionJT32)
961  .Default(-1);
962  if (Kind == -1)
963  return Error(Loc, "unknown region type in '.data_region' directive");
964  Lex();
965 
966  getStreamer().EmitDataRegion((MCDataRegionType)Kind);
967  return false;
968 }
969 
970 /// ParseDirectiveDataRegionEnd
971 /// ::= .end_data_region
972 bool DarwinAsmParser::parseDirectiveDataRegionEnd(StringRef, SMLoc) {
973  if (getLexer().isNot(AsmToken::EndOfStatement))
974  return TokError("unexpected token in '.end_data_region' directive");
975 
976  Lex();
977  getStreamer().EmitDataRegion(MCDR_DataRegionEnd);
978  return false;
979 }
980 
981 /// parseVersionMin
982 /// ::= .ios_version_min major,minor[,update]
983 /// ::= .macosx_version_min major,minor[,update]
984 bool DarwinAsmParser::parseVersionMin(StringRef Directive, SMLoc Loc) {
985  int64_t Major = 0, Minor = 0, Update = 0;
986  int Kind = StringSwitch<int>(Directive)
987  .Case(".watchos_version_min", MCVM_WatchOSVersionMin)
988  .Case(".tvos_version_min", MCVM_TvOSVersionMin)
989  .Case(".ios_version_min", MCVM_IOSVersionMin)
990  .Case(".macosx_version_min", MCVM_OSXVersionMin);
991  // Get the major version number.
992  if (getLexer().isNot(AsmToken::Integer))
993  return TokError("invalid OS major version number");
994  Major = getLexer().getTok().getIntVal();
995  if (Major > 65535 || Major <= 0)
996  return TokError("invalid OS major version number");
997  Lex();
998  if (getLexer().isNot(AsmToken::Comma))
999  return TokError("minor OS version number required, comma expected");
1000  Lex();
1001  // Get the minor version number.
1002  if (getLexer().isNot(AsmToken::Integer))
1003  return TokError("invalid OS minor version number");
1004  Minor = getLexer().getTok().getIntVal();
1005  if (Minor > 255 || Minor < 0)
1006  return TokError("invalid OS minor version number");
1007  Lex();
1008  // Get the update level, if specified
1009  if (getLexer().isNot(AsmToken::EndOfStatement)) {
1010  if (getLexer().isNot(AsmToken::Comma))
1011  return TokError("invalid update specifier, comma expected");
1012  Lex();
1013  if (getLexer().isNot(AsmToken::Integer))
1014  return TokError("invalid OS update number");
1015  Update = getLexer().getTok().getIntVal();
1016  if (Update > 255 || Update < 0)
1017  return TokError("invalid OS update number");
1018  Lex();
1019  }
1020 
1021  const Triple &T = getContext().getObjectFileInfo()->getTargetTriple();
1022  Triple::OSType ExpectedOS = Triple::UnknownOS;
1023  switch ((MCVersionMinType)Kind) {
1024  case MCVM_WatchOSVersionMin: ExpectedOS = Triple::WatchOS; break;
1025  case MCVM_TvOSVersionMin: ExpectedOS = Triple::TvOS; break;
1026  case MCVM_IOSVersionMin: ExpectedOS = Triple::IOS; break;
1027  case MCVM_OSXVersionMin: ExpectedOS = Triple::MacOSX; break;
1028  }
1029  if (T.getOS() != ExpectedOS)
1030  Warning(Loc, Directive + " should only be used for " +
1031  Triple::getOSTypeName(ExpectedOS) + " targets");
1032 
1033  if (LastVersionMinDirective.isValid()) {
1034  Warning(Loc, "overriding previous version_min directive");
1035  Note(LastVersionMinDirective, "previous definition is here");
1036  }
1037  LastVersionMinDirective = Loc;
1038 
1039  // We've parsed a correct version specifier, so send it to the streamer.
1040  getStreamer().EmitVersionMin((MCVersionMinType)Kind, Major, Minor, Update);
1041 
1042  return false;
1043 }
1044 
1045 namespace llvm {
1046 
1048  return new DarwinAsmParser;
1049 }
1050 
1051 } // end llvm namespace
Represents a range in source code.
Definition: SMLoc.h:49
void push_back(const T &Elt)
Definition: SmallVector.h:212
F_Append - When opening a file, if it already exists append to the existing file instead of returning...
Definition: FileSystem.h:726
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
static SectionKind getData()
Definition: SectionKind.h:202
S_NON_LAZY_SYMBOL_POINTERS - Section with non-lazy symbol pointers.
Definition: MachO.h:132
S_SYMBOL_STUBS - Section with symbol stubs, byte size of stub in the Reserved2 field.
Definition: MachO.h:137
This represents a section on a Mach-O system (used by Mac OS X).
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
Generic assembler parser interface, for use by target specific assembly parsers.
Definition: MCAsmParser.h:110
virtual void Initialize(MCAsmParser &Parser)
Initialize the extension for parsing using the given Parser.
OSType getOS() const
getOS - Get the parsed operating system type of this triple.
Definition: Triple.h:293
.watchos_version_min
Definition: MCDirectives.h:68
.ios_version_min
Definition: MCDirectives.h:65
MCAsmParserExtension * createDarwinAsmParser()
S_THREAD_LOCAL_VARIABLES - Section with thread local variable structure data.
Definition: MachO.h:165
.macosx_version_min
Definition: MCDirectives.h:66
MCDataRegionType
Definition: MCDirectives.h:56
S_4BYTE_LITERALS - Section with 4 byte literals.
Definition: MachO.h:126
static SectionKind getBSS()
Definition: SectionKind.h:198
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:36
S_8BYTE_LITERALS - Section with 8 byte literals.
Definition: MachO.h:128
.data_region jt16
Definition: MCDirectives.h:59
S_MOD_TERM_FUNC_POINTERS - Section with only function pointers for termination.
Definition: MachO.h:143
LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch & Case(const char(&S)[N], const T &Value)
Definition: StringSwitch.h:74
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:284
.alt_entry (MachO)
Definition: MCDirectives.h:38
static StringRef getOSTypeName(OSType Kind)
getOSTypeName - Get the canonical name for the Kind operating system.
Definition: Triple.cpp:176
.data_region jt32
Definition: MCDirectives.h:60
const char * getPointer() const
Definition: SMLoc.h:35
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:43
S_LITERAL_POINTERS - Section with pointers to literals.
Definition: MachO.h:130
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static std::string ParseSectionSpecifier(StringRef Spec, StringRef &Segment, StringRef &Section, unsigned &TAA, bool &TAAParsed, unsigned &StubSize)
Parse the section specifier indicated by "Spec".
.tvos_version_min
Definition: MCDirectives.h:67
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
S_THREAD_LOCAL_ZEROFILL - Thread local zerofill section.
Definition: MachO.h:162
bool isTemporary() const
isTemporary - Check if this is an assembler temporary symbol.
Definition: MCSymbol.h:220
.subsections_via_symbols (MachO)
Definition: MCDirectives.h:50
S_THREAD_LOCAL_REGULAR - Thread local data section.
Definition: MachO.h:160
S_CSTRING_LITERALS - Section with literal C strings.
Definition: MachO.h:124
MachO::SectionType getType() const
LLVM_ATTRIBUTE_ALWAYS_INLINE R Default(const T &Value) const
Definition: StringSwitch.h:244
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
S_LAZY_SYMBOL_POINTERS - Section with lazy symbol pointers.
Definition: MachO.h:134
static SectionKind getThreadBSS()
Definition: SectionKind.h:196
std::pair< MCSection *, const MCExpr * > MCSectionSubPair
Definition: MCStreamer.h:52
S_ATTR_NO_DEAD_STRIP - No dead stripping.
Definition: MachO.h:190
bool isUndefined(bool SetUsed=true) const
isUndefined - Check if this symbol undefined (i.e., implicitly defined).
Definition: MCSymbol.h:260
.indirect_symbol (MachO)
Definition: MCDirectives.h:32
S_THREAD_LOCAL_VARIABLE_POINTERS - Section with pointers to thread local structures.
Definition: MachO.h:168
S_THREAD_LOCAL_INIT_FUNCTION_POINTERS - Section with thread local variable initialization pointers to...
Definition: MachO.h:171
S_16BYTE_LITERALS - Section with only 16 byte literals.
Definition: MachO.h:153
The file should be opened in text mode on platforms that make this distinction.
Definition: FileSystem.h:730
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:169
iterator begin() const
Definition: StringRef.h:106
static SMLoc getFromPointer(const char *Ptr)
Definition: SMLoc.h:37
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:361
S_ATTR_PURE_INSTRUCTIONS - Section contains only true machine instructions.
Definition: MachO.h:182
bool isDefined(bool SetUsed=true) const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition: MCSymbol.h:249
const unsigned Kind
.data_region jt8
Definition: MCDirectives.h:58
Generic interface for extending the MCAsmParser, which is implemented by target and object file assem...
MCVersionMinType
Definition: MCDirectives.h:64
LLVM Value Representation.
Definition: Value.h:73
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
std::pair< MCAsmParserExtension *, DirectiveHandler > ExtensionDirectiveHandler
Definition: MCAsmParser.h:114
const char SectionName[]
Definition: AMDGPUPTNote.h:24
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
S_ZEROFILL - Zero fill on demand section.
Definition: MachO.h:122
Represents a location in source code.
Definition: SMLoc.h:24
S_MOD_INIT_FUNC_POINTERS - Section with only function pointers for initialization.
Definition: MachO.h:140
SectionType
These are the section type and attributes fields.
Definition: MachO.h:115
iterator end() const
Definition: StringRef.h:108
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
.end_data_region
Definition: MCDirectives.h:61
static SectionKind getText()
Definition: SectionKind.h:180