LLVM  14.0.0git
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 "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"
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(poison);
535  KEYWORD(to);
536  KEYWORD(caller);
537  KEYWORD(within);
538  KEYWORD(from);
539  KEYWORD(tail);
540  KEYWORD(musttail);
541  KEYWORD(notail);
542  KEYWORD(target);
543  KEYWORD(triple);
544  KEYWORD(source_filename);
545  KEYWORD(unwind);
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(cfguard_checkcc);
589  KEYWORD(x86_stdcallcc);
590  KEYWORD(x86_fastcallcc);
591  KEYWORD(x86_thiscallcc);
592  KEYWORD(x86_vectorcallcc);
593  KEYWORD(arm_apcscc);
594  KEYWORD(arm_aapcscc);
595  KEYWORD(arm_aapcs_vfpcc);
596  KEYWORD(aarch64_vector_pcs);
597  KEYWORD(aarch64_sve_vector_pcs);
598  KEYWORD(msp430_intrcc);
599  KEYWORD(avr_intrcc);
600  KEYWORD(avr_signalcc);
601  KEYWORD(ptx_kernel);
602  KEYWORD(ptx_device);
603  KEYWORD(spir_kernel);
604  KEYWORD(spir_func);
605  KEYWORD(intel_ocl_bicc);
606  KEYWORD(x86_64_sysvcc);
607  KEYWORD(win64cc);
608  KEYWORD(x86_regcallcc);
609  KEYWORD(webkit_jscc);
610  KEYWORD(swiftcc);
611  KEYWORD(swifttailcc);
612  KEYWORD(anyregcc);
613  KEYWORD(preserve_mostcc);
614  KEYWORD(preserve_allcc);
615  KEYWORD(ghccc);
616  KEYWORD(x86_intrcc);
617  KEYWORD(hhvmcc);
618  KEYWORD(hhvm_ccc);
619  KEYWORD(cxx_fast_tlscc);
620  KEYWORD(amdgpu_vs);
621  KEYWORD(amdgpu_ls);
622  KEYWORD(amdgpu_hs);
623  KEYWORD(amdgpu_es);
624  KEYWORD(amdgpu_gs);
625  KEYWORD(amdgpu_ps);
626  KEYWORD(amdgpu_cs);
627  KEYWORD(amdgpu_kernel);
628  KEYWORD(amdgpu_gfx);
629  KEYWORD(tailcc);
630 
631  KEYWORD(cc);
632  KEYWORD(c);
633 
635 
636  KEYWORD(alwaysinline);
637  KEYWORD(allocsize);
638  KEYWORD(argmemonly);
639  KEYWORD(builtin);
640  KEYWORD(byval);
641  KEYWORD(inalloca);
642  KEYWORD(cold);
643  KEYWORD(convergent);
644  KEYWORD(dereferenceable);
645  KEYWORD(dereferenceable_or_null);
646  KEYWORD(disable_sanitizer_instrumentation);
647  KEYWORD(elementtype);
648  KEYWORD(inaccessiblememonly);
649  KEYWORD(inaccessiblemem_or_argmemonly);
650  KEYWORD(inlinehint);
651  KEYWORD(inreg);
652  KEYWORD(jumptable);
653  KEYWORD(minsize);
654  KEYWORD(naked);
655  KEYWORD(nest);
656  KEYWORD(noalias);
657  KEYWORD(nobuiltin);
658  KEYWORD(nocallback);
659  KEYWORD(nocapture);
660  KEYWORD(noduplicate);
661  KEYWORD(nofree);
662  KEYWORD(noimplicitfloat);
663  KEYWORD(noinline);
664  KEYWORD(norecurse);
665  KEYWORD(nonlazybind);
666  KEYWORD(nomerge);
667  KEYWORD(nonnull);
668  KEYWORD(noprofile);
669  KEYWORD(noredzone);
670  KEYWORD(noreturn);
671  KEYWORD(nosync);
672  KEYWORD(nocf_check);
673  KEYWORD(noundef);
674  KEYWORD(nounwind);
675  KEYWORD(nosanitize_coverage);
676  KEYWORD(null_pointer_is_valid);
677  KEYWORD(optforfuzzing);
678  KEYWORD(optnone);
679  KEYWORD(optsize);
680  KEYWORD(preallocated);
681  KEYWORD(readnone);
682  KEYWORD(readonly);
683  KEYWORD(returned);
684  KEYWORD(returns_twice);
685  KEYWORD(signext);
686  KEYWORD(speculatable);
687  KEYWORD(sret);
688  KEYWORD(ssp);
689  KEYWORD(sspreq);
690  KEYWORD(sspstrong);
691  KEYWORD(strictfp);
692  KEYWORD(safestack);
693  KEYWORD(shadowcallstack);
694  KEYWORD(sanitize_address);
695  KEYWORD(sanitize_hwaddress);
696  KEYWORD(sanitize_memtag);
697  KEYWORD(sanitize_thread);
698  KEYWORD(sanitize_memory);
699  KEYWORD(speculative_load_hardening);
700  KEYWORD(swifterror);
701  KEYWORD(swiftself);
702  KEYWORD(swiftasync);
703  KEYWORD(uwtable);
704  KEYWORD(vscale_range);
705  KEYWORD(willreturn);
706  KEYWORD(writeonly);
707  KEYWORD(zeroext);
708  KEYWORD(immarg);
709  KEYWORD(byref);
710  KEYWORD(mustprogress);
711 
712  KEYWORD(type);
713  KEYWORD(opaque);
714 
715  KEYWORD(comdat);
716 
717  // Comdat types
718  KEYWORD(any);
719  KEYWORD(exactmatch);
720  KEYWORD(largest);
721  KEYWORD(nodeduplicate);
722  KEYWORD(samesize);
723 
724  KEYWORD(eq); KEYWORD(ne); KEYWORD(slt); KEYWORD(sgt); KEYWORD(sle);
725  KEYWORD(sge); KEYWORD(ult); KEYWORD(ugt); KEYWORD(ule); KEYWORD(uge);
726  KEYWORD(oeq); KEYWORD(one); KEYWORD(olt); KEYWORD(ogt); KEYWORD(ole);
727  KEYWORD(oge); KEYWORD(ord); KEYWORD(uno); KEYWORD(ueq); KEYWORD(une);
728 
729  KEYWORD(xchg); KEYWORD(nand); KEYWORD(max); KEYWORD(min); KEYWORD(umax);
730  KEYWORD(umin);
731 
732  KEYWORD(vscale);
733  KEYWORD(x);
734  KEYWORD(blockaddress);
735  KEYWORD(dso_local_equivalent);
736 
737  // Metadata types.
738  KEYWORD(distinct);
739 
740  // Use-list order directives.
741  KEYWORD(uselistorder);
742  KEYWORD(uselistorder_bb);
743 
744  KEYWORD(personality);
745  KEYWORD(cleanup);
746  KEYWORD(catch);
747  KEYWORD(filter);
748 
749  // Summary index keywords.
750  KEYWORD(path);
751  KEYWORD(hash);
752  KEYWORD(gv);
753  KEYWORD(guid);
754  KEYWORD(name);
755  KEYWORD(summaries);
756  KEYWORD(flags);
757  KEYWORD(blockcount);
758  KEYWORD(linkage);
759  KEYWORD(visibility);
760  KEYWORD(notEligibleToImport);
761  KEYWORD(live);
762  KEYWORD(dsoLocal);
763  KEYWORD(canAutoHide);
764  KEYWORD(function);
765  KEYWORD(insts);
766  KEYWORD(funcFlags);
767  KEYWORD(readNone);
768  KEYWORD(readOnly);
769  KEYWORD(noRecurse);
770  KEYWORD(returnDoesNotAlias);
771  KEYWORD(noInline);
772  KEYWORD(alwaysInline);
773  KEYWORD(noUnwind);
774  KEYWORD(mayThrow);
775  KEYWORD(hasUnknownCall);
776  KEYWORD(calls);
777  KEYWORD(callee);
778  KEYWORD(params);
779  KEYWORD(param);
780  KEYWORD(hotness);
781  KEYWORD(unknown);
782  KEYWORD(hot);
783  KEYWORD(critical);
784  KEYWORD(relbf);
785  KEYWORD(variable);
786  KEYWORD(vTableFuncs);
787  KEYWORD(virtFunc);
788  KEYWORD(aliasee);
789  KEYWORD(refs);
790  KEYWORD(typeIdInfo);
791  KEYWORD(typeTests);
792  KEYWORD(typeTestAssumeVCalls);
793  KEYWORD(typeCheckedLoadVCalls);
794  KEYWORD(typeTestAssumeConstVCalls);
795  KEYWORD(typeCheckedLoadConstVCalls);
796  KEYWORD(vFuncId);
797  KEYWORD(offset);
798  KEYWORD(args);
799  KEYWORD(typeid);
800  KEYWORD(typeidCompatibleVTable);
801  KEYWORD(summary);
802  KEYWORD(typeTestRes);
803  KEYWORD(kind);
804  KEYWORD(unsat);
805  KEYWORD(byteArray);
806  KEYWORD(inline);
807  KEYWORD(single);
808  KEYWORD(allOnes);
809  KEYWORD(sizeM1BitWidth);
810  KEYWORD(alignLog2);
811  KEYWORD(sizeM1);
812  KEYWORD(bitMask);
813  KEYWORD(inlineBits);
814  KEYWORD(vcall_visibility);
815  KEYWORD(wpdResolutions);
816  KEYWORD(wpdRes);
817  KEYWORD(indir);
818  KEYWORD(singleImpl);
819  KEYWORD(branchFunnel);
820  KEYWORD(singleImplName);
821  KEYWORD(resByArg);
822  KEYWORD(byArg);
823  KEYWORD(uniformRetVal);
824  KEYWORD(uniqueRetVal);
825  KEYWORD(virtualConstProp);
826  KEYWORD(info);
827  KEYWORD(byte);
828  KEYWORD(bit);
829  KEYWORD(varFlags);
830 
831 #undef KEYWORD
832 
833  // Keywords for types.
834 #define TYPEKEYWORD(STR, LLVMTY) \
835  do { \
836  if (Keyword == STR) { \
837  TyVal = LLVMTY; \
838  return lltok::Type; \
839  } \
840  } while (false)
841 
842  TYPEKEYWORD("void", Type::getVoidTy(Context));
843  TYPEKEYWORD("half", Type::getHalfTy(Context));
844  TYPEKEYWORD("bfloat", Type::getBFloatTy(Context));
845  TYPEKEYWORD("float", Type::getFloatTy(Context));
846  TYPEKEYWORD("double", Type::getDoubleTy(Context));
847  TYPEKEYWORD("x86_fp80", Type::getX86_FP80Ty(Context));
848  TYPEKEYWORD("fp128", Type::getFP128Ty(Context));
849  TYPEKEYWORD("ppc_fp128", Type::getPPC_FP128Ty(Context));
850  TYPEKEYWORD("label", Type::getLabelTy(Context));
851  TYPEKEYWORD("metadata", Type::getMetadataTy(Context));
852  TYPEKEYWORD("x86_mmx", Type::getX86_MMXTy(Context));
853  TYPEKEYWORD("x86_amx", Type::getX86_AMXTy(Context));
854  TYPEKEYWORD("token", Type::getTokenTy(Context));
855 
856  if (Keyword == "ptr") {
857  if (Context.supportsTypedPointers()) {
858  Warning("ptr type is only supported in -opaque-pointers mode");
859  return lltok::Error;
860  }
861  TyVal = PointerType::getUnqual(Context);
862  return lltok::Type;
863  }
864 
865 #undef TYPEKEYWORD
866 
867  // Keywords for instructions.
868 #define INSTKEYWORD(STR, Enum) \
869  do { \
870  if (Keyword == #STR) { \
871  UIntVal = Instruction::Enum; \
872  return lltok::kw_##STR; \
873  } \
874  } while (false)
875 
876  INSTKEYWORD(fneg, FNeg);
877 
878  INSTKEYWORD(add, Add); INSTKEYWORD(fadd, FAdd);
879  INSTKEYWORD(sub, Sub); INSTKEYWORD(fsub, FSub);
880  INSTKEYWORD(mul, Mul); INSTKEYWORD(fmul, FMul);
881  INSTKEYWORD(udiv, UDiv); INSTKEYWORD(sdiv, SDiv); INSTKEYWORD(fdiv, FDiv);
882  INSTKEYWORD(urem, URem); INSTKEYWORD(srem, SRem); INSTKEYWORD(frem, FRem);
883  INSTKEYWORD(shl, Shl); INSTKEYWORD(lshr, LShr); INSTKEYWORD(ashr, AShr);
884  INSTKEYWORD(and, And); INSTKEYWORD(or, Or); INSTKEYWORD(xor, Xor);
885  INSTKEYWORD(icmp, ICmp); INSTKEYWORD(fcmp, FCmp);
886 
887  INSTKEYWORD(phi, PHI);
888  INSTKEYWORD(call, Call);
889  INSTKEYWORD(trunc, Trunc);
890  INSTKEYWORD(zext, ZExt);
891  INSTKEYWORD(sext, SExt);
892  INSTKEYWORD(fptrunc, FPTrunc);
893  INSTKEYWORD(fpext, FPExt);
894  INSTKEYWORD(uitofp, UIToFP);
895  INSTKEYWORD(sitofp, SIToFP);
896  INSTKEYWORD(fptoui, FPToUI);
897  INSTKEYWORD(fptosi, FPToSI);
898  INSTKEYWORD(inttoptr, IntToPtr);
899  INSTKEYWORD(ptrtoint, PtrToInt);
900  INSTKEYWORD(bitcast, BitCast);
901  INSTKEYWORD(addrspacecast, AddrSpaceCast);
903  INSTKEYWORD(va_arg, VAArg);
904  INSTKEYWORD(ret, Ret);
905  INSTKEYWORD(br, Br);
906  INSTKEYWORD(switch, Switch);
907  INSTKEYWORD(indirectbr, IndirectBr);
908  INSTKEYWORD(invoke, Invoke);
909  INSTKEYWORD(resume, Resume);
910  INSTKEYWORD(unreachable, Unreachable);
911  INSTKEYWORD(callbr, CallBr);
912 
913  INSTKEYWORD(alloca, Alloca);
916  INSTKEYWORD(cmpxchg, AtomicCmpXchg);
917  INSTKEYWORD(atomicrmw, AtomicRMW);
918  INSTKEYWORD(fence, Fence);
919  INSTKEYWORD(getelementptr, GetElementPtr);
920 
921  INSTKEYWORD(extractelement, ExtractElement);
922  INSTKEYWORD(insertelement, InsertElement);
923  INSTKEYWORD(shufflevector, ShuffleVector);
924  INSTKEYWORD(extractvalue, ExtractValue);
925  INSTKEYWORD(insertvalue, InsertValue);
926  INSTKEYWORD(landingpad, LandingPad);
927  INSTKEYWORD(cleanupret, CleanupRet);
928  INSTKEYWORD(catchret, CatchRet);
929  INSTKEYWORD(catchswitch, CatchSwitch);
930  INSTKEYWORD(catchpad, CatchPad);
931  INSTKEYWORD(cleanuppad, CleanupPad);
932 
933  INSTKEYWORD(freeze, Freeze);
934 
935 #undef INSTKEYWORD
936 
937 #define DWKEYWORD(TYPE, TOKEN) \
938  do { \
939  if (Keyword.startswith("DW_" #TYPE "_")) { \
940  StrVal.assign(Keyword.begin(), Keyword.end()); \
941  return lltok::TOKEN; \
942  } \
943  } while (false)
944 
947  DWKEYWORD(VIRTUALITY, DwarfVirtuality);
948  DWKEYWORD(LANG, DwarfLang);
949  DWKEYWORD(CC, DwarfCC);
950  DWKEYWORD(OP, DwarfOp);
951  DWKEYWORD(MACINFO, DwarfMacinfo);
952 
953 #undef DWKEYWORD
954 
955  if (Keyword.startswith("DIFlag")) {
956  StrVal.assign(Keyword.begin(), Keyword.end());
957  return lltok::DIFlag;
958  }
959 
960  if (Keyword.startswith("DISPFlag")) {
961  StrVal.assign(Keyword.begin(), Keyword.end());
962  return lltok::DISPFlag;
963  }
964 
965  if (Keyword.startswith("CSK_")) {
966  StrVal.assign(Keyword.begin(), Keyword.end());
967  return lltok::ChecksumKind;
968  }
969 
970  if (Keyword == "NoDebug" || Keyword == "FullDebug" ||
971  Keyword == "LineTablesOnly" || Keyword == "DebugDirectivesOnly") {
972  StrVal.assign(Keyword.begin(), Keyword.end());
973  return lltok::EmissionKind;
974  }
975 
976  if (Keyword == "GNU" || Keyword == "None" || Keyword == "Default") {
977  StrVal.assign(Keyword.begin(), Keyword.end());
978  return lltok::NameTableKind;
979  }
980 
981  // Check for [us]0x[0-9A-Fa-f]+ which are Hexadecimal constant generated by
982  // the CFE to avoid forcing it to deal with 64-bit numbers.
983  if ((TokStart[0] == 'u' || TokStart[0] == 's') &&
984  TokStart[1] == '0' && TokStart[2] == 'x' &&
985  isxdigit(static_cast<unsigned char>(TokStart[3]))) {
986  int len = CurPtr-TokStart-3;
987  uint32_t bits = len * 4;
988  StringRef HexStr(TokStart + 3, len);
989  if (!all_of(HexStr, isxdigit)) {
990  // Bad token, return it as an error.
991  CurPtr = TokStart+3;
992  return lltok::Error;
993  }
994  APInt Tmp(bits, HexStr, 16);
995  uint32_t activeBits = Tmp.getActiveBits();
996  if (activeBits > 0 && activeBits < bits)
997  Tmp = Tmp.trunc(activeBits);
998  APSIntVal = APSInt(Tmp, TokStart[0] == 'u');
999  return lltok::APSInt;
1000  }
1001 
1002  // If this is "cc1234", return this as just "cc".
1003  if (TokStart[0] == 'c' && TokStart[1] == 'c') {
1004  CurPtr = TokStart+2;
1005  return lltok::kw_cc;
1006  }
1007 
1008  // Finally, if this isn't known, return an error.
1009  CurPtr = TokStart+1;
1010  return lltok::Error;
1011 }
1012 
1013 /// Lex all tokens that start with a 0x prefix, knowing they match and are not
1014 /// labels.
1015 /// HexFPConstant 0x[0-9A-Fa-f]+
1016 /// HexFP80Constant 0xK[0-9A-Fa-f]+
1017 /// HexFP128Constant 0xL[0-9A-Fa-f]+
1018 /// HexPPC128Constant 0xM[0-9A-Fa-f]+
1019 /// HexHalfConstant 0xH[0-9A-Fa-f]+
1020 /// HexBFloatConstant 0xR[0-9A-Fa-f]+
1021 lltok::Kind LLLexer::Lex0x() {
1022  CurPtr = TokStart + 2;
1023 
1024  char Kind;
1025  if ((CurPtr[0] >= 'K' && CurPtr[0] <= 'M') || CurPtr[0] == 'H' ||
1026  CurPtr[0] == 'R') {
1027  Kind = *CurPtr++;
1028  } else {
1029  Kind = 'J';
1030  }
1031 
1032  if (!isxdigit(static_cast<unsigned char>(CurPtr[0]))) {
1033  // Bad token, return it as an error.
1034  CurPtr = TokStart+1;
1035  return lltok::Error;
1036  }
1037 
1038  while (isxdigit(static_cast<unsigned char>(CurPtr[0])))
1039  ++CurPtr;
1040 
1041  if (Kind == 'J') {
1042  // HexFPConstant - Floating point constant represented in IEEE format as a
1043  // hexadecimal number for when exponential notation is not precise enough.
1044  // Half, BFloat, Float, and double only.
1045  APFloatVal = APFloat(APFloat::IEEEdouble(),
1046  APInt(64, HexIntToVal(TokStart + 2, CurPtr)));
1047  return lltok::APFloat;
1048  }
1049 
1050  uint64_t Pair[2];
1051  switch (Kind) {
1052  default: llvm_unreachable("Unknown kind!");
1053  case 'K':
1054  // F80HexFPConstant - x87 long double in hexadecimal format (10 bytes)
1055  FP80HexToIntPair(TokStart+3, CurPtr, Pair);
1056  APFloatVal = APFloat(APFloat::x87DoubleExtended(), APInt(80, Pair));
1057  return lltok::APFloat;
1058  case 'L':
1059  // F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes)
1060  HexToIntPair(TokStart+3, CurPtr, Pair);
1061  APFloatVal = APFloat(APFloat::IEEEquad(), APInt(128, Pair));
1062  return lltok::APFloat;
1063  case 'M':
1064  // PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes)
1065  HexToIntPair(TokStart+3, CurPtr, Pair);
1066  APFloatVal = APFloat(APFloat::PPCDoubleDouble(), APInt(128, Pair));
1067  return lltok::APFloat;
1068  case 'H':
1069  APFloatVal = APFloat(APFloat::IEEEhalf(),
1070  APInt(16,HexIntToVal(TokStart+3, CurPtr)));
1071  return lltok::APFloat;
1072  case 'R':
1073  // Brain floating point
1074  APFloatVal = APFloat(APFloat::BFloat(),
1075  APInt(16, HexIntToVal(TokStart + 3, CurPtr)));
1076  return lltok::APFloat;
1077  }
1078 }
1079 
1080 /// Lex tokens for a label or a numeric constant, possibly starting with -.
1081 /// Label [-a-zA-Z$._0-9]+:
1082 /// NInteger -[0-9]+
1083 /// FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
1084 /// PInteger [0-9]+
1085 /// HexFPConstant 0x[0-9A-Fa-f]+
1086 /// HexFP80Constant 0xK[0-9A-Fa-f]+
1087 /// HexFP128Constant 0xL[0-9A-Fa-f]+
1088 /// HexPPC128Constant 0xM[0-9A-Fa-f]+
1089 lltok::Kind LLLexer::LexDigitOrNegative() {
1090  // If the letter after the negative is not a number, this is probably a label.
1091  if (!isdigit(static_cast<unsigned char>(TokStart[0])) &&
1092  !isdigit(static_cast<unsigned char>(CurPtr[0]))) {
1093  // Okay, this is not a number after the -, it's probably a label.
1094  if (const char *End = isLabelTail(CurPtr)) {
1095  StrVal.assign(TokStart, End-1);
1096  CurPtr = End;
1097  return lltok::LabelStr;
1098  }
1099 
1100  return lltok::Error;
1101  }
1102 
1103  // At this point, it is either a label, int or fp constant.
1104 
1105  // Skip digits, we have at least one.
1106  for (; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
1107  /*empty*/;
1108 
1109  // Check if this is a fully-numeric label:
1110  if (isdigit(TokStart[0]) && CurPtr[0] == ':') {
1111  uint64_t Val = atoull(TokStart, CurPtr);
1112  ++CurPtr; // Skip the colon.
1113  if ((unsigned)Val != Val)
1114  Error("invalid value number (too large)!");
1115  UIntVal = unsigned(Val);
1116  return lltok::LabelID;
1117  }
1118 
1119  // Check to see if this really is a string label, e.g. "-1:".
1120  if (isLabelChar(CurPtr[0]) || CurPtr[0] == ':') {
1121  if (const char *End = isLabelTail(CurPtr)) {
1122  StrVal.assign(TokStart, End-1);
1123  CurPtr = End;
1124  return lltok::LabelStr;
1125  }
1126  }
1127 
1128  // If the next character is a '.', then it is a fp value, otherwise its
1129  // integer.
1130  if (CurPtr[0] != '.') {
1131  if (TokStart[0] == '0' && TokStart[1] == 'x')
1132  return Lex0x();
1133  APSIntVal = APSInt(StringRef(TokStart, CurPtr - TokStart));
1134  return lltok::APSInt;
1135  }
1136 
1137  ++CurPtr;
1138 
1139  // Skip over [0-9]*([eE][-+]?[0-9]+)?
1140  while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
1141 
1142  if (CurPtr[0] == 'e' || CurPtr[0] == 'E') {
1143  if (isdigit(static_cast<unsigned char>(CurPtr[1])) ||
1144  ((CurPtr[1] == '-' || CurPtr[1] == '+') &&
1145  isdigit(static_cast<unsigned char>(CurPtr[2])))) {
1146  CurPtr += 2;
1147  while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
1148  }
1149  }
1150 
1151  APFloatVal = APFloat(APFloat::IEEEdouble(),
1152  StringRef(TokStart, CurPtr - TokStart));
1153  return lltok::APFloat;
1154 }
1155 
1156 /// Lex a floating point constant starting with +.
1157 /// FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
1158 lltok::Kind LLLexer::LexPositive() {
1159  // If the letter after the negative is a number, this is probably not a
1160  // label.
1161  if (!isdigit(static_cast<unsigned char>(CurPtr[0])))
1162  return lltok::Error;
1163 
1164  // Skip digits.
1165  for (++CurPtr; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
1166  /*empty*/;
1167 
1168  // At this point, we need a '.'.
1169  if (CurPtr[0] != '.') {
1170  CurPtr = TokStart+1;
1171  return lltok::Error;
1172  }
1173 
1174  ++CurPtr;
1175 
1176  // Skip over [0-9]*([eE][-+]?[0-9]+)?
1177  while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
1178 
1179  if (CurPtr[0] == 'e' || CurPtr[0] == 'E') {
1180  if (isdigit(static_cast<unsigned char>(CurPtr[1])) ||
1181  ((CurPtr[1] == '-' || CurPtr[1] == '+') &&
1182  isdigit(static_cast<unsigned char>(CurPtr[2])))) {
1183  CurPtr += 2;
1184  while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
1185  }
1186  }
1187 
1188  APFloatVal = APFloat(APFloat::IEEEdouble(),
1189  StringRef(TokStart, CurPtr - TokStart));
1190  return lltok::APFloat;
1191 }
i
i
Definition: README.txt:29
llvm::lltok::APFloat
@ APFloat
Definition: LLToken.h:495
llvm::LLLexer::LLLexer
LLLexer(StringRef StartBuf, SourceMgr &SM, SMDiagnostic &, LLVMContext &C)
Definition: LLLexer.cpp:159
readnone
We generate the following IR with i32 b nounwind readnone
Definition: README.txt:1443
isLabelTail
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
constant
we should consider alternate ways to model stack dependencies Lots of things could be done in WebAssemblyTargetTransformInfo cpp there are numerous optimization related hooks that can be overridden in WebAssemblyTargetLowering Instead of the OptimizeReturned which should consider preserving the returned attribute through to MachineInstrs and extending the MemIntrinsicResults pass to do this optimization on calls too That would also let the WebAssemblyPeephole pass clean up dead defs for such as it does for stores Consider implementing and or getMachineCombinerPatterns Find a clean way to fix the problem which leads to the Shrink Wrapping pass being run after the WebAssembly PEI pass When setting multiple variables to the same constant
Definition: README.txt:91
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
llvm::lltok::Error
@ Error
Definition: LLToken.h:21
TYPEKEYWORD
#define TYPEKEYWORD(STR, LLVMTY)
type
contract
objc arc contract
Definition: ObjCARCContract.cpp:723
llvm::Type::getFP128Ty
static Type * getFP128Ty(LLVMContext &C)
Definition: Type.cpp:233
TAG
static constexpr auto TAG
Definition: OpenMPOpt.cpp:148
llvm::lltok::lparen
@ lparen
Definition: LLToken.h:34
llvm::LLLexer::Error
bool Error(LocTy ErrorLoc, const Twine &Msg) const
Definition: LLLexer.cpp:28
store
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM ID Predecessors according to mbb< bb27, 0x8b0a7c0 > Note ADDri is not a two address instruction its result reg1037 is an operand of the PHI node in bb76 and its operand reg1039 is the result of the PHI node We should treat it as a two address code and make sure the ADDri is scheduled after any node that reads reg1039 Use info(i.e. register scavenger) to assign it a free register to allow reuse the collector could move the objects and invalidate the derived pointer This is bad enough in the first but safe points can crop up unpredictably **array_addr i32 n y store obj obj **nth_el If the i64 division is lowered to a then a safe point array and nth_el no longer point into the correct object The fix for this is to copy address calculations so that dependent pointers are never live across safe point boundaries But the loads cannot be copied like this if there was an intervening store
Definition: README.txt:133
llvm::lltok::NameTableKind
@ NameTableKind
Definition: LLToken.h:485
llvm::lltok::LocalVar
@ LocalVar
Definition: LLToken.h:476
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:60
cc
src override malloc cc
Definition: CMakeLists.txt:93
llvm::lltok::bar
@ bar
Definition: LLToken.h:37
KEYWORD
#define KEYWORD(STR)
ErrorHandling.h
llvm::lltok::DwarfMacinfo
@ DwarfMacinfo
Definition: LLToken.h:489
llvm::WebAssembly::mayThrow
bool mayThrow(const MachineInstr &MI)
Definition: WebAssemblyUtilities.cpp:39
llvm::lltok::Eof
@ Eof
Definition: LLToken.h:20
llvm::lltok::APSInt
@ APSInt
Definition: LLToken.h:496
llvm::APFloatBase::x87DoubleExtended
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
Definition: APFloat.cpp:179
cleanup
static void cleanup(BlockFrequencyInfoImplBase &BFI)
Clear all memory not needed downstream.
Definition: BlockFrequencyInfoImpl.cpp:304
APInt.h
to
Should compile to
Definition: README.txt:449
llvm::SPII::Load
@ Load
Definition: SparcInstrInfo.h:32
llvm::APFloatBase::BFloat
static const fltSemantics & BFloat() LLVM_READNONE
Definition: APFloat.cpp:167
llvm::Type::getTokenTy
static Type * getTokenTy(LLVMContext &C)
Definition: Type.cpp:231
llvm::lltok::star
@ star
Definition: LLToken.h:27
ret
to esp esp setne al movzbw ax esp setg cl movzbw cx cmove cx cl jne LBB1_2 esp ret(also really horrible code on ppc). This is due to the expand code for 64-bit compares. GCC produces multiple branches
llvm::lltok::greater
@ greater
Definition: LLToken.h:33
attributes
Deduce and propagate attributes
Definition: Attributor.cpp:3084
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:116
STLExtras.h
llvm::lltok::less
@ less
Definition: LLToken.h:32
caller
int caller(int32 arg1, int32 arg2)
Definition: README.txt:681
and
We currently generate a but we really shouldn eax ecx xorl edx divl ecx eax divl ecx movl eax ret A similar code sequence works for division We currently compile i32 v2 eax eax jo LBB1_2 and
Definition: README.txt:1271
llvm::LegalityPredicates::any
Predicate any(Predicate P0, Predicate P1)
True iff P0 or P1 are true.
Definition: LegalizerInfo.h:239
llvm::lltok::AttrGrpID
@ AttrGrpID
Definition: LLToken.h:469
llvm::APIntOps::umin
const APInt & umin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be unsigned.
Definition: APInt.h:2117
llvm::APFloatBase::IEEEquad
static const fltSemantics & IEEEquad() LLVM_READNONE
Definition: APFloat.cpp:176
llvm::lltok::equal
@ equal
Definition: LLToken.h:25
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
Instruction.h
llvm::Type::getMetadataTy
static Type * getMetadataTy(LLVMContext &C)
Definition: Type.cpp:230
llvm::all_of
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:1551
llvm::Type::getX86_AMXTy
static Type * getX86_AMXTy(LLVMContext &C)
Definition: Type.cpp:236
llvm::LLVMContext::supportsTypedPointers
bool supportsTypedPointers() const
Whether typed pointers are supported. If false, all pointers are opaque.
Definition: LLVMContext.cpp:357
llvm::lltok::rparen
@ rparen
Definition: LLToken.h:35
select
into xmm2 addss xmm2 xmm1 xmm3 addss xmm3 movaps xmm0 unpcklps xmm0 ret seems silly when it could just be one addps Expand libm rounding functions main should enable SSE DAZ mode and other fast SSE modes Think about doing i64 math in SSE regs on x86 This testcase should have no SSE instructions in and only one load from a constant double ret double C the select is being which prevents the dag combiner from turning select(load CPI1)
llvm::SMLoc
Represents a location in source code.
Definition: SMLoc.h:23
bits
demanded bits
Definition: DemandedBits.cpp:63
shl
We currently generate a but we really shouldn eax ecx xorl edx divl ecx eax divl ecx movl eax ret A similar code sequence works for division We currently compile i32 v2 eax eax jo LBB1_2 shl
Definition: README.txt:1271
llvm::Type::getPPC_FP128Ty
static Type * getPPC_FP128Ty(LLVMContext &C)
Definition: Type.cpp:234
llvm::APFloatBase::IEEEhalf
static const fltSemantics & IEEEhalf() LLVM_READNONE
Definition: APFloat.cpp:164
llvm::Type::getDoubleTy
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:229
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
Twine.h
DWKEYWORD
#define DWKEYWORD(TYPE, TOKEN)
freeze
canon freeze
Definition: CanonicalizeFreezeInLoops.cpp:242
llvm::lltok::exclaim
@ exclaim
Definition: LLToken.h:36
llvm::SMDiagnostic
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition: SourceMgr.h:251
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
false
Definition: StackSlotColoring.cpp:142
llvm::lltok::kw_cc
@ kw_cc
Definition: LLToken.h:131
llvm::lltok::DwarfTag
@ DwarfTag
Definition: LLToken.h:479
c
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int c
Definition: README.txt:418
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
UnEscapeLexed
static void UnEscapeLexed(std::string &Str)
Definition: LLLexer.cpp:114
SourceMgr.h
one
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only one
Definition: README.txt:401
llvm::lltok::EmissionKind
@ EmissionKind
Definition: LLToken.h:484
readonly
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from where P can be anything The alignment inference code cannot handle loads from globals in static non mode because it doesn t look through the extra dyld stub load If you try vec_align ll without relocation you ll see what I mean We should lower which eliminates a constant pool load For float z nounwind readonly
Definition: README-SSE.txt:421
llvm::PointerType::getUnqual
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Definition: DerivedTypes.h:651
llvm::lltok::MetadataVar
@ MetadataVar
Definition: LLToken.h:477
uint64_t
llvm::lltok::DwarfCC
@ DwarfCC
Definition: LLToken.h:483
llvm::StringRef::end
iterator end() const
Definition: StringRef.h:130
llvm::lltok::LabelID
@ LabelID
Definition: LLToken.h:466
llvm::SourceMgr::PrintMessage
void PrintMessage(raw_ostream &OS, SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges={}, ArrayRef< SMFixIt > FixIts={}, bool ShowColors=true) const
Emit a message about the specified location with the specified string.
Definition: SourceMgr.cpp:341
llvm::SourceMgr::DK_Warning
@ DK_Warning
Definition: SourceMgr.h:35
llvm::ARM_AM::add
@ add
Definition: ARMAddressingModes.h:39
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::lltok::SummaryID
@ SummaryID
Definition: LLToken.h:470
StringExtras.h
sub
we currently eax ecx subl eax ret We would use one fewer register if codegen d eax neg eax eax ret Note that this isn t beneficial if the load can be folded into the sub In this we want a sub
Definition: README.txt:460
call
S is passed via registers r2 But gcc stores them to the and then reload them to and r3 before issuing the call(r0 contains the address of the format string)
Definition: README.txt:190
llvm::lltok::StringConstant
@ StringConstant
Definition: LLToken.h:478
llvm::lltok::DISPFlag
@ DISPFlag
Definition: LLToken.h:488
llvm::SPII::Store
@ Store
Definition: SparcInstrInfo.h:33
llvm::lltok::lsquare
@ lsquare
Definition: LLToken.h:28
llvm::APFloatBase::PPCDoubleDouble
static const fltSemantics & PPCDoubleDouble() LLVM_READNONE
Definition: APFloat.cpp:185
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
load
LLVM currently emits rax rax movq rax rax ret It could narrow the loads and stores to emit rax rax movq rax rax ret The trouble is that there is a TokenFactor between the store and the load
Definition: README.txt:1531
llvm::lltok::LocalVarID
@ LocalVarID
Definition: LLToken.h:468
llvm::LLLexer::Warning
void Warning(LocTy WarningLoc, const Twine &Msg) const
Definition: LLLexer.cpp:33
llvm::lltok::colon
@ colon
Definition: LLToken.h:38
llvm::lltok::DwarfOp
@ DwarfOp
Definition: LLToken.h:486
llvm::Type::getX86_FP80Ty
static Type * getX86_FP80Ty(LLVMContext &C)
Definition: Type.cpp:232
llvm::ErrorInfo
Base class for user error types.
Definition: Error.h:349
OP
#define OP(n)
Definition: regex2.h:73
gc
rewrite statepoints for gc
Definition: RewriteStatepointsForGC.cpp:228
info
lazy value info
Definition: LazyValueInfo.cpp:59
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
llvm::APFloatBase::IEEEdouble
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:173
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
allOnes
static uint64_t allOnes(unsigned int Count)
Definition: SystemZInstrInfo.cpp:51
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
llvm::SourceMgr
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling.
Definition: SourceMgr.h:31
uint32_t
LLLexer.h
trunc
We have fiadd patterns now but the followings have the same cost and complexity We need a way to specify the later is more profitable def def The FP stackifier should handle simple permutates to reduce number of shuffle e g trunc
Definition: README-FPStack.txt:63
llvm::lltok::DwarfAttEncoding
@ DwarfAttEncoding
Definition: LLToken.h:480
llvm::partition
auto partition(R &&Range, UnaryPredicate P)
Provide wrappers to std::partition which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1655
xor
We currently generate a but we really shouldn eax ecx xorl edx divl ecx eax divl ecx movl eax ret A similar code sequence works for division We currently compile i32 v2 eax eax jo LBB1_2 xor
Definition: README.txt:1271
llvm::lltok::comma
@ comma
Definition: LLToken.h:26
llvm::IntegerType::MAX_INT_BITS
@ MAX_INT_BITS
Maximum number of bits that can be specified.
Definition: DerivedTypes.h:52
llvm::MCID::Select
@ Select
Definition: MCInstrDesc.h:162
llvm::lltok::Type
@ Type
Definition: LLToken.h:493
name
static const char * name
Definition: SVEIntrinsicOpts.cpp:78
llvm::APIntOps::umax
const APInt & umax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be unsigned.
Definition: APInt.h:2122
reassoc
into llvm powi allowing the code generator to produce balanced multiplication trees the intrinsic needs to be extended to support and second the code generator needs to be enhanced to lower these to multiplication trees Interesting testcase for add shift mul reassoc
Definition: README.txt:61
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::lltok::lbrace
@ lbrace
Definition: LLToken.h:30
bit
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional ldr LCPI1_0 ldr ldr tst movne lsr ldr LCPI1_1 and r0 bx lr it saves an instruction and a register It might be profitable to cse MOVi16 if there are lots of bit immediates with the same bottom half Robert Muth started working on an alternate jump table implementation that does not put the tables in line in the text This is more like the llvm default jump table implementation This might be useful sometime Several revisions of patches are on the mailing beginning while CMP sets them like a subtract Therefore to be able to use CMN for comparisons other than the Z bit
Definition: README.txt:584
llvm::Type::getHalfTy
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:226
or
compiles or
Definition: README.txt:606
llvm::lltok::dotdotdot
@ dotdotdot
Definition: LLToken.h:24
x
TODO unsigned x
Definition: README.txt:10
llvm::SourceMgr::DK_Error
@ DK_Error
Definition: SourceMgr.h:34
llvm::IntegerType::MIN_INT_BITS
@ MIN_INT_BITS
Minimum number of bits that can be specified.
Definition: DerivedTypes.h:51
llvm::Type::getBFloatTy
static Type * getBFloatTy(LLVMContext &C)
Definition: Type.cpp:227
llvm::SourceMgr::GetMessage
SMDiagnostic GetMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges={}, ArrayRef< SMFixIt > FixIts={}) const
Return an SMDiagnostic at the specified location with the specified string.
Definition: SourceMgr.cpp:262
llvm::Type::getVoidTy
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:224
align
mov r0 ldr L5 sub r0 lr needed for prologue ldmia ip add bx lr r2 The last stmia stores r2 into the address passed in there is one additional stmia that stores and r2 to some stack location The store is dead The llvm gcc generated code looks like align
Definition: README.txt:236
llvm::numbers::phi
constexpr double phi
Definition: MathExtras.h:71
llvm::lltok::rbrace
@ rbrace
Definition: LLToken.h:31
llvm::lltok::ComdatVar
@ ComdatVar
Definition: LLToken.h:475
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::lltok::DIFlag
@ DIFlag
Definition: LLToken.h:487
llvm::lltok::GlobalID
@ GlobalID
Definition: LLToken.h:467
llvm::lltok::DwarfLang
@ DwarfLang
Definition: LLToken.h:482
isLabelChar
static bool isLabelChar(char C)
isLabelChar - Return true for [-a-zA-Z$._0-9].
Definition: LLLexer.cpp:141
calls
amdgpu Simplify well known AMD library calls
Definition: AMDGPULibCalls.cpp:199
llvm::lltok::GlobalVar
@ GlobalVar
Definition: LLToken.h:474
DerivedTypes.h
llvm::IntegerType::get
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:313
llvm::Type::getLabelTy
static Type * getLabelTy(LLVMContext &C)
Definition: Type.cpp:225
INSTKEYWORD
#define INSTKEYWORD(STR, Enum)
nounwind
this lets us change the cmpl into a which is and eliminate the shift We compile this i32 i32 i8 zeroext d nounwind
Definition: README.txt:973
lshr
Vector Shift Left don t map to llvm shl and lshr
Definition: README_P9.txt:118
llvm::lltok::ChecksumKind
@ ChecksumKind
Definition: LLToken.h:490
callee
Here we don t need to write any variables to the top of the stack since they don t overwrite each other int callee(int32 arg1, int32 arg2)
llvm::Type::getX86_MMXTy
static Type * getX86_MMXTy(LLVMContext &C)
Definition: Type.cpp:235
llvm::lltok::LabelStr
@ LabelStr
Definition: LLToken.h:473
llvm::lltok::rsquare
@ rsquare
Definition: LLToken.h:29
llvm::StringRef::begin
iterator begin() const
Definition: StringRef.h:128
llvm::Type::getFloatTy
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:228
llvm::lltok::DwarfVirtuality
@ DwarfVirtuality
Definition: LLToken.h:481