LCOV - code coverage report
Current view: top level - lib/MC/MCParser - ELFAsmParser.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 320 371 86.3 %
Date: 2018-07-13 00:08:38 Functions: 28 29 96.6 %
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       16164 : 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      421174 :     getParser().addDirectiveHandler(Directive, Handler);
      44             :   }
      45             : 
      46             :   bool ParseSectionSwitch(StringRef Section, unsigned Type, unsigned Flags,
      47             :                           SectionKind Kind);
      48             : 
      49             : public:
      50       16199 :   ELFAsmParser() { BracketExpressionsSupported = true; }
      51             : 
      52       16199 :   void Initialize(MCAsmParser &Parser) override {
      53             :     // Call the base implementation.
      54       16199 :     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       16199 :   }
      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         298 :     return ParseSectionSwitch(".data", ELF::SHT_PROGBITS,
      95             :                               ELF::SHF_WRITE | ELF::SHF_ALLOC,
      96         298 :                               SectionKind::getData());
      97             :   }
      98             :   bool ParseSectionDirectiveText(StringRef, SMLoc) {
      99       10990 :     return ParseSectionSwitch(".text", ELF::SHT_PROGBITS,
     100             :                               ELF::SHF_EXECINSTR |
     101       10990 :                               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          15 :     return ParseSectionSwitch(".rodata", ELF::SHT_PROGBITS,
     110             :                               ELF::SHF_ALLOC,
     111          15 :                               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         396 : bool ELFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
     171         396 :   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         396 :   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     180             :     while (true) {
     181         402 :       StringRef Name;
     182             : 
     183         402 :       if (getParser().parseIdentifier(Name))
     184           0 :         return TokError("expected identifier in directive");
     185             : 
     186         402 :       MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     187             : 
     188         402 :       getStreamer().EmitSymbolAttribute(Sym, Attr);
     189             : 
     190         402 :       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       11353 : bool ELFAsmParser::ParseSectionSwitch(StringRef Section, unsigned Type,
     204             :                                       unsigned Flags, SectionKind Kind) {
     205       11353 :   const MCExpr *Subsection = nullptr;
     206       11353 :   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     207           1 :     if (getParser().parseExpression(Subsection))
     208             :       return true;
     209             :   }
     210             :   Lex();
     211             : 
     212       22706 :   getStreamer().SwitchSection(getContext().getELFSection(Section, Type, Flags),
     213       11353 :                               Subsection);
     214             : 
     215             :   return false;
     216             : }
     217             : 
     218         667 : bool ELFAsmParser::ParseDirectiveSize(StringRef, SMLoc) {
     219         667 :   StringRef Name;
     220         667 :   if (getParser().parseIdentifier(Name))
     221           0 :     return TokError("expected identifier in directive");
     222         667 :   MCSymbolELF *Sym = cast<MCSymbolELF>(getContext().getOrCreateSymbol(Name));
     223             : 
     224         667 :   if (getLexer().isNot(AsmToken::Comma))
     225           0 :     return TokError("unexpected token in directive");
     226             :   Lex();
     227             : 
     228             :   const MCExpr *Expr;
     229         667 :   if (getParser().parseExpression(Expr))
     230             :     return true;
     231             : 
     232         665 :   if (getLexer().isNot(AsmToken::EndOfStatement))
     233           0 :     return TokError("unexpected token in directive");
     234             :   Lex();
     235             : 
     236         665 :   getStreamer().emitELFSize(Sym, Expr);
     237             :   return false;
     238             : }
     239             : 
     240      331531 : bool ELFAsmParser::ParseSectionName(StringRef &SectionName) {
     241             :   // A section name can contain -, so we cannot just use
     242             :   // parseIdentifier.
     243      331531 :   SMLoc FirstLoc = getLexer().getLoc();
     244             :   unsigned Size = 0;
     245             : 
     246      331531 :   if (getLexer().is(AsmToken::String)) {
     247         119 :     SectionName = getTok().getIdentifier();
     248             :     Lex();
     249         119 :     return false;
     250             :   }
     251             : 
     252     1657288 :   while (!getParser().hasPendingError()) {
     253      662900 :     SMLoc PrevLoc = getLexer().getLoc();
     254     1256074 :     if (getLexer().is(AsmToken::Comma) ||
     255             :       getLexer().is(AsmToken::EndOfStatement))
     256             :       break;
     257             :     
     258             :     unsigned CurSize;
     259      331489 :     if (getLexer().is(AsmToken::String)) {
     260           3 :       CurSize = getTok().getIdentifier().size() + 2;
     261             :       Lex();
     262      331486 :     } else if (getLexer().is(AsmToken::Identifier)) {
     263      331422 :       CurSize = getTok().getIdentifier().size();
     264             :       Lex();
     265             :     } else {
     266          64 :       CurSize = getTok().getString().size();
     267             :       Lex();
     268             :     }
     269      331489 :     Size += CurSize;
     270      662978 :     SectionName = StringRef(FirstLoc.getPointer(), Size);
     271             : 
     272             :     // Make sure the following token is adjacent.
     273      994467 :     if (PrevLoc.getPointer() + CurSize != getTok().getLoc().getPointer())
     274             :       break;
     275             :   }
     276      331412 :   if (Size == 0)
     277             :     return true;
     278             : 
     279      331412 :   return false;
     280             : }
     281             : 
     282       69816 : 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       69816 :   if (!flagsStr.getAsInteger(0, flags))
     287             :     return flags;
     288             : 
     289      216410 :   for (char i : flagsStr) {
     290       73298 :     switch (i) {
     291       69228 :     case 'a':
     292       69228 :       flags |= ELF::SHF_ALLOC;
     293       69228 :       break;
     294           7 :     case 'e':
     295           7 :       flags |= ELF::SHF_EXCLUDE;
     296           7 :       break;
     297        3183 :     case 'x':
     298        3183 :       flags |= ELF::SHF_EXECINSTR;
     299        3183 :       break;
     300         357 :     case 'w':
     301         357 :       flags |= ELF::SHF_WRITE;
     302         357 :       break;
     303          29 :     case 'o':
     304          29 :       flags |= ELF::SHF_LINK_ORDER;
     305          29 :       break;
     306         171 :     case 'M':
     307         171 :       flags |= ELF::SHF_MERGE;
     308         171 :       break;
     309         124 :     case 'S':
     310         124 :       flags |= ELF::SHF_STRINGS;
     311         124 :       break;
     312         139 :     case 'T':
     313         139 :       flags |= ELF::SHF_TLS;
     314         139 :       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          57 :     case 'G':
     325          57 :       flags |= ELF::SHF_GROUP;
     326          57 :       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             : bool ELFAsmParser::ParseDirectiveSection(StringRef, SMLoc loc) {
     386      331521 :   return ParseSectionArguments(/*IsPush=*/false, loc);
     387             : }
     388             : 
     389       69827 : bool ELFAsmParser::maybeParseSectionType(StringRef &TypeName) {
     390             :   MCAsmLexer &L = getLexer();
     391       69827 :   if (L.isNot(AsmToken::Comma))
     392             :     return false;
     393             :   Lex();
     394        1937 :   if (L.isNot(AsmToken::At) && L.isNot(AsmToken::Percent) &&
     395             :       L.isNot(AsmToken::String)) {
     396           1 :     if (L.getAllowAtInIdentifier())
     397           0 :       return TokError("expected '@<type>', '%<type>' or \"<type>\"");
     398             :     else
     399           1 :       return TokError("expected '%<type>' or \"<type>\"");
     400             :   }
     401        1936 :   if (!L.is(AsmToken::String))
     402             :     Lex();
     403        1936 :   if (L.is(AsmToken::Integer)) {
     404          13 :     TypeName = getTok().getString();
     405             :     Lex();
     406        1923 :   } else if (getParser().parseIdentifier(TypeName))
     407           0 :     return TokError("expected identifier in directive");
     408             :   return false;
     409             : }
     410             : 
     411         171 : bool ELFAsmParser::parseMergeSize(int64_t &Size) {
     412         171 :   if (getLexer().isNot(AsmToken::Comma))
     413           0 :     return TokError("expected the entry size");
     414             :   Lex();
     415         171 :   if (getParser().parseAbsoluteExpression(Size))
     416             :     return true;
     417         171 :   if (Size <= 0)
     418           0 :     return TokError("entry size must be positive");
     419             :   return false;
     420             : }
     421             : 
     422          57 : bool ELFAsmParser::parseGroup(StringRef &GroupName) {
     423             :   MCAsmLexer &L = getLexer();
     424          57 :   if (L.isNot(AsmToken::Comma))
     425           0 :     return TokError("expected group name");
     426             :   Lex();
     427          57 :   if (L.is(AsmToken::Integer)) {
     428           1 :     GroupName = getTok().getString();
     429             :     Lex();
     430          56 :   } else if (getParser().parseIdentifier(GroupName)) {
     431           1 :     return TokError("invalid group name");
     432             :   }
     433          56 :   if (L.is(AsmToken::Comma)) {
     434             :     Lex();
     435          56 :     StringRef Linkage;
     436          56 :     if (getParser().parseIdentifier(Linkage))
     437           1 :       return TokError("invalid linkage");
     438             :     if (Linkage != "comdat")
     439           0 :       return TokError("Linkage must be 'comdat'");
     440             :   }
     441             :   return false;
     442             : }
     443             : 
     444          29 : bool ELFAsmParser::parseMetadataSym(MCSymbolELF *&Associated) {
     445             :   MCAsmLexer &L = getLexer();
     446          29 :   if (L.isNot(AsmToken::Comma))
     447           1 :     return TokError("expected metadata symbol");
     448             :   Lex();
     449          28 :   StringRef Name;
     450          28 :   if (getParser().parseIdentifier(Name))
     451           1 :     return TokError("invalid metadata symbol");
     452          54 :   Associated = dyn_cast_or_null<MCSymbolELF>(getContext().lookupSymbol(Name));
     453          27 :   if (!Associated || !Associated->isInSection())
     454           3 :     return TokError("symbol is not in a section: " + Name);
     455             :   return false;
     456             : }
     457             : 
     458       69819 : bool ELFAsmParser::maybeParseUniqueID(int64_t &UniqueID) {
     459             :   MCAsmLexer &L = getLexer();
     460       69819 :   if (L.isNot(AsmToken::Comma))
     461             :     return false;
     462             :   Lex();
     463          87 :   StringRef UniqueStr;
     464          87 :   if (getParser().parseIdentifier(UniqueStr))
     465           0 :     return TokError("expected identifier in directive");
     466             :   if (UniqueStr != "unique")
     467           0 :     return TokError("expected 'unique'");
     468          87 :   if (L.isNot(AsmToken::Comma))
     469           1 :     return TokError("expected commma");
     470             :   Lex();
     471          86 :   if (getParser().parseAbsoluteExpression(UniqueID))
     472             :     return true;
     473          85 :   if (UniqueID < 0)
     474           1 :     return TokError("unique id must be positive");
     475          84 :   if (!isUInt<32>(UniqueID) || UniqueID == ~0U)
     476           1 :     return TokError("unique id is too large");
     477             :   return false;
     478             : }
     479             : 
     480     4956995 : static bool hasPrefix(StringRef SectionName, StringRef Prefix) {
     481     4956995 :   return SectionName.startswith(Prefix) || SectionName == Prefix.drop_back();
     482             : }
     483             : 
     484             : // Return a set of section flags based on the section name that can then
     485             : // be augmented later, otherwise return 0 if we don't have any reasonable
     486             : // defaults.
     487      331531 : static unsigned defaultSectionFlags(StringRef SectionName) {
     488             : 
     489      331531 :   if (hasPrefix(SectionName, ".rodata.cst"))
     490             :     return ELF::SHF_ALLOC | ELF::SHF_MERGE;
     491             : 
     492      332174 :   if (hasPrefix(SectionName, ".rodata.") || SectionName == ".rodata1")
     493             :     return ELF::SHF_ALLOC;
     494             : 
     495      331420 :   if (SectionName == ".fini" || SectionName == ".init" ||
     496      662852 :       hasPrefix(SectionName, ".text."))
     497             :     return ELF::SHF_ALLOC | ELF::SHF_EXECINSTR;
     498             : 
     499      992197 :   if (hasPrefix(SectionName, ".data.") || SectionName == ".data1" ||
     500      992121 :       hasPrefix(SectionName, ".bss.") ||
     501      992087 :       hasPrefix(SectionName, ".init_array.") ||
     502     1322813 :       hasPrefix(SectionName, ".fini_array.") ||
     503      661402 :       hasPrefix(SectionName, ".preinit_array."))
     504             :     return ELF::SHF_ALLOC | ELF::SHF_WRITE;
     505             : 
     506      661229 :   if (hasPrefix(SectionName, ".tdata.") || hasPrefix(SectionName, ".tbss."))
     507             :     return ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_TLS;
     508             : 
     509             :   return 0;
     510             : }
     511             : 
     512      331531 : bool ELFAsmParser::ParseSectionArguments(bool IsPush, SMLoc loc) {
     513      331531 :   StringRef SectionName;
     514             : 
     515      331531 :   if (ParseSectionName(SectionName))
     516           0 :     return TokError("expected identifier in directive");
     517             : 
     518      331531 :   StringRef TypeName;
     519      331531 :   int64_t Size = 0;
     520      331531 :   StringRef GroupName;
     521      331531 :   const MCExpr *Subsection = nullptr;
     522      331531 :   bool UseLastGroup = false;
     523      331531 :   MCSymbolELF *Associated = nullptr;
     524      331531 :   int64_t UniqueID = ~0;
     525             : 
     526             :   // Set the default section flags first in case no others are given.
     527      331531 :   unsigned Flags = defaultSectionFlags(SectionName);
     528             : 
     529      331531 :   if (getLexer().is(AsmToken::Comma)) {
     530             :     Lex();
     531             : 
     532       69829 :     if (IsPush && getLexer().isNot(AsmToken::String)) {
     533           1 :       if (getParser().parseExpression(Subsection))
     534             :         return true;
     535           1 :       if (getLexer().isNot(AsmToken::Comma))
     536             :         goto EndStmt;
     537             :       Lex();
     538             :     }
     539             : 
     540             :     unsigned extraFlags;
     541             : 
     542       69827 :     if (getLexer().isNot(AsmToken::String)) {
     543          11 :       if (!getContext().getAsmInfo()->usesSunStyleELFSectionSwitchSyntax()
     544          22 :           || getLexer().isNot(AsmToken::Hash))
     545           0 :         return TokError("expected string in directive");
     546          11 :       extraFlags = parseSunStyleSectionFlags();
     547             :     } else {
     548       69816 :       StringRef FlagsStr = getTok().getStringContents();
     549             :       Lex();
     550       69816 :       extraFlags = parseSectionFlags(FlagsStr, &UseLastGroup);
     551             :     }
     552             : 
     553       69827 :     if (extraFlags == -1U)
     554           0 :       return TokError("unknown flag");
     555             : 
     556             :     // If we found additional section flags on a known section then give a
     557             :     // warning.
     558       69827 :     if (Flags && Flags != extraFlags)
     559         114 :       Warning(loc, "setting incorrect section attributes for " + SectionName);
     560             : 
     561       69827 :     Flags |= extraFlags;
     562             : 
     563       69827 :     bool Mergeable = Flags & ELF::SHF_MERGE;
     564       69827 :     bool Group = Flags & ELF::SHF_GROUP;
     565       69827 :     if (Group && UseLastGroup)
     566           0 :       return TokError("Section cannot specifiy a group name while also acting "
     567             :                       "as a member of the last group");
     568             : 
     569       69827 :     if (maybeParseSectionType(TypeName))
     570             :       return true;
     571             : 
     572             :     MCAsmLexer &L = getLexer();
     573       69826 :     if (TypeName.empty()) {
     574       67890 :       if (Mergeable)
     575           0 :         return TokError("Mergeable section must specify the type");
     576       67890 :       if (Group)
     577           0 :         return TokError("Group section must specify the type");
     578       67890 :       if (L.isNot(AsmToken::EndOfStatement))
     579           0 :         return TokError("unexpected token in directive");
     580             :     }
     581             : 
     582       69826 :     if (Mergeable)
     583         171 :       if (parseMergeSize(Size))
     584             :         return true;
     585       69826 :     if (Group)
     586          57 :       if (parseGroup(GroupName))
     587             :         return true;
     588       69824 :     if (Flags & ELF::SHF_LINK_ORDER)
     589          29 :       if (parseMetadataSym(Associated))
     590             :         return true;
     591       69819 :     if (maybeParseUniqueID(UniqueID))
     592             :       return true;
     593             :   }
     594             : 
     595      593223 : EndStmt:
     596      331519 :   if (getLexer().isNot(AsmToken::EndOfStatement))
     597           2 :     return TokError("unexpected token in directive");
     598             :   Lex();
     599             : 
     600             :   unsigned Type = ELF::SHT_PROGBITS;
     601             : 
     602      331517 :   if (TypeName.empty()) {
     603             :     if (SectionName.startswith(".note"))
     604             :       Type = ELF::SHT_NOTE;
     605      329585 :     else if (hasPrefix(SectionName, ".init_array."))
     606             :       Type = ELF::SHT_INIT_ARRAY;
     607      329582 :     else if (hasPrefix(SectionName, ".bss."))
     608             :       Type = ELF::SHT_NOBITS;
     609      329574 :     else if (hasPrefix(SectionName, ".tbss."))
     610             :       Type = ELF::SHT_NOBITS;
     611      329562 :     else if (hasPrefix(SectionName, ".fini_array."))
     612             :       Type = ELF::SHT_FINI_ARRAY;
     613      329561 :     else if (hasPrefix(SectionName, ".preinit_array."))
     614             :       Type = ELF::SHT_PREINIT_ARRAY;
     615             :   } else {
     616             :     if (TypeName == "init_array")
     617             :       Type = ELF::SHT_INIT_ARRAY;
     618             :     else if (TypeName == "fini_array")
     619             :       Type = ELF::SHT_FINI_ARRAY;
     620             :     else if (TypeName == "preinit_array")
     621             :       Type = ELF::SHT_PREINIT_ARRAY;
     622             :     else if (TypeName == "nobits")
     623             :       Type = ELF::SHT_NOBITS;
     624             :     else if (TypeName == "progbits")
     625             :       Type = ELF::SHT_PROGBITS;
     626             :     else if (TypeName == "note")
     627             :       Type = ELF::SHT_NOTE;
     628             :     else if (TypeName == "unwind")
     629             :       Type = ELF::SHT_X86_64_UNWIND;
     630             :     else if (TypeName == "llvm_odrtab")
     631             :       Type = ELF::SHT_LLVM_ODRTAB;
     632             :     else if (TypeName == "llvm_linker_options")
     633             :       Type = ELF::SHT_LLVM_LINKER_OPTIONS;
     634             :     else if (TypeName == "llvm_call_graph_profile")
     635             :       Type = ELF::SHT_LLVM_CALL_GRAPH_PROFILE;
     636             :     else if (TypeName.getAsInteger(0, Type))
     637           0 :       return TokError("unknown section type");
     638             :   }
     639             : 
     640      331517 :   if (UseLastGroup) {
     641             :     MCSectionSubPair CurrentSection = getStreamer().getCurrentSection();
     642             :     if (const MCSectionELF *Section =
     643             :             cast_or_null<MCSectionELF>(CurrentSection.first))
     644           1 :       if (const MCSymbol *Group = Section->getGroup()) {
     645           1 :         GroupName = Group->getName();
     646           1 :         Flags |= ELF::SHF_GROUP;
     647             :       }
     648             :   }
     649             : 
     650             :   MCSection *ELFSection =
     651      994551 :       getContext().getELFSection(SectionName, Type, Flags, Size, GroupName,
     652      331517 :                                  UniqueID, Associated);
     653      331517 :   getStreamer().SwitchSection(ELFSection, Subsection);
     654             : 
     655      331515 :   if (getContext().getGenDwarfForAssembly()) {
     656             :     bool InsertResult = getContext().addGenDwarfSection(ELFSection);
     657          13 :     if (InsertResult) {
     658           7 :       if (getContext().getDwarfVersion() <= 2)
     659           2 :         Warning(loc, "DWARF2 only supports one section per compilation unit");
     660             : 
     661           7 :       if (!ELFSection->getBeginSymbol()) {
     662           0 :         MCSymbol *SectionStartSymbol = getContext().createTempSymbol();
     663           0 :         getStreamer().EmitLabel(SectionStartSymbol);
     664             :         ELFSection->setBeginSymbol(SectionStartSymbol);
     665             :       }
     666             :     }
     667             :   }
     668             : 
     669             :   return false;
     670             : }
     671             : 
     672          43 : bool ELFAsmParser::ParseDirectivePrevious(StringRef DirName, SMLoc) {
     673             :   MCSectionSubPair PreviousSection = getStreamer().getPreviousSection();
     674          43 :   if (PreviousSection.first == nullptr)
     675           0 :       return TokError(".previous without corresponding .section");
     676          43 :   getStreamer().SwitchSection(PreviousSection.first, PreviousSection.second);
     677             : 
     678             :   return false;
     679             : }
     680             : 
     681        2133 : static MCSymbolAttr MCAttrForString(StringRef Type) {
     682        2133 :   return StringSwitch<MCSymbolAttr>(Type)
     683             :           .Cases("STT_FUNC", "function", MCSA_ELF_TypeFunction)
     684             :           .Cases("STT_OBJECT", "object", MCSA_ELF_TypeObject)
     685             :           .Cases("STT_TLS", "tls_object", MCSA_ELF_TypeTLS)
     686             :           .Cases("STT_COMMON", "common", MCSA_ELF_TypeCommon)
     687             :           .Cases("STT_NOTYPE", "notype", MCSA_ELF_TypeNoType)
     688             :           .Cases("STT_GNU_IFUNC", "gnu_indirect_function",
     689             :                  MCSA_ELF_TypeIndFunction)
     690             :           .Case("gnu_unique_object", MCSA_ELF_TypeGnuUniqueObject)
     691        2133 :           .Default(MCSA_Invalid);
     692             : }
     693             : 
     694             : /// ParseDirectiveELFType
     695             : ///  ::= .type identifier , STT_<TYPE_IN_UPPER_CASE>
     696             : ///  ::= .type identifier , #attribute
     697             : ///  ::= .type identifier , @attribute
     698             : ///  ::= .type identifier , %attribute
     699             : ///  ::= .type identifier , "attribute"
     700        2147 : bool ELFAsmParser::ParseDirectiveType(StringRef, SMLoc) {
     701        2147 :   StringRef Name;
     702        2147 :   if (getParser().parseIdentifier(Name))
     703           0 :     return TokError("expected identifier in directive");
     704             : 
     705             :   // Handle the identifier as the key symbol.
     706        2147 :   MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     707             : 
     708             :   // NOTE the comma is optional in all cases.  It is only documented as being
     709             :   // optional in the first case, however, GAS will silently treat the comma as
     710             :   // optional in all cases.  Furthermore, although the documentation states that
     711             :   // the first form only accepts STT_<TYPE_IN_UPPER_CASE>, in reality, GAS
     712             :   // accepts both the upper case name as well as the lower case aliases.
     713        2147 :   if (getLexer().is(AsmToken::Comma))
     714             :     Lex();
     715             : 
     716        2102 :   if (getLexer().isNot(AsmToken::Identifier) &&
     717        2097 :       getLexer().isNot(AsmToken::Hash) &&
     718        3305 :       getLexer().isNot(AsmToken::Percent) &&
     719             :       getLexer().isNot(AsmToken::String)) {
     720        1155 :     if (!getLexer().getAllowAtInIdentifier())
     721          12 :       return TokError("expected STT_<TYPE_IN_UPPER_CASE>, '#<type>', "
     722             :                       "'%<type>' or \"<type>\"");
     723        1143 :     else if (getLexer().isNot(AsmToken::At))
     724           1 :       return TokError("expected STT_<TYPE_IN_UPPER_CASE>, '#<type>', '@<type>', "
     725             :                       "'%<type>' or \"<type>\"");
     726             :   }
     727             : 
     728        4265 :   if (getLexer().isNot(AsmToken::String) &&
     729             :       getLexer().isNot(AsmToken::Identifier))
     730             :     Lex();
     731             : 
     732        2134 :   SMLoc TypeLoc = getLexer().getLoc();
     733             : 
     734        2134 :   StringRef Type;
     735        2134 :   if (getParser().parseIdentifier(Type))
     736           1 :     return TokError("expected symbol type in directive");
     737             : 
     738        2133 :   MCSymbolAttr Attr = MCAttrForString(Type);
     739        2133 :   if (Attr == MCSA_Invalid)
     740           2 :     return Error(TypeLoc, "unsupported attribute in '.type' directive");
     741             : 
     742        2131 :   if (getLexer().isNot(AsmToken::EndOfStatement))
     743           0 :     return TokError("unexpected token in '.type' directive");
     744             :   Lex();
     745             : 
     746        2131 :   getStreamer().EmitSymbolAttribute(Sym, Attr);
     747             : 
     748             :   return false;
     749             : }
     750             : 
     751             : /// ParseDirectiveIdent
     752             : ///  ::= .ident string
     753          38 : bool ELFAsmParser::ParseDirectiveIdent(StringRef, SMLoc) {
     754          38 :   if (getLexer().isNot(AsmToken::String))
     755           0 :     return TokError("unexpected token in '.ident' directive");
     756             : 
     757          38 :   StringRef Data = getTok().getIdentifier();
     758             : 
     759             :   Lex();
     760             : 
     761          38 :   if (getLexer().isNot(AsmToken::EndOfStatement))
     762           0 :     return TokError("unexpected token in '.ident' directive");
     763             :   Lex();
     764             : 
     765          38 :   getStreamer().EmitIdent(Data);
     766             :   return false;
     767             : }
     768             : 
     769             : /// ParseDirectiveSymver
     770             : ///  ::= .symver foo, bar2@zed
     771         146 : bool ELFAsmParser::ParseDirectiveSymver(StringRef, SMLoc) {
     772         146 :   StringRef Name;
     773         146 :   if (getParser().parseIdentifier(Name))
     774           0 :     return TokError("expected identifier in directive");
     775             : 
     776         146 :   if (getLexer().isNot(AsmToken::Comma))
     777           0 :     return TokError("expected a comma");
     778             : 
     779             :   // ARM assembly uses @ for a comment...
     780             :   // except when parsing the second parameter of the .symver directive.
     781             :   // Force the next symbol to allow @ in the identifier, which is
     782             :   // required for this directive and then reset it to its initial state.
     783         146 :   const bool AllowAtInIdentifier = getLexer().getAllowAtInIdentifier();
     784             :   getLexer().setAllowAtInIdentifier(true);
     785             :   Lex();
     786             :   getLexer().setAllowAtInIdentifier(AllowAtInIdentifier);
     787             : 
     788         146 :   StringRef AliasName;
     789         146 :   if (getParser().parseIdentifier(AliasName))
     790           0 :     return TokError("expected identifier in directive");
     791             : 
     792         146 :   if (AliasName.find('@') == StringRef::npos)
     793           0 :     return TokError("expected a '@' in the name");
     794             : 
     795         146 :   MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     796         146 :   getStreamer().emitELFSymverDirective(AliasName, Sym);
     797             :   return false;
     798             : }
     799             : 
     800             : /// ParseDirectiveVersion
     801             : ///  ::= .version string
     802           2 : bool ELFAsmParser::ParseDirectiveVersion(StringRef, SMLoc) {
     803           2 :   if (getLexer().isNot(AsmToken::String))
     804           0 :     return TokError("unexpected token in '.version' directive");
     805             : 
     806           2 :   StringRef Data = getTok().getIdentifier();
     807             : 
     808             :   Lex();
     809             : 
     810           2 :   MCSection *Note = getContext().getELFSection(".note", ELF::SHT_NOTE, 0);
     811             : 
     812           2 :   getStreamer().PushSection();
     813           2 :   getStreamer().SwitchSection(Note);
     814           2 :   getStreamer().EmitIntValue(Data.size()+1, 4); // namesz.
     815           2 :   getStreamer().EmitIntValue(0, 4);             // descsz = 0 (no description).
     816           2 :   getStreamer().EmitIntValue(1, 4);             // type = NT_VERSION.
     817           2 :   getStreamer().EmitBytes(Data);                // name.
     818           2 :   getStreamer().EmitIntValue(0, 1);             // terminate the string.
     819           2 :   getStreamer().EmitValueToAlignment(4);        // ensure 4 byte alignment.
     820           2 :   getStreamer().PopSection();
     821             :   return false;
     822             : }
     823             : 
     824             : /// ParseDirectiveWeakref
     825             : ///  ::= .weakref foo, bar
     826          20 : bool ELFAsmParser::ParseDirectiveWeakref(StringRef, SMLoc) {
     827             :   // FIXME: Share code with the other alias building directives.
     828             : 
     829          20 :   StringRef AliasName;
     830          20 :   if (getParser().parseIdentifier(AliasName))
     831           0 :     return TokError("expected identifier in directive");
     832             : 
     833          20 :   if (getLexer().isNot(AsmToken::Comma))
     834           0 :     return TokError("expected a comma");
     835             : 
     836             :   Lex();
     837             : 
     838          20 :   StringRef Name;
     839          20 :   if (getParser().parseIdentifier(Name))
     840           0 :     return TokError("expected identifier in directive");
     841             : 
     842          20 :   MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName);
     843             : 
     844          20 :   MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     845             : 
     846          20 :   getStreamer().EmitWeakReference(Alias, Sym);
     847             :   return false;
     848             : }
     849             : 
     850           4 : bool ELFAsmParser::ParseDirectiveSubsection(StringRef, SMLoc) {
     851           4 :   const MCExpr *Subsection = nullptr;
     852           4 :   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     853           3 :     if (getParser().parseExpression(Subsection))
     854             :      return true;
     855             :   }
     856             : 
     857           4 :   if (getLexer().isNot(AsmToken::EndOfStatement))
     858           0 :     return TokError("unexpected token in directive");
     859             : 
     860             :   Lex();
     861             : 
     862           4 :   getStreamer().SubSection(Subsection);
     863             :   return false;
     864             : }
     865             : 
     866             : /// ParseDirectiveCGProfile
     867             : ///  ::= .cg_profile identifier, identifier, <number>
     868           8 : bool ELFAsmParser::ParseDirectiveCGProfile(StringRef, SMLoc) {
     869           8 :   StringRef From;
     870           8 :   SMLoc FromLoc = getLexer().getLoc();
     871           8 :   if (getParser().parseIdentifier(From))
     872           0 :     return TokError("expected identifier in directive");
     873             : 
     874           8 :   if (getLexer().isNot(AsmToken::Comma))
     875           0 :     return TokError("expected a comma");
     876             :   Lex();
     877             : 
     878           8 :   StringRef To;
     879           8 :   SMLoc ToLoc = getLexer().getLoc();
     880           8 :   if (getParser().parseIdentifier(To))
     881           0 :     return TokError("expected identifier in directive");
     882             : 
     883           8 :   if (getLexer().isNot(AsmToken::Comma))
     884           0 :     return TokError("expected a comma");
     885             :   Lex();
     886             : 
     887             :   int64_t Count;
     888          16 :   if (getParser().parseIntToken(
     889             :           Count, "expected integer count in '.cg_profile' directive"))
     890             :     return true;
     891             : 
     892           8 :   if (getLexer().isNot(AsmToken::EndOfStatement))
     893           0 :     return TokError("unexpected token in directive");
     894             : 
     895           8 :   MCSymbol *FromSym = getContext().getOrCreateSymbol(From);
     896           8 :   MCSymbol *ToSym = getContext().getOrCreateSymbol(To);
     897             : 
     898          24 :   getStreamer().emitCGProfileEntry(
     899             :       MCSymbolRefExpr::create(FromSym, MCSymbolRefExpr::VK_None, getContext(),
     900             :                               FromLoc),
     901             :       MCSymbolRefExpr::create(ToSym, MCSymbolRefExpr::VK_None, getContext(),
     902             :                               ToLoc),
     903           8 :       Count);
     904             :   return false;
     905             : }
     906             : 
     907             : namespace llvm {
     908             : 
     909       16199 : MCAsmParserExtension *createELFAsmParser() {
     910       32398 :   return new ELFAsmParser;
     911             : }
     912             : 
     913             : } // end namespace llvm

Generated by: LCOV version 1.13