lib/MC/MCParser/DarwinAsmParser.cpp

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