1 //===- DarwinAsmParser.cpp - Darwin (Mach-O) Assembly Parser --------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "llvm/ADT/STLExtras.h" 10 #include "llvm/ADT/SmallVector.h" 11 #include "llvm/ADT/StringRef.h" 12 #include "llvm/ADT/StringSwitch.h" 13 #include "llvm/ADT/Triple.h" 14 #include "llvm/ADT/Twine.h" 15 #include "llvm/BinaryFormat/MachO.h" 16 #include "llvm/MC/MCContext.h" 17 #include "llvm/MC/MCDirectives.h" 18 #include "llvm/MC/MCObjectFileInfo.h" 19 #include "llvm/MC/MCParser/MCAsmLexer.h" 20 #include "llvm/MC/MCParser/MCAsmParser.h" 21 #include "llvm/MC/MCParser/MCAsmParserExtension.h" 22 #include "llvm/MC/MCSectionMachO.h" 23 #include "llvm/MC/MCStreamer.h" 24 #include "llvm/MC/MCSymbol.h" 25 #include "llvm/MC/SectionKind.h" 26 #include "llvm/Support/Error.h" 27 #include "llvm/Support/FileSystem.h" 28 #include "llvm/Support/MemoryBuffer.h" 29 #include "llvm/Support/SMLoc.h" 30 #include "llvm/Support/SourceMgr.h" 31 #include "llvm/Support/raw_ostream.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 /// 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 LastVersionDirective; 58 59 public: 60 DarwinAsmParser() = default; 61 62 void Initialize(MCAsmParser &Parser) override { 63 // Call the base implementation. 64 this->MCAsmParserExtension::Initialize(Parser); 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::parseWatchOSVersionMin>( 190 ".watchos_version_min"); 191 addDirectiveHandler<&DarwinAsmParser::parseTvOSVersionMin>( 192 ".tvos_version_min"); 193 addDirectiveHandler<&DarwinAsmParser::parseIOSVersionMin>( 194 ".ios_version_min"); 195 addDirectiveHandler<&DarwinAsmParser::parseMacOSXVersionMin>( 196 ".macosx_version_min"); 197 addDirectiveHandler<&DarwinAsmParser::parseBuildVersion>(".build_version"); 198 199 LastVersionDirective = SMLoc(); 200 } 201 202 bool parseDirectiveAltEntry(StringRef, SMLoc); 203 bool parseDirectiveDesc(StringRef, SMLoc); 204 bool parseDirectiveIndirectSymbol(StringRef, SMLoc); 205 bool parseDirectiveDumpOrLoad(StringRef, SMLoc); 206 bool parseDirectiveLsym(StringRef, SMLoc); 207 bool parseDirectiveLinkerOption(StringRef, SMLoc); 208 bool parseDirectiveSection(StringRef, SMLoc); 209 bool parseDirectivePushSection(StringRef, SMLoc); 210 bool parseDirectivePopSection(StringRef, SMLoc); 211 bool parseDirectivePrevious(StringRef, SMLoc); 212 bool parseDirectiveSecureLogReset(StringRef, SMLoc); 213 bool parseDirectiveSecureLogUnique(StringRef, SMLoc); 214 bool parseDirectiveSubsectionsViaSymbols(StringRef, SMLoc); 215 bool parseDirectiveTBSS(StringRef, SMLoc); 216 bool parseDirectiveZerofill(StringRef, SMLoc); 217 bool parseDirectiveDataRegion(StringRef, SMLoc); 218 bool parseDirectiveDataRegionEnd(StringRef, SMLoc); 219 220 // Named Section Directive 221 bool parseSectionDirectiveBss(StringRef, SMLoc) { 222 return parseSectionSwitch("__DATA", "__bss"); 223 } 224 225 bool parseSectionDirectiveConst(StringRef, SMLoc) { 226 return parseSectionSwitch("__TEXT", "__const"); 227 } 228 229 bool parseSectionDirectiveStaticConst(StringRef, SMLoc) { 230 return parseSectionSwitch("__TEXT", "__static_const"); 231 } 232 233 bool parseSectionDirectiveCString(StringRef, SMLoc) { 234 return parseSectionSwitch("__TEXT","__cstring", 235 MachO::S_CSTRING_LITERALS); 236 } 237 238 bool parseSectionDirectiveLiteral4(StringRef, SMLoc) { 239 return parseSectionSwitch("__TEXT", "__literal4", 240 MachO::S_4BYTE_LITERALS, 4); 241 } 242 243 bool parseSectionDirectiveLiteral8(StringRef, SMLoc) { 244 return parseSectionSwitch("__TEXT", "__literal8", 245 MachO::S_8BYTE_LITERALS, 8); 246 } 247 248 bool parseSectionDirectiveLiteral16(StringRef, SMLoc) { 249 return parseSectionSwitch("__TEXT","__literal16", 250 MachO::S_16BYTE_LITERALS, 16); 251 } 252 253 bool parseSectionDirectiveConstructor(StringRef, SMLoc) { 254 return parseSectionSwitch("__TEXT","__constructor"); 255 } 256 257 bool parseSectionDirectiveDestructor(StringRef, SMLoc) { 258 return parseSectionSwitch("__TEXT","__destructor"); 259 } 260 261 bool parseSectionDirectiveFVMLibInit0(StringRef, SMLoc) { 262 return parseSectionSwitch("__TEXT","__fvmlib_init0"); 263 } 264 265 bool parseSectionDirectiveFVMLibInit1(StringRef, SMLoc) { 266 return parseSectionSwitch("__TEXT","__fvmlib_init1"); 267 } 268 269 bool parseSectionDirectiveSymbolStub(StringRef, SMLoc) { 270 return parseSectionSwitch("__TEXT","__symbol_stub", 271 MachO::S_SYMBOL_STUBS | 272 MachO::S_ATTR_PURE_INSTRUCTIONS, 273 // FIXME: Different on PPC and ARM. 274 0, 16); 275 } 276 277 bool parseSectionDirectivePICSymbolStub(StringRef, SMLoc) { 278 return parseSectionSwitch("__TEXT","__picsymbol_stub", 279 MachO::S_SYMBOL_STUBS | 280 MachO::S_ATTR_PURE_INSTRUCTIONS, 0, 26); 281 } 282 283 bool parseSectionDirectiveData(StringRef, SMLoc) { 284 return parseSectionSwitch("__DATA", "__data"); 285 } 286 287 bool parseSectionDirectiveStaticData(StringRef, SMLoc) { 288 return parseSectionSwitch("__DATA", "__static_data"); 289 } 290 291 bool parseSectionDirectiveNonLazySymbolPointers(StringRef, SMLoc) { 292 return parseSectionSwitch("__DATA", "__nl_symbol_ptr", 293 MachO::S_NON_LAZY_SYMBOL_POINTERS, 4); 294 } 295 296 bool parseSectionDirectiveLazySymbolPointers(StringRef, SMLoc) { 297 return parseSectionSwitch("__DATA", "__la_symbol_ptr", 298 MachO::S_LAZY_SYMBOL_POINTERS, 4); 299 } 300 301 bool parseSectionDirectiveThreadLocalVariablePointers(StringRef, SMLoc) { 302 return parseSectionSwitch("__DATA", "__thread_ptr", 303 MachO::S_THREAD_LOCAL_VARIABLE_POINTERS, 4); 304 } 305 306 bool parseSectionDirectiveDyld(StringRef, SMLoc) { 307 return parseSectionSwitch("__DATA", "__dyld"); 308 } 309 310 bool parseSectionDirectiveModInitFunc(StringRef, SMLoc) { 311 return parseSectionSwitch("__DATA", "__mod_init_func", 312 MachO::S_MOD_INIT_FUNC_POINTERS, 4); 313 } 314 315 bool parseSectionDirectiveModTermFunc(StringRef, SMLoc) { 316 return parseSectionSwitch("__DATA", "__mod_term_func", 317 MachO::S_MOD_TERM_FUNC_POINTERS, 4); 318 } 319 320 bool parseSectionDirectiveConstData(StringRef, SMLoc) { 321 return parseSectionSwitch("__DATA", "__const"); 322 } 323 324 bool parseSectionDirectiveObjCClass(StringRef, SMLoc) { 325 return parseSectionSwitch("__OBJC", "__class", 326 MachO::S_ATTR_NO_DEAD_STRIP); 327 } 328 329 bool parseSectionDirectiveObjCMetaClass(StringRef, SMLoc) { 330 return parseSectionSwitch("__OBJC", "__meta_class", 331 MachO::S_ATTR_NO_DEAD_STRIP); 332 } 333 334 bool parseSectionDirectiveObjCCatClsMeth(StringRef, SMLoc) { 335 return parseSectionSwitch("__OBJC", "__cat_cls_meth", 336 MachO::S_ATTR_NO_DEAD_STRIP); 337 } 338 339 bool parseSectionDirectiveObjCCatInstMeth(StringRef, SMLoc) { 340 return parseSectionSwitch("__OBJC", "__cat_inst_meth", 341 MachO::S_ATTR_NO_DEAD_STRIP); 342 } 343 344 bool parseSectionDirectiveObjCProtocol(StringRef, SMLoc) { 345 return parseSectionSwitch("__OBJC", "__protocol", 346 MachO::S_ATTR_NO_DEAD_STRIP); 347 } 348 349 bool parseSectionDirectiveObjCStringObject(StringRef, SMLoc) { 350 return parseSectionSwitch("__OBJC", "__string_object", 351 MachO::S_ATTR_NO_DEAD_STRIP); 352 } 353 354 bool parseSectionDirectiveObjCClsMeth(StringRef, SMLoc) { 355 return parseSectionSwitch("__OBJC", "__cls_meth", 356 MachO::S_ATTR_NO_DEAD_STRIP); 357 } 358 359 bool parseSectionDirectiveObjCInstMeth(StringRef, SMLoc) { 360 return parseSectionSwitch("__OBJC", "__inst_meth", 361 MachO::S_ATTR_NO_DEAD_STRIP); 362 } 363 364 bool parseSectionDirectiveObjCClsRefs(StringRef, SMLoc) { 365 return parseSectionSwitch("__OBJC", "__cls_refs", 366 MachO::S_ATTR_NO_DEAD_STRIP | 367 MachO::S_LITERAL_POINTERS, 4); 368 } 369 370 bool parseSectionDirectiveObjCMessageRefs(StringRef, SMLoc) { 371 return parseSectionSwitch("__OBJC", "__message_refs", 372 MachO::S_ATTR_NO_DEAD_STRIP | 373 MachO::S_LITERAL_POINTERS, 4); 374 } 375 376 bool parseSectionDirectiveObjCSymbols(StringRef, SMLoc) { 377 return parseSectionSwitch("__OBJC", "__symbols", 378 MachO::S_ATTR_NO_DEAD_STRIP); 379 } 380 381 bool parseSectionDirectiveObjCCategory(StringRef, SMLoc) { 382 return parseSectionSwitch("__OBJC", "__category", 383 MachO::S_ATTR_NO_DEAD_STRIP); 384 } 385 386 bool parseSectionDirectiveObjCClassVars(StringRef, SMLoc) { 387 return parseSectionSwitch("__OBJC", "__class_vars", 388 MachO::S_ATTR_NO_DEAD_STRIP); 389 } 390 391 bool parseSectionDirectiveObjCInstanceVars(StringRef, SMLoc) { 392 return parseSectionSwitch("__OBJC", "__instance_vars", 393 MachO::S_ATTR_NO_DEAD_STRIP); 394 } 395 396 bool parseSectionDirectiveObjCModuleInfo(StringRef, SMLoc) { 397 return parseSectionSwitch("__OBJC", "__module_info", 398 MachO::S_ATTR_NO_DEAD_STRIP); 399 } 400 401 bool parseSectionDirectiveObjCClassNames(StringRef, SMLoc) { 402 return parseSectionSwitch("__TEXT", "__cstring", 403 MachO::S_CSTRING_LITERALS); 404 } 405 406 bool parseSectionDirectiveObjCMethVarTypes(StringRef, SMLoc) { 407 return parseSectionSwitch("__TEXT", "__cstring", 408 MachO::S_CSTRING_LITERALS); 409 } 410 411 bool parseSectionDirectiveObjCMethVarNames(StringRef, SMLoc) { 412 return parseSectionSwitch("__TEXT", "__cstring", 413 MachO::S_CSTRING_LITERALS); 414 } 415 416 bool parseSectionDirectiveObjCSelectorStrs(StringRef, SMLoc) { 417 return parseSectionSwitch("__OBJC", "__selector_strs", 418 MachO::S_CSTRING_LITERALS); 419 } 420 421 bool parseSectionDirectiveTData(StringRef, SMLoc) { 422 return parseSectionSwitch("__DATA", "__thread_data", 423 MachO::S_THREAD_LOCAL_REGULAR); 424 } 425 426 bool parseSectionDirectiveText(StringRef, SMLoc) { 427 return parseSectionSwitch("__TEXT", "__text", 428 MachO::S_ATTR_PURE_INSTRUCTIONS); 429 } 430 431 bool parseSectionDirectiveTLV(StringRef, SMLoc) { 432 return parseSectionSwitch("__DATA", "__thread_vars", 433 MachO::S_THREAD_LOCAL_VARIABLES); 434 } 435 436 bool parseSectionDirectiveIdent(StringRef, SMLoc) { 437 // Darwin silently ignores the .ident directive. 438 getParser().eatToEndOfStatement(); 439 return false; 440 } 441 442 bool parseSectionDirectiveThreadInitFunc(StringRef, SMLoc) { 443 return parseSectionSwitch("__DATA", "__thread_init", 444 MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS); 445 } 446 447 bool parseWatchOSVersionMin(StringRef Directive, SMLoc Loc) { 448 return parseVersionMin(Directive, Loc, MCVM_WatchOSVersionMin); 449 } 450 bool parseTvOSVersionMin(StringRef Directive, SMLoc Loc) { 451 return parseVersionMin(Directive, Loc, MCVM_TvOSVersionMin); 452 } 453 bool parseIOSVersionMin(StringRef Directive, SMLoc Loc) { 454 return parseVersionMin(Directive, Loc, MCVM_IOSVersionMin); 455 } 456 bool parseMacOSXVersionMin(StringRef Directive, SMLoc Loc) { 457 return parseVersionMin(Directive, Loc, MCVM_OSXVersionMin); 458 } 459 460 bool parseBuildVersion(StringRef Directive, SMLoc Loc); 461 bool parseVersionMin(StringRef Directive, SMLoc Loc, MCVersionMinType Type); 462 bool parseMajorMinorVersionComponent(unsigned *Major, unsigned *Minor, 463 const char *VersionName); 464 bool parseOptionalTrailingVersionComponent(unsigned *Component, 465 const char *ComponentName); 466 bool parseVersion(unsigned *Major, unsigned *Minor, unsigned *Update); 467 bool parseSDKVersion(VersionTuple &SDKVersion); 468 void checkVersion(StringRef Directive, StringRef Arg, SMLoc Loc, 469 Triple::OSType ExpectedOS); 470 }; 471 472 } // end anonymous namespace 473 474 bool DarwinAsmParser::parseSectionSwitch(StringRef Segment, StringRef Section, 475 unsigned TAA, unsigned Align, 476 unsigned StubSize) { 477 if (getLexer().isNot(AsmToken::EndOfStatement)) 478 return TokError("unexpected token in section switching directive"); 479 Lex(); 480 481 // FIXME: Arch specific. 482 bool isText = TAA & MachO::S_ATTR_PURE_INSTRUCTIONS; 483 getStreamer().SwitchSection(getContext().getMachOSection( 484 Segment, Section, TAA, StubSize, 485 isText ? SectionKind::getText() : SectionKind::getData())); 486 487 // Set the implicit alignment, if any. 488 // 489 // FIXME: This isn't really what 'as' does; I think it just uses the implicit 490 // alignment on the section (e.g., if one manually inserts bytes into the 491 // section, then just issuing the section switch directive will not realign 492 // the section. However, this is arguably more reasonable behavior, and there 493 // is no good reason for someone to intentionally emit incorrectly sized 494 // values into the implicitly aligned sections. 495 if (Align) 496 getStreamer().emitValueToAlignment(Align); 497 498 return false; 499 } 500 501 /// parseDirectiveAltEntry 502 /// ::= .alt_entry identifier 503 bool DarwinAsmParser::parseDirectiveAltEntry(StringRef, SMLoc) { 504 StringRef Name; 505 if (getParser().parseIdentifier(Name)) 506 return TokError("expected identifier in directive"); 507 508 // Look up symbol. 509 MCSymbol *Sym = getContext().getOrCreateSymbol(Name); 510 511 if (Sym->isDefined()) 512 return TokError(".alt_entry must preceed symbol definition"); 513 514 if (!getStreamer().emitSymbolAttribute(Sym, MCSA_AltEntry)) 515 return TokError("unable to emit symbol attribute"); 516 517 Lex(); 518 return false; 519 } 520 521 /// parseDirectiveDesc 522 /// ::= .desc identifier , expression 523 bool DarwinAsmParser::parseDirectiveDesc(StringRef, SMLoc) { 524 StringRef Name; 525 if (getParser().parseIdentifier(Name)) 526 return TokError("expected identifier in directive"); 527 528 // Handle the identifier as the key symbol. 529 MCSymbol *Sym = getContext().getOrCreateSymbol(Name); 530 531 if (getLexer().isNot(AsmToken::Comma)) 532 return TokError("unexpected token in '.desc' directive"); 533 Lex(); 534 535 int64_t DescValue; 536 if (getParser().parseAbsoluteExpression(DescValue)) 537 return true; 538 539 if (getLexer().isNot(AsmToken::EndOfStatement)) 540 return TokError("unexpected token in '.desc' directive"); 541 542 Lex(); 543 544 // Set the n_desc field of this Symbol to this DescValue 545 getStreamer().emitSymbolDesc(Sym, DescValue); 546 547 return false; 548 } 549 550 /// parseDirectiveIndirectSymbol 551 /// ::= .indirect_symbol identifier 552 bool DarwinAsmParser::parseDirectiveIndirectSymbol(StringRef, SMLoc Loc) { 553 const MCSectionMachO *Current = static_cast<const MCSectionMachO *>( 554 getStreamer().getCurrentSectionOnly()); 555 MachO::SectionType SectionType = Current->getType(); 556 if (SectionType != MachO::S_NON_LAZY_SYMBOL_POINTERS && 557 SectionType != MachO::S_LAZY_SYMBOL_POINTERS && 558 SectionType != MachO::S_THREAD_LOCAL_VARIABLE_POINTERS && 559 SectionType != MachO::S_SYMBOL_STUBS) 560 return Error(Loc, "indirect symbol not in a symbol pointer or stub " 561 "section"); 562 563 StringRef Name; 564 if (getParser().parseIdentifier(Name)) 565 return TokError("expected identifier in .indirect_symbol directive"); 566 567 MCSymbol *Sym = getContext().getOrCreateSymbol(Name); 568 569 // Assembler local symbols don't make any sense here. Complain loudly. 570 if (Sym->isTemporary()) 571 return TokError("non-local symbol required in directive"); 572 573 if (!getStreamer().emitSymbolAttribute(Sym, MCSA_IndirectSymbol)) 574 return TokError("unable to emit indirect symbol attribute for: " + Name); 575 576 if (getLexer().isNot(AsmToken::EndOfStatement)) 577 return TokError("unexpected token in '.indirect_symbol' directive"); 578 579 Lex(); 580 581 return false; 582 } 583 584 /// parseDirectiveDumpOrLoad 585 /// ::= ( .dump | .load ) "filename" 586 bool DarwinAsmParser::parseDirectiveDumpOrLoad(StringRef Directive, 587 SMLoc IDLoc) { 588 bool IsDump = Directive == ".dump"; 589 if (getLexer().isNot(AsmToken::String)) 590 return TokError("expected string in '.dump' or '.load' directive"); 591 592 Lex(); 593 594 if (getLexer().isNot(AsmToken::EndOfStatement)) 595 return TokError("unexpected token in '.dump' or '.load' directive"); 596 597 Lex(); 598 599 // FIXME: If/when .dump and .load are implemented they will be done in the 600 // the assembly parser and not have any need for an MCStreamer API. 601 if (IsDump) 602 return Warning(IDLoc, "ignoring directive .dump for now"); 603 else 604 return Warning(IDLoc, "ignoring directive .load for now"); 605 } 606 607 /// ParseDirectiveLinkerOption 608 /// ::= .linker_option "string" ( , "string" )* 609 bool DarwinAsmParser::parseDirectiveLinkerOption(StringRef IDVal, SMLoc) { 610 SmallVector<std::string, 4> Args; 611 while (true) { 612 if (getLexer().isNot(AsmToken::String)) 613 return TokError("expected string in '" + Twine(IDVal) + "' directive"); 614 615 std::string Data; 616 if (getParser().parseEscapedString(Data)) 617 return true; 618 619 Args.push_back(Data); 620 621 if (getLexer().is(AsmToken::EndOfStatement)) 622 break; 623 624 if (getLexer().isNot(AsmToken::Comma)) 625 return TokError("unexpected token in '" + Twine(IDVal) + "' directive"); 626 Lex(); 627 } 628 629 getStreamer().emitLinkerOptions(Args); 630 return false; 631 } 632 633 /// parseDirectiveLsym 634 /// ::= .lsym identifier , expression 635 bool DarwinAsmParser::parseDirectiveLsym(StringRef, SMLoc) { 636 StringRef Name; 637 if (getParser().parseIdentifier(Name)) 638 return TokError("expected identifier in directive"); 639 640 // Handle the identifier as the key symbol. 641 MCSymbol *Sym = getContext().getOrCreateSymbol(Name); 642 643 if (getLexer().isNot(AsmToken::Comma)) 644 return TokError("unexpected token in '.lsym' directive"); 645 Lex(); 646 647 const MCExpr *Value; 648 if (getParser().parseExpression(Value)) 649 return true; 650 651 if (getLexer().isNot(AsmToken::EndOfStatement)) 652 return TokError("unexpected token in '.lsym' directive"); 653 654 Lex(); 655 656 // We don't currently support this directive. 657 // 658 // FIXME: Diagnostic location! 659 (void) Sym; 660 return TokError("directive '.lsym' is unsupported"); 661 } 662 663 /// parseDirectiveSection: 664 /// ::= .section identifier (',' identifier)* 665 bool DarwinAsmParser::parseDirectiveSection(StringRef, SMLoc) { 666 SMLoc Loc = getLexer().getLoc(); 667 668 StringRef SectionName; 669 if (getParser().parseIdentifier(SectionName)) 670 return Error(Loc, "expected identifier after '.section' directive"); 671 672 // Verify there is a following comma. 673 if (!getLexer().is(AsmToken::Comma)) 674 return TokError("unexpected token in '.section' directive"); 675 676 std::string SectionSpec = std::string(SectionName); 677 SectionSpec += ","; 678 679 // Add all the tokens until the end of the line, ParseSectionSpecifier will 680 // handle this. 681 StringRef EOL = getLexer().LexUntilEndOfStatement(); 682 SectionSpec.append(EOL.begin(), EOL.end()); 683 684 Lex(); 685 if (getLexer().isNot(AsmToken::EndOfStatement)) 686 return TokError("unexpected token in '.section' directive"); 687 Lex(); 688 689 StringRef Segment, Section; 690 unsigned StubSize; 691 unsigned TAA; 692 bool TAAParsed; 693 if (class Error E = MCSectionMachO::ParseSectionSpecifier( 694 SectionSpec, Segment, Section, TAA, TAAParsed, StubSize)) 695 return Error(Loc, toString(std::move(E))); 696 697 // Issue a warning if the target is not powerpc and Section is a *coal* section. 698 Triple TT = getParser().getContext().getTargetTriple(); 699 Triple::ArchType ArchTy = TT.getArch(); 700 701 if (ArchTy != Triple::ppc && ArchTy != Triple::ppc64) { 702 StringRef NonCoalSection = StringSwitch<StringRef>(Section) 703 .Case("__textcoal_nt", "__text") 704 .Case("__const_coal", "__const") 705 .Case("__datacoal_nt", "__data") 706 .Default(Section); 707 708 if (!Section.equals(NonCoalSection)) { 709 StringRef SectionVal(Loc.getPointer()); 710 size_t B = SectionVal.find(',') + 1, E = SectionVal.find(',', B); 711 SMLoc BLoc = SMLoc::getFromPointer(SectionVal.data() + B); 712 SMLoc ELoc = SMLoc::getFromPointer(SectionVal.data() + E); 713 getParser().Warning(Loc, "section \"" + Section + "\" is deprecated", 714 SMRange(BLoc, ELoc)); 715 getParser().Note(Loc, "change section name to \"" + NonCoalSection + 716 "\"", SMRange(BLoc, ELoc)); 717 } 718 } 719 720 // FIXME: Arch specific. 721 bool isText = Segment == "__TEXT"; // FIXME: Hack. 722 getStreamer().SwitchSection(getContext().getMachOSection( 723 Segment, Section, TAA, StubSize, 724 isText ? SectionKind::getText() : SectionKind::getData())); 725 return false; 726 } 727 728 /// ParseDirectivePushSection: 729 /// ::= .pushsection identifier (',' identifier)* 730 bool DarwinAsmParser::parseDirectivePushSection(StringRef S, SMLoc Loc) { 731 getStreamer().PushSection(); 732 733 if (parseDirectiveSection(S, Loc)) { 734 getStreamer().PopSection(); 735 return true; 736 } 737 738 return false; 739 } 740 741 /// ParseDirectivePopSection: 742 /// ::= .popsection 743 bool DarwinAsmParser::parseDirectivePopSection(StringRef, SMLoc) { 744 if (!getStreamer().PopSection()) 745 return TokError(".popsection without corresponding .pushsection"); 746 return false; 747 } 748 749 /// ParseDirectivePrevious: 750 /// ::= .previous 751 bool DarwinAsmParser::parseDirectivePrevious(StringRef DirName, SMLoc) { 752 MCSectionSubPair PreviousSection = getStreamer().getPreviousSection(); 753 if (!PreviousSection.first) 754 return TokError(".previous without corresponding .section"); 755 getStreamer().SwitchSection(PreviousSection.first, PreviousSection.second); 756 return false; 757 } 758 759 /// ParseDirectiveSecureLogUnique 760 /// ::= .secure_log_unique ... message ... 761 bool DarwinAsmParser::parseDirectiveSecureLogUnique(StringRef, SMLoc IDLoc) { 762 StringRef LogMessage = getParser().parseStringToEndOfStatement(); 763 if (getLexer().isNot(AsmToken::EndOfStatement)) 764 return TokError("unexpected token in '.secure_log_unique' directive"); 765 766 if (getContext().getSecureLogUsed()) 767 return Error(IDLoc, ".secure_log_unique specified multiple times"); 768 769 // Get the secure log path. 770 const char *SecureLogFile = getContext().getSecureLogFile(); 771 if (!SecureLogFile) 772 return Error(IDLoc, ".secure_log_unique used but AS_SECURE_LOG_FILE " 773 "environment variable unset."); 774 775 // Open the secure log file if we haven't already. 776 raw_fd_ostream *OS = getContext().getSecureLog(); 777 if (!OS) { 778 std::error_code EC; 779 auto NewOS = std::make_unique<raw_fd_ostream>(StringRef(SecureLogFile), EC, 780 sys::fs::OF_Append | 781 sys::fs::OF_TextWithCRLF); 782 if (EC) 783 return Error(IDLoc, Twine("can't open secure log file: ") + 784 SecureLogFile + " (" + EC.message() + ")"); 785 OS = NewOS.get(); 786 getContext().setSecureLog(std::move(NewOS)); 787 } 788 789 // Write the message. 790 unsigned CurBuf = getSourceManager().FindBufferContainingLoc(IDLoc); 791 *OS << getSourceManager().getBufferInfo(CurBuf).Buffer->getBufferIdentifier() 792 << ":" << getSourceManager().FindLineNumber(IDLoc, CurBuf) << ":" 793 << LogMessage + "\n"; 794 795 getContext().setSecureLogUsed(true); 796 797 return false; 798 } 799 800 /// ParseDirectiveSecureLogReset 801 /// ::= .secure_log_reset 802 bool DarwinAsmParser::parseDirectiveSecureLogReset(StringRef, SMLoc IDLoc) { 803 if (getLexer().isNot(AsmToken::EndOfStatement)) 804 return TokError("unexpected token in '.secure_log_reset' directive"); 805 806 Lex(); 807 808 getContext().setSecureLogUsed(false); 809 810 return false; 811 } 812 813 /// parseDirectiveSubsectionsViaSymbols 814 /// ::= .subsections_via_symbols 815 bool DarwinAsmParser::parseDirectiveSubsectionsViaSymbols(StringRef, SMLoc) { 816 if (getLexer().isNot(AsmToken::EndOfStatement)) 817 return TokError("unexpected token in '.subsections_via_symbols' directive"); 818 819 Lex(); 820 821 getStreamer().emitAssemblerFlag(MCAF_SubsectionsViaSymbols); 822 823 return false; 824 } 825 826 /// ParseDirectiveTBSS 827 /// ::= .tbss identifier, size, align 828 bool DarwinAsmParser::parseDirectiveTBSS(StringRef, SMLoc) { 829 SMLoc IDLoc = getLexer().getLoc(); 830 StringRef Name; 831 if (getParser().parseIdentifier(Name)) 832 return TokError("expected identifier in directive"); 833 834 // Handle the identifier as the key symbol. 835 MCSymbol *Sym = getContext().getOrCreateSymbol(Name); 836 837 if (getLexer().isNot(AsmToken::Comma)) 838 return TokError("unexpected token in directive"); 839 Lex(); 840 841 int64_t Size; 842 SMLoc SizeLoc = getLexer().getLoc(); 843 if (getParser().parseAbsoluteExpression(Size)) 844 return true; 845 846 int64_t Pow2Alignment = 0; 847 SMLoc Pow2AlignmentLoc; 848 if (getLexer().is(AsmToken::Comma)) { 849 Lex(); 850 Pow2AlignmentLoc = getLexer().getLoc(); 851 if (getParser().parseAbsoluteExpression(Pow2Alignment)) 852 return true; 853 } 854 855 if (getLexer().isNot(AsmToken::EndOfStatement)) 856 return TokError("unexpected token in '.tbss' directive"); 857 858 Lex(); 859 860 if (Size < 0) 861 return Error(SizeLoc, "invalid '.tbss' directive size, can't be less than" 862 "zero"); 863 864 // FIXME: Diagnose overflow. 865 if (Pow2Alignment < 0) 866 return Error(Pow2AlignmentLoc, "invalid '.tbss' alignment, can't be less" 867 "than zero"); 868 869 if (!Sym->isUndefined()) 870 return Error(IDLoc, "invalid symbol redefinition"); 871 872 getStreamer().emitTBSSSymbol( 873 getContext().getMachOSection("__DATA", "__thread_bss", 874 MachO::S_THREAD_LOCAL_ZEROFILL, 0, 875 SectionKind::getThreadBSS()), 876 Sym, Size, 1 << Pow2Alignment); 877 878 return false; 879 } 880 881 /// ParseDirectiveZerofill 882 /// ::= .zerofill segname , sectname [, identifier , size_expression [ 883 /// , align_expression ]] 884 bool DarwinAsmParser::parseDirectiveZerofill(StringRef, SMLoc) { 885 StringRef Segment; 886 if (getParser().parseIdentifier(Segment)) 887 return TokError("expected segment name after '.zerofill' directive"); 888 889 if (getLexer().isNot(AsmToken::Comma)) 890 return TokError("unexpected token in directive"); 891 Lex(); 892 893 StringRef Section; 894 SMLoc SectionLoc = getLexer().getLoc(); 895 if (getParser().parseIdentifier(Section)) 896 return TokError("expected section name after comma in '.zerofill' " 897 "directive"); 898 899 // If this is the end of the line all that was wanted was to create the 900 // the section but with no symbol. 901 if (getLexer().is(AsmToken::EndOfStatement)) { 902 // Create the zerofill section but no symbol 903 getStreamer().emitZerofill( 904 getContext().getMachOSection(Segment, Section, MachO::S_ZEROFILL, 0, 905 SectionKind::getBSS()), 906 /*Symbol=*/nullptr, /*Size=*/0, /*ByteAlignment=*/0, SectionLoc); 907 return false; 908 } 909 910 if (getLexer().isNot(AsmToken::Comma)) 911 return TokError("unexpected token in directive"); 912 Lex(); 913 914 SMLoc IDLoc = getLexer().getLoc(); 915 StringRef IDStr; 916 if (getParser().parseIdentifier(IDStr)) 917 return TokError("expected identifier in directive"); 918 919 // handle the identifier as the key symbol. 920 MCSymbol *Sym = getContext().getOrCreateSymbol(IDStr); 921 922 if (getLexer().isNot(AsmToken::Comma)) 923 return TokError("unexpected token in directive"); 924 Lex(); 925 926 int64_t Size; 927 SMLoc SizeLoc = getLexer().getLoc(); 928 if (getParser().parseAbsoluteExpression(Size)) 929 return true; 930 931 int64_t Pow2Alignment = 0; 932 SMLoc Pow2AlignmentLoc; 933 if (getLexer().is(AsmToken::Comma)) { 934 Lex(); 935 Pow2AlignmentLoc = getLexer().getLoc(); 936 if (getParser().parseAbsoluteExpression(Pow2Alignment)) 937 return true; 938 } 939 940 if (getLexer().isNot(AsmToken::EndOfStatement)) 941 return TokError("unexpected token in '.zerofill' directive"); 942 943 Lex(); 944 945 if (Size < 0) 946 return Error(SizeLoc, "invalid '.zerofill' directive size, can't be less " 947 "than zero"); 948 949 // NOTE: The alignment in the directive is a power of 2 value, the assembler 950 // may internally end up wanting an alignment in bytes. 951 // FIXME: Diagnose overflow. 952 if (Pow2Alignment < 0) 953 return Error(Pow2AlignmentLoc, "invalid '.zerofill' directive alignment, " 954 "can't be less than zero"); 955 956 if (!Sym->isUndefined()) 957 return Error(IDLoc, "invalid symbol redefinition"); 958 959 // Create the zerofill Symbol with Size and Pow2Alignment 960 // 961 // FIXME: Arch specific. 962 getStreamer().emitZerofill(getContext().getMachOSection( 963 Segment, Section, MachO::S_ZEROFILL, 964 0, SectionKind::getBSS()), 965 Sym, Size, 1 << Pow2Alignment, SectionLoc); 966 967 return false; 968 } 969 970 /// ParseDirectiveDataRegion 971 /// ::= .data_region [ ( jt8 | jt16 | jt32 ) ] 972 bool DarwinAsmParser::parseDirectiveDataRegion(StringRef, SMLoc) { 973 if (getLexer().is(AsmToken::EndOfStatement)) { 974 Lex(); 975 getStreamer().emitDataRegion(MCDR_DataRegion); 976 return false; 977 } 978 StringRef RegionType; 979 SMLoc Loc = getParser().getTok().getLoc(); 980 if (getParser().parseIdentifier(RegionType)) 981 return TokError("expected region type after '.data_region' directive"); 982 int Kind = StringSwitch<int>(RegionType) 983 .Case("jt8", MCDR_DataRegionJT8) 984 .Case("jt16", MCDR_DataRegionJT16) 985 .Case("jt32", MCDR_DataRegionJT32) 986 .Default(-1); 987 if (Kind == -1) 988 return Error(Loc, "unknown region type in '.data_region' directive"); 989 Lex(); 990 991 getStreamer().emitDataRegion((MCDataRegionType)Kind); 992 return false; 993 } 994 995 /// ParseDirectiveDataRegionEnd 996 /// ::= .end_data_region 997 bool DarwinAsmParser::parseDirectiveDataRegionEnd(StringRef, SMLoc) { 998 if (getLexer().isNot(AsmToken::EndOfStatement)) 999 return TokError("unexpected token in '.end_data_region' directive"); 1000 1001 Lex(); 1002 getStreamer().emitDataRegion(MCDR_DataRegionEnd); 1003 return false; 1004 } 1005 1006 static bool isSDKVersionToken(const AsmToken &Tok) { 1007 return Tok.is(AsmToken::Identifier) && Tok.getIdentifier() == "sdk_version"; 1008 } 1009 1010 /// parseMajorMinorVersionComponent ::= major, minor 1011 bool DarwinAsmParser::parseMajorMinorVersionComponent(unsigned *Major, 1012 unsigned *Minor, 1013 const char *VersionName) { 1014 // Get the major version number. 1015 if (getLexer().isNot(AsmToken::Integer)) 1016 return TokError(Twine("invalid ") + VersionName + 1017 " major version number, integer expected"); 1018 int64_t MajorVal = getLexer().getTok().getIntVal(); 1019 if (MajorVal > 65535 || MajorVal <= 0) 1020 return TokError(Twine("invalid ") + VersionName + " major version number"); 1021 *Major = (unsigned)MajorVal; 1022 Lex(); 1023 if (getLexer().isNot(AsmToken::Comma)) 1024 return TokError(Twine(VersionName) + 1025 " minor version number required, comma expected"); 1026 Lex(); 1027 // Get the minor version number. 1028 if (getLexer().isNot(AsmToken::Integer)) 1029 return TokError(Twine("invalid ") + VersionName + 1030 " minor version number, integer expected"); 1031 int64_t MinorVal = getLexer().getTok().getIntVal(); 1032 if (MinorVal > 255 || MinorVal < 0) 1033 return TokError(Twine("invalid ") + VersionName + " minor version number"); 1034 *Minor = MinorVal; 1035 Lex(); 1036 return false; 1037 } 1038 1039 /// parseOptionalTrailingVersionComponent ::= , version_number 1040 bool DarwinAsmParser::parseOptionalTrailingVersionComponent( 1041 unsigned *Component, const char *ComponentName) { 1042 assert(getLexer().is(AsmToken::Comma) && "comma expected"); 1043 Lex(); 1044 if (getLexer().isNot(AsmToken::Integer)) 1045 return TokError(Twine("invalid ") + ComponentName + 1046 " version number, integer expected"); 1047 int64_t Val = getLexer().getTok().getIntVal(); 1048 if (Val > 255 || Val < 0) 1049 return TokError(Twine("invalid ") + ComponentName + " version number"); 1050 *Component = Val; 1051 Lex(); 1052 return false; 1053 } 1054 1055 /// parseVersion ::= parseMajorMinorVersionComponent 1056 /// parseOptionalTrailingVersionComponent 1057 bool DarwinAsmParser::parseVersion(unsigned *Major, unsigned *Minor, 1058 unsigned *Update) { 1059 if (parseMajorMinorVersionComponent(Major, Minor, "OS")) 1060 return true; 1061 1062 // Get the update level, if specified 1063 *Update = 0; 1064 if (getLexer().is(AsmToken::EndOfStatement) || 1065 isSDKVersionToken(getLexer().getTok())) 1066 return false; 1067 if (getLexer().isNot(AsmToken::Comma)) 1068 return TokError("invalid OS update specifier, comma expected"); 1069 if (parseOptionalTrailingVersionComponent(Update, "OS update")) 1070 return true; 1071 return false; 1072 } 1073 1074 bool DarwinAsmParser::parseSDKVersion(VersionTuple &SDKVersion) { 1075 assert(isSDKVersionToken(getLexer().getTok()) && "expected sdk_version"); 1076 Lex(); 1077 unsigned Major, Minor; 1078 if (parseMajorMinorVersionComponent(&Major, &Minor, "SDK")) 1079 return true; 1080 SDKVersion = VersionTuple(Major, Minor); 1081 1082 // Get the subminor version, if specified. 1083 if (getLexer().is(AsmToken::Comma)) { 1084 unsigned Subminor; 1085 if (parseOptionalTrailingVersionComponent(&Subminor, "SDK subminor")) 1086 return true; 1087 SDKVersion = VersionTuple(Major, Minor, Subminor); 1088 } 1089 return false; 1090 } 1091 1092 void DarwinAsmParser::checkVersion(StringRef Directive, StringRef Arg, 1093 SMLoc Loc, Triple::OSType ExpectedOS) { 1094 const Triple &Target = getContext().getTargetTriple(); 1095 if (Target.getOS() != ExpectedOS) 1096 Warning(Loc, Twine(Directive) + 1097 (Arg.empty() ? Twine() : Twine(' ') + Arg) + 1098 " used while targeting " + Target.getOSName()); 1099 1100 if (LastVersionDirective.isValid()) { 1101 Warning(Loc, "overriding previous version directive"); 1102 Note(LastVersionDirective, "previous definition is here"); 1103 } 1104 LastVersionDirective = Loc; 1105 } 1106 1107 static Triple::OSType getOSTypeFromMCVM(MCVersionMinType Type) { 1108 switch (Type) { 1109 case MCVM_WatchOSVersionMin: return Triple::WatchOS; 1110 case MCVM_TvOSVersionMin: return Triple::TvOS; 1111 case MCVM_IOSVersionMin: return Triple::IOS; 1112 case MCVM_OSXVersionMin: return Triple::MacOSX; 1113 } 1114 llvm_unreachable("Invalid mc version min type"); 1115 } 1116 1117 /// parseVersionMin 1118 /// ::= .ios_version_min parseVersion parseSDKVersion 1119 /// | .macosx_version_min parseVersion parseSDKVersion 1120 /// | .tvos_version_min parseVersion parseSDKVersion 1121 /// | .watchos_version_min parseVersion parseSDKVersion 1122 bool DarwinAsmParser::parseVersionMin(StringRef Directive, SMLoc Loc, 1123 MCVersionMinType Type) { 1124 unsigned Major; 1125 unsigned Minor; 1126 unsigned Update; 1127 if (parseVersion(&Major, &Minor, &Update)) 1128 return true; 1129 1130 VersionTuple SDKVersion; 1131 if (isSDKVersionToken(getLexer().getTok()) && parseSDKVersion(SDKVersion)) 1132 return true; 1133 1134 if (parseToken(AsmToken::EndOfStatement)) 1135 return addErrorSuffix(Twine(" in '") + Directive + "' directive"); 1136 1137 Triple::OSType ExpectedOS = getOSTypeFromMCVM(Type); 1138 checkVersion(Directive, StringRef(), Loc, ExpectedOS); 1139 getStreamer().emitVersionMin(Type, Major, Minor, Update, SDKVersion); 1140 return false; 1141 } 1142 1143 static Triple::OSType getOSTypeFromPlatform(MachO::PlatformType Type) { 1144 switch (Type) { 1145 case MachO::PLATFORM_MACOS: return Triple::MacOSX; 1146 case MachO::PLATFORM_IOS: return Triple::IOS; 1147 case MachO::PLATFORM_TVOS: return Triple::TvOS; 1148 case MachO::PLATFORM_WATCHOS: return Triple::WatchOS; 1149 case MachO::PLATFORM_BRIDGEOS: /* silence warning */ break; 1150 case MachO::PLATFORM_MACCATALYST: return Triple::IOS; 1151 case MachO::PLATFORM_IOSSIMULATOR: /* silence warning */ break; 1152 case MachO::PLATFORM_TVOSSIMULATOR: /* silence warning */ break; 1153 case MachO::PLATFORM_WATCHOSSIMULATOR: /* silence warning */ break; 1154 case MachO::PLATFORM_DRIVERKIT: /* silence warning */ break; 1155 } 1156 llvm_unreachable("Invalid mach-o platform type"); 1157 } 1158 1159 /// parseBuildVersion 1160 /// ::= .build_version (macos|ios|tvos|watchos), parseVersion parseSDKVersion 1161 bool DarwinAsmParser::parseBuildVersion(StringRef Directive, SMLoc Loc) { 1162 StringRef PlatformName; 1163 SMLoc PlatformLoc = getTok().getLoc(); 1164 if (getParser().parseIdentifier(PlatformName)) 1165 return TokError("platform name expected"); 1166 1167 unsigned Platform = StringSwitch<unsigned>(PlatformName) 1168 .Case("macos", MachO::PLATFORM_MACOS) 1169 .Case("ios", MachO::PLATFORM_IOS) 1170 .Case("tvos", MachO::PLATFORM_TVOS) 1171 .Case("watchos", MachO::PLATFORM_WATCHOS) 1172 .Case("macCatalyst", MachO::PLATFORM_MACCATALYST) 1173 .Default(0); 1174 if (Platform == 0) 1175 return Error(PlatformLoc, "unknown platform name"); 1176 1177 if (getLexer().isNot(AsmToken::Comma)) 1178 return TokError("version number required, comma expected"); 1179 Lex(); 1180 1181 unsigned Major; 1182 unsigned Minor; 1183 unsigned Update; 1184 if (parseVersion(&Major, &Minor, &Update)) 1185 return true; 1186 1187 VersionTuple SDKVersion; 1188 if (isSDKVersionToken(getLexer().getTok()) && parseSDKVersion(SDKVersion)) 1189 return true; 1190 1191 if (parseToken(AsmToken::EndOfStatement)) 1192 return addErrorSuffix(" in '.build_version' directive"); 1193 1194 Triple::OSType ExpectedOS 1195 = getOSTypeFromPlatform((MachO::PlatformType)Platform); 1196 checkVersion(Directive, PlatformName, Loc, ExpectedOS); 1197 getStreamer().emitBuildVersion(Platform, Major, Minor, Update, SDKVersion); 1198 return false; 1199 } 1200 1201 1202 namespace llvm { 1203 1204 MCAsmParserExtension *createDarwinAsmParser() { 1205 return new DarwinAsmParser; 1206 } 1207 1208 } // end llvm namespace 1209