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 signext { return SIGNEXT; }
229 zeroext { return ZEROEXT; }
230 inreg { return INREG; }
231 sret { return SRET; }
232 nounwind { return NOUNWIND; }
233 noreturn { return NORETURN; }
234 noalias { return NOALIAS; }
235 byval { return BYVAL; }
237 void { RET_TY(Type::VoidTy, VOID); }
238 float { RET_TY(Type::FloatTy, FLOAT); }
239 double { RET_TY(Type::DoubleTy,DOUBLE);}
240 label { RET_TY(Type::LabelTy, LABEL); }
241 type { return TYPE; }
242 opaque { return OPAQUE; }
243 {IntegerType} { uint64_t NumBits = atoull(yytext+1);
244 if (NumBits < IntegerType::MIN_INT_BITS ||
245 NumBits > IntegerType::MAX_INT_BITS)
246 GenerateError("Bitwidth for integer type out of range!");
247 const Type* Ty = IntegerType::get(NumBits);
251 add { RET_TOK(BinaryOpVal, Add, ADD); }
252 sub { RET_TOK(BinaryOpVal, Sub, SUB); }
253 mul { RET_TOK(BinaryOpVal, Mul, MUL); }
254 udiv { RET_TOK(BinaryOpVal, UDiv, UDIV); }
255 sdiv { RET_TOK(BinaryOpVal, SDiv, SDIV); }
256 fdiv { RET_TOK(BinaryOpVal, FDiv, FDIV); }
257 urem { RET_TOK(BinaryOpVal, URem, UREM); }
258 srem { RET_TOK(BinaryOpVal, SRem, SREM); }
259 frem { RET_TOK(BinaryOpVal, FRem, FREM); }
260 shl { RET_TOK(BinaryOpVal, Shl, SHL); }
261 lshr { RET_TOK(BinaryOpVal, LShr, LSHR); }
262 ashr { RET_TOK(BinaryOpVal, AShr, ASHR); }
263 and { RET_TOK(BinaryOpVal, And, AND); }
264 or { RET_TOK(BinaryOpVal, Or , OR ); }
265 xor { RET_TOK(BinaryOpVal, Xor, XOR); }
266 icmp { RET_TOK(OtherOpVal, ICmp, ICMP); }
267 fcmp { RET_TOK(OtherOpVal, FCmp, FCMP); }
290 phi { RET_TOK(OtherOpVal, PHI, PHI_TOK); }
291 call { RET_TOK(OtherOpVal, Call, CALL); }
292 trunc { RET_TOK(CastOpVal, Trunc, TRUNC); }
293 zext { RET_TOK(CastOpVal, ZExt, ZEXT); }
294 sext { RET_TOK(CastOpVal, SExt, SEXT); }
295 fptrunc { RET_TOK(CastOpVal, FPTrunc, FPTRUNC); }
296 fpext { RET_TOK(CastOpVal, FPExt, FPEXT); }
297 uitofp { RET_TOK(CastOpVal, UIToFP, UITOFP); }
298 sitofp { RET_TOK(CastOpVal, SIToFP, SITOFP); }
299 fptoui { RET_TOK(CastOpVal, FPToUI, FPTOUI); }
300 fptosi { RET_TOK(CastOpVal, FPToSI, FPTOSI); }
301 inttoptr { RET_TOK(CastOpVal, IntToPtr, INTTOPTR); }
302 ptrtoint { RET_TOK(CastOpVal, PtrToInt, PTRTOINT); }
303 bitcast { RET_TOK(CastOpVal, BitCast, BITCAST); }
304 select { RET_TOK(OtherOpVal, Select, SELECT); }
305 va_arg { RET_TOK(OtherOpVal, VAArg , VAARG); }
306 ret { RET_TOK(TermOpVal, Ret, RET); }
307 br { RET_TOK(TermOpVal, Br, BR); }
308 switch { RET_TOK(TermOpVal, Switch, SWITCH); }
309 invoke { RET_TOK(TermOpVal, Invoke, INVOKE); }
310 unwind { RET_TOK(TermOpVal, Unwind, UNWIND); }
311 unreachable { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
313 malloc { RET_TOK(MemOpVal, Malloc, MALLOC); }
314 alloca { RET_TOK(MemOpVal, Alloca, ALLOCA); }
315 free { RET_TOK(MemOpVal, Free, FREE); }
316 load { RET_TOK(MemOpVal, Load, LOAD); }
317 store { RET_TOK(MemOpVal, Store, STORE); }
318 getelementptr { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
320 extractelement { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
321 insertelement { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); }
322 shufflevector { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
326 llvmAsmlval.StrVal = new std::string(yytext+1); // Skip %
330 llvmAsmlval.StrVal = new std::string(yytext+1); // Skip @
334 yytext[yyleng-1] = 0; // nuke colon
335 llvmAsmlval.StrVal = new std::string(yytext);
339 yytext[yyleng-2] = 0; // nuke colon, end quote
340 const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng);
342 new std::string(yytext+1, EndChar - yytext - 1);
346 {StringConstant} { yytext[yyleng-1] = 0; // nuke end quote
347 const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng);
349 new std::string(yytext+1, EndChar - yytext - 1);
350 return STRINGCONSTANT;
353 yytext[yyleng-1] = 0; // nuke end quote
354 const char* EndChar =
355 UnEscapeLexed(yytext+2, yytext+yyleng);
357 new std::string(yytext+2, EndChar - yytext - 2);
358 return ATSTRINGCONSTANT;
360 {PctStringConstant} {
361 yytext[yyleng-1] = 0; // nuke end quote
362 const char* EndChar =
363 UnEscapeLexed(yytext+2, yytext+yyleng);
365 new std::string(yytext+2, EndChar - yytext - 2);
366 return PCTSTRINGCONSTANT;
369 uint32_t numBits = ((yyleng * 64) / 19) + 1;
370 APInt Tmp(numBits, yytext, yyleng, 10);
371 uint32_t activeBits = Tmp.getActiveBits();
372 if (activeBits > 0 && activeBits < numBits)
373 Tmp.trunc(activeBits);
374 if (Tmp.getBitWidth() > 64) {
375 llvmAsmlval.APIntVal = new APInt(Tmp);
378 llvmAsmlval.UInt64Val = Tmp.getZExtValue();
383 uint32_t numBits = (((yyleng-1) * 64) / 19) + 2;
384 APInt Tmp(numBits, yytext, yyleng, 10);
385 uint32_t minBits = Tmp.getMinSignedBits();
386 if (minBits > 0 && minBits < numBits)
388 if (Tmp.getBitWidth() > 64) {
389 llvmAsmlval.APIntVal = new APInt(Tmp);
392 llvmAsmlval.SInt64Val = Tmp.getSExtValue();
397 {HexIntConstant} { int len = yyleng - 3;
398 uint32_t bits = len * 4;
399 APInt Tmp(bits, yytext+3, len, 16);
400 uint32_t activeBits = Tmp.getActiveBits();
401 if (activeBits > 0 && activeBits < bits)
402 Tmp.trunc(activeBits);
403 if (Tmp.getBitWidth() > 64) {
404 llvmAsmlval.APIntVal = new APInt(Tmp);
405 return yytext[0] == 's' ? ESAPINTVAL : EUAPINTVAL;
406 } else if (yytext[0] == 's') {
407 llvmAsmlval.SInt64Val = Tmp.getSExtValue();
410 llvmAsmlval.UInt64Val = Tmp.getZExtValue();
416 uint64_t Val = atoull(yytext+1);
417 if ((unsigned)Val != Val)
418 GenerateError("Invalid value number (too large)!");
419 llvmAsmlval.UIntVal = unsigned(Val);
423 uint64_t Val = atoull(yytext+1);
424 if ((unsigned)Val != Val)
425 GenerateError("Invalid value number (too large)!");
426 llvmAsmlval.UIntVal = unsigned(Val);
430 {FPConstant} { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
431 {HexFPConstant} { llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; }
434 /* Make sure to free the internal buffers for flex when we are
435 * done reading our input!
437 yy_delete_buffer(YY_CURRENT_BUFFER);
441 [ \r\t\n] { /* Ignore whitespace */ }
442 . { return yytext[0]; }