LLVM  10.0.0svn
MILexer.h
Go to the documentation of this file.
1 //===- MILexer.h - Lexer for machine instructions ---------------*- C++ -*-===//
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 // This file declares the function that lexes the machine instruction source
10 // string.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_LIB_CODEGEN_MIRPARSER_MILEXER_H
15 #define LLVM_LIB_CODEGEN_MIRPARSER_MILEXER_H
16 
17 #include "llvm/ADT/APSInt.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/StringRef.h"
20 #include <string>
21 
22 namespace llvm {
23 
24 class Twine;
25 
26 /// A token produced by the machine instruction lexer.
27 struct MIToken {
28  enum TokenKind {
29  // Markers
30  Eof,
33 
34  // Tokens with no info.
40  dot,
50 
51  // Keywords
124 
125  // Named metadata keywords
132 
133  // Identifier tokens
145 
146  // Other tokens
158  QuotedIRValue, // `<constant value>`
161  };
162 
163 private:
164  TokenKind Kind = Error;
165  StringRef Range;
166  StringRef StringValue;
167  std::string StringValueStorage;
168  APSInt IntVal;
169 
170 public:
171  MIToken() = default;
172 
173  MIToken &reset(TokenKind Kind, StringRef Range);
174 
176  MIToken &setOwnedStringValue(std::string StrVal);
177  MIToken &setIntegerValue(APSInt IntVal);
178 
179  TokenKind kind() const { return Kind; }
180 
181  bool isError() const { return Kind == Error; }
182 
183  bool isNewlineOrEOF() const { return Kind == Newline || Kind == Eof; }
184 
185  bool isErrorOrEOF() const { return Kind == Error || Kind == Eof; }
186 
187  bool isRegister() const {
188  return Kind == NamedRegister || Kind == underscore ||
189  Kind == NamedVirtualRegister || Kind == VirtualRegister;
190  }
191 
192  bool isRegisterFlag() const {
193  return Kind == kw_implicit || Kind == kw_implicit_define ||
194  Kind == kw_def || Kind == kw_dead || Kind == kw_killed ||
195  Kind == kw_undef || Kind == kw_internal ||
196  Kind == kw_early_clobber || Kind == kw_debug_use ||
197  Kind == kw_renamable;
198  }
199 
200  bool isMemoryOperandFlag() const {
201  return Kind == kw_volatile || Kind == kw_non_temporal ||
202  Kind == kw_dereferenceable || Kind == kw_invariant ||
203  Kind == StringConstant;
204  }
205 
206  bool is(TokenKind K) const { return Kind == K; }
207 
208  bool isNot(TokenKind K) const { return Kind != K; }
209 
210  StringRef::iterator location() const { return Range.begin(); }
211 
212  StringRef range() const { return Range; }
213 
214  /// Return the token's string value.
215  StringRef stringValue() const { return StringValue; }
216 
217  const APSInt &integerValue() const { return IntVal; }
218 
219  bool hasIntegerValue() const {
220  return Kind == IntegerLiteral || Kind == MachineBasicBlock ||
221  Kind == MachineBasicBlockLabel || Kind == StackObject ||
222  Kind == FixedStackObject || Kind == GlobalValue ||
223  Kind == VirtualRegister || Kind == ConstantPoolItem ||
224  Kind == JumpTableIndex || Kind == IRBlock || Kind == IRValue;
225  }
226 };
227 
228 /// Consume a single machine instruction token in the given source and return
229 /// the remaining source string.
231  StringRef Source, MIToken &Token,
232  function_ref<void(StringRef::iterator, const Twine &)> ErrorCallback);
233 
234 } // end namespace llvm
235 
236 #endif // LLVM_LIB_CODEGEN_MIRPARSER_MILEXER_H
StringRef stringValue() const
Return the token&#39;s string value.
Definition: MILexer.h:215
bool is(TokenKind K) const
Definition: MILexer.h:206
bool isError() const
Definition: MILexer.h:181
This class represents lattice values for constants.
Definition: AllocatorList.h:23
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:104
bool isMemoryOperandFlag() const
Definition: MILexer.h:200
StringRef lexMIToken(StringRef Source, MIToken &Token, function_ref< void(StringRef::iterator, const Twine &)> ErrorCallback)
Consume a single machine instruction token in the given source and return the remaining source string...
MIToken & reset(TokenKind Kind, StringRef Range)
Definition: MILexer.cpp:67
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
bool isNot(TokenKind K) const
Definition: MILexer.h:208
bool isNewlineOrEOF() const
Definition: MILexer.h:183
const APSInt & integerValue() const
Definition: MILexer.h:217
MIToken & setOwnedStringValue(std::string StrVal)
Definition: MILexer.cpp:78
bool isErrorOrEOF() const
Definition: MILexer.h:185
MIToken()=default
bool hasIntegerValue() const
Definition: MILexer.h:219
TokenKind kind() const
Definition: MILexer.h:179
MIToken & setStringValue(StringRef StrVal)
Definition: MILexer.cpp:73
StringRef range() const
Definition: MILexer.h:212
StringRef::iterator location() const
Definition: MILexer.h:210
iterator begin() const
Definition: StringRef.h:115
bool isRegisterFlag() const
Definition: MILexer.h:192
bool isRegister() const
Definition: MILexer.h:187
A token produced by the machine instruction lexer.
Definition: MILexer.h:27
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
MIToken & setIntegerValue(APSInt IntVal)
Definition: MILexer.cpp:84