X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FLexer.l;h=382ce24462a732dc6a9964faca8eda6882c875dc;hb=4989b842718e0ca1643a906dedda433b9a2c0679;hp=85852e2851391d7098fb0216507bfd469304853a;hpb=7a5a1f790f7a3912a9963c11f720b37ebb65056a;p=oota-llvm.git diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l index 85852e28513..382ce24462a 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,34 @@ #include "llvm/Module.h" #include #include "llvmAsmParser.h" -#include -#include +#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); +} +// Construct a token value for a non-obsolete token #define RET_TOK(type, Enum, sym) \ - llvmAsmlval.type = Instruction::Enum; return sym + llvmAsmlval.type = Instruction::Enum; \ + return sym +// Construct a token value for an obsolete token +#define RET_TY(CTYPE, SYM) \ + llvmAsmlval.PrimType = CTYPE;\ + return SYM -// TODO: All of the static identifiers are figured out by the lexer, +namespace llvm { + +// 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) { @@ -44,7 +66,7 @@ static uint64_t atoull(const char *Buffer) { Result *= 10; Result += *Buffer-'0'; if (Result < OldRes) // Uh, oh, overflow detected!!! - ThrowException("constant bigger than 64 bits detected!"); + GenerateError("constant bigger than 64 bits detected!"); } return Result; } @@ -63,7 +85,7 @@ static uint64_t HexIntToVal(const char *Buffer) { Result += C-'a'+10; if (Result < OldRes) // Uh, oh, overflow detected!!! - ThrowException("constant bigger than 64 bits detected!"); + GenerateError("constant bigger than 64 bits detected!"); } return Result; } @@ -99,10 +121,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!"); - + GenerateError("String literal cannot accept \\00 escape!"); + BIn[3] = Tmp; // Restore character BIn += 3; // Skip over handled chars ++BOut; @@ -114,6 +136,10 @@ char *UnEscapeLexed(char *Buffer, bool AllowNull) { return BOut; } +} // End llvm namespace + +using namespace llvm; + #define YY_NEVER_INTERACTIVE 1 %} @@ -122,24 +148,28 @@ char *UnEscapeLexed(char *Buffer, bool AllowNull) { /* Comments start with a ; and go till end of line */ Comment ;.* -/* Variable(Value) identifiers start with a % sign */ -VarID %[-a-zA-Z$._][-a-zA-Z$._0-9]* +/* Local Values and Type identifiers start with a % sign */ +LocalVarName %[-a-zA-Z$._][-a-zA-Z$._0-9]* + +/* Global Value identifiers start with an @ sign */ +GlobalVarName @[-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 \"[^\"]+\" - - -/* [PN]Integer: match positive and negative literal integer values that - * are preceeded by a '%' character. These represent unnamed variable slots. - */ -EPInteger %[0-9]+ -ENInteger %-[0-9]+ +StringConstant \"[^\"]*\" +AtStringConstant @\"[^\"]*\" + +/* LocalVarID/GlobalVarID: match an unnamed local variable slot ID. */ +LocalVarID %[0-9]+ +GlobalVarID @[0-9]+ +/* Integer types are specified with i and a bitwidth */ +IntegerType i[0-9]+ -/* E[PN]Integer: match positive and negative literal integer values */ +/* E[PN]Integer: match positive and negative literal integer values. */ PInteger [0-9]+ NInteger -[0-9]+ @@ -156,77 +186,134 @@ HexFPConstant 0x[0-9A-Fa-f]+ * it to deal with 64 bit numbers. */ HexIntConstant [us]0x[0-9A-Fa-f]+ + %% {Comment} { /* Ignore comments for now */ } begin { return BEGINTOK; } end { return ENDTOK; } -true { return TRUE; } -false { return FALSE; } +true { return TRUETOK; } +false { return FALSETOK; } declare { return DECLARE; } +define { return DEFINE; } global { return GLOBAL; } constant { return CONSTANT; } -const { return CONST; } internal { return INTERNAL; } linkonce { return LINKONCE; } +weak { return WEAK; } appending { return APPENDING; } -uninitialized { return EXTERNAL; } /* Deprecated, turn into external */ +dllimport { return DLLIMPORT; } +dllexport { return DLLEXPORT; } +hidden { return HIDDEN; } +extern_weak { return EXTERN_WEAK; } external { return EXTERNAL; } -implementation { return IMPLEMENTATION; } +thread_local { return THREAD_LOCAL; } +zeroinitializer { return ZEROINITIALIZER; } \.\.\. { return DOTDOTDOT; } +undef { return UNDEF; } null { return NULL_TOK; } to { return TO; } -except { return EXCEPT; } -not { return NOT; } /* Deprecated, turned into XOR */ +tail { return TAIL; } target { return TARGET; } -endian { return ENDIAN; } -pointersize { return POINTERSIZE; } -little { return LITTLE; } -big { return BIG; } - -void { llvmAsmlval.PrimType = Type::VoidTy ; return VOID; } -bool { llvmAsmlval.PrimType = Type::BoolTy ; return BOOL; } -sbyte { llvmAsmlval.PrimType = Type::SByteTy ; return SBYTE; } -ubyte { llvmAsmlval.PrimType = Type::UByteTy ; return UBYTE; } -short { llvmAsmlval.PrimType = Type::ShortTy ; return SHORT; } -ushort { llvmAsmlval.PrimType = Type::UShortTy; return USHORT; } -int { llvmAsmlval.PrimType = Type::IntTy ; return INT; } -uint { llvmAsmlval.PrimType = Type::UIntTy ; return UINT; } -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; } +triple { return TRIPLE; } +deplibs { return DEPLIBS; } +datalayout { return DATALAYOUT; } +volatile { return VOLATILE; } +align { return ALIGN; } +section { return SECTION; } +alias { return ALIAS; } +module { return MODULE; } +asm { return ASM_TOK; } +sideeffect { return SIDEEFFECT; } + +cc { return CC_TOK; } +ccc { return CCC_TOK; } +fastcc { return FASTCC_TOK; } +coldcc { return COLDCC_TOK; } +x86_stdcallcc { return X86_STDCALLCC_TOK; } +x86_fastcallcc { return X86_FASTCALLCC_TOK; } + +inreg { return INREG; } +sret { return SRET; } +nounwind { return NOUNWIND; } +noreturn { return NORETURN; } + +void { RET_TY(Type::VoidTy, VOID); } +float { RET_TY(Type::FloatTy, FLOAT); } +double { RET_TY(Type::DoubleTy,DOUBLE);} +label { RET_TY(Type::LabelTy, LABEL); } +type { return TYPE; } opaque { return OPAQUE; } +{IntegerType} { uint64_t NumBits = atoull(yytext+1); + if (NumBits < IntegerType::MIN_INT_BITS || + NumBits > IntegerType::MAX_INT_BITS) + GenerateError("Bitwidth for integer type out of range!"); + const Type* Ty = IntegerType::get(NumBits); + RET_TY(Ty, INTTYPE); + } add { RET_TOK(BinaryOpVal, Add, ADD); } sub { RET_TOK(BinaryOpVal, Sub, SUB); } mul { RET_TOK(BinaryOpVal, Mul, MUL); } -div { RET_TOK(BinaryOpVal, Div, DIV); } -rem { RET_TOK(BinaryOpVal, Rem, REM); } +udiv { RET_TOK(BinaryOpVal, UDiv, UDIV); } +sdiv { RET_TOK(BinaryOpVal, SDiv, SDIV); } +fdiv { RET_TOK(BinaryOpVal, FDiv, FDIV); } +urem { RET_TOK(BinaryOpVal, URem, UREM); } +srem { RET_TOK(BinaryOpVal, SRem, SREM); } +frem { RET_TOK(BinaryOpVal, FRem, FREM); } +shl { RET_TOK(BinaryOpVal, Shl, SHL); } +lshr { RET_TOK(BinaryOpVal, LShr, LSHR); } +ashr { RET_TOK(BinaryOpVal, AShr, ASHR); } and { RET_TOK(BinaryOpVal, And, AND); } or { RET_TOK(BinaryOpVal, Or , OR ); } xor { RET_TOK(BinaryOpVal, Xor, XOR); } -setne { RET_TOK(BinaryOpVal, SetNE, SETNE); } -seteq { RET_TOK(BinaryOpVal, SetEQ, SETEQ); } -setlt { RET_TOK(BinaryOpVal, SetLT, SETLT); } -setgt { RET_TOK(BinaryOpVal, SetGT, SETGT); } -setle { RET_TOK(BinaryOpVal, SetLE, SETLE); } -setge { RET_TOK(BinaryOpVal, SetGE, SETGE); } - -phi { RET_TOK(OtherOpVal, PHINode, PHI); } +icmp { RET_TOK(OtherOpVal, ICmp, ICMP); } +fcmp { RET_TOK(OtherOpVal, FCmp, FCMP); } + +eq { return EQ; } +ne { return NE; } +slt { return SLT; } +sgt { return SGT; } +sle { return SLE; } +sge { return SGE; } +ult { return ULT; } +ugt { return UGT; } +ule { return ULE; } +uge { return UGE; } +oeq { return OEQ; } +one { return ONE; } +olt { return OLT; } +ogt { return OGT; } +ole { return OLE; } +oge { return OGE; } +ord { return ORD; } +uno { return UNO; } +ueq { return UEQ; } +une { return UNE; } + +phi { RET_TOK(OtherOpVal, PHI, PHI_TOK); } call { RET_TOK(OtherOpVal, Call, CALL); } -cast { RET_TOK(OtherOpVal, Cast, CAST); } -shl { RET_TOK(OtherOpVal, Shl, SHL); } -shr { RET_TOK(OtherOpVal, Shr, SHR); } - +trunc { RET_TOK(CastOpVal, Trunc, TRUNC); } +zext { RET_TOK(CastOpVal, ZExt, ZEXT); } +sext { RET_TOK(CastOpVal, SExt, SEXT); } +fptrunc { RET_TOK(CastOpVal, FPTrunc, FPTRUNC); } +fpext { RET_TOK(CastOpVal, FPExt, FPEXT); } +uitofp { RET_TOK(CastOpVal, UIToFP, UITOFP); } +sitofp { RET_TOK(CastOpVal, SIToFP, SITOFP); } +fptoui { RET_TOK(CastOpVal, FPToUI, FPTOUI); } +fptosi { RET_TOK(CastOpVal, FPToSI, FPTOSI); } +inttoptr { RET_TOK(CastOpVal, IntToPtr, INTTOPTR); } +ptrtoint { RET_TOK(CastOpVal, PtrToInt, PTRTOINT); } +bitcast { RET_TOK(CastOpVal, BitCast, BITCAST); } +select { RET_TOK(OtherOpVal, Select, SELECT); } +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); } @@ -235,58 +322,123 @@ load { RET_TOK(MemOpVal, Load, LOAD); } store { RET_TOK(MemOpVal, Store, STORE); } getelementptr { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); } +extractelement { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); } +insertelement { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); } +shufflevector { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); } -{VarID} { + +{LocalVarName} { UnEscapeLexed(yytext+1); llvmAsmlval.StrVal = strdup(yytext+1); // Skip % - return VAR_ID; + return LOCALVAR; + } +{GlobalVarName} { + UnEscapeLexed(yytext+1); + llvmAsmlval.StrVal = strdup(yytext+1); // Skip @ + return GLOBALVAR; } {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; } +{AtStringConstant} { + yytext[strlen(yytext)-1] = 0; // nuke end quote + llvmAsmlval.StrVal = strdup(yytext+2); // Nuke @, quote + return ATSTRINGCONSTANT; + } + +{PInteger} { int len = strlen(yytext); + uint32_t numBits = ((len * 64) / 19) + 1; + APInt Tmp(numBits, yytext, len, 10); + uint32_t activeBits = Tmp.getActiveBits(); + if (activeBits > 0 && activeBits < numBits) + Tmp.trunc(activeBits); + if (Tmp.getBitWidth() > 64) { + llvmAsmlval.APIntVal = new APInt(Tmp); + return EUAPINTVAL; + } else { + llvmAsmlval.UInt64Val = Tmp.getZExtValue(); + return EUINT64VAL; + } + } +{NInteger} { int len = strlen(yytext); + uint32_t numBits = (((len-1) * 64) / 19) + 2; + APInt Tmp(numBits, yytext, len, 10); + uint32_t minBits = Tmp.getMinSignedBits(); + if (minBits > 0 && minBits < numBits) + Tmp.trunc(minBits); + if (Tmp.getBitWidth() > 64) { + llvmAsmlval.APIntVal = new APInt(Tmp); + return ESAPINTVAL; + } else { + llvmAsmlval.SInt64Val = Tmp.getSExtValue(); + return ESINT64VAL; + } + } +{HexIntConstant} { int len = strlen(yytext+3) - 3; + uint32_t bits = len * 4; + APInt Tmp(bits, yytext+3, len, 16); + uint32_t activeBits = Tmp.getActiveBits(); + if (activeBits > 0 && activeBits < bits) + Tmp.trunc(activeBits); + if (Tmp.getBitWidth() > 64) { + llvmAsmlval.APIntVal = new APInt(Tmp); + return yytext[0] == 's' ? ESAPINTVAL : EUAPINTVAL; + } else if (yytext[0] == 's') { + llvmAsmlval.SInt64Val = Tmp.getSExtValue(); + return ESINT64VAL; + } else { + llvmAsmlval.UInt64Val = Tmp.getZExtValue(); + return EUINT64VAL; + } + } -{PInteger} { llvmAsmlval.UInt64Val = atoull(yytext); return EUINT64VAL; } -{NInteger} { +{LocalVarID} { 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; + if ((unsigned)Val != Val) + GenerateError("Invalid value number (too large)!"); + llvmAsmlval.UIntVal = unsigned(Val); + return LOCALVAL_ID; } -{HexIntConstant} { - llvmAsmlval.UInt64Val = HexIntToVal(yytext+3); - return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL; - } - -{EPInteger} { llvmAsmlval.UIntVal = atoull(yytext+1); 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; +{GlobalVarID} { + uint64_t Val = atoull(yytext+1); + if ((unsigned)Val != Val) + GenerateError("Invalid value number (too large)!"); + llvmAsmlval.UIntVal = unsigned(Val); + return GLOBALVAL_ID; } {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]; } %%