![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m68k-opmap-make.pl CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / ic / m68k|
Return to m68k-opmap-make.pl CVS log | Up to [The Machine Emulator] / tme / ic / m68k |
1.1 ! root 1: #! /usr/local/bin/perl -w ! 2: ! 3: # m68k-opmap-make.pl - compiles the complete decoding of all legal ! 4: # first-instruction-word values into the opcode map used by the C ! 5: # decoder: ! 6: ! 7: # $Id: m68k-opmap-make.pl,v 1.3 2003/04/23 19:20:30 fredette Exp $ ! 8: ! 9: # globals: ! 10: $0 =~ /^(.*\/)?([^\/]+)$/; $PROG = $2; ! 11: $debug = 0; ! 12: ! 13: # to silence -w: ! 14: undef($value); ! 15: ! 16: # emit our header: ! 17: print <<"EOF;"; ! 18: /* generated automatically by $PROG, do not edit! */ ! 19: ! 20: /* includes: */ ! 21: #include "m68k-impl.h" ! 22: EOF; ! 23: ! 24: # we begin with no submaps and no opcode maps: ! 25: $submap_next = 0; ! 26: $opcode_map_next = 0; ! 27: %opcode_maps = (); ! 28: ! 29: # assuming an ILP32 machine, various sizeofs: ! 30: $sizeof_opcode = 12; ! 31: $sizeof_submap = 64 * 24; ! 32: ! 33: # loop over standard input: ! 34: for ($line = 1; defined($_ = <STDIN>); $line++) { ! 35: chomp; ! 36: ! 37: # break the line into tokens: ! 38: @tokens = split(' ', $_); ! 39: ! 40: # if this is the beginning of a new CPU: ! 41: if ($tokens[0] eq "cpu-begin") { ! 42: $cpu_name = $tokens[1]; ! 43: ! 44: # initialize for this CPU: ! 45: print STDERR "$PROG: initializing for $cpu_name..."; ! 46: ! 47: # initialize the full map: ! 48: undef(@map_line); ! 49: for ($pattern = 65536; $pattern-- > 0;) { ! 50: $map_op0[$pattern] = "U"; ! 51: $map_op1[$pattern] = "U"; ! 52: $map_eax_size[$pattern] = "U"; ! 53: $map_eax_cycles[$pattern] = "U"; ! 54: $map_imm_operand[$pattern] = "U"; ! 55: $map_imm_size[$pattern] = "U"; ! 56: $map_eay_size[$pattern] = "U"; ! 57: $map_eay_cycles[$pattern] = "U"; ! 58: } ! 59: ! 60: # initialize the special operations: ! 61: undef(%specop); ! 62: ! 63: # we're done initializing and we're now reading patterns: ! 64: $patterns = 0; ! 65: print STDERR " done\n$PROG: reading $cpu_name patterns..."; ! 66: } ! 67: ! 68: # if this is a special-operation line: ! 69: elsif ($tokens[0] eq "specop") { ! 70: shift(@tokens); ! 71: $specop = shift(@tokens); ! 72: foreach (@tokens) { ! 73: $specop{$_} = $specop; ! 74: } ! 75: } ! 76: ! 77: # if this is a pattern: ! 78: elsif ($tokens[0] =~ /^[01]/) { ! 79: ! 80: # the first token is the pattern. die if this pattern has already ! 81: # appeared: ! 82: $pattern = oct("0b".shift(@tokens)); ! 83: die "stdin:$line: duplicate pattern of line $map_line[$pattern]\n" ! 84: if (defined($map_line[$pattern])); ! 85: $map_line[$pattern] = $line; ! 86: ! 87: # fill this map entry: ! 88: foreach $token (@tokens) { ! 89: ($what, $value) = split(/=/, $token, 2); ! 90: eval("\$map_".$what."[$pattern] = \$value;"); ! 91: } ! 92: die "stdin:$line: no function given\n" ! 93: if (!defined($map_func[$pattern])); ! 94: $patterns++; ! 95: } ! 96: ! 97: # if this is the end of a CPU: ! 98: elsif ($tokens[0] eq "cpu-end") { ! 99: $cpu_name = $tokens[1]; ! 100: ! 101: # note how many patterns we read: ! 102: print STDERR " read $patterns $cpu_name patterns\n"; ! 103: ! 104: # sanity-check the information read in, and force all unused ! 105: # full map entries to illegal: ! 106: print STDERR "$PROG: finding unused $cpu_name patterns..."; ! 107: $unused = 0; ! 108: for ($pattern = 65536; $pattern-- > 0;) { ! 109: ! 110: # if this is an unused map entry: ! 111: if (!defined($map_line[$pattern])) { ! 112: $map_func[$pattern] = "illegal"; ! 113: $unused++; ! 114: next; ! 115: } ! 116: ! 117: # since the overwhelming majority of instructions use at ! 118: # most one effective address path (the eax path), only the ! 119: # size of the eax path operand is stored in the opcode ! 120: # maps. any instruction that uses the eay path must do so ! 121: # with the same size as the eax path: ! 122: if ($map_eay_size[$pattern] ne "U") { ! 123: ! 124: # if this instruction isn't using the eax path, switch ! 125: # to using the eax path instead. the only instruction ! 126: # allowed to do this is move.S. temporarily rewrite ! 127: # this function to a special function "movenonmemtomem": ! 128: if ($map_eax_size[$pattern] eq "U") { ! 129: die "$PROG: pattern ".sprintf("%b", $pattern)." ($map_func[$pattern]) uses the eay path\n" ! 130: if ($map_func[$pattern] !~ /^(move)(\d+)$/); ! 131: $map_func[$pattern] = $1."nonmemtomem".$2; ! 132: $map_eax_size[$pattern] = $map_eay_size[$pattern]; ! 133: $map_eax_cycles[$pattern] = $map_eay_cycles[$pattern]; ! 134: $map_op0[$pattern] =~ s/^memy/memx/; ! 135: $map_op1[$pattern] =~ s/^memy/memx/; ! 136: } ! 137: ! 138: # otherwise, this instruction is using both ea paths. ! 139: # the only instruction allowed to do this is move.S. ! 140: # temporarily rewrite this function to a special ! 141: # function "movememtomem": ! 142: else { ! 143: die "$PROG: pattern ".sprintf("%b", $pattern)." ($map_func[$pattern]) uses both ea paths\n" ! 144: if ($map_func[$pattern] !~ /^(move)(\d+)$/); ! 145: $map_func[$pattern] = $1."memtomem".$2; ! 146: die "$PROG: pattern ".sprintf("%b", $pattern)." ($map_func[$pattern]) uses both ea paths at different sizes\n" ! 147: if ($map_eay_size[$pattern] ne $map_eax_size[$pattern]); ! 148: die "$PROG: pattern ".sprintf("%b", $pattern)." ($map_func[$pattern]) doesn't use eay write-only\n" ! 149: if ($map_eay_cycles[$pattern] ne "wo"); ! 150: } ! 151: } ! 152: } ! 153: print STDERR " found $unused unused $cpu_name patterns\n"; ! 154: ! 155: # loop over the root patterns to come up with the root map ! 156: # entry, the submap key and the functions list for each: ! 157: print STDERR "$PROG: making $cpu_name root map entries and submap keys..."; ! 158: for ($root = 0; $root < 1024; $root++) { ! 159: ! 160: # get counts of the different map entry attribute values. ! 161: # the most popular attribute values will get stored in the ! 162: # root map entry, while the others will get set in submap ! 163: # entries: ! 164: # ! 165: undef(%count_func); ! 166: undef(%count_op0); ! 167: undef(%count_op1); ! 168: undef(%count_eax_size); ! 169: undef(%count_imm); ! 170: for ($sub = 0, $pattern = $root << 6; $sub < 64 ; $sub++, $pattern++) { ! 171: ! 172: # the decoder specially cancels all attributes other ! 173: # than "function" when the function is "illegal", so ! 174: # don't count any of its attribute values. ! 175: # ! 176: # otherwise, function, specop, and EA cycles go ! 177: # together, and immediate operand and immediate size ! 178: # go together: ! 179: # ! 180: $func = $map_func[$pattern]; ! 181: if ($func ne "illegal") { ! 182: $specop = "un" if (!defined($specop = $specop{$func})); ! 183: $func .= ".$specop"; ! 184: if ($map_eax_size[$pattern] eq "U") { ! 185: # a pattern that doesn't use the EA path can have ! 186: # any value for its opcode map entry cycles: ! 187: die "$PROG: pattern ".sprintf("%b", $pattern)." ($func) doesn't use the EA path but needs $map_eax_cycles[$pattern] cycles?\n" ! 188: if ($map_eax_cycles[$pattern] ne "U"); ! 189: $func .= ".any"; ! 190: } ! 191: elsif ($map_eax_size[$pattern] eq "UNSIZED") { ! 192: # a pattern that uses the raw effective address ! 193: # must have UNDEF for its opcode map entry cycles: ! 194: die "$PROG: pattern ".sprintf("%b", $pattern)." ($func) takes the raw EA path but needs $map_eax_cycles[$pattern] cycles?\n" ! 195: if ($map_eax_cycles[$pattern] ne "U"); ! 196: $func .= ".un"; ! 197: } ! 198: else { ! 199: # otherwise, this pattern must have its specified ! 200: # value for its opcode map entry cycles: ! 201: die "$PROG: pattern ".sprintf("%b", $pattern)." ($func) uses the EA path at size $map_eax_size[$pattern] but needs $map_eax_cycles[$pattern] cycles?\n" ! 202: if ($map_eax_cycles[$pattern] eq "U" ! 203: || $map_eax_cycles[$pattern] eq "un"); ! 204: $func .= ".".$map_eax_cycles[$pattern]; ! 205: } ! 206: $map_func[$pattern] = $func; ! 207: $count_op0{$map_op0[$pattern]}++; ! 208: $count_op1{$map_op1[$pattern]}++; ! 209: $count_eax_size{$map_eax_size[$pattern]}++; ! 210: $count_imm{$map_imm_operand[$pattern].".".$map_imm_size[$pattern]}++; ! 211: } ! 212: $count_func{$func}++; ! 213: } ! 214: ! 215: # a pattern that doesn't use the EA path can use the same ! 216: # opcode map entry as a pattern that has the same function ! 217: # but does use the EA path, because the former pattern ! 218: # will have UNDEF for its eax size, which makes the cycles ! 219: # member of the opcode map entry a don't care: ! 220: # ! 221: @funcs = (keys(%count_func)); ! 222: %funcs_rewrite = (); ! 223: foreach $func (@funcs) { ! 224: @parts = split(/\./, $func); ! 225: if (@parts == 3 ! 226: && $parts[2] ne "any") { ! 227: $func_rewrite = $parts[0].".".$parts[1].".any"; ! 228: if (defined($count_func{$func_rewrite})) { ! 229: $count_func{$func} += delete($count_func{$func_rewrite}); ! 230: $funcs_rewrite{$func_rewrite} = $func; ! 231: } ! 232: } ! 233: } ! 234: for ($sub = 0, $pattern = $root << 6; $sub < 64 ; $sub++, $pattern++) { ! 235: $map_func[$pattern] = $func ! 236: if (defined($func = $funcs_rewrite{$map_func[$pattern]})); ! 237: } ! 238: ! 239: # sort the attributes: ! 240: @funcs = (sort { ($count_func{$b} == $count_func{$a} ! 241: ? $a cmp $b ! 242: : $count_func{$b} <=> $count_func{$a}) } keys(%count_func)); ! 243: @op0s = (sort { ($count_op0{$b} == $count_op0{$a} ! 244: ? $a cmp $b ! 245: : $count_op0{$b} <=> $count_op0{$a}) } keys(%count_op0)); ! 246: @op1s = (sort { ($count_op1{$b} == $count_op1{$a} ! 247: ? $a cmp $b ! 248: : $count_op1{$b} <=> $count_op1{$a}) } keys(%count_op1)); ! 249: @eax_sizes = (sort { ($count_eax_size{$b} == $count_eax_size{$a} ! 250: ? $a cmp $b ! 251: : $count_eax_size{$b} <=> $count_eax_size{$a}) } keys(%count_eax_size)); ! 252: @imms = (sort { ($count_imm{$b} == $count_imm{$a} ! 253: ? $a cmp $b ! 254: : $count_imm{$b} <=> $count_imm{$a}) } keys(%count_imm)); ! 255: ! 256: # make sure the attributes have at least undef in them. for ! 257: # all-illegal roots they would otherwise be empty: ! 258: push(@op0s, "U"); $count_op0{"U"}++; ! 259: push(@op1s, "U"); $count_op1{"U"}++; ! 260: push(@eax_sizes, "U"); $count_eax_size{"U"}++; ! 261: push(@imms, "U.U"); $count_imm{"U.U"}++; ! 262: ! 263: # display the attributes: ! 264: if (1 && $debug) { ! 265: print STDERR "root $root:"; ! 266: print STDERR "\n funcs"; foreach (@funcs) { print STDERR " $_ ($count_func{$_})"} ! 267: print STDERR "\n op0s"; foreach (@op0s) { print STDERR " $_ ($count_op0{$_})"} ! 268: print STDERR "\n op1s"; foreach (@op1s) { print STDERR " $_ ($count_op1{$_})"} ! 269: print STDERR "\n eax_sizes"; foreach (@eax_sizes) { print STDERR " $_ ($count_eax_size{$_})"} ! 270: print STDERR "\n imms"; foreach (@imms) { print STDERR " $_ ($count_imm{$_})"} ! 271: print STDERR "\n"; ! 272: } ! 273: ! 274: # form the submap key. this is a very long string ! 275: # describing what a submap must do with attributes in ! 276: # order to be associated with this root. this string is ! 277: # very long because it lists all attributes for the 64 ! 278: # subs under this root: ! 279: # ! 280: # this string really ends up being a regular expression, ! 281: # and since the decoder specially cancels all attributes ! 282: # when the function is "illegal", illegal can really take ! 283: # any attributes, so wildcards are used: ! 284: # ! 285: @key = (); ! 286: for ($sub = 0, $pattern = $root << 6; $sub < 64 ; $sub++, $pattern++) { ! 287: if ($map_func[$pattern] eq "illegal") { ! 288: push(@key, '\S+'); ! 289: push(@key, '\S+'); ! 290: push(@key, '\S+'); ! 291: push(@key, '\S+'); ! 292: } ! 293: else { ! 294: ! 295: # the op0 and op1 attributes can be anything for ! 296: # patterns that don't use them ("U" for ! 297: # undefined), because even if they are defined in ! 298: # the submap or root, the instruction decoder does ! 299: # nothing except pass them to the instruction ! 300: # functions, which don't care. so they can be ! 301: # anything in the submap key: ! 302: $_ = $map_op0[$pattern]; push(@key, ($_ eq "U" ? '\S+' : $_ eq $op0s[0] ? "U" : $_)); ! 303: $_ = $map_op1[$pattern]; push(@key, ($_ eq "U" ? '\S+' : $_ eq $op1s[0] ? "U" : $_)); ! 304: ! 305: # however, the same is not true for the EA size ! 306: # and immediate operand attributes. if a pattern ! 307: # doesn't use these attributes, they *must* be ! 308: # undefined in the submap, so that any defined ! 309: # attribute in the root is ignored - otherwise the ! 310: # instruction decoder will do EA work and fetch ! 311: # immediates when it isn't supposed to. this ! 312: # means that we have to introduce a ! 313: # use-the-root-attribute value for those patterns ! 314: # that *must* use the root attribute value. we ! 315: # use "X" to stand for this value: ! 316: $_ = $map_eax_size[$pattern]; push(@key, ($_ eq $eax_sizes[0] ? "X" : $_)); ! 317: $_ = $map_imm_operand[$pattern].".".$map_imm_size[$pattern]; push(@key, ($_ eq $imms[0] ? "X" : $_)); ! 318: } ! 319: } ! 320: $key = join(" ", @key); ! 321: $root_key[$root] = $key; ! 322: $root_funcs[$root] = join(",", @funcs); ! 323: $root_op0[$root] = $op0s[0]; ! 324: $root_op1[$root] = $op1s[0]; ! 325: $root_eax_size[$root] = $eax_sizes[0]; ! 326: $imms[0] =~ /^(.*)\.(.*)$/; ! 327: $root_imm_operand[$root] = $1; ! 328: $root_imm_size[$root] = $2; ! 329: undef($root_submap[$root]); ! 330: print STDERR " key $key\n" if (0 && $debug); ! 331: } ! 332: print STDERR " done\n"; ! 333: ! 334: # create submaps and opcode maps for the roots: ! 335: $submaps_new = $submap_next; ! 336: print STDERR "$PROG: creating $cpu_name submaps..."; ! 337: for ($root = 0; $root < 1024; $root++) { ! 338: ! 339: # get the function array and key for this root: ! 340: @funcs = split(/,/, $root_funcs[$root]); ! 341: $key = $root_key[$root]; ! 342: print STDERR " root $root key $key\n" if (0 && $debug); ! 343: ! 344: # calculate the additional memory cost of creating a new ! 345: # submap for this root: ! 346: $submap_best_cost = ($sizeof_submap ! 347: # our opcode map: ! 348: + (@funcs * $sizeof_opcode)); ! 349: ! 350: # check all of the existing submaps for a key match: ! 351: undef($submap_best); ! 352: $key =~ s/\./\\\./g; ! 353: for ($submap = 0; $submap < $submap_next; $submap++) { ! 354: next unless ($submap_key[$submap] =~ /^$key$/); ! 355: ! 356: # get the opcode map indices array, and the size of ! 357: # the opcode map currently required by this submap: ! 358: @opcode_map_indices = split(/,/, $submap_opcode_map_indices[$submap]); ! 359: $opcode_map_size = $submap_opcode_map_size[$submap]; ! 360: ! 361: # loop over the submap entries, seeing how the submap's opcode ! 362: # map indices would have to change to accomodate this root: ! 363: undef(@index_to_func); ! 364: undef(%func_to_new_index); ! 365: for ($sub = 0, $pattern = $root << 6; $sub < 64 ; $sub++, $pattern++) { ! 366: $opcode_map_index = $opcode_map_indices[$sub]; ! 367: $func = $index_to_func[$opcode_map_index]; ! 368: if (!defined($func)) { ! 369: $index_to_func[$opcode_map_index] = $map_func[$pattern]; ! 370: } ! 371: elsif ($func ne $map_func[$pattern]) { ! 372: if (!defined($_ = $func_to_new_index{$map_func[$pattern]})) { ! 373: $_ = $func_to_new_index{$func} = $opcode_map_size++; ! 374: $index_to_func[$_] = $func; ! 375: } ! 376: $opcode_map_indices[$sub] = $_; ! 377: } ! 378: } ! 379: ! 380: # a submap for an earlier CPU is off-limits unless we ! 381: # can use it without growing the opcode map it ! 382: # requires, since both the submap and the earlier ! 383: # CPU's opcode maps have already been generated: ! 384: next if ($submap < $submaps_new ! 385: && $opcode_map_size > $submap_opcode_map_size[$submap]); ! 386: ! 387: # calculate the additional memory cost of reusing this ! 388: # submap for this root: ! 389: $submap_cost = 0; ! 390: ! 391: # if the exact opcode map we would need doesn't ! 392: # already exist, we would have to create it: ! 393: $opcode_map_key = join(" ", @index_to_func); ! 394: $submap_cost += ($sizeof_opcode ! 395: * $opcode_map_size) ! 396: if (!defined($opcode_map{$opcode_map_key})); ! 397: ! 398: # if we would grow the size of the opcode map required ! 399: # by this submap by N entries, that's N more opcodes ! 400: # for *each* root already using this submap: ! 401: $submap_cost += ($sizeof_opcode ! 402: * ($submap_refcnt[$submap] ! 403: * ($opcode_map_size ! 404: - $submap_opcode_map_size[$submap]))); ! 405: ! 406: # if using this submap for this root is still better ! 407: # than any alternative, remember it and how we may ! 408: # want to change it: ! 409: if ($submap_cost < $submap_best_cost) { ! 410: $submap_best = $submap; ! 411: $submap_best_cost = $submap_cost; ! 412: @submap_best_opcode_map_indices = @opcode_map_indices; ! 413: $submap_best_opcode_map_size = $opcode_map_size; ! 414: } ! 415: } ! 416: ! 417: # if there is a best existing submap, make changes to it: ! 418: if (defined($submap_best)) { ! 419: if ($submap_opcode_map_size[$submap_best] != $submap_best_opcode_map_size) { ! 420: $submap_opcode_map_indices[$submap_best] = join(",", @submap_best_opcode_map_indices); ! 421: $submap_opcode_map_size[$submap_best] = $submap_best_opcode_map_size; ! 422: print STDERR " submap $submap_best now funcs ".join(",", @funcs).", ($opcode_map_size) indices ".join(",", @opcode_map_indices)."\n" ! 423: if ($debug); ! 424: } ! 425: } ! 426: ! 427: # otherwise, create a new submap: ! 428: else { ! 429: ! 430: # allocate a new submap number: ! 431: $submap_best = $submap_next++; ! 432: ! 433: # create the hash of function name to opcode map index: ! 434: undef(%func_to_index); ! 435: $opcode_map_size = 0; ! 436: foreach $func (@funcs) { ! 437: $func_to_index{$func} = $opcode_map_size++; ! 438: } ! 439: ! 440: # now make the list of opcode map indices: ! 441: @opcode_map_indices = (); ! 442: for ($sub = 0, $pattern = $root << 6; $sub < 64 ; $sub++, $pattern++) { ! 443: die "internal error - func $map_func[$pattern] missing from ".join(" ", @funcs)."\n" ! 444: if (!defined($func_to_index{$map_func[$pattern]})); ! 445: push(@opcode_map_indices, $func_to_index{$map_func[$pattern]}); ! 446: } ! 447: ! 448: # officially add this new submap: ! 449: $submap_opcode_map_indices[$submap_best] = join(",", @opcode_map_indices); ! 450: $submap_opcode_map_size[$submap_best] = $opcode_map_size; ! 451: $submap_key[$submap_best] = $root_key[$root]; ! 452: print STDERR " new submap $submap_best, funcs ".join(",", @funcs).", ($opcode_map_size) indices ".join(",", @opcode_map_indices)."\n" ! 453: if ($debug); ! 454: } ! 455: ! 456: # note how reference counts have changed: ! 457: $root_submap[$root] = $submap_best; ! 458: $submap_refcnt[$submap_best]++; ! 459: print STDERR " refcnt on submap $submap_best now $submap_refcnt[$submap_best]\n" if ($debug); ! 460: } ! 461: ! 462: # write out any newly created submaps: ! 463: $submaps = 0; ! 464: for ($submap = $submaps_new; $submap < $submap_next; $submap++) { ! 465: next if ($submap_refcnt[$submap] == 0); ! 466: $submaps++; ! 467: ! 468: print <<"EOF;"; ! 469: ! 470: /* create submap $submap: */ ! 471: static struct _tme_m68k_decoder_submap * ! 472: _tme_m68k_create_submap$submap(struct tme_m68k *ic) ! 473: { ! 474: struct _tme_m68k_decoder_submap *submap, *submap_entry; ! 475: int entry_i; ! 476: ! 477: /* allocate and initialize the submap: */ ! 478: submap = tme_new(struct _tme_m68k_decoder_submap, 64); ! 479: submap_entry = submap; ! 480: for (entry_i = 0; entry_i < 64; entry_i++) { ! 481: submap_entry->_tme_m68k_decoder_submap_gen._tme_m68k_decoder_gen_operand0 = NULL; ! 482: submap_entry->_tme_m68k_decoder_submap_gen._tme_m68k_decoder_gen_operand1 = NULL; ! 483: submap_entry->_tme_m68k_decoder_submap_gen._tme_m68k_decoder_gen_eax_size = TME_M68K_SIZE_UNDEF; ! 484: submap_entry->_tme_m68k_decoder_submap_gen._tme_m68k_decoder_gen_imm_operand = TME_M68K_OPNUM_UNDEF; ! 485: submap_entry++; ! 486: } ! 487: ! 488: /* fill the submap: */ ! 489: submap_entry = submap; ! 490: EOF; ! 491: ! 492: # get the submap key and opcode map indices and split them up: ! 493: @key = split(' ', $submap_key[$submap]); ! 494: @opcode_map_indices = split(/,/, $submap_opcode_map_indices[$submap]); ! 495: ! 496: # emit the code to initialize each submap entry: ! 497: for ($sub = 0; $sub < 64 ; $sub++) { ! 498: print "\n /* submap $submap sub $sub */\n"; ! 499: ! 500: # emit op0: ! 501: $op0 = &operand_final(shift(@key)); ! 502: print " submap_entry->_tme_m68k_decoder_submap_gen._tme_m68k_decoder_gen_operand0 = $op0;\n" ! 503: if (defined($op0)); ! 504: ! 505: # emit op1: ! 506: $op1 = &operand_final(shift(@key)); ! 507: print " submap_entry->_tme_m68k_decoder_submap_gen._tme_m68k_decoder_gen_operand1 = $op1;\n" ! 508: if (defined($op1)); ! 509: ! 510: # emit eax_size: ! 511: $eax_size = shift(@key); ! 512: $eax_size = "SUBMAP_X" if ($eax_size eq "X"); ! 513: print " submap_entry->_tme_m68k_decoder_submap_gen._tme_m68k_decoder_gen_eax_size = TME_M68K_SIZE_$eax_size;\n" ! 514: if ($eax_size ne "U" && $eax_size ne '\S+'); ! 515: ! 516: # emit imm_size and imm_operand: ! 517: $_ = shift(@key); ! 518: if ($_ eq "X") { ! 519: print " submap_entry->_tme_m68k_decoder_submap_gen._tme_m68k_decoder_gen_imm_operand = TME_M68K_OPNUM_SUBMAP_X;\n"; ! 520: } ! 521: elsif ($_ !~ /^U/ && $_ ne '\S+') { ! 522: ($imm_operand, $imm_size) = (/^(\S+)\.(\S+)/); ! 523: $imm_size = "16U8" if ($imm_size eq "8"); ! 524: print " submap_entry->_tme_m68k_decoder_submap_gen._tme_m68k_decoder_gen_imm_operand = $imm_operand;\n"; ! 525: print " submap_entry->_tme_m68k_decoder_submap_gen._tme_m68k_decoder_gen_imm_size = TME_M68K_SIZE_$imm_size;\n"; ! 526: } ! 527: ! 528: # emit the opcode map index: ! 529: print " (submap_entry++)->_tme_m68k_decoder_submap_opcode_map_index = $opcode_map_indices[$sub];\n"; ! 530: } ! 531: ! 532: # finish the function: ! 533: print <<"EOF;"; ! 534: ! 535: /* done: */ ! 536: return(submap); ! 537: } ! 538: EOF; ! 539: } ! 540: ! 541: # for each root, according to the submap used, either use an ! 542: # existing opcode map or create a new opcode map: ! 543: $opcode_maps = 0; ! 544: for ($root = 0; $root < 1024; $root++) { ! 545: ! 546: # create the opcode map key: ! 547: $submap = $root_submap[$root]; ! 548: @opcode_map_indices = split(/,/, $submap_opcode_map_indices[$submap]); ! 549: $opcode_map_size = $submap_opcode_map_size[$submap]; ! 550: undef(@index_to_func); ! 551: for ($sub = 0, $pattern = $root << 6; $sub < 64 ; $sub++, $pattern++) { ! 552: $opcode_map_index = $opcode_map_indices[$sub]; ! 553: $func = $index_to_func[$opcode_map_index]; ! 554: if (!defined($func)) { ! 555: $index_to_func[$opcode_map_index] = $map_func[$pattern]; ! 556: } ! 557: elsif ($func ne $map_func[$pattern]) { ! 558: die "$PROG internal error: opcode map indices broken (root $root, submap $submap, sub $sub index $opcode_map_index needs to be $map_func[$pattern], but it's already $func)\n"; ! 559: } ! 560: } ! 561: $opcode_map_key = join(" ", @index_to_func); ! 562: ! 563: # if the exact opcode map we need doesn't already exist, ! 564: # create it: ! 565: if (!defined($opcode_map = $opcode_maps{$opcode_map_key})) { ! 566: $opcode_map = $opcode_map_next++; ! 567: $opcode_maps{$opcode_map_key} = $opcode_map; ! 568: $opcode_maps++; ! 569: ! 570: print "\n"; ! 571: print "/* opcode map for $cpu_name root $root (submap $submap): */\n"; ! 572: print "static const struct _tme_m68k_opcode _tme_m68k_opcode_map${opcode_map}[$opcode_map_size] = {\n"; ! 573: for ($map_i = 0; $map_i < $opcode_map_size; $map_i++) { ! 574: @parts = split(/\./, $index_to_func[$map_i]); ! 575: ($func, $specop, $cycles) = @parts; ! 576: if ($func =~ /^(\S+)(nonmemtomem)(\d+)/ ! 577: || $func =~ /^(\S+)(memtomem)(\d+)/) { ! 578: $func = $1.$3; ! 579: $specop = $1.$2; ! 580: } ! 581: $specop = "undef" ! 582: if (!defined($specop) ! 583: || $specop eq "un"); ! 584: $specop =~ tr/a-z/A-Z/; ! 585: $specop = "TME_M68K_SPECOP_$specop"; ! 586: if (!defined($cycles) ! 587: || $cycles eq "un" ! 588: || $cycles eq "any") { ! 589: $cycles = "TME_BUS_CYCLE_UNDEF"; ! 590: } ! 591: elsif ($cycles eq "ro") { ! 592: $cycles = "TME_BUS_CYCLE_READ"; ! 593: } ! 594: elsif ($cycles eq "wo") { ! 595: $cycles = "TME_BUS_CYCLE_WRITE"; ! 596: } ! 597: elsif ($cycles eq "rw") { ! 598: $cycles = "TME_BUS_CYCLE_READ|TME_BUS_CYCLE_WRITE"; ! 599: } ! 600: else { ! 601: die "$PROG error: bad cycles $cycles\n"; ! 602: } ! 603: print " { tme_m68k_$func, $specop, $cycles },\n"; ! 604: } ! 605: print "};\n"; ! 606: } ! 607: $root_opcode_map[$root] = $opcode_map; ! 608: } ! 609: print STDERR " created $submaps new submaps, $opcode_maps new opcode maps\n"; ! 610: ! 611: # write out the function that creates the root map: ! 612: print <<"EOF;"; ! 613: ! 614: /* initializes the ${cpu_name} decoder map: */ ! 615: void ! 616: _tme_${cpu_name}_decoder_map_init(struct tme_m68k *ic) ! 617: { ! 618: struct _tme_m68k_decoder_root *root, *root_entry; ! 619: int entry_i; ! 620: EOF; ! 621: ! 622: print "\n"; ! 623: print " /* the submaps used by this CPU: */\n"; ! 624: undef(@submap_done); ! 625: for ($root = 0; $root < 1024; $root++) { ! 626: $submap = $root_submap[$root]; ! 627: if (!$submap_done[$submap]) { ! 628: print " struct _tme_m68k_decoder_submap *submap$submap = _tme_m68k_create_submap$submap(ic);\n"; ! 629: $submap_done[$submap] = 1; ! 630: } ! 631: } ! 632: ! 633: print <<'EOF;'; ! 634: ! 635: /* allocate and initialize the root map: */ ! 636: root = tme_new(struct _tme_m68k_decoder_root, 1024); ! 637: ic->_tme_m68k_decoder_root = root; ! 638: root_entry = root; ! 639: for (entry_i = 0; entry_i < 1024; entry_i++) { ! 640: root_entry->_tme_m68k_decoder_root_gen._tme_m68k_decoder_gen_operand0 = NULL; ! 641: root_entry->_tme_m68k_decoder_root_gen._tme_m68k_decoder_gen_operand1 = NULL; ! 642: root_entry->_tme_m68k_decoder_root_gen._tme_m68k_decoder_gen_eax_size = TME_M68K_SIZE_UNDEF; ! 643: root_entry->_tme_m68k_decoder_root_gen._tme_m68k_decoder_gen_imm_operand = TME_M68K_OPNUM_UNDEF; ! 644: root_entry++; ! 645: } ! 646: root_entry = root; ! 647: EOF; ! 648: ! 649: print "\n"; ! 650: print " /* fill the root map: */\n"; ! 651: for ($root = 0; $root < 1024; $root++) { ! 652: print "\n /* root $root (base opcode ".sprintf("0x%04x", ($root << 6))."): */\n"; ! 653: ! 654: # emit op0: ! 655: $op0 = &operand_final($root_op0[$root]); ! 656: print " root_entry->_tme_m68k_decoder_root_gen._tme_m68k_decoder_gen_operand0 = $op0;\n" ! 657: if (defined($op0)); ! 658: ! 659: # emit op1: ! 660: $op1 = &operand_final($root_op1[$root]); ! 661: print " root_entry->_tme_m68k_decoder_root_gen._tme_m68k_decoder_gen_operand1 = $op1;\n" ! 662: if (defined($op1)); ! 663: ! 664: # emit eax_size: ! 665: $eax_size = $root_eax_size[$root]; ! 666: print " root_entry->_tme_m68k_decoder_root_gen._tme_m68k_decoder_gen_eax_size = TME_M68K_SIZE_$eax_size;\n" ! 667: if ($eax_size ne "U"); ! 668: ! 669: # emit imm_size and imm_operand: ! 670: $imm_operand = $root_imm_operand[$root]; ! 671: if ($imm_operand ne "U" && $imm_operand ne '\S+') { ! 672: $imm_size = $root_imm_size[$root]; ! 673: $imm_size = "16U8" if ($imm_size eq "8"); ! 674: print " root_entry->_tme_m68k_decoder_root_gen._tme_m68k_decoder_gen_imm_operand = $imm_operand;\n"; ! 675: print " root_entry->_tme_m68k_decoder_root_gen._tme_m68k_decoder_gen_imm_size = TME_M68K_SIZE_$imm_size;\n"; ! 676: } ! 677: ! 678: # emit the submap and opcode map: ! 679: print " root_entry->_tme_m68k_decoder_root_submap = submap$root_submap[$root];\n"; ! 680: print " (root_entry++)->_tme_m68k_decoder_root_opcode_map = _tme_m68k_opcode_map$root_opcode_map[$root];\n"; ! 681: } ! 682: ! 683: # close the function: ! 684: print "\n}\n"; ! 685: } ! 686: ! 687: # anything else is an error: ! 688: else { ! 689: print STDERR "stdin:$line $PROG error: don't know how to handle: ".join(" ", @tokens)."\n"; ! 690: exit(1); ! 691: } ! 692: } ! 693: ! 694: # done: ! 695: exit(0); ! 696: ! 697: # this subroutine returns the final C version of an operand: ! 698: sub operand_final { ! 699: local ($op) = @_; ! 700: ! 701: if ($op eq "U" || $op eq '\S+') { ! 702: undef($op); ! 703: } ! 704: elsif ($op =~ /^\%([ad][0-7])\.(\d+)/) { ! 705: ($op, $op_size) = ($1, $2); ! 706: $op =~ tr/a-z/A-Z/; ! 707: if ($op_size == 16) { ! 708: $op .= " << 1"; ! 709: } ! 710: elsif ($op_size == 8) { ! 711: $op .= " << 2"; ! 712: } ! 713: $op = "&ic->tme_m68k_ireg_uint${op_size}(TME_M68K_IREG_${op})"; ! 714: } ! 715: elsif ($op eq "eax.32") { ! 716: $op = "&ic->_tme_m68k_ea_address"; ! 717: } ! 718: elsif ($op =~ /^imm(\d+)\.(\d+)/) { ! 719: $op = "(tme_uint${2}_t *) &_tme_m68k_imm${2}[${1}]"; ! 720: } ! 721: elsif ($op =~ /^mem[xy]\.(\d+)/) { ! 722: $op = "&ic->tme_m68k_ireg_memx${1}"; ! 723: } ! 724: else { ! 725: die "$PROG fatal: unknown operand $op\n"; ! 726: } ! 727: $op; ! 728: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.