1 /*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the flex scanner for LLVM assembly languages files.
12 //===----------------------------------------------------------------------===*/
14 %option prefix="llvmAsm"
17 %option never-interactive
22 %option outfile="Lexer.cpp"
28 #include "ParserInternals.h"
29 #include "llvm/Module.h"
30 #include "llvm/Support/MathExtras.h"
32 #include "llvmAsmParser.h"
36 void set_scan_file(FILE * F){
37 yy_switch_to_buffer(yy_create_buffer( F, YY_BUF_SIZE ) );
39 void set_scan_string (const char * str) {
43 // Construct a token value for a non-obsolete token
44 #define RET_TOK(type, Enum, sym) \
45 llvmAsmlval.type = Instruction::Enum; \
48 // Construct a token value for an obsolete token
49 #define RET_TY(CTYPE, SYM) \
50 llvmAsmlval.PrimType = CTYPE;\
55 // TODO: All of the static identifiers are figured out by the lexer,
56 // these should be hashed to reduce the lexer size
59 // atoull - Convert an ascii string of decimal digits into the unsigned long
60 // long representation... this does not have to do input error checking,
61 // because we know that the input will be matched by a suitable regex...
63 static uint64_t atoull(const char *Buffer) {
65 for (; *Buffer; Buffer++) {
66 uint64_t OldRes = Result;
68 Result += *Buffer-'0';
69 if (Result < OldRes) // Uh, oh, overflow detected!!!
70 GenerateError("constant bigger than 64 bits detected!");
75 static uint64_t HexIntToVal(const char *Buffer) {
77 for (; *Buffer; ++Buffer) {
78 uint64_t OldRes = Result;
81 if (C >= '0' && C <= '9')
83 else if (C >= 'A' && C <= 'F')
85 else if (C >= 'a' && C <= 'f')
88 if (Result < OldRes) // Uh, oh, overflow detected!!!
89 GenerateError("constant bigger than 64 bits detected!");
95 // HexToFP - Convert the ascii string in hexidecimal format to the floating
96 // point representation of it.
98 static double HexToFP(const char *Buffer) {
99 return BitsToDouble(HexIntToVal(Buffer)); // Cast Hex constant to double
103 // UnEscapeLexed - Run through the specified buffer and change \xx codes to the
104 // appropriate character.
105 char *UnEscapeLexed(char *Buffer, char* EndBuffer) {
107 for (char *BIn = Buffer; *BIn; ) {
108 if (BIn[0] == '\\') {
109 if (BIn < EndBuffer-1 && BIn[1] == '\\') {
110 *BOut++ = '\\'; // Two \ becomes one
112 } else if (BIn < EndBuffer-2 && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
113 char Tmp = BIn[3]; BIn[3] = 0; // Terminate string
114 *BOut = (char)strtol(BIn+1, 0, 16); // Convert to number
115 BIn[3] = Tmp; // Restore character
116 BIn += 3; // Skip over handled chars
128 } // End llvm namespace
130 using namespace llvm;
132 #define YY_NEVER_INTERACTIVE 1
137 /* Comments start with a ; and go till end of line */
140 /* Local Values and Type identifiers start with a % sign */
141 LocalVarName %[-a-zA-Z$._][-a-zA-Z$._0-9]*
143 /* Global Value identifiers start with an @ sign */
144 GlobalVarName @[-a-zA-Z$._][-a-zA-Z$._0-9]*
146 /* Label identifiers end with a colon */
147 Label [-a-zA-Z$._0-9]+:
148 QuoteLabel \"[^\"]+\":
150 /* Quoted names can contain any character except " and \ */
151 StringConstant \"[^\"]*\"
152 AtStringConstant @\"[^\"]*\"
153 PctStringConstant %\"[^\"]*\"
155 /* LocalVarID/GlobalVarID: match an unnamed local variable slot ID. */
159 /* Integer types are specified with i and a bitwidth */
162 /* E[PN]Integer: match positive and negative literal integer values. */
166 /* FPConstant - A Floating point constant.
168 FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
170 /* HexFPConstant - Floating point constant represented in IEEE format as a
171 * hexadecimal number for when exponential notation is not precise enough.
173 HexFPConstant 0x[0-9A-Fa-f]+
175 /* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
176 * it to deal with 64 bit numbers.
178 HexIntConstant [us]0x[0-9A-Fa-f]+
182 {Comment} { /* Ignore comments for now */ }
184 begin { return BEGINTOK; }
185 end { return ENDTOK; }
186 true { return TRUETOK; }
187 false { return FALSETOK; }
188 declare { return DECLARE; }
189 define { return DEFINE; }
190 global { return GLOBAL; }
191 constant { return CONSTANT; }
192 internal { return INTERNAL; }
193 linkonce { return LINKONCE; }
194 weak { return WEAK; }
195 appending { return APPENDING; }
196 dllimport { return DLLIMPORT; }
197 dllexport { return DLLEXPORT; }
198 hidden { return HIDDEN; }
199 protected { return PROTECTED; }
200 extern_weak { return EXTERN_WEAK; }
201 external { return EXTERNAL; }
202 thread_local { return THREAD_LOCAL; }
203 zeroinitializer { return ZEROINITIALIZER; }
204 \.\.\. { return DOTDOTDOT; }
205 undef { return UNDEF; }
206 null { return NULL_TOK; }
208 tail { return TAIL; }
209 target { return TARGET; }
210 triple { return TRIPLE; }
211 deplibs { return DEPLIBS; }
212 datalayout { return DATALAYOUT; }
213 volatile { return VOLATILE; }
214 align { return ALIGN; }
215 section { return SECTION; }
216 alias { return ALIAS; }
217 module { return MODULE; }
218 asm { return ASM_TOK; }
219 sideeffect { return SIDEEFFECT; }
221 cc { return CC_TOK; }
222 ccc { return CCC_TOK; }
223 fastcc { return FASTCC_TOK; }
224 coldcc { return COLDCC_TOK; }
225 x86_stdcallcc { return X86_STDCALLCC_TOK; }
226 x86_fastcallcc { return X86_FASTCALLCC_TOK; }
228 inreg { return INREG; }
229 sret { return SRET; }
230 nounwind { return NOUNWIND; }
231 noreturn { return NORETURN; }
233 void { RET_TY(Type::VoidTy, VOID); }
234 float { RET_TY(Type::FloatTy, FLOAT); }
235 double { RET_TY(Type::DoubleTy,DOUBLE);}
236 label { RET_TY(Type::LabelTy, LABEL); }
237 type { return TYPE; }
238 opaque { return OPAQUE; }
239 {IntegerType} { uint64_t NumBits = atoull(yytext+1);
240 if (NumBits < IntegerType::MIN_INT_BITS ||
241 NumBits > IntegerType::MAX_INT_BITS)
242 GenerateError("Bitwidth for integer type out of range!");
243 const Type* Ty = IntegerType::get(NumBits);
247 add { RET_TOK(BinaryOpVal, Add, ADD); }
248 sub { RET_TOK(BinaryOpVal, Sub, SUB); }
249 mul { RET_TOK(BinaryOpVal, Mul, MUL); }
250 udiv { RET_TOK(BinaryOpVal, UDiv, UDIV); }
251 sdiv { RET_TOK(BinaryOpVal, SDiv, SDIV); }
252 fdiv { RET_TOK(BinaryOpVal, FDiv, FDIV); }
253 urem { RET_TOK(BinaryOpVal, URem, UREM); }
254 srem { RET_TOK(BinaryOpVal, SRem, SREM); }
255 frem { RET_TOK(BinaryOpVal, FRem, FREM); }
256 shl { RET_TOK(BinaryOpVal, Shl, SHL); }
257 lshr { RET_TOK(BinaryOpVal, LShr, LSHR); }
258 ashr { RET_TOK(BinaryOpVal, AShr, ASHR); }
259 and { RET_TOK(BinaryOpVal, And, AND); }
260 or { RET_TOK(BinaryOpVal, Or , OR ); }
261 xor { RET_TOK(BinaryOpVal, Xor, XOR); }
262 icmp { RET_TOK(OtherOpVal, ICmp, ICMP); }
263 fcmp { RET_TOK(OtherOpVal, FCmp, FCMP); }
286 phi { RET_TOK(OtherOpVal, PHI, PHI_TOK); }
287 call { RET_TOK(OtherOpVal, Call, CALL); }
288 trunc { RET_TOK(CastOpVal, Trunc, TRUNC); }
289 zext { RET_TOK(CastOpVal, ZExt, ZEXT); }
290 sext { RET_TOK(CastOpVal, SExt, SEXT); }
291 fptrunc { RET_TOK(CastOpVal, FPTrunc, FPTRUNC); }
292 fpext { RET_TOK(CastOpVal, FPExt, FPEXT); }
293 uitofp { RET_TOK(CastOpVal, UIToFP, UITOFP); }
294 sitofp { RET_TOK(CastOpVal, SIToFP, SITOFP); }
295 fptoui { RET_TOK(CastOpVal, FPToUI, FPTOUI); }
296 fptosi { RET_TOK(CastOpVal, FPToSI, FPTOSI); }
297 inttoptr { RET_TOK(CastOpVal, IntToPtr, INTTOPTR); }
298 ptrtoint { RET_TOK(CastOpVal, PtrToInt, PTRTOINT); }
299 bitcast { RET_TOK(CastOpVal, BitCast, BITCAST); }
300 select { RET_TOK(OtherOpVal, Select, SELECT); }
301 va_arg { RET_TOK(OtherOpVal, VAArg , VAARG); }
302 ret { RET_TOK(TermOpVal, Ret, RET); }
303 br { RET_TOK(TermOpVal, Br, BR); }
304 switch { RET_TOK(TermOpVal, Switch, SWITCH); }
305 invoke { RET_TOK(TermOpVal, Invoke, INVOKE); }
306 unwind { RET_TOK(TermOpVal, Unwind, UNWIND); }
307 unreachable { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
309 malloc { RET_TOK(MemOpVal, Malloc, MALLOC); }
310 alloca { RET_TOK(MemOpVal, Alloca, ALLOCA); }
311 free { RET_TOK(MemOpVal, Free, FREE); }
312 load { RET_TOK(MemOpVal, Load, LOAD); }
313 store { RET_TOK(MemOpVal, Store, STORE); }
314 getelementptr { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
316 extractelement { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
317 insertelement { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); }
318 shufflevector { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
322 llvmAsmlval.StrVal = new std::string(yytext+1); // Skip %
326 llvmAsmlval.StrVal = new std::string(yytext+1); // Skip @
330 yytext[yyleng-1] = 0; // nuke colon
331 llvmAsmlval.StrVal = new std::string(yytext);
335 yytext[yyleng-2] = 0; // nuke colon, end quote
336 const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng);
338 new std::string(yytext+1, EndChar - yytext - 1);
342 {StringConstant} { yytext[yyleng-1] = 0; // nuke end quote
343 const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng);
345 new std::string(yytext+1, EndChar - yytext - 1);
346 return STRINGCONSTANT;
349 yytext[yyleng-1] = 0; // nuke end quote
350 const char* EndChar =
351 UnEscapeLexed(yytext+2, yytext+yyleng);
353 new std::string(yytext+2, EndChar - yytext - 2);
354 return ATSTRINGCONSTANT;
356 {PctStringConstant} {
357 yytext[yyleng-1] = 0; // nuke end quote
358 const char* EndChar =
359 UnEscapeLexed(yytext+2, yytext+yyleng);
361 new std::string(yytext+2, EndChar - yytext - 2);
362 return PCTSTRINGCONSTANT;
365 uint32_t numBits = ((yyleng * 64) / 19) + 1;
366 APInt Tmp(numBits, yytext, yyleng, 10);
367 uint32_t activeBits = Tmp.getActiveBits();
368 if (activeBits > 0 && activeBits < numBits)
369 Tmp.trunc(activeBits);
370 if (Tmp.getBitWidth() > 64) {
371 llvmAsmlval.APIntVal = new APInt(Tmp);
374 llvmAsmlval.UInt64Val = Tmp.getZExtValue();
379 uint32_t numBits = (((yyleng-1) * 64) / 19) + 2;
380 APInt Tmp(numBits, yytext, yyleng, 10);
381 uint32_t minBits = Tmp.getMinSignedBits();
382 if (minBits > 0 && minBits < numBits)
384 if (Tmp.getBitWidth() > 64) {
385 llvmAsmlval.APIntVal = new APInt(Tmp);
388 llvmAsmlval.SInt64Val = Tmp.getSExtValue();
393 {HexIntConstant} { int len = yyleng - 3;
394 uint32_t bits = len * 4;
395 APInt Tmp(bits, yytext+3, len, 16);
396 uint32_t activeBits = Tmp.getActiveBits();
397 if (activeBits > 0 && activeBits < bits)
398 Tmp.trunc(activeBits);
399 if (Tmp.getBitWidth() > 64) {
400 llvmAsmlval.APIntVal = new APInt(Tmp);
401 return yytext[0] == 's' ? ESAPINTVAL : EUAPINTVAL;
402 } else if (yytext[0] == 's') {
403 llvmAsmlval.SInt64Val = Tmp.getSExtValue();
406 llvmAsmlval.UInt64Val = Tmp.getZExtValue();
412 uint64_t Val = atoull(yytext+1);
413 if ((unsigned)Val != Val)
414 GenerateError("Invalid value number (too large)!");
415 llvmAsmlval.UIntVal = unsigned(Val);
419 uint64_t Val = atoull(yytext+1);
420 if ((unsigned)Val != Val)
421 GenerateError("Invalid value number (too large)!");
422 llvmAsmlval.UIntVal = unsigned(Val);
426 {FPConstant} { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
427 {HexFPConstant} { llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; }
430 /* Make sure to free the internal buffers for flex when we are
431 * done reading our input!
433 yy_delete_buffer(YY_CURRENT_BUFFER);
437 [ \r\t\n] { /* Ignore whitespace */ }
438 . { return yytext[0]; }