xref: /freebsd/contrib/llvm-project/llvm/lib/MC/MCParser/COFFMasmParser.cpp (revision 5956d97f4b3204318ceb6aa9c77bd0bc6ea87a41) 
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/Triple.h"
11 #include "llvm/ADT/Twine.h"
12 #include "llvm/BinaryFormat/COFF.h"
13 #include "llvm/MC/MCContext.h"
14 #include "llvm/MC/MCDirectives.h"
15 #include "llvm/MC/MCObjectFileInfo.h"
16 #include "llvm/MC/MCParser/MCAsmLexer.h"
17 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
18 #include "llvm/MC/MCParser/MCAsmParserUtils.h"
19 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
20 #include "llvm/MC/MCRegisterInfo.h"
21 #include "llvm/MC/MCSectionCOFF.h"
22 #include "llvm/MC/MCStreamer.h"
23 #include "llvm/MC/MCSymbolCOFF.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 COFFMasmParser : public MCAsmParserExtension {
36   template <bool (COFFMasmParser::*HandlerMethod)(StringRef, SMLoc)>
37   void addDirectiveHandler(StringRef Directive) {
38     MCAsmParser::ExtensionDirectiveHandler Handler =
39         std::make_pair(this, HandleDirective<COFFMasmParser, HandlerMethod>);
40     getParser().addDirectiveHandler(Directive, Handler);
41   }
42 
43   bool ParseSectionSwitch(StringRef Section, unsigned Characteristics,
44                           SectionKind Kind);
45 
46   bool ParseSectionSwitch(StringRef Section, unsigned Characteristics,
47                           SectionKind Kind, StringRef COMDATSymName,
48                           COFF::COMDATType Type);
49 
50   bool ParseDirectiveProc(StringRef, SMLoc);
51   bool ParseDirectiveEndProc(StringRef, SMLoc);
52   bool ParseDirectiveSegment(StringRef, SMLoc);
53   bool ParseDirectiveSegmentEnd(StringRef, SMLoc);
54   bool ParseDirectiveIncludelib(StringRef, SMLoc);
55 
56   bool ParseDirectiveAlias(StringRef, SMLoc);
57 
58   bool ParseSEHDirectiveAllocStack(StringRef, SMLoc);
59   bool ParseSEHDirectiveEndProlog(StringRef, SMLoc);
60 
61   bool IgnoreDirective(StringRef, SMLoc) {
62     while (!getLexer().is(AsmToken::EndOfStatement)) {
63       Lex();
64     }
65     return false;
66   }
67 
68   void Initialize(MCAsmParser &Parser) override {
69     // Call the base implementation.
70     MCAsmParserExtension::Initialize(Parser);
71 
72     // x64 directives
73     addDirectiveHandler<&COFFMasmParser::ParseSEHDirectiveAllocStack>(
74         ".allocstack");
75     addDirectiveHandler<&COFFMasmParser::ParseSEHDirectiveEndProlog>(
76         ".endprolog");
77 
78     // Code label directives
79     // label
80     // org
81 
82     // Conditional control flow directives
83     // .break
84     // .continue
85     // .else
86     // .elseif
87     // .endif
88     // .endw
89     // .if
90     // .repeat
91     // .until
92     // .untilcxz
93     // .while
94 
95     // Data allocation directives
96     // align
97     // even
98     // mmword
99     // tbyte
100     // xmmword
101     // ymmword
102 
103     // Listing control directives
104     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".cref");
105     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".list");
106     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".listall");
107     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".listif");
108     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".listmacro");
109     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".listmacroall");
110     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".nocref");
111     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".nolist");
112     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".nolistif");
113     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".nolistmacro");
114     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>("page");
115     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>("subtitle");
116     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".tfcond");
117     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>("title");
118 
119     // Macro directives
120     // goto
121 
122     // Miscellaneous directives
123     addDirectiveHandler<&COFFMasmParser::ParseDirectiveAlias>("alias");
124     // assume
125     // .fpo
126     addDirectiveHandler<&COFFMasmParser::ParseDirectiveIncludelib>(
127         "includelib");
128     // option
129     // popcontext
130     // pushcontext
131     // .safeseh
132 
133     // Procedure directives
134     addDirectiveHandler<&COFFMasmParser::ParseDirectiveEndProc>("endp");
135     // invoke (32-bit only)
136     addDirectiveHandler<&COFFMasmParser::ParseDirectiveProc>("proc");
137     // proto
138 
139     // Processor directives; all ignored
140     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".386");
141     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".386p");
142     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".387");
143     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".486");
144     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".486p");
145     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".586");
146     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".586p");
147     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".686");
148     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".686p");
149     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".k3d");
150     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".mmx");
151     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".xmm");
152 
153     // Scope directives
154     // comm
155     // externdef
156 
157     // Segment directives
158     // .alpha (32-bit only, order segments alphabetically)
159     // .dosseg (32-bit only, order segments in DOS convention)
160     // .seq (32-bit only, order segments sequentially)
161     addDirectiveHandler<&COFFMasmParser::ParseDirectiveSegmentEnd>("ends");
162     // group (32-bit only)
163     addDirectiveHandler<&COFFMasmParser::ParseDirectiveSegment>("segment");
164 
165     // Simplified segment directives
166     addDirectiveHandler<&COFFMasmParser::ParseSectionDirectiveCode>(".code");
167     // .const
168     addDirectiveHandler<
169         &COFFMasmParser::ParseSectionDirectiveInitializedData>(".data");
170     addDirectiveHandler<
171         &COFFMasmParser::ParseSectionDirectiveUninitializedData>(".data?");
172     // .exit
173     // .fardata
174     // .fardata?
175     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".model");
176     // .stack
177     // .startup
178 
179     // String directives, written <name> <directive> <params>
180     // catstr (equivalent to <name> TEXTEQU <params>)
181     // instr (equivalent to <name> = @InStr(<params>))
182     // sizestr (equivalent to <name> = @SizeStr(<params>))
183     // substr (equivalent to <name> TEXTEQU @SubStr(<params>))
184 
185     // Structure and record directives
186     // record
187     // typedef
188   }
189 
190   bool ParseSectionDirectiveCode(StringRef, SMLoc) {
191     return ParseSectionSwitch(".text",
192                               COFF::IMAGE_SCN_CNT_CODE
193                             | COFF::IMAGE_SCN_MEM_EXECUTE
194                             | COFF::IMAGE_SCN_MEM_READ,
195                               SectionKind::getText());
196   }
197 
198   bool ParseSectionDirectiveInitializedData(StringRef, SMLoc) {
199     return ParseSectionSwitch(".data",
200                               COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
201                             | COFF::IMAGE_SCN_MEM_READ
202                             | COFF::IMAGE_SCN_MEM_WRITE,
203                               SectionKind::getData());
204   }
205 
206   bool ParseSectionDirectiveUninitializedData(StringRef, SMLoc) {
207     return ParseSectionSwitch(".bss",
208                               COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA
209                             | COFF::IMAGE_SCN_MEM_READ
210                             | COFF::IMAGE_SCN_MEM_WRITE,
211                               SectionKind::getBSS());
212   }
213 
214   StringRef CurrentProcedure;
215   bool CurrentProcedureFramed;
216 
217 public:
218   COFFMasmParser() = default;
219 };
220 
221 } // end anonymous namespace.
222 
223 static SectionKind computeSectionKind(unsigned Flags) {
224   if (Flags & COFF::IMAGE_SCN_MEM_EXECUTE)
225     return SectionKind::getText();
226   if (Flags & COFF::IMAGE_SCN_MEM_READ &&
227       (Flags & COFF::IMAGE_SCN_MEM_WRITE) == 0)
228     return SectionKind::getReadOnly();
229   return SectionKind::getData();
230 }
231 
232 bool COFFMasmParser::ParseSectionSwitch(StringRef Section,
233                                         unsigned Characteristics,
234                                         SectionKind Kind) {
235   return ParseSectionSwitch(Section, Characteristics, Kind, "",
236                             (COFF::COMDATType)0);
237 }
238 
239 bool COFFMasmParser::ParseSectionSwitch(StringRef Section,
240                                         unsigned Characteristics,
241                                         SectionKind Kind,
242                                         StringRef COMDATSymName,
243                                         COFF::COMDATType Type) {
244   if (getLexer().isNot(AsmToken::EndOfStatement))
245     return TokError("unexpected token in section switching directive");
246   Lex();
247 
248   getStreamer().SwitchSection(getContext().getCOFFSection(
249       Section, Characteristics, Kind, COMDATSymName, Type));
250 
251   return false;
252 }
253 
254 bool COFFMasmParser::ParseDirectiveSegment(StringRef Directive, SMLoc Loc) {
255   StringRef SegmentName;
256   if (!getLexer().is(AsmToken::Identifier))
257     return TokError("expected identifier in directive");
258   SegmentName = getTok().getIdentifier();
259   Lex();
260 
261   StringRef SectionName = SegmentName;
262   SmallVector<char, 247> SectionNameVector;
263   unsigned Flags = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
264                    COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE;
265   if (SegmentName == "_TEXT" || SegmentName.startswith("_TEXT$")) {
266     if (SegmentName.size() == 5) {
267       SectionName = ".text";
268     } else {
269       SectionName =
270           (".text$" + SegmentName.substr(6)).toStringRef(SectionNameVector);
271     }
272     Flags = COFF::IMAGE_SCN_CNT_CODE | COFF::IMAGE_SCN_MEM_EXECUTE |
273             COFF::IMAGE_SCN_MEM_READ;
274   }
275   SectionKind Kind = computeSectionKind(Flags);
276   getStreamer().SwitchSection(getContext().getCOFFSection(
277       SectionName, Flags, Kind, "", (COFF::COMDATType)(0)));
278   return false;
279 }
280 
281 /// ParseDirectiveSegmentEnd
282 ///  ::= identifier "ends"
283 bool COFFMasmParser::ParseDirectiveSegmentEnd(StringRef Directive, SMLoc Loc) {
284   StringRef SegmentName;
285   if (!getLexer().is(AsmToken::Identifier))
286     return TokError("expected identifier in directive");
287   SegmentName = getTok().getIdentifier();
288 
289   // Ignore; no action necessary.
290   Lex();
291   return false;
292 }
293 
294 /// ParseDirectiveIncludelib
295 ///  ::= "includelib" identifier
296 bool COFFMasmParser::ParseDirectiveIncludelib(StringRef Directive, SMLoc Loc) {
297   StringRef Lib;
298   if (getParser().parseIdentifier(Lib))
299     return TokError("expected identifier in includelib directive");
300 
301   unsigned Flags = COFF::IMAGE_SCN_MEM_PRELOAD | COFF::IMAGE_SCN_MEM_16BIT;
302   SectionKind Kind = computeSectionKind(Flags);
303   getStreamer().PushSection();
304   getStreamer().SwitchSection(getContext().getCOFFSection(
305       ".drectve", Flags, Kind, "", (COFF::COMDATType)(0)));
306   getStreamer().emitBytes("/DEFAULTLIB:");
307   getStreamer().emitBytes(Lib);
308   getStreamer().emitBytes(" ");
309   getStreamer().PopSection();
310   return false;
311 }
312 
313 /// ParseDirectiveProc
314 /// TODO(epastor): Implement parameters and other attributes.
315 ///  ::= label "proc" [[distance]]
316 ///          statements
317 ///      label "endproc"
318 bool COFFMasmParser::ParseDirectiveProc(StringRef Directive, SMLoc Loc) {
319   StringRef Label;
320   if (getParser().parseIdentifier(Label))
321     return Error(Loc, "expected identifier for procedure");
322   if (getLexer().is(AsmToken::Identifier)) {
323     StringRef nextVal = getTok().getString();
324     SMLoc nextLoc = getTok().getLoc();
325     if (nextVal.equals_insensitive("far")) {
326       // TODO(epastor): Handle far procedure definitions.
327       Lex();
328       return Error(nextLoc, "far procedure definitions not yet supported");
329     } else if (nextVal.equals_insensitive("near")) {
330       Lex();
331       nextVal = getTok().getString();
332       nextLoc = getTok().getLoc();
333     }
334   }
335   MCSymbolCOFF *Sym = cast<MCSymbolCOFF>(getContext().getOrCreateSymbol(Label));
336 
337   // Define symbol as simple external function
338   Sym->setExternal(true);
339   Sym->setType(COFF::IMAGE_SYM_DTYPE_FUNCTION << COFF::SCT_COMPLEX_TYPE_SHIFT);
340 
341   bool Framed = false;
342   if (getLexer().is(AsmToken::Identifier) &&
343       getTok().getString().equals_insensitive("frame")) {
344     Lex();
345     Framed = true;
346     getStreamer().EmitWinCFIStartProc(Sym, Loc);
347   }
348   getStreamer().emitLabel(Sym, Loc);
349 
350   CurrentProcedure = Label;
351   CurrentProcedureFramed = Framed;
352   return false;
353 }
354 bool COFFMasmParser::ParseDirectiveEndProc(StringRef Directive, SMLoc Loc) {
355   StringRef Label;
356   SMLoc LabelLoc = getTok().getLoc();
357   if (getParser().parseIdentifier(Label))
358     return Error(LabelLoc, "expected identifier for procedure end");
359 
360   if (CurrentProcedure.empty())
361     return Error(Loc, "endp outside of procedure block");
362   else if (CurrentProcedure != Label)
363     return Error(LabelLoc, "endp does not match current procedure '" +
364                                CurrentProcedure + "'");
365 
366   if (CurrentProcedureFramed) {
367     getStreamer().EmitWinCFIEndProc(Loc);
368   }
369   CurrentProcedure = "";
370   CurrentProcedureFramed = false;
371   return false;
372 }
373 
374 bool COFFMasmParser::ParseDirectiveAlias(StringRef Directive, SMLoc Loc) {
375   std::string AliasName, ActualName;
376   if (getTok().isNot(AsmToken::Less) ||
377       getParser().parseAngleBracketString(AliasName))
378     return Error(getTok().getLoc(), "expected <aliasName>");
379   if (getParser().parseToken(AsmToken::Equal))
380     return addErrorSuffix(" in " + Directive + " directive");
381   if (getTok().isNot(AsmToken::Less) ||
382       getParser().parseAngleBracketString(ActualName))
383     return Error(getTok().getLoc(), "expected <actualName>");
384 
385   MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName);
386   MCSymbol *Actual = getContext().getOrCreateSymbol(ActualName);
387 
388   getStreamer().emitWeakReference(Alias, Actual);
389 
390   return false;
391 }
392 
393 bool COFFMasmParser::ParseSEHDirectiveAllocStack(StringRef Directive,
394                                                  SMLoc Loc) {
395   int64_t Size;
396   SMLoc SizeLoc = getTok().getLoc();
397   if (getParser().parseAbsoluteExpression(Size))
398     return Error(SizeLoc, "expected integer size");
399   if (Size % 8 != 0)
400     return Error(SizeLoc, "stack size must be a multiple of 8");
401   getStreamer().EmitWinCFIAllocStack(static_cast<unsigned>(Size), Loc);
402   return false;
403 }
404 
405 bool COFFMasmParser::ParseSEHDirectiveEndProlog(StringRef Directive,
406                                                 SMLoc Loc) {
407   getStreamer().EmitWinCFIEndProlog(Loc);
408   return false;
409 }
410 
411 namespace llvm {
412 
413 MCAsmParserExtension *createCOFFMasmParser() { return new COFFMasmParser; }
414 
415 } // end namespace llvm
416