1 //===- COFFMasmParser.cpp - COFF MASM 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/Twine.h"
11 #include "llvm/BinaryFormat/COFF.h"
12 #include "llvm/MC/MCAsmMacro.h"
13 #include "llvm/MC/MCContext.h"
14 #include "llvm/MC/MCParser/MCAsmLexer.h"
15 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
16 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
17 #include "llvm/MC/MCSectionCOFF.h"
18 #include "llvm/MC/MCStreamer.h"
19 #include "llvm/MC/MCSymbolCOFF.h"
20 #include "llvm/MC/SectionKind.h"
21 #include "llvm/Support/Casting.h"
22 #include "llvm/Support/SMLoc.h"
23 #include <cstdint>
24 #include <utility>
25 
26 using namespace llvm;
27 
28 namespace {
29 
30 class COFFMasmParser : public MCAsmParserExtension {
31   template <bool (COFFMasmParser::*HandlerMethod)(StringRef, SMLoc)>
32   void addDirectiveHandler(StringRef Directive) {
33     MCAsmParser::ExtensionDirectiveHandler Handler =
34         std::make_pair(this, HandleDirective<COFFMasmParser, HandlerMethod>);
35     getParser().addDirectiveHandler(Directive, Handler);
36   }
37 
38   bool ParseSectionSwitch(StringRef SectionName, unsigned Characteristics,
39                           SectionKind Kind);
40 
41   bool ParseSectionSwitch(StringRef SectionName, unsigned Characteristics,
42                           SectionKind Kind, StringRef COMDATSymName,
43                           COFF::COMDATType Type, Align Alignment);
44 
45   bool ParseDirectiveProc(StringRef, SMLoc);
46   bool ParseDirectiveEndProc(StringRef, SMLoc);
47   bool ParseDirectiveSegment(StringRef, SMLoc);
48   bool ParseDirectiveSegmentEnd(StringRef, SMLoc);
49   bool ParseDirectiveIncludelib(StringRef, SMLoc);
50   bool ParseDirectiveOption(StringRef, SMLoc);
51 
52   bool ParseDirectiveAlias(StringRef, SMLoc);
53 
54   bool ParseSEHDirectiveAllocStack(StringRef, SMLoc);
55   bool ParseSEHDirectiveEndProlog(StringRef, SMLoc);
56 
57   bool IgnoreDirective(StringRef, SMLoc) {
58     while (!getLexer().is(AsmToken::EndOfStatement)) {
59       Lex();
60     }
61     return false;
62   }
63 
64   void Initialize(MCAsmParser &Parser) override {
65     // Call the base implementation.
66     MCAsmParserExtension::Initialize(Parser);
67 
68     // x64 directives
69     addDirectiveHandler<&COFFMasmParser::ParseSEHDirectiveAllocStack>(
70         ".allocstack");
71     addDirectiveHandler<&COFFMasmParser::ParseSEHDirectiveEndProlog>(
72         ".endprolog");
73 
74     // Code label directives
75     // label
76     // org
77 
78     // Conditional control flow directives
79     // .break
80     // .continue
81     // .else
82     // .elseif
83     // .endif
84     // .endw
85     // .if
86     // .repeat
87     // .until
88     // .untilcxz
89     // .while
90 
91     // Data allocation directives
92     // align
93     // even
94     // mmword
95     // tbyte
96     // xmmword
97     // ymmword
98 
99     // Listing control directives
100     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".cref");
101     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".list");
102     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".listall");
103     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".listif");
104     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".listmacro");
105     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".listmacroall");
106     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".nocref");
107     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".nolist");
108     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".nolistif");
109     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".nolistmacro");
110     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>("page");
111     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>("subtitle");
112     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".tfcond");
113     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>("title");
114 
115     // Macro directives
116     // goto
117 
118     // Miscellaneous directives
119     addDirectiveHandler<&COFFMasmParser::ParseDirectiveAlias>("alias");
120     // assume
121     // .fpo
122     addDirectiveHandler<&COFFMasmParser::ParseDirectiveIncludelib>(
123         "includelib");
124     addDirectiveHandler<&COFFMasmParser::ParseDirectiveOption>("option");
125     // popcontext
126     // pushcontext
127     // .safeseh
128 
129     // Procedure directives
130     addDirectiveHandler<&COFFMasmParser::ParseDirectiveEndProc>("endp");
131     // invoke (32-bit only)
132     addDirectiveHandler<&COFFMasmParser::ParseDirectiveProc>("proc");
133     // proto
134 
135     // Processor directives; all ignored
136     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".386");
137     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".386p");
138     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".387");
139     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".486");
140     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".486p");
141     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".586");
142     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".586p");
143     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".686");
144     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".686p");
145     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".k3d");
146     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".mmx");
147     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".xmm");
148 
149     // Scope directives
150     // comm
151     // externdef
152 
153     // Segment directives
154     // .alpha (32-bit only, order segments alphabetically)
155     // .dosseg (32-bit only, order segments in DOS convention)
156     // .seq (32-bit only, order segments sequentially)
157     addDirectiveHandler<&COFFMasmParser::ParseDirectiveSegmentEnd>("ends");
158     // group (32-bit only)
159     addDirectiveHandler<&COFFMasmParser::ParseDirectiveSegment>("segment");
160 
161     // Simplified segment directives
162     addDirectiveHandler<&COFFMasmParser::ParseSectionDirectiveCode>(".code");
163     // .const
164     addDirectiveHandler<
165         &COFFMasmParser::ParseSectionDirectiveInitializedData>(".data");
166     addDirectiveHandler<
167         &COFFMasmParser::ParseSectionDirectiveUninitializedData>(".data?");
168     // .exit
169     // .fardata
170     // .fardata?
171     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".model");
172     // .stack
173     // .startup
174 
175     // String directives, written <name> <directive> <params>
176     // catstr (equivalent to <name> TEXTEQU <params>)
177     // instr (equivalent to <name> = @InStr(<params>))
178     // sizestr (equivalent to <name> = @SizeStr(<params>))
179     // substr (equivalent to <name> TEXTEQU @SubStr(<params>))
180 
181     // Structure and record directives
182     // record
183     // typedef
184   }
185 
186   bool ParseSectionDirectiveCode(StringRef, SMLoc) {
187     return ParseSectionSwitch(".text",
188                               COFF::IMAGE_SCN_CNT_CODE
189                             | COFF::IMAGE_SCN_MEM_EXECUTE
190                             | COFF::IMAGE_SCN_MEM_READ,
191                               SectionKind::getText());
192   }
193 
194   bool ParseSectionDirectiveInitializedData(StringRef, SMLoc) {
195     return ParseSectionSwitch(".data",
196                               COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
197                             | COFF::IMAGE_SCN_MEM_READ
198                             | COFF::IMAGE_SCN_MEM_WRITE,
199                               SectionKind::getData());
200   }
201 
202   bool ParseSectionDirectiveUninitializedData(StringRef, SMLoc) {
203     return ParseSectionSwitch(".bss",
204                               COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA
205                             | COFF::IMAGE_SCN_MEM_READ
206                             | COFF::IMAGE_SCN_MEM_WRITE,
207                               SectionKind::getBSS());
208   }
209 
210   /// Stack of active procedure definitions.
211   SmallVector<StringRef, 1> CurrentProcedures;
212   SmallVector<bool, 1> CurrentProceduresFramed;
213 
214 public:
215   COFFMasmParser() = default;
216 };
217 
218 } // end anonymous namespace.
219 
220 bool COFFMasmParser::ParseSectionSwitch(StringRef SectionName,
221                                         unsigned Characteristics,
222                                         SectionKind Kind) {
223   return ParseSectionSwitch(SectionName, Characteristics, Kind, "",
224                             (COFF::COMDATType)0, Align(16));
225 }
226 
227 bool COFFMasmParser::ParseSectionSwitch(
228     StringRef SectionName, unsigned Characteristics, SectionKind Kind,
229     StringRef COMDATSymName, COFF::COMDATType Type, Align Alignment) {
230   if (getLexer().isNot(AsmToken::EndOfStatement))
231     return TokError("unexpected token in section switching directive");
232   Lex();
233 
234   MCSection *Section = getContext().getCOFFSection(SectionName, Characteristics,
235                                                    Kind, COMDATSymName, Type);
236   Section->setAlignment(Alignment);
237   getStreamer().switchSection(Section);
238 
239   return false;
240 }
241 
242 bool COFFMasmParser::ParseDirectiveSegment(StringRef Directive, SMLoc Loc) {
243   StringRef SegmentName;
244   if (!getLexer().is(AsmToken::Identifier))
245     return TokError("expected identifier in directive");
246   SegmentName = getTok().getIdentifier();
247   Lex();
248 
249   StringRef SectionName = SegmentName;
250   SmallVector<char, 247> SectionNameVector;
251 
252   StringRef Class;
253   if (SegmentName == "_TEXT" || SegmentName.startswith("_TEXT$")) {
254     if (SegmentName.size() == 5) {
255       SectionName = ".text";
256     } else {
257       SectionName =
258           (".text$" + SegmentName.substr(6)).toStringRef(SectionNameVector);
259     }
260     Class = "CODE";
261   }
262 
263   // Parse all options to end of statement.
264   // Alignment defaults to PARA if unspecified.
265   int64_t Alignment = 16;
266   // Default flags are used only if no characteristics are set.
267   bool DefaultCharacteristics = true;
268   unsigned Flags = 0;
269   // "obsolete" according to the documentation, but still supported.
270   bool Readonly = false;
271   while (getLexer().isNot(AsmToken::EndOfStatement)) {
272     switch (getTok().getKind()) {
273     default:
274       break;
275     case AsmToken::String: {
276       // Class identifier; overrides Kind.
277       Class = getTok().getStringContents();
278       Lex();
279       break;
280     }
281     case AsmToken::Identifier: {
282       SMLoc KeywordLoc = getTok().getLoc();
283       StringRef Keyword;
284       if (getParser().parseIdentifier(Keyword)) {
285         llvm_unreachable("failed to parse identifier at an identifier token");
286       }
287       if (Keyword.equals_insensitive("byte")) {
288         Alignment = 1;
289       } else if (Keyword.equals_insensitive("word")) {
290         Alignment = 2;
291       } else if (Keyword.equals_insensitive("dword")) {
292         Alignment = 4;
293       } else if (Keyword.equals_insensitive("para")) {
294         Alignment = 16;
295       } else if (Keyword.equals_insensitive("page")) {
296         Alignment = 256;
297       } else if (Keyword.equals_insensitive("align")) {
298         if (getParser().parseToken(AsmToken::LParen) ||
299             getParser().parseIntToken(Alignment,
300                                       "Expected integer alignment") ||
301             getParser().parseToken(AsmToken::RParen)) {
302           return Error(getTok().getLoc(),
303                        "Expected (n) following ALIGN in SEGMENT directive");
304         }
305         if (!isPowerOf2_64(Alignment) || Alignment > 8192) {
306           return Error(KeywordLoc,
307                        "ALIGN argument must be a power of 2 from 1 to 8192");
308         }
309       } else if (Keyword.equals_insensitive("alias")) {
310         if (getParser().parseToken(AsmToken::LParen) ||
311             !getTok().is(AsmToken::String))
312           return Error(
313               getTok().getLoc(),
314               "Expected (string) following ALIAS in SEGMENT directive");
315         SectionName = getTok().getStringContents();
316         Lex();
317         if (getParser().parseToken(AsmToken::RParen))
318           return Error(
319               getTok().getLoc(),
320               "Expected (string) following ALIAS in SEGMENT directive");
321       } else if (Keyword.equals_insensitive("readonly")) {
322         Readonly = true;
323       } else {
324         unsigned Characteristic =
325             StringSwitch<unsigned>(Keyword)
326                 .CaseLower("info", COFF::IMAGE_SCN_LNK_INFO)
327                 .CaseLower("read", COFF::IMAGE_SCN_MEM_READ)
328                 .CaseLower("write", COFF::IMAGE_SCN_MEM_WRITE)
329                 .CaseLower("execute", COFF::IMAGE_SCN_MEM_EXECUTE)
330                 .CaseLower("shared", COFF::IMAGE_SCN_MEM_SHARED)
331                 .CaseLower("nopage", COFF::IMAGE_SCN_MEM_NOT_PAGED)
332                 .CaseLower("nocache", COFF::IMAGE_SCN_MEM_NOT_CACHED)
333                 .CaseLower("discard", COFF::IMAGE_SCN_MEM_DISCARDABLE)
334                 .Default(-1);
335         if (Characteristic == static_cast<unsigned>(-1)) {
336           return Error(KeywordLoc,
337                        "Expected characteristic in SEGMENT directive; found '" +
338                            Keyword + "'");
339         }
340         Flags |= Characteristic;
341         DefaultCharacteristics = false;
342       }
343     }
344     }
345   }
346 
347   SectionKind Kind = StringSwitch<SectionKind>(Class)
348                          .CaseLower("data", SectionKind::getData())
349                          .CaseLower("code", SectionKind::getText())
350                          .CaseLower("const", SectionKind::getReadOnly())
351                          .Default(SectionKind::getData());
352   if (Kind.isText()) {
353     if (DefaultCharacteristics) {
354       Flags |= COFF::IMAGE_SCN_MEM_EXECUTE | COFF::IMAGE_SCN_MEM_READ;
355     }
356     Flags |= COFF::IMAGE_SCN_CNT_CODE;
357   } else {
358     if (DefaultCharacteristics) {
359       Flags |= COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE;
360     }
361     Flags |= COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
362   }
363   if (Readonly) {
364     Flags &= ~COFF::IMAGE_SCN_MEM_WRITE;
365   }
366 
367   MCSection *Section = getContext().getCOFFSection(SectionName, Flags, Kind, "",
368                                                    (COFF::COMDATType)(0));
369   if (Alignment != 0) {
370     Section->setAlignment(Align(Alignment));
371   }
372   getStreamer().switchSection(Section);
373   return false;
374 }
375 
376 /// ParseDirectiveSegmentEnd
377 ///  ::= identifier "ends"
378 bool COFFMasmParser::ParseDirectiveSegmentEnd(StringRef Directive, SMLoc Loc) {
379   StringRef SegmentName;
380   if (!getLexer().is(AsmToken::Identifier))
381     return TokError("expected identifier in directive");
382   SegmentName = getTok().getIdentifier();
383 
384   // Ignore; no action necessary.
385   Lex();
386   return false;
387 }
388 
389 /// ParseDirectiveIncludelib
390 ///  ::= "includelib" identifier
391 bool COFFMasmParser::ParseDirectiveIncludelib(StringRef Directive, SMLoc Loc) {
392   StringRef Lib;
393   if (getParser().parseIdentifier(Lib))
394     return TokError("expected identifier in includelib directive");
395 
396   unsigned Flags = COFF::IMAGE_SCN_MEM_PRELOAD | COFF::IMAGE_SCN_MEM_16BIT;
397   SectionKind Kind = SectionKind::getData();
398   getStreamer().pushSection();
399   getStreamer().switchSection(getContext().getCOFFSection(
400       ".drectve", Flags, Kind, "", (COFF::COMDATType)(0)));
401   getStreamer().emitBytes("/DEFAULTLIB:");
402   getStreamer().emitBytes(Lib);
403   getStreamer().emitBytes(" ");
404   getStreamer().popSection();
405   return false;
406 }
407 
408 /// ParseDirectiveOption
409 ///  ::= "option" option-list
410 bool COFFMasmParser::ParseDirectiveOption(StringRef Directive, SMLoc Loc) {
411   auto parseOption = [&]() -> bool {
412     StringRef Option;
413     if (getParser().parseIdentifier(Option))
414       return TokError("expected identifier for option name");
415     if (Option.equals_insensitive("prologue")) {
416       StringRef MacroId;
417       if (parseToken(AsmToken::Colon) || getParser().parseIdentifier(MacroId))
418         return TokError("expected :macroId after OPTION PROLOGUE");
419       if (MacroId.equals_insensitive("none")) {
420         // Since we currently don't implement prologues/epilogues, NONE is our
421         // default.
422         return false;
423       }
424       return TokError("OPTION PROLOGUE is currently unsupported");
425     }
426     if (Option.equals_insensitive("epilogue")) {
427       StringRef MacroId;
428       if (parseToken(AsmToken::Colon) || getParser().parseIdentifier(MacroId))
429         return TokError("expected :macroId after OPTION EPILOGUE");
430       if (MacroId.equals_insensitive("none")) {
431         // Since we currently don't implement prologues/epilogues, NONE is our
432         // default.
433         return false;
434       }
435       return TokError("OPTION EPILOGUE is currently unsupported");
436     }
437     return TokError("OPTION '" + Option + "' is currently unsupported");
438   };
439 
440   if (parseMany(parseOption))
441     return addErrorSuffix(" in OPTION directive");
442   return false;
443 }
444 
445 /// ParseDirectiveProc
446 /// TODO(epastor): Implement parameters and other attributes.
447 ///  ::= label "proc" [[distance]]
448 ///          statements
449 ///      label "endproc"
450 bool COFFMasmParser::ParseDirectiveProc(StringRef Directive, SMLoc Loc) {
451   StringRef Label;
452   if (getParser().parseIdentifier(Label))
453     return Error(Loc, "expected identifier for procedure");
454   if (getLexer().is(AsmToken::Identifier)) {
455     StringRef nextVal = getTok().getString();
456     SMLoc nextLoc = getTok().getLoc();
457     if (nextVal.equals_insensitive("far")) {
458       // TODO(epastor): Handle far procedure definitions.
459       Lex();
460       return Error(nextLoc, "far procedure definitions not yet supported");
461     } else if (nextVal.equals_insensitive("near")) {
462       Lex();
463       nextVal = getTok().getString();
464       nextLoc = getTok().getLoc();
465     }
466   }
467   MCSymbolCOFF *Sym = cast<MCSymbolCOFF>(getContext().getOrCreateSymbol(Label));
468 
469   // Define symbol as simple external function
470   Sym->setExternal(true);
471   Sym->setType(COFF::IMAGE_SYM_DTYPE_FUNCTION << COFF::SCT_COMPLEX_TYPE_SHIFT);
472 
473   bool Framed = false;
474   if (getLexer().is(AsmToken::Identifier) &&
475       getTok().getString().equals_insensitive("frame")) {
476     Lex();
477     Framed = true;
478     getStreamer().emitWinCFIStartProc(Sym, Loc);
479   }
480   getStreamer().emitLabel(Sym, Loc);
481 
482   CurrentProcedures.push_back(Label);
483   CurrentProceduresFramed.push_back(Framed);
484   return false;
485 }
486 bool COFFMasmParser::ParseDirectiveEndProc(StringRef Directive, SMLoc Loc) {
487   StringRef Label;
488   SMLoc LabelLoc = getTok().getLoc();
489   if (getParser().parseIdentifier(Label))
490     return Error(LabelLoc, "expected identifier for procedure end");
491 
492   if (CurrentProcedures.empty())
493     return Error(Loc, "endp outside of procedure block");
494   else if (!CurrentProcedures.back().equals_insensitive(Label))
495     return Error(LabelLoc, "endp does not match current procedure '" +
496                                CurrentProcedures.back() + "'");
497 
498   if (CurrentProceduresFramed.back()) {
499     getStreamer().emitWinCFIEndProc(Loc);
500   }
501   CurrentProcedures.pop_back();
502   CurrentProceduresFramed.pop_back();
503   return false;
504 }
505 
506 bool COFFMasmParser::ParseDirectiveAlias(StringRef Directive, SMLoc Loc) {
507   std::string AliasName, ActualName;
508   if (getTok().isNot(AsmToken::Less) ||
509       getParser().parseAngleBracketString(AliasName))
510     return Error(getTok().getLoc(), "expected <aliasName>");
511   if (getParser().parseToken(AsmToken::Equal))
512     return addErrorSuffix(" in " + Directive + " directive");
513   if (getTok().isNot(AsmToken::Less) ||
514       getParser().parseAngleBracketString(ActualName))
515     return Error(getTok().getLoc(), "expected <actualName>");
516 
517   MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName);
518   MCSymbol *Actual = getContext().getOrCreateSymbol(ActualName);
519 
520   getStreamer().emitWeakReference(Alias, Actual);
521 
522   return false;
523 }
524 
525 bool COFFMasmParser::ParseSEHDirectiveAllocStack(StringRef Directive,
526                                                  SMLoc Loc) {
527   int64_t Size;
528   SMLoc SizeLoc = getTok().getLoc();
529   if (getParser().parseAbsoluteExpression(Size))
530     return Error(SizeLoc, "expected integer size");
531   if (Size % 8 != 0)
532     return Error(SizeLoc, "stack size must be a multiple of 8");
533   getStreamer().emitWinCFIAllocStack(static_cast<unsigned>(Size), Loc);
534   return false;
535 }
536 
537 bool COFFMasmParser::ParseSEHDirectiveEndProlog(StringRef Directive,
538                                                 SMLoc Loc) {
539   getStreamer().emitWinCFIEndProlog(Loc);
540   return false;
541 }
542 
543 namespace llvm {
544 
545 MCAsmParserExtension *createCOFFMasmParser() { return new COFFMasmParser; }
546 
547 } // end namespace llvm
548