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