1 /* mmix-dis.c -- Disassemble MMIX instructions. 2 Copyright (C) 2000-2016 Free Software Foundation, Inc. 3 Written by Hans-Peter Nilsson (hp (at) bitrange.com) 4 5 This file is part of the GNU opcodes library. 6 7 This library is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 It is distributed in the hope that it will be useful, but WITHOUT 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 15 License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this file; see the file COPYING. If not, write to the Free 19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 #include "sysdep.h" 23 #include <stdio.h> 24 #include "opcode/mmix.h" 25 #include "dis-asm.h" 26 #include "libiberty.h" 27 #include "bfd.h" 28 #include "opintl.h" 29 30 #define BAD_CASE(x) \ 31 do \ 32 { \ 33 fprintf (stderr, \ 34 _("Bad case %d (%s) in %s:%d\n"), \ 35 x, #x, __FILE__, __LINE__); \ 36 abort (); \ 37 } \ 38 while (0) 39 40 #define FATAL_DEBUG \ 41 do \ 42 { \ 43 fprintf (stderr, \ 44 _("Internal: Non-debugged code (test-case missing): %s:%d"),\ 45 __FILE__, __LINE__); \ 46 abort (); \ 47 } \ 48 while (0) 49 50 #define ROUND_MODE(n) \ 51 ((n) == 1 ? "ROUND_OFF" : (n) == 2 ? "ROUND_UP" : \ 52 (n) == 3 ? "ROUND_DOWN" : (n) == 4 ? "ROUND_NEAR" : \ 53 _("(unknown)")) 54 55 #define INSN_IMMEDIATE_BIT (IMM_OFFSET_BIT << 24) 56 #define INSN_BACKWARD_OFFSET_BIT (1 << 24) 57 58 struct mmix_dis_info 59 { 60 const char *reg_name[256]; 61 const char *spec_reg_name[32]; 62 63 /* Waste a little memory so we don't have to allocate each separately. 64 We could have an array with static contents for these, but on the 65 other hand, we don't have to. */ 66 char basic_reg_name[256][sizeof ("$255")]; 67 }; 68 69 /* Initialize a target-specific array in INFO. */ 70 71 static bfd_boolean 72 initialize_mmix_dis_info (struct disassemble_info *info) 73 { 74 struct mmix_dis_info *minfop = malloc (sizeof (struct mmix_dis_info)); 75 long i; 76 77 if (minfop == NULL) 78 return FALSE; 79 80 memset (minfop, 0, sizeof (*minfop)); 81 82 /* Initialize register names from register symbols. If there's no 83 register section, then there are no register symbols. */ 84 if ((info->section != NULL && info->section->owner != NULL) 85 || (info->symbols != NULL 86 && info->symbols[0] != NULL 87 && bfd_asymbol_bfd (info->symbols[0]) != NULL)) 88 { 89 bfd *abfd = info->section && info->section->owner != NULL 90 ? info->section->owner 91 : bfd_asymbol_bfd (info->symbols[0]); 92 asection *reg_section = bfd_get_section_by_name (abfd, "*REG*"); 93 94 if (reg_section != NULL) 95 { 96 /* The returned symcount *does* include the ending NULL. */ 97 long symsize = bfd_get_symtab_upper_bound (abfd); 98 asymbol **syms = malloc (symsize); 99 long nsyms; 100 101 if (syms == NULL) 102 { 103 FATAL_DEBUG; 104 free (minfop); 105 return FALSE; 106 } 107 nsyms = bfd_canonicalize_symtab (abfd, syms); 108 109 /* We use the first name for a register. If this is MMO, then 110 it's the name with the first sequence number, presumably the 111 first in the source. */ 112 for (i = 0; i < nsyms && syms[i] != NULL; i++) 113 { 114 if (syms[i]->section == reg_section 115 && syms[i]->value < 256 116 && minfop->reg_name[syms[i]->value] == NULL) 117 minfop->reg_name[syms[i]->value] = syms[i]->name; 118 } 119 } 120 } 121 122 /* Fill in the rest with the canonical names. */ 123 for (i = 0; i < 256; i++) 124 if (minfop->reg_name[i] == NULL) 125 { 126 sprintf (minfop->basic_reg_name[i], "$%ld", i); 127 minfop->reg_name[i] = minfop->basic_reg_name[i]; 128 } 129 130 /* We assume it's actually a one-to-one mapping of number-to-name. */ 131 for (i = 0; mmix_spec_regs[i].name != NULL; i++) 132 minfop->spec_reg_name[mmix_spec_regs[i].number] = mmix_spec_regs[i].name; 133 134 info->private_data = (void *) minfop; 135 return TRUE; 136 } 137 138 /* A table indexed by the first byte is constructed as we disassemble each 139 tetrabyte. The contents is a pointer into mmix_insns reflecting the 140 first found entry with matching match-bits and lose-bits. Further 141 entries are considered one after one until the operand constraints 142 match or the match-bits and lose-bits do not match. Normally a 143 "further entry" will just show that there was no other match. */ 144 145 static const struct mmix_opcode * 146 get_opcode (unsigned long insn) 147 { 148 static const struct mmix_opcode **opcodes = NULL; 149 const struct mmix_opcode *opcodep = mmix_opcodes; 150 unsigned int opcode_part = (insn >> 24) & 255; 151 152 if (opcodes == NULL) 153 opcodes = xcalloc (256, sizeof (struct mmix_opcode *)); 154 155 opcodep = opcodes[opcode_part]; 156 if (opcodep == NULL 157 || (opcodep->match & insn) != opcodep->match 158 || (opcodep->lose & insn) != 0) 159 { 160 /* Search through the table. */ 161 for (opcodep = mmix_opcodes; opcodep->name != NULL; opcodep++) 162 { 163 /* FIXME: Break out this into an initialization function. */ 164 if ((opcodep->match & (opcode_part << 24)) == opcode_part 165 && (opcodep->lose & (opcode_part << 24)) == 0) 166 opcodes[opcode_part] = opcodep; 167 168 if ((opcodep->match & insn) == opcodep->match 169 && (opcodep->lose & insn) == 0) 170 break; 171 } 172 } 173 174 if (opcodep->name == NULL) 175 return NULL; 176 177 /* Check constraints. If they don't match, loop through the next opcode 178 entries. */ 179 do 180 { 181 switch (opcodep->operands) 182 { 183 /* These have no restraint on what can be in the lower three 184 bytes. */ 185 case mmix_operands_regs: 186 case mmix_operands_reg_yz: 187 case mmix_operands_regs_z_opt: 188 case mmix_operands_regs_z: 189 case mmix_operands_jmp: 190 case mmix_operands_pushgo: 191 case mmix_operands_pop: 192 case mmix_operands_sync: 193 case mmix_operands_x_regs_z: 194 case mmix_operands_neg: 195 case mmix_operands_pushj: 196 case mmix_operands_regaddr: 197 case mmix_operands_get: 198 case mmix_operands_set: 199 case mmix_operands_save: 200 case mmix_operands_unsave: 201 case mmix_operands_xyz_opt: 202 return opcodep; 203 204 /* For a ROUND_MODE, the middle byte must be 0..4. */ 205 case mmix_operands_roundregs_z: 206 case mmix_operands_roundregs: 207 { 208 int midbyte = (insn >> 8) & 255; 209 210 if (midbyte <= 4) 211 return opcodep; 212 } 213 break; 214 215 case mmix_operands_put: 216 /* A "PUT". If it is "immediate", then no restrictions, 217 otherwise we have to make sure the register number is < 32. */ 218 if ((insn & INSN_IMMEDIATE_BIT) 219 || ((insn >> 16) & 255) < 32) 220 return opcodep; 221 break; 222 223 case mmix_operands_resume: 224 /* Middle bytes must be zero. */ 225 if ((insn & 0x00ffff00) == 0) 226 return opcodep; 227 break; 228 229 default: 230 BAD_CASE (opcodep->operands); 231 } 232 233 opcodep++; 234 } 235 while ((opcodep->match & insn) == opcodep->match 236 && (opcodep->lose & insn) == 0); 237 238 /* If we got here, we had no match. */ 239 return NULL; 240 } 241 242 /* The main disassembly function. */ 243 244 int 245 print_insn_mmix (bfd_vma memaddr, struct disassemble_info *info) 246 { 247 unsigned char buffer[4]; 248 unsigned long insn; 249 unsigned int x, y, z; 250 const struct mmix_opcode *opcodep; 251 int status = (*info->read_memory_func) (memaddr, buffer, 4, info); 252 struct mmix_dis_info *minfop; 253 254 if (status != 0) 255 { 256 (*info->memory_error_func) (status, memaddr, info); 257 return -1; 258 } 259 260 /* FIXME: Is -1 suitable? */ 261 if (info->private_data == NULL 262 && ! initialize_mmix_dis_info (info)) 263 return -1; 264 265 minfop = (struct mmix_dis_info *) info->private_data; 266 x = buffer[1]; 267 y = buffer[2]; 268 z = buffer[3]; 269 270 insn = bfd_getb32 (buffer); 271 272 opcodep = get_opcode (insn); 273 274 if (opcodep == NULL) 275 { 276 (*info->fprintf_func) (info->stream, _("*unknown*")); 277 return 4; 278 } 279 280 (*info->fprintf_func) (info->stream, "%s ", opcodep->name); 281 282 /* Present bytes in the order they are laid out in memory. */ 283 info->display_endian = BFD_ENDIAN_BIG; 284 285 info->insn_info_valid = 1; 286 info->bytes_per_chunk = 4; 287 info->branch_delay_insns = 0; 288 info->target = 0; 289 switch (opcodep->type) 290 { 291 case mmix_type_normal: 292 case mmix_type_memaccess_block: 293 info->insn_type = dis_nonbranch; 294 break; 295 296 case mmix_type_branch: 297 info->insn_type = dis_branch; 298 break; 299 300 case mmix_type_condbranch: 301 info->insn_type = dis_condbranch; 302 break; 303 304 case mmix_type_memaccess_octa: 305 info->insn_type = dis_dref; 306 info->data_size = 8; 307 break; 308 309 case mmix_type_memaccess_tetra: 310 info->insn_type = dis_dref; 311 info->data_size = 4; 312 break; 313 314 case mmix_type_memaccess_wyde: 315 info->insn_type = dis_dref; 316 info->data_size = 2; 317 break; 318 319 case mmix_type_memaccess_byte: 320 info->insn_type = dis_dref; 321 info->data_size = 1; 322 break; 323 324 case mmix_type_jsr: 325 info->insn_type = dis_jsr; 326 break; 327 328 default: 329 BAD_CASE(opcodep->type); 330 } 331 332 switch (opcodep->operands) 333 { 334 case mmix_operands_regs: 335 /* All registers: "$X,$Y,$Z". */ 336 (*info->fprintf_func) (info->stream, "%s,%s,%s", 337 minfop->reg_name[x], 338 minfop->reg_name[y], 339 minfop->reg_name[z]); 340 break; 341 342 case mmix_operands_reg_yz: 343 /* Like SETH - "$X,YZ". */ 344 (*info->fprintf_func) (info->stream, "%s,0x%x", 345 minfop->reg_name[x], y * 256 + z); 346 break; 347 348 case mmix_operands_regs_z_opt: 349 case mmix_operands_regs_z: 350 case mmix_operands_pushgo: 351 /* The regular "$X,$Y,$Z|Z". */ 352 if (insn & INSN_IMMEDIATE_BIT) 353 (*info->fprintf_func) (info->stream, "%s,%s,%d", 354 minfop->reg_name[x], minfop->reg_name[y], z); 355 else 356 (*info->fprintf_func) (info->stream, "%s,%s,%s", 357 minfop->reg_name[x], 358 minfop->reg_name[y], 359 minfop->reg_name[z]); 360 break; 361 362 case mmix_operands_jmp: 363 /* Address; only JMP. */ 364 { 365 bfd_signed_vma offset = (x * 65536 + y * 256 + z) * 4; 366 367 if (insn & INSN_BACKWARD_OFFSET_BIT) 368 offset -= (256 * 65536) * 4; 369 370 info->target = memaddr + offset; 371 (*info->print_address_func) (memaddr + offset, info); 372 } 373 break; 374 375 case mmix_operands_roundregs_z: 376 /* Two registers, like FLOT, possibly with rounding: "$X,$Z|Z" 377 "$X,ROUND_MODE,$Z|Z". */ 378 if (y != 0) 379 { 380 if (insn & INSN_IMMEDIATE_BIT) 381 (*info->fprintf_func) (info->stream, "%s,%s,%d", 382 minfop->reg_name[x], 383 ROUND_MODE (y), z); 384 else 385 (*info->fprintf_func) (info->stream, "%s,%s,%s", 386 minfop->reg_name[x], 387 ROUND_MODE (y), 388 minfop->reg_name[z]); 389 } 390 else 391 { 392 if (insn & INSN_IMMEDIATE_BIT) 393 (*info->fprintf_func) (info->stream, "%s,%d", 394 minfop->reg_name[x], z); 395 else 396 (*info->fprintf_func) (info->stream, "%s,%s", 397 minfop->reg_name[x], 398 minfop->reg_name[z]); 399 } 400 break; 401 402 case mmix_operands_pop: 403 /* Like POP - "X,YZ". */ 404 (*info->fprintf_func) (info->stream, "%d,%d", x, y*256 + z); 405 break; 406 407 case mmix_operands_roundregs: 408 /* Two registers, possibly with rounding: "$X,$Z" or 409 "$X,ROUND_MODE,$Z". */ 410 if (y != 0) 411 (*info->fprintf_func) (info->stream, "%s,%s,%s", 412 minfop->reg_name[x], 413 ROUND_MODE (y), 414 minfop->reg_name[z]); 415 else 416 (*info->fprintf_func) (info->stream, "%s,%s", 417 minfop->reg_name[x], 418 minfop->reg_name[z]); 419 break; 420 421 case mmix_operands_sync: 422 /* Like SYNC - "XYZ". */ 423 (*info->fprintf_func) (info->stream, "%u", 424 x * 65536 + y * 256 + z); 425 break; 426 427 case mmix_operands_x_regs_z: 428 /* Like SYNCD - "X,$Y,$Z|Z". */ 429 if (insn & INSN_IMMEDIATE_BIT) 430 (*info->fprintf_func) (info->stream, "%d,%s,%d", 431 x, minfop->reg_name[y], z); 432 else 433 (*info->fprintf_func) (info->stream, "%d,%s,%s", 434 x, minfop->reg_name[y], 435 minfop->reg_name[z]); 436 break; 437 438 case mmix_operands_neg: 439 /* Like NEG and NEGU - "$X,Y,$Z|Z". */ 440 if (insn & INSN_IMMEDIATE_BIT) 441 (*info->fprintf_func) (info->stream, "%s,%d,%d", 442 minfop->reg_name[x], y, z); 443 else 444 (*info->fprintf_func) (info->stream, "%s,%d,%s", 445 minfop->reg_name[x], y, 446 minfop->reg_name[z]); 447 break; 448 449 case mmix_operands_pushj: 450 case mmix_operands_regaddr: 451 /* Like GETA or branches - "$X,Address". */ 452 { 453 bfd_signed_vma offset = (y * 256 + z) * 4; 454 455 if (insn & INSN_BACKWARD_OFFSET_BIT) 456 offset -= 65536 * 4; 457 458 info->target = memaddr + offset; 459 460 (*info->fprintf_func) (info->stream, "%s,", minfop->reg_name[x]); 461 (*info->print_address_func) (memaddr + offset, info); 462 } 463 break; 464 465 case mmix_operands_get: 466 /* GET - "X,spec_reg". */ 467 (*info->fprintf_func) (info->stream, "%s,%s", 468 minfop->reg_name[x], 469 minfop->spec_reg_name[z]); 470 break; 471 472 case mmix_operands_put: 473 /* PUT - "spec_reg,$Z|Z". */ 474 if (insn & INSN_IMMEDIATE_BIT) 475 (*info->fprintf_func) (info->stream, "%s,%d", 476 minfop->spec_reg_name[x], z); 477 else 478 (*info->fprintf_func) (info->stream, "%s,%s", 479 minfop->spec_reg_name[x], 480 minfop->reg_name[z]); 481 break; 482 483 case mmix_operands_set: 484 /* Two registers, "$X,$Y". */ 485 (*info->fprintf_func) (info->stream, "%s,%s", 486 minfop->reg_name[x], 487 minfop->reg_name[y]); 488 break; 489 490 case mmix_operands_save: 491 /* SAVE - "$X,0". */ 492 (*info->fprintf_func) (info->stream, "%s,0", minfop->reg_name[x]); 493 break; 494 495 case mmix_operands_unsave: 496 /* UNSAVE - "0,$Z". */ 497 (*info->fprintf_func) (info->stream, "0,%s", minfop->reg_name[z]); 498 break; 499 500 case mmix_operands_xyz_opt: 501 /* Like SWYM or TRAP - "X,Y,Z". */ 502 (*info->fprintf_func) (info->stream, "%d,%d,%d", x, y, z); 503 break; 504 505 case mmix_operands_resume: 506 /* Just "Z", like RESUME. */ 507 (*info->fprintf_func) (info->stream, "%d", z); 508 break; 509 510 default: 511 (*info->fprintf_func) (info->stream, _("*unknown operands type: %d*"), 512 opcodep->operands); 513 break; 514 } 515 516 return 4; 517 } 518
