gas/itbl-parse.y

   1 /* itbl-parse.y
   2    Copyright (C) 1997  Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to the Free
  18    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  19    02111-1307, USA.  */
  20
  21 %{
  22
  23 /*
  24
  25 Yacc grammar for instruction table entries.
  26
  27 =======================================================================
  28 Original Instruction table specification document:
  29
  30             MIPS Coprocessor Table Specification
  31             ====================================
  32
  33 This document describes the format of the MIPS coprocessor table.  The
  34 table specifies a list of valid functions, data registers and control
  35 registers that can be used in coprocessor instructions.  This list,
  36 together with the coprocessor instruction classes listed below,
  37 specifies the complete list of coprocessor instructions that will
  38 be recognized and assembled by the GNU assembler.  In effect,
  39 this makes the GNU assembler table-driven, where the table is
  40 specified by the programmer.
  41
  42 The table is an ordinary text file that the GNU assembler reads when
  43 it starts.  Using the information in the table, the assembler
  44 generates an internal list of valid coprocessor registers and
  45 functions.  The assembler uses this internal list in addition to the
  46 standard MIPS registers and instructions which are built-in to the
  47 assembler during code generation.
  48
  49 To specify the coprocessor table when invoking the GNU assembler, use
  50 the command line option "--itbl file", where file is the
  51 complete name of the table, including path and extension.
  52
  53 Examples:
  54
  55             gas -t cop.tbl test.s -o test.o
  56             gas -t /usr/local/lib/cop.tbl test.s -o test.o
  57             gas --itbl d:\gnu\data\cop.tbl test.s -o test.o
  58
  59 Only one table may be supplied during a single invocation of
  60 the assembler.
  61
  62
  63 Instruction classes
  64 ===================
  65
  66 Below is a list of the valid coprocessor instruction classes for
  67 any given coprocessor "z".  These instructions are already recognized
  68 by the assembler, and are listed here only for reference.
  69
  70 Class   format                        instructions
  71 -------------------------------------------------
  72 Class1:
  73         op base rt offset
  74                                                             LWCz rt,offset (base)
  75                                                             SWCz rt,offset (base)
  76 Class2:
  77         COPz sub rt rd 0
  78                                                             MTCz rt,rd
  79                                                             MFCz rt,rd
  80                                                             CTCz rt,rd
  81                                                             CFCz rt,rd
  82 Class3:
  83         COPz CO cofun
  84                                                             COPz cofun
  85 Class4:
  86         COPz BC br offset
  87                                                             BCzT offset
  88                                                             BCzF offset
  89 Class5:
  90         COPz sub rt rd 0
  91                                                             DMFCz rt,rd
  92                                                             DMTCz rt,rd
  93 Class6:
  94         op base rt offset
  95                                                             LDCz rt,offset (base)
  96                                                             SDCz rt,offset (base)
  97 Class7:
  98         COPz BC br offset
  99                                                             BCzTL offset
 100                                                             BCzFL offset
 101
 102 The coprocessor table defines coprocessor-specific registers that can
 103 be used with all of the above classes of instructions, where
 104 appropriate.  It also defines additional coprocessor-specific
 105 functions for Class3 (COPz cofun) instructions, Thus, the table allows
 106 the programmer to use convenient mnemonics and operands for these
 107 functions, instead of the COPz mmenmonic and cofun operand.
 108
 109 The names of the MIPS general registers and their aliases are defined
 110 by the assembler and will be recognized as valid register names by the
 111 assembler when used (where allowed) in coprocessor instructions.
 112 However, the names and values of all coprocessor data and control
 113 register mnemonics must be specified in the coprocessor table.
 114
 115
 116 Table Grammar
 117 =============
 118
 119 Here is the grammar for the coprocessor table:
 120
 121             table -> entry*
 122
 123             entry -> [z entrydef] [comment] '\n'
 124
 125             entrydef -> type name val
 126             entrydef -> 'insn' name val funcdef ; type of entry (instruction)
 127
 128             z -> 'p'['0'..'3']               ; processor number
 129             type -> ['dreg' | 'creg' | 'greg' ]      ; type of entry (register)
 130         ; 'dreg', 'creg' or 'greg' specifies a data, control, or general
 131         ;           register mnemonic, respectively
 132             name -> [ltr|dec]*               ; mnemonic of register/function
 133             val -> [dec|hex]                 ; register/function number (integer constant)
 134
 135             funcdef -> frange flags fields
 136                                 ; bitfield range for opcode
 137                                 ; list of fields' formats
 138             fields -> field*
 139             field -> [','] ftype frange flags
 140             flags -> ['*' flagexpr]
 141             flagexpr -> '[' flagexpr ']'
 142             flagexpr -> val '|' flagexpr
 143             ftype -> [ type | 'immed' | 'addr' ]
 144         ; 'immed' specifies an immediate value; see grammar for "val" above
 145                 ; 'addr' specifies a C identifier; name of symbol to be resolved at
 146         ;           link time
 147             frange -> ':' val '-' val   ; starting to ending bit positions, where
 148                                 ; where 0 is least significant bit
 149             frange -> (null)            ; default range of 31-0 will be assumed
 150
 151             comment -> [';'|'#'] [char]*
 152             char -> any printable character
 153             ltr -> ['a'..'z'|'A'..'Z']
 154             dec -> ['0'..'9']*                                       ; value in decimal
 155             hex -> '0x'['0'..'9' | 'a'..'f' | 'A'..'F']*        ; value in hexidecimal
 156
 157
 158 Examples
 159 ========
 160
 161 Example 1:
 162
 163 The table:
 164
 165             p1 dreg d1 1             ; data register "d1" for COP1 has value 1
 166             p1 creg c3 3             ; ctrl register "c3" for COP1 has value 3
 167             p3 func fill 0x1f:24-20           ; function "fill" for COP3 has value 31 and
 168                         ; no fields
 169
 170 will allow the assembler to accept the following coprocessor instructions:
 171
 172             LWC1 d1,0x100 ($2)
 173             fill
 174
 175 Here, the general purpose register "$2", and instruction "LWC1", are standard
 176 mnemonics built-in to the MIPS assembler.
 177
 178
 179 Example 2:
 180
 181 The table:
 182
 183             p3 dreg d3 3             ; data register "d3" for COP3 has value 3
 184             p3 creg c2 22            ; control register "c2" for COP3 has value 22
 185             p3 func fee 0x1f:24-20 dreg:17-13 creg:12-8 immed:7-0
 186                 ; function "fee" for COP3 has value 31, and 3 fields
 187                 ; consisting of a data register, a control register,
 188                 ; and an immediate value.
 189
 190 will allow the assembler to accept the following coprocessor instruction:
 191
 192             fee d3,c2,0x1
 193
 194 and will emit the object code:
 195
 196             31-26  25 24-20 19-18  17-13 12-8  7-0
 197             COPz   CO fun                     dreg  creg  immed
 198             010011 1  11111 00       00011 10110 00000001
 199
 200             0x4ff07601
 201
 202
 203 Example 3:
 204
 205 The table:
 206
 207             p3 dreg d3 3             ; data register "d3" for COP3 has value 3
 208             p3 creg c2 22            ; control register "c2" for COP3 has value 22
 209             p3 func fuu 0x01f00001 dreg:17-13 creg:12-8
 210
 211 will allow the assembler to accept the following coprocessor
 212 instruction:
 213
 214             fuu d3,c2
 215
 216 and will emit the object code:
 217
 218             31-26  25 24-20 19-18  17-13 12-8  7-0
 219             COPz   CO fun                     dreg  creg
 220             010011 1  11111 00       00011 10110 00000001
 221
 222             0x4ff07601
 223
 224 In this way, the programmer can force arbitrary bits of an instruction
 225 to have predefined values.
 226
 227 =======================================================================
 228 Additional notes:
 229
 230 Encoding of ranges:
 231 To handle more than one bit position range within an instruction,
 232 use 0s to mask out the ranges which don't apply.
 233 May decide to modify the syntax to allow commas separate multiple
 234 ranges within an instruction (range','range).
 235
 236 Changes in grammar:
 237         The number of parms argument to the function entry
 238 was deleted from the original format such that we now count the fields.
 239
 240 ----
 241 FIXME! should really change lexical analyzer
 242 to recognize 'dreg' etc. in context sensative way.
 243 Currently function names or mnemonics may be incorrectly parsed as keywords
 244
 245 FIXME! hex is ambiguous with any digit
 246
 247 */
 248
 249 #include <stdio.h>
 250 #include "itbl-ops.h"
 251
 252 /* #define DEBUG */
 253
 254 #ifdef DEBUG
 255 #ifndef DBG_LVL
 256 #define DBG_LVL 1
 257 #endif
 258 #else
 259 #define DBG_LVL 0
 260 #endif
 261
 262 #if DBG_LVL >= 1
 263 #define DBG(x) printf x
 264 #else
 265 #define DBG(x)
 266 #endif
 267
 268 #if DBG_LVL >= 2
 269 #define DBGL2(x) printf x
 270 #else
 271 #define DBGL2(x)
 272 #endif
 273
 274 static int sbit, ebit;
 275 static struct itbl_entry *insn=0;
 276 extern int insntbl_line;
 277 int yyparse PARAMS ((void));
 278 int yylex PARAMS ((void));
 279 static int yyerror PARAMS ((const char *));
 280
 281 %}
 282
 283 %union
 284   {
 285     char *str;
 286     int num;
 287     int processor;
 288     unsigned long val;
 289   }
 290
 291 %token      DREG CREG GREG IMMED ADDR INSN NUM ID NL PNUM
 292 %type       <val> value flags flagexpr
 293 %type       <num> number NUM ftype regtype pnum PNUM
 294 %type       <str> ID name
 295
 296 %start insntbl
 297
 298 %%
 299
 300 insntbl:
 301         entrys
 302         ;
 303
 304 entrys:
 305         entry entrys
 306         |
 307         ;
 308
 309 entry:
 310         pnum regtype name value NL
 311           {
 312             DBG (("line %d: entry pnum=%d type=%d name=%s value=x%x\n",
 313                     insntbl_line, $1, $2, $3, $4));
 314             itbl_add_reg ($1, $2, $3, $4);
 315           }
 316         | pnum INSN name value range flags
 317           {
 318             DBG (("line %d: entry pnum=%d type=INSN name=%s value=x%x",
 319                     insntbl_line, $1, $3, $4));
 320             DBG ((" sbit=%d ebit=%d flags=0x%x\n", sbit, ebit, $6));
 321             insn=itbl_add_insn ($1, $3, $4, sbit, ebit, $6);
 322           }
 323         fieldspecs NL
 324         | NL
 325         | error NL
 326         ;
 327
 328 fieldspecs:
 329         ',' fieldspec fieldspecs
 330         | fieldspec fieldspecs
 331         |
 332         ;
 333
 334 ftype:
 335         regtype
 336           {
 337             DBGL2 (("ftype\n"));
 338             $$ = $1;
 339           }
 340         | ADDR
 341           {
 342             DBGL2 (("addr\n"));
 343             $$ = ADDR;
 344           }
 345         | IMMED
 346           {
 347             DBGL2 (("immed\n"));
 348             $$ = IMMED;
 349           }
 350         ;
 351
 352 fieldspec:
 353         ftype range flags
 354           {
 355             DBG (("line %d: field type=%d sbit=%d ebit=%d, flags=0x%x\n",
 356                     insntbl_line, $1, sbit, ebit, $3));
 357             itbl_add_operand (insn, $1, sbit, ebit, $3);
 358           }
 359         ;
 360
 361 flagexpr:
 362         NUM '|' flagexpr
 363           {
 364             $$ = $1 | $3;
 365           }
 366         | '[' flagexpr ']'
 367           {
 368             $$ = $2;
 369           }
 370         | NUM
 371           {
 372             $$ = $1;
 373           }
 374         ;
 375
 376 flags:
 377         '*' flagexpr
 378           {
 379             DBGL2 (("flags=%d\n", $2));
 380             $$ = $2;
 381           }
 382         |
 383           {
 384             $$ = 0;
 385           }
 386         ;
 387
 388 range:
 389         ':' NUM '-' NUM
 390           {
 391             DBGL2 (("range %d %d\n", $2, $4));
 392             sbit = $2;
 393             ebit = $4;
 394           }
 395         |
 396           {
 397             sbit = 31;
 398             ebit = 0;
 399           }
 400         ;
 401
 402 pnum:
 403         PNUM
 404           {
 405             DBGL2 (("pnum=%d\n",$1));
 406             $$ = $1;
 407           }
 408         ;
 409
 410 regtype:
 411              DREG
 412           {
 413             DBGL2 (("dreg\n"));
 414             $$ = DREG;
 415           }
 416         | CREG
 417           {
 418             DBGL2 (("creg\n"));
 419             $$ = CREG;
 420           }
 421         | GREG
 422           {
 423             DBGL2 (("greg\n"));
 424             $$ = GREG;
 425           }
 426         ;
 427
 428 name:
 429         ID
 430           {
 431             DBGL2 (("name=%s\n",$1));
 432             $$ = $1;
 433           }
 434         ;
 435
 436 number:
 437         NUM
 438           {
 439             DBGL2 (("num=%d\n",$1));
 440             $$ = $1;
 441           }
 442         ;
 443
 444 value:
 445         NUM
 446           {
 447             DBGL2 (("val=x%x\n",$1));
 448             $$ = $1;
 449           }
 450         ;
 451 %%
 452
 453 static int
 454 yyerror (msg)
 455      const char *msg;
 456 {
 457   printf ("line %d: %s\n", insntbl_line, msg);
 458   return 0;
 459 }