git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/script_asm.pl

   1 #!/usr/bin/perl -s
   2
   3 # NCR 53c810 script assembler
   4 # Sponsored by
   5 #       iX Multiuser Multitasking Magazine
   6 #
   7 # Copyright 1993, Drew Eckhardt
   8 #      Visionary Computing
   9 #      (Unix and Linux consulting and custom programming)
  10 #      drew@Colorado.EDU
  11 #      +1 (303) 786-7975
  12 #
  13 #   Support for 53c710 (via -ncr7x0_family switch) added by Richard
  14 #   Hirst <richard@sleepie.demon.co.uk> - 15th March 1997
  15 #
  16 #   This program is free software; you can redistribute it and/or modify
  17 #   it under the terms of the GNU General Public License as published by
  18 #   the Free Software Foundation; either version 2 of the License, or
  19 #   (at your option) any later version.
  20 #
  21 #   This program is distributed in the hope that it will be useful,
  22 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 #   GNU General Public License for more details.
  25 #
  26 #   You should have received a copy of the GNU General Public License
  27 #   along with this program; if not, write to the Free Software
  28 #   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29 #
  30 # TolerANT and SCSI SCRIPTS are registered trademarks of NCR Corporation.
  31 #
  32
  33 #
  34 # Basically, I follow the NCR syntax documented in the NCR53c710
  35 # Programmer's guide, with the new instructions, registers, etc.
  36 # from the NCR53c810.
  37 #
  38 # Differences between this assembler and NCR's are that
  39 # 1.  PASS, REL (data, JUMPs work fine), and the option to start a new
  40 #       script,  are unimplemented, since I didn't use them in my scripts.
  41 #
  42 # 2.  I also emit a script_u.h file, which will undefine all of
  43 #       the A_*, E_*, etc. symbols defined in the script.  This
  44 #       makes including multiple scripts in one program easier
  45 #
  46 # 3.  This is a single pass assembler, which only emits
  47 #       .h files.
  48 #
  49
  50
  51 # XXX - set these with command line options
  52 $debug = 0;             # Print general debugging messages
  53 $debug_external = 0;    # Print external/forward reference messages
  54 $list_in_array = 1;     # Emit original SCRIPTS assembler in comments in
  55                         # script.h
  56 #$prefix;               # (set by perl -s)
  57                         # define all arrays having this prefix so we
  58                         # don't have name space collisions after
  59                         # assembling this file in different ways for
  60                         # different host adapters
  61
  62 # Constants
  63
  64
  65 # Table of the SCSI phase encodings
  66 %scsi_phases = (
  67     'DATA_OUT', 0x00_00_00_00, 'DATA_IN', 0x01_00_00_00, 'CMD', 0x02_00_00_00,
  68     'STATUS', 0x03_00_00_00, 'MSG_OUT', 0x06_00_00_00, 'MSG_IN', 0x07_00_00_00
  69 );
  70
  71 # XXX - replace references to the *_810 constants with general constants
  72 # assigned at compile time based on chip type.
  73
  74 # Table of operator encodings
  75 # XXX - NCR53c710 only implements
  76 #       move (nop) = 0x00_00_00_00
  77 #       or = 0x02_00_00_00
  78 #       and = 0x04_00_00_00
  79 #       add = 0x06_00_00_00
  80
  81 if ($ncr7x0_family) {
  82   %operators = (
  83     '|', 0x02_00_00_00, 'OR', 0x02_00_00_00,
  84     '&', 0x04_00_00_00, 'AND', 0x04_00_00_00,
  85     '+', 0x06_00_00_00
  86   );
  87 }
  88 else {
  89   %operators = (
  90     'SHL',  0x01_00_00_00,
  91     '|', 0x02_00_00_00, 'OR', 0x02_00_00_00,
  92     'XOR', 0x03_00_00_00,
  93     '&', 0x04_00_00_00, 'AND', 0x04_00_00_00,
  94     'SHR', 0x05_00_00_00,
  95     # Note : low bit of the operator bit should be set for add with
  96     # carry.
  97     '+', 0x06_00_00_00
  98   );
  99 }
 100
 101 # Table of register addresses
 102
 103 if ($ncr7x0_family) {
 104   %registers = (
 105     'SCNTL0', 0, 'SCNTL1', 1, 'SDID', 2, 'SIEN', 3,
 106     'SCID', 4, 'SXFER', 5, 'SODL', 6, 'SOCL', 7,
 107     'SFBR', 8, 'SIDL', 9, 'SBDL', 10, 'SBCL', 11,
 108     'DSTAT', 12, 'SSTAT0', 13, 'SSTAT1', 14, 'SSTAT2', 15,
 109     'DSA0', 16, 'DSA1', 17, 'DSA2', 18, 'DSA3', 19,
 110     'CTEST0', 20, 'CTEST1', 21, 'CTEST2', 22, 'CTEST3', 23,
 111     'CTEST4', 24, 'CTEST5', 25, 'CTEST6', 26, 'CTEST7', 27,
 112     'TEMP0', 28, 'TEMP1', 29, 'TEMP2', 30, 'TEMP3', 31,
 113     'DFIFO', 32, 'ISTAT', 33, 'CTEST8', 34, 'LCRC', 35,
 114     'DBC0', 36, 'DBC1', 37, 'DBC2', 38, 'DCMD', 39,
 115     'DNAD0', 40, 'DNAD1', 41, 'DNAD2', 42, 'DNAD3', 43,
 116     'DSP0', 44, 'DSP1', 45, 'DSP2', 46, 'DSP3', 47,
 117     'DSPS0', 48, 'DSPS1', 49, 'DSPS2', 50, 'DSPS3', 51,
 118     'SCRATCH0', 52, 'SCRATCH1', 53, 'SCRATCH2', 54, 'SCRATCH3', 55,
 119     'DMODE', 56, 'DIEN', 57, 'DWT', 58, 'DCNTL', 59,
 120     'ADDER0', 60, 'ADDER1', 61, 'ADDER2', 62, 'ADDER3', 63,
 121   );
 122 }
 123 else {
 124   %registers = (
 125     'SCNTL0', 0, 'SCNTL1', 1, 'SCNTL2', 2, 'SCNTL3', 3,
 126     'SCID', 4, 'SXFER', 5, 'SDID', 6, 'GPREG', 7,
 127     'SFBR', 8, 'SOCL', 9, 'SSID', 10, 'SBCL', 11,
 128     'DSTAT', 12, 'SSTAT0', 13, 'SSTAT1', 14, 'SSTAT2', 15,
 129     'DSA0', 16, 'DSA1', 17, 'DSA2', 18, 'DSA3', 19,
 130     'ISTAT', 20,
 131     'CTEST0', 24, 'CTEST1', 25, 'CTEST2', 26, 'CTEST3', 27,
 132     'TEMP0', 28, 'TEMP1', 29, 'TEMP2', 30, 'TEMP3', 31,
 133     'DFIFO', 32, 'CTEST4', 33, 'CTEST5', 34, 'CTEST6', 35,
 134     'DBC0', 36, 'DBC1', 37, 'DBC2', 38, 'DCMD', 39,
 135     'DNAD0', 40, 'DNAD1', 41, 'DNAD2', 42, 'DNAD3', 43,
 136     'DSP0', 44, 'DSP1', 45, 'DSP2', 46, 'DSP3', 47,
 137     'DSPS0', 48, 'DSPS1', 49, 'DSPS2', 50, 'DSPS3', 51,
 138     'SCRATCH0', 52, 'SCRATCH1', 53, 'SCRATCH2', 54, 'SCRATCH3', 55,
 139     'SCRATCHA0', 52, 'SCRATCHA1', 53, 'SCRATCHA2', 54, 'SCRATCHA3', 55,
 140     'DMODE', 56, 'DIEN', 57, 'DWT', 58, 'DCNTL', 59,
 141     'ADDER0', 60, 'ADDER1', 61, 'ADDER2', 62, 'ADDER3', 63,
 142     'SIEN0', 64, 'SIEN1', 65, 'SIST0', 66, 'SIST1', 67,
 143     'SLPAR', 68,              'MACNTL', 70, 'GPCNTL', 71,
 144     'STIME0', 72, 'STIME1', 73, 'RESPID', 74,
 145     'STEST0', 76, 'STEST1', 77, 'STEST2', 78, 'STEST3', 79,
 146     'SIDL', 80,
 147     'SODL', 84,
 148     'SBDL', 88,
 149     'SCRATCHB0', 92, 'SCRATCHB1', 93, 'SCRATCHB2', 94, 'SCRATCHB3', 95
 150   );
 151 }
 152
 153 # Parsing regular expressions
 154 $identifier = '[A-Za-z_][A-Za-z_0-9]*';
 155 $decnum = '-?\\d+';
 156 $hexnum = '0[xX][0-9A-Fa-f]+';
 157 $constant = "$hexnum|$decnum";
 158
 159 # yucky - since we can't control grouping of # $constant, we need to
 160 # expand out each alternative for $value.
 161
 162 $value = "$identifier|$identifier\\s*[+\-]\\s*$decnum|".
 163     "$identifier\\s*[+-]\s*$hexnum|$constant";
 164
 165 print STDERR "value regex = $value\n" if ($debug);
 166
 167 $phase = join ('|', keys %scsi_phases);
 168 print STDERR "phase regex = $phase\n" if ($debug);
 169 $register = join ('|', keys %registers);
 170
 171 # yucky - since %operators includes meta-characters which must
 172 # be escaped, I can't use the join() trick I used for the register
 173 # regex
 174
 175 if ($ncr7x0_family) {
 176   $operator = '\||OR|AND|\&|\+';
 177 }
 178 else {
 179   $operator = '\||OR|AND|XOR|\&|\+';
 180 }
 181
 182 # Global variables
 183
 184 %symbol_values = (%registers) ;         # Traditional symbol table
 185
 186 %symbol_references = () ;               # Table of symbol references, where
 187                                         # the index is the symbol name,
 188                                         # and the contents a white space
 189                                         # delimited list of address,size
 190                                         # tuples where size is in bytes.
 191
 192 @code = ();                             # Array of 32 bit words for SIOP
 193
 194 @entry = ();                            # Array of entry point names
 195
 196 @label = ();                            # Array of label names
 197
 198 @absolute = ();                         # Array of absolute names
 199
 200 @relative = ();                         # Array of relative names
 201
 202 @external = ();                         # Array of external names
 203
 204 $address = 0;                           # Address of current instruction
 205
 206 $lineno = 0;                            # Line number we are parsing
 207
 208 $output = 'script.h';                   # Output file
 209 $outputu = 'scriptu.h';
 210
 211 # &patch ($address, $offset, $length, $value) patches $code[$address]
 212 #       so that the $length bytes at $offset have $value added to
 213 #       them.
 214
 215 @inverted_masks = (0x00_00_00_00, 0x00_00_00_ff, 0x00_00_ff_ff, 0x00_ff_ff_ff,
 216     0xff_ff_ff_ff);
 217
 218 sub patch {
 219     local ($address, $offset, $length, $value) = @_;
 220     if ($debug) {
 221         print STDERR "Patching $address at offset $offset, length $length to $value\n";
 222         printf STDERR "Old code : %08x\n", $code[$address];
 223      }
 224
 225     $mask = ($inverted_masks[$length] << ($offset * 8));
 226
 227     $code[$address] = ($code[$address] & ~$mask) |
 228         (($code[$address] & $mask) + ($value << ($offset * 8)) &
 229         $mask);
 230
 231     printf STDERR "New code : %08x\n", $code[$address] if ($debug);
 232 }
 233
 234 # &parse_value($value, $word, $offset, $length) where $value is
 235 #       an identifier or constant, $word is the word offset relative to
 236 #       $address, $offset is the starting byte within that word, and
 237 #       $length is the length of the field in bytes.
 238 #
 239 # Side effects are that the bytes are combined into the @code array
 240 #       relative to $address, and that the %symbol_references table is
 241 #       updated as appropriate.
 242
 243 sub parse_value {
 244     local ($value, $word, $offset, $length) = @_;
 245     local ($tmp);
 246
 247     $symbol = '';
 248
 249     if ($value =~ /^REL\s*\(\s*($identifier)\s*\)\s*(.*)/i) {
 250         $relative = 'REL';
 251         $symbol = $1;
 252         $value = $2;
 253 print STDERR "Relative reference $symbol\n" if ($debug);
 254     } elsif ($value =~ /^($identifier)\s*(.*)/) {
 255         $relative = 'ABS';
 256         $symbol = $1;
 257         $value = $2;
 258 print STDERR "Absolute reference $symbol\n" if ($debug);
 259     }
 260
 261     if ($symbol ne '') {
 262 print STDERR "Referencing symbol $1, length = $length in $_\n" if ($debug);
 263         $tmp = ($address + $word) * 4 + $offset;
 264         if ($symbol_references{$symbol} ne undef) {
 265             $symbol_references{$symbol} =
 266                 "$symbol_references{$symbol} $relative,$tmp,$length";
 267         } else {
 268             if (!defined($symbol_values{$symbol})) {
 269 print STDERR "forward $1\n" if ($debug_external);
 270                 $forward{$symbol} = "line $lineno : $_";
 271             }
 272             $symbol_references{$symbol} = "$relative,$tmp,$length";
 273         }
 274     }
 275
 276     $value = eval $value;
 277     &patch ($address + $word, $offset, $length, $value);
 278 }
 279
 280 # &parse_conditional ($conditional) where $conditional is the conditional
 281 # clause from a transfer control instruction (RETURN, CALL, JUMP, INT).
 282
 283 sub parse_conditional {
 284     local ($conditional) = @_;
 285     if ($conditional =~ /^\s*(IF|WHEN)\s*(.*)/i) {
 286         $if = $1;
 287         $conditional = $2;
 288         if ($if =~ /WHEN/i) {
 289             $allow_atn = 0;
 290             $code[$address] |= 0x00_01_00_00;
 291             $allow_atn = 0;
 292             print STDERR "$0 : parsed WHEN\n" if ($debug);
 293         } else {
 294             $allow_atn = 1;
 295             print STDERR "$0 : parsed IF\n" if ($debug);
 296         }
 297     } else {
 298             die "$0 : syntax error in line $lineno : $_
 299         expected IF or WHEN
 300 ";
 301     }
 302
 303     if ($conditional =~ /^NOT\s+(.*)$/i) {
 304         $not = 'NOT ';
 305         $other = 'OR';
 306         $conditional = $1;
 307         print STDERR "$0 : parsed NOT\n" if ($debug);
 308     } else {
 309         $code[$address] |= 0x00_08_00_00;
 310         $not = '';
 311         $other = 'AND'
 312     }
 313
 314     $need_data = 0;
 315     if ($conditional =~ /^ATN\s*(.*)/i) {#
 316         die "$0 : syntax error in line $lineno : $_
 317         WHEN conditional is incompatible with ATN
 318 " if (!$allow_atn);
 319         $code[$address] |= 0x00_02_00_00;
 320         $conditional = $1;
 321         print STDERR "$0 : parsed ATN\n" if ($debug);
 322     } elsif ($conditional =~ /^($phase)\s*(.*)/i) {
 323         $phase_index = "\U$1\E";
 324         $p = $scsi_phases{$phase_index};
 325         $code[$address] |= $p | 0x00_02_00_00;
 326         $conditional = $2;
 327         print STDERR "$0 : parsed phase $phase_index\n" if ($debug);
 328     } else {
 329         $other = '';
 330         $need_data = 1;
 331     }
 332
 333 print STDERR "Parsing conjunction, expecting $other\n" if ($debug);
 334     if ($conditional =~ /^(AND|OR)\s*(.*)/i) {
 335         $conjunction = $1;
 336         $conditional = $2;
 337         $need_data = 1;
 338         die "$0 : syntax error in line $lineno : $_
 339             Illegal use of $1.  Valid uses are
 340             ".$not."<phase> $1 data
 341             ".$not."ATN $1 data
 342 " if ($other eq '');
 343         die "$0 : syntax error in line $lineno : $_
 344         Illegal use of $conjunction.  Valid syntaxes are
 345                 NOT <phase>|ATN OR data
 346                 <phase>|ATN AND data
 347 " if ($conjunction !~ /\s*$other\s*/i);
 348         print STDERR "$0 : parsed $1\n" if ($debug);
 349     }
 350
 351     if ($need_data) {
 352 print STDERR "looking for data in $conditional\n" if ($debug);
 353         if ($conditional=~ /^($value)\s*(.*)/i) {
 354             $code[$address] |= 0x00_04_00_00;
 355             $conditional = $2;
 356             &parse_value($1, 0, 0, 1);
 357             print STDERR "$0 : parsed data\n" if ($debug);
 358         } else {
 359         die "$0 : syntax error in line $lineno : $_
 360         expected <data>.
 361 ";
 362         }
 363     }
 364
 365     if ($conditional =~ /^\s*,\s*(.*)/) {
 366         $conditional = $1;
 367         if ($conditional =~ /^AND\s\s*MASK\s\s*($value)\s*(.*)/i) {
 368             &parse_value ($1, 0, 1, 1);
 369             print STDERR "$0 parsed AND MASK $1\n" if ($debug);
 370             die "$0 : syntax error in line $lineno : $_
 371         expected end of line, not \"$2\"
 372 " if ($2 ne '');
 373         } else {
 374             die "$0 : syntax error in line $lineno : $_
 375         expected \",AND MASK <data>\", not \"$2\"
 376 ";
 377         }
 378     } elsif ($conditional !~ /^\s*$/) {
 379         die "$0 : syntax error in line $lineno : $_
 380         expected end of line" . (($need_data) ? " or \"AND MASK <data>\"" : "") . "
 381         not \"$conditional\"
 382 ";
 383     }
 384 }
 385
 386 # Parse command line
 387 $output = shift;
 388 $outputu = shift;
 389
 390
 391 # Main loop
 392 while (<STDIN>) {
 393     $lineno = $lineno + 1;
 394     $list[$address] = $list[$address].$_;
 395     s/;.*$//;                           # Strip comments
 396
 397
 398     chop;                               # Leave new line out of error messages
 399
 400 # Handle symbol definitions of the form label:
 401     if (/^\s*($identifier)\s*:(.*)/) {
 402         if (!defined($symbol_values{$1})) {
 403             $symbol_values{$1} = $address * 4;  # Address is an index into
 404             delete $forward{$1};                # an array of longs
 405             push (@label, $1);
 406             $_ = $2;
 407         } else {
 408             die "$0 : redefinition of symbol $1 in line $lineno : $_\n";
 409         }
 410     }
 411
 412 # Handle symbol definitions of the form ABSOLUTE or RELATIVE identifier =
 413 # value
 414     if (/^\s*(ABSOLUTE|RELATIVE)\s+(.*)/i) {
 415         $is_absolute = $1;
 416         $rest = $2;
 417         foreach $rest (split (/\s*,\s*/, $rest)) {
 418             if ($rest =~ /^($identifier)\s*=\s*($constant)\s*$/) {
 419                 local ($id, $cnst) = ($1, $2);
 420                 if ($symbol_values{$id} eq undef) {
 421                     $symbol_values{$id} = eval $cnst;
 422                     delete $forward{$id};
 423                     if ($is_absolute =~ /ABSOLUTE/i) {
 424                         push (@absolute , $id);
 425                     } else {
 426                         push (@relative, $id);
 427                     }
 428                 } else {
 429                     die "$0 : redefinition of symbol $id in line $lineno : $_\n";
 430                 }
 431             } else {
 432                 die
 433 "$0 : syntax error in line $lineno : $_
 434             expected <identifier> = <value>
 435 ";
 436             }
 437         }
 438     } elsif (/^\s*EXTERNAL\s+(.*)/i) {
 439         $externals = $1;
 440         foreach $external (split (/,/,$externals)) {
 441             if ($external =~ /\s*($identifier)\s*$/) {
 442                 $external = $1;
 443                 push (@external, $external);
 444                 delete $forward{$external};
 445                 if (defined($symbol_values{$external})) {
 446                         die "$0 : redefinition of symbol $1 in line $lineno : $_\n";
 447                 }
 448                 $symbol_values{$external} = $external;
 449 print STDERR "defined external $1 to $external\n" if ($debug_external);
 450             } else {
 451                 die
 452 "$0 : syntax error in line $lineno : $_
 453         expected <identifier>, got $external
 454 ";
 455             }
 456         }
 457 # Process ENTRY identifier declarations
 458     } elsif (/^\s*ENTRY\s+(.*)/i) {
 459         if ($1 =~ /^($identifier)\s*$/) {
 460             push (@entry, $1);
 461         } else {
 462             die
 463 "$0 : syntax error in line $lineno : $_
 464         expected ENTRY <identifier>
 465 ";
 466         }
 467 # Process MOVE length, address, WITH|WHEN phase instruction
 468     } elsif (/^\s*MOVE\s+(.*)/i) {
 469         $rest = $1;
 470         if ($rest =~ /^FROM\s+($value)\s*,\s*(WITH|WHEN)\s+($phase)\s*$/i) {
 471             $transfer_addr = $1;
 472             $with_when = $2;
 473             $scsi_phase = $3;
 474 print STDERR "Parsing MOVE FROM $transfer_addr, $with_when $3\n" if ($debug);
 475             $code[$address] = 0x18_00_00_00 | (($with_when =~ /WITH/i) ?
 476                 0x00_00_00_00 : 0x08_00_00_00) | $scsi_phases{$scsi_phase};
 477             &parse_value ($transfer_addr, 1, 0, 4);
 478             $address += 2;
 479         } elsif ($rest =~ /^($value)\s*,\s*(PTR\s+|)($value)\s*,\s*(WITH|WHEN)\s+($phase)\s*$/i) {
 480             $transfer_len = $1;
 481             $ptr = $2;
 482             $transfer_addr = $3;
 483             $with_when = $4;
 484             $scsi_phase = $5;
 485             $code[$address] = (($with_when =~ /WITH/i) ? 0x00_00_00_00 :
 486                 0x08_00_00_00)  | (($ptr =~ /PTR/i) ? (1 << 29) : 0) |
 487                 $scsi_phases{$scsi_phase};
 488             &parse_value ($transfer_len, 0, 0, 3);
 489             &parse_value ($transfer_addr, 1, 0, 4);
 490             $address += 2;
 491         } elsif ($rest =~ /^MEMORY\s+(.*)/i) {
 492             $rest = $1;
 493             $code[$address] = 0xc0_00_00_00;
 494             if ($rest =~ /^($value)\s*,\s*($value)\s*,\s*($value)\s*$/) {
 495                 $count = $1;
 496                 $source = $2;
 497                 $dest =  $3;
 498 print STDERR "Parsing MOVE MEMORY $count, $source, $dest\n" if ($debug);
 499                 &parse_value ($count, 0, 0, 3);
 500                 &parse_value ($source, 1, 0, 4);
 501                 &parse_value ($dest, 2, 0, 4);
 502 printf STDERR "Move memory instruction = %08x,%08x,%08x\n",
 503                 $code[$address], $code[$address+1], $code[$address +2] if
 504                 ($debug);
 505                 $address += 3;
 506
 507             } else {
 508                 die
 509 "$0 : syntax error in line $lineno : $_
 510         expected <count>, <source>, <destination>
 511 "
 512             }
 513         } elsif ($1 =~ /^(.*)\s+(TO|SHL|SHR)\s+(.*)/i) {
 514 print STDERR "Parsing register to register move\n" if ($debug);
 515             $src = $1;
 516             $op = "\U$2\E";
 517             $rest = $3;
 518
 519             $code[$address] = 0x40_00_00_00;
 520
 521             $force = ($op !~ /TO/i);
 522
 523
 524 print STDERR "Forcing register source \n" if ($force && $debug);
 525
 526             if (!$force && $src =~
 527                 /^($register)\s+(-|$operator)\s+($value)\s*$/i) {
 528 print STDERR "register operand  data8 source\n" if ($debug);
 529                 $src_reg = "\U$1\E";
 530                 $op = "\U$2\E";
 531                 if ($op ne '-') {
 532                     $data8 = $3;
 533                 } else {
 534                     die "- is not implemented yet.\n"
 535                 }
 536             } elsif ($src =~ /^($register)\s*$/i) {
 537 print STDERR "register source\n" if ($debug);
 538                 $src_reg = "\U$1\E";
 539                 # Encode register to register move as a register | 0
 540                 # move to register.
 541                 if (!$force) {
 542                     $op = '|';
 543                 }
 544                 $data8 = 0;
 545             } elsif (!$force && $src =~ /^($value)\s*$/i) {
 546 print STDERR "data8 source\n" if ($debug);
 547                 $src_reg = undef;
 548                 $op = 'NONE';
 549                 $data8 = $1;
 550             } else {
 551                 if (!$force) {
 552                     die
 553 "$0 : syntax error in line $lineno : $_
 554         expected <register>
 555                 <data8>
 556                 <register> <operand> <data8>
 557 ";
 558                 } else {
 559                     die
 560 "$0 : syntax error in line $lineno : $_
 561         expected <register>
 562 ";
 563                 }
 564             }
 565             if ($rest =~ /^($register)\s*(.*)$/i) {
 566                 $dst_reg = "\U$1\E";
 567                 $rest = $2;
 568             } else {
 569             die
 570 "$0 : syntax error in $lineno : $_
 571         expected <register>, got $rest
 572 ";
 573             }
 574
 575             if ($rest =~ /^WITH\s+CARRY\s*(.*)/i) {
 576                 $rest = $1;
 577                 if ($op eq '+') {
 578                     $code[$address] |= 0x01_00_00_00;
 579                 } else {
 580                     die
 581 "$0 : syntax error in $lineno : $_
 582         WITH CARRY option is incompatible with the $op operator.
 583 ";
 584                 }
 585             }
 586
 587             if ($rest !~ /^\s*$/) {
 588                 die
 589 "$0 : syntax error in $lineno : $_
 590         Expected end of line, got $rest
 591 ";
 592             }
 593
 594             print STDERR "source = $src_reg, data = $data8 , destination = $dst_reg\n"
 595                 if ($debug);
 596             # Note that Move data8 to reg is encoded as a read-modify-write
 597             # instruction.
 598             if (($src_reg eq undef) || ($src_reg eq $dst_reg)) {
 599                 $code[$address] |= 0x38_00_00_00 |
 600                     ($registers{$dst_reg} << 16);
 601             } elsif ($dst_reg =~ /SFBR/i) {
 602                 $code[$address] |= 0x30_00_00_00 |
 603                     ($registers{$src_reg} << 16);
 604             } elsif ($src_reg =~ /SFBR/i) {
 605                 $code[$address] |= 0x28_00_00_00 |
 606                     ($registers{$dst_reg} << 16);
 607             } else {
 608                 die
 609 "$0 : Illegal combination of registers in line $lineno : $_
 610         Either source and destination registers must be the same,
 611         or either source or destination register must be SFBR.
 612 ";
 613             }
 614
 615             $code[$address] |= $operators{$op};
 616
 617             &parse_value ($data8, 0, 1, 1);
 618             $code[$address] |= $operators{$op};
 619             $code[$address + 1] = 0x00_00_00_00;# Reserved
 620             $address += 2;
 621         } else {
 622             die
 623 "$0 : syntax error in line $lineno : $_
 624         expected (initiator) <length>, <address>, WHEN <phase>
 625                  (target) <length>, <address>, WITH <phase>
 626                  MEMORY <length>, <source>, <destination>
 627                  <expression> TO <register>
 628 ";
 629         }
 630 # Process SELECT {ATN|} id, fail_address
 631     } elsif (/^\s*(SELECT|RESELECT)\s+(.*)/i) {
 632         $rest = $2;
 633         if ($rest =~ /^(ATN|)\s*($value)\s*,\s*($identifier)\s*$/i) {
 634             $atn = $1;
 635             $id = $2;
 636             $alt_addr = $3;
 637             $code[$address] = 0x40_00_00_00 |
 638                 (($atn =~ /ATN/i) ? 0x01_00_00_00 : 0);
 639             $code[$address + 1] = 0x00_00_00_00;
 640             &parse_value($id, 0, 2, 1);
 641             &parse_value($alt_addr, 1, 0, 4);
 642             $address += 2;
 643         } elsif ($rest =~ /^(ATN|)\s*FROM\s+($value)\s*,\s*($identifier)\s*$/i) {
 644             $atn = $1;
 645             $addr = $2;
 646             $alt_addr = $3;
 647             $code[$address] = 0x42_00_00_00 |
 648                 (($atn =~ /ATN/i) ? 0x01_00_00_00 : 0);
 649             $code[$address + 1] = 0x00_00_00_00;
 650             &parse_value($addr, 0, 0, 3);
 651             &parse_value($alt_addr, 1, 0, 4);
 652             $address += 2;
 653         } else {
 654             die
 655 "$0 : syntax error in line $lineno : $_
 656         expected SELECT id, alternate_address or
 657                 SELECT FROM address, alternate_address or
 658                 RESELECT id, alternate_address or
 659                 RESELECT FROM address, alternate_address
 660 ";
 661         }
 662     } elsif (/^\s*WAIT\s+(.*)/i) {
 663             $rest = $1;
 664 print STDERR "Parsing WAIT $rest\n" if ($debug);
 665         if ($rest =~ /^DISCONNECT\s*$/i) {
 666             $code[$address] = 0x48_00_00_00;
 667             $code[$address + 1] = 0x00_00_00_00;
 668             $address += 2;
 669         } elsif ($rest =~ /^(RESELECT|SELECT)\s+($identifier)\s*$/i) {
 670             $alt_addr = $2;
 671             $code[$address] = 0x50_00_00_00;
 672             &parse_value ($alt_addr, 1, 0, 4);
 673             $address += 2;
 674         } else {
 675             die
 676 "$0 : syntax error in line $lineno : $_
 677         expected (initiator) WAIT DISCONNECT or
 678                  (initiator) WAIT RESELECT alternate_address or
 679                  (target) WAIT SELECT alternate_address
 680 ";
 681         }
 682 # Handle SET and CLEAR instructions.  Note that we should also do something
 683 # with this syntax to set target mode.
 684     } elsif (/^\s*(SET|CLEAR)\s+(.*)/i) {
 685         $set = $1;
 686         $list = $2;
 687         $code[$address] = ($set =~ /SET/i) ?  0x58_00_00_00 :
 688             0x60_00_00_00;
 689         foreach $arg (split (/\s+AND\s+/i,$list)) {
 690             if ($arg =~ /ATN/i) {
 691                 $code[$address] |= 0x00_00_00_08;
 692             } elsif ($arg =~ /ACK/i) {
 693                 $code[$address] |= 0x00_00_00_40;
 694             } elsif ($arg =~ /TARGET/i) {
 695                 $code[$address] |= 0x00_00_02_00;
 696             } elsif ($arg =~ /CARRY/i) {
 697                 $code[$address] |= 0x00_00_04_00;
 698             } else {
 699                 die
 700 "$0 : syntax error in line $lineno : $_
 701         expected $set followed by a AND delimited list of one or
 702         more strings from the list ACK, ATN, CARRY, TARGET.
 703 ";
 704             }
 705         }
 706         $code[$address + 1] = 0x00_00_00_00;
 707         $address += 2;
 708     } elsif (/^\s*(JUMP|CALL|INT)\s+(.*)/i) {
 709         $instruction = $1;
 710         $rest = $2;
 711         if ($instruction =~ /JUMP/i) {
 712             $code[$address] = 0x80_00_00_00;
 713         } elsif ($instruction =~ /CALL/i) {
 714             $code[$address] = 0x88_00_00_00;
 715         } else {
 716             $code[$address] = 0x98_00_00_00;
 717         }
 718 print STDERR "parsing JUMP, rest = $rest\n" if ($debug);
 719
 720 # Relative jump.
 721         if ($rest =~ /^(REL\s*\(\s*$identifier\s*\))\s*(.*)/i) {
 722             $addr = $1;
 723             $rest = $2;
 724 print STDERR "parsing JUMP REL, addr = $addr, rest = $rest\n" if ($debug);
 725             $code[$address]  |= 0x00_80_00_00;
 726             &parse_value($addr, 1, 0, 4);
 727 # Absolute jump, requires no more gunk
 728         } elsif ($rest =~ /^($value)\s*(.*)/) {
 729             $addr = $1;
 730             $rest = $2;
 731             &parse_value($addr, 1, 0, 4);
 732         } else {
 733             die
 734 "$0 : syntax error in line $lineno : $_
 735         expected <address> or REL (address)
 736 ";
 737         }
 738
 739         if ($rest =~ /^,\s*(.*)/) {
 740             &parse_conditional($1);
 741         } elsif ($rest =~ /^\s*$/) {
 742             $code[$address] |= (1 << 19);
 743         } else {
 744             die
 745 "$0 : syntax error in line $lineno : $_
 746         expected , <conditional> or end of line, got $1
 747 ";
 748         }
 749
 750         $address += 2;
 751     } elsif (/^\s*(RETURN|INTFLY)\s*(.*)/i) {
 752         $instruction = $1;
 753         $conditional = $2;
 754 print STDERR "Parsing $instruction\n" if ($debug);
 755         $code[$address] = ($instruction =~ /RETURN/i) ? 0x90_00_00_00 :
 756             0x98_10_00_00;
 757         if ($conditional =~ /^,\s*(.*)/) {
 758             $conditional = $1;
 759             &parse_conditional ($conditional);
 760         } elsif ($conditional !~ /^\s*$/) {
 761             die
 762 "$0 : syntax error in line $lineno : $_
 763         expected , <conditional>
 764 ";
 765         } else {
 766             $code[$address] |= 0x00_08_00_00;
 767         }
 768
 769         $code[$address + 1] = 0x00_00_00_00;
 770         $address += 2;
 771     } elsif (/^\s*DISCONNECT\s*$/) {
 772         $code[$address] = 0x48_00_00_00;
 773         $code[$address + 1] = 0x00_00_00_00;
 774         $address += 2;
 775 # I'm not sure that I should be including this extension, but
 776 # what the hell?
 777     } elsif (/^\s*NOP\s*$/i) {
 778         $code[$address] = 0x80_88_00_00;
 779         $code[$address + 1] = 0x00_00_00_00;
 780         $address += 2;
 781 # Ignore lines consisting entirely of white space
 782     } elsif (/^\s*$/) {
 783     } else {
 784         die
 785 "$0 : syntax error in line $lineno: $_
 786         expected label:, ABSOLUTE, CLEAR, DISCONNECT, EXTERNAL, MOVE, RESELECT,
 787             SELECT SET, or WAIT
 788 ";
 789     }
 790 }
 791
 792 # Fill in label references
 793
 794 @undefined = keys %forward;
 795 if ($#undefined >= 0) {
 796     print STDERR "Undefined symbols : \n";
 797     foreach $undef (@undefined) {
 798         print STDERR "$undef in $forward{$undef}\n";
 799     }
 800     exit 1;
 801 }
 802
 803 @label_patches = ();
 804
 805 @external_patches = ();
 806
 807 @absolute = sort @absolute;
 808
 809 foreach $i (@absolute) {
 810     foreach $j (split (/\s+/,$symbol_references{$i})) {
 811         $j =~ /(REL|ABS),(.*),(.*)/;
 812         $type = $1;
 813         $address = $2;
 814         $length = $3;
 815         die
 816 "$0 : $symbol $i has invalid relative reference at address $address,
 817     size $length\n"
 818         if ($type eq 'REL');
 819
 820         &patch ($address / 4, $address % 4, $length, $symbol_values{$i});
 821     }
 822 }
 823
 824 foreach $external (@external) {
 825 print STDERR "checking external $external \n" if ($debug_external);
 826     if ($symbol_references{$external} ne undef) {
 827         for $reference (split(/\s+/,$symbol_references{$external})) {
 828             $reference =~ /(REL|ABS),(.*),(.*)/;
 829             $type = $1;
 830             $address = $2;
 831             $length = $3;
 832
 833             die
 834 "$0 : symbol $label is external, has invalid relative reference at $address,
 835     size $length\n"
 836                 if ($type eq 'REL');
 837
 838             die
 839 "$0 : symbol $label has invalid reference at $address, size $length\n"
 840                 if ((($address % 4) !=0) || ($length != 4));
 841
 842             $symbol = $symbol_values{$external};
 843             $add = $code[$address / 4];
 844             if ($add eq 0) {
 845                 $code[$address / 4] = $symbol;
 846             } else {
 847                 $add = sprintf ("0x%08x", $add);
 848                 $code[$address / 4] = "$symbol + $add";
 849             }
 850
 851 print STDERR "referenced external $external at $1\n" if ($debug_external);
 852         }
 853     }
 854 }
 855
 856 foreach $label (@label) {
 857     if ($symbol_references{$label} ne undef) {
 858         for $reference (split(/\s+/,$symbol_references{$label})) {
 859             $reference =~ /(REL|ABS),(.*),(.*)/;
 860             $type = $1;
 861             $address = $2;
 862             $length = $3;
 863
 864             if ((($address % 4) !=0) || ($length != 4)) {
 865                 die "$0 : symbol $label has invalid reference at $1, size $2\n";
 866             }
 867
 868             if ($type eq 'ABS') {
 869                 $code[$address / 4] += $symbol_values{$label};
 870                 push (@label_patches, $address / 4);
 871             } else {
 872 #
 873 # - The address of the reference should be in the second and last word
 874 #       of an instruction
 875 # - Relative jumps, etc. are relative to the DSP of the _next_ instruction
 876 #
 877 # So, we need to add four to the address of the reference, to get
 878 # the address of the next instruction, when computing the reference.
 879
 880                 $tmp = $symbol_values{$label} -
 881                     ($address + 4);
 882                 die
 883 # Relative addressing is limited to 24 bits.
 884 "$0 : symbol $label is too far ($tmp) from $address to reference as
 885     relative/\n" if (($tmp >= 0x80_00_00) || ($tmp < -0x80_00_00));
 886                 $code[$address / 4] = $tmp & 0x00_ff_ff_ff;
 887             }
 888         }
 889     }
 890 }
 891
 892 # Output SCRIPT[] array, one instruction per line.  Optionally
 893 # print the original code too.
 894
 895 open (OUTPUT, ">$output") || die "$0 : can't open $output for writing\n";
 896 open (OUTPUTU, ">$outputu") || die "$0 : can't open $outputu for writing\n";
 897
 898 ($_ = $0) =~ s:.*/::;
 899 print OUTPUT "/* DO NOT EDIT - Generated automatically by ".$_." */\n";
 900 print OUTPUT "static u32 ".$prefix."SCRIPT[] = {\n";
 901 $instructions = 0;
 902 for ($i = 0; $i < $#code; ) {
 903     if ($list_in_array) {
 904         printf OUTPUT "/*\n$list[$i]\nat 0x%08x : */", $i;
 905     }
 906     printf OUTPUT "\t0x%08x,", $code[$i];
 907     printf STDERR "Address $i = %x\n", $code[$i] if ($debug);
 908     if ($code[$i + 1] =~ /\s*($identifier)(.*)$/) {
 909         push (@external_patches, $i+1, $1);
 910         printf OUTPUT "0%s,", $2
 911     } else {
 912         printf OUTPUT "0x%08x,",$code[$i+1];
 913     }
 914
 915     if (($code[$i] & 0xff_00_00_00) == 0xc0_00_00_00) {
 916         if ($code[$i + 2] =~ /$identifier/) {
 917             push (@external_patches, $i+2, $code[$i+2]);
 918             printf OUTPUT "0,\n";
 919         } else {
 920             printf OUTPUT "0x%08x,\n",$code[$i+2];
 921         }
 922         $i += 3;
 923     } else {
 924         printf OUTPUT "\n";
 925         $i += 2;
 926     }
 927     $instructions += 1;
 928 }
 929 print OUTPUT "};\n\n";
 930
 931 foreach $i (@absolute) {
 932     printf OUTPUT "#define A_$i\t0x%08x\n", $symbol_values{$i};
 933     if (defined($prefix) && $prefix ne '') {
 934         printf OUTPUT "#define A_".$i."_used ".$prefix."A_".$i."_used\n";
 935         printf OUTPUTU "#undef A_".$i."_used\n";
 936     }
 937     printf OUTPUTU "#undef A_$i\n";
 938
 939     printf OUTPUT "static u32 A_".$i."_used\[\] __attribute((unused)) = {\n";
 940 printf STDERR "$i is used $symbol_references{$i}\n" if ($debug);
 941     foreach $j (split (/\s+/,$symbol_references{$i})) {
 942         $j =~ /(ABS|REL),(.*),(.*)/;
 943         if ($1 eq 'ABS') {
 944             $address = $2;
 945             $length = $3;
 946             printf OUTPUT "\t0x%08x,\n", $address / 4;
 947         }
 948     }
 949     printf OUTPUT "};\n\n";
 950 }
 951
 952 foreach $i (sort @entry) {
 953     printf OUTPUT "#define Ent_$i\t0x%08x\n", $symbol_values{$i};
 954     printf OUTPUTU "#undef Ent_$i\n", $symbol_values{$i};
 955 }
 956
 957 #
 958 # NCR assembler outputs label patches in the form of indices into
 959 # the code.
 960 #
 961 printf OUTPUT "static u32 ".$prefix."LABELPATCHES[] __attribute((unused)) = {\n";
 962 for $patch (sort {$a <=> $b} @label_patches) {
 963     printf OUTPUT "\t0x%08x,\n", $patch;
 964 }
 965 printf OUTPUT "};\n\n";
 966
 967 $num_external_patches = 0;
 968 printf OUTPUT "static struct {\n\tu32\toffset;\n\tvoid\t\t*address;\n".
 969     "} ".$prefix."EXTERNAL_PATCHES[] __attribute((unused)) = {\n";
 970 while ($ident = pop(@external_patches)) {
 971     $off = pop(@external_patches);
 972     printf OUTPUT "\t{0x%08x, &%s},\n", $off, $ident;
 973     ++$num_external_patches;
 974 }
 975 printf OUTPUT "};\n\n";
 976
 977 printf OUTPUT "static u32 ".$prefix."INSTRUCTIONS __attribute((unused))\t= %d;\n",
 978     $instructions;
 979 printf OUTPUT "static u32 ".$prefix."PATCHES __attribute((unused))\t= %d;\n",
 980     $#label_patches+1;
 981 printf OUTPUT "static u32 ".$prefix."EXTERNAL_PATCHES_LEN __attribute((unused))\t= %d;\n",
 982     $num_external_patches;
 983 close OUTPUT;
 984 close OUTPUTU;