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 237