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