2002-08-14 17:12:33 +00:00
|
|
|
/*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===//
|
2005-05-10 22:02:28 +00:00
|
|
|
//
|
2003-10-21 15:17:13 +00:00
|
|
|
// 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.
|
2005-05-10 22:02:28 +00:00
|
|
|
//
|
2003-10-21 15:17:13 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
|
|
|
// This file implements the flex scanner for LLVM assembly languages files.
|
|
|
|
//
|
2002-08-14 17:12:33 +00:00
|
|
|
//===----------------------------------------------------------------------===*/
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
%option prefix="llvmAsm"
|
|
|
|
%option yylineno
|
|
|
|
%option nostdinit
|
|
|
|
%option never-interactive
|
|
|
|
%option batch
|
|
|
|
%option noyywrap
|
|
|
|
%option nodefault
|
|
|
|
%option 8bit
|
|
|
|
%option outfile="Lexer.cpp"
|
|
|
|
%option ecs
|
|
|
|
%option noreject
|
|
|
|
%option noyymore
|
|
|
|
|
|
|
|
%{
|
|
|
|
#include "ParserInternals.h"
|
2003-04-22 19:07:06 +00:00
|
|
|
#include "llvm/Module.h"
|
2007-05-22 06:47:11 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2001-06-06 20:29:01 +00:00
|
|
|
#include <list>
|
|
|
|
#include "llvmAsmParser.h"
|
2003-10-10 19:12:08 +00:00
|
|
|
#include <cctype>
|
|
|
|
#include <cstdlib>
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2005-05-20 03:25:47 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2006-10-26 06:15:43 +00:00
|
|
|
// Construct a token value for a non-obsolete token
|
2001-06-06 20:29:01 +00:00
|
|
|
#define RET_TOK(type, Enum, sym) \
|
2006-12-03 05:45:44 +00:00
|
|
|
llvmAsmlval.type = Instruction::Enum; \
|
2006-10-26 06:15:43 +00:00
|
|
|
return sym
|
|
|
|
|
2006-11-19 23:07:00 +00:00
|
|
|
// Construct a token value for an obsolete token
|
2006-12-03 05:45:44 +00:00
|
|
|
#define RET_TY(CTYPE, SYM) \
|
|
|
|
llvmAsmlval.PrimType = CTYPE;\
|
2006-11-28 07:28:14 +00:00
|
|
|
return SYM
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
namespace llvm {
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2005-05-10 22:02:28 +00:00
|
|
|
// TODO: All of the static identifiers are figured out by the lexer,
|
2001-09-07 16:32:43 +00:00
|
|
|
// these should be hashed to reduce the lexer size
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
|
|
|
|
// atoull - Convert an ascii string of decimal digits into the unsigned long
|
2005-05-10 22:02:28 +00:00
|
|
|
// long representation... this does not have to do input error checking,
|
2001-06-06 20:29:01 +00:00
|
|
|
// because we know that the input will be matched by a suitable regex...
|
|
|
|
//
|
2002-04-07 08:10:41 +00:00
|
|
|
static uint64_t atoull(const char *Buffer) {
|
2001-06-06 20:29:01 +00:00
|
|
|
uint64_t Result = 0;
|
|
|
|
for (; *Buffer; Buffer++) {
|
|
|
|
uint64_t OldRes = Result;
|
|
|
|
Result *= 10;
|
|
|
|
Result += *Buffer-'0';
|
2002-04-07 08:10:41 +00:00
|
|
|
if (Result < OldRes) // Uh, oh, overflow detected!!!
|
2006-08-18 08:43:06 +00:00
|
|
|
GenerateError("constant bigger than 64 bits detected!");
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2003-04-17 22:17:32 +00:00
|
|
|
static uint64_t HexIntToVal(const char *Buffer) {
|
2002-04-07 08:10:41 +00:00
|
|
|
uint64_t Result = 0;
|
|
|
|
for (; *Buffer; ++Buffer) {
|
|
|
|
uint64_t OldRes = Result;
|
|
|
|
Result *= 16;
|
|
|
|
char C = *Buffer;
|
|
|
|
if (C >= '0' && C <= '9')
|
|
|
|
Result += C-'0';
|
|
|
|
else if (C >= 'A' && C <= 'F')
|
|
|
|
Result += C-'A'+10;
|
|
|
|
else if (C >= 'a' && C <= 'f')
|
|
|
|
Result += C-'a'+10;
|
|
|
|
|
|
|
|
if (Result < OldRes) // Uh, oh, overflow detected!!!
|
2006-08-18 08:43:06 +00:00
|
|
|
GenerateError("constant bigger than 64 bits detected!");
|
2002-04-07 08:10:41 +00:00
|
|
|
}
|
2003-04-17 22:17:32 +00:00
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2007-09-11 18:32:33 +00:00
|
|
|
// HexToFP - Convert the ascii string in hexadecimal format to the floating
|
2003-04-17 22:17:32 +00:00
|
|
|
// point representation of it.
|
|
|
|
//
|
|
|
|
static double HexToFP(const char *Buffer) {
|
2007-05-22 06:47:11 +00:00
|
|
|
return BitsToDouble(HexIntToVal(Buffer)); // Cast Hex constant to double
|
2002-04-07 08:10:41 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 18:32:33 +00:00
|
|
|
static void HexToIntPair(const char *Buffer, uint64_t Pair[2]) {
|
|
|
|
Pair[0] = 0;
|
|
|
|
for (int i=0; i<16; i++, Buffer++) {
|
|
|
|
assert(*Buffer);
|
|
|
|
Pair[0] *= 16;
|
|
|
|
char C = *Buffer;
|
|
|
|
if (C >= '0' && C <= '9')
|
|
|
|
Pair[0] += C-'0';
|
|
|
|
else if (C >= 'A' && C <= 'F')
|
|
|
|
Pair[0] += C-'A'+10;
|
|
|
|
else if (C >= 'a' && C <= 'f')
|
|
|
|
Pair[0] += C-'a'+10;
|
|
|
|
}
|
|
|
|
Pair[1] = 0;
|
|
|
|
for (int i=0; i<16 && *Buffer; i++, Buffer++) {
|
|
|
|
Pair[1] *= 16;
|
|
|
|
char C = *Buffer;
|
|
|
|
if (C >= '0' && C <= '9')
|
|
|
|
Pair[1] += C-'0';
|
|
|
|
else if (C >= 'A' && C <= 'F')
|
|
|
|
Pair[1] += C-'A'+10;
|
|
|
|
else if (C >= 'a' && C <= 'f')
|
|
|
|
Pair[1] += C-'a'+10;
|
|
|
|
}
|
|
|
|
if (*Buffer)
|
|
|
|
GenerateError("constant bigger than 128 bits detected!");
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2001-07-28 17:48:55 +00:00
|
|
|
// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
|
2007-05-22 18:52:21 +00:00
|
|
|
// appropriate character.
|
2007-05-22 19:07:45 +00:00
|
|
|
char *UnEscapeLexed(char *Buffer, char* EndBuffer) {
|
2001-07-28 17:48:55 +00:00
|
|
|
char *BOut = Buffer;
|
|
|
|
for (char *BIn = Buffer; *BIn; ) {
|
2007-05-22 19:07:45 +00:00
|
|
|
if (BIn[0] == '\\') {
|
|
|
|
if (BIn < EndBuffer-1 && BIn[1] == '\\') {
|
|
|
|
*BOut++ = '\\'; // Two \ becomes one
|
|
|
|
BIn += 2;
|
|
|
|
} else if (BIn < EndBuffer-2 && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
|
|
|
|
char Tmp = BIn[3]; BIn[3] = 0; // Terminate string
|
|
|
|
*BOut = (char)strtol(BIn+1, 0, 16); // Convert to number
|
|
|
|
BIn[3] = Tmp; // Restore character
|
|
|
|
BIn += 3; // Skip over handled chars
|
|
|
|
++BOut;
|
|
|
|
} else {
|
|
|
|
*BOut++ = *BIn++;
|
|
|
|
}
|
2001-07-28 17:48:55 +00:00
|
|
|
} else {
|
|
|
|
*BOut++ = *BIn++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return BOut;
|
|
|
|
}
|
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
} // End llvm namespace
|
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
#define YY_NEVER_INTERACTIVE 1
|
|
|
|
%}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Comments start with a ; and go till end of line */
|
|
|
|
Comment ;.*
|
|
|
|
|
2007-01-26 08:04:51 +00:00
|
|
|
/* 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]*
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
/* Label identifiers end with a colon */
|
2001-12-04 04:31:30 +00:00
|
|
|
Label [-a-zA-Z$._0-9]+:
|
2004-12-10 05:40:19 +00:00
|
|
|
QuoteLabel \"[^\"]+\":
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
/* Quoted names can contain any character except " and \ */
|
2003-10-18 05:53:13 +00:00
|
|
|
StringConstant \"[^\"]*\"
|
2007-01-26 08:04:51 +00:00
|
|
|
AtStringConstant @\"[^\"]*\"
|
2007-05-19 07:21:26 +00:00
|
|
|
PctStringConstant %\"[^\"]*\"
|
2007-01-26 08:04:51 +00:00
|
|
|
|
|
|
|
/* LocalVarID/GlobalVarID: match an unnamed local variable slot ID. */
|
|
|
|
LocalVarID %[0-9]+
|
|
|
|
GlobalVarID @[0-9]+
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2007-01-26 08:04:51 +00:00
|
|
|
/* Integer types are specified with i and a bitwidth */
|
2007-01-12 07:27:59 +00:00
|
|
|
IntegerType i[0-9]+
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
|
2007-01-26 08:04:51 +00:00
|
|
|
/* E[PN]Integer: match positive and negative literal integer values. */
|
2001-06-06 20:29:01 +00:00
|
|
|
PInteger [0-9]+
|
|
|
|
NInteger -[0-9]+
|
|
|
|
|
2007-09-11 18:32:33 +00:00
|
|
|
/* FPConstant - A Floating point constant. Float and double only.
|
2002-04-07 08:10:41 +00:00
|
|
|
*/
|
2001-11-01 22:06:08 +00:00
|
|
|
FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
|
2001-07-15 00:17:01 +00:00
|
|
|
|
2002-04-07 08:10:41 +00:00
|
|
|
/* HexFPConstant - Floating point constant represented in IEEE format as a
|
|
|
|
* hexadecimal number for when exponential notation is not precise enough.
|
2007-09-11 18:32:33 +00:00
|
|
|
* Float and double only.
|
2002-04-07 08:10:41 +00:00
|
|
|
*/
|
|
|
|
HexFPConstant 0x[0-9A-Fa-f]+
|
2003-04-17 22:17:32 +00:00
|
|
|
|
2007-09-11 18:32:33 +00:00
|
|
|
/* F80HexFPConstant - x87 long double in hexadecimal format (10 bytes)
|
|
|
|
*/
|
|
|
|
HexFP80Constant 0xK[0-9A-Fa-f]+
|
|
|
|
|
|
|
|
/* F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes)
|
|
|
|
*/
|
|
|
|
HexFP128Constant 0xL[0-9A-Fa-f]+
|
|
|
|
|
|
|
|
/* PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes)
|
|
|
|
*/
|
|
|
|
HexPPC128Constant 0xM[0-9A-Fa-f]+
|
|
|
|
|
2003-04-17 22:17:32 +00:00
|
|
|
/* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
|
|
|
|
* it to deal with 64 bit numbers.
|
|
|
|
*/
|
|
|
|
HexIntConstant [us]0x[0-9A-Fa-f]+
|
2007-02-28 02:24:27 +00:00
|
|
|
|
2007-07-31 03:55:43 +00:00
|
|
|
/* WSNL - shorthand for whitespace followed by newline */
|
|
|
|
WSNL [ \r\t]*$
|
2001-06-06 20:29:01 +00:00
|
|
|
%%
|
|
|
|
|
|
|
|
{Comment} { /* Ignore comments for now */ }
|
|
|
|
|
|
|
|
begin { return BEGINTOK; }
|
2002-05-03 18:23:48 +00:00
|
|
|
end { return ENDTOK; }
|
2004-03-31 03:49:47 +00:00
|
|
|
true { return TRUETOK; }
|
|
|
|
false { return FALSETOK; }
|
2001-06-06 20:29:01 +00:00
|
|
|
declare { return DECLARE; }
|
2006-12-29 20:29:48 +00:00
|
|
|
define { return DEFINE; }
|
2001-09-10 07:58:01 +00:00
|
|
|
global { return GLOBAL; }
|
2001-09-18 04:00:54 +00:00
|
|
|
constant { return CONSTANT; }
|
2001-11-26 18:54:16 +00:00
|
|
|
internal { return INTERNAL; }
|
2003-04-16 20:28:45 +00:00
|
|
|
linkonce { return LINKONCE; }
|
2003-10-10 04:54:02 +00:00
|
|
|
weak { return WEAK; }
|
2003-04-16 20:28:45 +00:00
|
|
|
appending { return APPENDING; }
|
2006-09-14 18:23:27 +00:00
|
|
|
dllimport { return DLLIMPORT; }
|
|
|
|
dllexport { return DLLEXPORT; }
|
2007-01-12 19:20:47 +00:00
|
|
|
hidden { return HIDDEN; }
|
2007-04-29 18:35:00 +00:00
|
|
|
protected { return PROTECTED; }
|
2006-09-14 18:23:27 +00:00
|
|
|
extern_weak { return EXTERN_WEAK; }
|
2002-10-06 22:45:09 +00:00
|
|
|
external { return EXTERNAL; }
|
2007-04-12 18:32:50 +00:00
|
|
|
thread_local { return THREAD_LOCAL; }
|
2003-06-28 20:01:34 +00:00
|
|
|
zeroinitializer { return ZEROINITIALIZER; }
|
2001-07-25 22:47:46 +00:00
|
|
|
\.\.\. { return DOTDOTDOT; }
|
2004-10-16 18:17:13 +00:00
|
|
|
undef { return UNDEF; }
|
2001-09-30 22:46:54 +00:00
|
|
|
null { return NULL_TOK; }
|
2001-10-13 06:37:14 +00:00
|
|
|
to { return TO; }
|
2005-05-06 06:20:33 +00:00
|
|
|
tail { return TAIL; }
|
2003-04-22 19:07:06 +00:00
|
|
|
target { return TARGET; }
|
2004-07-25 17:56:00 +00:00
|
|
|
triple { return TRIPLE; }
|
|
|
|
deplibs { return DEPLIBS; }
|
2006-10-22 06:07:41 +00:00
|
|
|
datalayout { return DATALAYOUT; }
|
2003-09-08 18:20:29 +00:00
|
|
|
volatile { return VOLATILE; }
|
2005-11-12 00:11:30 +00:00
|
|
|
align { return ALIGN; }
|
|
|
|
section { return SECTION; }
|
2007-04-25 14:27:10 +00:00
|
|
|
alias { return ALIAS; }
|
2006-01-24 00:40:17 +00:00
|
|
|
module { return MODULE; }
|
2006-01-23 23:05:15 +00:00
|
|
|
asm { return ASM_TOK; }
|
2006-01-25 22:26:43 +00:00
|
|
|
sideeffect { return SIDEEFFECT; }
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2005-05-06 20:27:19 +00:00
|
|
|
cc { return CC_TOK; }
|
|
|
|
ccc { return CCC_TOK; }
|
|
|
|
fastcc { return FASTCC_TOK; }
|
|
|
|
coldcc { return COLDCC_TOK; }
|
2006-09-17 20:25:45 +00:00
|
|
|
x86_stdcallcc { return X86_STDCALLCC_TOK; }
|
|
|
|
x86_fastcallcc { return X86_FASTCALLCC_TOK; }
|
2005-05-06 20:27:19 +00:00
|
|
|
|
2007-07-19 23:13:04 +00:00
|
|
|
signext { return SIGNEXT; }
|
|
|
|
zeroext { return ZEROEXT; }
|
2007-02-02 02:16:23 +00:00
|
|
|
inreg { return INREG; }
|
|
|
|
sret { return SRET; }
|
2007-03-22 02:13:23 +00:00
|
|
|
nounwind { return NOUNWIND; }
|
|
|
|
noreturn { return NORETURN; }
|
2007-06-05 05:28:26 +00:00
|
|
|
noalias { return NOALIAS; }
|
2007-07-06 10:57:03 +00:00
|
|
|
byval { return BYVAL; }
|
2007-07-27 12:58:54 +00:00
|
|
|
nest { return NEST; }
|
2007-07-31 02:57:37 +00:00
|
|
|
sext{WSNL} { // For auto-upgrade only, drop in LLVM 3.0
|
|
|
|
return SIGNEXT; }
|
|
|
|
zext{WSNL} { // For auto-upgrade only, drop in LLVM 3.0
|
|
|
|
return ZEROEXT; }
|
2007-02-02 02:16:23 +00:00
|
|
|
|
2006-12-03 05:45:44 +00:00
|
|
|
void { RET_TY(Type::VoidTy, VOID); }
|
|
|
|
float { RET_TY(Type::FloatTy, FLOAT); }
|
|
|
|
double { RET_TY(Type::DoubleTy,DOUBLE);}
|
2007-08-03 01:03:46 +00:00
|
|
|
x86_fp80 { RET_TY(Type::X86_FP80Ty, X86_FP80);}
|
|
|
|
fp128 { RET_TY(Type::FP128Ty, FP128);}
|
|
|
|
ppc_fp128 { RET_TY(Type::PPC_FP128Ty, PPC_FP128);}
|
2006-12-03 05:45:44 +00:00
|
|
|
label { RET_TY(Type::LabelTy, LABEL); }
|
2004-07-04 12:17:44 +00:00
|
|
|
type { return TYPE; }
|
2002-04-04 19:22:17 +00:00
|
|
|
opaque { return OPAQUE; }
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
{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);
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
add { RET_TOK(BinaryOpVal, Add, ADD); }
|
|
|
|
sub { RET_TOK(BinaryOpVal, Sub, SUB); }
|
|
|
|
mul { RET_TOK(BinaryOpVal, Mul, MUL); }
|
2006-10-26 06:15:43 +00:00
|
|
|
udiv { RET_TOK(BinaryOpVal, UDiv, UDIV); }
|
|
|
|
sdiv { RET_TOK(BinaryOpVal, SDiv, SDIV); }
|
|
|
|
fdiv { RET_TOK(BinaryOpVal, FDiv, FDIV); }
|
2006-11-02 01:53:59 +00:00
|
|
|
urem { RET_TOK(BinaryOpVal, URem, UREM); }
|
|
|
|
srem { RET_TOK(BinaryOpVal, SRem, SREM); }
|
|
|
|
frem { RET_TOK(BinaryOpVal, FRem, FREM); }
|
2007-02-02 02:16:23 +00:00
|
|
|
shl { RET_TOK(BinaryOpVal, Shl, SHL); }
|
|
|
|
lshr { RET_TOK(BinaryOpVal, LShr, LSHR); }
|
|
|
|
ashr { RET_TOK(BinaryOpVal, AShr, ASHR); }
|
2001-10-20 09:32:59 +00:00
|
|
|
and { RET_TOK(BinaryOpVal, And, AND); }
|
|
|
|
or { RET_TOK(BinaryOpVal, Or , OR ); }
|
|
|
|
xor { RET_TOK(BinaryOpVal, Xor, XOR); }
|
2006-12-03 05:45:44 +00:00
|
|
|
icmp { RET_TOK(OtherOpVal, ICmp, ICMP); }
|
|
|
|
fcmp { RET_TOK(OtherOpVal, FCmp, FCMP); }
|
2007-02-02 02:16:23 +00:00
|
|
|
|
2006-12-03 06:58:07 +00:00
|
|
|
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; }
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2003-10-19 21:34:28 +00:00
|
|
|
phi { RET_TOK(OtherOpVal, PHI, PHI_TOK); }
|
2001-07-08 21:10:27 +00:00
|
|
|
call { RET_TOK(OtherOpVal, Call, CALL); }
|
2006-11-27 01:05:10 +00:00
|
|
|
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); }
|
2004-03-12 05:51:36 +00:00
|
|
|
select { RET_TOK(OtherOpVal, Select, SELECT); }
|
2005-06-18 18:34:52 +00:00
|
|
|
va_arg { RET_TOK(OtherOpVal, VAArg , VAARG); }
|
2001-06-06 20:29:01 +00:00
|
|
|
ret { RET_TOK(TermOpVal, Ret, RET); }
|
|
|
|
br { RET_TOK(TermOpVal, Br, BR); }
|
|
|
|
switch { RET_TOK(TermOpVal, Switch, SWITCH); }
|
2001-10-13 06:37:14 +00:00
|
|
|
invoke { RET_TOK(TermOpVal, Invoke, INVOKE); }
|
2003-09-08 18:54:55 +00:00
|
|
|
unwind { RET_TOK(TermOpVal, Unwind, UNWIND); }
|
2004-10-16 18:17:13 +00:00
|
|
|
unreachable { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
malloc { RET_TOK(MemOpVal, Malloc, MALLOC); }
|
|
|
|
alloca { RET_TOK(MemOpVal, Alloca, ALLOCA); }
|
|
|
|
free { RET_TOK(MemOpVal, Free, FREE); }
|
|
|
|
load { RET_TOK(MemOpVal, Load, LOAD); }
|
|
|
|
store { RET_TOK(MemOpVal, Store, STORE); }
|
2001-07-08 23:22:50 +00:00
|
|
|
getelementptr { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2006-01-10 19:04:32 +00:00
|
|
|
extractelement { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
|
2006-01-17 20:06:25 +00:00
|
|
|
insertelement { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); }
|
2006-04-08 01:18:35 +00:00
|
|
|
shufflevector { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
|
2006-01-10 19:04:32 +00:00
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2007-01-26 08:04:51 +00:00
|
|
|
{LocalVarName} {
|
2007-05-22 18:52:21 +00:00
|
|
|
llvmAsmlval.StrVal = new std::string(yytext+1); // Skip %
|
2007-01-26 08:04:51 +00:00
|
|
|
return LOCALVAR;
|
|
|
|
}
|
|
|
|
{GlobalVarName} {
|
2007-05-22 18:52:21 +00:00
|
|
|
llvmAsmlval.StrVal = new std::string(yytext+1); // Skip @
|
2007-01-26 08:04:51 +00:00
|
|
|
return GLOBALVAR;
|
2001-07-28 17:48:55 +00:00
|
|
|
}
|
|
|
|
{Label} {
|
2007-05-22 18:52:21 +00:00
|
|
|
yytext[yyleng-1] = 0; // nuke colon
|
|
|
|
llvmAsmlval.StrVal = new std::string(yytext);
|
2005-05-10 22:02:28 +00:00
|
|
|
return LABELSTR;
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
2004-12-10 05:27:29 +00:00
|
|
|
{QuoteLabel} {
|
2007-05-22 18:52:21 +00:00
|
|
|
yytext[yyleng-2] = 0; // nuke colon, end quote
|
2007-05-22 19:07:45 +00:00
|
|
|
const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng);
|
2007-05-22 18:52:21 +00:00
|
|
|
llvmAsmlval.StrVal =
|
|
|
|
new std::string(yytext+1, EndChar - yytext - 1);
|
2005-05-10 22:02:28 +00:00
|
|
|
return LABELSTR;
|
2004-12-10 05:27:29 +00:00
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2007-05-22 18:52:21 +00:00
|
|
|
{StringConstant} { yytext[yyleng-1] = 0; // nuke end quote
|
2007-05-22 19:07:45 +00:00
|
|
|
const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng);
|
2007-05-22 18:52:21 +00:00
|
|
|
llvmAsmlval.StrVal =
|
|
|
|
new std::string(yytext+1, EndChar - yytext - 1);
|
2005-05-10 22:02:28 +00:00
|
|
|
return STRINGCONSTANT;
|
2001-07-28 17:48:55 +00:00
|
|
|
}
|
2007-01-26 08:04:51 +00:00
|
|
|
{AtStringConstant} {
|
2007-05-22 18:52:21 +00:00
|
|
|
yytext[yyleng-1] = 0; // nuke end quote
|
2007-05-22 19:07:45 +00:00
|
|
|
const char* EndChar =
|
|
|
|
UnEscapeLexed(yytext+2, yytext+yyleng);
|
2007-05-22 18:52:21 +00:00
|
|
|
llvmAsmlval.StrVal =
|
|
|
|
new std::string(yytext+2, EndChar - yytext - 2);
|
2007-01-26 08:04:51 +00:00
|
|
|
return ATSTRINGCONSTANT;
|
|
|
|
}
|
2007-05-19 07:21:26 +00:00
|
|
|
{PctStringConstant} {
|
2007-05-22 18:52:21 +00:00
|
|
|
yytext[yyleng-1] = 0; // nuke end quote
|
2007-05-22 19:07:45 +00:00
|
|
|
const char* EndChar =
|
|
|
|
UnEscapeLexed(yytext+2, yytext+yyleng);
|
2007-05-22 18:52:21 +00:00
|
|
|
llvmAsmlval.StrVal =
|
|
|
|
new std::string(yytext+2, EndChar - yytext - 2);
|
2007-05-19 07:21:26 +00:00
|
|
|
return PCTSTRINGCONSTANT;
|
|
|
|
}
|
2007-05-22 18:52:21 +00:00
|
|
|
{PInteger} {
|
|
|
|
uint32_t numBits = ((yyleng * 64) / 19) + 1;
|
|
|
|
APInt Tmp(numBits, yytext, yyleng, 10);
|
2007-02-28 02:24:27 +00:00
|
|
|
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;
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
2007-05-22 18:52:21 +00:00
|
|
|
{NInteger} {
|
|
|
|
uint32_t numBits = (((yyleng-1) * 64) / 19) + 2;
|
|
|
|
APInt Tmp(numBits, yytext, yyleng, 10);
|
2007-02-28 02:24:27 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-22 18:52:21 +00:00
|
|
|
{HexIntConstant} { int len = yyleng - 3;
|
2007-02-28 02:24:27 +00:00
|
|
|
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;
|
|
|
|
}
|
2003-04-17 22:17:32 +00:00
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2007-01-26 08:04:51 +00:00
|
|
|
{LocalVarID} {
|
2005-01-08 20:07:03 +00:00
|
|
|
uint64_t Val = atoull(yytext+1);
|
|
|
|
if ((unsigned)Val != Val)
|
2006-08-18 08:43:06 +00:00
|
|
|
GenerateError("Invalid value number (too large)!");
|
2005-01-08 20:07:03 +00:00
|
|
|
llvmAsmlval.UIntVal = unsigned(Val);
|
2007-01-26 08:04:51 +00:00
|
|
|
return LOCALVAL_ID;
|
2005-01-08 20:07:03 +00:00
|
|
|
}
|
2007-01-26 08:04:51 +00:00
|
|
|
{GlobalVarID} {
|
|
|
|
uint64_t Val = atoull(yytext+1);
|
|
|
|
if ((unsigned)Val != Val)
|
|
|
|
GenerateError("Invalid value number (too large)!");
|
|
|
|
llvmAsmlval.UIntVal = unsigned(Val);
|
|
|
|
return GLOBALVAL_ID;
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2007-09-06 18:13:44 +00:00
|
|
|
{FPConstant} { llvmAsmlval.FPVal = new APFloat(atof(yytext)); return FPVAL; }
|
|
|
|
{HexFPConstant} { llvmAsmlval.FPVal = new APFloat(HexToFP(yytext));
|
|
|
|
return FPVAL;
|
|
|
|
}
|
2007-09-11 18:32:33 +00:00
|
|
|
{HexFP80Constant} { uint64_t Pair[2];
|
|
|
|
HexToIntPair(yytext, Pair);
|
|
|
|
llvmAsmlval.FPVal = new APFloat(APInt(80, 2, Pair));
|
|
|
|
return FPVAL;
|
|
|
|
}
|
|
|
|
{HexFP128Constant} { uint64_t Pair[2];
|
|
|
|
HexToIntPair(yytext, Pair);
|
|
|
|
llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair));
|
|
|
|
return FPVAL;
|
|
|
|
}
|
|
|
|
{HexPPC128Constant} { uint64_t Pair[2];
|
|
|
|
HexToIntPair(yytext, Pair);
|
|
|
|
llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair));
|
|
|
|
return FPVAL;
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2004-03-19 23:34:33 +00:00
|
|
|
<<EOF>> {
|
|
|
|
/* Make sure to free the internal buffers for flex when we are
|
|
|
|
* done reading our input!
|
|
|
|
*/
|
|
|
|
yy_delete_buffer(YY_CURRENT_BUFFER);
|
|
|
|
return EOF;
|
|
|
|
}
|
|
|
|
|
2004-05-27 17:49:14 +00:00
|
|
|
[ \r\t\n] { /* Ignore whitespace */ }
|
2001-09-07 16:32:43 +00:00
|
|
|
. { return yytext[0]; }
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
%%
|