Home | History | Annotate | Line # | Download | only in MCParser 
      1 //===- COFFAsmParser.cpp - COFF Assembly Parser ---------------------------===//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 
      9 #include "llvm/ADT/StringRef.h"
     10 #include "llvm/ADT/StringSwitch.h"
     11 #include "llvm/ADT/Triple.h"
     12 #include "llvm/ADT/Twine.h"
     13 #include "llvm/BinaryFormat/COFF.h"
     14 #include "llvm/MC/MCContext.h"
     15 #include "llvm/MC/MCDirectives.h"
     16 #include "llvm/MC/MCObjectFileInfo.h"
     17 #include "llvm/MC/MCParser/MCAsmLexer.h"
     18 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
     19 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
     20 #include "llvm/MC/MCRegisterInfo.h"
     21 #include "llvm/MC/MCSectionCOFF.h"
     22 #include "llvm/MC/MCStreamer.h"
     23 #include "llvm/MC/SectionKind.h"
     24 #include "llvm/Support/SMLoc.h"
     25 #include <cassert>
     26 #include <cstdint>
     27 #include <limits>
     28 #include <utility>
     29 
     30 using namespace llvm;
     31 
     32 namespace {
     33 
     34 class COFFAsmParser : public MCAsmParserExtension {
     35   template<bool (COFFAsmParser::*HandlerMethod)(StringRef, SMLoc)>
     36   void addDirectiveHandler(StringRef Directive) {
     37     MCAsmParser::ExtensionDirectiveHandler Handler = std::make_pair(
     38         this, HandleDirective<COFFAsmParser, HandlerMethod>);
     39     getParser().addDirectiveHandler(Directive, Handler);
     40   }
     41 
     42   bool ParseSectionSwitch(StringRef Section,
     43                           unsigned Characteristics,
     44                           SectionKind Kind);
     45 
     46   bool ParseSectionSwitch(StringRef Section, unsigned Characteristics,
     47                           SectionKind Kind, StringRef COMDATSymName,
     48                           COFF::COMDATType Type);
     49 
     50   bool ParseSectionName(StringRef &SectionName);
     51   bool ParseSectionFlags(StringRef SectionName, StringRef FlagsString,
     52                          unsigned *Flags);
     53 
     54   void Initialize(MCAsmParser &Parser) override {
     55     // Call the base implementation.
     56     MCAsmParserExtension::Initialize(Parser);
     57 
     58     addDirectiveHandler<&COFFAsmParser::ParseSectionDirectiveText>(".text");
     59     addDirectiveHandler<&COFFAsmParser::ParseSectionDirectiveData>(".data");
     60     addDirectiveHandler<&COFFAsmParser::ParseSectionDirectiveBSS>(".bss");
     61     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSection>(".section");
     62     addDirectiveHandler<&COFFAsmParser::ParseDirectiveDef>(".def");
     63     addDirectiveHandler<&COFFAsmParser::ParseDirectiveScl>(".scl");
     64     addDirectiveHandler<&COFFAsmParser::ParseDirectiveType>(".type");
     65     addDirectiveHandler<&COFFAsmParser::ParseDirectiveEndef>(".endef");
     66     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSecRel32>(".secrel32");
     67     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSymIdx>(".symidx");
     68     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSafeSEH>(".safeseh");
     69     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSecIdx>(".secidx");
     70     addDirectiveHandler<&COFFAsmParser::ParseDirectiveLinkOnce>(".linkonce");
     71     addDirectiveHandler<&COFFAsmParser::ParseDirectiveRVA>(".rva");
     72     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSymbolAttribute>(".weak");
     73     addDirectiveHandler<&COFFAsmParser::ParseDirectiveCGProfile>(".cg_profile");
     74 
     75     // Win64 EH directives.
     76     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveStartProc>(
     77                                                                    ".seh_proc");
     78     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndProc>(
     79                                                                 ".seh_endproc");
     80     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndFuncletOrFunc>(
     81                                                                 ".seh_endfunclet");
     82     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveStartChained>(
     83                                                            ".seh_startchained");
     84     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndChained>(
     85                                                              ".seh_endchained");
     86     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveHandler>(
     87                                                                 ".seh_handler");
     88     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveHandlerData>(
     89                                                             ".seh_handlerdata");
     90     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveAllocStack>(
     91                                                              ".seh_stackalloc");
     92     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndProlog>(
     93                                                             ".seh_endprologue");
     94   }
     95 
     96   bool ParseSectionDirectiveText(StringRef, SMLoc) {
     97     return ParseSectionSwitch(".text",
     98                               COFF::IMAGE_SCN_CNT_CODE
     99                             | COFF::IMAGE_SCN_MEM_EXECUTE
    100                             | COFF::IMAGE_SCN_MEM_READ,
    101                               SectionKind::getText());
    102   }
    103 
    104   bool ParseSectionDirectiveData(StringRef, SMLoc) {
    105     return ParseSectionSwitch(".data", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
    106                                            COFF::IMAGE_SCN_MEM_READ |
    107                                            COFF::IMAGE_SCN_MEM_WRITE,
    108                               SectionKind::getData());
    109   }
    110 
    111   bool ParseSectionDirectiveBSS(StringRef, SMLoc) {
    112     return ParseSectionSwitch(".bss",
    113                               COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA
    114                             | COFF::IMAGE_SCN_MEM_READ
    115                             | COFF::IMAGE_SCN_MEM_WRITE,
    116                               SectionKind::getBSS());
    117   }
    118 
    119   bool ParseDirectiveSection(StringRef, SMLoc);
    120   bool ParseDirectiveDef(StringRef, SMLoc);
    121   bool ParseDirectiveScl(StringRef, SMLoc);
    122   bool ParseDirectiveType(StringRef, SMLoc);
    123   bool ParseDirectiveEndef(StringRef, SMLoc);
    124   bool ParseDirectiveSecRel32(StringRef, SMLoc);
    125   bool ParseDirectiveSecIdx(StringRef, SMLoc);
    126   bool ParseDirectiveSafeSEH(StringRef, SMLoc);
    127   bool ParseDirectiveSymIdx(StringRef, SMLoc);
    128   bool parseCOMDATType(COFF::COMDATType &Type);
    129   bool ParseDirectiveLinkOnce(StringRef, SMLoc);
    130   bool ParseDirectiveRVA(StringRef, SMLoc);
    131   bool ParseDirectiveCGProfile(StringRef, SMLoc);
    132 
    133   // Win64 EH directives.
    134   bool ParseSEHDirectiveStartProc(StringRef, SMLoc);
    135   bool ParseSEHDirectiveEndProc(StringRef, SMLoc);
    136   bool ParseSEHDirectiveEndFuncletOrFunc(StringRef, SMLoc);
    137   bool ParseSEHDirectiveStartChained(StringRef, SMLoc);
    138   bool ParseSEHDirectiveEndChained(StringRef, SMLoc);
    139   bool ParseSEHDirectiveHandler(StringRef, SMLoc);
    140   bool ParseSEHDirectiveHandlerData(StringRef, SMLoc);
    141   bool ParseSEHDirectiveAllocStack(StringRef, SMLoc);
    142   bool ParseSEHDirectiveEndProlog(StringRef, SMLoc);
    143 
    144   bool ParseAtUnwindOrAtExcept(bool &unwind, bool &except);
    145   bool ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc);
    146 
    147 public:
    148   COFFAsmParser() = default;
    149 };
    150 
    151 } // end anonymous namespace.
    152 
    153 static SectionKind computeSectionKind(unsigned Flags) {
    154   if (Flags & COFF::IMAGE_SCN_MEM_EXECUTE)
    155     return SectionKind::getText();
    156   if (Flags & COFF::IMAGE_SCN_MEM_READ &&
    157       (Flags & COFF::IMAGE_SCN_MEM_WRITE) == 0)
    158     return SectionKind::getReadOnly();
    159   return SectionKind::getData();
    160 }
    161 
    162 bool COFFAsmParser::ParseSectionFlags(StringRef SectionName,
    163                                       StringRef FlagsString, unsigned *Flags) {
    164   enum {
    165     None        = 0,
    166     Alloc       = 1 << 0,
    167     Code        = 1 << 1,
    168     Load        = 1 << 2,
    169     InitData    = 1 << 3,
    170     Shared      = 1 << 4,
    171     NoLoad      = 1 << 5,
    172     NoRead      = 1 << 6,
    173     NoWrite     = 1 << 7,
    174     Discardable = 1 << 8,
    175   };
    176 
    177   bool ReadOnlyRemoved = false;
    178   unsigned SecFlags = None;
    179 
    180   for (char FlagChar : FlagsString) {
    181     switch (FlagChar) {
    182     case 'a':
    183       // Ignored.
    184       break;
    185 
    186     case 'b': // bss section
    187       SecFlags |= Alloc;
    188       if (SecFlags & InitData)
    189         return TokError("conflicting section flags 'b' and 'd'.");
    190       SecFlags &= ~Load;
    191       break;
    192 
    193     case 'd': // data section
    194       SecFlags |= InitData;
    195       if (SecFlags & Alloc)
    196         return TokError("conflicting section flags 'b' and 'd'.");
    197       SecFlags &= ~NoWrite;
    198       if ((SecFlags & NoLoad) == 0)
    199         SecFlags |= Load;
    200       break;
    201 
    202     case 'n': // section is not loaded
    203       SecFlags |= NoLoad;
    204       SecFlags &= ~Load;
    205       break;
    206 
    207     case 'D': // discardable
    208       SecFlags |= Discardable;
    209       break;
    210 
    211     case 'r': // read-only
    212       ReadOnlyRemoved = false;
    213       SecFlags |= NoWrite;
    214       if ((SecFlags & Code) == 0)
    215         SecFlags |= InitData;
    216       if ((SecFlags & NoLoad) == 0)
    217         SecFlags |= Load;
    218       break;
    219 
    220     case 's': // shared section
    221       SecFlags |= Shared | InitData;
    222       SecFlags &= ~NoWrite;
    223       if ((SecFlags & NoLoad) == 0)
    224         SecFlags |= Load;
    225       break;
    226 
    227     case 'w': // writable
    228       SecFlags &= ~NoWrite;
    229       ReadOnlyRemoved = true;
    230       break;
    231 
    232     case 'x': // executable section
    233       SecFlags |= Code;
    234       if ((SecFlags & NoLoad) == 0)
    235         SecFlags |= Load;
    236       if (!ReadOnlyRemoved)
    237         SecFlags |= NoWrite;
    238       break;
    239 
    240     case 'y': // not readable
    241       SecFlags |= NoRead | NoWrite;
    242       break;
    243 
    244     default:
    245       return TokError("unknown flag");
    246     }
    247   }
    248 
    249   *Flags = 0;
    250 
    251   if (SecFlags == None)
    252     SecFlags = InitData;
    253 
    254   if (SecFlags & Code)
    255     *Flags |= COFF::IMAGE_SCN_CNT_CODE | COFF::IMAGE_SCN_MEM_EXECUTE;
    256   if (SecFlags & InitData)
    257     *Flags |= COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
    258   if ((SecFlags & Alloc) && (SecFlags & Load) == 0)
    259     *Flags |= COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
    260   if (SecFlags & NoLoad)
    261     *Flags |= COFF::IMAGE_SCN_LNK_REMOVE;
    262   if ((SecFlags & Discardable) ||
    263       MCSectionCOFF::isImplicitlyDiscardable(SectionName))
    264     *Flags |= COFF::IMAGE_SCN_MEM_DISCARDABLE;
    265   if ((SecFlags & NoRead) == 0)
    266     *Flags |= COFF::IMAGE_SCN_MEM_READ;
    267   if ((SecFlags & NoWrite) == 0)
    268     *Flags |= COFF::IMAGE_SCN_MEM_WRITE;
    269   if (SecFlags & Shared)
    270     *Flags |= COFF::IMAGE_SCN_MEM_SHARED;
    271 
    272   return false;
    273 }
    274 
    275 /// ParseDirectiveSymbolAttribute
    276 ///  ::= { ".weak", ... } [ identifier ( , identifier )* ]
    277 bool COFFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
    278   MCSymbolAttr Attr = StringSwitch<MCSymbolAttr>(Directive)
    279     .Case(".weak", MCSA_Weak)
    280     .Default(MCSA_Invalid);
    281   assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!");
    282   if (getLexer().isNot(AsmToken::EndOfStatement)) {
    283     while (true) {
    284       StringRef Name;
    285 
    286       if (getParser().parseIdentifier(Name))
    287         return TokError("expected identifier in directive");
    288 
    289       MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
    290 
    291       getStreamer().emitSymbolAttribute(Sym, Attr);
    292 
    293       if (getLexer().is(AsmToken::EndOfStatement))
    294         break;
    295 
    296       if (getLexer().isNot(AsmToken::Comma))
    297         return TokError("unexpected token in directive");
    298       Lex();
    299     }
    300   }
    301 
    302   Lex();
    303   return false;
    304 }
    305 
    306 bool COFFAsmParser::ParseDirectiveCGProfile(StringRef S, SMLoc Loc) {
    307   return MCAsmParserExtension::ParseDirectiveCGProfile(S, Loc);
    308 }
    309 
    310 bool COFFAsmParser::ParseSectionSwitch(StringRef Section,
    311                                        unsigned Characteristics,
    312                                        SectionKind Kind) {
    313   return ParseSectionSwitch(Section, Characteristics, Kind, "", (COFF::COMDATType)0);
    314 }
    315 
    316 bool COFFAsmParser::ParseSectionSwitch(StringRef Section,
    317                                        unsigned Characteristics,
    318                                        SectionKind Kind,
    319                                        StringRef COMDATSymName,
    320                                        COFF::COMDATType Type) {
    321   if (getLexer().isNot(AsmToken::EndOfStatement))
    322     return TokError("unexpected token in section switching directive");
    323   Lex();
    324 
    325   getStreamer().SwitchSection(getContext().getCOFFSection(
    326       Section, Characteristics, Kind, COMDATSymName, Type));
    327 
    328   return false;
    329 }
    330 
    331 bool COFFAsmParser::ParseSectionName(StringRef &SectionName) {
    332   if (!getLexer().is(AsmToken::Identifier) && !getLexer().is(AsmToken::String))
    333     return true;
    334 
    335   SectionName = getTok().getIdentifier();
    336   Lex();
    337   return false;
    338 }
    339 
    340 // .section name [, "flags"] [, identifier [ identifier ], identifier]
    341 //
    342 // Supported flags:
    343 //   a: Ignored.
    344 //   b: BSS section (uninitialized data)
    345 //   d: data section (initialized data)
    346 //   n: "noload" section (removed by linker)
    347 //   D: Discardable section
    348 //   r: Readable section
    349 //   s: Shared section
    350 //   w: Writable section
    351 //   x: Executable section
    352 //   y: Not-readable section (clears 'r')
    353 //
    354 // Subsections are not supported.
    355 bool COFFAsmParser::ParseDirectiveSection(StringRef, SMLoc) {
    356   StringRef SectionName;
    357 
    358   if (ParseSectionName(SectionName))
    359     return TokError("expected identifier in directive");
    360 
    361   unsigned Flags = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
    362                    COFF::IMAGE_SCN_MEM_READ |
    363                    COFF::IMAGE_SCN_MEM_WRITE;
    364 
    365   if (getLexer().is(AsmToken::Comma)) {
    366     Lex();
    367 
    368     if (getLexer().isNot(AsmToken::String))
    369       return TokError("expected string in directive");
    370 
    371     StringRef FlagsStr = getTok().getStringContents();
    372     Lex();
    373 
    374     if (ParseSectionFlags(SectionName, FlagsStr, &Flags))
    375       return true;
    376   }
    377 
    378   COFF::COMDATType Type = (COFF::COMDATType)0;
    379   StringRef COMDATSymName;
    380   if (getLexer().is(AsmToken::Comma)) {
    381     Type = COFF::IMAGE_COMDAT_SELECT_ANY;
    382     Lex();
    383 
    384     Flags |= COFF::IMAGE_SCN_LNK_COMDAT;
    385 
    386     if (!getLexer().is(AsmToken::Identifier))
    387       return TokError("expected comdat type such as 'discard' or 'largest' "
    388                       "after protection bits");
    389 
    390     if (parseCOMDATType(Type))
    391       return true;
    392 
    393     if (getLexer().isNot(AsmToken::Comma))
    394       return TokError("expected comma in directive");
    395     Lex();
    396 
    397     if (getParser().parseIdentifier(COMDATSymName))
    398       return TokError("expected identifier in directive");
    399   }
    400 
    401   if (getLexer().isNot(AsmToken::EndOfStatement))
    402     return TokError("unexpected token in directive");
    403 
    404   SectionKind Kind = computeSectionKind(Flags);
    405   if (Kind.isText()) {
    406     const Triple &T = getContext().getTargetTriple();
    407     if (T.getArch() == Triple::arm || T.getArch() == Triple::thumb)
    408       Flags |= COFF::IMAGE_SCN_MEM_16BIT;
    409   }
    410   ParseSectionSwitch(SectionName, Flags, Kind, COMDATSymName, Type);
    411   return false;
    412 }
    413 
    414 bool COFFAsmParser::ParseDirectiveDef(StringRef, SMLoc) {
    415   StringRef SymbolName;
    416 
    417   if (getParser().parseIdentifier(SymbolName))
    418     return TokError("expected identifier in directive");
    419 
    420   MCSymbol *Sym = getContext().getOrCreateSymbol(SymbolName);
    421 
    422   getStreamer().BeginCOFFSymbolDef(Sym);
    423 
    424   Lex();
    425   return false;
    426 }
    427 
    428 bool COFFAsmParser::ParseDirectiveScl(StringRef, SMLoc) {
    429   int64_t SymbolStorageClass;
    430   if (getParser().parseAbsoluteExpression(SymbolStorageClass))
    431     return true;
    432 
    433   if (getLexer().isNot(AsmToken::EndOfStatement))
    434     return TokError("unexpected token in directive");
    435 
    436   Lex();
    437   getStreamer().EmitCOFFSymbolStorageClass(SymbolStorageClass);
    438   return false;
    439 }
    440 
    441 bool COFFAsmParser::ParseDirectiveType(StringRef, SMLoc) {
    442   int64_t Type;
    443   if (getParser().parseAbsoluteExpression(Type))
    444     return true;
    445 
    446   if (getLexer().isNot(AsmToken::EndOfStatement))
    447     return TokError("unexpected token in directive");
    448 
    449   Lex();
    450   getStreamer().EmitCOFFSymbolType(Type);
    451   return false;
    452 }
    453 
    454 bool COFFAsmParser::ParseDirectiveEndef(StringRef, SMLoc) {
    455   Lex();
    456   getStreamer().EndCOFFSymbolDef();
    457   return false;
    458 }
    459 
    460 bool COFFAsmParser::ParseDirectiveSecRel32(StringRef, SMLoc) {
    461   StringRef SymbolID;
    462   if (getParser().parseIdentifier(SymbolID))
    463     return TokError("expected identifier in directive");
    464 
    465   int64_t Offset = 0;
    466   SMLoc OffsetLoc;
    467   if (getLexer().is(AsmToken::Plus)) {
    468     OffsetLoc = getLexer().getLoc();
    469     if (getParser().parseAbsoluteExpression(Offset))
    470       return true;
    471   }
    472 
    473   if (getLexer().isNot(AsmToken::EndOfStatement))
    474     return TokError("unexpected token in directive");
    475 
    476   if (Offset < 0 || Offset > std::numeric_limits<uint32_t>::max())
    477     return Error(
    478         OffsetLoc,
    479         "invalid '.secrel32' directive offset, can't be less "
    480         "than zero or greater than std::numeric_limits<uint32_t>::max()");
    481 
    482   MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
    483 
    484   Lex();
    485   getStreamer().EmitCOFFSecRel32(Symbol, Offset);
    486   return false;
    487 }
    488 
    489 bool COFFAsmParser::ParseDirectiveRVA(StringRef, SMLoc) {
    490   auto parseOp = [&]() -> bool {
    491     StringRef SymbolID;
    492     if (getParser().parseIdentifier(SymbolID))
    493       return TokError("expected identifier in directive");
    494 
    495     int64_t Offset = 0;
    496     SMLoc OffsetLoc;
    497     if (getLexer().is(AsmToken::Plus) || getLexer().is(AsmToken::Minus)) {
    498       OffsetLoc = getLexer().getLoc();
    499       if (getParser().parseAbsoluteExpression(Offset))
    500         return true;
    501     }
    502 
    503     if (Offset < std::numeric_limits<int32_t>::min() ||
    504         Offset > std::numeric_limits<int32_t>::max())
    505       return Error(OffsetLoc, "invalid '.rva' directive offset, can't be less "
    506                               "than -2147483648 or greater than "
    507                               "2147483647");
    508 
    509     MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
    510 
    511     getStreamer().EmitCOFFImgRel32(Symbol, Offset);
    512     return false;
    513   };
    514 
    515   if (getParser().parseMany(parseOp))
    516     return addErrorSuffix(" in directive");
    517   return false;
    518 }
    519 
    520 bool COFFAsmParser::ParseDirectiveSafeSEH(StringRef, SMLoc) {
    521   StringRef SymbolID;
    522   if (getParser().parseIdentifier(SymbolID))
    523     return TokError("expected identifier in directive");
    524 
    525   if (getLexer().isNot(AsmToken::EndOfStatement))
    526     return TokError("unexpected token in directive");
    527 
    528   MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
    529 
    530   Lex();
    531   getStreamer().EmitCOFFSafeSEH(Symbol);
    532   return false;
    533 }
    534 
    535 bool COFFAsmParser::ParseDirectiveSecIdx(StringRef, SMLoc) {
    536   StringRef SymbolID;
    537   if (getParser().parseIdentifier(SymbolID))
    538     return TokError("expected identifier in directive");
    539 
    540   if (getLexer().isNot(AsmToken::EndOfStatement))
    541     return TokError("unexpected token in directive");
    542 
    543   MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
    544 
    545   Lex();
    546   getStreamer().EmitCOFFSectionIndex(Symbol);
    547   return false;
    548 }
    549 
    550 bool COFFAsmParser::ParseDirectiveSymIdx(StringRef, SMLoc) {
    551   StringRef SymbolID;
    552   if (getParser().parseIdentifier(SymbolID))
    553     return TokError("expected identifier in directive");
    554 
    555   if (getLexer().isNot(AsmToken::EndOfStatement))
    556     return TokError("unexpected token in directive");
    557 
    558   MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
    559 
    560   Lex();
    561   getStreamer().EmitCOFFSymbolIndex(Symbol);
    562   return false;
    563 }
    564 
    565 /// ::= [ identifier ]
    566 bool COFFAsmParser::parseCOMDATType(COFF::COMDATType &Type) {
    567   StringRef TypeId = getTok().getIdentifier();
    568 
    569   Type = StringSwitch<COFF::COMDATType>(TypeId)
    570     .Case("one_only", COFF::IMAGE_COMDAT_SELECT_NODUPLICATES)
    571     .Case("discard", COFF::IMAGE_COMDAT_SELECT_ANY)
    572     .Case("same_size", COFF::IMAGE_COMDAT_SELECT_SAME_SIZE)
    573     .Case("same_contents", COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH)
    574     .Case("associative", COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
    575     .Case("largest", COFF::IMAGE_COMDAT_SELECT_LARGEST)
    576     .Case("newest", COFF::IMAGE_COMDAT_SELECT_NEWEST)
    577     .Default((COFF::COMDATType)0);
    578 
    579   if (Type == 0)
    580     return TokError(Twine("unrecognized COMDAT type '" + TypeId + "'"));
    581 
    582   Lex();
    583 
    584   return false;
    585 }
    586 
    587 /// ParseDirectiveLinkOnce
    588 ///  ::= .linkonce [ identifier ]
    589 bool COFFAsmParser::ParseDirectiveLinkOnce(StringRef, SMLoc Loc) {
    590   COFF::COMDATType Type = COFF::IMAGE_COMDAT_SELECT_ANY;
    591   if (getLexer().is(AsmToken::Identifier))
    592     if (parseCOMDATType(Type))
    593       return true;
    594 
    595   const MCSectionCOFF *Current =
    596       static_cast<const MCSectionCOFF *>(getStreamer().getCurrentSectionOnly());
    597 
    598   if (Type == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
    599     return Error(Loc, "cannot make section associative with .linkonce");
    600 
    601   if (Current->getCharacteristics() & COFF::IMAGE_SCN_LNK_COMDAT)
    602     return Error(Loc, Twine("section '") + Current->getName() +
    603                           "' is already linkonce");
    604 
    605   Current->setSelection(Type);
    606 
    607   if (getLexer().isNot(AsmToken::EndOfStatement))
    608     return TokError("unexpected token in directive");
    609 
    610   return false;
    611 }
    612 
    613 bool COFFAsmParser::ParseSEHDirectiveStartProc(StringRef, SMLoc Loc) {
    614   StringRef SymbolID;
    615   if (getParser().parseIdentifier(SymbolID))
    616     return true;
    617 
    618   if (getLexer().isNot(AsmToken::EndOfStatement))
    619     return TokError("unexpected token in directive");
    620 
    621   MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
    622 
    623   Lex();
    624   getStreamer().EmitWinCFIStartProc(Symbol, Loc);
    625   return false;
    626 }
    627 
    628 bool COFFAsmParser::ParseSEHDirectiveEndProc(StringRef, SMLoc Loc) {
    629   Lex();
    630   getStreamer().EmitWinCFIEndProc(Loc);
    631   return false;
    632 }
    633 
    634 bool COFFAsmParser::ParseSEHDirectiveEndFuncletOrFunc(StringRef, SMLoc Loc) {
    635   Lex();
    636   getStreamer().EmitWinCFIFuncletOrFuncEnd(Loc);
    637   return false;
    638 }
    639 
    640 bool COFFAsmParser::ParseSEHDirectiveStartChained(StringRef, SMLoc Loc) {
    641   Lex();
    642   getStreamer().EmitWinCFIStartChained(Loc);
    643   return false;
    644 }
    645 
    646 bool COFFAsmParser::ParseSEHDirectiveEndChained(StringRef, SMLoc Loc) {
    647   Lex();
    648   getStreamer().EmitWinCFIEndChained(Loc);
    649   return false;
    650 }
    651 
    652 bool COFFAsmParser::ParseSEHDirectiveHandler(StringRef, SMLoc Loc) {
    653   StringRef SymbolID;
    654   if (getParser().parseIdentifier(SymbolID))
    655     return true;
    656 
    657   if (getLexer().isNot(AsmToken::Comma))
    658     return TokError("you must specify one or both of @unwind or @except");
    659   Lex();
    660   bool unwind = false, except = false;
    661   if (ParseAtUnwindOrAtExcept(unwind, except))
    662     return true;
    663   if (getLexer().is(AsmToken::Comma)) {
    664     Lex();
    665     if (ParseAtUnwindOrAtExcept(unwind, except))
    666       return true;
    667   }
    668   if (getLexer().isNot(AsmToken::EndOfStatement))
    669     return TokError("unexpected token in directive");
    670 
    671   MCSymbol *handler = getContext().getOrCreateSymbol(SymbolID);
    672 
    673   Lex();
    674   getStreamer().EmitWinEHHandler(handler, unwind, except, Loc);
    675   return false;
    676 }
    677 
    678 bool COFFAsmParser::ParseSEHDirectiveHandlerData(StringRef, SMLoc Loc) {
    679   Lex();
    680   getStreamer().EmitWinEHHandlerData();
    681   return false;
    682 }
    683 
    684 bool COFFAsmParser::ParseSEHDirectiveAllocStack(StringRef, SMLoc Loc) {
    685   int64_t Size;
    686   if (getParser().parseAbsoluteExpression(Size))
    687     return true;
    688 
    689   if (getLexer().isNot(AsmToken::EndOfStatement))
    690     return TokError("unexpected token in directive");
    691 
    692   Lex();
    693   getStreamer().EmitWinCFIAllocStack(Size, Loc);
    694   return false;
    695 }
    696 
    697 bool COFFAsmParser::ParseSEHDirectiveEndProlog(StringRef, SMLoc Loc) {
    698   Lex();
    699   getStreamer().EmitWinCFIEndProlog(Loc);
    700   return false;
    701 }
    702 
    703 bool COFFAsmParser::ParseAtUnwindOrAtExcept(bool &unwind, bool &except) {
    704   StringRef identifier;
    705   if (getLexer().isNot(AsmToken::At))
    706     return TokError("a handler attribute must begin with '@'");
    707   SMLoc startLoc = getLexer().getLoc();
    708   Lex();
    709   if (getParser().parseIdentifier(identifier))
    710     return Error(startLoc, "expected @unwind or @except");
    711   if (identifier == "unwind")
    712     unwind = true;
    713   else if (identifier == "except")
    714     except = true;
    715   else
    716     return Error(startLoc, "expected @unwind or @except");
    717   return false;
    718 }
    719 
    720 namespace llvm {
    721 
    722 MCAsmParserExtension *createCOFFAsmParser() {
    723   return new COFFAsmParser;
    724 }
    725 
    726 } // end namespace llvm
    727