1//===- LLLexer.cpp - Lexer for .ll Files ----------------------------------===//
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// Implement the Lexer for .ll files.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/AsmParser/LLLexer.h"
14#include "llvm/ADT/APInt.h"
15#include "llvm/ADT/STLExtras.h"
16#include "llvm/ADT/StringExtras.h"
17#include "llvm/ADT/Twine.h"
18#include "llvm/IR/DerivedTypes.h"
19#include "llvm/IR/Instruction.h"
20#include "llvm/Support/ErrorHandling.h"
21#include "llvm/Support/SourceMgr.h"
22#include <cassert>
23#include <cctype>
24#include <cstdio>
25
26using namespace llvm;
27
28// Both the lexer and parser can issue error messages. If the lexer issues a
29// lexer error, since we do not terminate execution immediately, usually that
30// is followed by the parser issuing a parser error. However, the error issued
31// by the lexer is more relevant in that case as opposed to potentially more
32// generic parser error. So instead of always recording the last error message
33// use the `Priority` to establish a priority, with Lexer > Parser > None. We
34// record the issued message only if the message has same or higher priority
35// than the existing one. This prevents lexer errors from being overwritten by
36// parser errors.
37void LLLexer::Error(LocTy ErrorLoc, const Twine &Msg,
38 LLLexer::ErrorPriority Priority) {
39 if (Priority < ErrorInfo.Priority)
40 return;
41 ErrorInfo.Error = SM.GetMessage(Loc: ErrorLoc, Kind: SourceMgr::DK_Error, Msg);
42 ErrorInfo.Priority = Priority;
43}
44
45void LLLexer::Warning(LocTy WarningLoc, const Twine &Msg) const {
46 SM.PrintMessage(Loc: WarningLoc, Kind: SourceMgr::DK_Warning, Msg);
47}
48
49//===----------------------------------------------------------------------===//
50// Helper functions.
51//===----------------------------------------------------------------------===//
52
53// atoull - Convert an ascii string of decimal digits into the unsigned long
54// long representation... this does not have to do input error checking,
55// because we know that the input will be matched by a suitable regex...
56//
57uint64_t LLLexer::atoull(const char *Buffer, const char *End) {
58 uint64_t Result = 0;
59 for (; Buffer != End; Buffer++) {
60 uint64_t OldRes = Result;
61 Result *= 10;
62 Result += *Buffer-'0';
63 if (Result < OldRes) { // overflow detected.
64 LexError(Msg: "constant bigger than 64 bits detected");
65 return 0;
66 }
67 }
68 return Result;
69}
70
71uint64_t LLLexer::HexIntToVal(const char *Buffer, const char *End) {
72 uint64_t Result = 0;
73 for (; Buffer != End; ++Buffer) {
74 uint64_t OldRes = Result;
75 Result *= 16;
76 Result += hexDigitValue(C: *Buffer);
77
78 if (Result < OldRes) { // overflow detected.
79 LexError(Msg: "constant bigger than 64 bits detected");
80 return 0;
81 }
82 }
83 return Result;
84}
85
86void LLLexer::HexToIntPair(const char *Buffer, const char *End,
87 uint64_t Pair[2]) {
88 Pair[0] = 0;
89 if (End - Buffer >= 16) {
90 for (int i = 0; i < 16; i++, Buffer++) {
91 assert(Buffer != End);
92 Pair[0] *= 16;
93 Pair[0] += hexDigitValue(C: *Buffer);
94 }
95 }
96 Pair[1] = 0;
97 for (int i = 0; i < 16 && Buffer != End; i++, Buffer++) {
98 Pair[1] *= 16;
99 Pair[1] += hexDigitValue(C: *Buffer);
100 }
101 if (Buffer != End)
102 LexError(Msg: "constant bigger than 128 bits detected");
103}
104
105/// FP80HexToIntPair - translate an 80 bit FP80 number (20 hexits) into
106/// { low64, high16 } as usual for an APInt.
107void LLLexer::FP80HexToIntPair(const char *Buffer, const char *End,
108 uint64_t Pair[2]) {
109 Pair[1] = 0;
110 for (int i=0; i<4 && Buffer != End; i++, Buffer++) {
111 assert(Buffer != End);
112 Pair[1] *= 16;
113 Pair[1] += hexDigitValue(C: *Buffer);
114 }
115 Pair[0] = 0;
116 for (int i = 0; i < 16 && Buffer != End; i++, Buffer++) {
117 Pair[0] *= 16;
118 Pair[0] += hexDigitValue(C: *Buffer);
119 }
120 if (Buffer != End)
121 LexError(Msg: "constant bigger than 128 bits detected");
122}
123
124// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
125// appropriate character.
126static void UnEscapeLexed(std::string &Str) {
127 if (Str.empty()) return;
128
129 char *Buffer = &Str[0], *EndBuffer = Buffer+Str.size();
130 char *BOut = Buffer;
131 for (char *BIn = Buffer; BIn != EndBuffer; ) {
132 if (BIn[0] == '\\') {
133 if (BIn < EndBuffer-1 && BIn[1] == '\\') {
134 *BOut++ = '\\'; // Two \ becomes one
135 BIn += 2;
136 } else if (BIn < EndBuffer-2 &&
137 isxdigit(static_cast<unsigned char>(BIn[1])) &&
138 isxdigit(static_cast<unsigned char>(BIn[2]))) {
139 *BOut = hexDigitValue(C: BIn[1]) * 16 + hexDigitValue(C: BIn[2]);
140 BIn += 3; // Skip over handled chars
141 ++BOut;
142 } else {
143 *BOut++ = *BIn++;
144 }
145 } else {
146 *BOut++ = *BIn++;
147 }
148 }
149 Str.resize(n: BOut-Buffer);
150}
151
152/// isLabelChar - Return true for [-a-zA-Z$._0-9].
153static bool isLabelChar(char C) {
154 return isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' ||
155 C == '.' || C == '_';
156}
157
158/// isLabelTail - Return true if this pointer points to a valid end of a label.
159static const char *isLabelTail(const char *CurPtr) {
160 while (true) {
161 if (CurPtr[0] == ':') return CurPtr+1;
162 if (!isLabelChar(C: CurPtr[0])) return nullptr;
163 ++CurPtr;
164 }
165}
166
167//===----------------------------------------------------------------------===//
168// Lexer definition.
169//===----------------------------------------------------------------------===//
170
171LLLexer::LLLexer(StringRef StartBuf, SourceMgr &SM, SMDiagnostic &Err,
172 LLVMContext &C)
173 : CurBuf(StartBuf), ErrorInfo(Err), SM(SM), Context(C) {
174 CurPtr = CurBuf.begin();
175}
176
177int LLLexer::getNextChar() {
178 char CurChar = *CurPtr++;
179 switch (CurChar) {
180 default: return (unsigned char)CurChar;
181 case 0:
182 // A nul character in the stream is either the end of the current buffer or
183 // a random nul in the file. Disambiguate that here.
184 if (CurPtr-1 != CurBuf.end())
185 return 0; // Just whitespace.
186
187 // Otherwise, return end of file.
188 --CurPtr; // Another call to lex will return EOF again.
189 return EOF;
190 }
191}
192
193lltok::Kind LLLexer::LexToken() {
194 // Set token end to next location, since the end is exclusive.
195 PrevTokEnd = CurPtr;
196 while (true) {
197 TokStart = CurPtr;
198
199 int CurChar = getNextChar();
200 switch (CurChar) {
201 default:
202 // Handle letters: [a-zA-Z_]
203 if (isalpha(static_cast<unsigned char>(CurChar)) || CurChar == '_')
204 return LexIdentifier();
205 return lltok::Error;
206 case EOF: return lltok::Eof;
207 case 0:
208 case ' ':
209 case '\t':
210 case '\n':
211 case '\r':
212 // Ignore whitespace.
213 continue;
214 case '+': return LexPositive();
215 case '@': return LexAt();
216 case '$': return LexDollar();
217 case '%': return LexPercent();
218 case '"': return LexQuote();
219 case '.':
220 if (const char *Ptr = isLabelTail(CurPtr)) {
221 CurPtr = Ptr;
222 StrVal.assign(first: TokStart, last: CurPtr-1);
223 return lltok::LabelStr;
224 }
225 if (CurPtr[0] == '.' && CurPtr[1] == '.') {
226 CurPtr += 2;
227 return lltok::dotdotdot;
228 }
229 return lltok::Error;
230 case ';':
231 SkipLineComment();
232 continue;
233 case '!': return LexExclaim();
234 case '^':
235 return LexCaret();
236 case ':':
237 return lltok::colon;
238 case '#': return LexHash();
239 case '0': case '1': case '2': case '3': case '4':
240 case '5': case '6': case '7': case '8': case '9':
241 case '-':
242 return LexDigitOrNegative();
243 case '=': return lltok::equal;
244 case '[': return lltok::lsquare;
245 case ']': return lltok::rsquare;
246 case '{': return lltok::lbrace;
247 case '}': return lltok::rbrace;
248 case '<': return lltok::less;
249 case '>': return lltok::greater;
250 case '(': return lltok::lparen;
251 case ')': return lltok::rparen;
252 case ',': return lltok::comma;
253 case '*': return lltok::star;
254 case '|': return lltok::bar;
255 case '/':
256 if (getNextChar() != '*')
257 return lltok::Error;
258 if (SkipCComment())
259 return lltok::Error;
260 continue;
261 }
262 }
263}
264
265void LLLexer::SkipLineComment() {
266 while (true) {
267 if (CurPtr[0] == '\n' || CurPtr[0] == '\r' || getNextChar() == EOF)
268 return;
269 }
270}
271
272/// This skips C-style /**/ comments. Returns true if there
273/// was an error.
274bool LLLexer::SkipCComment() {
275 while (true) {
276 int CurChar = getNextChar();
277 switch (CurChar) {
278 case EOF:
279 LexError(Msg: "unterminated comment");
280 return true;
281 case '*':
282 // End of the comment?
283 CurChar = getNextChar();
284 if (CurChar == '/')
285 return false;
286 if (CurChar == EOF) {
287 LexError(Msg: "unterminated comment");
288 return true;
289 }
290 }
291 }
292}
293
294/// Lex all tokens that start with an @ character.
295/// GlobalVar @\"[^\"]*\"
296/// GlobalVar @[-a-zA-Z$._][-a-zA-Z$._0-9]*
297/// GlobalVarID @[0-9]+
298lltok::Kind LLLexer::LexAt() {
299 return LexVar(Var: lltok::GlobalVar, VarID: lltok::GlobalID);
300}
301
302lltok::Kind LLLexer::LexDollar() {
303 if (const char *Ptr = isLabelTail(CurPtr: TokStart)) {
304 CurPtr = Ptr;
305 StrVal.assign(first: TokStart, last: CurPtr - 1);
306 return lltok::LabelStr;
307 }
308
309 // Handle DollarStringConstant: $\"[^\"]*\"
310 if (CurPtr[0] == '"') {
311 ++CurPtr;
312
313 while (true) {
314 int CurChar = getNextChar();
315
316 if (CurChar == EOF) {
317 LexError(Msg: "end of file in COMDAT variable name");
318 return lltok::Error;
319 }
320 if (CurChar == '"') {
321 StrVal.assign(first: TokStart + 2, last: CurPtr - 1);
322 UnEscapeLexed(Str&: StrVal);
323 if (StringRef(StrVal).contains(C: 0)) {
324 LexError(Msg: "NUL character is not allowed in names");
325 return lltok::Error;
326 }
327 return lltok::ComdatVar;
328 }
329 }
330 }
331
332 // Handle ComdatVarName: $[-a-zA-Z$._][-a-zA-Z$._0-9]*
333 if (ReadVarName())
334 return lltok::ComdatVar;
335
336 return lltok::Error;
337}
338
339/// ReadString - Read a string until the closing quote.
340lltok::Kind LLLexer::ReadString(lltok::Kind kind) {
341 const char *Start = CurPtr;
342 while (true) {
343 int CurChar = getNextChar();
344
345 if (CurChar == EOF) {
346 LexError(Msg: "end of file in string constant");
347 return lltok::Error;
348 }
349 if (CurChar == '"') {
350 StrVal.assign(first: Start, last: CurPtr-1);
351 UnEscapeLexed(Str&: StrVal);
352 return kind;
353 }
354 }
355}
356
357/// ReadVarName - Read the rest of a token containing a variable name.
358bool LLLexer::ReadVarName() {
359 const char *NameStart = CurPtr;
360 if (isalpha(static_cast<unsigned char>(CurPtr[0])) ||
361 CurPtr[0] == '-' || CurPtr[0] == '$' ||
362 CurPtr[0] == '.' || CurPtr[0] == '_') {
363 ++CurPtr;
364 while (isalnum(static_cast<unsigned char>(CurPtr[0])) ||
365 CurPtr[0] == '-' || CurPtr[0] == '$' ||
366 CurPtr[0] == '.' || CurPtr[0] == '_')
367 ++CurPtr;
368
369 StrVal.assign(first: NameStart, last: CurPtr);
370 return true;
371 }
372 return false;
373}
374
375// Lex an ID: [0-9]+. On success, the ID is stored in UIntVal and Token is
376// returned, otherwise the Error token is returned.
377lltok::Kind LLLexer::LexUIntID(lltok::Kind Token) {
378 if (!isdigit(static_cast<unsigned char>(CurPtr[0])))
379 return lltok::Error;
380
381 for (++CurPtr; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
382 /*empty*/;
383
384 uint64_t Val = atoull(Buffer: TokStart + 1, End: CurPtr);
385 if ((unsigned)Val != Val)
386 LexError(Msg: "invalid value number (too large)");
387 UIntVal = unsigned(Val);
388 return Token;
389}
390
391lltok::Kind LLLexer::LexVar(lltok::Kind Var, lltok::Kind VarID) {
392 // Handle StringConstant: \"[^\"]*\"
393 if (CurPtr[0] == '"') {
394 ++CurPtr;
395
396 while (true) {
397 int CurChar = getNextChar();
398
399 if (CurChar == EOF) {
400 LexError(Msg: "end of file in global variable name");
401 return lltok::Error;
402 }
403 if (CurChar == '"') {
404 StrVal.assign(first: TokStart+2, last: CurPtr-1);
405 UnEscapeLexed(Str&: StrVal);
406 if (StringRef(StrVal).contains(C: 0)) {
407 LexError(Msg: "NUL character is not allowed in names");
408 return lltok::Error;
409 }
410 return Var;
411 }
412 }
413 }
414
415 // Handle VarName: [-a-zA-Z$._][-a-zA-Z$._0-9]*
416 if (ReadVarName())
417 return Var;
418
419 // Handle VarID: [0-9]+
420 return LexUIntID(Token: VarID);
421}
422
423/// Lex all tokens that start with a % character.
424/// LocalVar ::= %\"[^\"]*\"
425/// LocalVar ::= %[-a-zA-Z$._][-a-zA-Z$._0-9]*
426/// LocalVarID ::= %[0-9]+
427lltok::Kind LLLexer::LexPercent() {
428 return LexVar(Var: lltok::LocalVar, VarID: lltok::LocalVarID);
429}
430
431/// Lex all tokens that start with a " character.
432/// QuoteLabel "[^"]+":
433/// StringConstant "[^"]*"
434lltok::Kind LLLexer::LexQuote() {
435 lltok::Kind kind = ReadString(kind: lltok::StringConstant);
436 if (kind == lltok::Error || kind == lltok::Eof)
437 return kind;
438
439 if (CurPtr[0] == ':') {
440 ++CurPtr;
441 if (StringRef(StrVal).contains(C: 0)) {
442 LexError(Msg: "NUL character is not allowed in names");
443 kind = lltok::Error;
444 } else {
445 kind = lltok::LabelStr;
446 }
447 }
448
449 return kind;
450}
451
452/// Lex all tokens that start with a ! character.
453/// !foo
454/// !
455lltok::Kind LLLexer::LexExclaim() {
456 // Lex a metadata name as a MetadataVar.
457 if (isalpha(static_cast<unsigned char>(CurPtr[0])) ||
458 CurPtr[0] == '-' || CurPtr[0] == '$' ||
459 CurPtr[0] == '.' || CurPtr[0] == '_' || CurPtr[0] == '\\') {
460 ++CurPtr;
461 while (isalnum(static_cast<unsigned char>(CurPtr[0])) ||
462 CurPtr[0] == '-' || CurPtr[0] == '$' ||
463 CurPtr[0] == '.' || CurPtr[0] == '_' || CurPtr[0] == '\\')
464 ++CurPtr;
465
466 StrVal.assign(first: TokStart+1, last: CurPtr); // Skip !
467 UnEscapeLexed(Str&: StrVal);
468 return lltok::MetadataVar;
469 }
470 return lltok::exclaim;
471}
472
473/// Lex all tokens that start with a ^ character.
474/// SummaryID ::= ^[0-9]+
475lltok::Kind LLLexer::LexCaret() {
476 // Handle SummaryID: ^[0-9]+
477 return LexUIntID(Token: lltok::SummaryID);
478}
479
480/// Lex all tokens that start with a # character.
481/// AttrGrpID ::= #[0-9]+
482/// Hash ::= #
483lltok::Kind LLLexer::LexHash() {
484 // Handle AttrGrpID: #[0-9]+
485 if (isdigit(static_cast<unsigned char>(CurPtr[0])))
486 return LexUIntID(Token: lltok::AttrGrpID);
487 return lltok::hash;
488}
489
490/// Lex a label, integer or byte types, keyword, or hexadecimal integer
491/// constant.
492/// Label [-a-zA-Z$._0-9]+:
493/// ByteType b[0-9]+
494/// IntegerType i[0-9]+
495/// Keyword sdiv, float, ...
496/// HexIntConstant [us]0x[0-9A-Fa-f]+
497/// HexFloatConstant f0x[0-9A-Fa-f]+
498lltok::Kind LLLexer::LexIdentifier() {
499 const char *StartChar = CurPtr;
500 const char IntOrByteIdentifier = CurPtr[-1];
501 const char *IntOrByteEnd =
502 (IntOrByteIdentifier == 'i' || IntOrByteIdentifier == 'b') ? nullptr
503 : StartChar;
504 const char *KeywordEnd = nullptr;
505
506 for (; isLabelChar(C: *CurPtr); ++CurPtr) {
507 // If we decide this is a byte or an integer, remember the end of the
508 // sequence.
509 if (!IntOrByteEnd && !isdigit(static_cast<unsigned char>(*CurPtr)))
510 IntOrByteEnd = CurPtr;
511 if (!KeywordEnd && !isalnum(static_cast<unsigned char>(*CurPtr)) &&
512 *CurPtr != '_')
513 KeywordEnd = CurPtr;
514 }
515
516 // If we stopped due to a colon, unless we were directed to ignore it,
517 // this really is a label.
518 if (!IgnoreColonInIdentifiers && *CurPtr == ':') {
519 StrVal.assign(first: StartChar-1, last: CurPtr++);
520 return lltok::LabelStr;
521 }
522
523 // Otherwise, this wasn't a label. If this was valid as a byte or an integer
524 // type, return it.
525 if (!IntOrByteEnd)
526 IntOrByteEnd = CurPtr;
527 if (IntOrByteEnd != StartChar) {
528 CurPtr = IntOrByteEnd;
529 uint64_t NumBits = atoull(Buffer: StartChar, End: CurPtr);
530 if (NumBits < IntegerType::MIN_INT_BITS ||
531 NumBits > IntegerType::MAX_INT_BITS) {
532 LexError(Msg: "bitwidth for integer or byte type out of range");
533 return lltok::Error;
534 }
535 if (IntOrByteIdentifier == 'i')
536 TyVal = IntegerType::get(C&: Context, NumBits);
537 else
538 TyVal = ByteType::get(C&: Context, NumBits);
539
540 return lltok::Type;
541 }
542
543 // Otherwise, this was a letter sequence. See which keyword this is.
544 if (!KeywordEnd) KeywordEnd = CurPtr;
545 CurPtr = KeywordEnd;
546 --StartChar;
547 StringRef Keyword(StartChar, CurPtr - StartChar);
548
549#define KEYWORD(STR) \
550 do { \
551 if (Keyword == #STR) \
552 return lltok::kw_##STR; \
553 } while (false)
554
555 KEYWORD(true); KEYWORD(false);
556 KEYWORD(declare); KEYWORD(define);
557 KEYWORD(global); KEYWORD(constant);
558 KEYWORD(br);
559
560 KEYWORD(dso_local);
561 KEYWORD(dso_preemptable);
562
563 KEYWORD(private);
564 KEYWORD(internal);
565 KEYWORD(available_externally);
566 KEYWORD(linkonce);
567 KEYWORD(linkonce_odr);
568 KEYWORD(weak); // Use as a linkage, and a modifier for "cmpxchg".
569 KEYWORD(weak_odr);
570 KEYWORD(appending);
571 KEYWORD(dllimport);
572 KEYWORD(dllexport);
573 KEYWORD(common);
574 KEYWORD(default);
575 KEYWORD(hidden);
576 KEYWORD(protected);
577 KEYWORD(unnamed_addr);
578 KEYWORD(local_unnamed_addr);
579 KEYWORD(externally_initialized);
580 KEYWORD(extern_weak);
581 KEYWORD(external);
582 KEYWORD(thread_local);
583 KEYWORD(localdynamic);
584 KEYWORD(initialexec);
585 KEYWORD(localexec);
586 KEYWORD(zeroinitializer);
587 KEYWORD(undef);
588 KEYWORD(null);
589 KEYWORD(none);
590 KEYWORD(poison);
591 KEYWORD(to);
592 KEYWORD(caller);
593 KEYWORD(within);
594 KEYWORD(from);
595 KEYWORD(tail);
596 KEYWORD(musttail);
597 KEYWORD(notail);
598 KEYWORD(target);
599 KEYWORD(triple);
600 KEYWORD(source_filename);
601 KEYWORD(unwind);
602 KEYWORD(datalayout);
603 KEYWORD(volatile);
604 KEYWORD(elementwise);
605 KEYWORD(atomic);
606 KEYWORD(unordered);
607 KEYWORD(monotonic);
608 KEYWORD(acquire);
609 KEYWORD(release);
610 KEYWORD(acq_rel);
611 KEYWORD(seq_cst);
612 KEYWORD(syncscope);
613
614 KEYWORD(nnan);
615 KEYWORD(ninf);
616 KEYWORD(nsz);
617 KEYWORD(arcp);
618 KEYWORD(contract);
619 KEYWORD(reassoc);
620 KEYWORD(afn);
621 KEYWORD(fast);
622 KEYWORD(nuw);
623 KEYWORD(nsw);
624 KEYWORD(nusw);
625 KEYWORD(exact);
626 KEYWORD(disjoint);
627 KEYWORD(inbounds);
628 KEYWORD(nneg);
629 KEYWORD(samesign);
630 KEYWORD(inrange);
631 KEYWORD(addrspace);
632 KEYWORD(section);
633 KEYWORD(partition);
634 KEYWORD(code_model);
635 KEYWORD(alias);
636 KEYWORD(ifunc);
637 KEYWORD(module);
638 KEYWORD(asm);
639 KEYWORD(sideeffect);
640 KEYWORD(inteldialect);
641 KEYWORD(gc);
642 KEYWORD(prefix);
643 KEYWORD(prologue);
644 KEYWORD(prefalign);
645
646 KEYWORD(no_sanitize_address);
647 KEYWORD(no_sanitize_hwaddress);
648 KEYWORD(sanitize_address_dyninit);
649
650 KEYWORD(ccc);
651 KEYWORD(fastcc);
652 KEYWORD(coldcc);
653 KEYWORD(cfguard_checkcc);
654 KEYWORD(x86_stdcallcc);
655 KEYWORD(x86_fastcallcc);
656 KEYWORD(x86_thiscallcc);
657 KEYWORD(x86_vectorcallcc);
658 KEYWORD(arm_apcscc);
659 KEYWORD(arm_aapcscc);
660 KEYWORD(arm_aapcs_vfpcc);
661 KEYWORD(aarch64_vector_pcs);
662 KEYWORD(aarch64_sve_vector_pcs);
663 KEYWORD(aarch64_sme_preservemost_from_x0);
664 KEYWORD(aarch64_sme_preservemost_from_x1);
665 KEYWORD(aarch64_sme_preservemost_from_x2);
666 KEYWORD(msp430_intrcc);
667 KEYWORD(avr_intrcc);
668 KEYWORD(avr_signalcc);
669 KEYWORD(ptx_kernel);
670 KEYWORD(ptx_device);
671 KEYWORD(spir_kernel);
672 KEYWORD(spir_func);
673 KEYWORD(intel_ocl_bicc);
674 KEYWORD(x86_64_sysvcc);
675 KEYWORD(win64cc);
676 KEYWORD(x86_regcallcc);
677 KEYWORD(swiftcc);
678 KEYWORD(swifttailcc);
679 KEYWORD(anyregcc);
680 KEYWORD(preserve_mostcc);
681 KEYWORD(preserve_allcc);
682 KEYWORD(preserve_nonecc);
683 KEYWORD(ghccc);
684 KEYWORD(x86_intrcc);
685 KEYWORD(hhvmcc);
686 KEYWORD(hhvm_ccc);
687 KEYWORD(cxx_fast_tlscc);
688 KEYWORD(amdgpu_vs);
689 KEYWORD(amdgpu_ls);
690 KEYWORD(amdgpu_hs);
691 KEYWORD(amdgpu_es);
692 KEYWORD(amdgpu_gs);
693 KEYWORD(amdgpu_ps);
694 KEYWORD(amdgpu_cs);
695 KEYWORD(amdgpu_cs_chain);
696 KEYWORD(amdgpu_cs_chain_preserve);
697 KEYWORD(amdgpu_kernel);
698 KEYWORD(amdgpu_gfx);
699 KEYWORD(amdgpu_gfx_whole_wave);
700 KEYWORD(tailcc);
701 KEYWORD(m68k_rtdcc);
702 KEYWORD(wasm_emscripten_invokecc);
703 KEYWORD(graalcc);
704 KEYWORD(riscv_vector_cc);
705 KEYWORD(riscv_vls_cc);
706 KEYWORD(cheriot_compartmentcallcc);
707 KEYWORD(cheriot_compartmentcalleecc);
708 KEYWORD(cheriot_librarycallcc);
709
710 KEYWORD(cc);
711 KEYWORD(c);
712
713 KEYWORD(attributes);
714 KEYWORD(sync);
715 KEYWORD(async);
716
717#define GET_ATTR_NAMES
718#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
719 KEYWORD(DISPLAY_NAME);
720#include "llvm/IR/Attributes.inc"
721
722 KEYWORD(read);
723 KEYWORD(write);
724 KEYWORD(readwrite);
725 KEYWORD(argmem);
726 KEYWORD(target_mem0);
727 KEYWORD(target_mem1);
728 KEYWORD(target_mem);
729 KEYWORD(inaccessiblemem);
730 KEYWORD(errnomem);
731 KEYWORD(argmemonly);
732 KEYWORD(inaccessiblememonly);
733 KEYWORD(inaccessiblemem_or_argmemonly);
734 KEYWORD(nocapture);
735 KEYWORD(address_is_null);
736 KEYWORD(address);
737 KEYWORD(provenance);
738 KEYWORD(read_provenance);
739
740 // denormal_fpenv attribute
741 KEYWORD(ieee);
742 KEYWORD(preservesign);
743 KEYWORD(positivezero);
744 KEYWORD(dynamic);
745
746 // nofpclass attribute
747 KEYWORD(all);
748 KEYWORD(nan);
749 KEYWORD(snan);
750 KEYWORD(qnan);
751 KEYWORD(inf);
752 // ninf already a keyword
753 KEYWORD(pinf);
754 KEYWORD(norm);
755 KEYWORD(nnorm);
756 KEYWORD(pnorm);
757 // sub already a keyword
758 KEYWORD(nsub);
759 KEYWORD(psub);
760 KEYWORD(zero);
761 KEYWORD(nzero);
762 KEYWORD(pzero);
763
764 KEYWORD(type);
765 KEYWORD(opaque);
766
767 KEYWORD(comdat);
768
769 // Comdat types
770 KEYWORD(any);
771 KEYWORD(exactmatch);
772 KEYWORD(largest);
773 KEYWORD(nodeduplicate);
774 KEYWORD(samesize);
775
776 KEYWORD(eq); KEYWORD(ne); KEYWORD(slt); KEYWORD(sgt); KEYWORD(sle);
777 KEYWORD(sge); KEYWORD(ult); KEYWORD(ugt); KEYWORD(ule); KEYWORD(uge);
778 KEYWORD(oeq); KEYWORD(one); KEYWORD(olt); KEYWORD(ogt); KEYWORD(ole);
779 KEYWORD(oge); KEYWORD(ord); KEYWORD(uno); KEYWORD(ueq); KEYWORD(une);
780
781 KEYWORD(xchg); KEYWORD(nand); KEYWORD(max); KEYWORD(min); KEYWORD(umax);
782 KEYWORD(umin); KEYWORD(fmax); KEYWORD(fmin);
783 KEYWORD(fmaximum);
784 KEYWORD(fminimum);
785 KEYWORD(fmaximumnum);
786 KEYWORD(fminimumnum);
787 KEYWORD(uinc_wrap);
788 KEYWORD(udec_wrap);
789 KEYWORD(usub_cond);
790 KEYWORD(usub_sat);
791
792 KEYWORD(splat);
793 KEYWORD(vscale);
794 KEYWORD(x);
795 KEYWORD(blockaddress);
796 KEYWORD(dso_local_equivalent);
797 KEYWORD(no_cfi);
798 KEYWORD(ptrauth);
799
800 // Metadata types.
801 KEYWORD(distinct);
802
803 // Use-list order directives.
804 KEYWORD(uselistorder);
805
806 KEYWORD(personality);
807 KEYWORD(cleanup);
808 KEYWORD(catch);
809 KEYWORD(filter);
810
811 // Summary index keywords.
812 KEYWORD(path);
813 KEYWORD(hash);
814 KEYWORD(gv);
815 KEYWORD(guid);
816 KEYWORD(name);
817 KEYWORD(summaries);
818 KEYWORD(flags);
819 KEYWORD(blockcount);
820 KEYWORD(linkage);
821 KEYWORD(visibility);
822 KEYWORD(notEligibleToImport);
823 KEYWORD(live);
824 KEYWORD(dsoLocal);
825 KEYWORD(canAutoHide);
826 KEYWORD(importType);
827 KEYWORD(definition);
828 KEYWORD(declaration);
829 KEYWORD(noRenameOnPromotion);
830 KEYWORD(function);
831 KEYWORD(insts);
832 KEYWORD(funcFlags);
833 KEYWORD(readNone);
834 KEYWORD(readOnly);
835 KEYWORD(noRecurse);
836 KEYWORD(returnDoesNotAlias);
837 KEYWORD(noInline);
838 KEYWORD(alwaysInline);
839 KEYWORD(noUnwind);
840 KEYWORD(mayThrow);
841 KEYWORD(hasUnknownCall);
842 KEYWORD(mustBeUnreachable);
843 KEYWORD(calls);
844 KEYWORD(callee);
845 KEYWORD(params);
846 KEYWORD(param);
847 KEYWORD(hotness);
848 KEYWORD(unknown);
849 KEYWORD(critical);
850 // Deprecated, keep in order to support old files.
851 KEYWORD(relbf);
852 KEYWORD(variable);
853 KEYWORD(vTableFuncs);
854 KEYWORD(virtFunc);
855 KEYWORD(aliasee);
856 KEYWORD(refs);
857 KEYWORD(typeIdInfo);
858 KEYWORD(typeTests);
859 KEYWORD(typeTestAssumeVCalls);
860 KEYWORD(typeCheckedLoadVCalls);
861 KEYWORD(typeTestAssumeConstVCalls);
862 KEYWORD(typeCheckedLoadConstVCalls);
863 KEYWORD(vFuncId);
864 KEYWORD(offset);
865 KEYWORD(args);
866 KEYWORD(typeid);
867 KEYWORD(typeidCompatibleVTable);
868 KEYWORD(summary);
869 KEYWORD(typeTestRes);
870 KEYWORD(kind);
871 KEYWORD(unsat);
872 KEYWORD(byteArray);
873 KEYWORD(inline);
874 KEYWORD(single);
875 KEYWORD(allOnes);
876 KEYWORD(sizeM1BitWidth);
877 KEYWORD(alignLog2);
878 KEYWORD(sizeM1);
879 KEYWORD(bitMask);
880 KEYWORD(inlineBits);
881 KEYWORD(vcall_visibility);
882 KEYWORD(wpdResolutions);
883 KEYWORD(wpdRes);
884 KEYWORD(indir);
885 KEYWORD(singleImpl);
886 KEYWORD(branchFunnel);
887 KEYWORD(singleImplName);
888 KEYWORD(resByArg);
889 KEYWORD(byArg);
890 KEYWORD(uniformRetVal);
891 KEYWORD(uniqueRetVal);
892 KEYWORD(virtualConstProp);
893 KEYWORD(info);
894 KEYWORD(byte);
895 KEYWORD(bit);
896 KEYWORD(varFlags);
897 KEYWORD(callsites);
898 KEYWORD(clones);
899 KEYWORD(stackIds);
900 KEYWORD(allocs);
901 KEYWORD(versions);
902 KEYWORD(memProf);
903 KEYWORD(notcold);
904
905#undef KEYWORD
906
907 // Keywords for types.
908#define TYPEKEYWORD(STR, LLVMTY) \
909 do { \
910 if (Keyword == STR) { \
911 TyVal = LLVMTY; \
912 return lltok::Type; \
913 } \
914 } while (false)
915
916 TYPEKEYWORD("void", Type::getVoidTy(Context));
917 TYPEKEYWORD("half", Type::getHalfTy(Context));
918 TYPEKEYWORD("bfloat", Type::getBFloatTy(Context));
919 TYPEKEYWORD("float", Type::getFloatTy(Context));
920 TYPEKEYWORD("double", Type::getDoubleTy(Context));
921 TYPEKEYWORD("x86_fp80", Type::getX86_FP80Ty(Context));
922 TYPEKEYWORD("fp128", Type::getFP128Ty(Context));
923 TYPEKEYWORD("ppc_fp128", Type::getPPC_FP128Ty(Context));
924 TYPEKEYWORD("label", Type::getLabelTy(Context));
925 TYPEKEYWORD("metadata", Type::getMetadataTy(Context));
926 TYPEKEYWORD("x86_amx", Type::getX86_AMXTy(Context));
927 TYPEKEYWORD("token", Type::getTokenTy(Context));
928 TYPEKEYWORD("ptr", PointerType::getUnqual(Context));
929
930#undef TYPEKEYWORD
931
932 // Keywords for instructions.
933#define INSTKEYWORD(STR, Enum) \
934 do { \
935 if (Keyword == #STR) { \
936 UIntVal = Instruction::Enum; \
937 return lltok::kw_##STR; \
938 } \
939 } while (false)
940
941 INSTKEYWORD(fneg, FNeg);
942
943 INSTKEYWORD(add, Add); INSTKEYWORD(fadd, FAdd);
944 INSTKEYWORD(sub, Sub); INSTKEYWORD(fsub, FSub);
945 INSTKEYWORD(mul, Mul); INSTKEYWORD(fmul, FMul);
946 INSTKEYWORD(udiv, UDiv); INSTKEYWORD(sdiv, SDiv); INSTKEYWORD(fdiv, FDiv);
947 INSTKEYWORD(urem, URem); INSTKEYWORD(srem, SRem); INSTKEYWORD(frem, FRem);
948 INSTKEYWORD(shl, Shl); INSTKEYWORD(lshr, LShr); INSTKEYWORD(ashr, AShr);
949 INSTKEYWORD(and, And); INSTKEYWORD(or, Or); INSTKEYWORD(xor, Xor);
950 INSTKEYWORD(icmp, ICmp); INSTKEYWORD(fcmp, FCmp);
951
952 INSTKEYWORD(phi, PHI);
953 INSTKEYWORD(call, Call);
954 INSTKEYWORD(trunc, Trunc);
955 INSTKEYWORD(zext, ZExt);
956 INSTKEYWORD(sext, SExt);
957 INSTKEYWORD(fptrunc, FPTrunc);
958 INSTKEYWORD(fpext, FPExt);
959 INSTKEYWORD(uitofp, UIToFP);
960 INSTKEYWORD(sitofp, SIToFP);
961 INSTKEYWORD(fptoui, FPToUI);
962 INSTKEYWORD(fptosi, FPToSI);
963 INSTKEYWORD(inttoptr, IntToPtr);
964 INSTKEYWORD(ptrtoaddr, PtrToAddr);
965 INSTKEYWORD(ptrtoint, PtrToInt);
966 INSTKEYWORD(bitcast, BitCast);
967 INSTKEYWORD(addrspacecast, AddrSpaceCast);
968 INSTKEYWORD(select, Select);
969 INSTKEYWORD(va_arg, VAArg);
970 INSTKEYWORD(ret, Ret);
971 INSTKEYWORD(switch, Switch);
972 INSTKEYWORD(indirectbr, IndirectBr);
973 INSTKEYWORD(invoke, Invoke);
974 INSTKEYWORD(resume, Resume);
975 INSTKEYWORD(unreachable, Unreachable);
976 INSTKEYWORD(callbr, CallBr);
977
978 INSTKEYWORD(alloca, Alloca);
979 INSTKEYWORD(load, Load);
980 INSTKEYWORD(store, Store);
981 INSTKEYWORD(cmpxchg, AtomicCmpXchg);
982 INSTKEYWORD(atomicrmw, AtomicRMW);
983 INSTKEYWORD(fence, Fence);
984 INSTKEYWORD(getelementptr, GetElementPtr);
985
986 INSTKEYWORD(extractelement, ExtractElement);
987 INSTKEYWORD(insertelement, InsertElement);
988 INSTKEYWORD(shufflevector, ShuffleVector);
989 INSTKEYWORD(extractvalue, ExtractValue);
990 INSTKEYWORD(insertvalue, InsertValue);
991 INSTKEYWORD(landingpad, LandingPad);
992 INSTKEYWORD(cleanupret, CleanupRet);
993 INSTKEYWORD(catchret, CatchRet);
994 INSTKEYWORD(catchswitch, CatchSwitch);
995 INSTKEYWORD(catchpad, CatchPad);
996 INSTKEYWORD(cleanuppad, CleanupPad);
997
998 INSTKEYWORD(freeze, Freeze);
999 INSTKEYWORD(bitinsert, BitInsert);
1000 INSTKEYWORD(bitextract, BitExtract);
1001
1002#undef INSTKEYWORD
1003
1004#define DWKEYWORD(TYPE, TOKEN) \
1005 do { \
1006 if (Keyword.starts_with("DW_" #TYPE "_")) { \
1007 StrVal.assign(Keyword.begin(), Keyword.end()); \
1008 return lltok::TOKEN; \
1009 } \
1010 } while (false)
1011
1012 DWKEYWORD(TAG, DwarfTag);
1013 DWKEYWORD(ATE, DwarfAttEncoding);
1014 DWKEYWORD(VIRTUALITY, DwarfVirtuality);
1015 DWKEYWORD(LLVM_LANG_DIALECT, DwarfLangDialect);
1016 DWKEYWORD(LANG, DwarfLang);
1017 DWKEYWORD(LNAME, DwarfSourceLangName);
1018 DWKEYWORD(CC, DwarfCC);
1019 DWKEYWORD(OP, DwarfOp);
1020 DWKEYWORD(MACINFO, DwarfMacinfo);
1021 DWKEYWORD(APPLE_ENUM_KIND, DwarfEnumKind);
1022
1023#undef DWKEYWORD
1024
1025// Keywords for debug record types.
1026#define DBGRECORDTYPEKEYWORD(STR) \
1027 do { \
1028 if (Keyword == "dbg_" #STR) { \
1029 StrVal = #STR; \
1030 return lltok::DbgRecordType; \
1031 } \
1032 } while (false)
1033
1034 DBGRECORDTYPEKEYWORD(value);
1035 DBGRECORDTYPEKEYWORD(declare);
1036 DBGRECORDTYPEKEYWORD(assign);
1037 DBGRECORDTYPEKEYWORD(label);
1038 DBGRECORDTYPEKEYWORD(declare_value);
1039#undef DBGRECORDTYPEKEYWORD
1040
1041 if (Keyword.starts_with(Prefix: "DIFlag")) {
1042 StrVal.assign(first: Keyword.begin(), last: Keyword.end());
1043 return lltok::DIFlag;
1044 }
1045
1046 if (Keyword.starts_with(Prefix: "DISPFlag")) {
1047 StrVal.assign(first: Keyword.begin(), last: Keyword.end());
1048 return lltok::DISPFlag;
1049 }
1050
1051 if (Keyword.starts_with(Prefix: "CSK_")) {
1052 StrVal.assign(first: Keyword.begin(), last: Keyword.end());
1053 return lltok::ChecksumKind;
1054 }
1055
1056 if (Keyword == "NoDebug" || Keyword == "FullDebug" ||
1057 Keyword == "LineTablesOnly" || Keyword == "DebugDirectivesOnly") {
1058 StrVal.assign(first: Keyword.begin(), last: Keyword.end());
1059 return lltok::EmissionKind;
1060 }
1061
1062 if (Keyword == "GNU" || Keyword == "Apple" || Keyword == "None" ||
1063 Keyword == "Default") {
1064 StrVal.assign(first: Keyword.begin(), last: Keyword.end());
1065 return lltok::NameTableKind;
1066 }
1067
1068 if (Keyword == "Binary" || Keyword == "Decimal" || Keyword == "Rational") {
1069 StrVal.assign(first: Keyword.begin(), last: Keyword.end());
1070 return lltok::FixedPointKind;
1071 }
1072
1073 // Check for [us]0x[0-9A-Fa-f]+ which are Hexadecimal constant generated by
1074 // the CFE to avoid forcing it to deal with 64-bit numbers. Also check for
1075 // f0x[0-9A-Fa-f]+, which is the floating-point hexadecimal literal constant.
1076 if ((TokStart[0] == 'u' || TokStart[0] == 's' || TokStart[0] == 'f') &&
1077 TokStart[1] == '0' && TokStart[2] == 'x' &&
1078 isxdigit(static_cast<unsigned char>(TokStart[3]))) {
1079 bool IsFloatConst = TokStart[0] == 'f';
1080 size_t Len = CurPtr - TokStart - 3;
1081 uint32_t Bits = Len * 4;
1082 StringRef HexStr(TokStart + 3, Len);
1083 if (!all_of(Range&: HexStr, P: isxdigit)) {
1084 // Bad token, return it as an error.
1085 CurPtr = TokStart + 3;
1086 return lltok::Error;
1087 }
1088 APInt Tmp(Bits, HexStr, 16);
1089 uint32_t ActiveBits = Tmp.getActiveBits();
1090 if (!IsFloatConst && ActiveBits > 0 && ActiveBits < Bits)
1091 Tmp = Tmp.trunc(width: ActiveBits);
1092 APSIntVal = APSInt(Tmp, TokStart[0] != 's');
1093 return IsFloatConst ? lltok::FloatHexLiteral : lltok::APSInt;
1094 }
1095
1096 // If this is "cc1234", return this as just "cc".
1097 if (TokStart[0] == 'c' && TokStart[1] == 'c') {
1098 CurPtr = TokStart+2;
1099 return lltok::kw_cc;
1100 }
1101
1102 // Finally, if this isn't known, return an error.
1103 CurPtr = TokStart+1;
1104 return lltok::Error;
1105}
1106
1107/// Lex all tokens that start with a 0x prefix, knowing they match and are not
1108/// labels.
1109/// HexFPLiteral [-+]?0x[0-9A-Fa-f]+.[0-9A-Fa-f]*[pP][-+]?[0-9]+
1110/// HexFPConstant 0x[0-9A-Fa-f]+
1111/// HexFP80Constant 0xK[0-9A-Fa-f]+
1112/// HexFP128Constant 0xL[0-9A-Fa-f]+
1113/// HexPPC128Constant 0xM[0-9A-Fa-f]+
1114/// HexHalfConstant 0xH[0-9A-Fa-f]+
1115/// HexBFloatConstant 0xR[0-9A-Fa-f]+
1116lltok::Kind LLLexer::Lex0x() {
1117 CurPtr = TokStart + 2;
1118
1119 char Kind;
1120 if ((CurPtr[0] >= 'K' && CurPtr[0] <= 'M') || CurPtr[0] == 'H' ||
1121 CurPtr[0] == 'R') {
1122 Kind = *CurPtr++;
1123 } else {
1124 Kind = 'J';
1125 }
1126
1127 if (!isxdigit(static_cast<unsigned char>(CurPtr[0]))) {
1128 // Bad token, return it as an error.
1129 CurPtr = TokStart+1;
1130 return lltok::Error;
1131 }
1132
1133 while (isxdigit(static_cast<unsigned char>(CurPtr[0])))
1134 ++CurPtr;
1135
1136 if (*CurPtr == '.') {
1137 // HexFPLiteral, following C's %a syntax
1138 return LexFloatStr();
1139 }
1140
1141 if (Kind == 'J') {
1142 // HexFPConstant - Floating point constant represented in IEEE format as a
1143 // hexadecimal number for when exponential notation is not precise enough.
1144 // Half, BFloat, Float, and double only.
1145 APFloatVal = APFloat(APFloat::IEEEdouble(),
1146 APInt(64, HexIntToVal(Buffer: TokStart + 2, End: CurPtr)));
1147 return lltok::APFloat;
1148 }
1149
1150 uint64_t Pair[2];
1151 switch (Kind) {
1152 default:
1153 llvm_unreachable("Unknown kind!");
1154 case 'K':
1155 // F80HexFPConstant - x87 long double in hexadecimal format (10 bytes)
1156 FP80HexToIntPair(Buffer: TokStart + 3, End: CurPtr, Pair);
1157 APSIntVal = APInt(80, Pair);
1158 return lltok::FloatHexLiteral;
1159 case 'L':
1160 // F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes)
1161 HexToIntPair(Buffer: TokStart + 3, End: CurPtr, Pair);
1162 APSIntVal = APInt(128, Pair);
1163 return lltok::FloatHexLiteral;
1164 case 'M':
1165 // PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes)
1166 HexToIntPair(Buffer: TokStart + 3, End: CurPtr, Pair);
1167 APSIntVal = APInt(128, Pair);
1168 return lltok::FloatHexLiteral;
1169 case 'H': {
1170 uint64_t Val = HexIntToVal(Buffer: TokStart + 3, End: CurPtr);
1171 if (!llvm::isUInt<16>(x: Val)) {
1172 LexError(Msg: "hexadecimal constant too large for half (16-bit)");
1173 return lltok::Error;
1174 }
1175 APSIntVal = APInt(16, Val);
1176 return lltok::FloatHexLiteral;
1177 }
1178 case 'R': {
1179 // Brain floating point
1180 uint64_t Val = HexIntToVal(Buffer: TokStart + 3, End: CurPtr);
1181 if (!llvm::isUInt<16>(x: Val)) {
1182 LexError(Msg: "hexadecimal constant too large for bfloat (16-bit)");
1183 return lltok::Error;
1184 }
1185 APSIntVal = APInt(16, Val);
1186 return lltok::FloatHexLiteral;
1187 }
1188 }
1189}
1190
1191/// Lex tokens for a label or a numeric constant, possibly starting with -.
1192/// Label [-a-zA-Z$._0-9]+:
1193/// NInteger -[0-9]+
1194/// FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
1195/// PInteger [0-9]+
1196/// HexFPLiteral [-+]?0x[0-9A-Fa-f]+.[0-9A-Fa-f]*[pP][-+]?[0-9]+
1197/// HexFPConstant 0x[0-9A-Fa-f]+
1198/// HexFP80Constant 0xK[0-9A-Fa-f]+
1199/// HexFP128Constant 0xL[0-9A-Fa-f]+
1200/// HexPPC128Constant 0xM[0-9A-Fa-f]+
1201lltok::Kind LLLexer::LexDigitOrNegative() {
1202 // If the letter after the negative is not a number, this is probably a label.
1203 if (!isdigit(static_cast<unsigned char>(TokStart[0])) &&
1204 !isdigit(static_cast<unsigned char>(CurPtr[0]))) {
1205 // Okay, this is not a number after the -, it's probably a label.
1206 if (const char *End = isLabelTail(CurPtr)) {
1207 StrVal.assign(first: TokStart, last: End-1);
1208 CurPtr = End;
1209 return lltok::LabelStr;
1210 }
1211
1212 // It might be a -inf, -nan, etc. Check if it's a float string (which will
1213 // also handle error conditions there).
1214 return LexFloatStr();
1215 }
1216
1217 // At this point, it is either a label, int or fp constant.
1218
1219 // Skip digits, we have at least one.
1220 for (; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
1221 /*empty*/;
1222
1223 // Check if this is a fully-numeric label:
1224 if (isdigit(TokStart[0]) && CurPtr[0] == ':') {
1225 uint64_t Val = atoull(Buffer: TokStart, End: CurPtr);
1226 ++CurPtr; // Skip the colon.
1227 if ((unsigned)Val != Val)
1228 LexError(Msg: "invalid value number (too large)");
1229 UIntVal = unsigned(Val);
1230 return lltok::LabelID;
1231 }
1232
1233 // Check to see if this really is a string label, e.g. "-1:".
1234 if (isLabelChar(C: CurPtr[0]) || CurPtr[0] == ':') {
1235 if (const char *End = isLabelTail(CurPtr)) {
1236 StrVal.assign(first: TokStart, last: End-1);
1237 CurPtr = End;
1238 return lltok::LabelStr;
1239 }
1240 }
1241
1242 // If the next character is a '.', then it is a fp value, otherwise its
1243 // integer.
1244 if (CurPtr[0] != '.') {
1245 if (TokStart[0] == '0' && TokStart[1] == 'x')
1246 return Lex0x();
1247 if (TokStart[0] == '-' && TokStart[1] == '0' && TokStart[2] == 'x')
1248 return LexFloatStr();
1249
1250 APSIntVal = APSInt(StringRef(TokStart, CurPtr - TokStart));
1251 return lltok::APSInt;
1252 }
1253
1254 ++CurPtr;
1255
1256 // Skip over [0-9]*([eE][-+]?[0-9]+)?
1257 while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
1258
1259 if (CurPtr[0] == 'e' || CurPtr[0] == 'E') {
1260 if (isdigit(static_cast<unsigned char>(CurPtr[1])) ||
1261 ((CurPtr[1] == '-' || CurPtr[1] == '+') &&
1262 isdigit(static_cast<unsigned char>(CurPtr[2])))) {
1263 CurPtr += 2;
1264 while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
1265 }
1266 }
1267
1268 StrVal.assign(s: TokStart, n: CurPtr - TokStart);
1269 return lltok::FloatLiteral;
1270}
1271
1272/// Lex a floating point constant starting with +.
1273/// FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
1274/// HexFPLiteral [-+]?0x[0-9A-Fa-f]+.[0-9A-Fa-f]*[pP][-+]?[0-9]+
1275/// HexFPSpecial [-+](inf|qnan|s?nan\(0x[0-9A-Fa-f]+\))
1276lltok::Kind LLLexer::LexPositive() {
1277 // If it's not numeric, check for special floating-point values.
1278 if (!isdigit(static_cast<unsigned char>(CurPtr[0])))
1279 return LexFloatStr();
1280
1281 // Skip digits.
1282 for (++CurPtr; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
1283 /*empty*/;
1284
1285 // If the first non-digit is an x, check if it's a hex FP literal. LexFloatStr
1286 // will reanalyze TokStr..CurPtr to make sure that it's 0x and not 413x.
1287 if (CurPtr[0] == 'x')
1288 return LexFloatStr();
1289
1290 // At this point, we need a '.'.
1291 if (CurPtr[0] != '.') {
1292 CurPtr = TokStart + 1;
1293 return lltok::Error;
1294 }
1295
1296 ++CurPtr;
1297
1298 // Skip over [0-9]*([eE][-+]?[0-9]+)?
1299 while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
1300
1301 if (CurPtr[0] == 'e' || CurPtr[0] == 'E') {
1302 if (isdigit(static_cast<unsigned char>(CurPtr[1])) ||
1303 ((CurPtr[1] == '-' || CurPtr[1] == '+') &&
1304 isdigit(static_cast<unsigned char>(CurPtr[2])))) {
1305 CurPtr += 2;
1306 while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
1307 }
1308 }
1309
1310 StrVal.assign(s: TokStart, n: CurPtr - TokStart);
1311 return lltok::FloatLiteral;
1312}
1313
1314/// Lex all tokens that start with a + or - that could be a float literal.
1315/// HexFPLiteral [-+]?0x[0-9A-Fa-f]+.[0-9A-Fa-f]*[pP][-+]?[0-9]+
1316/// HexFPSpecial [-+](inf|qnan|s?nan\(0x[0-9A-Fa-f]+\))
1317lltok::Kind LLLexer::LexFloatStr() {
1318 // At the point we enter this function, we may have seen a few characters
1319 // already, but how many differs based on the entry point. Rewind to the
1320 // beginning just in case.
1321 CurPtr = TokStart;
1322
1323 // Check for optional sign.
1324 if (*CurPtr == '-' || *CurPtr == '+')
1325 ++CurPtr;
1326
1327 if (*CurPtr != '0') {
1328 // Check for keywords.
1329 const char *LabelStart = CurPtr;
1330 while (isLabelChar(C: *CurPtr))
1331 ++CurPtr;
1332 StringRef Label(LabelStart, CurPtr - LabelStart);
1333
1334 // Basic special values.
1335 if (Label == "inf") {
1336 // Copy from the beginning, to include the sign.
1337 StrVal.assign(s: TokStart, n: CurPtr - TokStart);
1338 return lltok::FloatLiteral;
1339 }
1340
1341 // APFloat::convertFromString doesn't support qnan, so translate it to a
1342 // nan payload string it does support.
1343 if (Label == "qnan") {
1344 StrVal = *TokStart == '-' ? "-nan(0)" : "nan(0)";
1345 return lltok::FloatLiteral;
1346 }
1347
1348 // NaN with payload.
1349 if ((Label == "nan" || Label == "snan") && *CurPtr == '(') {
1350 const char *Payload = ++CurPtr;
1351 while (*CurPtr && *CurPtr != ')')
1352 ++CurPtr;
1353
1354 // If no close parenthesis, it's a bad token, return it as an error.
1355 if (*CurPtr++ != ')') {
1356 CurPtr = TokStart + 1;
1357 LexError(Msg: "unclosed nan literal");
1358 return lltok::Error;
1359 }
1360
1361 StringRef PayloadStr(Payload, CurPtr - Payload);
1362 APInt Val;
1363 if (PayloadStr.consume_front(Prefix: "0x") && PayloadStr.getAsInteger(Radix: 16, Result&: Val)) {
1364 StrVal.assign(s: TokStart, n: CurPtr - TokStart);
1365 // Drop the leading + from the string, as APFloat::convertFromString
1366 // doesn't support leading + sign.
1367 if (StrVal[0] == '+')
1368 StrVal.erase(pos: 0, n: 1);
1369 return lltok::FloatLiteral;
1370 }
1371 }
1372
1373 // Bad token, return it as an error.
1374 LexError(Msg: "bad payload format for nan literal");
1375 CurPtr = TokStart + 1;
1376 return lltok::Error;
1377 }
1378 ++CurPtr;
1379
1380 if (*CurPtr++ != 'x') {
1381 // Bad token, return it as an error.
1382 CurPtr = TokStart + 1;
1383 return lltok::Error;
1384 }
1385
1386 if (!isxdigit(static_cast<unsigned char>(CurPtr[0]))) {
1387 // Bad token, return it as an error.
1388 CurPtr = TokStart + 1;
1389 return lltok::Error;
1390 }
1391
1392 while (isxdigit(static_cast<unsigned char>(CurPtr[0])))
1393 ++CurPtr;
1394
1395 if (*CurPtr != '.') {
1396 // Bad token, return it as an error.
1397 CurPtr = TokStart + 1;
1398 return lltok::Error;
1399 }
1400
1401 ++CurPtr; // Eat the .
1402 while (isxdigit(static_cast<unsigned char>(CurPtr[0])))
1403 ++CurPtr;
1404
1405 if (*CurPtr != 'p' && *CurPtr != 'P') {
1406 // Bad token, return it as an error.
1407 CurPtr = TokStart + 1;
1408 return lltok::Error;
1409 }
1410
1411 ++CurPtr;
1412 if (*CurPtr == '+' || *CurPtr == '-')
1413 ++CurPtr;
1414 while (isdigit(static_cast<unsigned char>(CurPtr[0])))
1415 ++CurPtr;
1416
1417 StrVal.assign(s: TokStart, n: CurPtr - TokStart);
1418 return lltok::FloatLiteral;
1419}
1420