2a2d3c343b00b1b65e5addb812b459bfa961d4bb
5 static void fetch_data();
6 static void fetch_instr();
7 static unsigned long get_val();
8 static int is_segmented();
9 static int lookup_instr();
10 static void output_instr();
11 static void unpack_instr();
12 static void unparse_instr();
15 unsigned char instr_buf
[24];
16 unsigned long bytes_fetched
;
17 unsigned long tabl_index
;
18 char instr_asmsrc
[80];
19 unsigned long arg_reg
[0x0f];
20 unsigned long immediate
;
21 unsigned long displacement
;
22 unsigned long address
;
23 unsigned long cond_code
;
24 unsigned long ctrl_code
;
26 unsigned long interrupts
;
30 static char *codes
[16] =
51 int print_insn_z8k(addr
, in_buf
, stream
)
53 unsigned char *in_buf
;
56 instr_data_s instr_data
;
58 fetch_instr( &in_buf
, &instr_data
);
59 if ( lookup_instr( &instr_data
))
61 fetch_data( &in_buf
, &instr_data
);
62 unpack_instr( &instr_data
);
63 unparse_instr( &instr_data
);
64 output_instr( &instr_data
, addr
, stream
);
65 return instr_data
.bytes_fetched
;
68 fprintf(stream
,".word %02x%02x", in_buf
[0], in_buf
[1]);
75 static void fetch_data( in_buf
, instr_data
)
76 unsigned char **in_buf
;
77 instr_data_s
*instr_data
;
81 bytes_2fetch
= z8k_table
[instr_data
->tabl_index
].length
-
82 instr_data
->bytes_fetched
;
83 while( bytes_2fetch
-- )
84 instr_data
->instr_buf
[instr_data
->bytes_fetched
++] = *(*in_buf
)++;
87 static void fetch_instr( in_buf
, instr_data
)
88 unsigned char **in_buf
;
89 instr_data_s
*instr_data
;
91 unsigned int loop
= 2;
93 instr_data
->bytes_fetched
= 0;
95 instr_data
->instr_buf
[instr_data
->bytes_fetched
++] = *(*in_buf
)++;
99 static unsigned long get_val( instr_buf
, start_nibl
, nibls_long
)
100 unsigned char (*instr_buf
)[];
101 unsigned int start_nibl
, nibls_long
;
103 unsigned long ret_val
;
104 unsigned char byte_val
, nibl_val
;
105 unsigned int nibl_index
, nibl_lim
;
106 unsigned int byte_index
;
107 unsigned int which_nibl
;
110 nibl_lim
= start_nibl
+ nibls_long
;
111 for( nibl_index
= start_nibl
; nibl_index
< nibl_lim
; nibl_index
++ )
113 byte_index
= nibl_index
/ 2;
114 which_nibl
= nibl_index
% 2;
118 byte_val
= (*instr_buf
)[byte_index
];
119 nibl_val
= (byte_val
>> 4) & 0x0f;
122 nibl_val
= byte_val
& 0x0f;
125 ret_val
= (ret_val
<< 4) | nibl_val
;
132 static int is_segmented()
138 int lookup_instr( instr_data
)
139 instr_data_s
*instr_data
;
142 int nibl_index
, tabl_index
;
143 int tablent_found
, nibl_matched
;
144 unsigned short instr_nibl
;
145 unsigned short tabl_datum
, datum_class
, datum_value
;
149 while( ! nibl_matched
&& z8k_table
[tabl_index
].name
)
152 for( nibl_index
= 0; nibl_index
< 4 && nibl_matched
; nibl_index
++ )
154 instr_nibl
= get_val( instr_data
->instr_buf
, nibl_index
, 1 );
156 tabl_datum
= z8k_table
[tabl_index
].byte_info
[nibl_index
];
157 datum_class
= tabl_datum
& CLASS_MASK
;
158 datum_value
= ~CLASS_MASK
& tabl_datum
;
160 switch( datum_class
)
163 if( datum_value
!= instr_nibl
) nibl_matched
= 0;
166 if( ! ((~instr_nibl
) & 0x4) ) nibl_matched
= 0;
169 if( ! (instr_nibl
& 0x4) ) nibl_matched
= 0;
172 if( ! ((~instr_nibl
) & 0x8) ) nibl_matched
= 0;
175 if( ! (instr_nibl
& 0x8) ) nibl_matched
= 0;
178 if( ! ((~instr_nibl
) & 0x8) ) nibl_matched
= 0;
182 if( ! (instr_nibl
& 0x8) ) nibl_matched
= 0;
186 if( instr_nibl
== 0 ) nibl_matched
= 0;
196 instr_data
->tabl_index
= tabl_index
;
202 static void output_instr( instr_data
, addr
, stream
)
203 instr_data_s
*instr_data
;
207 int loop
, loop_limit
;
208 unsigned long word_val
;
212 strcpy( out_str
, "" );
214 loop_limit
= z8k_table
[instr_data
->tabl_index
].length
/ 2;
215 for( loop
= 0; loop
< loop_limit
; loop
++ )
217 word_val
= get_val( instr_data
->instr_buf
, loop
* 4, 4 );
218 sprintf( tmp_str
, "%04x ", word_val
);
219 strcat( out_str
, tmp_str
);
224 strcat( out_str
, " " );
227 strcat( out_str
, instr_data
->instr_asmsrc
);
229 fprintf( stream
, "%s", out_str
);
232 static void unpack_instr( instr_data
)
233 instr_data_s
*instr_data
;
235 int nibl_index
, word_index
;
236 int nibl_count
, loop
;
237 unsigned short instr_nibl
, instr_byte
, instr_word
, instr_long
;
238 unsigned short tabl_datum
, datum_class
, datum_value
;
242 while( z8k_table
[instr_data
->tabl_index
].byte_info
[loop
] != 0 )
244 word_index
= (int) nibl_count
/ 4;
245 nibl_index
= (int) nibl_count
% 4;
250 instr_nibl
= get_val( instr_data
->instr_buf
, nibl_count
, 1 );
251 instr_byte
= get_val( instr_data
->instr_buf
, nibl_count
, 2 );
252 instr_word
= get_val( instr_data
->instr_buf
, nibl_count
, 4 );
253 instr_long
= get_val( instr_data
->instr_buf
, nibl_count
, 8 );
256 instr_nibl
= get_val( instr_data
->instr_buf
, nibl_count
, 1 );
259 instr_nibl
= get_val( instr_data
->instr_buf
, nibl_count
, 1 );
260 instr_byte
= get_val( instr_data
->instr_buf
, nibl_count
, 2 );
263 instr_nibl
= get_val( instr_data
->instr_buf
, nibl_count
, 1 );
269 tabl_datum
= z8k_table
[instr_data
->tabl_index
].byte_info
[loop
];
270 datum_class
= tabl_datum
& CLASS_MASK
;
271 datum_value
= tabl_datum
& ~CLASS_MASK
;
273 switch( datum_class
)
276 instr_data
->address
= instr_nibl
;
279 instr_data
->displacement
= instr_nibl
;
282 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
285 switch( datum_value
)
288 instr_data
->displacement
= instr_word
;
292 instr_data
->displacement
= instr_word
& 0x0fff;
300 switch( datum_value
)
303 instr_data
->immediate
= instr_nibl
;
306 instr_data
->immediate
= instr_byte
;
310 instr_data
->immediate
= instr_word
;
314 instr_data
->immediate
= instr_long
;
318 instr_data
->immediate
= instr_nibl
-1;
321 /* missing ARG_IMMNMINUS1 */
323 instr_data
->immediate
= 1;
326 instr_data
->immediate
= 2;
329 instr_data
->immediate
= (- instr_word
);
333 instr_data
->immediate
= instr_nibl
& 0x3;
340 instr_data
->cond_code
= instr_nibl
;
343 instr_data
->ctrl_code
= instr_nibl
;
349 if( instr_nibl
& 0x8 )
351 instr_data
->address
= ((instr_word
& 0x7f00) << 8) +
352 (instr_long
& 0xffff);
357 instr_data
->address
= ((instr_word
& 0x7f00) << 8) +
358 (instr_word
& 0x00ff);
364 instr_data
->address
= instr_word
;
369 instr_data
->cond_code
= instr_nibl
& 0x7;
372 instr_data
->cond_code
= instr_nibl
& 0x7;
375 instr_data
->displacement
= instr_byte
& 0x7f;
379 instr_data
->displacement
= instr_byte
& 0x7f;
383 instr_data
->interrupts
= instr_nibl
& 0x3;
386 instr_data
->interrupts
= instr_nibl
& 0x3;
392 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
395 instr_data
->flags
= instr_nibl
;
398 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
401 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
404 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
407 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
410 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
413 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
424 static void unparse_instr( instr_data
)
425 instr_data_s
*instr_data
;
427 unsigned short tabl_datum
, datum_class
, datum_value
;
428 int loop
, loop_limit
;
429 char out_str
[80], tmp_str
[25];
431 sprintf( out_str
, "\t%s\t", z8k_table
[instr_data
->tabl_index
].name
);
433 loop_limit
= z8k_table
[instr_data
->tabl_index
].noperands
;
434 for( loop
= 0; loop
< loop_limit
; loop
++ )
437 strcat( out_str
, "," );
439 tabl_datum
= z8k_table
[instr_data
->tabl_index
].arg_info
[loop
];
440 datum_class
= tabl_datum
& CLASS_MASK
;
441 datum_value
= tabl_datum
& ~CLASS_MASK
;
443 switch( datum_class
)
446 sprintf( tmp_str
, "0x%0x(R%d)", instr_data
->address
,
447 instr_data
->arg_reg
[datum_value
] );
448 strcat( out_str
, tmp_str
);
451 sprintf( tmp_str
, "r%d(#%x)", instr_data
->arg_reg
[datum_value
],
452 instr_data
->displacement
);
453 strcat( out_str
, tmp_str
);
456 sprintf( tmp_str
, "r%d(R%d)", instr_data
->arg_reg
[datum_value
],
457 instr_data
->arg_reg
[ARG_RX
] );
458 strcat( out_str
, tmp_str
);
461 sprintf( tmp_str
, "#0x%0x", instr_data
->displacement
);
462 strcat( out_str
, tmp_str
);
465 sprintf( tmp_str
, "#0x%0x", instr_data
->immediate
);
466 strcat( out_str
, tmp_str
);
469 sprintf( tmp_str
, "%s", codes
[instr_data
->cond_code
] );
470 strcat( out_str
, tmp_str
);
473 sprintf( tmp_str
, "0x%0x", instr_data
->ctrl_code
);
474 strcat( out_str
, tmp_str
);
478 sprintf( tmp_str
, "#0x%0x", instr_data
->address
);
479 strcat( out_str
, tmp_str
);
482 sprintf( tmp_str
, "@R%d", instr_data
->arg_reg
[datum_value
] );
483 strcat( out_str
, tmp_str
);
486 sprintf( tmp_str
, "0x%0x", instr_data
->flags
);
487 strcat( out_str
, tmp_str
);
490 if( instr_data
->arg_reg
[datum_value
] >= 0x8 )
492 sprintf( tmp_str
, "rl%d",
493 instr_data
->arg_reg
[datum_value
] - 0x8 );
497 sprintf( tmp_str
, "rh%d", instr_data
->arg_reg
[datum_value
] );
499 strcat( out_str
, tmp_str
);
502 sprintf( tmp_str
, "r%d", instr_data
->arg_reg
[datum_value
] );
503 strcat( out_str
, tmp_str
);
506 sprintf( tmp_str
, "rq%d", instr_data
->arg_reg
[datum_value
] );
507 strcat( out_str
, tmp_str
);
510 sprintf( tmp_str
, "rr%d", instr_data
->arg_reg
[datum_value
] );
511 strcat( out_str
, tmp_str
);
518 strcpy( instr_data
->instr_asmsrc
, out_str
);
This page took 0.040584 seconds and 4 git commands to generate.