Inform the dag combiner that the predicate compares only return a low bit.

[oota-llvm.git] / lib / AsmParser / Lexer.l

diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l
index 93e309260b6f8a97534b45ea2acddd1ad2b7d0c7..2fa4ec11ea851cd92f1da4e946dd61d37a3b83db 100644 (file)
--- a/lib/AsmParser/Lexer.l
+++ b/lib/AsmParser/Lexer.l
@@ -1,10 +1,10 @@
 /*===-- 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.
@@ -32,17 +32,24 @@
 #include <cctype>
 #include <cstdlib>
 
+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) {
@@ -110,7 +117,7 @@ char *UnEscapeLexed(char *Buffer, bool AllowNull) {
       *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;
@@ -194,6 +201,7 @@ null            { return NULL_TOK; }
 to              { return TO; }
 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; }
@@ -202,6 +210,16 @@ pointersize     { return POINTERSIZE; }
 little          { return LITTLE; }
 big             { return BIG; }
 volatile        { return VOLATILE; }
+align           { return ALIGN;  }
+section         { return SECTION; }
+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; }
 
 void            { llvmAsmlval.PrimType = Type::VoidTy  ; return VOID;   }
 bool            { llvmAsmlval.PrimType = Type::BoolTy  ; return BOOL;   }
@@ -240,9 +258,9 @@ cast            { RET_TOK(OtherOpVal, Cast, CAST); }
 select          { RET_TOK(OtherOpVal, Select, SELECT); }
 shl             { RET_TOK(OtherOpVal, Shl, SHL); }
 shr             { RET_TOK(OtherOpVal, Shr, SHR); }
-vanext          { RET_TOK(OtherOpVal, VANext, VANEXT); }
-vaarg           { RET_TOK(OtherOpVal, VAArg , VAARG); }
-
+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); }
@@ -257,47 +275,50 @@ 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); }
+
 
 {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; 
+                  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;
                  }
 
@@ -310,11 +331,11 @@ getelementptr   { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
                 }
 {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!");
+                  // +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;
+                  return SINTVAL;
                 }
 
 {FPConstant}    { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
@@ -332,3 +353,4 @@ getelementptr   { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
 .               { return yytext[0]; }
 
 %%
+