[mirror_qemu.git] / target / hexagon / idef-parser / idef-parser.lex

%option noyywrap noinput nounput
%option 8bit reentrant bison-bridge
%option warn nodefault
%option bison-locations

%{
/*
 *  Copyright(c) 2019-2023 rev.ng Labs Srl. All Rights Reserved.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include <string.h>
#include <stdbool.h>

#include "hex_regs.h"

#include "idef-parser.h"
#include "idef-parser.tab.h"

/* Keep track of scanner position for error message printout */
#define YY_USER_ACTION yylloc->first_column = yylloc->last_column; \
    for (int i = 0; yytext[i] != '\0'; i++) {   \
        yylloc->last_column++;                  \
    }

/* Global Error Counter */
int error_count;

%}

/* Definitions */
DIGIT                    [0-9]
LOWER_ID                 [a-z]
UPPER_ID                 [A-Z]
ID                       LOWER_ID|UPPER_ID
INST_NAME                [A-Z]+[0-9]_([A-Za-z]|[0-9]|_)+
HEX_DIGIT                [0-9a-fA-F]
REG_ID_32                e|s|d|t|u|v|x|y
REG_ID_64                ee|ss|dd|tt|uu|vv|xx|yy
SYS_ID_32                s|d
SYS_ID_64                ss|dd
PRED_ID                  d|s|t|u|v|e|x|x
IMM_ID                   r|s|S|u|U
VAR_ID                   [a-zA-Z_][a-zA-Z0-9_]*
SIGN_ID                  s|u
STRING_LIT               \"(\\.|[^"\\])*\"

/* Tokens */
%%

[ \t\f\v]+                { /* Ignore whitespaces. */ }
[\n\r]+                   { /* Ignore newlines. */ }
^#.*$                     { /* Ignore linemarkers. */ }

{INST_NAME}               { yylval->string = g_string_new(yytext);
                            return INAME; }
"fFLOAT"                 |
"fUNFLOAT"               |
"fDOUBLE"                |
"fUNDOUBLE"              |
"0.0"                    |
"0x1.0p52"               |
"0x1.0p-52"              { return FAIL; }
"in"                     { return IN; }
"R"{REG_ID_32}"V" {
                           yylval->rvalue.type = REGISTER_ARG;
                           yylval->rvalue.reg.type = GENERAL_PURPOSE;
                           yylval->rvalue.reg.id = yytext[1];
                           yylval->rvalue.reg.bit_width = 32;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.is_dotnew = false;
                           yylval->rvalue.signedness = SIGNED;
                           return REG; }
"R"{REG_ID_64}"V" {
                           yylval->rvalue.type = REGISTER_ARG;
                           yylval->rvalue.reg.type = GENERAL_PURPOSE;
                           yylval->rvalue.reg.id = yytext[1];
                           yylval->rvalue.reg.bit_width = 64;
                           yylval->rvalue.bit_width = 64;
                           yylval->rvalue.is_dotnew = false;
                           yylval->rvalue.signedness = SIGNED;
                           return REG; }
"MuV" {
                           yylval->rvalue.type = REGISTER_ARG;
                           yylval->rvalue.reg.type = MODIFIER;
                           yylval->rvalue.reg.id = 'u';
                           yylval->rvalue.reg.bit_width = 32;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.signedness = SIGNED;
                           return REG; }
"C"{REG_ID_32}"V" {
                           yylval->rvalue.type = REGISTER_ARG;
                           yylval->rvalue.reg.type = CONTROL;
                           yylval->rvalue.reg.id = yytext[1];
                           yylval->rvalue.reg.bit_width = 32;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.is_dotnew = false;
                           yylval->rvalue.signedness = SIGNED;
                           return REG; }
"C"{REG_ID_64}"V" {
                           yylval->rvalue.type = REGISTER_ARG;
                           yylval->rvalue.reg.type = CONTROL;
                           yylval->rvalue.reg.id = yytext[1];
                           yylval->rvalue.reg.bit_width = 64;
                           yylval->rvalue.bit_width = 64;
                           yylval->rvalue.is_dotnew = false;
                           yylval->rvalue.signedness = SIGNED;
                           return REG; }
{IMM_ID}"iV" {
                           yylval->rvalue.type = IMMEDIATE;
                           yylval->rvalue.signedness = SIGNED;
                           yylval->rvalue.imm.type = VARIABLE;
                           yylval->rvalue.imm.id = yytext[0];
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.is_dotnew = false;
                           return IMM; }
"P"{PRED_ID}"V" {
                           yylval->rvalue.type = PREDICATE;
                           yylval->rvalue.pred.id = yytext[1];
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.is_dotnew = false;
                           yylval->rvalue.signedness = SIGNED;
                           return PRED; }
"P"{PRED_ID}"N" {
                           yylval->rvalue.type = PREDICATE;
                           yylval->rvalue.pred.id = yytext[1];
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.is_dotnew = true;
                           yylval->rvalue.signedness = SIGNED;
                           return PRED; }
"+="                     { return INC; }
"-="                     { return DEC; }
"++"                     { return PLUSPLUS; }
"&="                     { return ANDA; }
"|="                     { return ORA; }
"^="                     { return XORA; }
"<<"                     { return ASL; }
">>"                     { return ASR; }
">>>"                    { return LSR; }
"=="                     { return EQ; }
"!="                     { return NEQ; }
"<="                     { return LTE; }
">="                     { return GTE; }
"&&"                     { return ANDL; }
"else"                   { return ELSE; }
"for"                    { return FOR; }
"fREAD_IREG"             { return ICIRC; }
"if"                     { return IF; }
"fFRAME_SCRAMBLE"        |
"fFRAME_UNSCRAMBLE"      { return FSCR; }
"fFRAMECHECK"            { return FCHK; }
"Constant_extended"      { return CONSTEXT; }
"fCL1_"{DIGIT}           { return LOCNT; }
"fbrev"                  { return BREV; }
"fSXTN"                  { return SXT; }
"fZXTN"                  { return ZXT; }
"fDF_MAX"                |
"fSF_MAX"                |
"fMAX"                   { return MAX; }
"fDF_MIN"                |
"fSF_MIN"                |
"fMIN"                   { return MIN; }
"fABS"                   { return ABS; }
"fRNDN"                  { return ROUND; }
"fCRND"                  { return CROUND; }
"fCRNDN"                 { return CROUND; }
"fPM_CIRI"               { return CIRCADD; }
"fPM_CIRR"               { return CIRCADD; }
"fCOUNTONES_"{DIGIT}     { return COUNTONES; }
"fSATN"                  { yylval->sat.signedness = SIGNED;
                           return SAT; }
"fSATUN"                 { yylval->sat.signedness = UNSIGNED;
                           return SAT; }
"fCONSTLL"               { yylval->cast.bit_width = 64;
                           yylval->cast.signedness = SIGNED;
                           return CAST; }
"fSE32_64"               { yylval->cast.bit_width = 64;
                           yylval->cast.signedness = SIGNED;
                           return CAST; }
"fCAST4_4u"              { yylval->cast.bit_width = 32;
                           yylval->cast.signedness = UNSIGNED;
                           return CAST; }
"fCAST4_8s"              { yylval->cast.bit_width = 64;
                           yylval->cast.signedness = SIGNED;
                           return CAST; }
"fCAST4_8u"              { return CAST4_8U; }
"fCAST4u"                { yylval->cast.bit_width = 32;
                           yylval->cast.signedness = UNSIGNED;
                           return CAST; }
"fNEWREG"                |
"fCAST4_4s"              |
"fCAST4s"                { yylval->cast.bit_width = 32;
                           yylval->cast.signedness = SIGNED;
                           return CAST; }
"fCAST8_8u"              { yylval->cast.bit_width = 64;
                           yylval->cast.signedness = UNSIGNED;
                           return CAST; }
"fCAST8u"                { yylval->cast.bit_width = 64;
                           yylval->cast.signedness = UNSIGNED;
                           return CAST; }
"fCAST8_8s"              |
"fCAST8s"                { yylval->cast.bit_width = 64;
                           yylval->cast.signedness = SIGNED;
                           return CAST; }
"fGETBIT"                { yylval->extract.bit_width = 1;
                           yylval->extract.storage_bit_width = 1;
                           yylval->extract.signedness = UNSIGNED;
                           return EXTRACT; }
"fGETBYTE"               { yylval->extract.bit_width = 8;
                           yylval->extract.storage_bit_width = 8;
                           yylval->extract.signedness = SIGNED;
                           return EXTRACT; }
"fGETUBYTE"              { yylval->extract.bit_width = 8;
                           yylval->extract.storage_bit_width = 8;
                           yylval->extract.signedness = UNSIGNED;
                           return EXTRACT; }
"fGETHALF"               { yylval->extract.bit_width = 16;
                           yylval->extract.storage_bit_width = 16;
                           yylval->extract.signedness = SIGNED;
                           return EXTRACT; }
"fGETUHALF"              { yylval->extract.bit_width = 16;
                           yylval->extract.storage_bit_width = 16;
                           yylval->extract.signedness = UNSIGNED;
                           return EXTRACT; }
"fGETWORD"               { yylval->extract.bit_width = 32;
                           yylval->extract.storage_bit_width = 64;
                           yylval->extract.signedness = SIGNED;
                           return EXTRACT; }
"fGETUWORD"              { yylval->extract.bit_width = 32;
                           yylval->extract.storage_bit_width = 64;
                           yylval->extract.signedness = UNSIGNED;
                           return EXTRACT; }
"fEXTRACTU_RANGE"        { return EXTRANGE; }
"fSETBIT"                { yylval->cast.bit_width = 1;
                           yylval->cast.signedness = SIGNED;
                           return DEPOSIT; }
"fSETBYTE"               { yylval->cast.bit_width = 8;
                           yylval->cast.signedness = SIGNED;
                           return DEPOSIT; }
"fSETHALF"               { yylval->cast.bit_width = 16;
                           yylval->cast.signedness = SIGNED;
                           return SETHALF; }
"fSETWORD"               { yylval->cast.bit_width = 32;
                           yylval->cast.signedness = SIGNED;
                           return DEPOSIT; }
"fINSERT_BITS"           { return INSBITS; }
"fSETBITS"               { return SETBITS; }
"fMPY16UU"               { yylval->mpy.first_bit_width = 16;
                           yylval->mpy.second_bit_width = 16;
                           yylval->mpy.first_signedness = UNSIGNED;
                           yylval->mpy.second_signedness = UNSIGNED;
                           return MPY; }
"fMPY16SU"               { yylval->mpy.first_bit_width = 16;
                           yylval->mpy.second_bit_width = 16;
                           yylval->mpy.first_signedness = SIGNED;
                           yylval->mpy.second_signedness = UNSIGNED;
                           return MPY; }
"fMPY16SS"               { yylval->mpy.first_bit_width = 16;
                           yylval->mpy.second_bit_width = 16;
                           yylval->mpy.first_signedness = SIGNED;
                           yylval->mpy.second_signedness = SIGNED;
                           return MPY; }
"fMPY32UU"               { yylval->mpy.first_bit_width = 32;
                           yylval->mpy.second_bit_width = 32;
                           yylval->mpy.first_signedness = UNSIGNED;
                           yylval->mpy.second_signedness = UNSIGNED;
                           return MPY; }
"fMPY32SU"               { yylval->mpy.first_bit_width = 32;
                           yylval->mpy.second_bit_width = 32;
                           yylval->mpy.first_signedness = SIGNED;
                           yylval->mpy.second_signedness = UNSIGNED;
                           return MPY; }
"fSFMPY"                 |
"fMPY32SS"               { yylval->mpy.first_bit_width = 32;
                           yylval->mpy.second_bit_width = 32;
                           yylval->mpy.first_signedness = SIGNED;
                           yylval->mpy.second_signedness = SIGNED;
                           return MPY; }
"fMPY3216SS"             { yylval->mpy.first_bit_width = 32;
                           yylval->mpy.second_bit_width = 16;
                           yylval->mpy.first_signedness = SIGNED;
                           yylval->mpy.second_signedness = SIGNED;
                           return MPY; }
"fMPY3216SU"             { yylval->mpy.first_bit_width = 32;
                           yylval->mpy.second_bit_width = 16;
                           yylval->mpy.first_signedness = SIGNED;
                           yylval->mpy.second_signedness = UNSIGNED;
                           return MPY; }
"fNEWREG_ST"             |
"fIMMEXT"                |
"fMUST_IMMEXT"           |
"fPASS"                  |
"fECHO"                  { return IDENTITY; }
"(size8u_t)"             { yylval->cast.bit_width = 64;
                           yylval->cast.signedness = UNSIGNED;
                           return CAST; }
"(unsigned int)"         { yylval->cast.bit_width = 32;
                           yylval->cast.signedness = UNSIGNED;
                           return CAST; }
"fREAD_PC()"             { return PC; }
"USR.LPCFG"              { return LPCFG; }
"LOAD_CANCEL(EA)"        { return LOAD_CANCEL; }
"STORE_CANCEL(EA)"       { return STORE_CANCEL; }
"CANCEL"                 { return CANCEL; }
"N"{LOWER_ID}"N"         { yylval->rvalue.type = REGISTER_ARG;
                           yylval->rvalue.reg.type = DOTNEW;
                           yylval->rvalue.reg.id = yytext[1];
                           yylval->rvalue.reg.bit_width = 32;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.signedness = UNSIGNED;
                           return REG; }
"fREAD_SP()"             |
"SP"                     { yylval->rvalue.type = REGISTER;
                           yylval->rvalue.reg.type = GENERAL_PURPOSE;
                           yylval->rvalue.reg.id = HEX_REG_SP;
                           yylval->rvalue.reg.bit_width = 32;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.signedness = UNSIGNED;
                           return REG; }
"fREAD_FP()"             |
"FP"                     { yylval->rvalue.type = REGISTER;
                           yylval->rvalue.reg.type = GENERAL_PURPOSE;
                           yylval->rvalue.reg.id = HEX_REG_FP;
                           yylval->rvalue.reg.bit_width = 32;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.signedness = UNSIGNED;
                           return REG; }
"fREAD_LR()"             |
"LR"                     { yylval->rvalue.type = REGISTER;
                           yylval->rvalue.reg.type = GENERAL_PURPOSE;
                           yylval->rvalue.reg.id = HEX_REG_LR;
                           yylval->rvalue.reg.bit_width = 32;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.signedness = UNSIGNED;
                           return REG; }
"fREAD_GP()"             |
"GP"                     { yylval->rvalue.type = REGISTER;
                           yylval->rvalue.reg.type = CONTROL;
                           yylval->rvalue.reg.id = HEX_REG_GP;
                           yylval->rvalue.reg.bit_width = 32;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.signedness = UNSIGNED;
                           return REG; }
"LC"[01]                 { yylval->rvalue.type = REGISTER;
                           yylval->rvalue.reg.type = CONTROL;
                           yylval->rvalue.reg.id = HEX_REG_LC0
                                                 + (yytext[2] - '0') * 2;
                           yylval->rvalue.reg.bit_width = 32;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.signedness = UNSIGNED;
                           return REG; }
"SA"[01]                 { yylval->rvalue.type = REGISTER;
                           yylval->rvalue.reg.type = CONTROL;
                           yylval->rvalue.reg.id = HEX_REG_SA0
                                                 + (yytext[2] - '0') * 2;
                           yylval->rvalue.reg.bit_width = 32;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.signedness = UNSIGNED;
                           return REG; }
"fREAD_P0()"             { yylval->rvalue.type = PREDICATE;
                           yylval->rvalue.pred.id = '0';
                           yylval->rvalue.bit_width = 32;
                           return PRED; }
[pP]{DIGIT}              { yylval->rvalue.type = PREDICATE;
                           yylval->rvalue.pred.id = yytext[1];
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.is_dotnew = false;
                           return PRED; }
[pP]{DIGIT}[nN]          { yylval->rvalue.type = PREDICATE;
                           yylval->rvalue.pred.id = yytext[1];
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.is_dotnew = true;
                           return PRED; }
"fLSBNEW"                { return LSBNEW; }
"N"                      { yylval->rvalue.type = IMMEDIATE;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.imm.type = VARIABLE;
                           yylval->rvalue.imm.id = 'N';
                           return IMM; }
"i"                      { yylval->rvalue.type = IMMEDIATE;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.signedness = SIGNED;
                           yylval->rvalue.imm.type = I;
                           return IMM; }
{SIGN_ID}                { if (yytext[0] == 'u') {
                               yylval->signedness = UNSIGNED;
                           } else {
                               yylval->signedness = SIGNED;
                           }
                           return SIGN;
                         }
"0x"{HEX_DIGIT}+         |
{DIGIT}+                 { yylval->rvalue.type = IMMEDIATE;
                           yylval->rvalue.bit_width = 32;
                           yylval->rvalue.signedness = SIGNED;
                           yylval->rvalue.imm.type = VALUE;
                           yylval->rvalue.imm.value = strtoull(yytext, NULL, 0);
                           return IMM; }
"0x"{HEX_DIGIT}+"ULL"    |
{DIGIT}+"ULL"            { yylval->rvalue.type = IMMEDIATE;
                           yylval->rvalue.bit_width = 64;
                           yylval->rvalue.signedness = UNSIGNED;
                           yylval->rvalue.imm.type = VALUE;
                           yylval->rvalue.imm.value = strtoull(yytext, NULL, 0);
                           return IMM; }
"fLOAD"                  { return LOAD; }
"fSTORE"                 { return STORE; }
"fROTL"                  { return ROTL; }
"fCARRY_FROM_ADD"        { return CARRY_FROM_ADD; }
"fADDSAT64"              { return ADDSAT64; }
"size"[1248][us]"_t"     { /* Handles "size_t" variants of int types */
                           const unsigned int bits_per_byte = 8;
                           const unsigned int bytes = yytext[4] - '0';
                           yylval->rvalue.bit_width = bits_per_byte * bytes;
                           if (yytext[5] == 'u') {
                               yylval->rvalue.signedness = UNSIGNED;
                           } else {
                               yylval->rvalue.signedness = SIGNED;
                           }
                           return TYPE_SIZE_T; }
"unsigned"               { return TYPE_UNSIGNED; }
"long"                   { return TYPE_LONG; }
"int"                    { return TYPE_INT; }
"const"                  { /* Emit no token */ }
{VAR_ID}                 { /* Variable name, we adopt the C names convention */
                           yylval->rvalue.type = VARID;
                           yylval->rvalue.var.name = g_string_new(yytext);
                           /* Default to an unknown signedness and 0 width. */
                           yylval->rvalue.bit_width = 0;
                           yylval->rvalue.signedness = UNKNOWN_SIGNEDNESS;
                           return VAR; }
"fatal("{STRING_LIT}")"  { /* Emit no token */ }
"fHINTJR(RsV)"           { /* Emit no token */ }
.                        { return yytext[0]; }

%%
Commit	Line	Data
fd8171fe PM	1	%option noyywrap noinput nounput
	2	%option 8bit reentrant bison-bridge
	3	%option warn nodefault
	4	%option bison-locations
	5
	6	%{
	7	/*
7b84fd04	8	* Copyright(c) 2019-2023 rev.ng Labs Srl. All Rights Reserved.
fd8171fe PM	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	22	*/
	23
	24	#include <string.h>
	25	#include <stdbool.h>
	26
	27	#include "hex_regs.h"
	28
	29	#include "idef-parser.h"
	30	#include "idef-parser.tab.h"
	31
	32	/* Keep track of scanner position for error message printout */
	33	#define YY_USER_ACTION yylloc->first_column = yylloc->last_column; \
	34	for (int i = 0; yytext[i] != '\0'; i++) { \
	35	yylloc->last_column++; \
	36	}
	37
	38	/* Global Error Counter */
	39	int error_count;
	40
	41	%}
	42
	43	/* Definitions */
	44	DIGIT [0-9]
	45	LOWER_ID [a-z]
	46	UPPER_ID [A-Z]
	47	ID LOWER_ID\|UPPER_ID
	48	INST_NAME [A-Z]+[0-9]_([A-Za-z]\|[0-9]\|_)+
	49	HEX_DIGIT [0-9a-fA-F]
	50	REG_ID_32 e\|s\|d\|t\|u\|v\|x\|y
	51	REG_ID_64 ee\|ss\|dd\|tt\|uu\|vv\|xx\|yy
	52	SYS_ID_32 s\|d
	53	SYS_ID_64 ss\|dd
	54	PRED_ID d\|s\|t\|u\|v\|e\|x\|x
	55	IMM_ID r\|s\|S\|u\|U
	56	VAR_ID [a-zA-Z_][a-zA-Z0-9_]*
	57	SIGN_ID s\|u
	58	STRING_LIT \"(\\.\|[^"\\])*\"
	59
	60	/* Tokens */
	61	%%
	62
	63	[ \t\f\v]+ { /* Ignore whitespaces. */ }
	64	[\n\r]+ { /* Ignore newlines. */ }
	65	^#.$ { / Ignore linemarkers. */ }
	66
	67	{INST_NAME} { yylval->string = g_string_new(yytext);
	68	return INAME; }
	69	"fFLOAT" \|
	70	"fUNFLOAT" \|
	71	"fDOUBLE" \|
	72	"fUNDOUBLE" \|
73	"0.0" \|
74	"0x1.0p52" \|
75	"0x1.0p-52" { return FAIL; }
76	"in" { return IN; }
77	"R"{REG_ID_32}"V" {
78	yylval->rvalue.type = REGISTER_ARG;
79	yylval->rvalue.reg.type = GENERAL_PURPOSE;
80	yylval->rvalue.reg.id = yytext[1];
81	yylval->rvalue.reg.bit_width = 32;
82	yylval->rvalue.bit_width = 32;
83	yylval->rvalue.is_dotnew = false;
84	yylval->rvalue.signedness = SIGNED;
85	return REG; }
86	"R"{REG_ID_64}"V" {
87	yylval->rvalue.type = REGISTER_ARG;
88	yylval->rvalue.reg.type = GENERAL_PURPOSE;
89	yylval->rvalue.reg.id = yytext[1];
90	yylval->rvalue.reg.bit_width = 64;
91	yylval->rvalue.bit_width = 64;
92	yylval->rvalue.is_dotnew = false;
93	yylval->rvalue.signedness = SIGNED;
94	return REG; }
95	"MuV" {
96	yylval->rvalue.type = REGISTER_ARG;
97	yylval->rvalue.reg.type = MODIFIER;
98	yylval->rvalue.reg.id = 'u';
99	yylval->rvalue.reg.bit_width = 32;
100	yylval->rvalue.bit_width = 32;
101	yylval->rvalue.signedness = SIGNED;
102	return REG; }
103	"C"{REG_ID_32}"V" {
104	yylval->rvalue.type = REGISTER_ARG;
105	yylval->rvalue.reg.type = CONTROL;
106	yylval->rvalue.reg.id = yytext[1];
107	yylval->rvalue.reg.bit_width = 32;
108	yylval->rvalue.bit_width = 32;
109	yylval->rvalue.is_dotnew = false;
110	yylval->rvalue.signedness = SIGNED;
111	return REG; }
112	"C"{REG_ID_64}"V" {
113	yylval->rvalue.type = REGISTER_ARG;
114	yylval->rvalue.reg.type = CONTROL;
115	yylval->rvalue.reg.id = yytext[1];
116	yylval->rvalue.reg.bit_width = 64;
117	yylval->rvalue.bit_width = 64;
118	yylval->rvalue.is_dotnew = false;
119	yylval->rvalue.signedness = SIGNED;
120	return REG; }
121	{IMM_ID}"iV" {
122	yylval->rvalue.type = IMMEDIATE;
123	yylval->rvalue.signedness = SIGNED;
124	yylval->rvalue.imm.type = VARIABLE;
125	yylval->rvalue.imm.id = yytext[0];
126	yylval->rvalue.bit_width = 32;
127	yylval->rvalue.is_dotnew = false;
128	return IMM; }
129	"P"{PRED_ID}"V" {
130	yylval->rvalue.type = PREDICATE;
131	yylval->rvalue.pred.id = yytext[1];
132	yylval->rvalue.bit_width = 32;
133	yylval->rvalue.is_dotnew = false;
134	yylval->rvalue.signedness = SIGNED;
135	return PRED; }
136	"P"{PRED_ID}"N" {
137	yylval->rvalue.type = PREDICATE;
138	yylval->rvalue.pred.id = yytext[1];
139	yylval->rvalue.bit_width = 32;
140	yylval->rvalue.is_dotnew = true;
141	yylval->rvalue.signedness = SIGNED;
142	return PRED; }
fd8171fe PM	143	"+=" { return INC; }
	144	"-=" { return DEC; }
	145	"++" { return PLUSPLUS; }
	146	"&=" { return ANDA; }
	147	"\|=" { return ORA; }
	148	"^=" { return XORA; }
	149	"<<" { return ASL; }
	150	">>" { return ASR; }
	151	">>>" { return LSR; }
	152	"==" { return EQ; }
	153	"!=" { return NEQ; }
	154	"<=" { return LTE; }
	155	">=" { return GTE; }
	156	"&&" { return ANDL; }
	157	"else" { return ELSE; }
	158	"for" { return FOR; }
	159	"fREAD_IREG" { return ICIRC; }
fd8171fe	160	"if" { return IF; }
bbb71568	161	"fFRAME_SCRAMBLE" \|
fd8171fe PM	162	"fFRAME_UNSCRAMBLE" { return FSCR; }
	163	"fFRAMECHECK" { return FCHK; }
	164	"Constant_extended" { return CONSTEXT; }
	165	"fCL1_"{DIGIT} { return LOCNT; }
	166	"fbrev" { return BREV; }
	167	"fSXTN" { return SXT; }
	168	"fZXTN" { return ZXT; }
	169	"fDF_MAX" \|
	170	"fSF_MAX" \|
	171	"fMAX" { return MAX; }
	172	"fDF_MIN" \|
	173	"fSF_MIN" \|
	174	"fMIN" { return MIN; }
	175	"fABS" { return ABS; }
	176	"fRNDN" { return ROUND; }
	177	"fCRND" { return CROUND; }
	178	"fCRNDN" { return CROUND; }
	179	"fPM_CIRI" { return CIRCADD; }
	180	"fPM_CIRR" { return CIRCADD; }
	181	"fCOUNTONES_"{DIGIT} { return COUNTONES; }
	182	"fSATN" { yylval->sat.signedness = SIGNED;
	183	return SAT; }
	184	"fSATUN" { yylval->sat.signedness = UNSIGNED;
	185	return SAT; }
	186	"fCONSTLL" { yylval->cast.bit_width = 64;
	187	yylval->cast.signedness = SIGNED;
	188	return CAST; }
	189	"fSE32_64" { yylval->cast.bit_width = 64;
	190	yylval->cast.signedness = SIGNED;
	191	return CAST; }
	192	"fCAST4_4u" { yylval->cast.bit_width = 32;
	193	yylval->cast.signedness = UNSIGNED;
	194	return CAST; }
	195	"fCAST4_8s" { yylval->cast.bit_width = 64;
	196	yylval->cast.signedness = SIGNED;
	197	return CAST; }
	198	"fCAST4_8u" { return CAST4_8U; }
	199	"fCAST4u" { yylval->cast.bit_width = 32;
	200	yylval->cast.signedness = UNSIGNED;
	201	return CAST; }
	202	"fNEWREG" \|
	203	"fCAST4_4s" \|
	204	"fCAST4s" { yylval->cast.bit_width = 32;
	205	yylval->cast.signedness = SIGNED;
	206	return CAST; }
	207	"fCAST8_8u" { yylval->cast.bit_width = 64;
	208	yylval->cast.signedness = UNSIGNED;
	209	return CAST; }
	210	"fCAST8u" { yylval->cast.bit_width = 64;
	211	yylval->cast.signedness = UNSIGNED;
	212	return CAST; }
	213	"fCAST8_8s" \|
	214	"fCAST8s" { yylval->cast.bit_width = 64;
	215	yylval->cast.signedness = SIGNED;
	216	return CAST; }
	217	"fGETBIT" { yylval->extract.bit_width = 1;
	218	yylval->extract.storage_bit_width = 1;
	219	yylval->extract.signedness = UNSIGNED;
	220	return EXTRACT; }
	221	"fGETBYTE" { yylval->extract.bit_width = 8;
	222	yylval->extract.storage_bit_width = 8;
	223	yylval->extract.signedness = SIGNED;
	224	return EXTRACT; }
	225	"fGETUBYTE" { yylval->extract.bit_width = 8;
226	yylval->extract.storage_bit_width = 8;
227	yylval->extract.signedness = UNSIGNED;
228	return EXTRACT; }
229	"fGETHALF" { yylval->extract.bit_width = 16;
230	yylval->extract.storage_bit_width = 16;
231	yylval->extract.signedness = SIGNED;
232	return EXTRACT; }
233	"fGETUHALF" { yylval->extract.bit_width = 16;
234	yylval->extract.storage_bit_width = 16;
235	yylval->extract.signedness = UNSIGNED;
236	return EXTRACT; }
237	"fGETWORD" { yylval->extract.bit_width = 32;
238	yylval->extract.storage_bit_width = 64;
239	yylval->extract.signedness = SIGNED;
240	return EXTRACT; }
241	"fGETUWORD" { yylval->extract.bit_width = 32;
242	yylval->extract.storage_bit_width = 64;
243	yylval->extract.signedness = UNSIGNED;
244	return EXTRACT; }
245	"fEXTRACTU_RANGE" { return EXTRANGE; }
246	"fSETBIT" { yylval->cast.bit_width = 1;
247	yylval->cast.signedness = SIGNED;
248	return DEPOSIT; }
249	"fSETBYTE" { yylval->cast.bit_width = 8;
250	yylval->cast.signedness = SIGNED;
251	return DEPOSIT; }
252	"fSETHALF" { yylval->cast.bit_width = 16;
253	yylval->cast.signedness = SIGNED;
254	return SETHALF; }
255	"fSETWORD" { yylval->cast.bit_width = 32;
256	yylval->cast.signedness = SIGNED;
257	return DEPOSIT; }
258	"fINSERT_BITS" { return INSBITS; }
259	"fSETBITS" { return SETBITS; }
260	"fMPY16UU" { yylval->mpy.first_bit_width = 16;
261	yylval->mpy.second_bit_width = 16;
262	yylval->mpy.first_signedness = UNSIGNED;
263	yylval->mpy.second_signedness = UNSIGNED;
264	return MPY; }
265	"fMPY16SU" { yylval->mpy.first_bit_width = 16;
266	yylval->mpy.second_bit_width = 16;
267	yylval->mpy.first_signedness = SIGNED;
268	yylval->mpy.second_signedness = UNSIGNED;
269	return MPY; }
270	"fMPY16SS" { yylval->mpy.first_bit_width = 16;
271	yylval->mpy.second_bit_width = 16;
272	yylval->mpy.first_signedness = SIGNED;
273	yylval->mpy.second_signedness = SIGNED;
274	return MPY; }
275	"fMPY32UU" { yylval->mpy.first_bit_width = 32;
276	yylval->mpy.second_bit_width = 32;
277	yylval->mpy.first_signedness = UNSIGNED;
278	yylval->mpy.second_signedness = UNSIGNED;
279	return MPY; }
280	"fMPY32SU" { yylval->mpy.first_bit_width = 32;
281	yylval->mpy.second_bit_width = 32;
282	yylval->mpy.first_signedness = SIGNED;
283	yylval->mpy.second_signedness = UNSIGNED;
284	return MPY; }
285	"fSFMPY" \|
286	"fMPY32SS" { yylval->mpy.first_bit_width = 32;
287	yylval->mpy.second_bit_width = 32;
288	yylval->mpy.first_signedness = SIGNED;
289	yylval->mpy.second_signedness = SIGNED;
290	return MPY; }
291	"fMPY3216SS" { yylval->mpy.first_bit_width = 32;
292	yylval->mpy.second_bit_width = 16;
293	yylval->mpy.first_signedness = SIGNED;
294	yylval->mpy.second_signedness = SIGNED;
295	return MPY; }
296	"fMPY3216SU" { yylval->mpy.first_bit_width = 32;
297	yylval->mpy.second_bit_width = 16;
298	yylval->mpy.first_signedness = SIGNED;
299	yylval->mpy.second_signedness = UNSIGNED;
300	return MPY; }
301	"fNEWREG_ST" \|
302	"fIMMEXT" \|
303	"fMUST_IMMEXT" \|
304	"fPASS" \|
305	"fECHO" { return IDENTITY; }
306	"(size8u_t)" { yylval->cast.bit_width = 64;
307	yylval->cast.signedness = UNSIGNED;
308	return CAST; }
309	"(unsigned int)" { yylval->cast.bit_width = 32;
310	yylval->cast.signedness = UNSIGNED;
311	return CAST; }
bbb71568	312	"fREAD_PC()" { return PC; }
fd8171fe PM	313	"USR.LPCFG" { return LPCFG; }
fd8171fe PM	314	"LOAD_CANCEL(EA)" { return LOAD_CANCEL; }
7b84fd04	315	"STORE_CANCEL(EA)" { return STORE_CANCEL; }
fd8171fe PM	316	"CANCEL" { return CANCEL; }
	317	"N"{LOWER_ID}"N" { yylval->rvalue.type = REGISTER_ARG;
	318	yylval->rvalue.reg.type = DOTNEW;
	319	yylval->rvalue.reg.id = yytext[1];
	320	yylval->rvalue.reg.bit_width = 32;
	321	yylval->rvalue.bit_width = 32;
	322	yylval->rvalue.signedness = UNSIGNED;
	323	return REG; }
	324	"fREAD_SP()" \|
	325	"SP" { yylval->rvalue.type = REGISTER;
	326	yylval->rvalue.reg.type = GENERAL_PURPOSE;
	327	yylval->rvalue.reg.id = HEX_REG_SP;
	328	yylval->rvalue.reg.bit_width = 32;
	329	yylval->rvalue.bit_width = 32;
	330	yylval->rvalue.signedness = UNSIGNED;
	331	return REG; }
	332	"fREAD_FP()" \|
	333	"FP" { yylval->rvalue.type = REGISTER;
	334	yylval->rvalue.reg.type = GENERAL_PURPOSE;
	335	yylval->rvalue.reg.id = HEX_REG_FP;
	336	yylval->rvalue.reg.bit_width = 32;
	337	yylval->rvalue.bit_width = 32;
	338	yylval->rvalue.signedness = UNSIGNED;
	339	return REG; }
	340	"fREAD_LR()" \|
	341	"LR" { yylval->rvalue.type = REGISTER;
	342	yylval->rvalue.reg.type = GENERAL_PURPOSE;
	343	yylval->rvalue.reg.id = HEX_REG_LR;
	344	yylval->rvalue.reg.bit_width = 32;
	345	yylval->rvalue.bit_width = 32;
	346	yylval->rvalue.signedness = UNSIGNED;
	347	return REG; }
	348	"fREAD_GP()" \|
	349	"GP" { yylval->rvalue.type = REGISTER;
	350	yylval->rvalue.reg.type = CONTROL;
	351	yylval->rvalue.reg.id = HEX_REG_GP;
	352	yylval->rvalue.reg.bit_width = 32;
	353	yylval->rvalue.bit_width = 32;
	354	yylval->rvalue.signedness = UNSIGNED;
	355	return REG; }
fd8171fe PM	356	"LC"[01] { yylval->rvalue.type = REGISTER;
	357	yylval->rvalue.reg.type = CONTROL;
	358	yylval->rvalue.reg.id = HEX_REG_LC0
	359	+ (yytext[2] - '0') * 2;
	360	yylval->rvalue.reg.bit_width = 32;
	361	yylval->rvalue.bit_width = 32;
	362	yylval->rvalue.signedness = UNSIGNED;
	363	return REG; }
fd8171fe PM	364	"SA"[01] { yylval->rvalue.type = REGISTER;
	365	yylval->rvalue.reg.type = CONTROL;
	366	yylval->rvalue.reg.id = HEX_REG_SA0
	367	+ (yytext[2] - '0') * 2;
	368	yylval->rvalue.reg.bit_width = 32;
	369	yylval->rvalue.bit_width = 32;
	370	yylval->rvalue.signedness = UNSIGNED;
	371	return REG; }
	372	"fREAD_P0()" { yylval->rvalue.type = PREDICATE;
	373	yylval->rvalue.pred.id = '0';
	374	yylval->rvalue.bit_width = 32;
	375	return PRED; }
	376	[pP]{DIGIT} { yylval->rvalue.type = PREDICATE;
	377	yylval->rvalue.pred.id = yytext[1];
	378	yylval->rvalue.bit_width = 32;
	379	yylval->rvalue.is_dotnew = false;
	380	return PRED; }
	381	[pP]{DIGIT}[nN] { yylval->rvalue.type = PREDICATE;
	382	yylval->rvalue.pred.id = yytext[1];
	383	yylval->rvalue.bit_width = 32;
	384	yylval->rvalue.is_dotnew = true;
	385	return PRED; }
	386	"fLSBNEW" { return LSBNEW; }
	387	"N" { yylval->rvalue.type = IMMEDIATE;
	388	yylval->rvalue.bit_width = 32;
	389	yylval->rvalue.imm.type = VARIABLE;
	390	yylval->rvalue.imm.id = 'N';
	391	return IMM; }
	392	"i" { yylval->rvalue.type = IMMEDIATE;
	393	yylval->rvalue.bit_width = 32;
	394	yylval->rvalue.signedness = SIGNED;
	395	yylval->rvalue.imm.type = I;
	396	return IMM; }
	397	{SIGN_ID} { if (yytext[0] == 'u') {
	398	yylval->signedness = UNSIGNED;
	399	} else {
	400	yylval->signedness = SIGNED;
	401	}
	402	return SIGN;
	403	}
	404	"0x"{HEX_DIGIT}+ \|
	405	{DIGIT}+ { yylval->rvalue.type = IMMEDIATE;
	406	yylval->rvalue.bit_width = 32;
	407	yylval->rvalue.signedness = SIGNED;
	408	yylval->rvalue.imm.type = VALUE;
	409	yylval->rvalue.imm.value = strtoull(yytext, NULL, 0);
	410	return IMM; }
	411	"0x"{HEX_DIGIT}+"ULL" \|
	412	{DIGIT}+"ULL" { yylval->rvalue.type = IMMEDIATE;
	413	yylval->rvalue.bit_width = 64;
	414	yylval->rvalue.signedness = UNSIGNED;
	415	yylval->rvalue.imm.type = VALUE;
	416	yylval->rvalue.imm.value = strtoull(yytext, NULL, 0);
	417	return IMM; }
	418	"fLOAD" { return LOAD; }
	419	"fSTORE" { return STORE; }
	420	"fROTL" { return ROTL; }
	421	"fCARRY_FROM_ADD" { return CARRY_FROM_ADD; }
	422	"fADDSAT64" { return ADDSAT64; }
	423	"size"[1248][us]"_t" { /* Handles "size_t" variants of int types */
	424	const unsigned int bits_per_byte = 8;
	425	const unsigned int bytes = yytext[4] - '0';
	426	yylval->rvalue.bit_width = bits_per_byte * bytes;
	427	if (yytext[5] == 'u') {
428	yylval->rvalue.signedness = UNSIGNED;
429	} else {
430	yylval->rvalue.signedness = SIGNED;
431	}
432	return TYPE_SIZE_T; }
433	"unsigned" { return TYPE_UNSIGNED; }
434	"long" { return TYPE_LONG; }
435	"int" { return TYPE_INT; }
436	"const" { /* Emit no token */ }
437	{VAR_ID} { /* Variable name, we adopt the C names convention */
438	yylval->rvalue.type = VARID;
439	yylval->rvalue.var.name = g_string_new(yytext);
440	/* Default to an unknown signedness and 0 width. */
441	yylval->rvalue.bit_width = 0;
442	yylval->rvalue.signedness = UNKNOWN_SIGNEDNESS;
443	return VAR; }
444	"fatal("{STRING_LIT}")" { /* Emit no token */ }
445	"fHINTJR(RsV)" { /* Emit no token */ }
446	. { return yytext[0]; }
447
448	%%