DarwinAsmParser.cpp Source File (original) (raw)

30#include

31#include

32#include

33#include <system_error>

34#include

36using namespace llvm;

38namespace {

43 template<bool (DarwinAsmParser::*HandlerMethod)(StringRef, SMLoc)>

44 void addDirectiveHandler(StringRef Directive) {

46 this, HandleDirective<DarwinAsmParser, HandlerMethod>);

47 getParser().addDirectiveHandler(Directive, Handler);

48 }

50 bool parseSectionSwitch(StringRef Segment, StringRef Section,

51 unsigned TAA = 0, unsigned ImplicitAlign = 0,

52 unsigned StubSize = 0);

54 SMLoc LastVersionDirective;

56public:

57 DarwinAsmParser() = default;

59 void Initialize(MCAsmParser &Parser) override {

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");

85 addDirectiveHandler<&DarwinAsmParser::parseDirectiveDataRegion>(

86 ".data_region");

87 addDirectiveHandler<&DarwinAsmParser::parseDirectiveDataRegionEnd>(

88 ".end_data_region");

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

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",

235 }

236

237 bool parseSectionDirectiveLiteral4(StringRef, SMLoc) {

238 return parseSectionSwitch("__TEXT", "__literal4",

240 }

241

242 bool parseSectionDirectiveLiteral8(StringRef, SMLoc) {

243 return parseSectionSwitch("__TEXT", "__literal8",

245 }

246

247 bool parseSectionDirectiveLiteral16(StringRef, SMLoc) {

248 return parseSectionSwitch("__TEXT","__literal16",

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",

272

273 0, 16);

274 }

275

276 bool parseSectionDirectivePICSymbolStub(StringRef, SMLoc) {

277 return parseSectionSwitch("__TEXT","__picsymbol_stub",

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",

293 }

294

295 bool parseSectionDirectiveLazySymbolPointers(StringRef, SMLoc) {

296 return parseSectionSwitch("__DATA", "__la_symbol_ptr",

298 }

299

300 bool parseSectionDirectiveThreadLocalVariablePointers(StringRef, SMLoc) {

301 return parseSectionSwitch("__DATA", "__thread_ptr",

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",

312 }

313

314 bool parseSectionDirectiveModTermFunc(StringRef, SMLoc) {

315 return parseSectionSwitch("__DATA", "__mod_term_func",

317 }

318

319 bool parseSectionDirectiveConstData(StringRef, SMLoc) {

320 return parseSectionSwitch("__DATA", "__const");

321 }

322

323 bool parseSectionDirectiveObjCClass(StringRef, SMLoc) {

324 return parseSectionSwitch("__OBJC", "__class",

326 }

327

328 bool parseSectionDirectiveObjCMetaClass(StringRef, SMLoc) {

329 return parseSectionSwitch("__OBJC", "__meta_class",

331 }

332

333 bool parseSectionDirectiveObjCCatClsMeth(StringRef, SMLoc) {

334 return parseSectionSwitch("__OBJC", "__cat_cls_meth",

336 }

337

338 bool parseSectionDirectiveObjCCatInstMeth(StringRef, SMLoc) {

339 return parseSectionSwitch("__OBJC", "__cat_inst_meth",

341 }

342

343 bool parseSectionDirectiveObjCProtocol(StringRef, SMLoc) {

344 return parseSectionSwitch("__OBJC", "__protocol",

346 }

347

348 bool parseSectionDirectiveObjCStringObject(StringRef, SMLoc) {

349 return parseSectionSwitch("__OBJC", "__string_object",

351 }

352

353 bool parseSectionDirectiveObjCClsMeth(StringRef, SMLoc) {

354 return parseSectionSwitch("__OBJC", "__cls_meth",

356 }

357

358 bool parseSectionDirectiveObjCInstMeth(StringRef, SMLoc) {

359 return parseSectionSwitch("__OBJC", "__inst_meth",

361 }

362

363 bool parseSectionDirectiveObjCClsRefs(StringRef, SMLoc) {

364 return parseSectionSwitch("__OBJC", "__cls_refs",

367 }

368

369 bool parseSectionDirectiveObjCMessageRefs(StringRef, SMLoc) {

370 return parseSectionSwitch("__OBJC", "__message_refs",

373 }

374

375 bool parseSectionDirectiveObjCSymbols(StringRef, SMLoc) {

376 return parseSectionSwitch("__OBJC", "__symbols",

378 }

379

380 bool parseSectionDirectiveObjCCategory(StringRef, SMLoc) {

381 return parseSectionSwitch("__OBJC", "__category",

383 }

384

385 bool parseSectionDirectiveObjCClassVars(StringRef, SMLoc) {

386 return parseSectionSwitch("__OBJC", "__class_vars",

388 }

389

390 bool parseSectionDirectiveObjCInstanceVars(StringRef, SMLoc) {

391 return parseSectionSwitch("__OBJC", "__instance_vars",

393 }

394

395 bool parseSectionDirectiveObjCModuleInfo(StringRef, SMLoc) {

396 return parseSectionSwitch("__OBJC", "__module_info",

398 }

399

400 bool parseSectionDirectiveObjCClassNames(StringRef, SMLoc) {

401 return parseSectionSwitch("__TEXT", "__cstring",

403 }

404

405 bool parseSectionDirectiveObjCMethVarTypes(StringRef, SMLoc) {

406 return parseSectionSwitch("__TEXT", "__cstring",

408 }

409

410 bool parseSectionDirectiveObjCMethVarNames(StringRef, SMLoc) {

411 return parseSectionSwitch("__TEXT", "__cstring",

413 }

414

415 bool parseSectionDirectiveObjCSelectorStrs(StringRef, SMLoc) {

416 return parseSectionSwitch("__OBJC", "__selector_strs",

418 }

419

420 bool parseSectionDirectiveTData(StringRef, SMLoc) {

421 return parseSectionSwitch("__DATA", "__thread_data",

423 }

424

425 bool parseSectionDirectiveText(StringRef, SMLoc) {

426 return parseSectionSwitch("__TEXT", "__text",

428 }

429

430 bool parseSectionDirectiveTLV(StringRef, SMLoc) {

431 return parseSectionSwitch("__DATA", "__thread_vars",

433 }

434

435 bool parseSectionDirectiveIdent(StringRef, SMLoc) {

436

437 getParser().eatToEndOfStatement();

438 return false;

439 }

440

441 bool parseSectionDirectiveThreadInitFunc(StringRef, SMLoc) {

442 return parseSectionSwitch("__DATA", "__thread_init",

444 }

445

446 bool parseWatchOSVersionMin(StringRef Directive, SMLoc Loc) {

448 }

449 bool parseTvOSVersionMin(StringRef Directive, SMLoc Loc) {

451 }

452 bool parseIOSVersionMin(StringRef Directive, SMLoc Loc) {

454 }

455 bool parseMacOSXVersionMin(StringRef Directive, SMLoc Loc) {

457 }

458

459 bool parseBuildVersion(StringRef Directive, SMLoc Loc);

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,

469 bool parseDirectiveCGProfile(StringRef Directive, SMLoc Loc);

470};

471

472}

473

474bool DarwinAsmParser::parseSectionSwitch(StringRef Segment, StringRef Section,

475 unsigned TAA, unsigned Alignment,

476 unsigned StubSize) {

478 return TokError("unexpected token in section switching directive");

479 Lex();

480

481

483 getStreamer().switchSection(getContext().getMachOSection(

484 Segment, Section, TAA, StubSize,

486

487

488

489

490

491

492

493

494

495 if (Alignment)

496 getStreamer().emitValueToAlignment(Align(Alignment));

497

498 return false;

499}

500

501

502

503bool DarwinAsmParser::parseDirectiveAltEntry(StringRef, SMLoc) {

506 return TokError("expected identifier in directive");

507

509 return TokError(".alt_entry must preceed symbol definition");

510

511 if (!getStreamer().emitSymbolAttribute(Sym, MCSA_AltEntry))

512 return TokError("unable to emit symbol attribute");

513

514 Lex();

515 return false;

516}

517

518

519

520bool DarwinAsmParser::parseDirectiveDesc(StringRef, SMLoc) {

523 return TokError("expected identifier in directive");

524

526 return TokError("unexpected token in '.desc' directive");

527 Lex();

528

529 int64_t DescValue;

530 if (getParser().parseAbsoluteExpression(DescValue))

531 return true;

532

534 return TokError("unexpected token in '.desc' directive");

535

536 Lex();

537

538

539 getStreamer().emitSymbolDesc(Sym, DescValue);

540

541 return false;

542}

543

544

545

546bool DarwinAsmParser::parseDirectiveIndirectSymbol(StringRef, SMLoc Loc) {

547 const MCSectionMachO *Current = static_cast<const MCSectionMachO *>(

548 getStreamer().getCurrentSectionOnly());

554 return Error(Loc, "indirect symbol not in a symbol pointer or stub "

555 "section");

556

559 return TokError("expected identifier in .indirect_symbol directive");

560

561

563 return TokError("non-local symbol required in directive");

564

566 return TokError("unable to emit indirect symbol attribute for: " +

568

570 return TokError("unexpected token in '.indirect_symbol' directive");

571

572 Lex();

573

574 return false;

575}

576

577

578

579bool DarwinAsmParser::parseDirectiveDumpOrLoad(StringRef Directive,

580 SMLoc IDLoc) {

581 bool IsDump = Directive == ".dump";

583 return TokError("expected string in '.dump' or '.load' directive");

584

585 Lex();

586

588 return TokError("unexpected token in '.dump' or '.load' directive");

589

590 Lex();

591

592

593

594 if (IsDump)

595 return Warning(IDLoc, "ignoring directive .dump for now");

596 else

597 return Warning(IDLoc, "ignoring directive .load for now");

598}

599

600

601

602bool DarwinAsmParser::parseDirectiveLinkerOption(StringRef IDVal, SMLoc) {

603 SmallVector<std::string, 4> Args;

604 while (true) {

606 return TokError("expected string in '" + Twine(IDVal) + "' directive");

607

608 std::string Data;

609 if (getParser().parseEscapedString(Data))

610 return true;

611

613

615 break;

616

618 return TokError("unexpected token in '" + Twine(IDVal) + "' directive");

619 Lex();

620 }

621

622 getStreamer().emitLinkerOptions(Args);

623 return false;

624}

625

626

627

628bool DarwinAsmParser::parseDirectiveLsym(StringRef, SMLoc) {

631 return TokError("expected identifier in directive");

632

634 return TokError("unexpected token in '.lsym' directive");

635 Lex();

636

637 const MCExpr *Value;

638 if (getParser().parseExpression(Value))

639 return true;

640

642 return TokError("unexpected token in '.lsym' directive");

643

644 Lex();

645

646

647

648

649 (void) Sym;

650 return TokError("directive '.lsym' is unsupported");

651}

652

653

654

655bool DarwinAsmParser::parseDirectiveSection(StringRef, SMLoc) {

656 SMLoc Loc = getLexer().getLoc();

657

659 if (getParser().parseIdentifier(SectionName))

660 return Error(Loc, "expected identifier after '.section' directive");

661

662

664 return TokError("unexpected token in '.section' directive");

665

666 std::string SectionSpec = std::string(SectionName);

667 SectionSpec += ",";

668

669

670

671 StringRef EOL = getLexer().LexUntilEndOfStatement();

672 SectionSpec.append(EOL.begin(), EOL.end());

673

674 Lex();

676 return TokError("unexpected token in '.section' directive");

677 Lex();

678

679 StringRef Segment, Section;

680 unsigned StubSize;

681 unsigned TAA;

682 bool TAAParsed;

684 SectionSpec, Segment, Section, TAA, TAAParsed, StubSize))

686

687

688 Triple TT = getParser().getContext().getTargetTriple();

690

692 StringRef NonCoalSection = StringSwitch(Section)

693 .Case("__textcoal_nt", "__text")

694 .Case("__const_coal", "__const")

695 .Case("__datacoal_nt", "__data")

696 .Default(Section);

697

698 if (Section != NonCoalSection) {

699 StringRef SectionVal(Loc.getPointer());

700 size_t B = SectionVal.find(',') + 1, E = SectionVal.find(',', B);

703 getParser().Warning(Loc, "section \"" + Section + "\" is deprecated",

704 SMRange(BLoc, ELoc));

705 getParser().Note(Loc, "change section name to \"" + NonCoalSection +

706 "\"", SMRange(BLoc, ELoc));

707 }

708 }

709

710

711 bool isText = Segment == "__TEXT";

712 getStreamer().switchSection(getContext().getMachOSection(

713 Segment, Section, TAA, StubSize,

715 return false;

716}

717

718

719

720bool DarwinAsmParser::parseDirectivePushSection(StringRef S, SMLoc Loc) {

721 getStreamer().pushSection();

722

723 if (parseDirectiveSection(S, Loc)) {

724 getStreamer().popSection();

725 return true;

726 }

727

728 return false;

729}

730

731

732

733bool DarwinAsmParser::parseDirectivePopSection(StringRef, SMLoc) {

734 if (!getStreamer().popSection())

735 return TokError(".popsection without corresponding .pushsection");

736 return false;

737}

738

739

740

741bool DarwinAsmParser::parseDirectivePrevious(StringRef DirName, SMLoc) {

742 MCSectionSubPair PreviousSection = getStreamer().getPreviousSection();

743 if (!PreviousSection.first)

744 return TokError(".previous without corresponding .section");

745 getStreamer().switchSection(PreviousSection.first, PreviousSection.second);

746 return false;

747}

748

749

750

751bool DarwinAsmParser::parseDirectiveSecureLogUnique(StringRef, SMLoc IDLoc) {

752 StringRef LogMessage = getParser().parseStringToEndOfStatement();

754 return TokError("unexpected token in '.secure_log_unique' directive");

755

757 return Error(IDLoc, ".secure_log_unique specified multiple times");

758

759

760 StringRef SecureLogFile = getContext().getSecureLogFile();

761 if (SecureLogFile.empty())

762 return Error(IDLoc, ".secure_log_unique used but AS_SECURE_LOG_FILE "

763 "environment variable unset.");

764

765

766 raw_fd_ostream *OS = getContext().getSecureLog();

767 if (!OS) {

768 std::error_code EC;

769 auto NewOS = std::make_unique<raw_fd_ostream>(

771 if (EC)

772 return Error(IDLoc, Twine("can't open secure log file: ") +

773 SecureLogFile + " (" + EC.message() + ")");

774 OS = NewOS.get();

775 getContext().setSecureLog(std::move(NewOS));

776 }

777

778

779 unsigned CurBuf = getSourceManager().FindBufferContainingLoc(IDLoc);

780 *OS << getSourceManager().getBufferInfo(CurBuf).Buffer->getBufferIdentifier()

781 << ":" << getSourceManager().FindLineNumber(IDLoc, CurBuf) << ":"

782 << LogMessage + "\n";

783

785

786 return false;

787}

788

789

790

791bool DarwinAsmParser::parseDirectiveSecureLogReset(StringRef, SMLoc IDLoc) {

793 return TokError("unexpected token in '.secure_log_reset' directive");

794

795 Lex();

796

797 getContext().setSecureLogUsed(false);

798

799 return false;

800}

801

802

803

804bool DarwinAsmParser::parseDirectiveSubsectionsViaSymbols(StringRef, SMLoc) {

806 return TokError("unexpected token in '.subsections_via_symbols' directive");

807

808 Lex();

809

810 getStreamer().emitSubsectionsViaSymbols();

811

812 return false;

813}

814

815

816

817bool DarwinAsmParser::parseDirectiveTBSS(StringRef, SMLoc) {

818 SMLoc IDLoc = getLexer().getLoc();

821 return TokError("expected identifier in directive");

822

824 return TokError("unexpected token in directive");

825 Lex();

826

827 int64_t Size;

828 SMLoc SizeLoc = getLexer().getLoc();

829 if (getParser().parseAbsoluteExpression(Size))

830 return true;

831

832 int64_t Pow2Alignment = 0;

833 SMLoc Pow2AlignmentLoc;

835 Lex();

836 Pow2AlignmentLoc = getLexer().getLoc();

837 if (getParser().parseAbsoluteExpression(Pow2Alignment))

838 return true;

839 }

840

842 return TokError("unexpected token in '.tbss' directive");

843

844 Lex();

845

846 if (Size < 0)

847 return Error(SizeLoc, "invalid '.tbss' directive size, can't be less than"

848 "zero");

849

850

851 if (Pow2Alignment < 0)

852 return Error(Pow2AlignmentLoc, "invalid '.tbss' alignment, can't be less"

853 "than zero");

854

856 return Error(IDLoc, "invalid symbol redefinition");

857

858 getStreamer().emitTBSSSymbol(

859 getContext().getMachOSection("__DATA", "__thread_bss",

862 Sym, Size, Align(1ULL << Pow2Alignment));

863

864 return false;

865}

866

867

868

869

870bool DarwinAsmParser::parseDirectiveZerofill(StringRef, SMLoc) {

871 StringRef Segment;

872 if (getParser().parseIdentifier(Segment))

873 return TokError("expected segment name after '.zerofill' directive");

874

876 return TokError("unexpected token in directive");

877 Lex();

878

880 SMLoc SectionLoc = getLexer().getLoc();

881 if (getParser().parseIdentifier(Section))

882 return TokError("expected section name after comma in '.zerofill' "

883 "directive");

884

885

886

888

889 getStreamer().emitZerofill(

892 nullptr, 0, Align(1), SectionLoc);

893 return false;

894 }

895

897 return TokError("unexpected token in directive");

898 Lex();

899

900 SMLoc IDLoc = getLexer().getLoc();

903 return TokError("expected identifier in directive");

904

906 return TokError("unexpected token in directive");

907 Lex();

908

909 int64_t Size;

910 SMLoc SizeLoc = getLexer().getLoc();

911 if (getParser().parseAbsoluteExpression(Size))

912 return true;

913

914 int64_t Pow2Alignment = 0;

915 SMLoc Pow2AlignmentLoc;

917 Lex();

918 Pow2AlignmentLoc = getLexer().getLoc();

919 if (getParser().parseAbsoluteExpression(Pow2Alignment))

920 return true;

921 }

922

924 return TokError("unexpected token in '.zerofill' directive");

925

926 Lex();

927

928 if (Size < 0)

929 return Error(SizeLoc, "invalid '.zerofill' directive size, can't be less "

930 "than zero");

931

932

933

934

935 if (Pow2Alignment < 0)

936 return Error(Pow2AlignmentLoc, "invalid '.zerofill' directive alignment, "

937 "can't be less than zero");

938

940 return Error(IDLoc, "invalid symbol redefinition");

941

942

943

944

945 getStreamer().emitZerofill(

948 Sym, Size, Align(1ULL << Pow2Alignment), SectionLoc);

949

950 return false;

951}

952

953

954

955bool DarwinAsmParser::parseDirectiveDataRegion(StringRef, SMLoc) {

957 Lex();

959 return false;

960 }

961 StringRef RegionType;

962 SMLoc Loc = getParser().getTok().getLoc();

963 if (getParser().parseIdentifier(RegionType))

964 return TokError("expected region type after '.data_region' directive");

965 int Kind = StringSwitch(RegionType)

969 .Default(-1);

970 if (Kind == -1)

971 return Error(Loc, "unknown region type in '.data_region' directive");

972 Lex();

973

975 return false;

976}

977

978

979

980bool DarwinAsmParser::parseDirectiveDataRegionEnd(StringRef, SMLoc) {

982 return TokError("unexpected token in '.end_data_region' directive");

983

984 Lex();

986 return false;

987}

988

992

993

994bool DarwinAsmParser::parseMajorMinorVersionComponent(unsigned *Major,

995 unsigned *Minor,

996 const char *VersionName) {

997

999 return TokError(Twine("invalid ") + VersionName +

1000 " major version number, integer expected");

1001 int64_t MajorVal = getLexer().getTok().getIntVal();

1002 if (MajorVal > 65535 || MajorVal <= 0)

1003 return TokError(Twine("invalid ") + VersionName + " major version number");

1004 *Major = (unsigned)MajorVal;

1005 Lex();

1007 return TokError(Twine(VersionName) +

1008 " minor version number required, comma expected");

1009 Lex();

1010

1012 return TokError(Twine("invalid ") + VersionName +

1013 " minor version number, integer expected");

1014 int64_t MinorVal = getLexer().getTok().getIntVal();

1015 if (MinorVal > 255 || MinorVal < 0)

1016 return TokError(Twine("invalid ") + VersionName + " minor version number");

1017 *Minor = MinorVal;

1018 Lex();

1019 return false;

1020}

1021

1022

1023bool DarwinAsmParser::parseOptionalTrailingVersionComponent(

1024 unsigned *Component, const char *ComponentName) {

1026 Lex();

1028 return TokError(Twine("invalid ") + ComponentName +

1029 " version number, integer expected");

1030 int64_t Val = getLexer().getTok().getIntVal();

1031 if (Val > 255 || Val < 0)

1032 return TokError(Twine("invalid ") + ComponentName + " version number");

1034 Lex();

1035 return false;

1036}

1037

1038

1039

1040bool DarwinAsmParser::parseVersion(unsigned *Major, unsigned *Minor,

1041 unsigned *Update) {

1042 if (parseMajorMinorVersionComponent(Major, Minor, "OS"))

1043 return true;

1044

1045

1046 *Update = 0;

1049 return false;

1051 return TokError("invalid OS update specifier, comma expected");

1052 if (parseOptionalTrailingVersionComponent(Update, "OS update"))

1053 return true;

1054 return false;

1055}

1056

1057bool DarwinAsmParser::parseSDKVersion(VersionTuple &SDKVersion) {

1059 Lex();

1060 unsigned Major, Minor;

1061 if (parseMajorMinorVersionComponent(&Major, &Minor, "SDK"))

1062 return true;

1063 SDKVersion = VersionTuple(Major, Minor);

1064

1065

1067 unsigned Subminor;

1068 if (parseOptionalTrailingVersionComponent(&Subminor, "SDK subminor"))

1069 return true;

1070 SDKVersion = VersionTuple(Major, Minor, Subminor);

1071 }

1072 return false;

1073}

1074

1075void DarwinAsmParser::checkVersion(StringRef Directive, StringRef Arg,

1078 if (Target.getOS() != ExpectedOS)

1079 Warning(Loc, Twine(Directive) +

1080 (Arg.empty() ? Twine() : Twine(' ') + Arg) +

1081 " used while targeting " + Target.getOSName());

1082

1083 if (LastVersionDirective.isValid()) {

1084 Warning(Loc, "overriding previous version directive");

1085 Note(LastVersionDirective, "previous definition is here");

1086 }

1087 LastVersionDirective = Loc;

1088}

1089

1091 switch (Type) {

1096 }

1098}

1099

1100

1101

1102

1103

1104

1105bool DarwinAsmParser::parseVersionMin(StringRef Directive, SMLoc Loc,

1107 unsigned Major;

1108 unsigned Minor;

1109 unsigned Update;

1111 return true;

1112

1113 VersionTuple SDKVersion;

1114 if (isSDKVersionToken(getLexer().getTok()) && parseSDKVersion(SDKVersion))

1115 return true;

1116

1117 if (parseEOL())

1118 return addErrorSuffix(Twine(" in '") + Directive + "' directive");

1119

1121 checkVersion(Directive, StringRef(), Loc, ExpectedOS);

1122 getStreamer().emitVersionMin(Type, Major, Minor, Update, SDKVersion);

1123 return false;

1124}

1125

1127 switch (Type) {

1128 case MachO::PLATFORM_UNKNOWN:

1129 break;

1131 case MachO::PLATFORM_IOS: return Triple::IOS;

1132 case MachO::PLATFORM_TVOS: return Triple::TvOS;

1134 case MachO::PLATFORM_XROS: return Triple::XROS;

1135 case MachO::PLATFORM_BRIDGEOS: break;

1136 case MachO::PLATFORM_DRIVERKIT:

1138 case MachO::PLATFORM_MACCATALYST: return Triple::IOS;

1139 case MachO::PLATFORM_IOSSIMULATOR: break;

1140 case MachO::PLATFORM_TVOSSIMULATOR: break;

1141 case MachO::PLATFORM_WATCHOSSIMULATOR: break;

1142 case MachO::PLATFORM_XROS_SIMULATOR: break;

1143 }

1145}

1146

1147

1148

1149bool DarwinAsmParser::parseBuildVersion(StringRef Directive, SMLoc Loc) {

1150 StringRef PlatformName;

1151 SMLoc PlatformLoc = getTok().getLoc();

1152 if (getParser().parseIdentifier(PlatformName))

1153 return TokError("platform name expected");

1154

1155 unsigned Platform = StringSwitch(PlatformName)

1156#define PLATFORM(platform, id, name, build_name, target, tapi_target, \

1157 marketing) \

1158 .Case(#build_name, MachO::PLATFORM_##platform)

1159#include "llvm/BinaryFormat/MachO.def"

1160 .Default(MachO::PLATFORM_UNKNOWN);

1161

1162 if (Platform == MachO::PLATFORM_UNKNOWN)

1163 return Error(PlatformLoc, "unknown platform name");

1164

1166 return TokError("version number required, comma expected");

1167 Lex();

1168

1169 unsigned Major;

1170 unsigned Minor;

1171 unsigned Update;

1173 return true;

1174

1175 VersionTuple SDKVersion;

1176 if (isSDKVersionToken(getLexer().getTok()) && parseSDKVersion(SDKVersion))

1177 return true;

1178

1179 if (parseEOL())

1180 return addErrorSuffix(" in '.build_version' directive");

1181

1184 checkVersion(Directive, PlatformName, Loc, ExpectedOS);

1185 getStreamer().emitBuildVersion(Platform, Major, Minor, Update, SDKVersion);

1186 return false;

1187}

1188

1189

1190

1191bool DarwinAsmParser::parseDirectiveCGProfile(StringRef S, SMLoc Loc) {

1193}

1194

1196 return new DarwinAsmParser;

1197}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static bool isNot(const MachineRegisterInfo &MRI, const MachineInstr &MI)

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

static Version parseVersion(StringRef Name)

static bool isSDKVersionToken(const AsmToken &Tok)

Definition DarwinAsmParser.cpp:989

static Triple::OSType getOSTypeFromMCVM(MCVersionMinType Type)

Definition DarwinAsmParser.cpp:1090

static Triple::OSType getOSTypeFromPlatform(MachO::PlatformType Type)

Definition DarwinAsmParser.cpp:1126

This file defines the SmallVector class.

This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...

Target independent representation for an assembler token.

bool is(TokenKind K) const

StringRef getIdentifier() const

Get the identifier string for the current token, which should be an identifier or a string.

Generic interface for extending the MCAsmParser, which is implemented by target and object file assem...

virtual void Initialize(MCAsmParser &Parser)

Initialize the extension for parsing using the given Parser.

bool parseDirectiveCGProfile(StringRef, SMLoc)

parseDirectiveCGProfile ::= .cg_profile identifier, identifier,

std::pair< MCAsmParserExtension *, DirectiveHandler > ExtensionDirectiveHandler

static Error ParseSectionSpecifier(StringRef Spec, StringRef &Segment, StringRef &Section, unsigned &TAA, bool &TAAParsed, unsigned &StubSize)

Parse the section specifier indicated by "Spec".

MachO::SectionType getType() const

bool isDefined() const

isDefined - Check if this symbol is defined (i.e., it has an address).

bool isUndefined() const

isUndefined - Check if this symbol undefined (i.e., implicitly defined).

StringRef getName() const

getName - Get the symbol name.

bool isTemporary() const

isTemporary - Check if this is an assembler temporary symbol.

static SMLoc getFromPointer(const char *Ptr)

constexpr const char * getPointer() const

constexpr bool isValid() const

static SectionKind getText()

static SectionKind getData()

static SectionKind getBSS()

static SectionKind getThreadBSS()

StringRef - Represent a constant reference to a string, i.e.

constexpr bool empty() const

empty - Check if the string is empty.

The instances of the Type class are immutable: once they are created, they are never changed.

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

constexpr char Align[]

Key for Kernel::Arg::Metadata::mAlign.

constexpr char Args[]

Key for Kernel::Metadata::mArgs.

SectionType

These are the section type and attributes fields.

@ S_THREAD_LOCAL_VARIABLE_POINTERS

S_THREAD_LOCAL_VARIABLE_POINTERS - Section with pointers to thread local structures.

@ S_16BYTE_LITERALS

S_16BYTE_LITERALS - Section with only 16 byte literals.

@ S_THREAD_LOCAL_INIT_FUNCTION_POINTERS

S_THREAD_LOCAL_INIT_FUNCTION_POINTERS - Section with thread local variable initialization pointers to...

@ S_THREAD_LOCAL_ZEROFILL

S_THREAD_LOCAL_ZEROFILL - Thread local zerofill section.

@ S_LAZY_SYMBOL_POINTERS

S_LAZY_SYMBOL_POINTERS - Section with lazy symbol pointers.

@ S_MOD_TERM_FUNC_POINTERS

S_MOD_TERM_FUNC_POINTERS - Section with only function pointers for termination.

@ S_MOD_INIT_FUNC_POINTERS

S_MOD_INIT_FUNC_POINTERS - Section with only function pointers for initialization.

@ S_CSTRING_LITERALS

S_CSTRING_LITERALS - Section with literal C strings.

@ S_THREAD_LOCAL_REGULAR

S_THREAD_LOCAL_REGULAR - Thread local data section.

@ S_ZEROFILL

S_ZEROFILL - Zero fill on demand section.

@ S_NON_LAZY_SYMBOL_POINTERS

S_NON_LAZY_SYMBOL_POINTERS - Section with non-lazy symbol pointers.

@ S_4BYTE_LITERALS

S_4BYTE_LITERALS - Section with 4 byte literals.

@ S_LITERAL_POINTERS

S_LITERAL_POINTERS - Section with pointers to literals.

@ S_8BYTE_LITERALS

S_8BYTE_LITERALS - Section with 8 byte literals.

@ S_THREAD_LOCAL_VARIABLES

S_THREAD_LOCAL_VARIABLES - Section with thread local variable structure data.

@ S_SYMBOL_STUBS

S_SYMBOL_STUBS - Section with symbol stubs, byte size of stub in the Reserved2 field.

LLVM_ABI SimpleSymbol parseSymbol(StringRef SymName)

Get symbol classification by parsing the name of a symbol.

@ S_ATTR_NO_DEAD_STRIP

S_ATTR_NO_DEAD_STRIP - No dead stripping.

@ S_ATTR_PURE_INSTRUCTIONS

S_ATTR_PURE_INSTRUCTIONS - Section contains only true machine instructions.

Context & getContext() const

@ OF_TextWithCRLF

The file should be opened in text mode and use a carriage linefeed '\r '.

@ OF_Append

The file should be opened in append mode.

This is an optimization pass for GlobalISel generic memory operations.

FunctionAddr VTableAddr Value

@ MCDR_DataRegionEnd

.end_data_region

@ MCDR_DataRegion

.data_region

@ MCDR_DataRegionJT8

.data_region jt8

@ MCDR_DataRegionJT32

.data_region jt32

@ MCDR_DataRegionJT16

.data_region jt16

@ MCVM_WatchOSVersionMin

.watchos_version_min

@ MCVM_OSXVersionMin

.macosx_version_min

@ MCVM_TvOSVersionMin

.tvos_version_min

@ MCVM_IOSVersionMin

.ios_version_min

FunctionAddr VTableAddr uintptr_t uintptr_t Data

std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)

std::pair< MCSection *, uint32_t > MCSectionSubPair

MCAsmParserExtension * createDarwinAsmParser()

Definition DarwinAsmParser.cpp:1195

@ MCSA_AltEntry

.alt_entry (MachO)

@ MCSA_IndirectSymbol

.indirect_symbol (MachO)