Lines Matching +full:- +full:c
1 //===- MILexer.cpp - Machine instructions lexer implementation ------------===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
11 //===----------------------------------------------------------------------===//
44 char peek(int I = 0) const { return End - Ptr <= I ? 0 : Ptr[I]; } in peek()
48 StringRef remaining() const { return StringRef(Ptr, End - Ptr); } in remaining()
50 StringRef upto(Cursor C) const { in upto()
51 assert(C.Ptr >= Ptr && C.Ptr <= End); in upto()
52 return StringRef(Ptr, C.Ptr - Ptr); in upto()
63 this->Kind = Kind; in reset()
64 this->Range = Range; in reset()
80 this->IntVal = std::move(IntVal); in setIntegerValue()
85 static Cursor skipWhitespace(Cursor C) { in skipWhitespace() argument
86 while (isblank(C.peek())) in skipWhitespace()
87 C.advance(); in skipWhitespace()
88 return C; in skipWhitespace()
91 static bool isNewlineChar(char C) { return C == '\n' || C == '\r'; } in isNewlineChar() argument
94 static Cursor skipComment(Cursor C) { in skipComment() argument
95 if (C.peek() != ';') in skipComment()
96 return C; in skipComment()
97 while (!isNewlineChar(C.peek()) && !C.isEOF()) in skipComment()
98 C.advance(); in skipComment()
99 return C; in skipComment()
104 static Cursor skipMachineOperandComment(Cursor C) { in skipMachineOperandComment() argument
105 if (C.peek() != '/' || C.peek(1) != '*') in skipMachineOperandComment()
106 return C; in skipMachineOperandComment()
108 while (C.peek() != '*' || C.peek(1) != '/') in skipMachineOperandComment()
109 C.advance(); in skipMachineOperandComment()
111 C.advance(); in skipMachineOperandComment()
112 C.advance(); in skipMachineOperandComment()
113 return C; in skipMachineOperandComment()
117 /// expression: [-a-zA-Z$._0-9]
118 static bool isIdentifierChar(char C) { in isIdentifierChar() argument
119 return isalpha(C) || isdigit(C) || C == '_' || C == '-' || C == '.' || in isIdentifierChar()
120 C == '$'; in isIdentifierChar()
128 Cursor C = Cursor(Value.substr(1, Value.size() - 2)); in unescapeQuotedString() local
131 Str.reserve(C.remaining().size()); in unescapeQuotedString()
132 while (!C.isEOF()) { in unescapeQuotedString()
133 char Char = C.peek(); in unescapeQuotedString()
135 if (C.peek(1) == '\\') { in unescapeQuotedString()
138 C.advance(2); in unescapeQuotedString()
141 if (isxdigit(C.peek(1)) && isxdigit(C.peek(2))) { in unescapeQuotedString()
142 Str += hexDigitValue(C.peek(1)) * 16 + hexDigitValue(C.peek(2)); in unescapeQuotedString()
143 C.advance(3); in unescapeQuotedString()
148 C.advance(); in unescapeQuotedString()
154 static Cursor lexStringConstant(Cursor C, ErrorCallbackType ErrorCallback) { in lexStringConstant() argument
155 assert(C.peek() == '"'); in lexStringConstant()
156 for (C.advance(); C.peek() != '"'; C.advance()) { in lexStringConstant()
157 if (C.isEOF() || isNewlineChar(C.peek())) { in lexStringConstant()
159 C.location(), in lexStringConstant()
164 C.advance(); in lexStringConstant()
165 return C; in lexStringConstant()
168 static Cursor lexName(Cursor C, MIToken &Token, MIToken::TokenKind Type, in lexName() argument
170 auto Range = C; in lexName()
171 C.advance(PrefixLength); in lexName()
172 if (C.peek() == '"') { in lexName()
173 if (Cursor R = lexStringConstant(C, ErrorCallback)) { in lexName()
183 while (isIdentifierChar(C.peek())) in lexName()
184 C.advance(); in lexName()
185 Token.reset(Type, Range.upto(C)) in lexName()
186 .setStringValue(Range.upto(C).drop_front(PrefixLength)); in lexName()
187 return C; in lexName()
194 .Case("implicit-def", MIToken::kw_implicit_define) in getIdentifierKind()
200 .Case("early-clobber", MIToken::kw_early_clobber) in getIdentifierKind()
201 .Case("debug-use", MIToken::kw_debug_use) in getIdentifierKind()
203 .Case("tied-def", MIToken::kw_tied_def) in getIdentifierKind()
204 .Case("frame-setup", MIToken::kw_frame_setup) in getIdentifierKind()
205 .Case("frame-destroy", MIToken::kw_frame_destroy) in getIdentifierKind()
221 .Case("debug-location", MIToken::kw_debug_location) in getIdentifierKind()
222 .Case("debug-instr-number", MIToken::kw_debug_instr_number) in getIdentifierKind()
223 .Case("dbg-instr-ref", MIToken::kw_dbg_instr_ref) in getIdentifierKind()
243 .Case("target-index", MIToken::kw_target_index) in getIdentifierKind()
251 .Case("target-flags", MIToken::kw_target_flags) in getIdentifierKind()
253 .Case("non-temporal", MIToken::kw_non_temporal) in getIdentifierKind()
261 .Case("jump-table", MIToken::kw_jump_table) in getIdentifierKind()
262 .Case("constant-pool", MIToken::kw_constant_pool) in getIdentifierKind()
263 .Case("call-entry", MIToken::kw_call_entry) in getIdentifierKind()
266 .Case("landing-pad", MIToken::kw_landing_pad) in getIdentifierKind()
267 .Case("inlineasm-br-indirect-target", in getIdentifierKind()
269 .Case("ehfunclet-entry", MIToken::kw_ehfunclet_entry) in getIdentifierKind()
275 .Case("pre-instr-symbol", MIToken::kw_pre_instr_symbol) in getIdentifierKind()
276 .Case("post-instr-symbol", MIToken::kw_post_instr_symbol) in getIdentifierKind()
277 .Case("heap-alloc-marker", MIToken::kw_heap_alloc_marker) in getIdentifierKind()
279 .Case("cfi-type", MIToken::kw_cfi_type) in getIdentifierKind()
282 .Case("unknown-size", MIToken::kw_unknown_size) in getIdentifierKind()
283 .Case("unknown-address", MIToken::kw_unknown_address) in getIdentifierKind()
285 .Case("ir-block-address-taken", MIToken::kw_ir_block_address_taken) in getIdentifierKind()
286 .Case("machine-block-address-taken", in getIdentifierKind()
288 .Case("call-frame-size", MIToken::kw_call_frame_size) in getIdentifierKind()
293 static Cursor maybeLexIdentifier(Cursor C, MIToken &Token) { in maybeLexIdentifier() argument
294 if (!isalpha(C.peek()) && C.peek() != '_') in maybeLexIdentifier()
296 auto Range = C; in maybeLexIdentifier()
297 while (isIdentifierChar(C.peek())) in maybeLexIdentifier()
298 C.advance(); in maybeLexIdentifier()
299 auto Identifier = Range.upto(C); in maybeLexIdentifier()
302 return C; in maybeLexIdentifier()
305 static Cursor maybeLexMachineBasicBlock(Cursor C, MIToken &Token, in maybeLexMachineBasicBlock() argument
307 bool IsReference = C.remaining().starts_with("%bb."); in maybeLexMachineBasicBlock()
308 if (!IsReference && !C.remaining().starts_with("bb.")) in maybeLexMachineBasicBlock()
310 auto Range = C; in maybeLexMachineBasicBlock()
312 C.advance(PrefixLength); // Skip '%bb.' or 'bb.' in maybeLexMachineBasicBlock()
313 if (!isdigit(C.peek())) { in maybeLexMachineBasicBlock()
314 Token.reset(MIToken::Error, C.remaining()); in maybeLexMachineBasicBlock()
315 ErrorCallback(C.location(), "expected a number after '%bb.'"); in maybeLexMachineBasicBlock()
316 return C; in maybeLexMachineBasicBlock()
318 auto NumberRange = C; in maybeLexMachineBasicBlock()
319 while (isdigit(C.peek())) in maybeLexMachineBasicBlock()
320 C.advance(); in maybeLexMachineBasicBlock()
321 StringRef Number = NumberRange.upto(C); in maybeLexMachineBasicBlock()
326 if (C.peek() == '.') { in maybeLexMachineBasicBlock()
327 C.advance(); // Skip '.' in maybeLexMachineBasicBlock()
329 while (isIdentifierChar(C.peek())) in maybeLexMachineBasicBlock()
330 C.advance(); in maybeLexMachineBasicBlock()
334 Range.upto(C)) in maybeLexMachineBasicBlock()
336 .setStringValue(Range.upto(C).drop_front(StringOffset)); in maybeLexMachineBasicBlock()
337 return C; in maybeLexMachineBasicBlock()
340 static Cursor maybeLexIndex(Cursor C, MIToken &Token, StringRef Rule, in maybeLexIndex() argument
342 if (!C.remaining().starts_with(Rule) || !isdigit(C.peek(Rule.size()))) in maybeLexIndex()
344 auto Range = C; in maybeLexIndex()
345 C.advance(Rule.size()); in maybeLexIndex()
346 auto NumberRange = C; in maybeLexIndex()
347 while (isdigit(C.peek())) in maybeLexIndex()
348 C.advance(); in maybeLexIndex()
349 Token.reset(Kind, Range.upto(C)).setIntegerValue(APSInt(NumberRange.upto(C))); in maybeLexIndex()
350 return C; in maybeLexIndex()
353 static Cursor maybeLexIndexAndName(Cursor C, MIToken &Token, StringRef Rule, in maybeLexIndexAndName() argument
355 if (!C.remaining().starts_with(Rule) || !isdigit(C.peek(Rule.size()))) in maybeLexIndexAndName()
357 auto Range = C; in maybeLexIndexAndName()
358 C.advance(Rule.size()); in maybeLexIndexAndName()
359 auto NumberRange = C; in maybeLexIndexAndName()
360 while (isdigit(C.peek())) in maybeLexIndexAndName()
361 C.advance(); in maybeLexIndexAndName()
362 StringRef Number = NumberRange.upto(C); in maybeLexIndexAndName()
364 if (C.peek() == '.') { in maybeLexIndexAndName()
365 C.advance(); in maybeLexIndexAndName()
367 while (isIdentifierChar(C.peek())) in maybeLexIndexAndName()
368 C.advance(); in maybeLexIndexAndName()
370 Token.reset(Kind, Range.upto(C)) in maybeLexIndexAndName()
372 .setStringValue(Range.upto(C).drop_front(StringOffset)); in maybeLexIndexAndName()
373 return C; in maybeLexIndexAndName()
376 static Cursor maybeLexJumpTableIndex(Cursor C, MIToken &Token) { in maybeLexJumpTableIndex() argument
377 return maybeLexIndex(C, Token, "%jump-table.", MIToken::JumpTableIndex); in maybeLexJumpTableIndex()
380 static Cursor maybeLexStackObject(Cursor C, MIToken &Token) { in maybeLexStackObject() argument
381 return maybeLexIndexAndName(C, Token, "%stack.", MIToken::StackObject); in maybeLexStackObject()
384 static Cursor maybeLexFixedStackObject(Cursor C, MIToken &Token) { in maybeLexFixedStackObject() argument
385 return maybeLexIndex(C, Token, "%fixed-stack.", MIToken::FixedStackObject); in maybeLexFixedStackObject()
388 static Cursor maybeLexConstantPoolItem(Cursor C, MIToken &Token) { in maybeLexConstantPoolItem() argument
389 return maybeLexIndex(C, Token, "%const.", MIToken::ConstantPoolItem); in maybeLexConstantPoolItem()
392 static Cursor maybeLexSubRegisterIndex(Cursor C, MIToken &Token, in maybeLexSubRegisterIndex() argument
395 if (!C.remaining().starts_with(Rule)) in maybeLexSubRegisterIndex()
397 return lexName(C, Token, MIToken::SubRegisterIndex, Rule.size(), in maybeLexSubRegisterIndex()
401 static Cursor maybeLexIRBlock(Cursor C, MIToken &Token, in maybeLexIRBlock() argument
403 const StringRef Rule = "%ir-block."; in maybeLexIRBlock()
404 if (!C.remaining().starts_with(Rule)) in maybeLexIRBlock()
406 if (isdigit(C.peek(Rule.size()))) in maybeLexIRBlock()
407 return maybeLexIndex(C, Token, Rule, MIToken::IRBlock); in maybeLexIRBlock()
408 return lexName(C, Token, MIToken::NamedIRBlock, Rule.size(), ErrorCallback); in maybeLexIRBlock()
411 static Cursor maybeLexIRValue(Cursor C, MIToken &Token, in maybeLexIRValue() argument
414 if (!C.remaining().starts_with(Rule)) in maybeLexIRValue()
416 if (isdigit(C.peek(Rule.size()))) in maybeLexIRValue()
417 return maybeLexIndex(C, Token, Rule, MIToken::IRValue); in maybeLexIRValue()
418 return lexName(C, Token, MIToken::NamedIRValue, Rule.size(), ErrorCallback); in maybeLexIRValue()
421 static Cursor maybeLexStringConstant(Cursor C, MIToken &Token, in maybeLexStringConstant() argument
423 if (C.peek() != '"') in maybeLexStringConstant()
425 return lexName(C, Token, MIToken::StringConstant, /*PrefixLength=*/0, in maybeLexStringConstant()
429 static Cursor lexVirtualRegister(Cursor C, MIToken &Token) { in lexVirtualRegister() argument
430 auto Range = C; in lexVirtualRegister()
431 C.advance(); // Skip '%' in lexVirtualRegister()
432 auto NumberRange = C; in lexVirtualRegister()
433 while (isdigit(C.peek())) in lexVirtualRegister()
434 C.advance(); in lexVirtualRegister()
435 Token.reset(MIToken::VirtualRegister, Range.upto(C)) in lexVirtualRegister()
436 .setIntegerValue(APSInt(NumberRange.upto(C))); in lexVirtualRegister()
437 return C; in lexVirtualRegister()
441 static bool isRegisterChar(char C) { in isRegisterChar() argument
442 return isIdentifierChar(C) && C != '.'; in isRegisterChar()
445 static Cursor lexNamedVirtualRegister(Cursor C, MIToken &Token) { in lexNamedVirtualRegister() argument
446 Cursor Range = C; in lexNamedVirtualRegister()
447 C.advance(); // Skip '%' in lexNamedVirtualRegister()
448 while (isRegisterChar(C.peek())) in lexNamedVirtualRegister()
449 C.advance(); in lexNamedVirtualRegister()
450 Token.reset(MIToken::NamedVirtualRegister, Range.upto(C)) in lexNamedVirtualRegister()
451 .setStringValue(Range.upto(C).drop_front(1)); // Drop the '%' in lexNamedVirtualRegister()
452 return C; in lexNamedVirtualRegister()
455 static Cursor maybeLexRegister(Cursor C, MIToken &Token, in maybeLexRegister() argument
457 if (C.peek() != '%' && C.peek() != '$') in maybeLexRegister()
460 if (C.peek() == '%') { in maybeLexRegister()
461 if (isdigit(C.peek(1))) in maybeLexRegister()
462 return lexVirtualRegister(C, Token); in maybeLexRegister()
464 if (isRegisterChar(C.peek(1))) in maybeLexRegister()
465 return lexNamedVirtualRegister(C, Token); in maybeLexRegister()
470 assert(C.peek() == '$'); in maybeLexRegister()
471 auto Range = C; in maybeLexRegister()
472 C.advance(); // Skip '$' in maybeLexRegister()
473 while (isRegisterChar(C.peek())) in maybeLexRegister()
474 C.advance(); in maybeLexRegister()
475 Token.reset(MIToken::NamedRegister, Range.upto(C)) in maybeLexRegister()
476 .setStringValue(Range.upto(C).drop_front(1)); // Drop the '$' in maybeLexRegister()
477 return C; in maybeLexRegister()
480 static Cursor maybeLexGlobalValue(Cursor C, MIToken &Token, in maybeLexGlobalValue() argument
482 if (C.peek() != '@') in maybeLexGlobalValue()
484 if (!isdigit(C.peek(1))) in maybeLexGlobalValue()
485 return lexName(C, Token, MIToken::NamedGlobalValue, /*PrefixLength=*/1, in maybeLexGlobalValue()
487 auto Range = C; in maybeLexGlobalValue()
488 C.advance(1); // Skip the '@' in maybeLexGlobalValue()
489 auto NumberRange = C; in maybeLexGlobalValue()
490 while (isdigit(C.peek())) in maybeLexGlobalValue()
491 C.advance(); in maybeLexGlobalValue()
492 Token.reset(MIToken::GlobalValue, Range.upto(C)) in maybeLexGlobalValue()
493 .setIntegerValue(APSInt(NumberRange.upto(C))); in maybeLexGlobalValue()
494 return C; in maybeLexGlobalValue()
497 static Cursor maybeLexExternalSymbol(Cursor C, MIToken &Token, in maybeLexExternalSymbol() argument
499 if (C.peek() != '&') in maybeLexExternalSymbol()
501 return lexName(C, Token, MIToken::ExternalSymbol, /*PrefixLength=*/1, in maybeLexExternalSymbol()
505 static Cursor maybeLexMCSymbol(Cursor C, MIToken &Token, in maybeLexMCSymbol() argument
508 if (!C.remaining().starts_with(Rule)) in maybeLexMCSymbol()
510 auto Start = C; in maybeLexMCSymbol()
511 C.advance(Rule.size()); in maybeLexMCSymbol()
514 if (C.peek() != '"') { in maybeLexMCSymbol()
515 while (isIdentifierChar(C.peek())) in maybeLexMCSymbol()
516 C.advance(); in maybeLexMCSymbol()
517 StringRef String = Start.upto(C).drop_front(Rule.size()); in maybeLexMCSymbol()
518 if (C.peek() != '>') { in maybeLexMCSymbol()
519 ErrorCallback(C.location(), in maybeLexMCSymbol()
524 C.advance(); in maybeLexMCSymbol()
526 Token.reset(MIToken::MCSymbol, Start.upto(C)).setStringValue(String); in maybeLexMCSymbol()
527 return C; in maybeLexMCSymbol()
531 Cursor R = lexStringConstant(C, ErrorCallback); in maybeLexMCSymbol()
533 ErrorCallback(C.location(), in maybeLexMCSymbol()
552 static bool isValidHexFloatingPointPrefix(char C) { in isValidHexFloatingPointPrefix() argument
553 return C == 'H' || C == 'K' || C == 'L' || C == 'M' || C == 'R'; in isValidHexFloatingPointPrefix()
556 static Cursor lexFloatingPointLiteral(Cursor Range, Cursor C, MIToken &Token) { in lexFloatingPointLiteral() argument
557 C.advance(); in lexFloatingPointLiteral()
558 // Skip over [0-9]*([eE][-+]?[0-9]+)? in lexFloatingPointLiteral()
559 while (isdigit(C.peek())) in lexFloatingPointLiteral()
560 C.advance(); in lexFloatingPointLiteral()
561 if ((C.peek() == 'e' || C.peek() == 'E') && in lexFloatingPointLiteral()
562 (isdigit(C.peek(1)) || in lexFloatingPointLiteral()
563 ((C.peek(1) == '-' || C.peek(1) == '+') && isdigit(C.peek(2))))) { in lexFloatingPointLiteral()
564 C.advance(2); in lexFloatingPointLiteral()
565 while (isdigit(C.peek())) in lexFloatingPointLiteral()
566 C.advance(); in lexFloatingPointLiteral()
568 Token.reset(MIToken::FloatingPointLiteral, Range.upto(C)); in lexFloatingPointLiteral()
569 return C; in lexFloatingPointLiteral()
572 static Cursor maybeLexHexadecimalLiteral(Cursor C, MIToken &Token) { in maybeLexHexadecimalLiteral() argument
573 if (C.peek() != '0' || (C.peek(1) != 'x' && C.peek(1) != 'X')) in maybeLexHexadecimalLiteral()
575 Cursor Range = C; in maybeLexHexadecimalLiteral()
576 C.advance(2); in maybeLexHexadecimalLiteral()
578 if (isValidHexFloatingPointPrefix(C.peek())) { in maybeLexHexadecimalLiteral()
579 C.advance(); in maybeLexHexadecimalLiteral()
582 while (isxdigit(C.peek())) in maybeLexHexadecimalLiteral()
583 C.advance(); in maybeLexHexadecimalLiteral()
584 StringRef StrVal = Range.upto(C); in maybeLexHexadecimalLiteral()
588 Token.reset(MIToken::HexLiteral, Range.upto(C)); in maybeLexHexadecimalLiteral()
589 else // It must be 3, which means that there was a floating-point prefix. in maybeLexHexadecimalLiteral()
590 Token.reset(MIToken::FloatingPointLiteral, Range.upto(C)); in maybeLexHexadecimalLiteral()
591 return C; in maybeLexHexadecimalLiteral()
594 static Cursor maybeLexNumericalLiteral(Cursor C, MIToken &Token) { in maybeLexNumericalLiteral() argument
595 if (!isdigit(C.peek()) && (C.peek() != '-' || !isdigit(C.peek(1)))) in maybeLexNumericalLiteral()
597 auto Range = C; in maybeLexNumericalLiteral()
598 C.advance(); in maybeLexNumericalLiteral()
599 while (isdigit(C.peek())) in maybeLexNumericalLiteral()
600 C.advance(); in maybeLexNumericalLiteral()
601 if (C.peek() == '.') in maybeLexNumericalLiteral()
602 return lexFloatingPointLiteral(Range, C, Token); in maybeLexNumericalLiteral()
603 StringRef StrVal = Range.upto(C); in maybeLexNumericalLiteral()
605 return C; in maybeLexNumericalLiteral()
619 static Cursor maybeLexExclaim(Cursor C, MIToken &Token, in maybeLexExclaim() argument
621 if (C.peek() != '!') in maybeLexExclaim()
623 auto Range = C; in maybeLexExclaim()
624 C.advance(1); in maybeLexExclaim()
625 if (isdigit(C.peek()) || !isIdentifierChar(C.peek())) { in maybeLexExclaim()
626 Token.reset(MIToken::exclaim, Range.upto(C)); in maybeLexExclaim()
627 return C; in maybeLexExclaim()
629 while (isIdentifierChar(C.peek())) in maybeLexExclaim()
630 C.advance(); in maybeLexExclaim()
631 StringRef StrVal = Range.upto(C); in maybeLexExclaim()
636 return C; in maybeLexExclaim()
639 static MIToken::TokenKind symbolToken(char C) { in symbolToken() argument
640 switch (C) { in symbolToken()
659 case '-': in symbolToken()
670 static Cursor maybeLexSymbol(Cursor C, MIToken &Token) { in maybeLexSymbol() argument
673 if (C.peek() == ':' && C.peek(1) == ':') { in maybeLexSymbol()
677 Kind = symbolToken(C.peek()); in maybeLexSymbol()
680 auto Range = C; in maybeLexSymbol()
681 C.advance(Length); in maybeLexSymbol()
682 Token.reset(Kind, Range.upto(C)); in maybeLexSymbol()
683 return C; in maybeLexSymbol()
686 static Cursor maybeLexNewline(Cursor C, MIToken &Token) { in maybeLexNewline() argument
687 if (!isNewlineChar(C.peek())) in maybeLexNewline()
689 auto Range = C; in maybeLexNewline()
690 C.advance(); in maybeLexNewline()
691 Token.reset(MIToken::Newline, Range.upto(C)); in maybeLexNewline()
692 return C; in maybeLexNewline()
695 static Cursor maybeLexEscapedIRValue(Cursor C, MIToken &Token, in maybeLexEscapedIRValue() argument
697 if (C.peek() != '`') in maybeLexEscapedIRValue()
699 auto Range = C; in maybeLexEscapedIRValue()
700 C.advance(); in maybeLexEscapedIRValue()
701 auto StrRange = C; in maybeLexEscapedIRValue()
702 while (C.peek() != '`') { in maybeLexEscapedIRValue()
703 if (C.isEOF() || isNewlineChar(C.peek())) { in maybeLexEscapedIRValue()
705 C.location(), in maybeLexEscapedIRValue()
708 return C; in maybeLexEscapedIRValue()
710 C.advance(); in maybeLexEscapedIRValue()
712 StringRef Value = StrRange.upto(C); in maybeLexEscapedIRValue()
713 C.advance(); in maybeLexEscapedIRValue()
714 Token.reset(MIToken::QuotedIRValue, Range.upto(C)).setStringValue(Value); in maybeLexEscapedIRValue()
715 return C; in maybeLexEscapedIRValue()
720 auto C = skipComment(skipWhitespace(Cursor(Source))); in lexMIToken() local
721 if (C.isEOF()) { in lexMIToken()
722 Token.reset(MIToken::Eof, C.remaining()); in lexMIToken()
723 return C.remaining(); in lexMIToken()
726 C = skipMachineOperandComment(C); in lexMIToken()
728 if (Cursor R = maybeLexMachineBasicBlock(C, Token, ErrorCallback)) in lexMIToken()
730 if (Cursor R = maybeLexIdentifier(C, Token)) in lexMIToken()
732 if (Cursor R = maybeLexJumpTableIndex(C, Token)) in lexMIToken()
734 if (Cursor R = maybeLexStackObject(C, Token)) in lexMIToken()
736 if (Cursor R = maybeLexFixedStackObject(C, Token)) in lexMIToken()
738 if (Cursor R = maybeLexConstantPoolItem(C, Token)) in lexMIToken()
740 if (Cursor R = maybeLexSubRegisterIndex(C, Token, ErrorCallback)) in lexMIToken()
742 if (Cursor R = maybeLexIRBlock(C, Token, ErrorCallback)) in lexMIToken()
744 if (Cursor R = maybeLexIRValue(C, Token, ErrorCallback)) in lexMIToken()
746 if (Cursor R = maybeLexRegister(C, Token, ErrorCallback)) in lexMIToken()
748 if (Cursor R = maybeLexGlobalValue(C, Token, ErrorCallback)) in lexMIToken()
750 if (Cursor R = maybeLexExternalSymbol(C, Token, ErrorCallback)) in lexMIToken()
752 if (Cursor R = maybeLexMCSymbol(C, Token, ErrorCallback)) in lexMIToken()
754 if (Cursor R = maybeLexHexadecimalLiteral(C, Token)) in lexMIToken()
756 if (Cursor R = maybeLexNumericalLiteral(C, Token)) in lexMIToken()
758 if (Cursor R = maybeLexExclaim(C, Token, ErrorCallback)) in lexMIToken()
760 if (Cursor R = maybeLexSymbol(C, Token)) in lexMIToken()
762 if (Cursor R = maybeLexNewline(C, Token)) in lexMIToken()
764 if (Cursor R = maybeLexEscapedIRValue(C, Token, ErrorCallback)) in lexMIToken()
766 if (Cursor R = maybeLexStringConstant(C, Token, ErrorCallback)) in lexMIToken()
769 Token.reset(MIToken::Error, C.remaining()); in lexMIToken()
770 ErrorCallback(C.location(), in lexMIToken()
771 Twine("unexpected character '") + Twine(C.peek()) + "'"); in lexMIToken()
772 return C.remaining(); in lexMIToken()