src/intel/tools/i965_lex.l

   1 %option yylineno
   2 %option nounput
   3 %{
   4 #include <string.h>
   5 #include "i965_asm.h"
   6 #include "i965_gram.tab.h"
   7
   8 /* Locations */
   9 int yycolumn = 1;
  10
  11 int saved_state = 0;
  12 extern char *input_filename;
  13
  14 #define YY_NO_INPUT
  15 #define YY_USER_ACTION                                          \
  16         yylloc.first_line = yylloc.last_line = yylineno;        \
  17         yylloc.first_column = yycolumn;                         \
  18         yylloc.last_column = yycolumn + yyleng - 1;             \
  19         yycolumn += yyleng;
  20 %}
  21
  22 %x BLOCK_COMMENT
  23 %x FILENAME
  24 %x CHANNEL
  25 %x REG
  26 %x DOTSEL
  27 %%
  28
  29  /* eat up single line comment */
  30 \/\/.*[\r\n]    { yycolumn = 1; }
  31
  32  /* eat up multiline comment */
  33 \/\*            { saved_state = YYSTATE; BEGIN(BLOCK_COMMENT); }
  34
  35 <BLOCK_COMMENT>\*\/     { BEGIN(saved_state); }
  36
  37 <BLOCK_COMMENT>.        { }
  38 <BLOCK_COMMENT>[\r\n]   { }
  39
  40 <FILENAME>\"[^\"]+\"    {
  41                            char *name = malloc(yyleng - 1);
  42                            memmove(name, yytext + 1, yyleng - 2);
  43                            name[yyleng-1] = '\0';
  44                            input_filename = name;
  45                         }
  46
  47  /* null register */
  48 null            { BEGIN(REG); return NULL_TOKEN; }
  49
  50  /* Opcodes */
  51 add             { yylval.integer = BRW_OPCODE_ADD; return ADD; }
  52 addc            { yylval.integer = BRW_OPCODE_ADDC; return ADDC; }
  53 and             { yylval.integer = BRW_OPCODE_AND; return AND; }
  54 asr             { yylval.integer = BRW_OPCODE_ASR; return ASR; }
  55 avg             { yylval.integer = BRW_OPCODE_AVG; return AVG; }
  56 bfe             { yylval.integer = BRW_OPCODE_BFE; return BFE; }
  57 bfi1            { yylval.integer = BRW_OPCODE_BFI1; return BFI1; }
  58 bfi2            { yylval.integer = BRW_OPCODE_BFI2; return BFI2; }
  59 bfrev           { yylval.integer = BRW_OPCODE_BFREV; return BFREV; }
  60 brc             { yylval.integer = BRW_OPCODE_BRC; return BRC; }
  61 brd             { yylval.integer = BRW_OPCODE_BRD; return BRD; }
  62 break           { yylval.integer = BRW_OPCODE_BREAK; return BREAK; }
  63 call            { yylval.integer = BRW_OPCODE_CALL; return CALL; }
  64 calla           { yylval.integer = BRW_OPCODE_CALLA; return CALLA; }
  65 case            { yylval.integer = BRW_OPCODE_CASE; return CASE; }
  66 cbit            { yylval.integer = BRW_OPCODE_CBIT; return CBIT; }
  67 cmp             { yylval.integer = BRW_OPCODE_CMP; return CMP; }
  68 cmpn            { yylval.integer = BRW_OPCODE_CMPN; return CMPN; }
  69 cont            { yylval.integer = BRW_OPCODE_CONTINUE; return CONT; }
  70 csel            { yylval.integer = BRW_OPCODE_CSEL; return CSEL; }
  71 dim             { yylval.integer = BRW_OPCODE_DIM; return DIM; }
  72 do              { yylval.integer = BRW_OPCODE_DO; return DO; }
  73 dp2             { yylval.integer = BRW_OPCODE_DP2; return DP2; }
  74 dp3             { yylval.integer = BRW_OPCODE_DP3; return DP3; }
  75 dp4             { yylval.integer = BRW_OPCODE_DP4; return DP4; }
  76 dph             { yylval.integer = BRW_OPCODE_DPH; return DPH; }
  77 else            { yylval.integer = BRW_OPCODE_ELSE; return ELSE; }
  78 endif           { yylval.integer = BRW_OPCODE_ENDIF; return ENDIF; }
  79 f16to32         { yylval.integer = BRW_OPCODE_F16TO32; return F16TO32; }
  80 f32to16         { yylval.integer = BRW_OPCODE_F32TO16; return F32TO16; }
  81 fbh             { yylval.integer = BRW_OPCODE_FBH; return FBH; }
  82 fbl             { yylval.integer = BRW_OPCODE_FBL; return FBL; }
  83 fork            { yylval.integer = BRW_OPCODE_FORK; return FORK; }
  84 frc             { yylval.integer = BRW_OPCODE_FRC; return FRC; }
  85 goto            { yylval.integer = BRW_OPCODE_GOTO; return GOTO; }
  86 halt            { yylval.integer = BRW_OPCODE_HALT; return HALT; }
  87 if              { yylval.integer = BRW_OPCODE_IF; return IF; }
  88 iff             { yylval.integer = BRW_OPCODE_IFF; return IFF; }
  89 illegal         { yylval.integer = BRW_OPCODE_ILLEGAL; return ILLEGAL; }
  90 jmpi            { yylval.integer = BRW_OPCODE_JMPI; return JMPI; }
  91 line            { yylval.integer = BRW_OPCODE_LINE; return LINE; }
  92 lrp             { yylval.integer = BRW_OPCODE_LRP; return LRP; }
  93 lzd             { yylval.integer = BRW_OPCODE_LZD; return LZD; }
  94 mac             { yylval.integer = BRW_OPCODE_MAC; return MAC; }
  95 mach            { yylval.integer = BRW_OPCODE_MACH; return MACH; }
  96 mad             { yylval.integer = BRW_OPCODE_MAD; return MAD; }
  97 madm            { yylval.integer = BRW_OPCODE_MADM; return MADM; }
  98 mov             { yylval.integer = BRW_OPCODE_MOV; return MOV; }
  99 movi            { yylval.integer = BRW_OPCODE_MOVI; return MOVI; }
 100 mul             { yylval.integer = BRW_OPCODE_MUL; return MUL; }
 101 mrest           { yylval.integer = BRW_OPCODE_MREST; return MREST; }
 102 msave           { yylval.integer = BRW_OPCODE_MSAVE; return MSAVE; }
 103 nenop           { yylval.integer = BRW_OPCODE_NENOP; return NENOP; }
 104 nop             { yylval.integer = BRW_OPCODE_NOP; return NOP; }
 105 not             { yylval.integer = BRW_OPCODE_NOT; return NOT; }
 106 or              { yylval.integer = BRW_OPCODE_OR; return OR; }
 107 pln             { yylval.integer = BRW_OPCODE_PLN; return PLN; }
 108 pop             { yylval.integer = BRW_OPCODE_POP; return POP; }
 109 push            { yylval.integer = BRW_OPCODE_PUSH; return PUSH; }
 110 ret             { yylval.integer = BRW_OPCODE_RET; return RET; }
 111 rndd            { yylval.integer = BRW_OPCODE_RNDD; return RNDD; }
 112 rnde            { yylval.integer = BRW_OPCODE_RNDE; return RNDE; }
 113 rndu            { yylval.integer = BRW_OPCODE_RNDU; return RNDU; }
 114 rndz            { yylval.integer = BRW_OPCODE_RNDZ; return RNDZ; }
 115 rol             { yylval.integer = BRW_OPCODE_ROL; return ROL; }
 116 ror             { yylval.integer = BRW_OPCODE_ROR; return ROR; }
 117 sad2            { yylval.integer = BRW_OPCODE_SAD2; return SAD2; }
 118 sada2           { yylval.integer = BRW_OPCODE_SADA2; return SADA2; }
 119 sel             { yylval.integer = BRW_OPCODE_SEL; return SEL; }
 120 send            { yylval.integer = BRW_OPCODE_SEND; return SEND; }
 121 sendc           { yylval.integer = BRW_OPCODE_SENDC; return SENDC; }
 122 sends           { yylval.integer = BRW_OPCODE_SENDS; return SENDS; }
 123 sendsc          { yylval.integer = BRW_OPCODE_SENDSC; return SENDSC; }
 124 shl             { yylval.integer = BRW_OPCODE_SHL; return SHL; }
 125 shr             { yylval.integer = BRW_OPCODE_SHR; return SHR; }
 126 smov            { yylval.integer = BRW_OPCODE_SMOV; return SMOV; }
 127 subb            { yylval.integer = BRW_OPCODE_SUBB; return SUBB; }
 128 wait            { yylval.integer = BRW_OPCODE_WAIT; return WAIT; }
 129 while           { yylval.integer = BRW_OPCODE_WHILE; return WHILE; }
 130 xor             { yylval.integer = BRW_OPCODE_XOR; return XOR; }
 131
 132  /* extended math functions */
 133 cos             { yylval.integer = BRW_MATH_FUNCTION_COS; return COS; }
 134 exp             { yylval.integer = BRW_MATH_FUNCTION_EXP; return EXP; }
 135 fdiv            { yylval.integer = BRW_MATH_FUNCTION_FDIV; return FDIV; }
 136 inv             { yylval.integer = BRW_MATH_FUNCTION_INV; return INV; }
 137 invm            { yylval.integer = GEN8_MATH_FUNCTION_INVM; return INVM; }
 138 intdiv          {
 139                    yylval.integer = BRW_MATH_FUNCTION_INT_DIV_QUOTIENT;
 140                    return INTDIV;
 141                 }
 142 intdivmod       {
 143                    yylval.integer =
 144                       BRW_MATH_FUNCTION_INT_DIV_QUOTIENT_AND_REMAINDER;
 145                    return INTDIVMOD;
 146                 }
 147 intmod          {
 148                    yylval.integer = BRW_MATH_FUNCTION_INT_DIV_REMAINDER;
 149                    return INTMOD;
 150                 }
 151 log             { yylval.integer = BRW_MATH_FUNCTION_LOG; return LOG; }
 152 pow             { yylval.integer = BRW_MATH_FUNCTION_POW; return POW; }
 153 rsq             { yylval.integer = BRW_MATH_FUNCTION_RSQ; return RSQ; }
 154 rsqrtm          { yylval.integer = GEN8_MATH_FUNCTION_RSQRTM; return RSQRTM; }
 155 sin             { yylval.integer = BRW_MATH_FUNCTION_SIN; return SIN; }
 156 sqrt            { yylval.integer = BRW_MATH_FUNCTION_SQRT; return SQRT; }
 157 sincos          { yylval.integer = BRW_MATH_FUNCTION_SINCOS; return SINCOS; }
 158
 159  /* shared functions for send instruction */
 160 sampler                 { return SAMPLER; }
 161 dp_sampler              { return DP_SAMPLER; }
 162 gateway                 { return GATEWAY; }
 163 urb                     { return URB; }
 164 thread_spawner          { return THREAD_SPAWNER; }
 165 render                  { return RENDER; }
 166 const                   { return CONST; }
 167 data                    { return DATA; }
 168 cre                     { return CRE; }
 169 math                    { return MATH; }
 170 read                    { return READ; }
 171 write                   { return WRITE; }
 172 vme                     { return VME; }
 173 "pixel interp"          { return PIXEL_INTERP; }
 174 "dp data 1"             { return DP_DATA_1; }
 175
 176 ";"     { return SEMICOLON; }
 177 ":"     { return COLON; }
 178 "("     { return LPAREN; }
 179 ")"     { return RPAREN; }
 180 "{"     { return LCURLY; }
 181 "}"     { return RCURLY; }
 182 "["     { return LSQUARE; }
 183 "]"     { return RSQUARE; }
 184 "<"     { return LANGLE; }
 185 ">"     { return RANGLE; }
 186 ","     { return COMMA; }
 187 "."     { return DOT; }
 188 "+"     { return PLUS; }
 189 "-"     { return MINUS; }
 190 "~"     { return MINUS; }
 191 "(abs)" { return ABS; }
 192
 193
 194 "VxH"                   { return VxH; }
 195 <REG>"<"                { return LANGLE; }
 196 <REG>[0-9][0-9]*        {
 197                            yylval.integer = strtoul(yytext, NULL, 10);
 198                            return INTEGER;
 199                         }
 200 <REG>">"                { return RANGLE; }
 201 <REG>","                { return COMMA; }
 202 <REG>"."                { BEGIN(DOTSEL); return DOT; }
 203 <REG>";"                { return SEMICOLON; }
 204
 205 <DOTSEL>"x"             { yylval.integer = BRW_CHANNEL_X; return X; }
 206 <DOTSEL>"y"             { yylval.integer = BRW_CHANNEL_Y; return Y; }
 207 <DOTSEL>"z"             { yylval.integer = BRW_CHANNEL_Z; return Z; }
 208 <DOTSEL>"w"             { yylval.integer = BRW_CHANNEL_W; return W; }
 209 <DOTSEL>[0-9][0-9]*     {
 210                            yylval.integer = strtoul(yytext, NULL, 10);
 211                            BEGIN(REG);
 212                            return INTEGER;
 213                         }
 214 <DOTSEL>.               { yyless(0); BEGIN(INITIAL); }
 215 <REG>.                  { yyless(0); BEGIN(INITIAL); }
 216
 217  /* Access mode */
 218 "align1"        { return ALIGN1; }
 219 "align16"       { return ALIGN16; }
 220
 221  /* Accumulator write control */
 222 AccWrEnable     { return ACCWREN; }
 223
 224  /* Mask control (formerly WECtrl/Write Enable Control) */
 225 "WE_all"        { return WECTRL; }
 226
 227  /* Compaction control */
 228 compacted       { return CMPTCTRL; }
 229
 230  /* Debug control */
 231 breakpoint      { return BREAKPOINT; }
 232
 233  /* Dependency control */
 234 NoDDClr         { return NODDCLR; }
 235 NoDDChk         { return NODDCHK; }
 236
 237  /* End of thread */
 238 EOT             { return EOT; }
 239
 240  /* Mask control */
 241 nomask          { return MASK_DISABLE; }
 242
 243  /* Channel */
 244 <CHANNEL>"x"            { yylval.integer = BRW_CHANNEL_X; return X; }
 245 <CHANNEL>"y"            { yylval.integer = BRW_CHANNEL_Y; return Y; }
 246 <CHANNEL>"z"            { yylval.integer = BRW_CHANNEL_Z; return Z; }
 247 <CHANNEL>"w"            { yylval.integer = BRW_CHANNEL_W; return W; }
 248 <CHANNEL>[0-9][0-9]*    {
 249                            yylval.integer = strtoul(yytext, NULL, 10);
 250                            return INTEGER;
 251                         }
 252 <CHANNEL>"."            { return DOT; }
 253 <CHANNEL>.              { yyless(0); BEGIN(INITIAL); }
 254
 255
 256  /* Predicate Control */
 257 <CHANNEL>".anyv"        { yylval.integer = BRW_PREDICATE_ALIGN1_ANYV; return ANYV; }
 258 <CHANNEL>".allv"        { yylval.integer = BRW_PREDICATE_ALIGN1_ALLV; return ALLV; }
 259 <CHANNEL>".any2h"       { yylval.integer = BRW_PREDICATE_ALIGN1_ANY2H; return ANY2H; }
 260 <CHANNEL>".all2h"       { yylval.integer = BRW_PREDICATE_ALIGN1_ALL2H; return ALL2H; }
 261 <CHANNEL>".any4h"       { yylval.integer = BRW_PREDICATE_ALIGN16_ANY4H; return ANY4H; }
 262 <CHANNEL>".all4h"       { yylval.integer = BRW_PREDICATE_ALIGN16_ALL4H; return ALL4H; }
 263 <CHANNEL>".any8h"       { yylval.integer = BRW_PREDICATE_ALIGN1_ANY8H; return ANY8H; }
 264 <CHANNEL>".all8h"       { yylval.integer = BRW_PREDICATE_ALIGN1_ALL8H; return ALL8H; }
 265 <CHANNEL>".any16h"      { yylval.integer = BRW_PREDICATE_ALIGN1_ANY16H; return ANY16H; }
 266 <CHANNEL>".all16h"      { yylval.integer = BRW_PREDICATE_ALIGN1_ALL16H; return ALL16H; }
 267 <CHANNEL>".any32h"      { yylval.integer = BRW_PREDICATE_ALIGN1_ANY32H; return ANY32H; }
 268 <CHANNEL>".all32h"      { yylval.integer = BRW_PREDICATE_ALIGN1_ALL32H; return ALL32H; }
 269
 270  /* Saturation */
 271 ".sat"          { return SATURATE; }
 272
 273  /* Thread control */
 274 atomic          { return ATOMIC; }
 275 switch          { return SWITCH; }
 276
 277  /* compression control */
 278 compr           { return COMPR; }
 279 compr4          { return COMPR4; }
 280 sechalf         { return SECHALF; }
 281
 282  /* Quarter Control */
 283 1[HNQ]          { }
 284 "2Q"            { return QTR_2Q; }
 285 "3Q"            { return QTR_3Q; }
 286 "4Q"            { return QTR_4Q; }
 287 "2H"            { return QTR_2H; }
 288 "2N"            { return QTR_2N; }
 289 "3N"            { return QTR_3N; }
 290 "4N"            { return QTR_4N; }
 291 "5N"            { return QTR_5N; }
 292 "6N"            { return QTR_6N; }
 293 "7N"            { return QTR_7N; }
 294 "8N"            { return QTR_8N; }
 295
 296  /* data types */
 297 :?B     { return TYPE_B; }
 298 :?D     { return TYPE_D; }
 299 :?DF    { return TYPE_DF; }
 300 :?F     { return TYPE_F; }
 301 :?HF    { return TYPE_HF; }
 302 :?NF    { return TYPE_NF; }
 303 :?Q     { return TYPE_Q; }
 304 :?UB    { return TYPE_UB; }
 305 :?UD    { return TYPE_UD; }
 306 :?UW    { return TYPE_UW; }
 307 :?UQ    { return TYPE_UQ; }
 308 :?UV    { return TYPE_UV; }
 309 :?V     { return TYPE_V; }
 310 :?VF    { return TYPE_VF; }
 311 :?W     { return TYPE_W; }
 312
 313  /* Address registers */
 314 "a0"            { return ADDRREG; }
 315
 316  /* accumulator registers */
 317 "acc"[0-9]+     { yylval.integer = atoi(yytext + 3); return ACCREG; }
 318
 319  /* channel enable registers */
 320 "ce0"           { return CHANNELENABLEREG; }
 321
 322  /* control registers */
 323 "cr0"           { return CONTROLREG; }
 324
 325  /* flag registers */
 326 "f"[0|1]        { BEGIN(CHANNEL); yylval.integer = atoi(yytext + 1); return FLAGREG; }
 327
 328  /* message control registers */
 329 "m"             { return MSGREGFILE; }
 330 m[0-9]+         { yylval.integer = atoi(yytext + 1); BEGIN(REG); return MSGREG; }
 331
 332  /* state register */
 333 sr[0-9]+        { yylval.integer = atoi(yytext + 2); return STATEREG; }
 334
 335  /* notification registers */
 336 "n0"            { BEGIN(REG); return NOTIFYREG; }
 337
 338  /* IP register */
 339 "ip"            { return IPREG; }
 340
 341  /* Thread control register */
 342 "tdr0"          { return THREADREG; }
 343
 344  /* performance register */
 345 "tm0"           { BEGIN(REG); return PERFORMANCEREG; }
 346
 347 [gr][0-9]+      {
 348                    yylval.integer = atoi(yytext + 1);
 349                    BEGIN(REG); return GENREG;
 350                 }
 351 [gr]            { return GENREGFILE; }
 352 "mask"[0-9]+    { yylval.integer = atoi(yytext + 4); return MASKREG; }
 353
 354  /* Conditional modifiers */
 355 ".e"    { yylval.integer = BRW_CONDITIONAL_Z; return EQUAL; }
 356 ".g"    { yylval.integer = BRW_CONDITIONAL_G; return GREATER; }
 357 ".ge"   { yylval.integer = BRW_CONDITIONAL_GE; return GREATER_EQUAL; }
 358 ".l"    { yylval.integer = BRW_CONDITIONAL_L; return LESS; }
 359 ".le"   { yylval.integer = BRW_CONDITIONAL_LE; return LESS_EQUAL; }
 360 ".ne"   { yylval.integer = BRW_CONDITIONAL_NZ; return NOT_EQUAL; }
 361 ".nz"   { yylval.integer = BRW_CONDITIONAL_NZ; return NOT_ZERO; }
 362 ".o"    { yylval.integer = BRW_CONDITIONAL_O; return OVERFLOW; }
 363 ".r"    { yylval.integer = BRW_CONDITIONAL_R; return ROUND_INCREMENT; }
 364 ".u"    { yylval.integer = BRW_CONDITIONAL_U; return UNORDERED; }
 365 ".z"    { yylval.integer = BRW_CONDITIONAL_Z; return ZERO; }
 366
 367  /* Eat up JIP and UIP token, their values will be parsed
 368   * in numeric section
 369   */
 370 "JIP: "         { }
 371 "UIP: "         { }
 372 "Jump: "        { }
 373 "Pop: "         { }
 374 [ \t]+          { }
 375 "MsgDesc:"[^{]*         { }
 376
 377 "0x"[0-9a-f][0-9a-f]*   {
 378                            yylval.llint = strtoull(yytext + 2, NULL, 16);
 379                            return LONG;
 380                         }
 381 [0-9][0-9]*             {
 382                            yylval.llint = strtoll(yytext, NULL, 10);
 383                            return LONG;
 384                         }
 385
 386 \n      { yycolumn = 1; }
 387
 388 .       {
 389            fprintf(stderr, "%s: %d: %s: at \"%s\"\n",
 390                    input_filename, yylineno,
 391                    "unexpected token", lex_text());
 392         }
 393 %%
 394
 395 char *
 396 lex_text(void)
 397 {
 398         return yytext;
 399 }
 400
 401 #ifndef yywrap
 402 int yywrap()
 403 {
 404         return -1;
 405 }
 406 #endif