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