1 //===- llvm/MC/MCAsmParser.h - Abstract Asm Parser Interface ----*- C++ -*-===//
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 #ifndef LLVM_MC_MCPARSER_MCASMPARSER_H
11 #define LLVM_MC_MCPARSER_MCASMPARSER_H
12 
13 #include "llvm/ADT/None.h"
14 #include "llvm/ADT/STLExtras.h"
15 #include "llvm/ADT/SmallString.h"
16 #include "llvm/ADT/SmallVector.h"
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/ADT/Twine.h"
19 #include "llvm/MC/MCParser/MCAsmLexer.h"
20 #include "llvm/Support/SMLoc.h"
21 #include <cstdint>
22 #include <string>
23 #include <utility>
24 
25 namespace llvm {
26 
27 class MCAsmInfo;
28 class MCAsmParserExtension;
29 class MCContext;
30 class MCExpr;
31 class MCInstPrinter;
32 class MCInstrInfo;
33 class MCStreamer;
34 class MCTargetAsmParser;
35 class SourceMgr;
36 
37 struct InlineAsmIdentifierInfo {
38   enum IdKind {
39     IK_Invalid,  // Initial state. Unexpected after a successful parsing.
40     IK_Label,    // Function/Label reference.
41     IK_EnumVal,  // Value of enumeration type.
42     IK_Var       // Variable.
43   };
44   // Represents an Enum value
45   struct EnumIdentifier {
46     int64_t EnumVal;
47   };
48   // Represents a label/function reference
49   struct LabelIdentifier {
50     void *Decl;
51   };
52   // Represents a variable
53   struct VariableIdentifier {
54     void *Decl;
55     bool IsGlobalLV;
56     unsigned Length;
57     unsigned Size;
58     unsigned Type;
59   };
60   // An InlineAsm identifier can only be one of those
61   union {
62     EnumIdentifier Enum;
63     LabelIdentifier Label;
64     VariableIdentifier Var;
65   };
isKindInlineAsmIdentifierInfo66   bool isKind(IdKind kind) const { return Kind == kind; }
67   // Initializers
setEnumInlineAsmIdentifierInfo68   void setEnum(int64_t enumVal) {
69     assert(isKind(IK_Invalid) && "should be initialized only once");
70     Kind = IK_EnumVal;
71     Enum.EnumVal = enumVal;
72   }
setLabelInlineAsmIdentifierInfo73   void setLabel(void *decl) {
74     assert(isKind(IK_Invalid) && "should be initialized only once");
75     Kind = IK_Label;
76     Label.Decl = decl;
77   }
setVarInlineAsmIdentifierInfo78   void setVar(void *decl, bool isGlobalLV, unsigned size, unsigned type) {
79     assert(isKind(IK_Invalid) && "should be initialized only once");
80     Kind = IK_Var;
81     Var.Decl = decl;
82     Var.IsGlobalLV = isGlobalLV;
83     Var.Size = size;
84     Var.Type = type;
85     Var.Length = size / type;
86   }
InlineAsmIdentifierInfoInlineAsmIdentifierInfo87   InlineAsmIdentifierInfo() : Kind(IK_Invalid) {}
88 
89 private:
90   // Discriminate using the current kind.
91   IdKind Kind;
92 };
93 
94 /// Generic Sema callback for assembly parser.
95 class MCAsmParserSemaCallback {
96 public:
97   virtual ~MCAsmParserSemaCallback();
98 
99   virtual void LookupInlineAsmIdentifier(StringRef &LineBuf,
100                                          InlineAsmIdentifierInfo &Info,
101                                          bool IsUnevaluatedContext) = 0;
102   virtual StringRef LookupInlineAsmLabel(StringRef Identifier, SourceMgr &SM,
103                                          SMLoc Location, bool Create) = 0;
104   virtual bool LookupInlineAsmField(StringRef Base, StringRef Member,
105                                     unsigned &Offset) = 0;
106 };
107 
108 /// Generic assembler parser interface, for use by target specific
109 /// assembly parsers.
110 class MCAsmParser {
111 public:
112   using DirectiveHandler = bool (*)(MCAsmParserExtension*, StringRef, SMLoc);
113   using ExtensionDirectiveHandler =
114       std::pair<MCAsmParserExtension*, DirectiveHandler>;
115 
116   struct MCPendingError {
117     SMLoc Loc;
118     SmallString<64> Msg;
119     SMRange Range;
120   };
121 
122 private:
123   MCTargetAsmParser *TargetParser = nullptr;
124 
125 protected: // Can only create subclasses.
126   MCAsmParser();
127 
128   SmallVector<MCPendingError, 0> PendingErrors;
129 
130   /// Flag tracking whether any errors have been encountered.
131   bool HadError = false;
132 
133   /// Enable print [latency:throughput] in output file.
134   bool EnablePrintSchedInfo = false;
135 
136   bool ShowParsedOperands = false;
137 
138 public:
139   MCAsmParser(const MCAsmParser &) = delete;
140   MCAsmParser &operator=(const MCAsmParser &) = delete;
141   virtual ~MCAsmParser();
142 
143   virtual void addDirectiveHandler(StringRef Directive,
144                                    ExtensionDirectiveHandler Handler) = 0;
145 
146   virtual void addAliasForDirective(StringRef Directive, StringRef Alias) = 0;
147 
148   virtual SourceMgr &getSourceManager() = 0;
149 
150   virtual MCAsmLexer &getLexer() = 0;
getLexer()151   const MCAsmLexer &getLexer() const {
152     return const_cast<MCAsmParser*>(this)->getLexer();
153   }
154 
155   virtual MCContext &getContext() = 0;
156 
157   /// Return the output streamer for the assembler.
158   virtual MCStreamer &getStreamer() = 0;
159 
getTargetParser()160   MCTargetAsmParser &getTargetParser() const { return *TargetParser; }
161   void setTargetParser(MCTargetAsmParser &P);
162 
getAssemblerDialect()163   virtual unsigned getAssemblerDialect() { return 0;}
setAssemblerDialect(unsigned i)164   virtual void setAssemblerDialect(unsigned i) { }
165 
getShowParsedOperands()166   bool getShowParsedOperands() const { return ShowParsedOperands; }
setShowParsedOperands(bool Value)167   void setShowParsedOperands(bool Value) { ShowParsedOperands = Value; }
168 
setEnablePrintSchedInfo(bool Value)169   void setEnablePrintSchedInfo(bool Value) { EnablePrintSchedInfo = Value; }
shouldPrintSchedInfo()170   bool shouldPrintSchedInfo() const { return EnablePrintSchedInfo; }
171 
172   /// Run the parser on the input source buffer.
173   virtual bool Run(bool NoInitialTextSection, bool NoFinalize = false) = 0;
174 
175   virtual void setParsingInlineAsm(bool V) = 0;
176   virtual bool isParsingInlineAsm() = 0;
177 
178   /// Parse MS-style inline assembly.
179   virtual bool parseMSInlineAsm(
180       void *AsmLoc, std::string &AsmString, unsigned &NumOutputs,
181       unsigned &NumInputs, SmallVectorImpl<std::pair<void *, bool>> &OpDecls,
182       SmallVectorImpl<std::string> &Constraints,
183       SmallVectorImpl<std::string> &Clobbers, const MCInstrInfo *MII,
184       const MCInstPrinter *IP, MCAsmParserSemaCallback &SI) = 0;
185 
186   /// Emit a note at the location \p L, with the message \p Msg.
187   virtual void Note(SMLoc L, const Twine &Msg, SMRange Range = None) = 0;
188 
189   /// Emit a warning at the location \p L, with the message \p Msg.
190   ///
191   /// \return The return value is true, if warnings are fatal.
192   virtual bool Warning(SMLoc L, const Twine &Msg, SMRange Range = None) = 0;
193 
194   /// Return an error at the location \p L, with the message \p Msg. This
195   /// may be modified before being emitted.
196   ///
197   /// \return The return value is always true, as an idiomatic convenience to
198   /// clients.
199   bool Error(SMLoc L, const Twine &Msg, SMRange Range = None);
200 
201   /// Emit an error at the location \p L, with the message \p Msg.
202   ///
203   /// \return The return value is always true, as an idiomatic convenience to
204   /// clients.
205   virtual bool printError(SMLoc L, const Twine &Msg, SMRange Range = None) = 0;
206 
hasPendingError()207   bool hasPendingError() { return !PendingErrors.empty(); }
208 
printPendingErrors()209   bool printPendingErrors() {
210     bool rv = !PendingErrors.empty();
211     for (auto Err : PendingErrors) {
212       printError(Err.Loc, Twine(Err.Msg), Err.Range);
213     }
214     PendingErrors.clear();
215     return rv;
216   }
217 
clearPendingErrors()218   void clearPendingErrors() { PendingErrors.clear(); }
219 
220   bool addErrorSuffix(const Twine &Suffix);
221 
222   /// Get the next AsmToken in the stream, possibly handling file
223   /// inclusion first.
224   virtual const AsmToken &Lex() = 0;
225 
226   /// Get the current AsmToken from the stream.
227   const AsmToken &getTok() const;
228 
229   /// Report an error at the current lexer location.
230   bool TokError(const Twine &Msg, SMRange Range = None);
231 
232   bool parseTokenLoc(SMLoc &Loc);
233   bool parseToken(AsmToken::TokenKind T, const Twine &Msg = "unexpected token");
234   /// Attempt to parse and consume token, returning true on
235   /// success.
236   bool parseOptionalToken(AsmToken::TokenKind T);
237 
238   bool parseEOL(const Twine &ErrMsg);
239 
240   bool parseMany(function_ref<bool()> parseOne, bool hasComma = true);
241 
242   bool parseIntToken(int64_t &V, const Twine &ErrMsg);
243 
244   bool check(bool P, const Twine &Msg);
245   bool check(bool P, SMLoc Loc, const Twine &Msg);
246 
247   /// Parse an identifier or string (as a quoted identifier) and set \p
248   /// Res to the identifier contents.
249   virtual bool parseIdentifier(StringRef &Res) = 0;
250 
251   /// Parse up to the end of statement and return the contents from the
252   /// current token until the end of the statement; the current token on exit
253   /// will be either the EndOfStatement or EOF.
254   virtual StringRef parseStringToEndOfStatement() = 0;
255 
256   /// Parse the current token as a string which may include escaped
257   /// characters and return the string contents.
258   virtual bool parseEscapedString(std::string &Data) = 0;
259 
260   /// Skip to the end of the current statement, for error recovery.
261   virtual void eatToEndOfStatement() = 0;
262 
263   /// Parse an arbitrary expression.
264   ///
265   /// \param Res - The value of the expression. The result is undefined
266   /// on error.
267   /// \return - False on success.
268   virtual bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) = 0;
269   bool parseExpression(const MCExpr *&Res);
270 
271   /// Parse a primary expression.
272   ///
273   /// \param Res - The value of the expression. The result is undefined
274   /// on error.
275   /// \return - False on success.
276   virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) = 0;
277 
278   /// Parse an arbitrary expression, assuming that an initial '(' has
279   /// already been consumed.
280   ///
281   /// \param Res - The value of the expression. The result is undefined
282   /// on error.
283   /// \return - False on success.
284   virtual bool parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) = 0;
285 
286   /// Parse an expression which must evaluate to an absolute value.
287   ///
288   /// \param Res - The value of the absolute expression. The result is undefined
289   /// on error.
290   /// \return - False on success.
291   virtual bool parseAbsoluteExpression(int64_t &Res) = 0;
292 
293   /// Ensure that we have a valid section set in the streamer. Otherwise,
294   /// report an error and switch to .text.
295   /// \return - False on success.
296   virtual bool checkForValidSection() = 0;
297 
298   /// Parse an arbitrary expression of a specified parenthesis depth,
299   /// assuming that the initial '(' characters have already been consumed.
300   ///
301   /// \param ParenDepth - Specifies how many trailing expressions outside the
302   /// current parentheses we have to parse.
303   /// \param Res - The value of the expression. The result is undefined
304   /// on error.
305   /// \return - False on success.
306   virtual bool parseParenExprOfDepth(unsigned ParenDepth, const MCExpr *&Res,
307                                      SMLoc &EndLoc) = 0;
308 };
309 
310 /// Create an MCAsmParser instance.
311 MCAsmParser *createMCAsmParser(SourceMgr &, MCContext &, MCStreamer &,
312                                const MCAsmInfo &, unsigned CB = 0);
313 
314 } // end namespace llvm
315 
316 #endif // LLVM_MC_MCPARSER_MCASMPARSER_H
317