1 //===- COFFAsmParser.cpp - COFF 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/ADT/Triple.h"
13 #include "llvm/ADT/Twine.h"
14 #include "llvm/BinaryFormat/COFF.h"
15 #include "llvm/MC/MCContext.h"
16 #include "llvm/MC/MCDirectives.h"
17 #include "llvm/MC/MCObjectFileInfo.h"
18 #include "llvm/MC/MCParser/MCAsmLexer.h"
19 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
20 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
21 #include "llvm/MC/MCRegisterInfo.h"
22 #include "llvm/MC/MCSectionCOFF.h"
23 #include "llvm/MC/MCStreamer.h"
24 #include "llvm/MC/SectionKind.h"
25 #include "llvm/Support/SMLoc.h"
26 #include <cassert>
27 #include <cstdint>
28 #include <limits>
29 #include <utility>
30 
31 using namespace llvm;
32 
33 namespace {
34 
35 class COFFAsmParser : public MCAsmParserExtension {
36   template<bool (COFFAsmParser::*HandlerMethod)(StringRef, SMLoc)>
37   void addDirectiveHandler(StringRef Directive) {
38     MCAsmParser::ExtensionDirectiveHandler Handler = std::make_pair(
39         this, HandleDirective<COFFAsmParser, HandlerMethod>);
40     getParser().addDirectiveHandler(Directive, Handler);
41   }
42 
43   bool ParseSectionSwitch(StringRef Section,
44                           unsigned Characteristics,
45                           SectionKind Kind);
46 
47   bool ParseSectionSwitch(StringRef Section, unsigned Characteristics,
48                           SectionKind Kind, StringRef COMDATSymName,
49                           COFF::COMDATType Type);
50 
51   bool ParseSectionName(StringRef &SectionName);
52   bool ParseSectionFlags(StringRef SectionName, StringRef FlagsString,
53                          unsigned *Flags);
54 
55   void Initialize(MCAsmParser &Parser) override {
56     // Call the base implementation.
57     MCAsmParserExtension::Initialize(Parser);
58 
59     addDirectiveHandler<&COFFAsmParser::ParseSectionDirectiveText>(".text");
60     addDirectiveHandler<&COFFAsmParser::ParseSectionDirectiveData>(".data");
61     addDirectiveHandler<&COFFAsmParser::ParseSectionDirectiveBSS>(".bss");
62     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSection>(".section");
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 
74     // Win64 EH directives.
75     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveStartProc>(
76                                                                    ".seh_proc");
77     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndProc>(
78                                                                 ".seh_endproc");
79     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveStartChained>(
80                                                            ".seh_startchained");
81     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndChained>(
82                                                              ".seh_endchained");
83     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveHandler>(
84                                                                 ".seh_handler");
85     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveHandlerData>(
86                                                             ".seh_handlerdata");
87     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectivePushReg>(
88                                                                 ".seh_pushreg");
89     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveSetFrame>(
90                                                                ".seh_setframe");
91     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveAllocStack>(
92                                                              ".seh_stackalloc");
93     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveSaveReg>(
94                                                                 ".seh_savereg");
95     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveSaveXMM>(
96                                                                 ".seh_savexmm");
97     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectivePushFrame>(
98                                                               ".seh_pushframe");
99     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndProlog>(
100                                                             ".seh_endprologue");
101     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSymbolAttribute>(".weak");
102   }
103 
104   bool ParseSectionDirectiveText(StringRef, SMLoc) {
105     return ParseSectionSwitch(".text",
106                               COFF::IMAGE_SCN_CNT_CODE
107                             | COFF::IMAGE_SCN_MEM_EXECUTE
108                             | COFF::IMAGE_SCN_MEM_READ,
109                               SectionKind::getText());
110   }
111 
112   bool ParseSectionDirectiveData(StringRef, SMLoc) {
113     return ParseSectionSwitch(".data", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
114                                            COFF::IMAGE_SCN_MEM_READ |
115                                            COFF::IMAGE_SCN_MEM_WRITE,
116                               SectionKind::getData());
117   }
118 
119   bool ParseSectionDirectiveBSS(StringRef, SMLoc) {
120     return ParseSectionSwitch(".bss",
121                               COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA
122                             | COFF::IMAGE_SCN_MEM_READ
123                             | COFF::IMAGE_SCN_MEM_WRITE,
124                               SectionKind::getBSS());
125   }
126 
127   bool ParseDirectiveSection(StringRef, SMLoc);
128   bool ParseDirectiveDef(StringRef, SMLoc);
129   bool ParseDirectiveScl(StringRef, SMLoc);
130   bool ParseDirectiveType(StringRef, SMLoc);
131   bool ParseDirectiveEndef(StringRef, SMLoc);
132   bool ParseDirectiveSecRel32(StringRef, SMLoc);
133   bool ParseDirectiveSecIdx(StringRef, SMLoc);
134   bool ParseDirectiveSafeSEH(StringRef, SMLoc);
135   bool ParseDirectiveSymIdx(StringRef, SMLoc);
136   bool parseCOMDATType(COFF::COMDATType &Type);
137   bool ParseDirectiveLinkOnce(StringRef, SMLoc);
138   bool ParseDirectiveRVA(StringRef, SMLoc);
139 
140   // Win64 EH directives.
141   bool ParseSEHDirectiveStartProc(StringRef, SMLoc);
142   bool ParseSEHDirectiveEndProc(StringRef, SMLoc);
143   bool ParseSEHDirectiveStartChained(StringRef, SMLoc);
144   bool ParseSEHDirectiveEndChained(StringRef, SMLoc);
145   bool ParseSEHDirectiveHandler(StringRef, SMLoc);
146   bool ParseSEHDirectiveHandlerData(StringRef, SMLoc);
147   bool ParseSEHDirectivePushReg(StringRef, SMLoc);
148   bool ParseSEHDirectiveSetFrame(StringRef, SMLoc);
149   bool ParseSEHDirectiveAllocStack(StringRef, SMLoc);
150   bool ParseSEHDirectiveSaveReg(StringRef, SMLoc);
151   bool ParseSEHDirectiveSaveXMM(StringRef, SMLoc);
152   bool ParseSEHDirectivePushFrame(StringRef, SMLoc);
153   bool ParseSEHDirectiveEndProlog(StringRef, SMLoc);
154 
155   bool ParseAtUnwindOrAtExcept(bool &unwind, bool &except);
156   bool ParseSEHRegisterNumber(unsigned &RegNo);
157   bool ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc);
158 
159 public:
160   COFFAsmParser() = default;
161 };
162 
163 } // end annonomous namespace.
164 
165 static SectionKind computeSectionKind(unsigned Flags) {
166   if (Flags & COFF::IMAGE_SCN_MEM_EXECUTE)
167     return SectionKind::getText();
168   if (Flags & COFF::IMAGE_SCN_MEM_READ &&
169       (Flags & COFF::IMAGE_SCN_MEM_WRITE) == 0)
170     return SectionKind::getReadOnly();
171   return SectionKind::getData();
172 }
173 
174 bool COFFAsmParser::ParseSectionFlags(StringRef SectionName,
175                                       StringRef FlagsString, unsigned *Flags) {
176   enum {
177     None        = 0,
178     Alloc       = 1 << 0,
179     Code        = 1 << 1,
180     Load        = 1 << 2,
181     InitData    = 1 << 3,
182     Shared      = 1 << 4,
183     NoLoad      = 1 << 5,
184     NoRead      = 1 << 6,
185     NoWrite     = 1 << 7,
186     Discardable = 1 << 8,
187   };
188 
189   bool ReadOnlyRemoved = false;
190   unsigned SecFlags = None;
191 
192   for (char FlagChar : FlagsString) {
193     switch (FlagChar) {
194     case 'a':
195       // Ignored.
196       break;
197 
198     case 'b': // bss section
199       SecFlags |= Alloc;
200       if (SecFlags & InitData)
201         return TokError("conflicting section flags 'b' and 'd'.");
202       SecFlags &= ~Load;
203       break;
204 
205     case 'd': // data section
206       SecFlags |= InitData;
207       if (SecFlags & Alloc)
208         return TokError("conflicting section flags 'b' and 'd'.");
209       SecFlags &= ~NoWrite;
210       if ((SecFlags & NoLoad) == 0)
211         SecFlags |= Load;
212       break;
213 
214     case 'n': // section is not loaded
215       SecFlags |= NoLoad;
216       SecFlags &= ~Load;
217       break;
218 
219     case 'D': // discardable
220       SecFlags |= Discardable;
221       break;
222 
223     case 'r': // read-only
224       ReadOnlyRemoved = false;
225       SecFlags |= NoWrite;
226       if ((SecFlags & Code) == 0)
227         SecFlags |= InitData;
228       if ((SecFlags & NoLoad) == 0)
229         SecFlags |= Load;
230       break;
231 
232     case 's': // shared section
233       SecFlags |= Shared | InitData;
234       SecFlags &= ~NoWrite;
235       if ((SecFlags & NoLoad) == 0)
236         SecFlags |= Load;
237       break;
238 
239     case 'w': // writable
240       SecFlags &= ~NoWrite;
241       ReadOnlyRemoved = true;
242       break;
243 
244     case 'x': // executable section
245       SecFlags |= Code;
246       if ((SecFlags & NoLoad) == 0)
247         SecFlags |= Load;
248       if (!ReadOnlyRemoved)
249         SecFlags |= NoWrite;
250       break;
251 
252     case 'y': // not readable
253       SecFlags |= NoRead | NoWrite;
254       break;
255 
256     default:
257       return TokError("unknown flag");
258     }
259   }
260 
261   *Flags = 0;
262 
263   if (SecFlags == None)
264     SecFlags = InitData;
265 
266   if (SecFlags & Code)
267     *Flags |= COFF::IMAGE_SCN_CNT_CODE | COFF::IMAGE_SCN_MEM_EXECUTE;
268   if (SecFlags & InitData)
269     *Flags |= COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
270   if ((SecFlags & Alloc) && (SecFlags & Load) == 0)
271     *Flags |= COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
272   if (SecFlags & NoLoad)
273     *Flags |= COFF::IMAGE_SCN_LNK_REMOVE;
274   if ((SecFlags & Discardable) ||
275       MCSectionCOFF::isImplicitlyDiscardable(SectionName))
276     *Flags |= COFF::IMAGE_SCN_MEM_DISCARDABLE;
277   if ((SecFlags & NoRead) == 0)
278     *Flags |= COFF::IMAGE_SCN_MEM_READ;
279   if ((SecFlags & NoWrite) == 0)
280     *Flags |= COFF::IMAGE_SCN_MEM_WRITE;
281   if (SecFlags & Shared)
282     *Flags |= COFF::IMAGE_SCN_MEM_SHARED;
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     .Default(MCSA_Invalid);
293   assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!");
294   if (getLexer().isNot(AsmToken::EndOfStatement)) {
295     while (true) {
296       StringRef Name;
297 
298       if (getParser().parseIdentifier(Name))
299         return TokError("expected identifier in directive");
300 
301       MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
302 
303       getStreamer().EmitSymbolAttribute(Sym, Attr);
304 
305       if (getLexer().is(AsmToken::EndOfStatement))
306         break;
307 
308       if (getLexer().isNot(AsmToken::Comma))
309         return TokError("unexpected token in directive");
310       Lex();
311     }
312   }
313 
314   Lex();
315   return false;
316 }
317 
318 bool COFFAsmParser::ParseSectionSwitch(StringRef Section,
319                                        unsigned Characteristics,
320                                        SectionKind Kind) {
321   return ParseSectionSwitch(Section, Characteristics, Kind, "", (COFF::COMDATType)0);
322 }
323 
324 bool COFFAsmParser::ParseSectionSwitch(StringRef Section,
325                                        unsigned Characteristics,
326                                        SectionKind Kind,
327                                        StringRef COMDATSymName,
328                                        COFF::COMDATType Type) {
329   if (getLexer().isNot(AsmToken::EndOfStatement))
330     return TokError("unexpected token in section switching directive");
331   Lex();
332 
333   getStreamer().SwitchSection(getContext().getCOFFSection(
334       Section, Characteristics, Kind, COMDATSymName, Type));
335 
336   return false;
337 }
338 
339 bool COFFAsmParser::ParseSectionName(StringRef &SectionName) {
340   if (!getLexer().is(AsmToken::Identifier))
341     return true;
342 
343   SectionName = getTok().getIdentifier();
344   Lex();
345   return false;
346 }
347 
348 // .section name [, "flags"] [, identifier [ identifier ], identifier]
349 //
350 // Supported flags:
351 //   a: Ignored.
352 //   b: BSS section (uninitialized data)
353 //   d: data section (initialized data)
354 //   n: "noload" section (removed by linker)
355 //   D: Discardable section
356 //   r: Readable section
357 //   s: Shared section
358 //   w: Writable section
359 //   x: Executable section
360 //   y: Not-readable section (clears 'r')
361 //
362 // Subsections are not supported.
363 bool COFFAsmParser::ParseDirectiveSection(StringRef, SMLoc) {
364   StringRef SectionName;
365 
366   if (ParseSectionName(SectionName))
367     return TokError("expected identifier in directive");
368 
369   unsigned Flags = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
370                    COFF::IMAGE_SCN_MEM_READ |
371                    COFF::IMAGE_SCN_MEM_WRITE;
372 
373   if (getLexer().is(AsmToken::Comma)) {
374     Lex();
375 
376     if (getLexer().isNot(AsmToken::String))
377       return TokError("expected string in directive");
378 
379     StringRef FlagsStr = getTok().getStringContents();
380     Lex();
381 
382     if (ParseSectionFlags(SectionName, FlagsStr, &Flags))
383       return true;
384   }
385 
386   COFF::COMDATType Type = (COFF::COMDATType)0;
387   StringRef COMDATSymName;
388   if (getLexer().is(AsmToken::Comma)) {
389     Type = COFF::IMAGE_COMDAT_SELECT_ANY;
390     Lex();
391 
392     Flags |= COFF::IMAGE_SCN_LNK_COMDAT;
393 
394     if (!getLexer().is(AsmToken::Identifier))
395       return TokError("expected comdat type such as 'discard' or 'largest' "
396                       "after protection bits");
397 
398     if (parseCOMDATType(Type))
399       return true;
400 
401     if (getLexer().isNot(AsmToken::Comma))
402       return TokError("expected comma in directive");
403     Lex();
404 
405     if (getParser().parseIdentifier(COMDATSymName))
406       return TokError("expected identifier in directive");
407   }
408 
409   if (getLexer().isNot(AsmToken::EndOfStatement))
410     return TokError("unexpected token in directive");
411 
412   SectionKind Kind = computeSectionKind(Flags);
413   if (Kind.isText()) {
414     const Triple &T = getContext().getObjectFileInfo()->getTargetTriple();
415     if (T.getArch() == Triple::arm || T.getArch() == Triple::thumb)
416       Flags |= COFF::IMAGE_SCN_MEM_16BIT;
417   }
418   ParseSectionSwitch(SectionName, Flags, Kind, COMDATSymName, Type);
419   return false;
420 }
421 
422 bool COFFAsmParser::ParseDirectiveDef(StringRef, SMLoc) {
423   StringRef SymbolName;
424 
425   if (getParser().parseIdentifier(SymbolName))
426     return TokError("expected identifier in directive");
427 
428   MCSymbol *Sym = getContext().getOrCreateSymbol(SymbolName);
429 
430   getStreamer().BeginCOFFSymbolDef(Sym);
431 
432   Lex();
433   return false;
434 }
435 
436 bool COFFAsmParser::ParseDirectiveScl(StringRef, SMLoc) {
437   int64_t SymbolStorageClass;
438   if (getParser().parseAbsoluteExpression(SymbolStorageClass))
439     return true;
440 
441   if (getLexer().isNot(AsmToken::EndOfStatement))
442     return TokError("unexpected token in directive");
443 
444   Lex();
445   getStreamer().EmitCOFFSymbolStorageClass(SymbolStorageClass);
446   return false;
447 }
448 
449 bool COFFAsmParser::ParseDirectiveType(StringRef, SMLoc) {
450   int64_t Type;
451   if (getParser().parseAbsoluteExpression(Type))
452     return true;
453 
454   if (getLexer().isNot(AsmToken::EndOfStatement))
455     return TokError("unexpected token in directive");
456 
457   Lex();
458   getStreamer().EmitCOFFSymbolType(Type);
459   return false;
460 }
461 
462 bool COFFAsmParser::ParseDirectiveEndef(StringRef, SMLoc) {
463   Lex();
464   getStreamer().EndCOFFSymbolDef();
465   return false;
466 }
467 
468 bool COFFAsmParser::ParseDirectiveSecRel32(StringRef, SMLoc) {
469   StringRef SymbolID;
470   if (getParser().parseIdentifier(SymbolID))
471     return TokError("expected identifier in directive");
472 
473   int64_t Offset = 0;
474   SMLoc OffsetLoc;
475   if (getLexer().is(AsmToken::Plus)) {
476     OffsetLoc = getLexer().getLoc();
477     if (getParser().parseAbsoluteExpression(Offset))
478       return true;
479   }
480 
481   if (getLexer().isNot(AsmToken::EndOfStatement))
482     return TokError("unexpected token in directive");
483 
484   if (Offset < 0 || Offset > std::numeric_limits<uint32_t>::max())
485     return Error(
486         OffsetLoc,
487         "invalid '.secrel32' directive offset, can't be less "
488         "than zero or greater than std::numeric_limits<uint32_t>::max()");
489 
490   MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
491 
492   Lex();
493   getStreamer().EmitCOFFSecRel32(Symbol, Offset);
494   return false;
495 }
496 
497 bool COFFAsmParser::ParseDirectiveRVA(StringRef, SMLoc) {
498   auto parseOp = [&]() -> bool {
499     StringRef SymbolID;
500     if (getParser().parseIdentifier(SymbolID))
501       return TokError("expected identifier in directive");
502 
503     int64_t Offset = 0;
504     SMLoc OffsetLoc;
505     if (getLexer().is(AsmToken::Plus) || getLexer().is(AsmToken::Minus)) {
506       OffsetLoc = getLexer().getLoc();
507       if (getParser().parseAbsoluteExpression(Offset))
508         return true;
509     }
510 
511     if (Offset < std::numeric_limits<int32_t>::min() ||
512         Offset > std::numeric_limits<int32_t>::max())
513       return Error(OffsetLoc, "invalid '.rva' directive offset, can't be less "
514                               "than -2147483648 or greater than "
515                               "2147483647");
516 
517     MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
518 
519     getStreamer().EmitCOFFImgRel32(Symbol, Offset);
520     return false;
521   };
522 
523   if (getParser().parseMany(parseOp))
524     return addErrorSuffix(" in directive");
525   return false;
526 }
527 
528 bool COFFAsmParser::ParseDirectiveSafeSEH(StringRef, SMLoc) {
529   StringRef SymbolID;
530   if (getParser().parseIdentifier(SymbolID))
531     return TokError("expected identifier in directive");
532 
533   if (getLexer().isNot(AsmToken::EndOfStatement))
534     return TokError("unexpected token in directive");
535 
536   MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
537 
538   Lex();
539   getStreamer().EmitCOFFSafeSEH(Symbol);
540   return false;
541 }
542 
543 bool COFFAsmParser::ParseDirectiveSecIdx(StringRef, SMLoc) {
544   StringRef SymbolID;
545   if (getParser().parseIdentifier(SymbolID))
546     return TokError("expected identifier in directive");
547 
548   if (getLexer().isNot(AsmToken::EndOfStatement))
549     return TokError("unexpected token in directive");
550 
551   MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
552 
553   Lex();
554   getStreamer().EmitCOFFSectionIndex(Symbol);
555   return false;
556 }
557 
558 bool COFFAsmParser::ParseDirectiveSymIdx(StringRef, SMLoc) {
559   StringRef SymbolID;
560   if (getParser().parseIdentifier(SymbolID))
561     return TokError("expected identifier in directive");
562 
563   if (getLexer().isNot(AsmToken::EndOfStatement))
564     return TokError("unexpected token in directive");
565 
566   MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
567 
568   Lex();
569   getStreamer().EmitCOFFSymbolIndex(Symbol);
570   return false;
571 }
572 
573 /// ::= [ identifier ]
574 bool COFFAsmParser::parseCOMDATType(COFF::COMDATType &Type) {
575   StringRef TypeId = getTok().getIdentifier();
576 
577   Type = StringSwitch<COFF::COMDATType>(TypeId)
578     .Case("one_only", COFF::IMAGE_COMDAT_SELECT_NODUPLICATES)
579     .Case("discard", COFF::IMAGE_COMDAT_SELECT_ANY)
580     .Case("same_size", COFF::IMAGE_COMDAT_SELECT_SAME_SIZE)
581     .Case("same_contents", COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH)
582     .Case("associative", COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
583     .Case("largest", COFF::IMAGE_COMDAT_SELECT_LARGEST)
584     .Case("newest", COFF::IMAGE_COMDAT_SELECT_NEWEST)
585     .Default((COFF::COMDATType)0);
586 
587   if (Type == 0)
588     return TokError(Twine("unrecognized COMDAT type '" + TypeId + "'"));
589 
590   Lex();
591 
592   return false;
593 }
594 
595 /// ParseDirectiveLinkOnce
596 ///  ::= .linkonce [ identifier ]
597 bool COFFAsmParser::ParseDirectiveLinkOnce(StringRef, SMLoc Loc) {
598   COFF::COMDATType Type = COFF::IMAGE_COMDAT_SELECT_ANY;
599   if (getLexer().is(AsmToken::Identifier))
600     if (parseCOMDATType(Type))
601       return true;
602 
603   const MCSectionCOFF *Current =
604       static_cast<const MCSectionCOFF *>(getStreamer().getCurrentSectionOnly());
605 
606   if (Type == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
607     return Error(Loc, "cannot make section associative with .linkonce");
608 
609   if (Current->getCharacteristics() & COFF::IMAGE_SCN_LNK_COMDAT)
610     return Error(Loc, Twine("section '") + Current->getSectionName() +
611                                                        "' is already linkonce");
612 
613   Current->setSelection(Type);
614 
615   if (getLexer().isNot(AsmToken::EndOfStatement))
616     return TokError("unexpected token in directive");
617 
618   return false;
619 }
620 
621 bool COFFAsmParser::ParseSEHDirectiveStartProc(StringRef, SMLoc Loc) {
622   StringRef SymbolID;
623   if (getParser().parseIdentifier(SymbolID))
624     return true;
625 
626   if (getLexer().isNot(AsmToken::EndOfStatement))
627     return TokError("unexpected token in directive");
628 
629   MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
630 
631   Lex();
632   getStreamer().EmitWinCFIStartProc(Symbol, Loc);
633   return false;
634 }
635 
636 bool COFFAsmParser::ParseSEHDirectiveEndProc(StringRef, SMLoc Loc) {
637   Lex();
638   getStreamer().EmitWinCFIEndProc(Loc);
639   return false;
640 }
641 
642 bool COFFAsmParser::ParseSEHDirectiveStartChained(StringRef, SMLoc Loc) {
643   Lex();
644   getStreamer().EmitWinCFIStartChained(Loc);
645   return false;
646 }
647 
648 bool COFFAsmParser::ParseSEHDirectiveEndChained(StringRef, SMLoc Loc) {
649   Lex();
650   getStreamer().EmitWinCFIEndChained(Loc);
651   return false;
652 }
653 
654 bool COFFAsmParser::ParseSEHDirectiveHandler(StringRef, SMLoc Loc) {
655   StringRef SymbolID;
656   if (getParser().parseIdentifier(SymbolID))
657     return true;
658 
659   if (getLexer().isNot(AsmToken::Comma))
660     return TokError("you must specify one or both of @unwind or @except");
661   Lex();
662   bool unwind = false, except = false;
663   if (ParseAtUnwindOrAtExcept(unwind, except))
664     return true;
665   if (getLexer().is(AsmToken::Comma)) {
666     Lex();
667     if (ParseAtUnwindOrAtExcept(unwind, except))
668       return true;
669   }
670   if (getLexer().isNot(AsmToken::EndOfStatement))
671     return TokError("unexpected token in directive");
672 
673   MCSymbol *handler = getContext().getOrCreateSymbol(SymbolID);
674 
675   Lex();
676   getStreamer().EmitWinEHHandler(handler, unwind, except, Loc);
677   return false;
678 }
679 
680 bool COFFAsmParser::ParseSEHDirectiveHandlerData(StringRef, SMLoc Loc) {
681   Lex();
682   getStreamer().EmitWinEHHandlerData();
683   return false;
684 }
685 
686 bool COFFAsmParser::ParseSEHDirectivePushReg(StringRef, SMLoc Loc) {
687   unsigned Reg = 0;
688   if (ParseSEHRegisterNumber(Reg))
689     return true;
690 
691   if (getLexer().isNot(AsmToken::EndOfStatement))
692     return TokError("unexpected token in directive");
693 
694   Lex();
695   getStreamer().EmitWinCFIPushReg(Reg, Loc);
696   return false;
697 }
698 
699 bool COFFAsmParser::ParseSEHDirectiveSetFrame(StringRef, SMLoc Loc) {
700   unsigned Reg = 0;
701   int64_t Off;
702   if (ParseSEHRegisterNumber(Reg))
703     return true;
704   if (getLexer().isNot(AsmToken::Comma))
705     return TokError("you must specify a stack pointer offset");
706 
707   Lex();
708   if (getParser().parseAbsoluteExpression(Off))
709     return true;
710 
711   if (getLexer().isNot(AsmToken::EndOfStatement))
712     return TokError("unexpected token in directive");
713 
714   Lex();
715   getStreamer().EmitWinCFISetFrame(Reg, Off, Loc);
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::ParseSEHDirectiveSaveReg(StringRef, SMLoc Loc) {
733   unsigned Reg = 0;
734   int64_t Off;
735   if (ParseSEHRegisterNumber(Reg))
736     return true;
737   if (getLexer().isNot(AsmToken::Comma))
738     return TokError("you must specify an offset on the stack");
739 
740   Lex();
741   if (getParser().parseAbsoluteExpression(Off))
742     return true;
743 
744   if (getLexer().isNot(AsmToken::EndOfStatement))
745     return TokError("unexpected token in directive");
746 
747   Lex();
748   // FIXME: Err on %xmm* registers
749   getStreamer().EmitWinCFISaveReg(Reg, Off, Loc);
750   return false;
751 }
752 
753 // FIXME: This method is inherently x86-specific. It should really be in the
754 // x86 backend.
755 bool COFFAsmParser::ParseSEHDirectiveSaveXMM(StringRef, SMLoc Loc) {
756   unsigned Reg = 0;
757   int64_t Off;
758   if (ParseSEHRegisterNumber(Reg))
759     return true;
760   if (getLexer().isNot(AsmToken::Comma))
761     return TokError("you must specify an offset on the stack");
762 
763   Lex();
764   if (getParser().parseAbsoluteExpression(Off))
765     return true;
766 
767   if (getLexer().isNot(AsmToken::EndOfStatement))
768     return TokError("unexpected token in directive");
769 
770   Lex();
771   // FIXME: Err on non-%xmm* registers
772   getStreamer().EmitWinCFISaveXMM(Reg, Off, Loc);
773   return false;
774 }
775 
776 bool COFFAsmParser::ParseSEHDirectivePushFrame(StringRef, SMLoc Loc) {
777   bool Code = false;
778   StringRef CodeID;
779   if (getLexer().is(AsmToken::At)) {
780     SMLoc startLoc = getLexer().getLoc();
781     Lex();
782     if (!getParser().parseIdentifier(CodeID)) {
783       if (CodeID != "code")
784         return Error(startLoc, "expected @code");
785       Code = true;
786     }
787   }
788 
789   if (getLexer().isNot(AsmToken::EndOfStatement))
790     return TokError("unexpected token in directive");
791 
792   Lex();
793   getStreamer().EmitWinCFIPushFrame(Code, Loc);
794   return false;
795 }
796 
797 bool COFFAsmParser::ParseSEHDirectiveEndProlog(StringRef, SMLoc Loc) {
798   Lex();
799   getStreamer().EmitWinCFIEndProlog(Loc);
800   return false;
801 }
802 
803 bool COFFAsmParser::ParseAtUnwindOrAtExcept(bool &unwind, bool &except) {
804   StringRef identifier;
805   if (getLexer().isNot(AsmToken::At))
806     return TokError("a handler attribute must begin with '@'");
807   SMLoc startLoc = getLexer().getLoc();
808   Lex();
809   if (getParser().parseIdentifier(identifier))
810     return Error(startLoc, "expected @unwind or @except");
811   if (identifier == "unwind")
812     unwind = true;
813   else if (identifier == "except")
814     except = true;
815   else
816     return Error(startLoc, "expected @unwind or @except");
817   return false;
818 }
819 
820 bool COFFAsmParser::ParseSEHRegisterNumber(unsigned &RegNo) {
821   SMLoc startLoc = getLexer().getLoc();
822   if (getLexer().is(AsmToken::Percent)) {
823     const MCRegisterInfo *MRI = getContext().getRegisterInfo();
824     SMLoc endLoc;
825     unsigned LLVMRegNo;
826     if (getParser().getTargetParser().ParseRegister(LLVMRegNo,startLoc,endLoc))
827       return true;
828 
829 #if 0
830     // FIXME: TargetAsmInfo::getCalleeSavedRegs() commits a serious layering
831     // violation so this validation code is disabled.
832 
833     // Check that this is a non-volatile register.
834     const unsigned *NVRegs = TAI.getCalleeSavedRegs();
835     unsigned i;
836     for (i = 0; NVRegs[i] != 0; ++i)
837       if (NVRegs[i] == LLVMRegNo)
838         break;
839     if (NVRegs[i] == 0)
840       return Error(startLoc, "expected non-volatile register");
841 #endif
842 
843     int SEHRegNo = MRI->getSEHRegNum(LLVMRegNo);
844     if (SEHRegNo < 0)
845       return Error(startLoc,"register can't be represented in SEH unwind info");
846     RegNo = SEHRegNo;
847   }
848   else {
849     int64_t n;
850     if (getParser().parseAbsoluteExpression(n))
851       return true;
852     if (n > 15)
853       return Error(startLoc, "register number is too high");
854     RegNo = n;
855   }
856 
857   return false;
858 }
859 
860 namespace llvm {
861 
862 MCAsmParserExtension *createCOFFAsmParser() {
863   return new COFFAsmParser;
864 }
865 
866 } // end namespace llvm
867