lib/CodeGen/MIRParser/MILexer.h

   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,
  31     Error,
  32     Newline,
  33
  34     // Tokens with no info.
  35     comma,
  36     equal,
  37     underscore,
  38     colon,
  39     coloncolon,
  40     dot,
  41     exclaim,
  42     lparen,
  43     rparen,
  44     lbrace,
  45     rbrace,
  46     plus,
  47     minus,
  48     less,
  49     greater,
  50
  51     // Keywords
  52     kw_implicit,
  53     kw_implicit_define,
  54     kw_def,
  55     kw_dead,
  56     kw_dereferenceable,
  57     kw_killed,
  58     kw_undef,
  59     kw_internal,
  60     kw_early_clobber,
  61     kw_debug_use,
  62     kw_renamable,
  63     kw_tied_def,
  64     kw_frame_setup,
  65     kw_frame_destroy,
  66     kw_nnan,
  67     kw_ninf,
  68     kw_nsz,
  69     kw_arcp,
  70     kw_contract,
  71     kw_afn,
  72     kw_reassoc,
  73     kw_nuw,
  74     kw_nsw,
  75     kw_exact,
  76     kw_fpexcept,
  77     kw_debug_location,
  78     kw_cfi_same_value,
  79     kw_cfi_offset,
  80     kw_cfi_rel_offset,
  81     kw_cfi_def_cfa_register,
  82     kw_cfi_def_cfa_offset,
  83     kw_cfi_adjust_cfa_offset,
  84     kw_cfi_escape,
  85     kw_cfi_def_cfa,
  86     kw_cfi_register,
  87     kw_cfi_remember_state,
  88     kw_cfi_restore,
  89     kw_cfi_restore_state,
  90     kw_cfi_undefined,
  91     kw_cfi_window_save,
  92     kw_cfi_aarch64_negate_ra_sign_state,
  93     kw_blockaddress,
  94     kw_intrinsic,
  95     kw_target_index,
  96     kw_half,
  97     kw_float,
  98     kw_double,
  99     kw_x86_fp80,
 100     kw_fp128,
 101     kw_ppc_fp128,
 102     kw_target_flags,
 103     kw_volatile,
 104     kw_non_temporal,
 105     kw_invariant,
 106     kw_align,
 107     kw_addrspace,
 108     kw_stack,
 109     kw_got,
 110     kw_jump_table,
 111     kw_constant_pool,
 112     kw_call_entry,
 113     kw_liveout,
 114     kw_address_taken,
 115     kw_landing_pad,
 116     kw_liveins,
 117     kw_successors,
 118     kw_floatpred,
 119     kw_intpred,
 120     kw_shufflemask,
 121     kw_pre_instr_symbol,
 122     kw_post_instr_symbol,
 123     kw_unknown_size,
 124
 125     // Named metadata keywords
 126     md_tbaa,
 127     md_alias_scope,
 128     md_noalias,
 129     md_range,
 130     md_diexpr,
 131     md_dilocation,
 132
 133     // Identifier tokens
 134     Identifier,
 135     NamedRegister,
 136     NamedVirtualRegister,
 137     MachineBasicBlockLabel,
 138     MachineBasicBlock,
 139     StackObject,
 140     FixedStackObject,
 141     NamedGlobalValue,
 142     GlobalValue,
 143     ExternalSymbol,
 144     MCSymbol,
 145
 146     // Other tokens
 147     IntegerLiteral,
 148     FloatingPointLiteral,
 149     HexLiteral,
 150     VectorLiteral,
 151     VirtualRegister,
 152     ConstantPoolItem,
 153     JumpTableIndex,
 154     NamedIRBlock,
 155     IRBlock,
 156     NamedIRValue,
 157     IRValue,
 158     QuotedIRValue, // `<constant value>`
 159     SubRegisterIndex,
 160     StringConstant
 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
 175   MIToken &setStringValue(StringRef StrVal);
 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.
 230 StringRef lexMIToken(
 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