PageRenderTime 76ms CodeModel.GetById 12ms app.highlight 55ms RepoModel.GetById 1ms app.codeStats 1ms

/3rd_party/llvm/lib/MC/MCParser/COFFAsmParser.cpp

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