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/MC/MCParser/MCAsmParserExtension.h"
11#include "llvm/ADT/StringSwitch.h"
12#include "llvm/ADT/Twine.h"
13#include "llvm/MC/MCAsmInfo.h"
14#include "llvm/MC/MCContext.h"
15#include "llvm/MC/MCExpr.h"
16#include "llvm/MC/MCParser/MCAsmLexer.h"
17#include "llvm/MC/MCSectionELF.h"
18#include "llvm/MC/MCStreamer.h"
19#include "llvm/MC/MCSymbol.h"
20#include "llvm/Support/ELF.h"
21using namespace llvm;
22
23namespace {
24
25class ELFAsmParser : public MCAsmParserExtension {
26  template<bool (ELFAsmParser::*HandlerMethod)(StringRef, SMLoc)>
27  void addDirectiveHandler(StringRef Directive) {
28    MCAsmParser::ExtensionDirectiveHandler Handler = std::make_pair(
29        this, HandleDirective<ELFAsmParser, HandlerMethod>);
30
31    getParser().addDirectiveHandler(Directive, Handler);
32  }
33
34  bool ParseSectionSwitch(StringRef Section, unsigned Type, unsigned Flags,
35                          SectionKind Kind);
36
37public:
38  ELFAsmParser() { BracketExpressionsSupported = true; }
39
40  void Initialize(MCAsmParser &Parser) override {
41    // Call the base implementation.
42    this->MCAsmParserExtension::Initialize(Parser);
43
44    addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveData>(".data");
45    addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveText>(".text");
46    addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveBSS>(".bss");
47    addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveRoData>(".rodata");
48    addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveTData>(".tdata");
49    addDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveTBSS>(".tbss");
50    addDirectiveHandler<
51      &ELFAsmParser::ParseSectionDirectiveDataRel>(".data.rel");
52    addDirectiveHandler<
53      &ELFAsmParser::ParseSectionDirectiveDataRelRo>(".data.rel.ro");
54    addDirectiveHandler<
55      &ELFAsmParser::ParseSectionDirectiveDataRelRoLocal>(".data.rel.ro.local");
56    addDirectiveHandler<
57      &ELFAsmParser::ParseSectionDirectiveEhFrame>(".eh_frame");
58    addDirectiveHandler<&ELFAsmParser::ParseDirectiveSection>(".section");
59    addDirectiveHandler<
60      &ELFAsmParser::ParseDirectivePushSection>(".pushsection");
61    addDirectiveHandler<&ELFAsmParser::ParseDirectivePopSection>(".popsection");
62    addDirectiveHandler<&ELFAsmParser::ParseDirectiveSize>(".size");
63    addDirectiveHandler<&ELFAsmParser::ParseDirectivePrevious>(".previous");
64    addDirectiveHandler<&ELFAsmParser::ParseDirectiveType>(".type");
65    addDirectiveHandler<&ELFAsmParser::ParseDirectiveIdent>(".ident");
66    addDirectiveHandler<&ELFAsmParser::ParseDirectiveSymver>(".symver");
67    addDirectiveHandler<&ELFAsmParser::ParseDirectiveVersion>(".version");
68    addDirectiveHandler<&ELFAsmParser::ParseDirectiveWeakref>(".weakref");
69    addDirectiveHandler<&ELFAsmParser::ParseDirectiveSymbolAttribute>(".weak");
70    addDirectiveHandler<&ELFAsmParser::ParseDirectiveSymbolAttribute>(".local");
71    addDirectiveHandler<
72      &ELFAsmParser::ParseDirectiveSymbolAttribute>(".protected");
73    addDirectiveHandler<
74      &ELFAsmParser::ParseDirectiveSymbolAttribute>(".internal");
75    addDirectiveHandler<
76      &ELFAsmParser::ParseDirectiveSymbolAttribute>(".hidden");
77    addDirectiveHandler<&ELFAsmParser::ParseDirectiveSubsection>(".subsection");
78  }
79
80  // FIXME: Part of this logic is duplicated in the MCELFStreamer. What is
81  // the best way for us to get access to it?
82  bool ParseSectionDirectiveData(StringRef, SMLoc) {
83    return ParseSectionSwitch(".data", ELF::SHT_PROGBITS,
84                              ELF::SHF_WRITE |ELF::SHF_ALLOC,
85                              SectionKind::getDataRel());
86  }
87  bool ParseSectionDirectiveText(StringRef, SMLoc) {
88    return ParseSectionSwitch(".text", ELF::SHT_PROGBITS,
89                              ELF::SHF_EXECINSTR |
90                              ELF::SHF_ALLOC, SectionKind::getText());
91  }
92  bool ParseSectionDirectiveBSS(StringRef, SMLoc) {
93    return ParseSectionSwitch(".bss", ELF::SHT_NOBITS,
94                              ELF::SHF_WRITE |
95                              ELF::SHF_ALLOC, SectionKind::getBSS());
96  }
97  bool ParseSectionDirectiveRoData(StringRef, SMLoc) {
98    return ParseSectionSwitch(".rodata", ELF::SHT_PROGBITS,
99                              ELF::SHF_ALLOC,
100                              SectionKind::getReadOnly());
101  }
102  bool ParseSectionDirectiveTData(StringRef, SMLoc) {
103    return ParseSectionSwitch(".tdata", ELF::SHT_PROGBITS,
104                              ELF::SHF_ALLOC |
105                              ELF::SHF_TLS | ELF::SHF_WRITE,
106                              SectionKind::getThreadData());
107  }
108  bool ParseSectionDirectiveTBSS(StringRef, SMLoc) {
109    return ParseSectionSwitch(".tbss", ELF::SHT_NOBITS,
110                              ELF::SHF_ALLOC |
111                              ELF::SHF_TLS | ELF::SHF_WRITE,
112                              SectionKind::getThreadBSS());
113  }
114  bool ParseSectionDirectiveDataRel(StringRef, SMLoc) {
115    return ParseSectionSwitch(".data.rel", ELF::SHT_PROGBITS,
116                              ELF::SHF_ALLOC |
117                              ELF::SHF_WRITE,
118                              SectionKind::getDataRel());
119  }
120  bool ParseSectionDirectiveDataRelRo(StringRef, SMLoc) {
121    return ParseSectionSwitch(".data.rel.ro", ELF::SHT_PROGBITS,
122                              ELF::SHF_ALLOC |
123                              ELF::SHF_WRITE,
124                              SectionKind::getReadOnlyWithRel());
125  }
126  bool ParseSectionDirectiveDataRelRoLocal(StringRef, SMLoc) {
127    return ParseSectionSwitch(".data.rel.ro.local", ELF::SHT_PROGBITS,
128                              ELF::SHF_ALLOC |
129                              ELF::SHF_WRITE,
130                              SectionKind::getReadOnlyWithRelLocal());
131  }
132  bool ParseSectionDirectiveEhFrame(StringRef, SMLoc) {
133    return ParseSectionSwitch(".eh_frame", ELF::SHT_PROGBITS,
134                              ELF::SHF_ALLOC |
135                              ELF::SHF_WRITE,
136                              SectionKind::getDataRel());
137  }
138  bool ParseDirectivePushSection(StringRef, SMLoc);
139  bool ParseDirectivePopSection(StringRef, SMLoc);
140  bool ParseDirectiveSection(StringRef, SMLoc);
141  bool ParseDirectiveSize(StringRef, SMLoc);
142  bool ParseDirectivePrevious(StringRef, SMLoc);
143  bool ParseDirectiveType(StringRef, SMLoc);
144  bool ParseDirectiveIdent(StringRef, SMLoc);
145  bool ParseDirectiveSymver(StringRef, SMLoc);
146  bool ParseDirectiveVersion(StringRef, SMLoc);
147  bool ParseDirectiveWeakref(StringRef, SMLoc);
148  bool ParseDirectiveSymbolAttribute(StringRef, SMLoc);
149  bool ParseDirectiveSubsection(StringRef, SMLoc);
150
151private:
152  bool ParseSectionName(StringRef &SectionName);
153  bool ParseSectionArguments(bool IsPush, SMLoc loc);
154  unsigned parseSunStyleSectionFlags();
155};
156
157}
158
159/// ParseDirectiveSymbolAttribute
160///  ::= { ".local", ".weak", ... } [ identifier ( , identifier )* ]
161bool ELFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
162  MCSymbolAttr Attr = StringSwitch<MCSymbolAttr>(Directive)
163    .Case(".weak", MCSA_Weak)
164    .Case(".local", MCSA_Local)
165    .Case(".hidden", MCSA_Hidden)
166    .Case(".internal", MCSA_Internal)
167    .Case(".protected", MCSA_Protected)
168    .Default(MCSA_Invalid);
169  assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!");
170  if (getLexer().isNot(AsmToken::EndOfStatement)) {
171    for (;;) {
172      StringRef Name;
173
174      if (getParser().parseIdentifier(Name))
175        return TokError("expected identifier in directive");
176
177      MCSymbol *Sym = getContext().GetOrCreateSymbol(Name);
178
179      getStreamer().EmitSymbolAttribute(Sym, Attr);
180
181      if (getLexer().is(AsmToken::EndOfStatement))
182        break;
183
184      if (getLexer().isNot(AsmToken::Comma))
185        return TokError("unexpected token in directive");
186      Lex();
187    }
188  }
189
190  Lex();
191  return false;
192}
193
194bool ELFAsmParser::ParseSectionSwitch(StringRef Section, unsigned Type,
195                                      unsigned Flags, SectionKind Kind) {
196  const MCExpr *Subsection = nullptr;
197  if (getLexer().isNot(AsmToken::EndOfStatement)) {
198    if (getParser().parseExpression(Subsection))
199      return true;
200  }
201
202  getStreamer().SwitchSection(getContext().getELFSection(
203                                Section, Type, Flags, Kind),
204                              Subsection);
205
206  return false;
207}
208
209bool ELFAsmParser::ParseDirectiveSize(StringRef, SMLoc) {
210  StringRef Name;
211  if (getParser().parseIdentifier(Name))
212    return TokError("expected identifier in directive");
213  MCSymbol *Sym = getContext().GetOrCreateSymbol(Name);
214
215  if (getLexer().isNot(AsmToken::Comma))
216    return TokError("unexpected token in directive");
217  Lex();
218
219  const MCExpr *Expr;
220  if (getParser().parseExpression(Expr))
221    return true;
222
223  if (getLexer().isNot(AsmToken::EndOfStatement))
224    return TokError("unexpected token in directive");
225
226  getStreamer().EmitELFSize(Sym, Expr);
227  return false;
228}
229
230bool ELFAsmParser::ParseSectionName(StringRef &SectionName) {
231  // A section name can contain -, so we cannot just use
232  // parseIdentifier.
233  SMLoc FirstLoc = getLexer().getLoc();
234  unsigned Size = 0;
235
236  if (getLexer().is(AsmToken::String)) {
237    SectionName = getTok().getIdentifier();
238    Lex();
239    return false;
240  }
241
242  for (;;) {
243    unsigned CurSize;
244
245    SMLoc PrevLoc = getLexer().getLoc();
246    if (getLexer().is(AsmToken::Minus)) {
247      CurSize = 1;
248      Lex(); // Consume the "-".
249    } else if (getLexer().is(AsmToken::String)) {
250      CurSize = getTok().getIdentifier().size() + 2;
251      Lex();
252    } else if (getLexer().is(AsmToken::Identifier)) {
253      CurSize = getTok().getIdentifier().size();
254      Lex();
255    } else {
256      break;
257    }
258
259    Size += CurSize;
260    SectionName = StringRef(FirstLoc.getPointer(), Size);
261
262    // Make sure the following token is adjacent.
263    if (PrevLoc.getPointer() + CurSize != getTok().getLoc().getPointer())
264      break;
265  }
266  if (Size == 0)
267    return true;
268
269  return false;
270}
271
272static SectionKind computeSectionKind(unsigned Flags, unsigned ElemSize) {
273  if (Flags & ELF::SHF_EXECINSTR)
274    return SectionKind::getText();
275  if (Flags & ELF::SHF_TLS)
276    return SectionKind::getThreadData();
277  if (Flags & ELF::SHF_MERGE) {
278    if (Flags & ELF::SHF_STRINGS) {
279      switch (ElemSize) {
280      default:
281        break;
282      case 1:
283        return SectionKind::getMergeable1ByteCString();
284      case 2:
285        return SectionKind::getMergeable2ByteCString();
286      case 4:
287        return SectionKind::getMergeable4ByteCString();
288      }
289    } else {
290      switch (ElemSize) {
291      default:
292        break;
293      case 4:
294        return SectionKind::getMergeableConst4();
295      case 8:
296        return SectionKind::getMergeableConst8();
297      case 16:
298        return SectionKind::getMergeableConst16();
299      }
300    }
301  }
302
303  return SectionKind::getDataRel();
304}
305
306static unsigned parseSectionFlags(StringRef flagsStr, bool *UseLastGroup) {
307  unsigned flags = 0;
308
309  for (unsigned i = 0; i < flagsStr.size(); i++) {
310    switch (flagsStr[i]) {
311    case 'a':
312      flags |= ELF::SHF_ALLOC;
313      break;
314    case 'e':
315      flags |= ELF::SHF_EXCLUDE;
316      break;
317    case 'x':
318      flags |= ELF::SHF_EXECINSTR;
319      break;
320    case 'w':
321      flags |= ELF::SHF_WRITE;
322      break;
323    case 'M':
324      flags |= ELF::SHF_MERGE;
325      break;
326    case 'S':
327      flags |= ELF::SHF_STRINGS;
328      break;
329    case 'T':
330      flags |= ELF::SHF_TLS;
331      break;
332    case 'c':
333      flags |= ELF::XCORE_SHF_CP_SECTION;
334      break;
335    case 'd':
336      flags |= ELF::XCORE_SHF_DP_SECTION;
337      break;
338    case 'G':
339      flags |= ELF::SHF_GROUP;
340      break;
341    case '?':
342      *UseLastGroup = true;
343      break;
344    default:
345      return -1U;
346    }
347  }
348
349  return flags;
350}
351
352unsigned ELFAsmParser::parseSunStyleSectionFlags() {
353  unsigned flags = 0;
354  while (getLexer().is(AsmToken::Hash)) {
355    Lex(); // Eat the #.
356
357    if (!getLexer().is(AsmToken::Identifier))
358      return -1U;
359
360    StringRef flagId = getTok().getIdentifier();
361    if (flagId == "alloc")
362      flags |= ELF::SHF_ALLOC;
363    else if (flagId == "execinstr")
364      flags |= ELF::SHF_EXECINSTR;
365    else if (flagId == "write")
366      flags |= ELF::SHF_WRITE;
367    else if (flagId == "tls")
368      flags |= ELF::SHF_TLS;
369    else
370      return -1U;
371
372    Lex(); // Eat the flag.
373
374    if (!getLexer().is(AsmToken::Comma))
375        break;
376    Lex(); // Eat the comma.
377  }
378  return flags;
379}
380
381
382bool ELFAsmParser::ParseDirectivePushSection(StringRef s, SMLoc loc) {
383  getStreamer().PushSection();
384
385  if (ParseSectionArguments(/*IsPush=*/true, loc)) {
386    getStreamer().PopSection();
387    return true;
388  }
389
390  return false;
391}
392
393bool ELFAsmParser::ParseDirectivePopSection(StringRef, SMLoc) {
394  if (!getStreamer().PopSection())
395    return TokError(".popsection without corresponding .pushsection");
396  return false;
397}
398
399// FIXME: This is a work in progress.
400bool ELFAsmParser::ParseDirectiveSection(StringRef, SMLoc loc) {
401  return ParseSectionArguments(/*IsPush=*/false, loc);
402}
403
404bool ELFAsmParser::ParseSectionArguments(bool IsPush, SMLoc loc) {
405  StringRef SectionName;
406
407  if (ParseSectionName(SectionName))
408    return TokError("expected identifier in directive");
409
410  StringRef TypeName;
411  int64_t Size = 0;
412  StringRef GroupName;
413  unsigned Flags = 0;
414  const MCExpr *Subsection = nullptr;
415  bool UseLastGroup = false;
416
417  // Set the defaults first.
418  if (SectionName == ".fini" || SectionName == ".init" ||
419      SectionName == ".rodata")
420    Flags |= ELF::SHF_ALLOC;
421  if (SectionName == ".fini" || SectionName == ".init")
422    Flags |= ELF::SHF_EXECINSTR;
423
424  if (getLexer().is(AsmToken::Comma)) {
425    Lex();
426
427    if (IsPush && getLexer().isNot(AsmToken::String)) {
428      if (getParser().parseExpression(Subsection))
429        return true;
430      if (getLexer().isNot(AsmToken::Comma))
431        goto EndStmt;
432      Lex();
433    }
434
435    unsigned extraFlags;
436
437    if (getLexer().isNot(AsmToken::String)) {
438      if (!getContext().getAsmInfo()->usesSunStyleELFSectionSwitchSyntax()
439          || getLexer().isNot(AsmToken::Hash))
440        return TokError("expected string in directive");
441      extraFlags = parseSunStyleSectionFlags();
442    } else {
443      StringRef FlagsStr = getTok().getStringContents();
444      Lex();
445      extraFlags = parseSectionFlags(FlagsStr, &UseLastGroup);
446    }
447
448    if (extraFlags == -1U)
449      return TokError("unknown flag");
450    Flags |= extraFlags;
451
452    bool Mergeable = Flags & ELF::SHF_MERGE;
453    bool Group = Flags & ELF::SHF_GROUP;
454    if (Group && UseLastGroup)
455      return TokError("Section cannot specifiy a group name while also acting "
456                      "as a member of the last group");
457
458    if (getLexer().isNot(AsmToken::Comma)) {
459      if (Mergeable)
460        return TokError("Mergeable section must specify the type");
461      if (Group)
462        return TokError("Group section must specify the type");
463    } else {
464      Lex();
465      if (getLexer().is(AsmToken::At) || getLexer().is(AsmToken::Percent) ||
466          getLexer().is(AsmToken::String)) {
467        if (!getLexer().is(AsmToken::String))
468          Lex();
469      } else
470        return TokError("expected '@<type>', '%<type>' or \"<type>\"");
471
472      if (getParser().parseIdentifier(TypeName))
473        return TokError("expected identifier in directive");
474
475      if (Mergeable) {
476        if (getLexer().isNot(AsmToken::Comma))
477          return TokError("expected the entry size");
478        Lex();
479        if (getParser().parseAbsoluteExpression(Size))
480          return true;
481        if (Size <= 0)
482          return TokError("entry size must be positive");
483      }
484
485      if (Group) {
486        if (getLexer().isNot(AsmToken::Comma))
487          return TokError("expected group name");
488        Lex();
489        if (getParser().parseIdentifier(GroupName))
490          return true;
491        if (getLexer().is(AsmToken::Comma)) {
492          Lex();
493          StringRef Linkage;
494          if (getParser().parseIdentifier(Linkage))
495            return true;
496          if (Linkage != "comdat")
497            return TokError("Linkage must be 'comdat'");
498        }
499      }
500    }
501  }
502
503EndStmt:
504  if (getLexer().isNot(AsmToken::EndOfStatement))
505    return TokError("unexpected token in directive");
506
507  unsigned Type = ELF::SHT_PROGBITS;
508
509  if (TypeName.empty()) {
510    if (SectionName.startswith(".note"))
511      Type = ELF::SHT_NOTE;
512    else if (SectionName == ".init_array")
513      Type = ELF::SHT_INIT_ARRAY;
514    else if (SectionName == ".fini_array")
515      Type = ELF::SHT_FINI_ARRAY;
516    else if (SectionName == ".preinit_array")
517      Type = ELF::SHT_PREINIT_ARRAY;
518  } else {
519    if (TypeName == "init_array")
520      Type = ELF::SHT_INIT_ARRAY;
521    else if (TypeName == "fini_array")
522      Type = ELF::SHT_FINI_ARRAY;
523    else if (TypeName == "preinit_array")
524      Type = ELF::SHT_PREINIT_ARRAY;
525    else if (TypeName == "nobits")
526      Type = ELF::SHT_NOBITS;
527    else if (TypeName == "progbits")
528      Type = ELF::SHT_PROGBITS;
529    else if (TypeName == "note")
530      Type = ELF::SHT_NOTE;
531    else if (TypeName == "unwind")
532      Type = ELF::SHT_X86_64_UNWIND;
533    else
534      return TokError("unknown section type");
535  }
536
537  if (UseLastGroup) {
538    MCSectionSubPair CurrentSection = getStreamer().getCurrentSection();
539    if (const MCSectionELF *Section =
540            cast_or_null<MCSectionELF>(CurrentSection.first))
541      if (const MCSymbol *Group = Section->getGroup()) {
542        GroupName = Group->getName();
543        Flags |= ELF::SHF_GROUP;
544      }
545  }
546
547  SectionKind Kind = computeSectionKind(Flags, Size);
548  const MCSection *ELFSection = getContext().getELFSection(
549      SectionName, Type, Flags, Kind, Size, GroupName);
550  getStreamer().SwitchSection(ELFSection, Subsection);
551
552  if (getContext().getGenDwarfForAssembly()) {
553    auto &Sections = getContext().getGenDwarfSectionSyms();
554    auto InsertResult = Sections.insert(
555        std::make_pair(ELFSection, std::make_pair(nullptr, nullptr)));
556    if (InsertResult.second) {
557      if (getContext().getDwarfVersion() <= 2)
558        Error(loc, "DWARF2 only supports one section per compilation unit");
559
560      MCSymbol *SectionStartSymbol = getContext().CreateTempSymbol();
561      getStreamer().EmitLabel(SectionStartSymbol);
562      InsertResult.first->second.first = SectionStartSymbol;
563    }
564  }
565
566  return false;
567}
568
569bool ELFAsmParser::ParseDirectivePrevious(StringRef DirName, SMLoc) {
570  MCSectionSubPair PreviousSection = getStreamer().getPreviousSection();
571  if (PreviousSection.first == nullptr)
572      return TokError(".previous without corresponding .section");
573  getStreamer().SwitchSection(PreviousSection.first, PreviousSection.second);
574
575  return false;
576}
577
578static MCSymbolAttr MCAttrForString(StringRef Type) {
579  return StringSwitch<MCSymbolAttr>(Type)
580          .Cases("STT_FUNC", "function", MCSA_ELF_TypeFunction)
581          .Cases("STT_OBJECT", "object", MCSA_ELF_TypeObject)
582          .Cases("STT_TLS", "tls_object", MCSA_ELF_TypeTLS)
583          .Cases("STT_COMMON", "common", MCSA_ELF_TypeCommon)
584          .Cases("STT_NOTYPE", "notype", MCSA_ELF_TypeNoType)
585          .Cases("STT_GNU_IFUNC", "gnu_indirect_function",
586                 MCSA_ELF_TypeIndFunction)
587          .Case("gnu_unique_object", MCSA_ELF_TypeGnuUniqueObject)
588          .Default(MCSA_Invalid);
589}
590
591/// ParseDirectiveELFType
592///  ::= .type identifier , STT_<TYPE_IN_UPPER_CASE>
593///  ::= .type identifier , #attribute
594///  ::= .type identifier , @attribute
595///  ::= .type identifier , %attribute
596///  ::= .type identifier , "attribute"
597bool ELFAsmParser::ParseDirectiveType(StringRef, SMLoc) {
598  StringRef Name;
599  if (getParser().parseIdentifier(Name))
600    return TokError("expected identifier in directive");
601
602  // Handle the identifier as the key symbol.
603  MCSymbol *Sym = getContext().GetOrCreateSymbol(Name);
604
605  // NOTE the comma is optional in all cases.  It is only documented as being
606  // optional in the first case, however, GAS will silently treat the comma as
607  // optional in all cases.  Furthermore, although the documentation states that
608  // the first form only accepts STT_<TYPE_IN_UPPER_CASE>, in reality, GAS
609  // accepts both the upper case name as well as the lower case aliases.
610  if (getLexer().is(AsmToken::Comma))
611    Lex();
612
613  if (getLexer().isNot(AsmToken::Identifier) &&
614      getLexer().isNot(AsmToken::Hash) && getLexer().isNot(AsmToken::At) &&
615      getLexer().isNot(AsmToken::Percent) && getLexer().isNot(AsmToken::String))
616    return TokError("expected STT_<TYPE_IN_UPPER_CASE>, '#<type>', '@<type>', "
617                    "'%<type>' or \"<type>\"");
618
619  if (getLexer().isNot(AsmToken::String) &&
620      getLexer().isNot(AsmToken::Identifier))
621    Lex();
622
623  SMLoc TypeLoc = getLexer().getLoc();
624
625  StringRef Type;
626  if (getParser().parseIdentifier(Type))
627    return TokError("expected symbol type in directive");
628
629  MCSymbolAttr Attr = MCAttrForString(Type);
630  if (Attr == MCSA_Invalid)
631    return Error(TypeLoc, "unsupported attribute in '.type' directive");
632
633  if (getLexer().isNot(AsmToken::EndOfStatement))
634    return TokError("unexpected token in '.type' directive");
635  Lex();
636
637  getStreamer().EmitSymbolAttribute(Sym, Attr);
638
639  return false;
640}
641
642/// ParseDirectiveIdent
643///  ::= .ident string
644bool ELFAsmParser::ParseDirectiveIdent(StringRef, SMLoc) {
645  if (getLexer().isNot(AsmToken::String))
646    return TokError("unexpected token in '.ident' directive");
647
648  StringRef Data = getTok().getIdentifier();
649
650  Lex();
651
652  getStreamer().EmitIdent(Data);
653  return false;
654}
655
656/// ParseDirectiveSymver
657///  ::= .symver foo, bar2@zed
658bool ELFAsmParser::ParseDirectiveSymver(StringRef, SMLoc) {
659  StringRef Name;
660  if (getParser().parseIdentifier(Name))
661    return TokError("expected identifier in directive");
662
663  if (getLexer().isNot(AsmToken::Comma))
664    return TokError("expected a comma");
665
666  // ARM assembly uses @ for a comment...
667  // except when parsing the second parameter of the .symver directive.
668  // Force the next symbol to allow @ in the identifier, which is
669  // required for this directive and then reset it to its initial state.
670  const bool AllowAtInIdentifier = getLexer().getAllowAtInIdentifier();
671  getLexer().setAllowAtInIdentifier(true);
672  Lex();
673  getLexer().setAllowAtInIdentifier(AllowAtInIdentifier);
674
675  StringRef AliasName;
676  if (getParser().parseIdentifier(AliasName))
677    return TokError("expected identifier in directive");
678
679  if (AliasName.find('@') == StringRef::npos)
680    return TokError("expected a '@' in the name");
681
682  MCSymbol *Alias = getContext().GetOrCreateSymbol(AliasName);
683  MCSymbol *Sym = getContext().GetOrCreateSymbol(Name);
684  const MCExpr *Value = MCSymbolRefExpr::Create(Sym, getContext());
685
686  getStreamer().EmitAssignment(Alias, Value);
687  return false;
688}
689
690/// ParseDirectiveVersion
691///  ::= .version string
692bool ELFAsmParser::ParseDirectiveVersion(StringRef, SMLoc) {
693  if (getLexer().isNot(AsmToken::String))
694    return TokError("unexpected token in '.version' directive");
695
696  StringRef Data = getTok().getIdentifier();
697
698  Lex();
699
700  const MCSection *Note =
701    getContext().getELFSection(".note", ELF::SHT_NOTE, 0,
702                               SectionKind::getReadOnly());
703
704  getStreamer().PushSection();
705  getStreamer().SwitchSection(Note);
706  getStreamer().EmitIntValue(Data.size()+1, 4); // namesz.
707  getStreamer().EmitIntValue(0, 4);             // descsz = 0 (no description).
708  getStreamer().EmitIntValue(1, 4);             // type = NT_VERSION.
709  getStreamer().EmitBytes(Data);                // name.
710  getStreamer().EmitIntValue(0, 1);             // terminate the string.
711  getStreamer().EmitValueToAlignment(4);        // ensure 4 byte alignment.
712  getStreamer().PopSection();
713  return false;
714}
715
716/// ParseDirectiveWeakref
717///  ::= .weakref foo, bar
718bool ELFAsmParser::ParseDirectiveWeakref(StringRef, SMLoc) {
719  // FIXME: Share code with the other alias building directives.
720
721  StringRef AliasName;
722  if (getParser().parseIdentifier(AliasName))
723    return TokError("expected identifier in directive");
724
725  if (getLexer().isNot(AsmToken::Comma))
726    return TokError("expected a comma");
727
728  Lex();
729
730  StringRef Name;
731  if (getParser().parseIdentifier(Name))
732    return TokError("expected identifier in directive");
733
734  MCSymbol *Alias = getContext().GetOrCreateSymbol(AliasName);
735
736  MCSymbol *Sym = getContext().GetOrCreateSymbol(Name);
737
738  getStreamer().EmitWeakReference(Alias, Sym);
739  return false;
740}
741
742bool ELFAsmParser::ParseDirectiveSubsection(StringRef, SMLoc) {
743  const MCExpr *Subsection = nullptr;
744  if (getLexer().isNot(AsmToken::EndOfStatement)) {
745    if (getParser().parseExpression(Subsection))
746     return true;
747  }
748
749  if (getLexer().isNot(AsmToken::EndOfStatement))
750    return TokError("unexpected token in directive");
751
752  getStreamer().SubSection(Subsection);
753  return false;
754}
755
756namespace llvm {
757
758MCAsmParserExtension *createELFAsmParser() {
759  return new ELFAsmParser;
760}
761
762}
763