X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FLexer.l;h=9a2c5a347244bad83b3b335b6716871e6fcb2739;hb=0b118206bf3411722707f2e5cab8fd2eedcd50d6;hp=0a9d2c3e8f9b49762496b54e3bf6547d2f63d046;hpb=f797cabedff00365ffbb096e8d8cfcdb7535e97f;p=oota-llvm.git diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l index 0a9d2c3e8f9..9a2c5a34724 100644 --- a/lib/AsmParser/Lexer.l +++ b/lib/AsmParser/Lexer.l @@ -1,5 +1,12 @@ /*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===// // +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// // This file implements the flex scanner for LLVM assembly languages files. // //===----------------------------------------------------------------------===*/ @@ -22,19 +29,27 @@ #include "llvm/Module.h" #include #include "llvmAsmParser.h" -#include -#include "Config/stdlib.h" +#include +#include + +void set_scan_file(FILE * F){ + yy_switch_to_buffer(yy_create_buffer( F, YY_BUF_SIZE ) ); +} +void set_scan_string (const char * str) { + yy_scan_string (str); +} #define RET_TOK(type, Enum, sym) \ llvmAsmlval.type = Instruction::Enum; return sym +namespace llvm { -// TODO: All of the static identifiers are figured out by the lexer, +// TODO: All of the static identifiers are figured out by the lexer, // these should be hashed to reduce the lexer size // atoull - Convert an ascii string of decimal digits into the unsigned long -// long representation... this does not have to do input error checking, +// long representation... this does not have to do input error checking, // because we know that the input will be matched by a suitable regex... // static uint64_t atoull(const char *Buffer) { @@ -99,10 +114,10 @@ char *UnEscapeLexed(char *Buffer, bool AllowNull) { for (char *BIn = Buffer; *BIn; ) { if (BIn[0] == '\\' && isxdigit(BIn[1]) && isxdigit(BIn[2])) { char Tmp = BIn[3]; BIn[3] = 0; // Terminate string - *BOut = strtol(BIn+1, 0, 16); // Convert to number + *BOut = (char)strtol(BIn+1, 0, 16); // Convert to number if (!AllowNull && !*BOut) ThrowException("String literal cannot accept \\00 escape!"); - + BIn[3] = Tmp; // Restore character BIn += 3; // Skip over handled chars ++BOut; @@ -114,6 +129,10 @@ char *UnEscapeLexed(char *Buffer, bool AllowNull) { return BOut; } +} // End llvm namespace + +using namespace llvm; + #define YY_NEVER_INTERACTIVE 1 %} @@ -127,9 +146,10 @@ VarID %[-a-zA-Z$._][-a-zA-Z$._0-9]* /* Label identifiers end with a colon */ Label [-a-zA-Z$._0-9]+: +QuoteLabel \"[^\"]+\": /* Quoted names can contain any character except " and \ */ -StringConstant \"[^\"]+\" +StringConstant \"[^\"]*\" /* [PN]Integer: match positive and negative literal integer values that @@ -162,12 +182,11 @@ HexIntConstant [us]0x[0-9A-Fa-f]+ begin { return BEGINTOK; } end { return ENDTOK; } -true { return TRUE; } -false { return FALSE; } +true { return TRUETOK; } +false { return FALSETOK; } declare { return DECLARE; } global { return GLOBAL; } constant { return CONSTANT; } -const { return CONST; } internal { return INTERNAL; } linkonce { return LINKONCE; } weak { return WEAK; } @@ -177,16 +196,27 @@ external { return EXTERNAL; } implementation { return IMPLEMENTATION; } zeroinitializer { return ZEROINITIALIZER; } \.\.\. { return DOTDOTDOT; } +undef { return UNDEF; } null { return NULL_TOK; } to { return TO; } -except { return EXCEPT; } +except { RET_TOK(TermOpVal, Unwind, UNWIND); } not { return NOT; } /* Deprecated, turned into XOR */ +tail { return TAIL; } target { return TARGET; } +triple { return TRIPLE; } +deplibs { return DEPLIBS; } endian { return ENDIAN; } pointersize { return POINTERSIZE; } little { return LITTLE; } big { return BIG; } volatile { return VOLATILE; } +align { return ALIGN; } +section { return SECTION; } + +cc { return CC_TOK; } +ccc { return CCC_TOK; } +fastcc { return FASTCC_TOK; } +coldcc { return COLDCC_TOK; } void { llvmAsmlval.PrimType = Type::VoidTy ; return VOID; } bool { llvmAsmlval.PrimType = Type::BoolTy ; return BOOL; } @@ -200,8 +230,8 @@ long { llvmAsmlval.PrimType = Type::LongTy ; return LONG; } ulong { llvmAsmlval.PrimType = Type::ULongTy ; return ULONG; } float { llvmAsmlval.PrimType = Type::FloatTy ; return FLOAT; } double { llvmAsmlval.PrimType = Type::DoubleTy; return DOUBLE; } -type { llvmAsmlval.PrimType = Type::TypeTy ; return TYPE; } label { llvmAsmlval.PrimType = Type::LabelTy ; return LABEL; } +type { return TYPE; } opaque { return OPAQUE; } add { RET_TOK(BinaryOpVal, Add, ADD); } @@ -219,19 +249,21 @@ setgt { RET_TOK(BinaryOpVal, SetGT, SETGT); } setle { RET_TOK(BinaryOpVal, SetLE, SETLE); } setge { RET_TOK(BinaryOpVal, SetGE, SETGE); } -phi { RET_TOK(OtherOpVal, PHINode, PHI); } +phi { RET_TOK(OtherOpVal, PHI, PHI_TOK); } call { RET_TOK(OtherOpVal, Call, CALL); } cast { RET_TOK(OtherOpVal, Cast, CAST); } +select { RET_TOK(OtherOpVal, Select, SELECT); } shl { RET_TOK(OtherOpVal, Shl, SHL); } shr { RET_TOK(OtherOpVal, Shr, SHR); } -va_arg { RET_TOK(OtherOpVal, VarArg, VA_ARG); } - +vanext { return VANEXT_old; } +vaarg { return VAARG_old; } +va_arg { RET_TOK(OtherOpVal, VAArg , VAARG); } ret { RET_TOK(TermOpVal, Ret, RET); } br { RET_TOK(TermOpVal, Br, BR); } switch { RET_TOK(TermOpVal, Switch, SWITCH); } invoke { RET_TOK(TermOpVal, Invoke, INVOKE); } unwind { RET_TOK(TermOpVal, Unwind, UNWIND); } - +unreachable { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); } malloc { RET_TOK(MemOpVal, Malloc, MALLOC); } alloca { RET_TOK(MemOpVal, Alloca, ALLOCA); } @@ -240,58 +272,80 @@ load { RET_TOK(MemOpVal, Load, LOAD); } store { RET_TOK(MemOpVal, Store, STORE); } getelementptr { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); } +extractelement { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); } + {VarID} { UnEscapeLexed(yytext+1); llvmAsmlval.StrVal = strdup(yytext+1); // Skip % - return VAR_ID; + return VAR_ID; } {Label} { yytext[strlen(yytext)-1] = 0; // nuke colon UnEscapeLexed(yytext); - llvmAsmlval.StrVal = strdup(yytext); - return LABELSTR; + llvmAsmlval.StrVal = strdup(yytext); + return LABELSTR; + } +{QuoteLabel} { + yytext[strlen(yytext)-2] = 0; // nuke colon, end quote + UnEscapeLexed(yytext+1); + llvmAsmlval.StrVal = strdup(yytext+1); + return LABELSTR; } {StringConstant} { // Note that we cannot unescape a string constant here! The - // string constant might contain a \00 which would not be + // string constant might contain a \00 which would not be // understood by the string stuff. It is valid to make a // [sbyte] c"Hello World\00" constant, for example. // - yytext[strlen(yytext)-1] = 0; // nuke end quote - llvmAsmlval.StrVal = strdup(yytext+1); // Nuke start quote - return STRINGCONSTANT; + yytext[strlen(yytext)-1] = 0; // nuke end quote + llvmAsmlval.StrVal = strdup(yytext+1); // Nuke start quote + return STRINGCONSTANT; } {PInteger} { llvmAsmlval.UInt64Val = atoull(yytext); return EUINT64VAL; } -{NInteger} { +{NInteger} { uint64_t Val = atoull(yytext+1); - // +1: we have bigger negative range - if (Val > (uint64_t)INT64_MAX+1) - ThrowException("Constant too large for signed 64 bits!"); - llvmAsmlval.SInt64Val = -Val; - return ESINT64VAL; + // +1: we have bigger negative range + if (Val > (uint64_t)INT64_MAX+1) + ThrowException("Constant too large for signed 64 bits!"); + llvmAsmlval.SInt64Val = -Val; + return ESINT64VAL; } {HexIntConstant} { - llvmAsmlval.UInt64Val = HexIntToVal(yytext+3); + llvmAsmlval.UInt64Val = HexIntToVal(yytext+3); return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL; } -{EPInteger} { llvmAsmlval.UIntVal = atoull(yytext+1); return UINTVAL; } +{EPInteger} { + uint64_t Val = atoull(yytext+1); + if ((unsigned)Val != Val) + ThrowException("Invalid value number (too large)!"); + llvmAsmlval.UIntVal = unsigned(Val); + return UINTVAL; + } {ENInteger} { uint64_t Val = atoull(yytext+2); - // +1: we have bigger negative range - if (Val > (uint64_t)INT32_MAX+1) - ThrowException("Constant too large for signed 32 bits!"); - llvmAsmlval.SIntVal = -Val; - return SINTVAL; + // +1: we have bigger negative range + if (Val > (uint64_t)INT32_MAX+1) + ThrowException("Constant too large for signed 32 bits!"); + llvmAsmlval.SIntVal = (int)-Val; + return SINTVAL; } {FPConstant} { llvmAsmlval.FPVal = atof(yytext); return FPVAL; } {HexFPConstant} { llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; } -[ \t\n] { /* Ignore whitespace */ } +<> { + /* Make sure to free the internal buffers for flex when we are + * done reading our input! + */ + yy_delete_buffer(YY_CURRENT_BUFFER); + return EOF; + } + +[ \r\t\n] { /* Ignore whitespace */ } . { return yytext[0]; } %%