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 sad2            { yylval.integer = BRW_OPCODE_SAD2; return SAD2; }
 116 sada2           { yylval.integer = BRW_OPCODE_SADA2; return SADA2; }
 117 sel             { yylval.integer = BRW_OPCODE_SEL; return SEL; }
 118 send            { yylval.integer = BRW_OPCODE_SEND; return SEND; }
 119 sendc           { yylval.integer = BRW_OPCODE_SENDC; return SENDC; }
 120 sends           { yylval.integer = BRW_OPCODE_SENDS; return SENDS; }
 121 sendsc          { yylval.integer = BRW_OPCODE_SENDSC; return SENDSC; }
 122 shl             { yylval.integer = BRW_OPCODE_SHL; return SHL; }
 123 shr             { yylval.integer = BRW_OPCODE_SHR; return SHR; }
 124 smov            { yylval.integer = BRW_OPCODE_SMOV; return SMOV; }
 125 subb            { yylval.integer = BRW_OPCODE_SUBB; return SUBB; }
 126 wait            { yylval.integer = BRW_OPCODE_WAIT; return WAIT; }
 127 while           { yylval.integer = BRW_OPCODE_WHILE; return WHILE; }
 128 xor             { yylval.integer = BRW_OPCODE_XOR; return XOR; }
 129
 130  /* extended math functions */
 131 cos             { yylval.integer = BRW_MATH_FUNCTION_COS; return COS; }
 132 exp             { yylval.integer = BRW_MATH_FUNCTION_EXP; return EXP; }
 133 fdiv            { yylval.integer = BRW_MATH_FUNCTION_FDIV; return FDIV; }
 134 inv             { yylval.integer = BRW_MATH_FUNCTION_INV; return INV; }
 135 invm            { yylval.integer = GEN8_MATH_FUNCTION_INVM; return INVM; }
 136 intdiv          {
 137                    yylval.integer = BRW_MATH_FUNCTION_INT_DIV_QUOTIENT;
 138                    return INTDIV;
 139                 }
 140 intdivmod       {
 141                    yylval.integer =
 142                       BRW_MATH_FUNCTION_INT_DIV_QUOTIENT_AND_REMAINDER;
 143                    return INTDIVMOD;
 144                 }
 145 intmod          {
 146                    yylval.integer = BRW_MATH_FUNCTION_INT_DIV_REMAINDER;
 147                    return INTMOD;
 148                 }
 149 log             { yylval.integer = BRW_MATH_FUNCTION_LOG; return LOG; }
 150 pow             { yylval.integer = BRW_MATH_FUNCTION_POW; return POW; }
 151 rsq             { yylval.integer = BRW_MATH_FUNCTION_RSQ; return RSQ; }
 152 rsqrtm          { yylval.integer = GEN8_MATH_FUNCTION_RSQRTM; return RSQRTM; }
 153 sin             { yylval.integer = BRW_MATH_FUNCTION_SIN; return SIN; }
 154 sqrt            { yylval.integer = BRW_MATH_FUNCTION_SQRT; return SQRT; }
 155 sincos          { yylval.integer = BRW_MATH_FUNCTION_SINCOS; return SINCOS; }
 156
 157  /* shared functions for send instruction */
 158 sampler                 { return SAMPLER; }
 159 dp_sampler              { return DP_SAMPLER; }
 160 gateway                 { return GATEWAY; }
 161 urb                     { return URB; }
 162 thread_spawner          { return THREAD_SPAWNER; }
 163 render                  { return RENDER; }
 164 const                   { return CONST; }
 165 data                    { return DATA; }
 166 cre                     { return CRE; }
 167 math                    { return MATH; }
 168 read                    { return READ; }
 169 write                   { return WRITE; }
 170 vme                     { return VME; }
 171 "pixel interp"          { return PIXEL_INTERP; }
 172 "dp data 1"             { return DP_DATA_1; }
 173
 174 ";"     { return SEMICOLON; }
 175 ":"     { return COLON; }
 176 "("     { return LPAREN; }
 177 ")"     { return RPAREN; }
 178 "{"     { return LCURLY; }
 179 "}"     { return RCURLY; }
 180 "["     { return LSQUARE; }
 181 "]"     { return RSQUARE; }
 182 "<"     { return LANGLE; }
 183 ">"     { return RANGLE; }
 184 ","     { return COMMA; }
 185 "."     { return DOT; }
 186 "+"     { return PLUS; }
 187 "-"     { return MINUS; }
 188 "~"     { return MINUS; }
 189 "(abs)" { return ABS; }
 190
 191
 192 "VxH"                   { return VxH; }
 193 <REG>"<"                { return LANGLE; }
 194 <REG>[0-9][0-9]*        {
 195                            yylval.integer = strtoul(yytext, NULL, 10);
 196                            return INTEGER;
 197                         }
 198 <REG>">"                { return RANGLE; }
 199 <REG>","                { return COMMA; }
 200 <REG>"."                { BEGIN(DOTSEL); return DOT; }
 201 <REG>";"                { return SEMICOLON; }
 202
 203 <DOTSEL>"x"             { yylval.integer = BRW_CHANNEL_X; return X; }
 204 <DOTSEL>"y"             { yylval.integer = BRW_CHANNEL_Y; return Y; }
 205 <DOTSEL>"z"             { yylval.integer = BRW_CHANNEL_Z; return Z; }
 206 <DOTSEL>"w"             { yylval.integer = BRW_CHANNEL_W; return W; }
 207 <DOTSEL>[0-9][0-9]*     {
 208                            yylval.integer = strtoul(yytext, NULL, 10);
 209                            BEGIN(REG);
 210                            return INTEGER;
 211                         }
 212 <DOTSEL>.               { yyless(0); BEGIN(INITIAL); }
 213 <REG>.                  { yyless(0); BEGIN(INITIAL); }
 214
 215  /* Access mode */
 216 "align1"        { return ALIGN1; }
 217 "align16"       { return ALIGN16; }
 218
 219  /* Accumulator write control */
 220 AccWrEnable     { return ACCWREN; }
 221
 222  /* Mask control (formerly WECtrl/Write Enable Control) */
 223 "WE_all"        { return WECTRL; }
 224
 225  /* Compaction control */
 226 compacted       { return CMPTCTRL; }
 227
 228  /* Debug control */
 229 breakpoint      { return BREAKPOINT; }
 230
 231  /* Dependency control */
 232 NoDDClr         { return NODDCLR; }
 233 NoDDChk         { return NODDCHK; }
 234
 235  /* End of thread */
 236 EOT             { return EOT; }
 237
 238  /* Mask control */
 239 nomask          { return MASK_DISABLE; }
 240
 241  /* Channel */
 242 <CHANNEL>"x"            { yylval.integer = BRW_CHANNEL_X; return X; }
 243 <CHANNEL>"y"            { yylval.integer = BRW_CHANNEL_Y; return Y; }
 244 <CHANNEL>"z"            { yylval.integer = BRW_CHANNEL_Z; return Z; }
 245 <CHANNEL>"w"            { yylval.integer = BRW_CHANNEL_W; return W; }
 246 <CHANNEL>[0-9][0-9]*    {
 247                            yylval.integer = strtoul(yytext, NULL, 10);
 248                            return INTEGER;
 249                         }
 250 <CHANNEL>"."            { return DOT; }
 251 <CHANNEL>.              { yyless(0); BEGIN(INITIAL); }
 252
 253
 254  /* Predicate Control */
 255 <CHANNEL>".anyv"        { yylval.integer = BRW_PREDICATE_ALIGN1_ANYV; return ANYV; }
 256 <CHANNEL>".allv"        { yylval.integer = BRW_PREDICATE_ALIGN1_ALLV; return ALLV; }
 257 <CHANNEL>".any2h"       { yylval.integer = BRW_PREDICATE_ALIGN1_ANY2H; return ANY2H; }
 258 <CHANNEL>".all2h"       { yylval.integer = BRW_PREDICATE_ALIGN1_ALL2H; return ALL2H; }
 259 <CHANNEL>".any4h"       { yylval.integer = BRW_PREDICATE_ALIGN16_ANY4H; return ANY4H; }
 260 <CHANNEL>".all4h"       { yylval.integer = BRW_PREDICATE_ALIGN16_ALL4H; return ALL4H; }
 261 <CHANNEL>".any8h"       { yylval.integer = BRW_PREDICATE_ALIGN1_ANY8H; return ANY8H; }
 262 <CHANNEL>".all8h"       { yylval.integer = BRW_PREDICATE_ALIGN1_ALL8H; return ALL8H; }
 263 <CHANNEL>".any16h"      { yylval.integer = BRW_PREDICATE_ALIGN1_ANY16H; return ANY16H; }
 264 <CHANNEL>".all16h"      { yylval.integer = BRW_PREDICATE_ALIGN1_ALL16H; return ALL16H; }
 265 <CHANNEL>".any32h"      { yylval.integer = BRW_PREDICATE_ALIGN1_ANY32H; return ANY32H; }
 266 <CHANNEL>".all32h"      { yylval.integer = BRW_PREDICATE_ALIGN1_ALL32H; return ALL32H; }
 267
 268  /* Saturation */
 269 ".sat"          { return SATURATE; }
 270
 271  /* Thread control */
 272 atomic          { return ATOMIC; }
 273 switch          { return SWITCH; }
 274
 275  /* compression control */
 276 compr           { return COMPR; }
 277 compr4          { return COMPR4; }
 278 sechalf         { return SECHALF; }
 279
 280  /* Quarter Control */
 281 1[HNQ]          { }
 282 "2Q"            { return QTR_2Q; }
 283 "3Q"            { return QTR_3Q; }
 284 "4Q"            { return QTR_4Q; }
 285 "2H"            { return QTR_2H; }
 286 "2N"            { return QTR_2N; }
 287 "3N"            { return QTR_3N; }
 288 "4N"            { return QTR_4N; }
 289 "5N"            { return QTR_5N; }
 290 "6N"            { return QTR_6N; }
 291 "7N"            { return QTR_7N; }
 292 "8N"            { return QTR_8N; }
 293
 294  /* data types */
 295 :?B     { return TYPE_B; }
 296 :?D     { return TYPE_D; }
 297 :?DF    { return TYPE_DF; }
 298 :?F     { return TYPE_F; }
 299 :?HF    { return TYPE_HF; }
 300 :?NF    { return TYPE_NF; }
 301 :?Q     { return TYPE_Q; }
 302 :?UB    { return TYPE_UB; }
 303 :?UD    { return TYPE_UD; }
 304 :?UW    { return TYPE_UW; }
 305 :?UQ    { return TYPE_UQ; }
 306 :?UV    { return TYPE_UV; }
 307 :?V     { return TYPE_V; }
 308 :?VF    { return TYPE_VF; }
 309 :?W     { return TYPE_W; }
 310
 311  /* Address registers */
 312 "a0"            { yylval.integer = atoi(yytext + 1); BEGIN(REG); return ADDRREG; }
 313
 314  /* accumulator registers */
 315 "acc"[0-9]+     { yylval.integer = atoi(yytext + 3); return ACCREG; }
 316
 317  /* channel enable registers */
 318 "ce0"           { return CHANNELENABLEREG; }
 319
 320  /* control registers */
 321 "cr0"           { return CONTROLREG; }
 322
 323  /* flag registers */
 324 "f"[0|1]        { BEGIN(CHANNEL); yylval.integer = atoi(yytext + 1); return FLAGREG; }
 325
 326  /* message control registers */
 327 "m"             { return MSGREGFILE; }
 328 m[0-9]+         { yylval.integer = atoi(yytext + 1); BEGIN(REG); return MSGREG; }
 329
 330  /* state register */
 331 sr[0-9]+        { yylval.integer = atoi(yytext + 2); return STATEREG; }
 332
 333  /* notification registers */
 334 "n"[0-2]+       { yylval.integer = atoi(yytext + 1); BEGIN(REG); return NOTIFYREG; }
 335
 336  /* IP register */
 337 "ip"            { return IPREG; }
 338
 339  /* Thread control register */
 340 "tdr0"          { return THREADREG; }
 341
 342  /* performance register */
 343 "tm0"           { BEGIN(REG); return PERFORMANCEREG; }
 344
 345 [gr][0-9]+      {
 346                    yylval.integer = atoi(yytext + 1);
 347                    BEGIN(REG); return GENREG;
 348                 }
 349 [gr]            { return GENREGFILE; }
 350 "mask"[0-9]+    { yylval.integer = atoi(yytext + 4); return MASKREG; }
 351
 352  /* Conditional modifiers */
 353 ".e"    { yylval.integer = BRW_CONDITIONAL_Z; return EQUAL; }
 354 ".g"    { yylval.integer = BRW_CONDITIONAL_G; return GREATER; }
 355 ".ge"   { yylval.integer = BRW_CONDITIONAL_GE; return GREATER_EQUAL; }
 356 ".l"    { yylval.integer = BRW_CONDITIONAL_L; return LESS; }
 357 ".le"   { yylval.integer = BRW_CONDITIONAL_LE; return LESS_EQUAL; }
 358 ".ne"   { yylval.integer = BRW_CONDITIONAL_NZ; return NOT_EQUAL; }
 359 ".nz"   { yylval.integer = BRW_CONDITIONAL_NZ; return NOT_ZERO; }
 360 ".o"    { yylval.integer = BRW_CONDITIONAL_O; return OVERFLOW; }
 361 ".r"    { yylval.integer = BRW_CONDITIONAL_R; return ROUND_INCREMENT; }
 362 ".u"    { yylval.integer = BRW_CONDITIONAL_U; return UNORDERED; }
 363 ".z"    { yylval.integer = BRW_CONDITIONAL_Z; return ZERO; }
 364
 365  /* Eat up JIP and UIP token, their values will be parsed
 366   * in numeric section
 367   */
 368 "JIP: "         { }
 369 "UIP: "         { }
 370 "Jump: "        { }
 371 "Pop: "         { }
 372 [ \t]+          { }
 373 "MsgDesc:"[^{]*         { }
 374
 375 "0x"[0-9a-f][0-9a-f]*   {
 376                            yylval.llint = strtoull(yytext + 2, NULL, 16);
 377                            return LONG;
 378                         }
 379 [0-9][0-9]*             {
 380                            yylval.llint = strtoll(yytext, NULL, 10);
 381                            return LONG;
 382                         }
 383
 384 \n      { yycolumn = 1; }
 385
 386 .       {
 387            fprintf(stderr, "%s: %d: %s: at \"%s\"\n",
 388                    input_filename, yylineno,
 389                    "unexpected token", lex_text());
 390         }
 391 %%
 392
 393 char *
 394 lex_text(void)
 395 {
 396         return yytext;
 397 }
 398
 399 #ifndef yywrap
 400 int yywrap()
 401 {
 402         return -1;
 403 }
 404 #endif