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