LLVM  10.0.0svn
LLLexer.cpp
Go to the documentation of this file.
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 "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"
21 #include "llvm/Support/SourceMgr.h"
22 #include <cassert>
23 #include <cctype>
24 #include <cstdio>
25 
26 using namespace llvm;
27 
28 bool LLLexer::Error(LocTy ErrorLoc, const Twine &Msg) const {
29  ErrorInfo = SM.GetMessage(ErrorLoc, SourceMgr::DK_Error, Msg);
30  return true;
31 }
32 
33 void LLLexer::Warning(LocTy WarningLoc, const Twine &Msg) const {
34  SM.PrintMessage(WarningLoc, SourceMgr::DK_Warning, Msg);
35 }
36 
37 //===----------------------------------------------------------------------===//
38 // Helper functions.
39 //===----------------------------------------------------------------------===//
40 
41 // atoull - Convert an ascii string of decimal digits into the unsigned long
42 // long representation... this does not have to do input error checking,
43 // because we know that the input will be matched by a suitable regex...
44 //
45 uint64_t LLLexer::atoull(const char *Buffer, const char *End) {
46  uint64_t Result = 0;
47  for (; Buffer != End; Buffer++) {
48  uint64_t OldRes = Result;
49  Result *= 10;
50  Result += *Buffer-'0';
51  if (Result < OldRes) { // Uh, oh, overflow detected!!!
52  Error("constant bigger than 64 bits detected!");
53  return 0;
54  }
55  }
56  return Result;
57 }
58 
59 uint64_t LLLexer::HexIntToVal(const char *Buffer, const char *End) {
60  uint64_t Result = 0;
61  for (; Buffer != End; ++Buffer) {
62  uint64_t OldRes = Result;
63  Result *= 16;
64  Result += hexDigitValue(*Buffer);
65 
66  if (Result < OldRes) { // Uh, oh, overflow detected!!!
67  Error("constant bigger than 64 bits detected!");
68  return 0;
69  }
70  }
71  return Result;
72 }
73 
74 void LLLexer::HexToIntPair(const char *Buffer, const char *End,
75  uint64_t Pair[2]) {
76  Pair[0] = 0;
77  if (End - Buffer >= 16) {
78  for (int i = 0; i < 16; i++, Buffer++) {
79  assert(Buffer != End);
80  Pair[0] *= 16;
81  Pair[0] += hexDigitValue(*Buffer);
82  }
83  }
84  Pair[1] = 0;
85  for (int i = 0; i < 16 && Buffer != End; i++, Buffer++) {
86  Pair[1] *= 16;
87  Pair[1] += hexDigitValue(*Buffer);
88  }
89  if (Buffer != End)
90  Error("constant bigger than 128 bits detected!");
91 }
92 
93 /// FP80HexToIntPair - translate an 80 bit FP80 number (20 hexits) into
94 /// { low64, high16 } as usual for an APInt.
95 void LLLexer::FP80HexToIntPair(const char *Buffer, const char *End,
96  uint64_t Pair[2]) {
97  Pair[1] = 0;
98  for (int i=0; i<4 && Buffer != End; i++, Buffer++) {
99  assert(Buffer != End);
100  Pair[1] *= 16;
101  Pair[1] += hexDigitValue(*Buffer);
102  }
103  Pair[0] = 0;
104  for (int i = 0; i < 16 && Buffer != End; i++, Buffer++) {
105  Pair[0] *= 16;
106  Pair[0] += hexDigitValue(*Buffer);
107  }
108  if (Buffer != End)
109  Error("constant bigger than 128 bits detected!");
110 }
111 
112 // UnEscapeLexed - Run through the specified buffer and change \xx codes to the
113 // appropriate character.
114 static void UnEscapeLexed(std::string &Str) {
115  if (Str.empty()) return;
116 
117  char *Buffer = &Str[0], *EndBuffer = Buffer+Str.size();
118  char *BOut = Buffer;
119  for (char *BIn = Buffer; BIn != EndBuffer; ) {
120  if (BIn[0] == '\\') {
121  if (BIn < EndBuffer-1 && BIn[1] == '\\') {
122  *BOut++ = '\\'; // Two \ becomes one
123  BIn += 2;
124  } else if (BIn < EndBuffer-2 &&
125  isxdigit(static_cast<unsigned char>(BIn[1])) &&
126  isxdigit(static_cast<unsigned char>(BIn[2]))) {
127  *BOut = hexDigitValue(BIn[1]) * 16 + hexDigitValue(BIn[2]);
128  BIn += 3; // Skip over handled chars
129  ++BOut;
130  } else {
131  *BOut++ = *BIn++;
132  }
133  } else {
134  *BOut++ = *BIn++;
135  }
136  }
137  Str.resize(BOut-Buffer);
138 }
139 
140 /// isLabelChar - Return true for [-a-zA-Z$._0-9].
141 static bool isLabelChar(char C) {
142  return isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' ||
143  C == '.' || C == '_';
144 }
145 
146 /// isLabelTail - Return true if this pointer points to a valid end of a label.
147 static const char *isLabelTail(const char *CurPtr) {
148  while (true) {
149  if (CurPtr[0] == ':') return CurPtr+1;
150  if (!isLabelChar(CurPtr[0])) return nullptr;
151  ++CurPtr;
152  }
153 }
154 
155 //===----------------------------------------------------------------------===//
156 // Lexer definition.
157 //===----------------------------------------------------------------------===//
158 
160  LLVMContext &C)
161  : CurBuf(StartBuf), ErrorInfo(Err), SM(SM), Context(C), APFloatVal(0.0),
162  IgnoreColonInIdentifiers(false) {
163  CurPtr = CurBuf.begin();
164 }
165 
166 int LLLexer::getNextChar() {
167  char CurChar = *CurPtr++;
168  switch (CurChar) {
169  default: return (unsigned char)CurChar;
170  case 0:
171  // A nul character in the stream is either the end of the current buffer or
172  // a random nul in the file. Disambiguate that here.
173  if (CurPtr-1 != CurBuf.end())
174  return 0; // Just whitespace.
175 
176  // Otherwise, return end of file.
177  --CurPtr; // Another call to lex will return EOF again.
178  return EOF;
179  }
180 }
181 
182 lltok::Kind LLLexer::LexToken() {
183  while (true) {
184  TokStart = CurPtr;
185 
186  int CurChar = getNextChar();
187  switch (CurChar) {
188  default:
189  // Handle letters: [a-zA-Z_]
190  if (isalpha(static_cast<unsigned char>(CurChar)) || CurChar == '_')
191  return LexIdentifier();
192 
193  return lltok::Error;
194  case EOF: return lltok::Eof;
195  case 0:
196  case ' ':
197  case '\t':
198  case '\n':
199  case '\r':
200  // Ignore whitespace.
201  continue;
202  case '+': return LexPositive();
203  case '@': return LexAt();
204  case '$': return LexDollar();
205  case '%': return LexPercent();
206  case '"': return LexQuote();
207  case '.':
208  if (const char *Ptr = isLabelTail(CurPtr)) {
209  CurPtr = Ptr;
210  StrVal.assign(TokStart, CurPtr-1);
211  return lltok::LabelStr;
212  }
213  if (CurPtr[0] == '.' && CurPtr[1] == '.') {
214  CurPtr += 2;
215  return lltok::dotdotdot;
216  }
217  return lltok::Error;
218  case ';':
219  SkipLineComment();
220  continue;
221  case '!': return LexExclaim();
222  case '^':
223  return LexCaret();
224  case ':':
225  return lltok::colon;
226  case '#': return LexHash();
227  case '0': case '1': case '2': case '3': case '4':
228  case '5': case '6': case '7': case '8': case '9':
229  case '-':
230  return LexDigitOrNegative();
231  case '=': return lltok::equal;
232  case '[': return lltok::lsquare;
233  case ']': return lltok::rsquare;
234  case '{': return lltok::lbrace;
235  case '}': return lltok::rbrace;
236  case '<': return lltok::less;
237  case '>': return lltok::greater;
238  case '(': return lltok::lparen;
239  case ')': return lltok::rparen;
240  case ',': return lltok::comma;
241  case '*': return lltok::star;
242  case '|': return lltok::bar;
243  }
244  }
245 }
246 
247 void LLLexer::SkipLineComment() {
248  while (true) {
249  if (CurPtr[0] == '\n' || CurPtr[0] == '\r' || getNextChar() == EOF)
250  return;
251  }
252 }
253 
254 /// Lex all tokens that start with an @ character.
255 /// GlobalVar @\"[^\"]*\"
256 /// GlobalVar @[-a-zA-Z$._][-a-zA-Z$._0-9]*
257 /// GlobalVarID @[0-9]+
258 lltok::Kind LLLexer::LexAt() {
259  return LexVar(lltok::GlobalVar, lltok::GlobalID);
260 }
261 
262 lltok::Kind LLLexer::LexDollar() {
263  if (const char *Ptr = isLabelTail(TokStart)) {
264  CurPtr = Ptr;
265  StrVal.assign(TokStart, CurPtr - 1);
266  return lltok::LabelStr;
267  }
268 
269  // Handle DollarStringConstant: $\"[^\"]*\"
270  if (CurPtr[0] == '"') {
271  ++CurPtr;
272 
273  while (true) {
274  int CurChar = getNextChar();
275 
276  if (CurChar == EOF) {
277  Error("end of file in COMDAT variable name");
278  return lltok::Error;
279  }
280  if (CurChar == '"') {
281  StrVal.assign(TokStart + 2, CurPtr - 1);
282  UnEscapeLexed(StrVal);
283  if (StringRef(StrVal).find_first_of(0) != StringRef::npos) {
284  Error("Null bytes are not allowed in names");
285  return lltok::Error;
286  }
287  return lltok::ComdatVar;
288  }
289  }
290  }
291 
292  // Handle ComdatVarName: $[-a-zA-Z$._][-a-zA-Z$._0-9]*
293  if (ReadVarName())
294  return lltok::ComdatVar;
295 
296  return lltok::Error;
297 }
298 
299 /// ReadString - Read a string until the closing quote.
300 lltok::Kind LLLexer::ReadString(lltok::Kind kind) {
301  const char *Start = CurPtr;
302  while (true) {
303  int CurChar = getNextChar();
304 
305  if (CurChar == EOF) {
306  Error("end of file in string constant");
307  return lltok::Error;
308  }
309  if (CurChar == '"') {
310  StrVal.assign(Start, CurPtr-1);
311  UnEscapeLexed(StrVal);
312  return kind;
313  }
314  }
315 }
316 
317 /// ReadVarName - Read the rest of a token containing a variable name.
318 bool LLLexer::ReadVarName() {
319  const char *NameStart = CurPtr;
320  if (isalpha(static_cast<unsigned char>(CurPtr[0])) ||
321  CurPtr[0] == '-' || CurPtr[0] == '$' ||
322  CurPtr[0] == '.' || CurPtr[0] == '_') {
323  ++CurPtr;
324  while (isalnum(static_cast<unsigned char>(CurPtr[0])) ||
325  CurPtr[0] == '-' || CurPtr[0] == '$' ||
326  CurPtr[0] == '.' || CurPtr[0] == '_')
327  ++CurPtr;
328 
329  StrVal.assign(NameStart, CurPtr);
330  return true;
331  }
332  return false;
333 }
334 
335 // Lex an ID: [0-9]+. On success, the ID is stored in UIntVal and Token is
336 // returned, otherwise the Error token is returned.
337 lltok::Kind LLLexer::LexUIntID(lltok::Kind Token) {
338  if (!isdigit(static_cast<unsigned char>(CurPtr[0])))
339  return lltok::Error;
340 
341  for (++CurPtr; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
342  /*empty*/;
343 
344  uint64_t Val = atoull(TokStart + 1, CurPtr);
345  if ((unsigned)Val != Val)
346  Error("invalid value number (too large)!");
347  UIntVal = unsigned(Val);
348  return Token;
349 }
350 
351 lltok::Kind LLLexer::LexVar(lltok::Kind Var, lltok::Kind VarID) {
352  // Handle StringConstant: \"[^\"]*\"
353  if (CurPtr[0] == '"') {
354  ++CurPtr;
355 
356  while (true) {
357  int CurChar = getNextChar();
358 
359  if (CurChar == EOF) {
360  Error("end of file in global variable name");
361  return lltok::Error;
362  }
363  if (CurChar == '"') {
364  StrVal.assign(TokStart+2, CurPtr-1);
365  UnEscapeLexed(StrVal);
366  if (StringRef(StrVal).find_first_of(0) != StringRef::npos) {
367  Error("Null bytes are not allowed in names");
368  return lltok::Error;
369  }
370  return Var;
371  }
372  }
373  }
374 
375  // Handle VarName: [-a-zA-Z$._][-a-zA-Z$._0-9]*
376  if (ReadVarName())
377  return Var;
378 
379  // Handle VarID: [0-9]+
380  return LexUIntID(VarID);
381 }
382 
383 /// Lex all tokens that start with a % character.
384 /// LocalVar ::= %\"[^\"]*\"
385 /// LocalVar ::= %[-a-zA-Z$._][-a-zA-Z$._0-9]*
386 /// LocalVarID ::= %[0-9]+
387 lltok::Kind LLLexer::LexPercent() {
388  return LexVar(lltok::LocalVar, lltok::LocalVarID);
389 }
390 
391 /// Lex all tokens that start with a " character.
392 /// QuoteLabel "[^"]+":
393 /// StringConstant "[^"]*"
394 lltok::Kind LLLexer::LexQuote() {
395  lltok::Kind kind = ReadString(lltok::StringConstant);
396  if (kind == lltok::Error || kind == lltok::Eof)
397  return kind;
398 
399  if (CurPtr[0] == ':') {
400  ++CurPtr;
401  if (StringRef(StrVal).find_first_of(0) != StringRef::npos) {
402  Error("Null bytes are not allowed in names");
403  kind = lltok::Error;
404  } else {
405  kind = lltok::LabelStr;
406  }
407  }
408 
409  return kind;
410 }
411 
412 /// Lex all tokens that start with a ! character.
413 /// !foo
414 /// !
415 lltok::Kind LLLexer::LexExclaim() {
416  // Lex a metadata name as a MetadataVar.
417  if (isalpha(static_cast<unsigned char>(CurPtr[0])) ||
418  CurPtr[0] == '-' || CurPtr[0] == '$' ||
419  CurPtr[0] == '.' || CurPtr[0] == '_' || CurPtr[0] == '\\') {
420  ++CurPtr;
421  while (isalnum(static_cast<unsigned char>(CurPtr[0])) ||
422  CurPtr[0] == '-' || CurPtr[0] == '$' ||
423  CurPtr[0] == '.' || CurPtr[0] == '_' || CurPtr[0] == '\\')
424  ++CurPtr;
425 
426  StrVal.assign(TokStart+1, CurPtr); // Skip !
427  UnEscapeLexed(StrVal);
428  return lltok::MetadataVar;
429  }
430  return lltok::exclaim;
431 }
432 
433 /// Lex all tokens that start with a ^ character.
434 /// SummaryID ::= ^[0-9]+
435 lltok::Kind LLLexer::LexCaret() {
436  // Handle SummaryID: ^[0-9]+
437  return LexUIntID(lltok::SummaryID);
438 }
439 
440 /// Lex all tokens that start with a # character.
441 /// AttrGrpID ::= #[0-9]+
442 lltok::Kind LLLexer::LexHash() {
443  // Handle AttrGrpID: #[0-9]+
444  return LexUIntID(lltok::AttrGrpID);
445 }
446 
447 /// Lex a label, integer type, keyword, or hexadecimal integer constant.
448 /// Label [-a-zA-Z$._0-9]+:
449 /// IntegerType i[0-9]+
450 /// Keyword sdiv, float, ...
451 /// HexIntConstant [us]0x[0-9A-Fa-f]+
452 lltok::Kind LLLexer::LexIdentifier() {
453  const char *StartChar = CurPtr;
454  const char *IntEnd = CurPtr[-1] == 'i' ? nullptr : StartChar;
455  const char *KeywordEnd = nullptr;
456 
457  for (; isLabelChar(*CurPtr); ++CurPtr) {
458  // If we decide this is an integer, remember the end of the sequence.
459  if (!IntEnd && !isdigit(static_cast<unsigned char>(*CurPtr)))
460  IntEnd = CurPtr;
461  if (!KeywordEnd && !isalnum(static_cast<unsigned char>(*CurPtr)) &&
462  *CurPtr != '_')
463  KeywordEnd = CurPtr;
464  }
465 
466  // If we stopped due to a colon, unless we were directed to ignore it,
467  // this really is a label.
468  if (!IgnoreColonInIdentifiers && *CurPtr == ':') {
469  StrVal.assign(StartChar-1, CurPtr++);
470  return lltok::LabelStr;
471  }
472 
473  // Otherwise, this wasn't a label. If this was valid as an integer type,
474  // return it.
475  if (!IntEnd) IntEnd = CurPtr;
476  if (IntEnd != StartChar) {
477  CurPtr = IntEnd;
478  uint64_t NumBits = atoull(StartChar, CurPtr);
479  if (NumBits < IntegerType::MIN_INT_BITS ||
480  NumBits > IntegerType::MAX_INT_BITS) {
481  Error("bitwidth for integer type out of range!");
482  return lltok::Error;
483  }
484  TyVal = IntegerType::get(Context, NumBits);
485  return lltok::Type;
486  }
487 
488  // Otherwise, this was a letter sequence. See which keyword this is.
489  if (!KeywordEnd) KeywordEnd = CurPtr;
490  CurPtr = KeywordEnd;
491  --StartChar;
492  StringRef Keyword(StartChar, CurPtr - StartChar);
493 
494 #define KEYWORD(STR) \
495  do { \
496  if (Keyword == #STR) \
497  return lltok::kw_##STR; \
498  } while (false)
499 
500  KEYWORD(true); KEYWORD(false);
501  KEYWORD(declare); KEYWORD(define);
502  KEYWORD(global); KEYWORD(constant);
503 
504  KEYWORD(dso_local);
505  KEYWORD(dso_preemptable);
506 
507  KEYWORD(private);
508  KEYWORD(internal);
509  KEYWORD(available_externally);
510  KEYWORD(linkonce);
511  KEYWORD(linkonce_odr);
512  KEYWORD(weak); // Use as a linkage, and a modifier for "cmpxchg".
513  KEYWORD(weak_odr);
514  KEYWORD(appending);
515  KEYWORD(dllimport);
516  KEYWORD(dllexport);
517  KEYWORD(common);
518  KEYWORD(default);
519  KEYWORD(hidden);
520  KEYWORD(protected);
521  KEYWORD(unnamed_addr);
522  KEYWORD(local_unnamed_addr);
523  KEYWORD(externally_initialized);
524  KEYWORD(extern_weak);
525  KEYWORD(external);
526  KEYWORD(thread_local);
527  KEYWORD(localdynamic);
528  KEYWORD(initialexec);
529  KEYWORD(localexec);
530  KEYWORD(zeroinitializer);
531  KEYWORD(undef);
532  KEYWORD(null);
533  KEYWORD(none);
534  KEYWORD(to);
535  KEYWORD(caller);
536  KEYWORD(within);
537  KEYWORD(from);
538  KEYWORD(tail);
539  KEYWORD(musttail);
540  KEYWORD(notail);
541  KEYWORD(target);
542  KEYWORD(triple);
543  KEYWORD(source_filename);
544  KEYWORD(unwind);
545  KEYWORD(deplibs); // FIXME: Remove in 4.0.
546  KEYWORD(datalayout);
547  KEYWORD(volatile);
548  KEYWORD(atomic);
549  KEYWORD(unordered);
550  KEYWORD(monotonic);
551  KEYWORD(acquire);
552  KEYWORD(release);
553  KEYWORD(acq_rel);
554  KEYWORD(seq_cst);
555  KEYWORD(syncscope);
556 
557  KEYWORD(nnan);
558  KEYWORD(ninf);
559  KEYWORD(nsz);
560  KEYWORD(arcp);
561  KEYWORD(contract);
562  KEYWORD(reassoc);
563  KEYWORD(afn);
564  KEYWORD(fast);
565  KEYWORD(nuw);
566  KEYWORD(nsw);
567  KEYWORD(exact);
568  KEYWORD(inbounds);
569  KEYWORD(inrange);
570  KEYWORD(align);
571  KEYWORD(addrspace);
572  KEYWORD(section);
574  KEYWORD(alias);
575  KEYWORD(ifunc);
576  KEYWORD(module);
577  KEYWORD(asm);
578  KEYWORD(sideeffect);
579  KEYWORD(alignstack);
580  KEYWORD(inteldialect);
581  KEYWORD(gc);
582  KEYWORD(prefix);
583  KEYWORD(prologue);
584 
585  KEYWORD(ccc);
586  KEYWORD(fastcc);
587  KEYWORD(coldcc);
588  KEYWORD(x86_stdcallcc);
589  KEYWORD(x86_fastcallcc);
590  KEYWORD(x86_thiscallcc);
591  KEYWORD(x86_vectorcallcc);
592  KEYWORD(arm_apcscc);
593  KEYWORD(arm_aapcscc);
594  KEYWORD(arm_aapcs_vfpcc);
595  KEYWORD(aarch64_vector_pcs);
596  KEYWORD(msp430_intrcc);
597  KEYWORD(avr_intrcc);
598  KEYWORD(avr_signalcc);
599  KEYWORD(ptx_kernel);
600  KEYWORD(ptx_device);
601  KEYWORD(spir_kernel);
602  KEYWORD(spir_func);
603  KEYWORD(intel_ocl_bicc);
604  KEYWORD(x86_64_sysvcc);
605  KEYWORD(win64cc);
606  KEYWORD(x86_regcallcc);
607  KEYWORD(webkit_jscc);
608  KEYWORD(swiftcc);
609  KEYWORD(anyregcc);
610  KEYWORD(preserve_mostcc);
611  KEYWORD(preserve_allcc);
612  KEYWORD(ghccc);
613  KEYWORD(x86_intrcc);
614  KEYWORD(hhvmcc);
615  KEYWORD(hhvm_ccc);
616  KEYWORD(cxx_fast_tlscc);
617  KEYWORD(amdgpu_vs);
618  KEYWORD(amdgpu_ls);
619  KEYWORD(amdgpu_hs);
620  KEYWORD(amdgpu_es);
621  KEYWORD(amdgpu_gs);
622  KEYWORD(amdgpu_ps);
623  KEYWORD(amdgpu_cs);
624  KEYWORD(amdgpu_kernel);
625 
626  KEYWORD(cc);
627  KEYWORD(c);
628 
630 
631  KEYWORD(alwaysinline);
632  KEYWORD(allocsize);
633  KEYWORD(argmemonly);
634  KEYWORD(builtin);
635  KEYWORD(byval);
636  KEYWORD(inalloca);
637  KEYWORD(cold);
638  KEYWORD(convergent);
639  KEYWORD(dereferenceable);
640  KEYWORD(dereferenceable_or_null);
641  KEYWORD(inaccessiblememonly);
642  KEYWORD(inaccessiblemem_or_argmemonly);
643  KEYWORD(inlinehint);
644  KEYWORD(inreg);
645  KEYWORD(jumptable);
646  KEYWORD(minsize);
647  KEYWORD(naked);
648  KEYWORD(nest);
649  KEYWORD(noalias);
650  KEYWORD(nobuiltin);
651  KEYWORD(nocapture);
652  KEYWORD(noduplicate);
653  KEYWORD(nofree);
654  KEYWORD(noimplicitfloat);
655  KEYWORD(noinline);
656  KEYWORD(norecurse);
657  KEYWORD(nonlazybind);
658  KEYWORD(nonnull);
659  KEYWORD(noredzone);
660  KEYWORD(noreturn);
661  KEYWORD(nosync);
662  KEYWORD(nocf_check);
663  KEYWORD(nounwind);
664  KEYWORD(optforfuzzing);
665  KEYWORD(optnone);
666  KEYWORD(optsize);
667  KEYWORD(readnone);
668  KEYWORD(readonly);
669  KEYWORD(returned);
670  KEYWORD(returns_twice);
671  KEYWORD(signext);
672  KEYWORD(speculatable);
673  KEYWORD(sret);
674  KEYWORD(ssp);
675  KEYWORD(sspreq);
676  KEYWORD(sspstrong);
677  KEYWORD(strictfp);
678  KEYWORD(safestack);
679  KEYWORD(shadowcallstack);
680  KEYWORD(sanitize_address);
681  KEYWORD(sanitize_hwaddress);
682  KEYWORD(sanitize_memtag);
683  KEYWORD(sanitize_thread);
684  KEYWORD(sanitize_memory);
685  KEYWORD(speculative_load_hardening);
686  KEYWORD(swifterror);
687  KEYWORD(swiftself);
688  KEYWORD(uwtable);
689  KEYWORD(willreturn);
690  KEYWORD(writeonly);
691  KEYWORD(zeroext);
692  KEYWORD(immarg);
693 
694  KEYWORD(type);
695  KEYWORD(opaque);
696 
697  KEYWORD(comdat);
698 
699  // Comdat types
700  KEYWORD(any);
701  KEYWORD(exactmatch);
702  KEYWORD(largest);
703  KEYWORD(noduplicates);
704  KEYWORD(samesize);
705 
706  KEYWORD(eq); KEYWORD(ne); KEYWORD(slt); KEYWORD(sgt); KEYWORD(sle);
707  KEYWORD(sge); KEYWORD(ult); KEYWORD(ugt); KEYWORD(ule); KEYWORD(uge);
708  KEYWORD(oeq); KEYWORD(one); KEYWORD(olt); KEYWORD(ogt); KEYWORD(ole);
709  KEYWORD(oge); KEYWORD(ord); KEYWORD(uno); KEYWORD(ueq); KEYWORD(une);
710 
711  KEYWORD(xchg); KEYWORD(nand); KEYWORD(max); KEYWORD(min); KEYWORD(umax);
712  KEYWORD(umin);
713 
714  KEYWORD(vscale);
715  KEYWORD(x);
716  KEYWORD(blockaddress);
717 
718  // Metadata types.
719  KEYWORD(distinct);
720 
721  // Use-list order directives.
722  KEYWORD(uselistorder);
723  KEYWORD(uselistorder_bb);
724 
725  KEYWORD(personality);
726  KEYWORD(cleanup);
727  KEYWORD(catch);
728  KEYWORD(filter);
729 
730  // Summary index keywords.
731  KEYWORD(path);
732  KEYWORD(hash);
733  KEYWORD(gv);
734  KEYWORD(guid);
735  KEYWORD(name);
736  KEYWORD(summaries);
737  KEYWORD(flags);
738  KEYWORD(linkage);
739  KEYWORD(notEligibleToImport);
740  KEYWORD(live);
741  KEYWORD(dsoLocal);
742  KEYWORD(canAutoHide);
743  KEYWORD(function);
744  KEYWORD(insts);
745  KEYWORD(funcFlags);
746  KEYWORD(readNone);
747  KEYWORD(readOnly);
748  KEYWORD(noRecurse);
749  KEYWORD(returnDoesNotAlias);
750  KEYWORD(noInline);
751  KEYWORD(calls);
752  KEYWORD(callee);
753  KEYWORD(hotness);
754  KEYWORD(unknown);
755  KEYWORD(hot);
756  KEYWORD(critical);
757  KEYWORD(relbf);
758  KEYWORD(variable);
759  KEYWORD(vTableFuncs);
760  KEYWORD(virtFunc);
761  KEYWORD(aliasee);
762  KEYWORD(refs);
763  KEYWORD(typeIdInfo);
764  KEYWORD(typeTests);
765  KEYWORD(typeTestAssumeVCalls);
766  KEYWORD(typeCheckedLoadVCalls);
767  KEYWORD(typeTestAssumeConstVCalls);
768  KEYWORD(typeCheckedLoadConstVCalls);
769  KEYWORD(vFuncId);
770  KEYWORD(offset);
771  KEYWORD(args);
772  KEYWORD(typeid);
773  KEYWORD(typeidCompatibleVTable);
774  KEYWORD(summary);
775  KEYWORD(typeTestRes);
776  KEYWORD(kind);
777  KEYWORD(unsat);
778  KEYWORD(byteArray);
779  KEYWORD(inline);
780  KEYWORD(single);
781  KEYWORD(allOnes);
782  KEYWORD(sizeM1BitWidth);
783  KEYWORD(alignLog2);
784  KEYWORD(sizeM1);
785  KEYWORD(bitMask);
786  KEYWORD(inlineBits);
787  KEYWORD(wpdResolutions);
788  KEYWORD(wpdRes);
789  KEYWORD(indir);
790  KEYWORD(singleImpl);
791  KEYWORD(branchFunnel);
792  KEYWORD(singleImplName);
793  KEYWORD(resByArg);
794  KEYWORD(byArg);
795  KEYWORD(uniformRetVal);
796  KEYWORD(uniqueRetVal);
797  KEYWORD(virtualConstProp);
798  KEYWORD(info);
799  KEYWORD(byte);
800  KEYWORD(bit);
801  KEYWORD(varFlags);
802 
803 #undef KEYWORD
804 
805  // Keywords for types.
806 #define TYPEKEYWORD(STR, LLVMTY) \
807  do { \
808  if (Keyword == STR) { \
809  TyVal = LLVMTY; \
810  return lltok::Type; \
811  } \
812  } while (false)
813 
814  TYPEKEYWORD("void", Type::getVoidTy(Context));
815  TYPEKEYWORD("half", Type::getHalfTy(Context));
816  TYPEKEYWORD("float", Type::getFloatTy(Context));
817  TYPEKEYWORD("double", Type::getDoubleTy(Context));
818  TYPEKEYWORD("x86_fp80", Type::getX86_FP80Ty(Context));
819  TYPEKEYWORD("fp128", Type::getFP128Ty(Context));
820  TYPEKEYWORD("ppc_fp128", Type::getPPC_FP128Ty(Context));
821  TYPEKEYWORD("label", Type::getLabelTy(Context));
822  TYPEKEYWORD("metadata", Type::getMetadataTy(Context));
823  TYPEKEYWORD("x86_mmx", Type::getX86_MMXTy(Context));
824  TYPEKEYWORD("token", Type::getTokenTy(Context));
825 
826 #undef TYPEKEYWORD
827 
828  // Keywords for instructions.
829 #define INSTKEYWORD(STR, Enum) \
830  do { \
831  if (Keyword == #STR) { \
832  UIntVal = Instruction::Enum; \
833  return lltok::kw_##STR; \
834  } \
835  } while (false)
836 
837  INSTKEYWORD(fneg, FNeg);
838 
839  INSTKEYWORD(add, Add); INSTKEYWORD(fadd, FAdd);
840  INSTKEYWORD(sub, Sub); INSTKEYWORD(fsub, FSub);
841  INSTKEYWORD(mul, Mul); INSTKEYWORD(fmul, FMul);
842  INSTKEYWORD(udiv, UDiv); INSTKEYWORD(sdiv, SDiv); INSTKEYWORD(fdiv, FDiv);
843  INSTKEYWORD(urem, URem); INSTKEYWORD(srem, SRem); INSTKEYWORD(frem, FRem);
844  INSTKEYWORD(shl, Shl); INSTKEYWORD(lshr, LShr); INSTKEYWORD(ashr, AShr);
845  INSTKEYWORD(and, And); INSTKEYWORD(or, Or); INSTKEYWORD(xor, Xor);
846  INSTKEYWORD(icmp, ICmp); INSTKEYWORD(fcmp, FCmp);
847 
848  INSTKEYWORD(phi, PHI);
849  INSTKEYWORD(call, Call);
850  INSTKEYWORD(trunc, Trunc);
851  INSTKEYWORD(zext, ZExt);
852  INSTKEYWORD(sext, SExt);
853  INSTKEYWORD(fptrunc, FPTrunc);
854  INSTKEYWORD(fpext, FPExt);
855  INSTKEYWORD(uitofp, UIToFP);
856  INSTKEYWORD(sitofp, SIToFP);
857  INSTKEYWORD(fptoui, FPToUI);
858  INSTKEYWORD(fptosi, FPToSI);
859  INSTKEYWORD(inttoptr, IntToPtr);
860  INSTKEYWORD(ptrtoint, PtrToInt);
861  INSTKEYWORD(bitcast, BitCast);
862  INSTKEYWORD(addrspacecast, AddrSpaceCast);
863  INSTKEYWORD(select, Select);
864  INSTKEYWORD(va_arg, VAArg);
865  INSTKEYWORD(ret, Ret);
866  INSTKEYWORD(br, Br);
867  INSTKEYWORD(switch, Switch);
868  INSTKEYWORD(indirectbr, IndirectBr);
869  INSTKEYWORD(invoke, Invoke);
870  INSTKEYWORD(resume, Resume);
871  INSTKEYWORD(unreachable, Unreachable);
872  INSTKEYWORD(callbr, CallBr);
873 
874  INSTKEYWORD(alloca, Alloca);
875  INSTKEYWORD(load, Load);
876  INSTKEYWORD(store, Store);
877  INSTKEYWORD(cmpxchg, AtomicCmpXchg);
878  INSTKEYWORD(atomicrmw, AtomicRMW);
879  INSTKEYWORD(fence, Fence);
880  INSTKEYWORD(getelementptr, GetElementPtr);
881 
882  INSTKEYWORD(extractelement, ExtractElement);
883  INSTKEYWORD(insertelement, InsertElement);
884  INSTKEYWORD(shufflevector, ShuffleVector);
885  INSTKEYWORD(extractvalue, ExtractValue);
886  INSTKEYWORD(insertvalue, InsertValue);
887  INSTKEYWORD(landingpad, LandingPad);
888  INSTKEYWORD(cleanupret, CleanupRet);
889  INSTKEYWORD(catchret, CatchRet);
890  INSTKEYWORD(catchswitch, CatchSwitch);
891  INSTKEYWORD(catchpad, CatchPad);
892  INSTKEYWORD(cleanuppad, CleanupPad);
893 
894 #undef INSTKEYWORD
895 
896 #define DWKEYWORD(TYPE, TOKEN) \
897  do { \
898  if (Keyword.startswith("DW_" #TYPE "_")) { \
899  StrVal.assign(Keyword.begin(), Keyword.end()); \
900  return lltok::TOKEN; \
901  } \
902  } while (false)
903 
904  DWKEYWORD(TAG, DwarfTag);
906  DWKEYWORD(VIRTUALITY, DwarfVirtuality);
907  DWKEYWORD(LANG, DwarfLang);
908  DWKEYWORD(CC, DwarfCC);
909  DWKEYWORD(OP, DwarfOp);
910  DWKEYWORD(MACINFO, DwarfMacinfo);
911 
912 #undef DWKEYWORD
913 
914  if (Keyword.startswith("DIFlag")) {
915  StrVal.assign(Keyword.begin(), Keyword.end());
916  return lltok::DIFlag;
917  }
918 
919  if (Keyword.startswith("DISPFlag")) {
920  StrVal.assign(Keyword.begin(), Keyword.end());
921  return lltok::DISPFlag;
922  }
923 
924  if (Keyword.startswith("CSK_")) {
925  StrVal.assign(Keyword.begin(), Keyword.end());
926  return lltok::ChecksumKind;
927  }
928 
929  if (Keyword == "NoDebug" || Keyword == "FullDebug" ||
930  Keyword == "LineTablesOnly" || Keyword == "DebugDirectivesOnly") {
931  StrVal.assign(Keyword.begin(), Keyword.end());
932  return lltok::EmissionKind;
933  }
934 
935  if (Keyword == "GNU" || Keyword == "None" || Keyword == "Default") {
936  StrVal.assign(Keyword.begin(), Keyword.end());
937  return lltok::NameTableKind;
938  }
939 
940  // Check for [us]0x[0-9A-Fa-f]+ which are Hexadecimal constant generated by
941  // the CFE to avoid forcing it to deal with 64-bit numbers.
942  if ((TokStart[0] == 'u' || TokStart[0] == 's') &&
943  TokStart[1] == '0' && TokStart[2] == 'x' &&
944  isxdigit(static_cast<unsigned char>(TokStart[3]))) {
945  int len = CurPtr-TokStart-3;
946  uint32_t bits = len * 4;
947  StringRef HexStr(TokStart + 3, len);
948  if (!all_of(HexStr, isxdigit)) {
949  // Bad token, return it as an error.
950  CurPtr = TokStart+3;
951  return lltok::Error;
952  }
953  APInt Tmp(bits, HexStr, 16);
954  uint32_t activeBits = Tmp.getActiveBits();
955  if (activeBits > 0 && activeBits < bits)
956  Tmp = Tmp.trunc(activeBits);
957  APSIntVal = APSInt(Tmp, TokStart[0] == 'u');
958  return lltok::APSInt;
959  }
960 
961  // If this is "cc1234", return this as just "cc".
962  if (TokStart[0] == 'c' && TokStart[1] == 'c') {
963  CurPtr = TokStart+2;
964  return lltok::kw_cc;
965  }
966 
967  // Finally, if this isn't known, return an error.
968  CurPtr = TokStart+1;
969  return lltok::Error;
970 }
971 
972 /// Lex all tokens that start with a 0x prefix, knowing they match and are not
973 /// labels.
974 /// HexFPConstant 0x[0-9A-Fa-f]+
975 /// HexFP80Constant 0xK[0-9A-Fa-f]+
976 /// HexFP128Constant 0xL[0-9A-Fa-f]+
977 /// HexPPC128Constant 0xM[0-9A-Fa-f]+
978 /// HexHalfConstant 0xH[0-9A-Fa-f]+
979 lltok::Kind LLLexer::Lex0x() {
980  CurPtr = TokStart + 2;
981 
982  char Kind;
983  if ((CurPtr[0] >= 'K' && CurPtr[0] <= 'M') || CurPtr[0] == 'H') {
984  Kind = *CurPtr++;
985  } else {
986  Kind = 'J';
987  }
988 
989  if (!isxdigit(static_cast<unsigned char>(CurPtr[0]))) {
990  // Bad token, return it as an error.
991  CurPtr = TokStart+1;
992  return lltok::Error;
993  }
994 
995  while (isxdigit(static_cast<unsigned char>(CurPtr[0])))
996  ++CurPtr;
997 
998  if (Kind == 'J') {
999  // HexFPConstant - Floating point constant represented in IEEE format as a
1000  // hexadecimal number for when exponential notation is not precise enough.
1001  // Half, Float, and double only.
1002  APFloatVal = APFloat(APFloat::IEEEdouble(),
1003  APInt(64, HexIntToVal(TokStart + 2, CurPtr)));
1004  return lltok::APFloat;
1005  }
1006 
1007  uint64_t Pair[2];
1008  switch (Kind) {
1009  default: llvm_unreachable("Unknown kind!");
1010  case 'K':
1011  // F80HexFPConstant - x87 long double in hexadecimal format (10 bytes)
1012  FP80HexToIntPair(TokStart+3, CurPtr, Pair);
1013  APFloatVal = APFloat(APFloat::x87DoubleExtended(), APInt(80, Pair));
1014  return lltok::APFloat;
1015  case 'L':
1016  // F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes)
1017  HexToIntPair(TokStart+3, CurPtr, Pair);
1018  APFloatVal = APFloat(APFloat::IEEEquad(), APInt(128, Pair));
1019  return lltok::APFloat;
1020  case 'M':
1021  // PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes)
1022  HexToIntPair(TokStart+3, CurPtr, Pair);
1023  APFloatVal = APFloat(APFloat::PPCDoubleDouble(), APInt(128, Pair));
1024  return lltok::APFloat;
1025  case 'H':
1026  APFloatVal = APFloat(APFloat::IEEEhalf(),
1027  APInt(16,HexIntToVal(TokStart+3, CurPtr)));
1028  return lltok::APFloat;
1029  }
1030 }
1031 
1032 /// Lex tokens for a label or a numeric constant, possibly starting with -.
1033 /// Label [-a-zA-Z$._0-9]+:
1034 /// NInteger -[0-9]+
1035 /// FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
1036 /// PInteger [0-9]+
1037 /// HexFPConstant 0x[0-9A-Fa-f]+
1038 /// HexFP80Constant 0xK[0-9A-Fa-f]+
1039 /// HexFP128Constant 0xL[0-9A-Fa-f]+
1040 /// HexPPC128Constant 0xM[0-9A-Fa-f]+
1041 lltok::Kind LLLexer::LexDigitOrNegative() {
1042  // If the letter after the negative is not a number, this is probably a label.
1043  if (!isdigit(static_cast<unsigned char>(TokStart[0])) &&
1044  !isdigit(static_cast<unsigned char>(CurPtr[0]))) {
1045  // Okay, this is not a number after the -, it's probably a label.
1046  if (const char *End = isLabelTail(CurPtr)) {
1047  StrVal.assign(TokStart, End-1);
1048  CurPtr = End;
1049  return lltok::LabelStr;
1050  }
1051 
1052  return lltok::Error;
1053  }
1054 
1055  // At this point, it is either a label, int or fp constant.
1056 
1057  // Skip digits, we have at least one.
1058  for (; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
1059  /*empty*/;
1060 
1061  // Check if this is a fully-numeric label:
1062  if (isdigit(TokStart[0]) && CurPtr[0] == ':') {
1063  uint64_t Val = atoull(TokStart, CurPtr);
1064  ++CurPtr; // Skip the colon.
1065  if ((unsigned)Val != Val)
1066  Error("invalid value number (too large)!");
1067  UIntVal = unsigned(Val);
1068  return lltok::LabelID;
1069  }
1070 
1071  // Check to see if this really is a string label, e.g. "-1:".
1072  if (isLabelChar(CurPtr[0]) || CurPtr[0] == ':') {
1073  if (const char *End = isLabelTail(CurPtr)) {
1074  StrVal.assign(TokStart, End-1);
1075  CurPtr = End;
1076  return lltok::LabelStr;
1077  }
1078  }
1079 
1080  // If the next character is a '.', then it is a fp value, otherwise its
1081  // integer.
1082  if (CurPtr[0] != '.') {
1083  if (TokStart[0] == '0' && TokStart[1] == 'x')
1084  return Lex0x();
1085  APSIntVal = APSInt(StringRef(TokStart, CurPtr - TokStart));
1086  return lltok::APSInt;
1087  }
1088 
1089  ++CurPtr;
1090 
1091  // Skip over [0-9]*([eE][-+]?[0-9]+)?
1092  while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
1093 
1094  if (CurPtr[0] == 'e' || CurPtr[0] == 'E') {
1095  if (isdigit(static_cast<unsigned char>(CurPtr[1])) ||
1096  ((CurPtr[1] == '-' || CurPtr[1] == '+') &&
1097  isdigit(static_cast<unsigned char>(CurPtr[2])))) {
1098  CurPtr += 2;
1099  while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
1100  }
1101  }
1102 
1103  APFloatVal = APFloat(APFloat::IEEEdouble(),
1104  StringRef(TokStart, CurPtr - TokStart));
1105  return lltok::APFloat;
1106 }
1107 
1108 /// Lex a floating point constant starting with +.
1109 /// FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
1110 lltok::Kind LLLexer::LexPositive() {
1111  // If the letter after the negative is a number, this is probably not a
1112  // label.
1113  if (!isdigit(static_cast<unsigned char>(CurPtr[0])))
1114  return lltok::Error;
1115 
1116  // Skip digits.
1117  for (++CurPtr; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
1118  /*empty*/;
1119 
1120  // At this point, we need a '.'.
1121  if (CurPtr[0] != '.') {
1122  CurPtr = TokStart+1;
1123  return lltok::Error;
1124  }
1125 
1126  ++CurPtr;
1127 
1128  // Skip over [0-9]*([eE][-+]?[0-9]+)?
1129  while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
1130 
1131  if (CurPtr[0] == 'e' || CurPtr[0] == 'E') {
1132  if (isdigit(static_cast<unsigned char>(CurPtr[1])) ||
1133  ((CurPtr[1] == '-' || CurPtr[1] == '+') &&
1134  isdigit(static_cast<unsigned char>(CurPtr[2])))) {
1135  CurPtr += 2;
1136  while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
1137  }
1138  }
1139 
1140  APFloatVal = APFloat(APFloat::IEEEdouble(),
1141  StringRef(TokStart, CurPtr - TokStart));
1142  return lltok::APFloat;
1143 }
objc arc contract
uint64_t CallInst * C
static const fltSemantics & IEEEquad() LLVM_READNONE
Definition: APFloat.cpp:161
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:164
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
This class represents lattice values for constants.
Definition: AllocatorList.h:23
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:256
void Warning(LocTy WarningLoc, const Twine &Msg) const
Definition: LLLexer.cpp:33
static const char * isLabelTail(const char *CurPtr)
isLabelTail - Return true if this pointer points to a valid end of a label.
Definition: LLLexer.cpp:147
demanded bits
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1165
APInt trunc(unsigned width) const
Truncate to new width.
Definition: APInt.cpp:813
#define DWKEYWORD(TYPE, TOKEN)
static void cleanup(BlockFrequencyInfoImplBase &BFI)
Clear all memory not needed downstream.
static Type * getMetadataTy(LLVMContext &C)
Definition: Type.cpp:165
static Type * getX86_MMXTy(LLVMContext &C)
Definition: Type.cpp:170
static Type * getX86_FP80Ty(LLVMContext &C)
Definition: Type.cpp:167
static uint64_t allOnes(unsigned int Count)
void PrintMessage(raw_ostream &OS, SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges=None, ArrayRef< SMFixIt > FixIts=None, bool ShowColors=true) const
Emit a message about the specified location with the specified string.
Definition: SourceMgr.cpp:242
static Type * getTokenTy(LLVMContext &C)
Definition: Type.cpp:166
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:163
#define TYPEKEYWORD(STR, LLVMTY)
static Type * getPPC_FP128Ty(LLVMContext &C)
Definition: Type.cpp:169
LLLexer(StringRef StartBuf, SourceMgr &SM, SMDiagnostic &, LLVMContext &C)
Definition: LLLexer.cpp:159
static bool isLabelChar(char C)
isLabelChar - Return true for [-a-zA-Z$._0-9].
Definition: LLLexer.cpp:141
This file implements a class to represent arbitrary precision integral constant values and operations...
unsigned getActiveBits() const
Compute the number of active bits in the value.
Definition: APInt.h:1539
static Type * getLabelTy(LLVMContext &C)
Definition: Type.cpp:161
auto partition(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range))
Provide wrappers to std::partition which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1254
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:158
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:160
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
Definition: APFloat.cpp:164
rewrite statepoints for gc
lazy value info
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling...
Definition: SourceMgr.h:41
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
SMDiagnostic GetMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges=None, ArrayRef< SMFixIt > FixIts=None) const
Return an SMDiagnostic at the specified location with the specified string.
Definition: SourceMgr.cpp:163
static Type * getFP128Ty(LLVMContext &C)
Definition: Type.cpp:168
const APInt & umin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be signed.
Definition: APInt.h:2121
Maximum number of bits that can be specified.
Definition: DerivedTypes.h:52
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:162
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:239
static const fltSemantics & IEEEhalf() LLVM_READNONE
Definition: APFloat.cpp:152
static uint64_t add(uint64_t LeftOp, uint64_t RightOp)
Definition: FileCheck.cpp:243
Class for arbitrary precision integers.
Definition: APInt.h:69
Base class for user error types.
Definition: Error.h:344
unsigned hexDigitValue(char C)
Interpret the given character C as a hexadecimal digit and return its value.
Definition: StringExtras.h:68
const APInt & umax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be unsigned.
Definition: APInt.h:2126
iterator begin() const
Definition: StringRef.h:101
static const fltSemantics & PPCDoubleDouble() LLVM_READNONE
Definition: APFloat.cpp:170
static const size_t npos
Definition: StringRef.h:50
bool Error(LocTy ErrorLoc, const Twine &Msg) const
Definition: LLLexer.cpp:28
static void UnEscapeLexed(std::string &Str)
Definition: LLLexer.cpp:114
Deduce and propagate attributes
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static const char * name
amdgpu Simplify well known AMD library calls
Minimum number of bits that can be specified.
Definition: DerivedTypes.h:51
static uint64_t sub(uint64_t LeftOp, uint64_t RightOp)
Definition: FileCheck.cpp:247
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
#define KEYWORD(STR)
Represents a location in source code.
Definition: SMLoc.h:23
iterator end() const
Definition: StringRef.h:103
#define OP(n)
Definition: regex2.h:73
#define INSTKEYWORD(STR, Enum)
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition: SourceMgr.h:261