Added LLVM copyright header.

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

diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l
index a5cb4eff2658dbab93caadd7fc94a36aeb2048f5..6466cb721b760748162442ffa8972d70c281461f 100644 (file)
--- a/lib/AsmParser/Lexer.l
+++ b/lib/AsmParser/Lexer.l
@@ -1,8 +1,15 @@
-/*===-- Lexer.l - Scanner for llvm assembly files ----------------*- C++ -*--=//
+/*===-- 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.
 //
-//===------------------------------------------------------------------------=*/
+//===----------------------------------------------------------------------===*/
 
 %option prefix="llvmAsm"
 %option yylineno
@@ -19,10 +26,11 @@
 
 %{
 #include "ParserInternals.h"
+#include "llvm/Module.h"
 #include <list>
 #include "llvmAsmParser.h"
-#include <ctype.h>
-#include <stdlib.h>
+#include <cctype>
+#include <cstdlib>
 
 #define RET_TOK(type, Enum, sym) \
   llvmAsmlval.type = Instruction::Enum; return sym
@@ -48,10 +56,7 @@ static uint64_t atoull(const char *Buffer) {
   return Result;
 }
 
-// HexToFP - Convert the ascii string in hexidecimal format to the floating
-// point representation of it.
-//
-static double HexToFP(const char *Buffer) {
+static uint64_t HexIntToVal(const char *Buffer) {
   uint64_t Result = 0;
   for (; *Buffer; ++Buffer) {
     uint64_t OldRes = Result;
@@ -67,11 +72,25 @@ static double HexToFP(const char *Buffer) {
     if (Result < OldRes)   // Uh, oh, overflow detected!!!
       ThrowException("constant bigger than 64 bits detected!");
   }
+  return Result;
+}
 
-  assert(sizeof(double) == sizeof(Result) &&
+
+// HexToFP - Convert the ascii string in hexidecimal format to the floating
+// point representation of it.
+//
+static double HexToFP(const char *Buffer) {
+  // Behave nicely in the face of C TBAA rules... see:
+  // http://www.nullstone.com/htmls/category/aliastyp.htm
+  union {
+    uint64_t UI;
+    double FP;
+  } UIntToFP;
+  UIntToFP.UI = HexIntToVal(Buffer);
+
+  assert(sizeof(double) == sizeof(uint64_t) &&
          "Data sizes incompatible on this target!");
-  void *ProxyPointer = &Result;  // Break TBAA correctly
-  return *(double*)ProxyPointer;   // Cast Hex constant to double
+  return UIntToFP.FP;   // Cast Hex constant to double
 }
 
 
@@ -82,7 +101,7 @@ static double HexToFP(const char *Buffer) {
 // If AllowNull is set to true, the return value of the function points to the
 // last character of the string in memory.
 //
-char *UnEscapeLexed(char *Buffer, bool AllowNull = false) {
+char *UnEscapeLexed(char *Buffer, bool AllowNull) {
   char *BOut = Buffer;
   for (char *BIn = Buffer; *BIn; ) {
     if (BIn[0] == '\\' && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
@@ -117,7 +136,7 @@ VarID       %[-a-zA-Z$._][-a-zA-Z$._0-9]*
 Label       [-a-zA-Z$._0-9]+:
 
 /* Quoted names can contain any character except " and \ */
-StringConstant \"[^\"]+\"
+StringConstant \"[^\"]*\"
 
 
 /* [PN]Integer: match positive and negative literal integer values that
@@ -139,12 +158,17 @@ FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
  *  hexadecimal number for when exponential notation is not precise enough.
  */
 HexFPConstant 0x[0-9A-Fa-f]+
+
+/* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
+ * it to deal with 64 bit numbers.
+ */
+HexIntConstant [us]0x[0-9A-Fa-f]+
 %%
 
 {Comment}       { /* Ignore comments for now */ }
 
 begin           { return BEGINTOK; }
-end             { return END; }
+end             { return ENDTOK; }
 true            { return TRUE;  }
 false           { return FALSE; }
 declare         { return DECLARE; }
@@ -152,13 +176,24 @@ global          { return GLOBAL; }
 constant        { return CONSTANT; }
 const           { return CONST; }
 internal        { return INTERNAL; }
-uninitialized   { return UNINIT; }
+linkonce        { return LINKONCE; }
+weak            { return WEAK; }
+appending       { return APPENDING; }
+uninitialized   { return EXTERNAL; }    /* Deprecated, turn into external */
+external        { return EXTERNAL; }
 implementation  { return IMPLEMENTATION; }
+zeroinitializer { return ZEROINITIALIZER; }
 \.\.\.          { return DOTDOTDOT; }
-string          { return STRING; }
 null            { return NULL_TOK; }
 to              { return TO; }
 except          { return EXCEPT; }
+not             { return NOT; }  /* Deprecated, turned into XOR */
+target          { return TARGET; }
+endian          { return ENDIAN; }
+pointersize     { return POINTERSIZE; }
+little          { return LITTLE; }
+big             { return BIG; }
+volatile        { return VOLATILE; }
 
 void            { llvmAsmlval.PrimType = Type::VoidTy  ; return VOID;   }
 bool            { llvmAsmlval.PrimType = Type::BoolTy  ; return BOOL;   }
@@ -176,9 +211,6 @@ type            { llvmAsmlval.PrimType = Type::TypeTy  ; return TYPE;   }
 label           { llvmAsmlval.PrimType = Type::LabelTy ; return LABEL;  }
 opaque          { return OPAQUE; }
 
-
-not             { RET_TOK(UnaryOpVal, Not, NOT); }
-
 add             { RET_TOK(BinaryOpVal, Add, ADD); }
 sub             { RET_TOK(BinaryOpVal, Sub, SUB); }
 mul             { RET_TOK(BinaryOpVal, Mul, MUL); }
@@ -194,16 +226,20 @@ 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); }
 shl             { RET_TOK(OtherOpVal, Shl, SHL); }
 shr             { RET_TOK(OtherOpVal, Shr, SHR); }
+va_arg          { return VA_ARG; /* FIXME: OBSOLETE */}
+vanext          { RET_TOK(OtherOpVal, VANext, VANEXT); }
+vaarg           { 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); }
 
 
 malloc          { RET_TOK(MemOpVal, Malloc, MALLOC); }
@@ -246,7 +282,10 @@ getelementptr   { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
                   llvmAsmlval.SInt64Val = -Val; 
                  return ESINT64VAL; 
                 }
-
+{HexIntConstant} {
+                   llvmAsmlval.UInt64Val = HexIntToVal(yytext+3); 
+                   return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL;
+                 }
 
 {EPInteger}     { llvmAsmlval.UIntVal = atoull(yytext+1); return UINTVAL; }
 {ENInteger}     {