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/SmallVector.h" 10 #include "llvm/ADT/StringRef.h" 11 #include "llvm/ADT/StringSwitch.h" 12 #include "llvm/ADT/Triple.h" 13 #include "llvm/ADT/Twine.h" 14 #include "llvm/BinaryFormat/MachO.h" 15 #include "llvm/MC/MCContext.h" 16 #include "llvm/MC/MCDirectives.h" 17 #include "llvm/MC/MCParser/MCAsmLexer.h" 18 #include "llvm/MC/MCParser/MCAsmParser.h" 19 #include "llvm/MC/MCParser/MCAsmParserExtension.h" 20 #include "llvm/MC/MCSectionMachO.h" 21 #include "llvm/MC/MCStreamer.h" 22 #include "llvm/MC/MCSymbol.h" 23 #include "llvm/MC/SectionKind.h" 24 #include "llvm/Support/Error.h" 25 #include "llvm/Support/FileSystem.h" 26 #include "llvm/Support/MemoryBuffer.h" 27 #include "llvm/Support/SMLoc.h" 28 #include "llvm/Support/SourceMgr.h" 29 #include "llvm/Support/raw_ostream.h" 30 #include <cstddef> 31 #include <cstdint> 32 #include <string> 33 #include <system_error> 34 #include <utility> 35 36 using namespace llvm; 37 38 namespace { 39 40 /// Implementation of directive handling which is shared across all 41 /// Darwin targets. 42 class DarwinAsmParser : public MCAsmParserExtension { 43 template<bool (DarwinAsmParser::*HandlerMethod)(StringRef, SMLoc)> 44 void addDirectiveHandler(StringRef Directive) { 45 MCAsmParser::ExtensionDirectiveHandler Handler = std::make_pair( 46 this, HandleDirective<DarwinAsmParser, HandlerMethod>); 47 getParser().addDirectiveHandler(Directive, Handler); 48 } 49 50 bool parseSectionSwitch(StringRef Segment, StringRef Section, 51 unsigned TAA = 0, unsigned ImplicitAlign = 0, 52 unsigned StubSize = 0); 53 54 SMLoc LastVersionDirective; 55 56 public: 57 DarwinAsmParser() = default; 58 59 void Initialize(MCAsmParser &Parser) override { 60 // Call the base implementation. 61 this->MCAsmParserExtension::Initialize(Parser); 62 63 addDirectiveHandler<&DarwinAsmParser::parseDirectiveAltEntry>(".alt_entry"); 64 addDirectiveHandler<&DarwinAsmParser::parseDirectiveDesc>(".desc"); 65 addDirectiveHandler<&DarwinAsmParser::parseDirectiveIndirectSymbol>( 66 ".indirect_symbol"); 67 addDirectiveHandler<&DarwinAsmParser::parseDirectiveLsym>(".lsym"); 68 addDirectiveHandler<&DarwinAsmParser::parseDirectiveSubsectionsViaSymbols>( 69 ".subsections_via_symbols"); 70 addDirectiveHandler<&DarwinAsmParser::parseDirectiveDumpOrLoad>(".dump"); 71 addDirectiveHandler<&DarwinAsmParser::parseDirectiveDumpOrLoad>(".load"); 72 addDirectiveHandler<&DarwinAsmParser::parseDirectiveSection>(".section"); 73 addDirectiveHandler<&DarwinAsmParser::parseDirectivePushSection>( 74 ".pushsection"); 75 addDirectiveHandler<&DarwinAsmParser::parseDirectivePopSection>( 76 ".popsection"); 77 addDirectiveHandler<&DarwinAsmParser::parseDirectivePrevious>(".previous"); 78 addDirectiveHandler<&DarwinAsmParser::parseDirectiveSecureLogUnique>( 79 ".secure_log_unique"); 80 addDirectiveHandler<&DarwinAsmParser::parseDirectiveSecureLogReset>( 81 ".secure_log_reset"); 82 addDirectiveHandler<&DarwinAsmParser::parseDirectiveTBSS>(".tbss"); 83 addDirectiveHandler<&DarwinAsmParser::parseDirectiveZerofill>(".zerofill"); 84 85 addDirectiveHandler<&DarwinAsmParser::parseDirectiveDataRegion>( 86 ".data_region"); 87 addDirectiveHandler<&DarwinAsmParser::parseDirectiveDataRegionEnd>( 88 ".end_data_region"); 89 90 // Special section directives. 91 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveBss>(".bss"); 92 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveConst>(".const"); 93 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveConstData>( 94 ".const_data"); 95 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveConstructor>( 96 ".constructor"); 97 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveCString>( 98 ".cstring"); 99 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveData>(".data"); 100 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveDestructor>( 101 ".destructor"); 102 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveDyld>(".dyld"); 103 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveFVMLibInit0>( 104 ".fvmlib_init0"); 105 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveFVMLibInit1>( 106 ".fvmlib_init1"); 107 addDirectiveHandler< 108 &DarwinAsmParser::parseSectionDirectiveLazySymbolPointers>( 109 ".lazy_symbol_pointer"); 110 addDirectiveHandler<&DarwinAsmParser::parseDirectiveLinkerOption>( 111 ".linker_option"); 112 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveLiteral16>( 113 ".literal16"); 114 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveLiteral4>( 115 ".literal4"); 116 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveLiteral8>( 117 ".literal8"); 118 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveModInitFunc>( 119 ".mod_init_func"); 120 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveModTermFunc>( 121 ".mod_term_func"); 122 addDirectiveHandler< 123 &DarwinAsmParser::parseSectionDirectiveNonLazySymbolPointers>( 124 ".non_lazy_symbol_pointer"); 125 addDirectiveHandler< 126 &DarwinAsmParser::parseSectionDirectiveThreadLocalVariablePointers>( 127 ".thread_local_variable_pointer"); 128 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCCatClsMeth>( 129 ".objc_cat_cls_meth"); 130 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCCatInstMeth>( 131 ".objc_cat_inst_meth"); 132 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCCategory>( 133 ".objc_category"); 134 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClass>( 135 ".objc_class"); 136 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClassNames>( 137 ".objc_class_names"); 138 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClassVars>( 139 ".objc_class_vars"); 140 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClsMeth>( 141 ".objc_cls_meth"); 142 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCClsRefs>( 143 ".objc_cls_refs"); 144 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCInstMeth>( 145 ".objc_inst_meth"); 146 addDirectiveHandler< 147 &DarwinAsmParser::parseSectionDirectiveObjCInstanceVars>( 148 ".objc_instance_vars"); 149 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCMessageRefs>( 150 ".objc_message_refs"); 151 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCMetaClass>( 152 ".objc_meta_class"); 153 addDirectiveHandler< 154 &DarwinAsmParser::parseSectionDirectiveObjCMethVarNames>( 155 ".objc_meth_var_names"); 156 addDirectiveHandler< 157 &DarwinAsmParser::parseSectionDirectiveObjCMethVarTypes>( 158 ".objc_meth_var_types"); 159 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCModuleInfo>( 160 ".objc_module_info"); 161 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCProtocol>( 162 ".objc_protocol"); 163 addDirectiveHandler< 164 &DarwinAsmParser::parseSectionDirectiveObjCSelectorStrs>( 165 ".objc_selector_strs"); 166 addDirectiveHandler< 167 &DarwinAsmParser::parseSectionDirectiveObjCStringObject>( 168 ".objc_string_object"); 169 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveObjCSymbols>( 170 ".objc_symbols"); 171 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectivePICSymbolStub>( 172 ".picsymbol_stub"); 173 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveStaticConst>( 174 ".static_const"); 175 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveStaticData>( 176 ".static_data"); 177 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveSymbolStub>( 178 ".symbol_stub"); 179 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveTData>(".tdata"); 180 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveText>(".text"); 181 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveThreadInitFunc>( 182 ".thread_init_func"); 183 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveTLV>(".tlv"); 184 185 addDirectiveHandler<&DarwinAsmParser::parseSectionDirectiveIdent>(".ident"); 186 addDirectiveHandler<&DarwinAsmParser::parseWatchOSVersionMin>( 187 ".watchos_version_min"); 188 addDirectiveHandler<&DarwinAsmParser::parseTvOSVersionMin>( 189 ".tvos_version_min"); 190 addDirectiveHandler<&DarwinAsmParser::parseIOSVersionMin>( 191 ".ios_version_min"); 192 addDirectiveHandler<&DarwinAsmParser::parseMacOSXVersionMin>( 193 ".macosx_version_min"); 194 addDirectiveHandler<&DarwinAsmParser::parseBuildVersion>(".build_version"); 195 addDirectiveHandler<&DarwinAsmParser::parseDirectiveCGProfile>( 196 ".cg_profile"); 197 198 LastVersionDirective = SMLoc(); 199 } 200 201 bool parseDirectiveAltEntry(StringRef, SMLoc); 202 bool parseDirectiveDesc(StringRef, SMLoc); 203 bool parseDirectiveIndirectSymbol(StringRef, SMLoc); 204 bool parseDirectiveDumpOrLoad(StringRef, SMLoc); 205 bool parseDirectiveLsym(StringRef, SMLoc); 206 bool parseDirectiveLinkerOption(StringRef, SMLoc); 207 bool parseDirectiveSection(StringRef, SMLoc); 208 bool parseDirectivePushSection(StringRef, SMLoc); 209 bool parseDirectivePopSection(StringRef, SMLoc); 210 bool parseDirectivePrevious(StringRef, SMLoc); 211 bool parseDirectiveSecureLogReset(StringRef, SMLoc); 212 bool parseDirectiveSecureLogUnique(StringRef, SMLoc); 213 bool parseDirectiveSubsectionsViaSymbols(StringRef, SMLoc); 214 bool parseDirectiveTBSS(StringRef, SMLoc); 215 bool parseDirectiveZerofill(StringRef, SMLoc); 216 bool parseDirectiveDataRegion(StringRef, SMLoc); 217 bool parseDirectiveDataRegionEnd(StringRef, SMLoc); 218 219 // Named Section Directive 220 bool parseSectionDirectiveBss(StringRef, SMLoc) { 221 return parseSectionSwitch("__DATA", "__bss"); 222 } 223 224 bool parseSectionDirectiveConst(StringRef, SMLoc) { 225 return parseSectionSwitch("__TEXT", "__const"); 226 } 227 228 bool parseSectionDirectiveStaticConst(StringRef, SMLoc) { 229 return parseSectionSwitch("__TEXT", "__static_const"); 230 } 231 232 bool parseSectionDirectiveCString(StringRef, SMLoc) { 233 return parseSectionSwitch("__TEXT","__cstring", 234 MachO::S_CSTRING_LITERALS); 235 } 236 237 bool parseSectionDirectiveLiteral4(StringRef, SMLoc) { 238 return parseSectionSwitch("__TEXT", "__literal4", 239 MachO::S_4BYTE_LITERALS, 4); 240 } 241 242 bool parseSectionDirectiveLiteral8(StringRef, SMLoc) { 243 return parseSectionSwitch("__TEXT", "__literal8", 244 MachO::S_8BYTE_LITERALS, 8); 245 } 246 247 bool parseSectionDirectiveLiteral16(StringRef, SMLoc) { 248 return parseSectionSwitch("__TEXT","__literal16", 249 MachO::S_16BYTE_LITERALS, 16); 250 } 251 252 bool parseSectionDirectiveConstructor(StringRef, SMLoc) { 253 return parseSectionSwitch("__TEXT","__constructor"); 254 } 255 256 bool parseSectionDirectiveDestructor(StringRef, SMLoc) { 257 return parseSectionSwitch("__TEXT","__destructor"); 258 } 259 260 bool parseSectionDirectiveFVMLibInit0(StringRef, SMLoc) { 261 return parseSectionSwitch("__TEXT","__fvmlib_init0"); 262 } 263 264 bool parseSectionDirectiveFVMLibInit1(StringRef, SMLoc) { 265 return parseSectionSwitch("__TEXT","__fvmlib_init1"); 266 } 267 268 bool parseSectionDirectiveSymbolStub(StringRef, SMLoc) { 269 return parseSectionSwitch("__TEXT","__symbol_stub", 270 MachO::S_SYMBOL_STUBS | 271 MachO::S_ATTR_PURE_INSTRUCTIONS, 272 // FIXME: Different on PPC and ARM. 273 0, 16); 274 } 275 276 bool parseSectionDirectivePICSymbolStub(StringRef, SMLoc) { 277 return parseSectionSwitch("__TEXT","__picsymbol_stub", 278 MachO::S_SYMBOL_STUBS | 279 MachO::S_ATTR_PURE_INSTRUCTIONS, 0, 26); 280 } 281 282 bool parseSectionDirectiveData(StringRef, SMLoc) { 283 return parseSectionSwitch("__DATA", "__data"); 284 } 285 286 bool parseSectionDirectiveStaticData(StringRef, SMLoc) { 287 return parseSectionSwitch("__DATA", "__static_data"); 288 } 289 290 bool parseSectionDirectiveNonLazySymbolPointers(StringRef, SMLoc) { 291 return parseSectionSwitch("__DATA", "__nl_symbol_ptr", 292 MachO::S_NON_LAZY_SYMBOL_POINTERS, 4); 293 } 294 295 bool parseSectionDirectiveLazySymbolPointers(StringRef, SMLoc) { 296 return parseSectionSwitch("__DATA", "__la_symbol_ptr", 297 MachO::S_LAZY_SYMBOL_POINTERS, 4); 298 } 299 300 bool parseSectionDirectiveThreadLocalVariablePointers(StringRef, SMLoc) { 301 return parseSectionSwitch("__DATA", "__thread_ptr", 302 MachO::S_THREAD_LOCAL_VARIABLE_POINTERS, 4); 303 } 304 305 bool parseSectionDirectiveDyld(StringRef, SMLoc) { 306 return parseSectionSwitch("__DATA", "__dyld"); 307 } 308 309 bool parseSectionDirectiveModInitFunc(StringRef, SMLoc) { 310 return parseSectionSwitch("__DATA", "__mod_init_func", 311 MachO::S_MOD_INIT_FUNC_POINTERS, 4); 312 } 313 314 bool parseSectionDirectiveModTermFunc(StringRef, SMLoc) { 315 return parseSectionSwitch("__DATA", "__mod_term_func", 316 MachO::S_MOD_TERM_FUNC_POINTERS, 4); 317 } 318 319 bool parseSectionDirectiveConstData(StringRef, SMLoc) { 320 return parseSectionSwitch("__DATA", "__const"); 321 } 322 323 bool parseSectionDirectiveObjCClass(StringRef, SMLoc) { 324 return parseSectionSwitch("__OBJC", "__class", 325 MachO::S_ATTR_NO_DEAD_STRIP); 326 } 327 328 bool parseSectionDirectiveObjCMetaClass(StringRef, SMLoc) { 329 return parseSectionSwitch("__OBJC", "__meta_class", 330 MachO::S_ATTR_NO_DEAD_STRIP); 331 } 332 333 bool parseSectionDirectiveObjCCatClsMeth(StringRef, SMLoc) { 334 return parseSectionSwitch("__OBJC", "__cat_cls_meth", 335 MachO::S_ATTR_NO_DEAD_STRIP); 336 } 337 338 bool parseSectionDirectiveObjCCatInstMeth(StringRef, SMLoc) { 339 return parseSectionSwitch("__OBJC", "__cat_inst_meth", 340 MachO::S_ATTR_NO_DEAD_STRIP); 341 } 342 343 bool parseSectionDirectiveObjCProtocol(StringRef, SMLoc) { 344 return parseSectionSwitch("__OBJC", "__protocol", 345 MachO::S_ATTR_NO_DEAD_STRIP); 346 } 347 348 bool parseSectionDirectiveObjCStringObject(StringRef, SMLoc) { 349 return parseSectionSwitch("__OBJC", "__string_object", 350 MachO::S_ATTR_NO_DEAD_STRIP); 351 } 352 353 bool parseSectionDirectiveObjCClsMeth(StringRef, SMLoc) { 354 return parseSectionSwitch("__OBJC", "__cls_meth", 355 MachO::S_ATTR_NO_DEAD_STRIP); 356 } 357 358 bool parseSectionDirectiveObjCInstMeth(StringRef, SMLoc) { 359 return parseSectionSwitch("__OBJC", "__inst_meth", 360 MachO::S_ATTR_NO_DEAD_STRIP); 361 } 362 363 bool parseSectionDirectiveObjCClsRefs(StringRef, SMLoc) { 364 return parseSectionSwitch("__OBJC", "__cls_refs", 365 MachO::S_ATTR_NO_DEAD_STRIP | 366 MachO::S_LITERAL_POINTERS, 4); 367 } 368 369 bool parseSectionDirectiveObjCMessageRefs(StringRef, SMLoc) { 370 return parseSectionSwitch("__OBJC", "__message_refs", 371 MachO::S_ATTR_NO_DEAD_STRIP | 372 MachO::S_LITERAL_POINTERS, 4); 373 } 374 375 bool parseSectionDirectiveObjCSymbols(StringRef, SMLoc) { 376 return parseSectionSwitch("__OBJC", "__symbols", 377 MachO::S_ATTR_NO_DEAD_STRIP); 378 } 379 380 bool parseSectionDirectiveObjCCategory(StringRef, SMLoc) { 381 return parseSectionSwitch("__OBJC", "__category", 382 MachO::S_ATTR_NO_DEAD_STRIP); 383 } 384 385 bool parseSectionDirectiveObjCClassVars(StringRef, SMLoc) { 386 return parseSectionSwitch("__OBJC", "__class_vars", 387 MachO::S_ATTR_NO_DEAD_STRIP); 388 } 389 390 bool parseSectionDirectiveObjCInstanceVars(StringRef, SMLoc) { 391 return parseSectionSwitch("__OBJC", "__instance_vars", 392 MachO::S_ATTR_NO_DEAD_STRIP); 393 } 394 395 bool parseSectionDirectiveObjCModuleInfo(StringRef, SMLoc) { 396 return parseSectionSwitch("__OBJC", "__module_info", 397 MachO::S_ATTR_NO_DEAD_STRIP); 398 } 399 400 bool parseSectionDirectiveObjCClassNames(StringRef, SMLoc) { 401 return parseSectionSwitch("__TEXT", "__cstring", 402 MachO::S_CSTRING_LITERALS); 403 } 404 405 bool parseSectionDirectiveObjCMethVarTypes(StringRef, SMLoc) { 406 return parseSectionSwitch("__TEXT", "__cstring", 407 MachO::S_CSTRING_LITERALS); 408 } 409 410 bool parseSectionDirectiveObjCMethVarNames(StringRef, SMLoc) { 411 return parseSectionSwitch("__TEXT", "__cstring", 412 MachO::S_CSTRING_LITERALS); 413 } 414 415 bool parseSectionDirectiveObjCSelectorStrs(StringRef, SMLoc) { 416 return parseSectionSwitch("__OBJC", "__selector_strs", 417 MachO::S_CSTRING_LITERALS); 418 } 419 420 bool parseSectionDirectiveTData(StringRef, SMLoc) { 421 return parseSectionSwitch("__DATA", "__thread_data", 422 MachO::S_THREAD_LOCAL_REGULAR); 423 } 424 425 bool parseSectionDirectiveText(StringRef, SMLoc) { 426 return parseSectionSwitch("__TEXT", "__text", 427 MachO::S_ATTR_PURE_INSTRUCTIONS); 428 } 429 430 bool parseSectionDirectiveTLV(StringRef, SMLoc) { 431 return parseSectionSwitch("__DATA", "__thread_vars", 432 MachO::S_THREAD_LOCAL_VARIABLES); 433 } 434 435 bool parseSectionDirectiveIdent(StringRef, SMLoc) { 436 // Darwin silently ignores the .ident directive. 437 getParser().eatToEndOfStatement(); 438 return false; 439 } 440 441 bool parseSectionDirectiveThreadInitFunc(StringRef, SMLoc) { 442 return parseSectionSwitch("__DATA", "__thread_init", 443 MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS); 444 } 445 446 bool parseWatchOSVersionMin(StringRef Directive, SMLoc Loc) { 447 return parseVersionMin(Directive, Loc, MCVM_WatchOSVersionMin); 448 } 449 bool parseTvOSVersionMin(StringRef Directive, SMLoc Loc) { 450 return parseVersionMin(Directive, Loc, MCVM_TvOSVersionMin); 451 } 452 bool parseIOSVersionMin(StringRef Directive, SMLoc Loc) { 453 return parseVersionMin(Directive, Loc, MCVM_IOSVersionMin); 454 } 455 bool parseMacOSXVersionMin(StringRef Directive, SMLoc Loc) { 456 return parseVersionMin(Directive, Loc, MCVM_OSXVersionMin); 457 } 458 459 bool parseBuildVersion(StringRef Directive, SMLoc Loc); 460 bool parseVersionMin(StringRef Directive, SMLoc Loc, MCVersionMinType Type); 461 bool parseMajorMinorVersionComponent(unsigned *Major, unsigned *Minor, 462 const char *VersionName); 463 bool parseOptionalTrailingVersionComponent(unsigned *Component, 464 const char *ComponentName); 465 bool parseVersion(unsigned *Major, unsigned *Minor, unsigned *Update); 466 bool parseSDKVersion(VersionTuple &SDKVersion); 467 void checkVersion(StringRef Directive, StringRef Arg, SMLoc Loc, 468 Triple::OSType ExpectedOS); 469 bool parseDirectiveCGProfile(StringRef Directive, SMLoc Loc); 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_UNKNOWN: /* silence warning */ 1146 break; 1147 case MachO::PLATFORM_MACOS: return Triple::MacOSX; 1148 case MachO::PLATFORM_IOS: return Triple::IOS; 1149 case MachO::PLATFORM_TVOS: return Triple::TvOS; 1150 case MachO::PLATFORM_WATCHOS: return Triple::WatchOS; 1151 case MachO::PLATFORM_BRIDGEOS: /* silence warning */ break; 1152 case MachO::PLATFORM_DRIVERKIT: 1153 return Triple::DriverKit; 1154 case MachO::PLATFORM_MACCATALYST: return Triple::IOS; 1155 case MachO::PLATFORM_IOSSIMULATOR: /* silence warning */ break; 1156 case MachO::PLATFORM_TVOSSIMULATOR: /* silence warning */ break; 1157 case MachO::PLATFORM_WATCHOSSIMULATOR: /* silence warning */ break; 1158 } 1159 llvm_unreachable("Invalid mach-o platform type"); 1160 } 1161 1162 /// parseBuildVersion 1163 /// ::= .build_version (macos|ios|tvos|watchos), parseVersion parseSDKVersion 1164 bool DarwinAsmParser::parseBuildVersion(StringRef Directive, SMLoc Loc) { 1165 StringRef PlatformName; 1166 SMLoc PlatformLoc = getTok().getLoc(); 1167 if (getParser().parseIdentifier(PlatformName)) 1168 return TokError("platform name expected"); 1169 1170 unsigned Platform = StringSwitch<unsigned>(PlatformName) 1171 .Case("macos", MachO::PLATFORM_MACOS) 1172 .Case("ios", MachO::PLATFORM_IOS) 1173 .Case("tvos", MachO::PLATFORM_TVOS) 1174 .Case("watchos", MachO::PLATFORM_WATCHOS) 1175 .Case("macCatalyst", MachO::PLATFORM_MACCATALYST) 1176 .Case("driverkit", MachO::PLATFORM_DRIVERKIT) 1177 .Default(0); 1178 if (Platform == 0) 1179 return Error(PlatformLoc, "unknown platform name"); 1180 1181 if (getLexer().isNot(AsmToken::Comma)) 1182 return TokError("version number required, comma expected"); 1183 Lex(); 1184 1185 unsigned Major; 1186 unsigned Minor; 1187 unsigned Update; 1188 if (parseVersion(&Major, &Minor, &Update)) 1189 return true; 1190 1191 VersionTuple SDKVersion; 1192 if (isSDKVersionToken(getLexer().getTok()) && parseSDKVersion(SDKVersion)) 1193 return true; 1194 1195 if (parseToken(AsmToken::EndOfStatement)) 1196 return addErrorSuffix(" in '.build_version' directive"); 1197 1198 Triple::OSType ExpectedOS 1199 = getOSTypeFromPlatform((MachO::PlatformType)Platform); 1200 checkVersion(Directive, PlatformName, Loc, ExpectedOS); 1201 getStreamer().emitBuildVersion(Platform, Major, Minor, Update, SDKVersion); 1202 return false; 1203 } 1204 1205 /// parseDirectiveCGProfile 1206 /// ::= .cg_profile from, to, count 1207 bool DarwinAsmParser::parseDirectiveCGProfile(StringRef S, SMLoc Loc) { 1208 return MCAsmParserExtension::ParseDirectiveCGProfile(S, Loc); 1209 } 1210 1211 namespace llvm { 1212 1213 MCAsmParserExtension *createDarwinAsmParser() { 1214 return new DarwinAsmParser; 1215 } 1216 1217 } // end llvm namespace 1218