1210006Srdivacky//===- ELFAsmParser.cpp - ELF Assembly Parser -----------------------------===// 2210006Srdivacky// 3210006Srdivacky// The LLVM Compiler Infrastructure 4210006Srdivacky// 5210006Srdivacky// This file is distributed under the University of Illinois Open Source 6210006Srdivacky// License. See LICENSE.TXT for details. 7210006Srdivacky// 8210006Srdivacky//===----------------------------------------------------------------------===// 9210006Srdivacky 10210006Srdivacky#include "llvm/MC/MCParser/MCAsmParserExtension.h" 11218893Sdim#include "llvm/ADT/StringSwitch.h" 12212904Sdim#include "llvm/ADT/Twine.h" 13212904Sdim#include "llvm/MC/MCAsmInfo.h" 14212904Sdim#include "llvm/MC/MCContext.h" 15218893Sdim#include "llvm/MC/MCExpr.h" 16212904Sdim#include "llvm/MC/MCParser/MCAsmLexer.h" 17210006Srdivacky#include "llvm/MC/MCSectionELF.h" 18210006Srdivacky#include "llvm/MC/MCStreamer.h" 19263508Sdim#include "llvm/MC/MCSymbol.h" 20218893Sdim#include "llvm/Support/ELF.h" 21210006Srdivackyusing namespace llvm; 22210006Srdivacky 23210006Srdivackynamespace { 24210006Srdivacky 25210006Srdivackyclass ELFAsmParser : public MCAsmParserExtension { 26249423Sdim template<bool (ELFAsmParser::*HandlerMethod)(StringRef, SMLoc)> 27249423Sdim void addDirectiveHandler(StringRef Directive) { 28249423Sdim MCAsmParser::ExtensionDirectiveHandler Handler = std::make_pair( 29249423Sdim this, HandleDirective<ELFAsmParser, HandlerMethod>); 30249423Sdim 31249423Sdim getParser().addDirectiveHandler(Directive, Handler); 32212904Sdim } 33212904Sdim 34263508Sdim bool ParseSectionSwitch(StringRef Section, unsigned Type, unsigned Flags, 35263508Sdim SectionKind Kind); 36210006Srdivacky 37210006Srdivackypublic: 38263508Sdim ELFAsmParser() { BracketExpressionsSupported = true; } 39210006Srdivacky 40210006Srdivacky virtual void Initialize(MCAsmParser &Parser) { 41210006Srdivacky // Call the base implementation. 42210006Srdivacky this->MCAsmParserExtension::Initialize(Parser); 43210006Srdivacky 44249423Sdim addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveData>(".data"); 45249423Sdim addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveText>(".text"); 46249423Sdim addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveBSS>(".bss"); 47249423Sdim addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveRoData>(".rodata"); 48249423Sdim addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveTData>(".tdata"); 49249423Sdim addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveTBSS>(".tbss"); 50249423Sdim addDirectiveHandler< 51226633Sdim &ELFAsmParser::ParseSectionDirectiveDataRel>(".data.rel"); 52249423Sdim addDirectiveHandler< 53226633Sdim &ELFAsmParser::ParseSectionDirectiveDataRelRo>(".data.rel.ro"); 54249423Sdim addDirectiveHandler< 55226633Sdim &ELFAsmParser::ParseSectionDirectiveDataRelRoLocal>(".data.rel.ro.local"); 56249423Sdim addDirectiveHandler< 57226633Sdim &ELFAsmParser::ParseSectionDirectiveEhFrame>(".eh_frame"); 58249423Sdim addDirectiveHandler<&ELFAsmParser::ParseDirectiveSection>(".section"); 59249423Sdim addDirectiveHandler< 60226633Sdim &ELFAsmParser::ParseDirectivePushSection>(".pushsection"); 61249423Sdim addDirectiveHandler<&ELFAsmParser::ParseDirectivePopSection>(".popsection"); 62249423Sdim addDirectiveHandler<&ELFAsmParser::ParseDirectiveSize>(".size"); 63249423Sdim addDirectiveHandler<&ELFAsmParser::ParseDirectivePrevious>(".previous"); 64249423Sdim addDirectiveHandler<&ELFAsmParser::ParseDirectiveType>(".type"); 65249423Sdim addDirectiveHandler<&ELFAsmParser::ParseDirectiveIdent>(".ident"); 66249423Sdim addDirectiveHandler<&ELFAsmParser::ParseDirectiveSymver>(".symver"); 67249423Sdim addDirectiveHandler<&ELFAsmParser::ParseDirectiveVersion>(".version"); 68249423Sdim addDirectiveHandler<&ELFAsmParser::ParseDirectiveWeakref>(".weakref"); 69249423Sdim addDirectiveHandler<&ELFAsmParser::ParseDirectiveSymbolAttribute>(".weak"); 70249423Sdim addDirectiveHandler<&ELFAsmParser::ParseDirectiveSymbolAttribute>(".local"); 71249423Sdim addDirectiveHandler< 72226633Sdim &ELFAsmParser::ParseDirectiveSymbolAttribute>(".protected"); 73249423Sdim addDirectiveHandler< 74226633Sdim &ELFAsmParser::ParseDirectiveSymbolAttribute>(".internal"); 75249423Sdim addDirectiveHandler< 76226633Sdim &ELFAsmParser::ParseDirectiveSymbolAttribute>(".hidden"); 77251662Sdim addDirectiveHandler<&ELFAsmParser::ParseDirectiveSubsection>(".subsection"); 78210006Srdivacky } 79210006Srdivacky 80218893Sdim // FIXME: Part of this logic is duplicated in the MCELFStreamer. What is 81218893Sdim // the best way for us to get access to it? 82210006Srdivacky bool ParseSectionDirectiveData(StringRef, SMLoc) { 83218893Sdim return ParseSectionSwitch(".data", ELF::SHT_PROGBITS, 84218893Sdim ELF::SHF_WRITE |ELF::SHF_ALLOC, 85210006Srdivacky SectionKind::getDataRel()); 86210006Srdivacky } 87210006Srdivacky bool ParseSectionDirectiveText(StringRef, SMLoc) { 88218893Sdim return ParseSectionSwitch(".text", ELF::SHT_PROGBITS, 89218893Sdim ELF::SHF_EXECINSTR | 90218893Sdim ELF::SHF_ALLOC, SectionKind::getText()); 91210006Srdivacky } 92212904Sdim bool ParseSectionDirectiveBSS(StringRef, SMLoc) { 93218893Sdim return ParseSectionSwitch(".bss", ELF::SHT_NOBITS, 94218893Sdim ELF::SHF_WRITE | 95218893Sdim ELF::SHF_ALLOC, SectionKind::getBSS()); 96212904Sdim } 97212904Sdim bool ParseSectionDirectiveRoData(StringRef, SMLoc) { 98218893Sdim return ParseSectionSwitch(".rodata", ELF::SHT_PROGBITS, 99218893Sdim ELF::SHF_ALLOC, 100212904Sdim SectionKind::getReadOnly()); 101212904Sdim } 102212904Sdim bool ParseSectionDirectiveTData(StringRef, SMLoc) { 103218893Sdim return ParseSectionSwitch(".tdata", ELF::SHT_PROGBITS, 104218893Sdim ELF::SHF_ALLOC | 105218893Sdim ELF::SHF_TLS | ELF::SHF_WRITE, 106212904Sdim SectionKind::getThreadData()); 107212904Sdim } 108212904Sdim bool ParseSectionDirectiveTBSS(StringRef, SMLoc) { 109218893Sdim return ParseSectionSwitch(".tbss", ELF::SHT_NOBITS, 110218893Sdim ELF::SHF_ALLOC | 111218893Sdim ELF::SHF_TLS | ELF::SHF_WRITE, 112212904Sdim SectionKind::getThreadBSS()); 113212904Sdim } 114212904Sdim bool ParseSectionDirectiveDataRel(StringRef, SMLoc) { 115218893Sdim return ParseSectionSwitch(".data.rel", ELF::SHT_PROGBITS, 116218893Sdim ELF::SHF_ALLOC | 117218893Sdim ELF::SHF_WRITE, 118212904Sdim SectionKind::getDataRel()); 119212904Sdim } 120212904Sdim bool ParseSectionDirectiveDataRelRo(StringRef, SMLoc) { 121218893Sdim return ParseSectionSwitch(".data.rel.ro", ELF::SHT_PROGBITS, 122218893Sdim ELF::SHF_ALLOC | 123218893Sdim ELF::SHF_WRITE, 124212904Sdim SectionKind::getReadOnlyWithRel()); 125212904Sdim } 126212904Sdim bool ParseSectionDirectiveDataRelRoLocal(StringRef, SMLoc) { 127218893Sdim return ParseSectionSwitch(".data.rel.ro.local", ELF::SHT_PROGBITS, 128218893Sdim ELF::SHF_ALLOC | 129218893Sdim ELF::SHF_WRITE, 130212904Sdim SectionKind::getReadOnlyWithRelLocal()); 131212904Sdim } 132212904Sdim bool ParseSectionDirectiveEhFrame(StringRef, SMLoc) { 133218893Sdim return ParseSectionSwitch(".eh_frame", ELF::SHT_PROGBITS, 134218893Sdim ELF::SHF_ALLOC | 135218893Sdim ELF::SHF_WRITE, 136212904Sdim SectionKind::getDataRel()); 137212904Sdim } 138218893Sdim bool ParseDirectivePushSection(StringRef, SMLoc); 139218893Sdim bool ParseDirectivePopSection(StringRef, SMLoc); 140212904Sdim bool ParseDirectiveSection(StringRef, SMLoc); 141212904Sdim bool ParseDirectiveSize(StringRef, SMLoc); 142212904Sdim bool ParseDirectivePrevious(StringRef, SMLoc); 143218893Sdim bool ParseDirectiveType(StringRef, SMLoc); 144218893Sdim bool ParseDirectiveIdent(StringRef, SMLoc); 145218893Sdim bool ParseDirectiveSymver(StringRef, SMLoc); 146239462Sdim bool ParseDirectiveVersion(StringRef, SMLoc); 147218893Sdim bool ParseDirectiveWeakref(StringRef, SMLoc); 148226633Sdim bool ParseDirectiveSymbolAttribute(StringRef, SMLoc); 149251662Sdim bool ParseDirectiveSubsection(StringRef, SMLoc); 150218893Sdim 151218893Sdimprivate: 152218893Sdim bool ParseSectionName(StringRef &SectionName); 153251662Sdim bool ParseSectionArguments(bool IsPush); 154210006Srdivacky}; 155210006Srdivacky 156210006Srdivacky} 157210006Srdivacky 158226633Sdim/// ParseDirectiveSymbolAttribute 159226633Sdim/// ::= { ".local", ".weak", ... } [ identifier ( , identifier )* ] 160226633Sdimbool ELFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) { 161226633Sdim MCSymbolAttr Attr = StringSwitch<MCSymbolAttr>(Directive) 162226633Sdim .Case(".weak", MCSA_Weak) 163226633Sdim .Case(".local", MCSA_Local) 164226633Sdim .Case(".hidden", MCSA_Hidden) 165226633Sdim .Case(".internal", MCSA_Internal) 166226633Sdim .Case(".protected", MCSA_Protected) 167226633Sdim .Default(MCSA_Invalid); 168226633Sdim assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!"); 169226633Sdim if (getLexer().isNot(AsmToken::EndOfStatement)) { 170226633Sdim for (;;) { 171226633Sdim StringRef Name; 172226633Sdim 173249423Sdim if (getParser().parseIdentifier(Name)) 174226633Sdim return TokError("expected identifier in directive"); 175226633Sdim 176226633Sdim MCSymbol *Sym = getContext().GetOrCreateSymbol(Name); 177226633Sdim 178226633Sdim getStreamer().EmitSymbolAttribute(Sym, Attr); 179226633Sdim 180226633Sdim if (getLexer().is(AsmToken::EndOfStatement)) 181226633Sdim break; 182226633Sdim 183226633Sdim if (getLexer().isNot(AsmToken::Comma)) 184226633Sdim return TokError("unexpected token in directive"); 185226633Sdim Lex(); 186226633Sdim } 187226633Sdim } 188226633Sdim 189226633Sdim Lex(); 190226633Sdim return false; 191226633Sdim} 192226633Sdim 193210006Srdivackybool ELFAsmParser::ParseSectionSwitch(StringRef Section, unsigned Type, 194210006Srdivacky unsigned Flags, SectionKind Kind) { 195251662Sdim const MCExpr *Subsection = 0; 196251662Sdim if (getLexer().isNot(AsmToken::EndOfStatement)) { 197251662Sdim if (getParser().parseExpression(Subsection)) 198251662Sdim return true; 199251662Sdim } 200210006Srdivacky 201210006Srdivacky getStreamer().SwitchSection(getContext().getELFSection( 202251662Sdim Section, Type, Flags, Kind), 203251662Sdim Subsection); 204210006Srdivacky 205210006Srdivacky return false; 206210006Srdivacky} 207210006Srdivacky 208212904Sdimbool ELFAsmParser::ParseDirectiveSize(StringRef, SMLoc) { 209212904Sdim StringRef Name; 210249423Sdim if (getParser().parseIdentifier(Name)) 211212904Sdim return TokError("expected identifier in directive"); 212243830Sdim MCSymbol *Sym = getContext().GetOrCreateSymbol(Name); 213212904Sdim 214212904Sdim if (getLexer().isNot(AsmToken::Comma)) 215212904Sdim return TokError("unexpected token in directive"); 216212904Sdim Lex(); 217212904Sdim 218212904Sdim const MCExpr *Expr; 219249423Sdim if (getParser().parseExpression(Expr)) 220212904Sdim return true; 221212904Sdim 222212904Sdim if (getLexer().isNot(AsmToken::EndOfStatement)) 223212904Sdim return TokError("unexpected token in directive"); 224212904Sdim 225212904Sdim getStreamer().EmitELFSize(Sym, Expr); 226212904Sdim return false; 227212904Sdim} 228212904Sdim 229218893Sdimbool ELFAsmParser::ParseSectionName(StringRef &SectionName) { 230218893Sdim // A section name can contain -, so we cannot just use 231249423Sdim // parseIdentifier. 232218893Sdim SMLoc FirstLoc = getLexer().getLoc(); 233218893Sdim unsigned Size = 0; 234212904Sdim 235218893Sdim if (getLexer().is(AsmToken::String)) { 236218893Sdim SectionName = getTok().getIdentifier(); 237212904Sdim Lex(); 238218893Sdim return false; 239218893Sdim } 240212904Sdim 241218893Sdim for (;;) { 242218893Sdim unsigned CurSize; 243212904Sdim 244218893Sdim SMLoc PrevLoc = getLexer().getLoc(); 245218893Sdim if (getLexer().is(AsmToken::Minus)) { 246218893Sdim CurSize = 1; 247218893Sdim Lex(); // Consume the "-". 248218893Sdim } else if (getLexer().is(AsmToken::String)) { 249218893Sdim CurSize = getTok().getIdentifier().size() + 2; 250218893Sdim Lex(); 251218893Sdim } else if (getLexer().is(AsmToken::Identifier)) { 252218893Sdim CurSize = getTok().getIdentifier().size(); 253218893Sdim Lex(); 254218893Sdim } else { 255218893Sdim break; 256218893Sdim } 257212904Sdim 258218893Sdim Size += CurSize; 259218893Sdim SectionName = StringRef(FirstLoc.getPointer(), Size); 260212904Sdim 261218893Sdim // Make sure the following token is adjacent. 262218893Sdim if (PrevLoc.getPointer() + CurSize != getTok().getLoc().getPointer()) 263218893Sdim break; 264218893Sdim } 265218893Sdim if (Size == 0) 266218893Sdim return true; 267212904Sdim 268218893Sdim return false; 269218893Sdim} 270212904Sdim 271218893Sdimstatic SectionKind computeSectionKind(unsigned Flags) { 272218893Sdim if (Flags & ELF::SHF_EXECINSTR) 273218893Sdim return SectionKind::getText(); 274218893Sdim if (Flags & ELF::SHF_TLS) 275218893Sdim return SectionKind::getThreadData(); 276218893Sdim return SectionKind::getDataRel(); 277218893Sdim} 278212904Sdim 279263508Sdimstatic unsigned parseSectionFlags(StringRef flagsStr, bool *UseLastGroup) { 280263508Sdim unsigned flags = 0; 281212904Sdim 282218893Sdim for (unsigned i = 0; i < flagsStr.size(); i++) { 283218893Sdim switch (flagsStr[i]) { 284212904Sdim case 'a': 285218893Sdim flags |= ELF::SHF_ALLOC; 286212904Sdim break; 287263508Sdim case 'e': 288263508Sdim flags |= ELF::SHF_EXCLUDE; 289263508Sdim break; 290212904Sdim case 'x': 291218893Sdim flags |= ELF::SHF_EXECINSTR; 292212904Sdim break; 293212904Sdim case 'w': 294218893Sdim flags |= ELF::SHF_WRITE; 295212904Sdim break; 296212904Sdim case 'M': 297218893Sdim flags |= ELF::SHF_MERGE; 298212904Sdim break; 299212904Sdim case 'S': 300218893Sdim flags |= ELF::SHF_STRINGS; 301212904Sdim break; 302212904Sdim case 'T': 303218893Sdim flags |= ELF::SHF_TLS; 304212904Sdim break; 305212904Sdim case 'c': 306218893Sdim flags |= ELF::XCORE_SHF_CP_SECTION; 307212904Sdim break; 308212904Sdim case 'd': 309218893Sdim flags |= ELF::XCORE_SHF_DP_SECTION; 310212904Sdim break; 311218893Sdim case 'G': 312218893Sdim flags |= ELF::SHF_GROUP; 313218893Sdim break; 314263508Sdim case '?': 315263508Sdim *UseLastGroup = true; 316263508Sdim break; 317212904Sdim default: 318263508Sdim return -1U; 319218893Sdim } 320218893Sdim } 321218893Sdim 322218893Sdim return flags; 323218893Sdim} 324218893Sdim 325218893Sdimbool ELFAsmParser::ParseDirectivePushSection(StringRef s, SMLoc loc) { 326218893Sdim getStreamer().PushSection(); 327218893Sdim 328251662Sdim if (ParseSectionArguments(/*IsPush=*/true)) { 329218893Sdim getStreamer().PopSection(); 330218893Sdim return true; 331218893Sdim } 332218893Sdim 333218893Sdim return false; 334218893Sdim} 335218893Sdim 336218893Sdimbool ELFAsmParser::ParseDirectivePopSection(StringRef, SMLoc) { 337218893Sdim if (!getStreamer().PopSection()) 338218893Sdim return TokError(".popsection without corresponding .pushsection"); 339218893Sdim return false; 340218893Sdim} 341218893Sdim 342218893Sdim// FIXME: This is a work in progress. 343218893Sdimbool ELFAsmParser::ParseDirectiveSection(StringRef, SMLoc) { 344251662Sdim return ParseSectionArguments(/*IsPush=*/false); 345251662Sdim} 346251662Sdim 347251662Sdimbool ELFAsmParser::ParseSectionArguments(bool IsPush) { 348218893Sdim StringRef SectionName; 349218893Sdim 350218893Sdim if (ParseSectionName(SectionName)) 351218893Sdim return TokError("expected identifier in directive"); 352218893Sdim 353218893Sdim StringRef TypeName; 354218893Sdim int64_t Size = 0; 355218893Sdim StringRef GroupName; 356218893Sdim unsigned Flags = 0; 357251662Sdim const MCExpr *Subsection = 0; 358263508Sdim bool UseLastGroup = false; 359218893Sdim 360218893Sdim // Set the defaults first. 361218893Sdim if (SectionName == ".fini" || SectionName == ".init" || 362218893Sdim SectionName == ".rodata") 363218893Sdim Flags |= ELF::SHF_ALLOC; 364218893Sdim if (SectionName == ".fini" || SectionName == ".init") 365218893Sdim Flags |= ELF::SHF_EXECINSTR; 366218893Sdim 367218893Sdim if (getLexer().is(AsmToken::Comma)) { 368218893Sdim Lex(); 369218893Sdim 370251662Sdim if (IsPush && getLexer().isNot(AsmToken::String)) { 371251662Sdim if (getParser().parseExpression(Subsection)) 372251662Sdim return true; 373251662Sdim if (getLexer().isNot(AsmToken::Comma)) 374251662Sdim goto EndStmt; 375251662Sdim Lex(); 376251662Sdim } 377251662Sdim 378218893Sdim if (getLexer().isNot(AsmToken::String)) 379218893Sdim return TokError("expected string in directive"); 380218893Sdim 381218893Sdim StringRef FlagsStr = getTok().getStringContents(); 382218893Sdim Lex(); 383218893Sdim 384263508Sdim unsigned extraFlags = parseSectionFlags(FlagsStr, &UseLastGroup); 385263508Sdim if (extraFlags == -1U) 386212904Sdim return TokError("unknown flag"); 387218893Sdim Flags |= extraFlags; 388218893Sdim 389218893Sdim bool Mergeable = Flags & ELF::SHF_MERGE; 390218893Sdim bool Group = Flags & ELF::SHF_GROUP; 391263508Sdim if (Group && UseLastGroup) 392263508Sdim return TokError("Section cannot specifiy a group name while also acting " 393263508Sdim "as a member of the last group"); 394218893Sdim 395218893Sdim if (getLexer().isNot(AsmToken::Comma)) { 396218893Sdim if (Mergeable) 397218893Sdim return TokError("Mergeable section must specify the type"); 398218893Sdim if (Group) 399218893Sdim return TokError("Group section must specify the type"); 400218893Sdim } else { 401218893Sdim Lex(); 402263508Sdim if (getLexer().is(AsmToken::At) || getLexer().is(AsmToken::Percent) || 403263508Sdim getLexer().is(AsmToken::String)) { 404263508Sdim if (!getLexer().is(AsmToken::String)) 405263508Sdim Lex(); 406263508Sdim } else 407263508Sdim return TokError("expected '@<type>', '%<type>' or \"<type>\""); 408218893Sdim 409249423Sdim if (getParser().parseIdentifier(TypeName)) 410218893Sdim return TokError("expected identifier in directive"); 411218893Sdim 412218893Sdim if (Mergeable) { 413218893Sdim if (getLexer().isNot(AsmToken::Comma)) 414218893Sdim return TokError("expected the entry size"); 415218893Sdim Lex(); 416249423Sdim if (getParser().parseAbsoluteExpression(Size)) 417218893Sdim return true; 418218893Sdim if (Size <= 0) 419218893Sdim return TokError("entry size must be positive"); 420218893Sdim } 421218893Sdim 422218893Sdim if (Group) { 423218893Sdim if (getLexer().isNot(AsmToken::Comma)) 424218893Sdim return TokError("expected group name"); 425218893Sdim Lex(); 426249423Sdim if (getParser().parseIdentifier(GroupName)) 427218893Sdim return true; 428218893Sdim if (getLexer().is(AsmToken::Comma)) { 429218893Sdim Lex(); 430218893Sdim StringRef Linkage; 431249423Sdim if (getParser().parseIdentifier(Linkage)) 432218893Sdim return true; 433218893Sdim if (Linkage != "comdat") 434218893Sdim return TokError("Linkage must be 'comdat'"); 435218893Sdim } 436218893Sdim } 437212904Sdim } 438212904Sdim } 439212904Sdim 440251662SdimEndStmt: 441218893Sdim if (getLexer().isNot(AsmToken::EndOfStatement)) 442218893Sdim return TokError("unexpected token in directive"); 443218893Sdim 444218893Sdim unsigned Type = ELF::SHT_PROGBITS; 445218893Sdim 446249423Sdim if (TypeName.empty()) { 447249423Sdim if (SectionName.startswith(".note")) 448249423Sdim Type = ELF::SHT_NOTE; 449249423Sdim else if (SectionName == ".init_array") 450249423Sdim Type = ELF::SHT_INIT_ARRAY; 451249423Sdim else if (SectionName == ".fini_array") 452249423Sdim Type = ELF::SHT_FINI_ARRAY; 453249423Sdim else if (SectionName == ".preinit_array") 454249423Sdim Type = ELF::SHT_PREINIT_ARRAY; 455249423Sdim } else { 456212904Sdim if (TypeName == "init_array") 457218893Sdim Type = ELF::SHT_INIT_ARRAY; 458212904Sdim else if (TypeName == "fini_array") 459218893Sdim Type = ELF::SHT_FINI_ARRAY; 460212904Sdim else if (TypeName == "preinit_array") 461218893Sdim Type = ELF::SHT_PREINIT_ARRAY; 462212904Sdim else if (TypeName == "nobits") 463218893Sdim Type = ELF::SHT_NOBITS; 464212904Sdim else if (TypeName == "progbits") 465218893Sdim Type = ELF::SHT_PROGBITS; 466218893Sdim else if (TypeName == "note") 467218893Sdim Type = ELF::SHT_NOTE; 468218893Sdim else if (TypeName == "unwind") 469218893Sdim Type = ELF::SHT_X86_64_UNWIND; 470212904Sdim else 471212904Sdim return TokError("unknown section type"); 472212904Sdim } 473212904Sdim 474263508Sdim if (UseLastGroup) { 475263508Sdim MCSectionSubPair CurrentSection = getStreamer().getCurrentSection(); 476263508Sdim if (const MCSectionELF *Section = 477263508Sdim cast_or_null<MCSectionELF>(CurrentSection.first)) 478263508Sdim if (const MCSymbol *Group = Section->getGroup()) { 479263508Sdim GroupName = Group->getName(); 480263508Sdim Flags |= ELF::SHF_GROUP; 481263508Sdim } 482263508Sdim } 483263508Sdim 484218893Sdim SectionKind Kind = computeSectionKind(Flags); 485212904Sdim getStreamer().SwitchSection(getContext().getELFSection(SectionName, Type, 486218893Sdim Flags, Kind, Size, 487251662Sdim GroupName), 488251662Sdim Subsection); 489212904Sdim return false; 490212904Sdim} 491212904Sdim 492218893Sdimbool ELFAsmParser::ParseDirectivePrevious(StringRef DirName, SMLoc) { 493251662Sdim MCSectionSubPair PreviousSection = getStreamer().getPreviousSection(); 494251662Sdim if (PreviousSection.first == NULL) 495218893Sdim return TokError(".previous without corresponding .section"); 496251662Sdim getStreamer().SwitchSection(PreviousSection.first, PreviousSection.second); 497212904Sdim 498218893Sdim return false; 499218893Sdim} 500218893Sdim 501218893Sdim/// ParseDirectiveELFType 502263508Sdim/// ::= .type identifier , STT_<TYPE_IN_UPPER_CASE> 503263508Sdim/// ::= .type identifier , #attribute 504218893Sdim/// ::= .type identifier , @attribute 505263508Sdim/// ::= .type identifier , %attribute 506263508Sdim/// ::= .type identifier , "attribute" 507218893Sdimbool ELFAsmParser::ParseDirectiveType(StringRef, SMLoc) { 508218893Sdim StringRef Name; 509249423Sdim if (getParser().parseIdentifier(Name)) 510218893Sdim return TokError("expected identifier in directive"); 511218893Sdim 512218893Sdim // Handle the identifier as the key symbol. 513218893Sdim MCSymbol *Sym = getContext().GetOrCreateSymbol(Name); 514218893Sdim 515218893Sdim if (getLexer().isNot(AsmToken::Comma)) 516218893Sdim return TokError("unexpected token in '.type' directive"); 517218893Sdim Lex(); 518218893Sdim 519218893Sdim StringRef Type; 520218893Sdim SMLoc TypeLoc; 521263508Sdim MCSymbolAttr Attr; 522263508Sdim if (getLexer().is(AsmToken::Identifier)) { 523263508Sdim TypeLoc = getLexer().getLoc(); 524263508Sdim if (getParser().parseIdentifier(Type)) 525263508Sdim return TokError("expected symbol type in directive"); 526263508Sdim Attr = StringSwitch<MCSymbolAttr>(Type) 527263508Sdim .Case("STT_FUNC", MCSA_ELF_TypeFunction) 528263508Sdim .Case("STT_OBJECT", MCSA_ELF_TypeObject) 529263508Sdim .Case("STT_TLS", MCSA_ELF_TypeTLS) 530263508Sdim .Case("STT_COMMON", MCSA_ELF_TypeCommon) 531263508Sdim .Case("STT_NOTYPE", MCSA_ELF_TypeNoType) 532263508Sdim .Case("STT_GNU_IFUNC", MCSA_ELF_TypeIndFunction) 533263508Sdim .Default(MCSA_Invalid); 534263508Sdim } else if (getLexer().is(AsmToken::Hash) || getLexer().is(AsmToken::At) || 535263508Sdim getLexer().is(AsmToken::Percent) || 536263508Sdim getLexer().is(AsmToken::String)) { 537263508Sdim if (!getLexer().is(AsmToken::String)) 538263508Sdim Lex(); 539218893Sdim 540263508Sdim TypeLoc = getLexer().getLoc(); 541263508Sdim if (getParser().parseIdentifier(Type)) 542263508Sdim return TokError("expected symbol type in directive"); 543263508Sdim Attr = StringSwitch<MCSymbolAttr>(Type) 544263508Sdim .Case("function", MCSA_ELF_TypeFunction) 545263508Sdim .Case("object", MCSA_ELF_TypeObject) 546263508Sdim .Case("tls_object", MCSA_ELF_TypeTLS) 547263508Sdim .Case("common", MCSA_ELF_TypeCommon) 548263508Sdim .Case("notype", MCSA_ELF_TypeNoType) 549263508Sdim .Case("gnu_unique_object", MCSA_ELF_TypeGnuUniqueObject) 550263508Sdim .Case("gnu_indirect_function", MCSA_ELF_TypeIndFunction) 551263508Sdim .Default(MCSA_Invalid); 552263508Sdim } else 553263508Sdim return TokError("expected STT_<TYPE_IN_UPPER_CASE>, '#<type>', '@<type>', " 554263508Sdim "'%<type>' or \"<type>\""); 555218893Sdim 556218893Sdim if (Attr == MCSA_Invalid) 557218893Sdim return Error(TypeLoc, "unsupported attribute in '.type' directive"); 558218893Sdim 559212904Sdim if (getLexer().isNot(AsmToken::EndOfStatement)) 560218893Sdim return TokError("unexpected token in '.type' directive"); 561212904Sdim 562218893Sdim Lex(); 563218893Sdim 564218893Sdim getStreamer().EmitSymbolAttribute(Sym, Attr); 565218893Sdim 566218893Sdim return false; 567212904Sdim} 568212904Sdim 569218893Sdim/// ParseDirectiveIdent 570218893Sdim/// ::= .ident string 571218893Sdimbool ELFAsmParser::ParseDirectiveIdent(StringRef, SMLoc) { 572218893Sdim if (getLexer().isNot(AsmToken::String)) 573218893Sdim return TokError("unexpected token in '.ident' directive"); 574212904Sdim 575218893Sdim StringRef Data = getTok().getIdentifier(); 576218893Sdim 577218893Sdim Lex(); 578218893Sdim 579263508Sdim getStreamer().EmitIdent(Data); 580212904Sdim return false; 581212904Sdim} 582212904Sdim 583218893Sdim/// ParseDirectiveSymver 584218893Sdim/// ::= .symver foo, bar2@zed 585218893Sdimbool ELFAsmParser::ParseDirectiveSymver(StringRef, SMLoc) { 586218893Sdim StringRef Name; 587249423Sdim if (getParser().parseIdentifier(Name)) 588218893Sdim return TokError("expected identifier in directive"); 589218893Sdim 590218893Sdim if (getLexer().isNot(AsmToken::Comma)) 591218893Sdim return TokError("expected a comma"); 592218893Sdim 593218893Sdim Lex(); 594218893Sdim 595218893Sdim StringRef AliasName; 596249423Sdim if (getParser().parseIdentifier(AliasName)) 597218893Sdim return TokError("expected identifier in directive"); 598218893Sdim 599218893Sdim if (AliasName.find('@') == StringRef::npos) 600218893Sdim return TokError("expected a '@' in the name"); 601218893Sdim 602218893Sdim MCSymbol *Alias = getContext().GetOrCreateSymbol(AliasName); 603218893Sdim MCSymbol *Sym = getContext().GetOrCreateSymbol(Name); 604218893Sdim const MCExpr *Value = MCSymbolRefExpr::Create(Sym, getContext()); 605218893Sdim 606218893Sdim getStreamer().EmitAssignment(Alias, Value); 607218893Sdim return false; 608218893Sdim} 609218893Sdim 610239462Sdim/// ParseDirectiveVersion 611239462Sdim/// ::= .version string 612239462Sdimbool ELFAsmParser::ParseDirectiveVersion(StringRef, SMLoc) { 613239462Sdim if (getLexer().isNot(AsmToken::String)) 614239462Sdim return TokError("unexpected token in '.version' directive"); 615239462Sdim 616239462Sdim StringRef Data = getTok().getIdentifier(); 617239462Sdim 618239462Sdim Lex(); 619239462Sdim 620239462Sdim const MCSection *Note = 621239462Sdim getContext().getELFSection(".note", ELF::SHT_NOTE, 0, 622239462Sdim SectionKind::getReadOnly()); 623239462Sdim 624239462Sdim getStreamer().PushSection(); 625239462Sdim getStreamer().SwitchSection(Note); 626239462Sdim getStreamer().EmitIntValue(Data.size()+1, 4); // namesz. 627239462Sdim getStreamer().EmitIntValue(0, 4); // descsz = 0 (no description). 628239462Sdim getStreamer().EmitIntValue(1, 4); // type = NT_VERSION. 629249423Sdim getStreamer().EmitBytes(Data); // name. 630239462Sdim getStreamer().EmitIntValue(0, 1); // terminate the string. 631239462Sdim getStreamer().EmitValueToAlignment(4); // ensure 4 byte alignment. 632239462Sdim getStreamer().PopSection(); 633239462Sdim return false; 634239462Sdim} 635239462Sdim 636218893Sdim/// ParseDirectiveWeakref 637218893Sdim/// ::= .weakref foo, bar 638218893Sdimbool ELFAsmParser::ParseDirectiveWeakref(StringRef, SMLoc) { 639218893Sdim // FIXME: Share code with the other alias building directives. 640218893Sdim 641218893Sdim StringRef AliasName; 642249423Sdim if (getParser().parseIdentifier(AliasName)) 643218893Sdim return TokError("expected identifier in directive"); 644218893Sdim 645218893Sdim if (getLexer().isNot(AsmToken::Comma)) 646218893Sdim return TokError("expected a comma"); 647218893Sdim 648218893Sdim Lex(); 649218893Sdim 650218893Sdim StringRef Name; 651249423Sdim if (getParser().parseIdentifier(Name)) 652218893Sdim return TokError("expected identifier in directive"); 653218893Sdim 654218893Sdim MCSymbol *Alias = getContext().GetOrCreateSymbol(AliasName); 655218893Sdim 656218893Sdim MCSymbol *Sym = getContext().GetOrCreateSymbol(Name); 657218893Sdim 658218893Sdim getStreamer().EmitWeakReference(Alias, Sym); 659218893Sdim return false; 660218893Sdim} 661218893Sdim 662251662Sdimbool ELFAsmParser::ParseDirectiveSubsection(StringRef, SMLoc) { 663251662Sdim const MCExpr *Subsection = 0; 664251662Sdim if (getLexer().isNot(AsmToken::EndOfStatement)) { 665251662Sdim if (getParser().parseExpression(Subsection)) 666251662Sdim return true; 667251662Sdim } 668251662Sdim 669251662Sdim if (getLexer().isNot(AsmToken::EndOfStatement)) 670251662Sdim return TokError("unexpected token in directive"); 671251662Sdim 672251662Sdim getStreamer().SubSection(Subsection); 673251662Sdim return false; 674251662Sdim} 675251662Sdim 676210006Srdivackynamespace llvm { 677210006Srdivacky 678210006SrdivackyMCAsmParserExtension *createELFAsmParser() { 679210006Srdivacky return new ELFAsmParser; 680210006Srdivacky} 681210006Srdivacky 682210006Srdivacky} 683