LCOV - code coverage report
Current view: top level - lib/MC/MCParser - ELFAsmParser.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 316 367 86.1 %
Date: 2018-06-17 00:07:59 Functions: 27 28 96.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- ELFAsmParser.cpp - ELF 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/ADT/StringRef.h"
      11             : #include "llvm/ADT/StringSwitch.h"
      12             : #include "llvm/BinaryFormat/ELF.h"
      13             : #include "llvm/MC/MCAsmInfo.h"
      14             : #include "llvm/MC/MCContext.h"
      15             : #include "llvm/MC/MCDirectives.h"
      16             : #include "llvm/MC/MCExpr.h"
      17             : #include "llvm/MC/MCParser/MCAsmLexer.h"
      18             : #include "llvm/MC/MCParser/MCAsmParser.h"
      19             : #include "llvm/MC/MCParser/MCAsmParserExtension.h"
      20             : #include "llvm/MC/MCSection.h"
      21             : #include "llvm/MC/MCSectionELF.h"
      22             : #include "llvm/MC/MCStreamer.h"
      23             : #include "llvm/MC/MCSymbol.h"
      24             : #include "llvm/MC/MCSymbolELF.h"
      25             : #include "llvm/MC/SectionKind.h"
      26             : #include "llvm/Support/Casting.h"
      27             : #include "llvm/Support/MathExtras.h"
      28             : #include "llvm/Support/SMLoc.h"
      29             : #include <cassert>
      30             : #include <cstdint>
      31             : #include <utility>
      32             : 
      33             : using namespace llvm;
      34             : 
      35             : namespace {
      36             : 
      37       15474 : class ELFAsmParser : public MCAsmParserExtension {
      38             :   template<bool (ELFAsmParser::*HandlerMethod)(StringRef, SMLoc)>
      39             :   void addDirectiveHandler(StringRef Directive) {
      40             :     MCAsmParser::ExtensionDirectiveHandler Handler = std::make_pair(
      41             :         this, HandleDirective<ELFAsmParser, HandlerMethod>);
      42             : 
      43      403104 :     getParser().addDirectiveHandler(Directive, Handler);
      44             :   }
      45             : 
      46             :   bool ParseSectionSwitch(StringRef Section, unsigned Type, unsigned Flags,
      47             :                           SectionKind Kind);
      48             : 
      49             : public:
      50       15504 :   ELFAsmParser() { BracketExpressionsSupported = true; }
      51             : 
      52       15504 :   void Initialize(MCAsmParser &Parser) override {
      53             :     // Call the base implementation.
      54       15504 :     this->MCAsmParserExtension::Initialize(Parser);
      55             : 
      56             :     addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveData>(".data");
      57             :     addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveText>(".text");
      58             :     addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveBSS>(".bss");
      59             :     addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveRoData>(".rodata");
      60             :     addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveTData>(".tdata");
      61             :     addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveTBSS>(".tbss");
      62             :     addDirectiveHandler<
      63             :       &ELFAsmParser::ParseSectionDirectiveDataRel>(".data.rel");
      64             :     addDirectiveHandler<
      65             :       &ELFAsmParser::ParseSectionDirectiveDataRelRo>(".data.rel.ro");
      66             :     addDirectiveHandler<
      67             :       &ELFAsmParser::ParseSectionDirectiveEhFrame>(".eh_frame");
      68             :     addDirectiveHandler<&ELFAsmParser::ParseDirectiveSection>(".section");
      69             :     addDirectiveHandler<
      70             :       &ELFAsmParser::ParseDirectivePushSection>(".pushsection");
      71             :     addDirectiveHandler<&ELFAsmParser::ParseDirectivePopSection>(".popsection");
      72             :     addDirectiveHandler<&ELFAsmParser::ParseDirectiveSize>(".size");
      73             :     addDirectiveHandler<&ELFAsmParser::ParseDirectivePrevious>(".previous");
      74             :     addDirectiveHandler<&ELFAsmParser::ParseDirectiveType>(".type");
      75             :     addDirectiveHandler<&ELFAsmParser::ParseDirectiveIdent>(".ident");
      76             :     addDirectiveHandler<&ELFAsmParser::ParseDirectiveSymver>(".symver");
      77             :     addDirectiveHandler<&ELFAsmParser::ParseDirectiveVersion>(".version");
      78             :     addDirectiveHandler<&ELFAsmParser::ParseDirectiveWeakref>(".weakref");
      79             :     addDirectiveHandler<&ELFAsmParser::ParseDirectiveSymbolAttribute>(".weak");
      80             :     addDirectiveHandler<&ELFAsmParser::ParseDirectiveSymbolAttribute>(".local");
      81             :     addDirectiveHandler<
      82             :       &ELFAsmParser::ParseDirectiveSymbolAttribute>(".protected");
      83             :     addDirectiveHandler<
      84             :       &ELFAsmParser::ParseDirectiveSymbolAttribute>(".internal");
      85             :     addDirectiveHandler<
      86             :       &ELFAsmParser::ParseDirectiveSymbolAttribute>(".hidden");
      87             :     addDirectiveHandler<&ELFAsmParser::ParseDirectiveSubsection>(".subsection");
      88             :     addDirectiveHandler<&ELFAsmParser::ParseDirectiveCGProfile>(".cg_profile");
      89       15504 :   }
      90             : 
      91             :   // FIXME: Part of this logic is duplicated in the MCELFStreamer. What is
      92             :   // the best way for us to get access to it?
      93             :   bool ParseSectionDirectiveData(StringRef, SMLoc) {
      94         302 :     return ParseSectionSwitch(".data", ELF::SHT_PROGBITS,
      95             :                               ELF::SHF_WRITE | ELF::SHF_ALLOC,
      96         302 :                               SectionKind::getData());
      97             :   }
      98             :   bool ParseSectionDirectiveText(StringRef, SMLoc) {
      99       10988 :     return ParseSectionSwitch(".text", ELF::SHT_PROGBITS,
     100             :                               ELF::SHF_EXECINSTR |
     101       10988 :                               ELF::SHF_ALLOC, SectionKind::getText());
     102             :   }
     103             :   bool ParseSectionDirectiveBSS(StringRef, SMLoc) {
     104          43 :     return ParseSectionSwitch(".bss", ELF::SHT_NOBITS,
     105             :                               ELF::SHF_WRITE |
     106          43 :                               ELF::SHF_ALLOC, SectionKind::getBSS());
     107             :   }
     108             :   bool ParseSectionDirectiveRoData(StringRef, SMLoc) {
     109          12 :     return ParseSectionSwitch(".rodata", ELF::SHT_PROGBITS,
     110             :                               ELF::SHF_ALLOC,
     111          12 :                               SectionKind::getReadOnly());
     112             :   }
     113             :   bool ParseSectionDirectiveTData(StringRef, SMLoc) {
     114           1 :     return ParseSectionSwitch(".tdata", ELF::SHT_PROGBITS,
     115             :                               ELF::SHF_ALLOC |
     116             :                               ELF::SHF_TLS | ELF::SHF_WRITE,
     117           1 :                               SectionKind::getThreadData());
     118             :   }
     119             :   bool ParseSectionDirectiveTBSS(StringRef, SMLoc) {
     120           3 :     return ParseSectionSwitch(".tbss", ELF::SHT_NOBITS,
     121             :                               ELF::SHF_ALLOC |
     122             :                               ELF::SHF_TLS | ELF::SHF_WRITE,
     123           3 :                               SectionKind::getThreadBSS());
     124             :   }
     125             :   bool ParseSectionDirectiveDataRel(StringRef, SMLoc) {
     126           1 :     return ParseSectionSwitch(".data.rel", ELF::SHT_PROGBITS,
     127             :                               ELF::SHF_ALLOC | ELF::SHF_WRITE,
     128           1 :                               SectionKind::getData());
     129             :   }
     130             :   bool ParseSectionDirectiveDataRelRo(StringRef, SMLoc) {
     131           1 :     return ParseSectionSwitch(".data.rel.ro", ELF::SHT_PROGBITS,
     132             :                               ELF::SHF_ALLOC |
     133             :                               ELF::SHF_WRITE,
     134           1 :                               SectionKind::getReadOnlyWithRel());
     135             :   }
     136             :   bool ParseSectionDirectiveEhFrame(StringRef, SMLoc) {
     137           1 :     return ParseSectionSwitch(".eh_frame", ELF::SHT_PROGBITS,
     138             :                               ELF::SHF_ALLOC | ELF::SHF_WRITE,
     139           1 :                               SectionKind::getData());
     140             :   }
     141             :   bool ParseDirectivePushSection(StringRef, SMLoc);
     142             :   bool ParseDirectivePopSection(StringRef, SMLoc);
     143             :   bool ParseDirectiveSection(StringRef, SMLoc);
     144             :   bool ParseDirectiveSize(StringRef, SMLoc);
     145             :   bool ParseDirectivePrevious(StringRef, SMLoc);
     146             :   bool ParseDirectiveType(StringRef, SMLoc);
     147             :   bool ParseDirectiveIdent(StringRef, SMLoc);
     148             :   bool ParseDirectiveSymver(StringRef, SMLoc);
     149             :   bool ParseDirectiveVersion(StringRef, SMLoc);
     150             :   bool ParseDirectiveWeakref(StringRef, SMLoc);
     151             :   bool ParseDirectiveSymbolAttribute(StringRef, SMLoc);
     152             :   bool ParseDirectiveSubsection(StringRef, SMLoc);
     153             :   bool ParseDirectiveCGProfile(StringRef, SMLoc);
     154             : 
     155             : private:
     156             :   bool ParseSectionName(StringRef &SectionName);
     157             :   bool ParseSectionArguments(bool IsPush, SMLoc loc);
     158             :   unsigned parseSunStyleSectionFlags();
     159             :   bool maybeParseSectionType(StringRef &TypeName);
     160             :   bool parseMergeSize(int64_t &Size);
     161             :   bool parseGroup(StringRef &GroupName);
     162             :   bool parseMetadataSym(MCSymbolELF *&Associated);
     163             :   bool maybeParseUniqueID(int64_t &UniqueID);
     164             : };
     165             : 
     166             : } // end anonymous namespace
     167             : 
     168             : /// ParseDirectiveSymbolAttribute
     169             : ///  ::= { ".local", ".weak", ... } [ identifier ( , identifier )* ]
     170         400 : bool ELFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
     171         400 :   MCSymbolAttr Attr = StringSwitch<MCSymbolAttr>(Directive)
     172             :     .Case(".weak", MCSA_Weak)
     173             :     .Case(".local", MCSA_Local)
     174             :     .Case(".hidden", MCSA_Hidden)
     175             :     .Case(".internal", MCSA_Internal)
     176             :     .Case(".protected", MCSA_Protected)
     177             :     .Default(MCSA_Invalid);
     178             :   assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!");
     179         400 :   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     180             :     while (true) {
     181         406 :       StringRef Name;
     182             : 
     183         406 :       if (getParser().parseIdentifier(Name))
     184           0 :         return TokError("expected identifier in directive");
     185             : 
     186         406 :       MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     187             : 
     188         406 :       getStreamer().EmitSymbolAttribute(Sym, Attr);
     189             : 
     190         406 :       if (getLexer().is(AsmToken::EndOfStatement))
     191             :         break;
     192             : 
     193           7 :       if (getLexer().isNot(AsmToken::Comma))
     194           0 :         return TokError("unexpected token in directive");
     195             :       Lex();
     196             :     }
     197             :   }
     198             : 
     199             :   Lex();
     200             :   return false;
     201             : }
     202             : 
     203       11352 : bool ELFAsmParser::ParseSectionSwitch(StringRef Section, unsigned Type,
     204             :                                       unsigned Flags, SectionKind Kind) {
     205       11352 :   const MCExpr *Subsection = nullptr;
     206       11352 :   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     207           1 :     if (getParser().parseExpression(Subsection))
     208             :       return true;
     209             :   }
     210             :   Lex();
     211             : 
     212       22704 :   getStreamer().SwitchSection(getContext().getELFSection(Section, Type, Flags),
     213       11352 :                               Subsection);
     214             : 
     215             :   return false;
     216             : }
     217             : 
     218         659 : bool ELFAsmParser::ParseDirectiveSize(StringRef, SMLoc) {
     219         659 :   StringRef Name;
     220         659 :   if (getParser().parseIdentifier(Name))
     221           0 :     return TokError("expected identifier in directive");
     222         659 :   MCSymbolELF *Sym = cast<MCSymbolELF>(getContext().getOrCreateSymbol(Name));
     223             : 
     224         659 :   if (getLexer().isNot(AsmToken::Comma))
     225           0 :     return TokError("unexpected token in directive");
     226             :   Lex();
     227             : 
     228             :   const MCExpr *Expr;
     229         659 :   if (getParser().parseExpression(Expr))
     230             :     return true;
     231             : 
     232         657 :   if (getLexer().isNot(AsmToken::EndOfStatement))
     233           0 :     return TokError("unexpected token in directive");
     234             :   Lex();
     235             : 
     236         657 :   getStreamer().emitELFSize(Sym, Expr);
     237             :   return false;
     238             : }
     239             : 
     240      329426 : bool ELFAsmParser::ParseSectionName(StringRef &SectionName) {
     241             :   // A section name can contain -, so we cannot just use
     242             :   // parseIdentifier.
     243      329426 :   SMLoc FirstLoc = getLexer().getLoc();
     244             :   unsigned Size = 0;
     245             : 
     246      329426 :   if (getLexer().is(AsmToken::String)) {
     247         118 :     SectionName = getTok().getIdentifier();
     248             :     Lex();
     249         118 :     return false;
     250             :   }
     251             : 
     252     1646768 :   while (!getParser().hasPendingError()) {
     253      658692 :     SMLoc PrevLoc = getLexer().getLoc();
     254     1249738 :     if (getLexer().is(AsmToken::Comma) ||
     255             :       getLexer().is(AsmToken::EndOfStatement))
     256             :       break;
     257             :     
     258             :     unsigned CurSize;
     259      329385 :     if (getLexer().is(AsmToken::String)) {
     260           3 :       CurSize = getTok().getIdentifier().size() + 2;
     261             :       Lex();
     262      329382 :     } else if (getLexer().is(AsmToken::Identifier)) {
     263      329318 :       CurSize = getTok().getIdentifier().size();
     264             :       Lex();
     265             :     } else {
     266          64 :       CurSize = getTok().getString().size();
     267             :       Lex();
     268             :     }
     269      329385 :     Size += CurSize;
     270      658770 :     SectionName = StringRef(FirstLoc.getPointer(), Size);
     271             : 
     272             :     // Make sure the following token is adjacent.
     273      988155 :     if (PrevLoc.getPointer() + CurSize != getTok().getLoc().getPointer())
     274             :       break;
     275             :   }
     276      329308 :   if (Size == 0)
     277             :     return true;
     278             : 
     279      329308 :   return false;
     280             : }
     281             : 
     282       67735 : static unsigned parseSectionFlags(StringRef flagsStr, bool *UseLastGroup) {
     283             :   unsigned flags = 0;
     284             : 
     285             :   // If a valid numerical value is set for the section flag, use it verbatim
     286       67735 :   if (!flagsStr.getAsInteger(0, flags))
     287             :     return flags;
     288             : 
     289      205999 :   for (char i : flagsStr) {
     290       69133 :     switch (i) {
     291       67147 :     case 'a':
     292       67147 :       flags |= ELF::SHF_ALLOC;
     293       67147 :       break;
     294           7 :     case 'e':
     295           7 :       flags |= ELF::SHF_EXCLUDE;
     296           7 :       break;
     297        1118 :     case 'x':
     298        1118 :       flags |= ELF::SHF_EXECINSTR;
     299        1118 :       break;
     300         349 :     case 'w':
     301         349 :       flags |= ELF::SHF_WRITE;
     302         349 :       break;
     303          29 :     case 'o':
     304          29 :       flags |= ELF::SHF_LINK_ORDER;
     305          29 :       break;
     306         169 :     case 'M':
     307         169 :       flags |= ELF::SHF_MERGE;
     308         169 :       break;
     309         123 :     case 'S':
     310         123 :       flags |= ELF::SHF_STRINGS;
     311         123 :       break;
     312         133 :     case 'T':
     313         133 :       flags |= ELF::SHF_TLS;
     314         133 :       break;
     315           0 :     case 'c':
     316           0 :       flags |= ELF::XCORE_SHF_CP_SECTION;
     317           0 :       break;
     318           0 :     case 'd':
     319           0 :       flags |= ELF::XCORE_SHF_DP_SECTION;
     320           0 :       break;
     321           2 :     case 'y':
     322           2 :       flags |= ELF::SHF_ARM_PURECODE;
     323           2 :       break;
     324          55 :     case 'G':
     325          55 :       flags |= ELF::SHF_GROUP;
     326          55 :       break;
     327           1 :     case '?':
     328           1 :       *UseLastGroup = true;
     329           1 :       break;
     330             :     default:
     331             :       return -1U;
     332             :     }
     333             :   }
     334             : 
     335             :   return flags;
     336             : }
     337             : 
     338          11 : unsigned ELFAsmParser::parseSunStyleSectionFlags() {
     339             :   unsigned flags = 0;
     340          43 :   while (getLexer().is(AsmToken::Hash)) {
     341             :     Lex(); // Eat the #.
     342             : 
     343          27 :     if (!getLexer().is(AsmToken::Identifier))
     344             :       return -1U;
     345             : 
     346             :     StringRef flagId = getTok().getIdentifier();
     347             :     if (flagId == "alloc")
     348          11 :       flags |= ELF::SHF_ALLOC;
     349             :     else if (flagId == "execinstr")
     350           0 :       flags |= ELF::SHF_EXECINSTR;
     351             :     else if (flagId == "write")
     352          10 :       flags |= ELF::SHF_WRITE;
     353             :     else if (flagId == "tls")
     354           6 :       flags |= ELF::SHF_TLS;
     355             :     else
     356             :       return -1U;
     357             : 
     358             :     Lex(); // Eat the flag.
     359             : 
     360          27 :     if (!getLexer().is(AsmToken::Comma))
     361             :         break;
     362             :     Lex(); // Eat the comma.
     363             :   }
     364             :   return flags;
     365             : }
     366             : 
     367             : 
     368          10 : bool ELFAsmParser::ParseDirectivePushSection(StringRef s, SMLoc loc) {
     369          10 :   getStreamer().PushSection();
     370             : 
     371          10 :   if (ParseSectionArguments(/*IsPush=*/true, loc)) {
     372           0 :     getStreamer().PopSection();
     373             :     return true;
     374             :   }
     375             : 
     376             :   return false;
     377             : }
     378             : 
     379          10 : bool ELFAsmParser::ParseDirectivePopSection(StringRef, SMLoc) {
     380          10 :   if (!getStreamer().PopSection())
     381           0 :     return TokError(".popsection without corresponding .pushsection");
     382             :   return false;
     383             : }
     384             : 
     385             : // FIXME: This is a work in progress.
     386             : bool ELFAsmParser::ParseDirectiveSection(StringRef, SMLoc loc) {
     387      329416 :   return ParseSectionArguments(/*IsPush=*/false, loc);
     388             : }
     389             : 
     390       67746 : bool ELFAsmParser::maybeParseSectionType(StringRef &TypeName) {
     391             :   MCAsmLexer &L = getLexer();
     392       67746 :   if (L.isNot(AsmToken::Comma))
     393             :     return false;
     394             :   Lex();
     395        1923 :   if (L.isNot(AsmToken::At) && L.isNot(AsmToken::Percent) &&
     396             :       L.isNot(AsmToken::String)) {
     397           1 :     if (L.getAllowAtInIdentifier())
     398           0 :       return TokError("expected '@<type>', '%<type>' or \"<type>\"");
     399             :     else
     400           1 :       return TokError("expected '%<type>' or \"<type>\"");
     401             :   }
     402        1922 :   if (!L.is(AsmToken::String))
     403             :     Lex();
     404        1922 :   if (L.is(AsmToken::Integer)) {
     405          13 :     TypeName = getTok().getString();
     406             :     Lex();
     407        1909 :   } else if (getParser().parseIdentifier(TypeName))
     408           0 :     return TokError("expected identifier in directive");
     409             :   return false;
     410             : }
     411             : 
     412         169 : bool ELFAsmParser::parseMergeSize(int64_t &Size) {
     413         169 :   if (getLexer().isNot(AsmToken::Comma))
     414           0 :     return TokError("expected the entry size");
     415             :   Lex();
     416         169 :   if (getParser().parseAbsoluteExpression(Size))
     417             :     return true;
     418         169 :   if (Size <= 0)
     419           0 :     return TokError("entry size must be positive");
     420             :   return false;
     421             : }
     422             : 
     423          55 : bool ELFAsmParser::parseGroup(StringRef &GroupName) {
     424             :   MCAsmLexer &L = getLexer();
     425          55 :   if (L.isNot(AsmToken::Comma))
     426           0 :     return TokError("expected group name");
     427             :   Lex();
     428          55 :   if (L.is(AsmToken::Integer)) {
     429           1 :     GroupName = getTok().getString();
     430             :     Lex();
     431          54 :   } else if (getParser().parseIdentifier(GroupName)) {
     432           1 :     return TokError("invalid group name");
     433             :   }
     434          54 :   if (L.is(AsmToken::Comma)) {
     435             :     Lex();
     436          54 :     StringRef Linkage;
     437          54 :     if (getParser().parseIdentifier(Linkage))
     438           1 :       return TokError("invalid linkage");
     439             :     if (Linkage != "comdat")
     440           0 :       return TokError("Linkage must be 'comdat'");
     441             :   }
     442             :   return false;
     443             : }
     444             : 
     445          29 : bool ELFAsmParser::parseMetadataSym(MCSymbolELF *&Associated) {
     446             :   MCAsmLexer &L = getLexer();
     447          29 :   if (L.isNot(AsmToken::Comma))
     448           1 :     return TokError("expected metadata symbol");
     449             :   Lex();
     450          28 :   StringRef Name;
     451          28 :   if (getParser().parseIdentifier(Name))
     452           1 :     return TokError("invalid metadata symbol");
     453          54 :   Associated = dyn_cast_or_null<MCSymbolELF>(getContext().lookupSymbol(Name));
     454          27 :   if (!Associated || !Associated->isInSection())
     455           3 :     return TokError("symbol is not in a section: " + Name);
     456             :   return false;
     457             : }
     458             : 
     459       67738 : bool ELFAsmParser::maybeParseUniqueID(int64_t &UniqueID) {
     460             :   MCAsmLexer &L = getLexer();
     461       67738 :   if (L.isNot(AsmToken::Comma))
     462             :     return false;
     463             :   Lex();
     464          87 :   StringRef UniqueStr;
     465          87 :   if (getParser().parseIdentifier(UniqueStr))
     466           0 :     return TokError("expected identifier in directive");
     467             :   if (UniqueStr != "unique")
     468           0 :     return TokError("expected 'unique'");
     469          87 :   if (L.isNot(AsmToken::Comma))
     470           1 :     return TokError("expected commma");
     471             :   Lex();
     472          86 :   if (getParser().parseAbsoluteExpression(UniqueID))
     473             :     return true;
     474          85 :   if (UniqueID < 0)
     475           1 :     return TokError("unique id must be positive");
     476          84 :   if (!isUInt<32>(UniqueID) || UniqueID == ~0U)
     477           1 :     return TokError("unique id is too large");
     478             :   return false;
     479             : }
     480             : 
     481     4596300 : static bool hasPrefix(StringRef SectionName, StringRef Prefix) {
     482     4596300 :   return SectionName.startswith(Prefix) || SectionName == Prefix.drop_back();
     483             : }
     484             : 
     485      329426 : bool ELFAsmParser::ParseSectionArguments(bool IsPush, SMLoc loc) {
     486      329426 :   StringRef SectionName;
     487             : 
     488      329426 :   if (ParseSectionName(SectionName))
     489           0 :     return TokError("expected identifier in directive");
     490             : 
     491      329426 :   StringRef TypeName;
     492      329426 :   int64_t Size = 0;
     493      329426 :   StringRef GroupName;
     494             :   unsigned Flags = 0;
     495      329426 :   const MCExpr *Subsection = nullptr;
     496      329426 :   bool UseLastGroup = false;
     497      329426 :   MCSymbolELF *Associated = nullptr;
     498      329426 :   int64_t UniqueID = ~0;
     499             : 
     500             :   // Set the defaults first.
     501      330077 :   if (hasPrefix(SectionName, ".rodata.") || SectionName == ".rodata1")
     502             :     Flags |= ELF::SHF_ALLOC;
     503      329320 :   else if (SectionName == ".fini" || SectionName == ".init" ||
     504      658652 :            hasPrefix(SectionName, ".text."))
     505             :     Flags |= ELF::SHF_ALLOC | ELF::SHF_EXECINSTR;
     506      985971 :   else if (hasPrefix(SectionName, ".data.") || SectionName == ".data1" ||
     507      985897 :            hasPrefix(SectionName, ".bss.") ||
     508      985863 :            hasPrefix(SectionName, ".init_array.") ||
     509     1314513 :            hasPrefix(SectionName, ".fini_array.") ||
     510      657252 :            hasPrefix(SectionName, ".preinit_array."))
     511             :     Flags |= ELF::SHF_ALLOC | ELF::SHF_WRITE;
     512      985659 :   else if (hasPrefix(SectionName, ".tdata.") ||
     513      657087 :            hasPrefix(SectionName, ".tbss."))
     514             :     Flags |= ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_TLS;
     515             : 
     516      329426 :   if (getLexer().is(AsmToken::Comma)) {
     517             :     Lex();
     518             : 
     519       67748 :     if (IsPush && getLexer().isNot(AsmToken::String)) {
     520           1 :       if (getParser().parseExpression(Subsection))
     521             :         return true;
     522           1 :       if (getLexer().isNot(AsmToken::Comma))
     523             :         goto EndStmt;
     524             :       Lex();
     525             :     }
     526             : 
     527             :     unsigned extraFlags;
     528             : 
     529       67746 :     if (getLexer().isNot(AsmToken::String)) {
     530          11 :       if (!getContext().getAsmInfo()->usesSunStyleELFSectionSwitchSyntax()
     531          22 :           || getLexer().isNot(AsmToken::Hash))
     532           0 :         return TokError("expected string in directive");
     533          11 :       extraFlags = parseSunStyleSectionFlags();
     534             :     } else {
     535       67735 :       StringRef FlagsStr = getTok().getStringContents();
     536             :       Lex();
     537       67735 :       extraFlags = parseSectionFlags(FlagsStr, &UseLastGroup);
     538             :     }
     539             : 
     540       67746 :     if (extraFlags == -1U)
     541           0 :       return TokError("unknown flag");
     542       67746 :     Flags |= extraFlags;
     543             : 
     544       67746 :     bool Mergeable = Flags & ELF::SHF_MERGE;
     545       67746 :     bool Group = Flags & ELF::SHF_GROUP;
     546       67746 :     if (Group && UseLastGroup)
     547           0 :       return TokError("Section cannot specifiy a group name while also acting "
     548             :                       "as a member of the last group");
     549             : 
     550       67746 :     if (maybeParseSectionType(TypeName))
     551             :       return true;
     552             : 
     553             :     MCAsmLexer &L = getLexer();
     554       67745 :     if (TypeName.empty()) {
     555       65823 :       if (Mergeable)
     556           0 :         return TokError("Mergeable section must specify the type");
     557       65823 :       if (Group)
     558           0 :         return TokError("Group section must specify the type");
     559       65823 :       if (L.isNot(AsmToken::EndOfStatement))
     560           0 :         return TokError("unexpected token in directive");
     561             :     }
     562             : 
     563       67745 :     if (Mergeable)
     564         169 :       if (parseMergeSize(Size))
     565             :         return true;
     566       67745 :     if (Group)
     567          55 :       if (parseGroup(GroupName))
     568             :         return true;
     569       67743 :     if (Flags & ELF::SHF_LINK_ORDER)
     570          29 :       if (parseMetadataSym(Associated))
     571             :         return true;
     572       67738 :     if (maybeParseUniqueID(UniqueID))
     573             :       return true;
     574             :   }
     575             : 
     576      591094 : EndStmt:
     577      329414 :   if (getLexer().isNot(AsmToken::EndOfStatement))
     578           2 :     return TokError("unexpected token in directive");
     579             :   Lex();
     580             : 
     581             :   unsigned Type = ELF::SHT_PROGBITS;
     582             : 
     583      329412 :   if (TypeName.empty()) {
     584             :     if (SectionName.startswith(".note"))
     585             :       Type = ELF::SHT_NOTE;
     586      327494 :     else if (hasPrefix(SectionName, ".init_array."))
     587             :       Type = ELF::SHT_INIT_ARRAY;
     588      327491 :     else if (hasPrefix(SectionName, ".bss."))
     589             :       Type = ELF::SHT_NOBITS;
     590      327483 :     else if (hasPrefix(SectionName, ".tbss."))
     591             :       Type = ELF::SHT_NOBITS;
     592      327471 :     else if (hasPrefix(SectionName, ".fini_array."))
     593             :       Type = ELF::SHT_FINI_ARRAY;
     594      327470 :     else if (hasPrefix(SectionName, ".preinit_array."))
     595             :       Type = ELF::SHT_PREINIT_ARRAY;
     596             :   } else {
     597             :     if (TypeName == "init_array")
     598             :       Type = ELF::SHT_INIT_ARRAY;
     599             :     else if (TypeName == "fini_array")
     600             :       Type = ELF::SHT_FINI_ARRAY;
     601             :     else if (TypeName == "preinit_array")
     602             :       Type = ELF::SHT_PREINIT_ARRAY;
     603             :     else if (TypeName == "nobits")
     604             :       Type = ELF::SHT_NOBITS;
     605             :     else if (TypeName == "progbits")
     606             :       Type = ELF::SHT_PROGBITS;
     607             :     else if (TypeName == "note")
     608             :       Type = ELF::SHT_NOTE;
     609             :     else if (TypeName == "unwind")
     610             :       Type = ELF::SHT_X86_64_UNWIND;
     611             :     else if (TypeName == "llvm_odrtab")
     612             :       Type = ELF::SHT_LLVM_ODRTAB;
     613             :     else if (TypeName == "llvm_linker_options")
     614             :       Type = ELF::SHT_LLVM_LINKER_OPTIONS;
     615             :     else if (TypeName == "llvm_call_graph_profile")
     616             :       Type = ELF::SHT_LLVM_CALL_GRAPH_PROFILE;
     617             :     else if (TypeName.getAsInteger(0, Type))
     618           0 :       return TokError("unknown section type");
     619             :   }
     620             : 
     621      329412 :   if (UseLastGroup) {
     622             :     MCSectionSubPair CurrentSection = getStreamer().getCurrentSection();
     623             :     if (const MCSectionELF *Section =
     624             :             cast_or_null<MCSectionELF>(CurrentSection.first))
     625           1 :       if (const MCSymbol *Group = Section->getGroup()) {
     626           1 :         GroupName = Group->getName();
     627           1 :         Flags |= ELF::SHF_GROUP;
     628             :       }
     629             :   }
     630             : 
     631             :   MCSection *ELFSection =
     632      988236 :       getContext().getELFSection(SectionName, Type, Flags, Size, GroupName,
     633      329412 :                                  UniqueID, Associated);
     634      329412 :   getStreamer().SwitchSection(ELFSection, Subsection);
     635             : 
     636      329410 :   if (getContext().getGenDwarfForAssembly()) {
     637             :     bool InsertResult = getContext().addGenDwarfSection(ELFSection);
     638          13 :     if (InsertResult) {
     639           7 :       if (getContext().getDwarfVersion() <= 2)
     640           2 :         Warning(loc, "DWARF2 only supports one section per compilation unit");
     641             : 
     642           7 :       if (!ELFSection->getBeginSymbol()) {
     643           0 :         MCSymbol *SectionStartSymbol = getContext().createTempSymbol();
     644           0 :         getStreamer().EmitLabel(SectionStartSymbol);
     645             :         ELFSection->setBeginSymbol(SectionStartSymbol);
     646             :       }
     647             :     }
     648             :   }
     649             : 
     650             :   return false;
     651             : }
     652             : 
     653          43 : bool ELFAsmParser::ParseDirectivePrevious(StringRef DirName, SMLoc) {
     654             :   MCSectionSubPair PreviousSection = getStreamer().getPreviousSection();
     655          43 :   if (PreviousSection.first == nullptr)
     656           0 :       return TokError(".previous without corresponding .section");
     657          43 :   getStreamer().SwitchSection(PreviousSection.first, PreviousSection.second);
     658             : 
     659             :   return false;
     660             : }
     661             : 
     662        2110 : static MCSymbolAttr MCAttrForString(StringRef Type) {
     663        2110 :   return StringSwitch<MCSymbolAttr>(Type)
     664             :           .Cases("STT_FUNC", "function", MCSA_ELF_TypeFunction)
     665             :           .Cases("STT_OBJECT", "object", MCSA_ELF_TypeObject)
     666             :           .Cases("STT_TLS", "tls_object", MCSA_ELF_TypeTLS)
     667             :           .Cases("STT_COMMON", "common", MCSA_ELF_TypeCommon)
     668             :           .Cases("STT_NOTYPE", "notype", MCSA_ELF_TypeNoType)
     669             :           .Cases("STT_GNU_IFUNC", "gnu_indirect_function",
     670             :                  MCSA_ELF_TypeIndFunction)
     671             :           .Case("gnu_unique_object", MCSA_ELF_TypeGnuUniqueObject)
     672        2110 :           .Default(MCSA_Invalid);
     673             : }
     674             : 
     675             : /// ParseDirectiveELFType
     676             : ///  ::= .type identifier , STT_<TYPE_IN_UPPER_CASE>
     677             : ///  ::= .type identifier , #attribute
     678             : ///  ::= .type identifier , @attribute
     679             : ///  ::= .type identifier , %attribute
     680             : ///  ::= .type identifier , "attribute"
     681        2124 : bool ELFAsmParser::ParseDirectiveType(StringRef, SMLoc) {
     682        2124 :   StringRef Name;
     683        2124 :   if (getParser().parseIdentifier(Name))
     684           0 :     return TokError("expected identifier in directive");
     685             : 
     686             :   // Handle the identifier as the key symbol.
     687        2124 :   MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     688             : 
     689             :   // NOTE the comma is optional in all cases.  It is only documented as being
     690             :   // optional in the first case, however, GAS will silently treat the comma as
     691             :   // optional in all cases.  Furthermore, although the documentation states that
     692             :   // the first form only accepts STT_<TYPE_IN_UPPER_CASE>, in reality, GAS
     693             :   // accepts both the upper case name as well as the lower case aliases.
     694        2124 :   if (getLexer().is(AsmToken::Comma))
     695             :     Lex();
     696             : 
     697        2079 :   if (getLexer().isNot(AsmToken::Identifier) &&
     698        2074 :       getLexer().isNot(AsmToken::Hash) &&
     699        3263 :       getLexer().isNot(AsmToken::Percent) &&
     700             :       getLexer().isNot(AsmToken::String)) {
     701        1136 :     if (!getLexer().getAllowAtInIdentifier())
     702          12 :       return TokError("expected STT_<TYPE_IN_UPPER_CASE>, '#<type>', "
     703             :                       "'%<type>' or \"<type>\"");
     704        1124 :     else if (getLexer().isNot(AsmToken::At))
     705           1 :       return TokError("expected STT_<TYPE_IN_UPPER_CASE>, '#<type>', '@<type>', "
     706             :                       "'%<type>' or \"<type>\"");
     707             :   }
     708             : 
     709        4219 :   if (getLexer().isNot(AsmToken::String) &&
     710             :       getLexer().isNot(AsmToken::Identifier))
     711             :     Lex();
     712             : 
     713        2111 :   SMLoc TypeLoc = getLexer().getLoc();
     714             : 
     715        2111 :   StringRef Type;
     716        2111 :   if (getParser().parseIdentifier(Type))
     717           1 :     return TokError("expected symbol type in directive");
     718             : 
     719        2110 :   MCSymbolAttr Attr = MCAttrForString(Type);
     720        2110 :   if (Attr == MCSA_Invalid)
     721           2 :     return Error(TypeLoc, "unsupported attribute in '.type' directive");
     722             : 
     723        2108 :   if (getLexer().isNot(AsmToken::EndOfStatement))
     724           0 :     return TokError("unexpected token in '.type' directive");
     725             :   Lex();
     726             : 
     727        2108 :   getStreamer().EmitSymbolAttribute(Sym, Attr);
     728             : 
     729             :   return false;
     730             : }
     731             : 
     732             : /// ParseDirectiveIdent
     733             : ///  ::= .ident string
     734          38 : bool ELFAsmParser::ParseDirectiveIdent(StringRef, SMLoc) {
     735          38 :   if (getLexer().isNot(AsmToken::String))
     736           0 :     return TokError("unexpected token in '.ident' directive");
     737             : 
     738          38 :   StringRef Data = getTok().getIdentifier();
     739             : 
     740             :   Lex();
     741             : 
     742          38 :   if (getLexer().isNot(AsmToken::EndOfStatement))
     743           0 :     return TokError("unexpected token in '.ident' directive");
     744             :   Lex();
     745             : 
     746          38 :   getStreamer().EmitIdent(Data);
     747             :   return false;
     748             : }
     749             : 
     750             : /// ParseDirectiveSymver
     751             : ///  ::= .symver foo, bar2@zed
     752         146 : bool ELFAsmParser::ParseDirectiveSymver(StringRef, SMLoc) {
     753         146 :   StringRef Name;
     754         146 :   if (getParser().parseIdentifier(Name))
     755           0 :     return TokError("expected identifier in directive");
     756             : 
     757         146 :   if (getLexer().isNot(AsmToken::Comma))
     758           0 :     return TokError("expected a comma");
     759             : 
     760             :   // ARM assembly uses @ for a comment...
     761             :   // except when parsing the second parameter of the .symver directive.
     762             :   // Force the next symbol to allow @ in the identifier, which is
     763             :   // required for this directive and then reset it to its initial state.
     764         146 :   const bool AllowAtInIdentifier = getLexer().getAllowAtInIdentifier();
     765             :   getLexer().setAllowAtInIdentifier(true);
     766             :   Lex();
     767             :   getLexer().setAllowAtInIdentifier(AllowAtInIdentifier);
     768             : 
     769         146 :   StringRef AliasName;
     770         146 :   if (getParser().parseIdentifier(AliasName))
     771           0 :     return TokError("expected identifier in directive");
     772             : 
     773         146 :   if (AliasName.find('@') == StringRef::npos)
     774           0 :     return TokError("expected a '@' in the name");
     775             : 
     776         146 :   MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     777         146 :   getStreamer().emitELFSymverDirective(AliasName, Sym);
     778             :   return false;
     779             : }
     780             : 
     781             : /// ParseDirectiveVersion
     782             : ///  ::= .version string
     783           2 : bool ELFAsmParser::ParseDirectiveVersion(StringRef, SMLoc) {
     784           2 :   if (getLexer().isNot(AsmToken::String))
     785           0 :     return TokError("unexpected token in '.version' directive");
     786             : 
     787           2 :   StringRef Data = getTok().getIdentifier();
     788             : 
     789             :   Lex();
     790             : 
     791           2 :   MCSection *Note = getContext().getELFSection(".note", ELF::SHT_NOTE, 0);
     792             : 
     793           2 :   getStreamer().PushSection();
     794           2 :   getStreamer().SwitchSection(Note);
     795           2 :   getStreamer().EmitIntValue(Data.size()+1, 4); // namesz.
     796           2 :   getStreamer().EmitIntValue(0, 4);             // descsz = 0 (no description).
     797           2 :   getStreamer().EmitIntValue(1, 4);             // type = NT_VERSION.
     798           2 :   getStreamer().EmitBytes(Data);                // name.
     799           2 :   getStreamer().EmitIntValue(0, 1);             // terminate the string.
     800           2 :   getStreamer().EmitValueToAlignment(4);        // ensure 4 byte alignment.
     801           2 :   getStreamer().PopSection();
     802             :   return false;
     803             : }
     804             : 
     805             : /// ParseDirectiveWeakref
     806             : ///  ::= .weakref foo, bar
     807          20 : bool ELFAsmParser::ParseDirectiveWeakref(StringRef, SMLoc) {
     808             :   // FIXME: Share code with the other alias building directives.
     809             : 
     810          20 :   StringRef AliasName;
     811          20 :   if (getParser().parseIdentifier(AliasName))
     812           0 :     return TokError("expected identifier in directive");
     813             : 
     814          20 :   if (getLexer().isNot(AsmToken::Comma))
     815           0 :     return TokError("expected a comma");
     816             : 
     817             :   Lex();
     818             : 
     819          20 :   StringRef Name;
     820          20 :   if (getParser().parseIdentifier(Name))
     821           0 :     return TokError("expected identifier in directive");
     822             : 
     823          20 :   MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName);
     824             : 
     825          20 :   MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     826             : 
     827          20 :   getStreamer().EmitWeakReference(Alias, Sym);
     828             :   return false;
     829             : }
     830             : 
     831           4 : bool ELFAsmParser::ParseDirectiveSubsection(StringRef, SMLoc) {
     832           4 :   const MCExpr *Subsection = nullptr;
     833           4 :   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     834           3 :     if (getParser().parseExpression(Subsection))
     835             :      return true;
     836             :   }
     837             : 
     838           4 :   if (getLexer().isNot(AsmToken::EndOfStatement))
     839           0 :     return TokError("unexpected token in directive");
     840             : 
     841             :   Lex();
     842             : 
     843           4 :   getStreamer().SubSection(Subsection);
     844             :   return false;
     845             : }
     846             : 
     847             : /// ParseDirectiveCGProfile
     848             : ///  ::= .cg_profile identifier, identifier, <number>
     849           8 : bool ELFAsmParser::ParseDirectiveCGProfile(StringRef, SMLoc) {
     850           8 :   StringRef From;
     851           8 :   SMLoc FromLoc = getLexer().getLoc();
     852           8 :   if (getParser().parseIdentifier(From))
     853           0 :     return TokError("expected identifier in directive");
     854             : 
     855           8 :   if (getLexer().isNot(AsmToken::Comma))
     856           0 :     return TokError("expected a comma");
     857             :   Lex();
     858             : 
     859           8 :   StringRef To;
     860           8 :   SMLoc ToLoc = getLexer().getLoc();
     861           8 :   if (getParser().parseIdentifier(To))
     862           0 :     return TokError("expected identifier in directive");
     863             : 
     864           8 :   if (getLexer().isNot(AsmToken::Comma))
     865           0 :     return TokError("expected a comma");
     866             :   Lex();
     867             : 
     868             :   int64_t Count;
     869          16 :   if (getParser().parseIntToken(
     870             :           Count, "expected integer count in '.cg_profile' directive"))
     871             :     return true;
     872             : 
     873           8 :   if (getLexer().isNot(AsmToken::EndOfStatement))
     874           0 :     return TokError("unexpected token in directive");
     875             : 
     876           8 :   MCSymbol *FromSym = getContext().getOrCreateSymbol(From);
     877           8 :   MCSymbol *ToSym = getContext().getOrCreateSymbol(To);
     878             : 
     879          24 :   getStreamer().emitCGProfileEntry(
     880             :       MCSymbolRefExpr::create(FromSym, MCSymbolRefExpr::VK_None, getContext(),
     881             :                               FromLoc),
     882             :       MCSymbolRefExpr::create(ToSym, MCSymbolRefExpr::VK_None, getContext(),
     883             :                               ToLoc),
     884           8 :       Count);
     885             :   return false;
     886             : }
     887             : 
     888             : namespace llvm {
     889             : 
     890       15504 : MCAsmParserExtension *createELFAsmParser() {
     891       31008 :   return new ELFAsmParser;
     892             : }
     893             : 
     894             : } // end namespace llvm

Generated by: LCOV version 1.13