linux/drivers/scsi/script_asm.pl
<<
>>
Prefs
   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
  81if ($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}
  88else {
  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
 103if ($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}
 123else {
 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
 165print STDERR "value regex = $value\n" if ($debug);
 166
 167$phase = join ('|', keys %scsi_phases);
 168print 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
 175if ($ncr7x0_family) {
 176  $operator = '\||OR|AND|\&|\+';
 177}
 178else {
 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
 218sub 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
 243sub 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;
 253print STDERR "Relative reference $symbol\n" if ($debug);
 254    } elsif ($value =~ /^($identifier)\s*(.*)/) {
 255        $relative = 'ABS';
 256        $symbol = $1;
 257        $value = $2;
 258print STDERR "Absolute reference $symbol\n" if ($debug);
 259    } 
 260
 261    if ($symbol ne '') {
 262print 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})) {
 269print 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
 283sub 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
 333print 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) {
 352print 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
 392while (<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;
 449print 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;
 474print 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;
 498print 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);
 502printf 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) {
 514print 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
 524print STDERR "Forcing register source \n" if ($force && $debug);
 525
 526            if (!$force && $src =~ 
 527                /^($register)\s+(-|$operator)\s+($value)\s*$/i) {
 528print 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) {
 537print 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) {
 546print 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;
 664print 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        }
 718print 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;
 724print 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; 
 754print 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;
 795if ($#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
 809foreach $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
 824foreach $external (@external) {
 825print 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                
 851print STDERR "referenced external $external at $1\n" if ($debug_external);
 852        }
 853    }
 854}
 855
 856foreach $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
 895open (OUTPUT, ">$output") || die "$0 : can't open $output for writing\n";
 896open (OUTPUTU, ">$outputu") || die "$0 : can't open $outputu for writing\n";
 897
 898($_ = $0) =~ s:.*/::;
 899print OUTPUT "/* DO NOT EDIT - Generated automatically by ".$_." */\n";
 900print OUTPUT "static u32 ".$prefix."SCRIPT[] = {\n";
 901$instructions = 0;
 902for ($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}
 929print OUTPUT "};\n\n";
 930
 931foreach $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";
 940printf 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
 952foreach $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#
 961printf OUTPUT "static u32 ".$prefix."LABELPATCHES[] __attribute((unused)) = {\n";
 962for $patch (sort {$a <=> $b} @label_patches) {
 963    printf OUTPUT "\t0x%08x,\n", $patch;
 964}
 965printf OUTPUT "};\n\n";
 966
 967$num_external_patches = 0;
 968printf OUTPUT "static struct {\n\tu32\toffset;\n\tvoid\t\t*address;\n".
 969    "} ".$prefix."EXTERNAL_PATCHES[] __attribute((unused)) = {\n";
 970while ($ident = pop(@external_patches)) {
 971    $off = pop(@external_patches);
 972    printf OUTPUT "\t{0x%08x, &%s},\n", $off, $ident;
 973    ++$num_external_patches;
 974}
 975printf OUTPUT "};\n\n";
 976
 977printf OUTPUT "static u32 ".$prefix."INSTRUCTIONS __attribute((unused))\t= %d;\n", 
 978    $instructions;
 979printf OUTPUT "static u32 ".$prefix."PATCHES __attribute((unused))\t= %d;\n", 
 980    $#label_patches+1;
 981printf OUTPUT "static u32 ".$prefix."EXTERNAL_PATCHES_LEN __attribute((unused))\t= %d;\n",
 982    $num_external_patches;
 983close OUTPUT;
 984close OUTPUTU;
 985
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.