1 //===- DarwinAsmParser.cpp - Darwin (Mach-O) Assembly Parser --------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
11 #include "llvm/ADT/STLExtras.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"
16 #include "llvm/MC/MCContext.h"
17 #include "llvm/MC/MCObjectFileInfo.h"
18 #include "llvm/MC/MCParser/MCAsmLexer.h"
19 #include "llvm/MC/MCParser/MCAsmParser.h"
20 #include "llvm/MC/MCSectionMachO.h"
21 #include "llvm/MC/MCStreamer.h"
22 #include "llvm/MC/MCSymbol.h"
23 #include "llvm/Support/FileSystem.h"
24 #include "llvm/Support/MemoryBuffer.h"
25 #include "llvm/Support/SourceMgr.h"
30 /// \brief Implementation of directive handling which is shared across all
32 class DarwinAsmParser : public MCAsmParserExtension {
33 template<bool (DarwinAsmParser::*HandlerMethod)(StringRef, SMLoc)>
34 void addDirectiveHandler(StringRef Directive) {
35 MCAsmParser::ExtensionDirectiveHandler Handler = std::make_pair(
36 this, HandleDirective<DarwinAsmParser, HandlerMethod>);
37 getParser().addDirectiveHandler(Directive, Handler);
40 bool parseSectionSwitch(const char *Segment, const char *Section,
41 unsigned TAA = 0, unsigned ImplicitAlign = 0,
42 unsigned StubSize = 0);
44 SMLoc LastVersionMinDirective;
49 void Initialize(MCAsmParser &Parser) override {
50 // Call the base implementation.
51 this->MCAsmParserExtension::Initialize(Parser);
53 addDirectiveHandler<&DarwinAsmParser::parseDirectiveDesc>(".desc");
54 addDirectiveHandler<&DarwinAsmParser::parseDirectiveIndirectSymbol>(
56 addDirectiveHandler<&DarwinAsmParser::parseDirectiveLsym>(".lsym");
57 addDirectiveHandler<&DarwinAsmParser::parseDirectiveSubsectionsViaSymbols>(
58 ".subsections_via_symbols");
59 addDirectiveHandler<&DarwinAsmParser::parseDirectiveDumpOrLoad>(".dump");
60 addDirectiveHandler<&DarwinAsmParser::parseDirectiveDumpOrLoad>(".load");
61 addDirectiveHandler<&DarwinAsmParser::parseDirectiveSection>(".section");
62 addDirectiveHandler<&DarwinAsmParser::parseDirectivePushSection>(
64 addDirectiveHandler<&DarwinAsmParser::parseDirectivePopSection>(
66 addDirectiveHandler<&DarwinAsmParser::parseDirectivePrevious>(".previous");
67 addDirectiveHandler<&DarwinAsmParser::parseDirectiveSecureLogUnique>(
68 ".secure_log_unique");
69 addDirectiveHandler<&DarwinAsmParser::parseDirectiveSecureLogReset>(
71 addDirectiveHandler<&DarwinAsmParser::parseDirectiveTBSS>(".tbss");
72 addDirectiveHandler<&DarwinAsmParser::parseDirectiveZerofill>(".zerofill");
74 addDirectiveHandler<&DarwinAsmParser::parseDirectiveDataRegion>(
76 addDirectiveHandler<&DarwinAsmParser::parseDirectiveDataRegionEnd>(
79 // Special section directives.
80 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveBss>(".bss");
81 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveConst>(".const");
82 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveConstData>(
84 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveConstructor>(
86 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveCString>(
88 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveData>(".data");
89 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveDestructor>(
91 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveDyld>(".dyld");
92 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveFVMLibInit0>(
94 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveFVMLibInit1>(
97 &DarwinAsmParser::parseSectionDirectiveLazySymbolPointers>(
98 ".lazy_symbol_pointer");
99 addDirectiveHandler<&DarwinAsmParser::parseDirectiveLinkerOption>(
101 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveLiteral16>(
103 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveLiteral4>(
105 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveLiteral8>(
107 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveModInitFunc>(
109 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveModTermFunc>(
112 &DarwinAsmParser::parseSectionDirectiveNonLazySymbolPointers>(
113 ".non_lazy_symbol_pointer");
114 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCCatClsMeth>(
115 ".objc_cat_cls_meth");
116 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCCatInstMeth>(
117 ".objc_cat_inst_meth");
118 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCCategory>(
120 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClass>(
122 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClassNames>(
123 ".objc_class_names");
124 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClassVars>(
126 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClsMeth>(
128 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClsRefs>(
130 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCInstMeth>(
133 &DarwinAsmParser::parseSectionDirectiveObjCInstanceVars>(
134 ".objc_instance_vars");
135 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCMessageRefs>(
136 ".objc_message_refs");
137 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCMetaClass>(
140 &DarwinAsmParser::parseSectionDirectiveObjCMethVarNames>(
141 ".objc_meth_var_names");
143 &DarwinAsmParser::parseSectionDirectiveObjCMethVarTypes>(
144 ".objc_meth_var_types");
145 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCModuleInfo>(
146 ".objc_module_info");
147 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCProtocol>(
150 &DarwinAsmParser::parseSectionDirectiveObjCSelectorStrs>(
151 ".objc_selector_strs");
153 &DarwinAsmParser::parseSectionDirectiveObjCStringObject>(
154 ".objc_string_object");
155 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCSymbols>(
157 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectivePICSymbolStub>(
159 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveStaticConst>(
161 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveStaticData>(
163 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveSymbolStub>(
165 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveTData>(".tdata");
166 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveText>(".text");
167 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveThreadInitFunc>(
168 ".thread_init_func");
169 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveTLV>(".tlv");
171 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveIdent>(".ident");
172 addDirectiveHandler<&DarwinAsmParser::parseVersionMin>(
173 ".watchos_version_min");
174 addDirectiveHandler<&DarwinAsmParser::parseVersionMin>(".tvos_version_min");
175 addDirectiveHandler<&DarwinAsmParser::parseVersionMin>(".ios_version_min");
176 addDirectiveHandler<&DarwinAsmParser::parseVersionMin>(
177 ".macosx_version_min");
179 LastVersionMinDirective = SMLoc();
182 bool parseDirectiveDesc(StringRef, SMLoc);
183 bool parseDirectiveIndirectSymbol(StringRef, SMLoc);
184 bool parseDirectiveDumpOrLoad(StringRef, SMLoc);
185 bool parseDirectiveLsym(StringRef, SMLoc);
186 bool parseDirectiveLinkerOption(StringRef, SMLoc);
187 bool parseDirectiveSection(StringRef, SMLoc);
188 bool parseDirectivePushSection(StringRef, SMLoc);
189 bool parseDirectivePopSection(StringRef, SMLoc);
190 bool parseDirectivePrevious(StringRef, SMLoc);
191 bool parseDirectiveSecureLogReset(StringRef, SMLoc);
192 bool parseDirectiveSecureLogUnique(StringRef, SMLoc);
193 bool parseDirectiveSubsectionsViaSymbols(StringRef, SMLoc);
194 bool parseDirectiveTBSS(StringRef, SMLoc);
195 bool parseDirectiveZerofill(StringRef, SMLoc);
196 bool parseDirectiveDataRegion(StringRef, SMLoc);
197 bool parseDirectiveDataRegionEnd(StringRef, SMLoc);
199 // Named Section Directive
200 bool parseSectionDirectiveBss(StringRef, SMLoc) {
201 return parseSectionSwitch("__DATA", "__bss");
204 bool parseSectionDirectiveConst(StringRef, SMLoc) {
205 return parseSectionSwitch("__TEXT", "__const");
207 bool parseSectionDirectiveStaticConst(StringRef, SMLoc) {
208 return parseSectionSwitch("__TEXT", "__static_const");
210 bool parseSectionDirectiveCString(StringRef, SMLoc) {
211 return parseSectionSwitch("__TEXT","__cstring",
212 MachO::S_CSTRING_LITERALS);
214 bool parseSectionDirectiveLiteral4(StringRef, SMLoc) {
215 return parseSectionSwitch("__TEXT", "__literal4",
216 MachO::S_4BYTE_LITERALS, 4);
218 bool parseSectionDirectiveLiteral8(StringRef, SMLoc) {
219 return parseSectionSwitch("__TEXT", "__literal8",
220 MachO::S_8BYTE_LITERALS, 8);
222 bool parseSectionDirectiveLiteral16(StringRef, SMLoc) {
223 return parseSectionSwitch("__TEXT","__literal16",
224 MachO::S_16BYTE_LITERALS, 16);
226 bool parseSectionDirectiveConstructor(StringRef, SMLoc) {
227 return parseSectionSwitch("__TEXT","__constructor");
229 bool parseSectionDirectiveDestructor(StringRef, SMLoc) {
230 return parseSectionSwitch("__TEXT","__destructor");
232 bool parseSectionDirectiveFVMLibInit0(StringRef, SMLoc) {
233 return parseSectionSwitch("__TEXT","__fvmlib_init0");
235 bool parseSectionDirectiveFVMLibInit1(StringRef, SMLoc) {
236 return parseSectionSwitch("__TEXT","__fvmlib_init1");
238 bool parseSectionDirectiveSymbolStub(StringRef, SMLoc) {
239 return parseSectionSwitch("__TEXT","__symbol_stub",
240 MachO::S_SYMBOL_STUBS |
241 MachO::S_ATTR_PURE_INSTRUCTIONS,
242 // FIXME: Different on PPC and ARM.
245 bool parseSectionDirectivePICSymbolStub(StringRef, SMLoc) {
246 return parseSectionSwitch("__TEXT","__picsymbol_stub",
247 MachO::S_SYMBOL_STUBS |
248 MachO::S_ATTR_PURE_INSTRUCTIONS, 0, 26);
250 bool parseSectionDirectiveData(StringRef, SMLoc) {
251 return parseSectionSwitch("__DATA", "__data");
253 bool parseSectionDirectiveStaticData(StringRef, SMLoc) {
254 return parseSectionSwitch("__DATA", "__static_data");
256 bool parseSectionDirectiveNonLazySymbolPointers(StringRef, SMLoc) {
257 return parseSectionSwitch("__DATA", "__nl_symbol_ptr",
258 MachO::S_NON_LAZY_SYMBOL_POINTERS, 4);
260 bool parseSectionDirectiveLazySymbolPointers(StringRef, SMLoc) {
261 return parseSectionSwitch("__DATA", "__la_symbol_ptr",
262 MachO::S_LAZY_SYMBOL_POINTERS, 4);
264 bool parseSectionDirectiveDyld(StringRef, SMLoc) {
265 return parseSectionSwitch("__DATA", "__dyld");
267 bool parseSectionDirectiveModInitFunc(StringRef, SMLoc) {
268 return parseSectionSwitch("__DATA", "__mod_init_func",
269 MachO::S_MOD_INIT_FUNC_POINTERS, 4);
271 bool parseSectionDirectiveModTermFunc(StringRef, SMLoc) {
272 return parseSectionSwitch("__DATA", "__mod_term_func",
273 MachO::S_MOD_TERM_FUNC_POINTERS, 4);
275 bool parseSectionDirectiveConstData(StringRef, SMLoc) {
276 return parseSectionSwitch("__DATA", "__const");
278 bool parseSectionDirectiveObjCClass(StringRef, SMLoc) {
279 return parseSectionSwitch("__OBJC", "__class",
280 MachO::S_ATTR_NO_DEAD_STRIP);
282 bool parseSectionDirectiveObjCMetaClass(StringRef, SMLoc) {
283 return parseSectionSwitch("__OBJC", "__meta_class",
284 MachO::S_ATTR_NO_DEAD_STRIP);
286 bool parseSectionDirectiveObjCCatClsMeth(StringRef, SMLoc) {
287 return parseSectionSwitch("__OBJC", "__cat_cls_meth",
288 MachO::S_ATTR_NO_DEAD_STRIP);
290 bool parseSectionDirectiveObjCCatInstMeth(StringRef, SMLoc) {
291 return parseSectionSwitch("__OBJC", "__cat_inst_meth",
292 MachO::S_ATTR_NO_DEAD_STRIP);
294 bool parseSectionDirectiveObjCProtocol(StringRef, SMLoc) {
295 return parseSectionSwitch("__OBJC", "__protocol",
296 MachO::S_ATTR_NO_DEAD_STRIP);
298 bool parseSectionDirectiveObjCStringObject(StringRef, SMLoc) {
299 return parseSectionSwitch("__OBJC", "__string_object",
300 MachO::S_ATTR_NO_DEAD_STRIP);
302 bool parseSectionDirectiveObjCClsMeth(StringRef, SMLoc) {
303 return parseSectionSwitch("__OBJC", "__cls_meth",
304 MachO::S_ATTR_NO_DEAD_STRIP);
306 bool parseSectionDirectiveObjCInstMeth(StringRef, SMLoc) {
307 return parseSectionSwitch("__OBJC", "__inst_meth",
308 MachO::S_ATTR_NO_DEAD_STRIP);
310 bool parseSectionDirectiveObjCClsRefs(StringRef, SMLoc) {
311 return parseSectionSwitch("__OBJC", "__cls_refs",
312 MachO::S_ATTR_NO_DEAD_STRIP |
313 MachO::S_LITERAL_POINTERS, 4);
315 bool parseSectionDirectiveObjCMessageRefs(StringRef, SMLoc) {
316 return parseSectionSwitch("__OBJC", "__message_refs",
317 MachO::S_ATTR_NO_DEAD_STRIP |
318 MachO::S_LITERAL_POINTERS, 4);
320 bool parseSectionDirectiveObjCSymbols(StringRef, SMLoc) {
321 return parseSectionSwitch("__OBJC", "__symbols",
322 MachO::S_ATTR_NO_DEAD_STRIP);
324 bool parseSectionDirectiveObjCCategory(StringRef, SMLoc) {
325 return parseSectionSwitch("__OBJC", "__category",
326 MachO::S_ATTR_NO_DEAD_STRIP);
328 bool parseSectionDirectiveObjCClassVars(StringRef, SMLoc) {
329 return parseSectionSwitch("__OBJC", "__class_vars",
330 MachO::S_ATTR_NO_DEAD_STRIP);
332 bool parseSectionDirectiveObjCInstanceVars(StringRef, SMLoc) {
333 return parseSectionSwitch("__OBJC", "__instance_vars",
334 MachO::S_ATTR_NO_DEAD_STRIP);
336 bool parseSectionDirectiveObjCModuleInfo(StringRef, SMLoc) {
337 return parseSectionSwitch("__OBJC", "__module_info",
338 MachO::S_ATTR_NO_DEAD_STRIP);
340 bool parseSectionDirectiveObjCClassNames(StringRef, SMLoc) {
341 return parseSectionSwitch("__TEXT", "__cstring",
342 MachO::S_CSTRING_LITERALS);
344 bool parseSectionDirectiveObjCMethVarTypes(StringRef, SMLoc) {
345 return parseSectionSwitch("__TEXT", "__cstring",
346 MachO::S_CSTRING_LITERALS);
348 bool parseSectionDirectiveObjCMethVarNames(StringRef, SMLoc) {
349 return parseSectionSwitch("__TEXT", "__cstring",
350 MachO::S_CSTRING_LITERALS);
352 bool parseSectionDirectiveObjCSelectorStrs(StringRef, SMLoc) {
353 return parseSectionSwitch("__OBJC", "__selector_strs",
354 MachO::S_CSTRING_LITERALS);
356 bool parseSectionDirectiveTData(StringRef, SMLoc) {
357 return parseSectionSwitch("__DATA", "__thread_data",
358 MachO::S_THREAD_LOCAL_REGULAR);
360 bool parseSectionDirectiveText(StringRef, SMLoc) {
361 return parseSectionSwitch("__TEXT", "__text",
362 MachO::S_ATTR_PURE_INSTRUCTIONS);
364 bool parseSectionDirectiveTLV(StringRef, SMLoc) {
365 return parseSectionSwitch("__DATA", "__thread_vars",
366 MachO::S_THREAD_LOCAL_VARIABLES);
368 bool parseSectionDirectiveIdent(StringRef, SMLoc) {
369 // Darwin silently ignores the .ident directive.
370 getParser().eatToEndOfStatement();
373 bool parseSectionDirectiveThreadInitFunc(StringRef, SMLoc) {
374 return parseSectionSwitch("__DATA", "__thread_init",
375 MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS);
377 bool parseVersionMin(StringRef, SMLoc);
381 } // end anonymous namespace
383 bool DarwinAsmParser::parseSectionSwitch(const char *Segment,
385 unsigned TAA, unsigned Align,
387 if (getLexer().isNot(AsmToken::EndOfStatement))
388 return TokError("unexpected token in section switching directive");
391 // FIXME: Arch specific.
392 bool isText = TAA & MachO::S_ATTR_PURE_INSTRUCTIONS;
393 getStreamer().SwitchSection(getContext().getMachOSection(
394 Segment, Section, TAA, StubSize,
395 isText ? SectionKind::getText() : SectionKind::getData()));
397 // Set the implicit alignment, if any.
399 // FIXME: This isn't really what 'as' does; I think it just uses the implicit
400 // alignment on the section (e.g., if one manually inserts bytes into the
401 // section, then just issuing the section switch directive will not realign
402 // the section. However, this is arguably more reasonable behavior, and there
403 // is no good reason for someone to intentionally emit incorrectly sized
404 // values into the implicitly aligned sections.
406 getStreamer().EmitValueToAlignment(Align);
411 /// parseDirectiveDesc
412 /// ::= .desc identifier , expression
413 bool DarwinAsmParser::parseDirectiveDesc(StringRef, SMLoc) {
415 if (getParser().parseIdentifier(Name))
416 return TokError("expected identifier in directive");
418 // Handle the identifier as the key symbol.
419 MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
421 if (getLexer().isNot(AsmToken::Comma))
422 return TokError("unexpected token in '.desc' directive");
426 if (getParser().parseAbsoluteExpression(DescValue))
429 if (getLexer().isNot(AsmToken::EndOfStatement))
430 return TokError("unexpected token in '.desc' directive");
434 // Set the n_desc field of this Symbol to this DescValue
435 getStreamer().EmitSymbolDesc(Sym, DescValue);
440 /// parseDirectiveIndirectSymbol
441 /// ::= .indirect_symbol identifier
442 bool DarwinAsmParser::parseDirectiveIndirectSymbol(StringRef, SMLoc Loc) {
443 const MCSectionMachO *Current = static_cast<const MCSectionMachO*>(
444 getStreamer().getCurrentSection().first);
445 MachO::SectionType SectionType = Current->getType();
446 if (SectionType != MachO::S_NON_LAZY_SYMBOL_POINTERS &&
447 SectionType != MachO::S_LAZY_SYMBOL_POINTERS &&
448 SectionType != MachO::S_SYMBOL_STUBS)
449 return Error(Loc, "indirect symbol not in a symbol pointer or stub "
453 if (getParser().parseIdentifier(Name))
454 return TokError("expected identifier in .indirect_symbol directive");
456 MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
458 // Assembler local symbols don't make any sense here. Complain loudly.
459 if (Sym->isTemporary())
460 return TokError("non-local symbol required in directive");
462 if (!getStreamer().EmitSymbolAttribute(Sym, MCSA_IndirectSymbol))
463 return TokError("unable to emit indirect symbol attribute for: " + Name);
465 if (getLexer().isNot(AsmToken::EndOfStatement))
466 return TokError("unexpected token in '.indirect_symbol' directive");
473 /// parseDirectiveDumpOrLoad
474 /// ::= ( .dump | .load ) "filename"
475 bool DarwinAsmParser::parseDirectiveDumpOrLoad(StringRef Directive,
477 bool IsDump = Directive == ".dump";
478 if (getLexer().isNot(AsmToken::String))
479 return TokError("expected string in '.dump' or '.load' directive");
483 if (getLexer().isNot(AsmToken::EndOfStatement))
484 return TokError("unexpected token in '.dump' or '.load' directive");
488 // FIXME: If/when .dump and .load are implemented they will be done in the
489 // the assembly parser and not have any need for an MCStreamer API.
491 return Warning(IDLoc, "ignoring directive .dump for now");
493 return Warning(IDLoc, "ignoring directive .load for now");
496 /// ParseDirectiveLinkerOption
497 /// ::= .linker_option "string" ( , "string" )*
498 bool DarwinAsmParser::parseDirectiveLinkerOption(StringRef IDVal, SMLoc) {
499 SmallVector<std::string, 4> Args;
501 if (getLexer().isNot(AsmToken::String))
502 return TokError("expected string in '" + Twine(IDVal) + "' directive");
505 if (getParser().parseEscapedString(Data))
508 Args.push_back(Data);
511 if (getLexer().is(AsmToken::EndOfStatement))
514 if (getLexer().isNot(AsmToken::Comma))
515 return TokError("unexpected token in '" + Twine(IDVal) + "' directive");
519 getStreamer().EmitLinkerOptions(Args);
523 /// parseDirectiveLsym
524 /// ::= .lsym identifier , expression
525 bool DarwinAsmParser::parseDirectiveLsym(StringRef, SMLoc) {
527 if (getParser().parseIdentifier(Name))
528 return TokError("expected identifier in directive");
530 // Handle the identifier as the key symbol.
531 MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
533 if (getLexer().isNot(AsmToken::Comma))
534 return TokError("unexpected token in '.lsym' directive");
538 if (getParser().parseExpression(Value))
541 if (getLexer().isNot(AsmToken::EndOfStatement))
542 return TokError("unexpected token in '.lsym' directive");
546 // We don't currently support this directive.
548 // FIXME: Diagnostic location!
550 return TokError("directive '.lsym' is unsupported");
553 /// parseDirectiveSection:
554 /// ::= .section identifier (',' identifier)*
555 bool DarwinAsmParser::parseDirectiveSection(StringRef, SMLoc) {
556 SMLoc Loc = getLexer().getLoc();
558 StringRef SectionName;
559 if (getParser().parseIdentifier(SectionName))
560 return Error(Loc, "expected identifier after '.section' directive");
562 // Verify there is a following comma.
563 if (!getLexer().is(AsmToken::Comma))
564 return TokError("unexpected token in '.section' directive");
566 std::string SectionSpec = SectionName;
569 // Add all the tokens until the end of the line, ParseSectionSpecifier will
571 StringRef EOL = getLexer().LexUntilEndOfStatement();
572 SectionSpec.append(EOL.begin(), EOL.end());
575 if (getLexer().isNot(AsmToken::EndOfStatement))
576 return TokError("unexpected token in '.section' directive");
580 StringRef Segment, Section;
584 std::string ErrorStr =
585 MCSectionMachO::ParseSectionSpecifier(SectionSpec, Segment, Section,
586 TAA, TAAParsed, StubSize);
588 if (!ErrorStr.empty())
589 return Error(Loc, ErrorStr.c_str());
591 // Issue a warning if the target is not powerpc and Section is a *coal* section.
592 Triple TT = getParser().getContext().getObjectFileInfo()->getTargetTriple();
593 Triple::ArchType ArchTy = TT.getArch();
595 if (ArchTy != Triple::ppc && ArchTy != Triple::ppc64) {
596 StringRef NonCoalSection = StringSwitch<StringRef>(Section)
597 .Case("__textcoal_nt", "__text")
598 .Case("__const_coal", "__const")
599 .Case("__datacoal_nt", "__data")
602 if (!Section.equals(NonCoalSection)) {
603 StringRef SectionVal(Loc.getPointer());
604 size_t B = SectionVal.find(',') + 1, E = SectionVal.find(',', B);
605 SMLoc BLoc = SMLoc::getFromPointer(SectionVal.data() + B);
606 SMLoc ELoc = SMLoc::getFromPointer(SectionVal.data() + E);
607 getParser().Warning(Loc, "section \"" + Section + "\" is deprecated",
608 SMRange(BLoc, ELoc));
609 getParser().Note(Loc, "change section name to \"" + NonCoalSection +
610 "\"", SMRange(BLoc, ELoc));
614 // FIXME: Arch specific.
615 bool isText = Segment == "__TEXT"; // FIXME: Hack.
616 getStreamer().SwitchSection(getContext().getMachOSection(
617 Segment, Section, TAA, StubSize,
618 isText ? SectionKind::getText() : SectionKind::getData()));
622 /// ParseDirectivePushSection:
623 /// ::= .pushsection identifier (',' identifier)*
624 bool DarwinAsmParser::parseDirectivePushSection(StringRef S, SMLoc Loc) {
625 getStreamer().PushSection();
627 if (parseDirectiveSection(S, Loc)) {
628 getStreamer().PopSection();
635 /// ParseDirectivePopSection:
637 bool DarwinAsmParser::parseDirectivePopSection(StringRef, SMLoc) {
638 if (!getStreamer().PopSection())
639 return TokError(".popsection without corresponding .pushsection");
643 /// ParseDirectivePrevious:
645 bool DarwinAsmParser::parseDirectivePrevious(StringRef DirName, SMLoc) {
646 MCSectionSubPair PreviousSection = getStreamer().getPreviousSection();
647 if (!PreviousSection.first)
648 return TokError(".previous without corresponding .section");
649 getStreamer().SwitchSection(PreviousSection.first, PreviousSection.second);
653 /// ParseDirectiveSecureLogUnique
654 /// ::= .secure_log_unique ... message ...
655 bool DarwinAsmParser::parseDirectiveSecureLogUnique(StringRef, SMLoc IDLoc) {
656 StringRef LogMessage = getParser().parseStringToEndOfStatement();
657 if (getLexer().isNot(AsmToken::EndOfStatement))
658 return TokError("unexpected token in '.secure_log_unique' directive");
660 if (getContext().getSecureLogUsed())
661 return Error(IDLoc, ".secure_log_unique specified multiple times");
663 // Get the secure log path.
664 const char *SecureLogFile = getContext().getSecureLogFile();
666 return Error(IDLoc, ".secure_log_unique used but AS_SECURE_LOG_FILE "
667 "environment variable unset.");
669 // Open the secure log file if we haven't already.
670 raw_fd_ostream *OS = getContext().getSecureLog();
673 auto NewOS = llvm::make_unique<raw_fd_ostream>(
674 SecureLogFile, EC, sys::fs::F_Append | sys::fs::F_Text);
676 return Error(IDLoc, Twine("can't open secure log file: ") +
677 SecureLogFile + " (" + EC.message() + ")");
679 getContext().setSecureLog(std::move(NewOS));
682 // Write the message.
683 unsigned CurBuf = getSourceManager().FindBufferContainingLoc(IDLoc);
684 *OS << getSourceManager().getBufferInfo(CurBuf).Buffer->getBufferIdentifier()
685 << ":" << getSourceManager().FindLineNumber(IDLoc, CurBuf) << ":"
686 << LogMessage + "\n";
688 getContext().setSecureLogUsed(true);
693 /// ParseDirectiveSecureLogReset
694 /// ::= .secure_log_reset
695 bool DarwinAsmParser::parseDirectiveSecureLogReset(StringRef, SMLoc IDLoc) {
696 if (getLexer().isNot(AsmToken::EndOfStatement))
697 return TokError("unexpected token in '.secure_log_reset' directive");
701 getContext().setSecureLogUsed(false);
706 /// parseDirectiveSubsectionsViaSymbols
707 /// ::= .subsections_via_symbols
708 bool DarwinAsmParser::parseDirectiveSubsectionsViaSymbols(StringRef, SMLoc) {
709 if (getLexer().isNot(AsmToken::EndOfStatement))
710 return TokError("unexpected token in '.subsections_via_symbols' directive");
714 getStreamer().EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
719 /// ParseDirectiveTBSS
720 /// ::= .tbss identifier, size, align
721 bool DarwinAsmParser::parseDirectiveTBSS(StringRef, SMLoc) {
722 SMLoc IDLoc = getLexer().getLoc();
724 if (getParser().parseIdentifier(Name))
725 return TokError("expected identifier in directive");
727 // Handle the identifier as the key symbol.
728 MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
730 if (getLexer().isNot(AsmToken::Comma))
731 return TokError("unexpected token in directive");
735 SMLoc SizeLoc = getLexer().getLoc();
736 if (getParser().parseAbsoluteExpression(Size))
739 int64_t Pow2Alignment = 0;
740 SMLoc Pow2AlignmentLoc;
741 if (getLexer().is(AsmToken::Comma)) {
743 Pow2AlignmentLoc = getLexer().getLoc();
744 if (getParser().parseAbsoluteExpression(Pow2Alignment))
748 if (getLexer().isNot(AsmToken::EndOfStatement))
749 return TokError("unexpected token in '.tbss' directive");
754 return Error(SizeLoc, "invalid '.tbss' directive size, can't be less than"
757 // FIXME: Diagnose overflow.
758 if (Pow2Alignment < 0)
759 return Error(Pow2AlignmentLoc, "invalid '.tbss' alignment, can't be less"
762 if (!Sym->isUndefined())
763 return Error(IDLoc, "invalid symbol redefinition");
765 getStreamer().EmitTBSSSymbol(getContext().getMachOSection(
766 "__DATA", "__thread_bss",
767 MachO::S_THREAD_LOCAL_ZEROFILL,
768 0, SectionKind::getThreadBSS()),
769 Sym, Size, 1 << Pow2Alignment);
774 /// ParseDirectiveZerofill
775 /// ::= .zerofill segname , sectname [, identifier , size_expression [
776 /// , align_expression ]]
777 bool DarwinAsmParser::parseDirectiveZerofill(StringRef, SMLoc) {
779 if (getParser().parseIdentifier(Segment))
780 return TokError("expected segment name after '.zerofill' directive");
782 if (getLexer().isNot(AsmToken::Comma))
783 return TokError("unexpected token in directive");
787 if (getParser().parseIdentifier(Section))
788 return TokError("expected section name after comma in '.zerofill' "
791 // If this is the end of the line all that was wanted was to create the
792 // the section but with no symbol.
793 if (getLexer().is(AsmToken::EndOfStatement)) {
794 // Create the zerofill section but no symbol
795 getStreamer().EmitZerofill(getContext().getMachOSection(
796 Segment, Section, MachO::S_ZEROFILL,
797 0, SectionKind::getBSS()));
801 if (getLexer().isNot(AsmToken::Comma))
802 return TokError("unexpected token in directive");
805 SMLoc IDLoc = getLexer().getLoc();
807 if (getParser().parseIdentifier(IDStr))
808 return TokError("expected identifier in directive");
810 // handle the identifier as the key symbol.
811 MCSymbol *Sym = getContext().getOrCreateSymbol(IDStr);
813 if (getLexer().isNot(AsmToken::Comma))
814 return TokError("unexpected token in directive");
818 SMLoc SizeLoc = getLexer().getLoc();
819 if (getParser().parseAbsoluteExpression(Size))
822 int64_t Pow2Alignment = 0;
823 SMLoc Pow2AlignmentLoc;
824 if (getLexer().is(AsmToken::Comma)) {
826 Pow2AlignmentLoc = getLexer().getLoc();
827 if (getParser().parseAbsoluteExpression(Pow2Alignment))
831 if (getLexer().isNot(AsmToken::EndOfStatement))
832 return TokError("unexpected token in '.zerofill' directive");
837 return Error(SizeLoc, "invalid '.zerofill' directive size, can't be less "
840 // NOTE: The alignment in the directive is a power of 2 value, the assembler
841 // may internally end up wanting an alignment in bytes.
842 // FIXME: Diagnose overflow.
843 if (Pow2Alignment < 0)
844 return Error(Pow2AlignmentLoc, "invalid '.zerofill' directive alignment, "
845 "can't be less than zero");
847 if (!Sym->isUndefined())
848 return Error(IDLoc, "invalid symbol redefinition");
850 // Create the zerofill Symbol with Size and Pow2Alignment
852 // FIXME: Arch specific.
853 getStreamer().EmitZerofill(getContext().getMachOSection(
854 Segment, Section, MachO::S_ZEROFILL,
855 0, SectionKind::getBSS()),
856 Sym, Size, 1 << Pow2Alignment);
861 /// ParseDirectiveDataRegion
862 /// ::= .data_region [ ( jt8 | jt16 | jt32 ) ]
863 bool DarwinAsmParser::parseDirectiveDataRegion(StringRef, SMLoc) {
864 if (getLexer().is(AsmToken::EndOfStatement)) {
866 getStreamer().EmitDataRegion(MCDR_DataRegion);
869 StringRef RegionType;
870 SMLoc Loc = getParser().getTok().getLoc();
871 if (getParser().parseIdentifier(RegionType))
872 return TokError("expected region type after '.data_region' directive");
873 int Kind = StringSwitch<int>(RegionType)
874 .Case("jt8", MCDR_DataRegionJT8)
875 .Case("jt16", MCDR_DataRegionJT16)
876 .Case("jt32", MCDR_DataRegionJT32)
879 return Error(Loc, "unknown region type in '.data_region' directive");
882 getStreamer().EmitDataRegion((MCDataRegionType)Kind);
886 /// ParseDirectiveDataRegionEnd
887 /// ::= .end_data_region
888 bool DarwinAsmParser::parseDirectiveDataRegionEnd(StringRef, SMLoc) {
889 if (getLexer().isNot(AsmToken::EndOfStatement))
890 return TokError("unexpected token in '.end_data_region' directive");
893 getStreamer().EmitDataRegion(MCDR_DataRegionEnd);
898 /// ::= .ios_version_min major,minor[,update]
899 /// ::= .macosx_version_min major,minor[,update]
900 bool DarwinAsmParser::parseVersionMin(StringRef Directive, SMLoc Loc) {
901 int64_t Major = 0, Minor = 0, Update = 0;
902 int Kind = StringSwitch<int>(Directive)
903 .Case(".watchos_version_min", MCVM_WatchOSVersionMin)
904 .Case(".tvos_version_min", MCVM_TvOSVersionMin)
905 .Case(".ios_version_min", MCVM_IOSVersionMin)
906 .Case(".macosx_version_min", MCVM_OSXVersionMin);
907 // Get the major version number.
908 if (getLexer().isNot(AsmToken::Integer))
909 return TokError("invalid OS major version number");
910 Major = getLexer().getTok().getIntVal();
911 if (Major > 65535 || Major <= 0)
912 return TokError("invalid OS major version number");
914 if (getLexer().isNot(AsmToken::Comma))
915 return TokError("minor OS version number required, comma expected");
917 // Get the minor version number.
918 if (getLexer().isNot(AsmToken::Integer))
919 return TokError("invalid OS minor version number");
920 Minor = getLexer().getTok().getIntVal();
921 if (Minor > 255 || Minor < 0)
922 return TokError("invalid OS minor version number");
924 // Get the update level, if specified
925 if (getLexer().isNot(AsmToken::EndOfStatement)) {
926 if (getLexer().isNot(AsmToken::Comma))
927 return TokError("invalid update specifier, comma expected");
929 if (getLexer().isNot(AsmToken::Integer))
930 return TokError("invalid OS update number");
931 Update = getLexer().getTok().getIntVal();
932 if (Update > 255 || Update < 0)
933 return TokError("invalid OS update number");
937 const Triple &T = getContext().getObjectFileInfo()->getTargetTriple();
938 Triple::OSType ExpectedOS = Triple::UnknownOS;
939 switch ((MCVersionMinType)Kind) {
940 case MCVM_WatchOSVersionMin: ExpectedOS = Triple::WatchOS; break;
941 case MCVM_TvOSVersionMin: ExpectedOS = Triple::TvOS; break;
942 case MCVM_IOSVersionMin: ExpectedOS = Triple::IOS; break;
943 case MCVM_OSXVersionMin: ExpectedOS = Triple::MacOSX; break;
945 if (T.getOS() != ExpectedOS)
946 Warning(Loc, Directive + " should only be used for " +
947 Triple::getOSTypeName(ExpectedOS) + " targets");
949 if (LastVersionMinDirective.isValid()) {
950 Warning(Loc, "overriding previous version_min directive");
951 Note(LastVersionMinDirective, "previous definition is here");
953 LastVersionMinDirective = Loc;
955 // We've parsed a correct version specifier, so send it to the streamer.
956 getStreamer().EmitVersionMin((MCVersionMinType)Kind, Major, Minor, Update);
963 MCAsmParserExtension *createDarwinAsmParser() {
964 return new DarwinAsmParser;
967 } // end llvm namespace