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