daily update
[binutils.git] / opcodes / ip2k-dis.c
blob00e764ccceddbac07e86656b2357cfbd9dce2bd4
1 /* Disassembler interface for targets using CGEN. -*- C -*-
2 CGEN: Cpu tools GENerator
4 THIS FILE IS MACHINE GENERATED WITH CGEN.
5 - the resultant file is machine generated, cgen-dis.in isn't
7 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
8 Free Software Foundation, Inc.
10 This file is part of the GNU Binutils and GDB, the GNU debugger.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2, or (at your option)
15 any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software Foundation, Inc.,
24 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
27 Keep that in mind. */
29 #include "sysdep.h"
30 #include <stdio.h>
31 #include "ansidecl.h"
32 #include "dis-asm.h"
33 #include "bfd.h"
34 #include "symcat.h"
35 #include "libiberty.h"
36 #include "ip2k-desc.h"
37 #include "ip2k-opc.h"
38 #include "opintl.h"
40 /* Default text to print if an instruction isn't recognized. */
41 #define UNKNOWN_INSN_MSG _("*unknown*")
43 static void print_normal
44 (CGEN_CPU_DESC, void *, long, unsigned int, bfd_vma, int);
45 static void print_address
46 (CGEN_CPU_DESC, void *, bfd_vma, unsigned int, bfd_vma, int);
47 static void print_keyword
48 (CGEN_CPU_DESC, void *, CGEN_KEYWORD *, long, unsigned int);
49 static void print_insn_normal
50 (CGEN_CPU_DESC, void *, const CGEN_INSN *, CGEN_FIELDS *, bfd_vma, int);
51 static int print_insn
52 (CGEN_CPU_DESC, bfd_vma, disassemble_info *, char *, unsigned);
53 static int default_print_insn
54 (CGEN_CPU_DESC, bfd_vma, disassemble_info *);
55 static int read_insn
56 (CGEN_CPU_DESC, bfd_vma, disassemble_info *, char *, int, CGEN_EXTRACT_INFO *,
57 unsigned long *);
59 /* -- disassembler routines inserted here */
61 /* -- dis.c */
63 #define PRINT_FUNC_DECL(name) \
64 static void name PARAMS ((CGEN_CPU_DESC, PTR, long, unsigned int, bfd_vma, int))
66 PRINT_FUNC_DECL (print_fr);
67 PRINT_FUNC_DECL (print_dollarhex);
68 PRINT_FUNC_DECL (print_dollarhex8);
69 PRINT_FUNC_DECL (print_dollarhex16);
70 PRINT_FUNC_DECL (print_dollarhex_addr16h);
71 PRINT_FUNC_DECL (print_dollarhex_addr16l);
72 PRINT_FUNC_DECL (print_dollarhex_p);
73 PRINT_FUNC_DECL (print_dollarhex_cj);
74 PRINT_FUNC_DECL (print_decimal);
76 static void
77 print_fr (cd, dis_info, value, attrs, pc, length)
78 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
79 PTR dis_info;
80 long value;
81 unsigned int attrs ATTRIBUTE_UNUSED;
82 bfd_vma pc ATTRIBUTE_UNUSED;
83 int length ATTRIBUTE_UNUSED;
85 disassemble_info *info = (disassemble_info *) dis_info;
86 const CGEN_KEYWORD_ENTRY *ke;
87 extern CGEN_KEYWORD ip2k_cgen_opval_register_names;
88 long offsettest;
89 long offsetvalue;
91 if ( value == 0 ) /* This is (IP) */
93 (*info->fprintf_func) (info->stream, "%s", "(IP)");
94 return;
97 offsettest = value >> 7;
98 offsetvalue = value & 0x7F;
100 /* Check to see if first two bits are 10 -> (DP) */
101 if ( offsettest == 2 )
103 if ( offsetvalue == 0 )
104 (*info->fprintf_func) (info->stream, "%s","(DP)");
105 else
106 (*info->fprintf_func) (info->stream, "$%x%s",offsetvalue, "(DP)");
107 return;
110 /* Check to see if first two bits are 11 -> (SP) */
111 if ( offsettest == 3 )
113 if ( offsetvalue == 0 )
114 (*info->fprintf_func) (info->stream, "%s", "(SP)");
115 else
116 (*info->fprintf_func) (info->stream, "$%x%s", offsetvalue,"(SP)");
117 return;
120 /* Attempt to print as a register keyword. */
121 ke = cgen_keyword_lookup_value (& ip2k_cgen_opval_register_names, value);
122 if (ke != NULL)
124 (*info->fprintf_func) (info->stream, "%s", ke->name);
125 return;
128 /* Print as an address literal. */
129 (*info->fprintf_func) (info->stream, "$%02x", value);
132 static void
133 print_dollarhex (cd, dis_info, value, attrs, pc, length)
134 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
135 PTR dis_info;
136 long value;
137 unsigned int attrs ATTRIBUTE_UNUSED;
138 bfd_vma pc ATTRIBUTE_UNUSED;
139 int length ATTRIBUTE_UNUSED;
141 disassemble_info *info = (disassemble_info *) dis_info;
143 (*info->fprintf_func) (info->stream, "$%x", value);
146 static void
147 print_dollarhex8 (cd, dis_info, value, attrs, pc, length)
148 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
149 PTR dis_info;
150 long value;
151 unsigned int attrs ATTRIBUTE_UNUSED;
152 bfd_vma pc ATTRIBUTE_UNUSED;
153 int length ATTRIBUTE_UNUSED;
155 disassemble_info *info = (disassemble_info *) dis_info;
157 (*info->fprintf_func) (info->stream, "$%02x", value);
160 static void
161 print_dollarhex16 (cd, dis_info, value, attrs, pc, length)
162 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
163 PTR dis_info;
164 long value;
165 unsigned int attrs ATTRIBUTE_UNUSED;
166 bfd_vma pc ATTRIBUTE_UNUSED;
167 int length ATTRIBUTE_UNUSED;
169 disassemble_info *info = (disassemble_info *) dis_info;
171 (*info->fprintf_func) (info->stream, "$%04x", value);
174 static void
175 print_dollarhex_addr16h (cd, dis_info, value, attrs, pc, length)
176 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
177 PTR dis_info;
178 long value;
179 unsigned int attrs ATTRIBUTE_UNUSED;
180 bfd_vma pc ATTRIBUTE_UNUSED;
181 int length ATTRIBUTE_UNUSED;
183 disassemble_info *info = (disassemble_info *) dis_info;
185 /* This is a loadh instruction. Shift the value to the left */
186 /* by 8 bits so that disassembled code will reassemble properly. */
187 value = ((value << 8) & 0xFF00);
189 (*info->fprintf_func) (info->stream, "$%04x", value);
192 static void
193 print_dollarhex_addr16l (cd, dis_info, value, attrs, pc, length)
194 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
195 PTR dis_info;
196 long value;
197 unsigned int attrs ATTRIBUTE_UNUSED;
198 bfd_vma pc ATTRIBUTE_UNUSED;
199 int length ATTRIBUTE_UNUSED;
201 disassemble_info *info = (disassemble_info *) dis_info;
203 (*info->fprintf_func) (info->stream, "$%04x", value);
206 static void
207 print_dollarhex_p (cd, dis_info, value, attrs, pc, length)
208 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
209 PTR dis_info;
210 long value;
211 unsigned int attrs ATTRIBUTE_UNUSED;
212 bfd_vma pc ATTRIBUTE_UNUSED;
213 int length ATTRIBUTE_UNUSED;
215 disassemble_info *info = (disassemble_info *) dis_info;
217 value = ((value << 14) & 0x1C000);
218 ;value = (value & 0x1FFFF);
219 (*info->fprintf_func) (info->stream, "$%05x", value);
222 static void
223 print_dollarhex_cj (cd, dis_info, value, attrs, pc, length)
224 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
225 PTR dis_info;
226 long value;
227 unsigned int attrs ATTRIBUTE_UNUSED;
228 bfd_vma pc ATTRIBUTE_UNUSED;
229 int length ATTRIBUTE_UNUSED;
231 disassemble_info *info = (disassemble_info *) dis_info;
233 value = ((value << 1) & 0x1FFFF);
234 (*info->fprintf_func) (info->stream, "$%05x", value);
238 static void
239 print_decimal (cd, dis_info, value, attrs, pc, length)
240 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
241 PTR dis_info;
242 long value;
243 unsigned int attrs ATTRIBUTE_UNUSED;
244 bfd_vma pc ATTRIBUTE_UNUSED;
245 int length ATTRIBUTE_UNUSED;
247 disassemble_info *info = (disassemble_info *) dis_info;
249 (*info->fprintf_func) (info->stream, "%d", value);
254 /* -- */
256 void ip2k_cgen_print_operand
257 PARAMS ((CGEN_CPU_DESC, int, PTR, CGEN_FIELDS *,
258 void const *, bfd_vma, int));
260 /* Main entry point for printing operands.
261 XINFO is a `void *' and not a `disassemble_info *' to not put a requirement
262 of dis-asm.h on cgen.h.
264 This function is basically just a big switch statement. Earlier versions
265 used tables to look up the function to use, but
266 - if the table contains both assembler and disassembler functions then
267 the disassembler contains much of the assembler and vice-versa,
268 - there's a lot of inlining possibilities as things grow,
269 - using a switch statement avoids the function call overhead.
271 This function could be moved into `print_insn_normal', but keeping it
272 separate makes clear the interface between `print_insn_normal' and each of
273 the handlers. */
275 void
276 ip2k_cgen_print_operand (cd, opindex, xinfo, fields, attrs, pc, length)
277 CGEN_CPU_DESC cd;
278 int opindex;
279 PTR xinfo;
280 CGEN_FIELDS *fields;
281 void const *attrs ATTRIBUTE_UNUSED;
282 bfd_vma pc;
283 int length;
285 disassemble_info *info = (disassemble_info *) xinfo;
287 switch (opindex)
289 case IP2K_OPERAND_ADDR16CJP :
290 print_dollarhex_cj (cd, info, fields->f_addr16cjp, 0|(1<<CGEN_OPERAND_ABS_ADDR), pc, length);
291 break;
292 case IP2K_OPERAND_ADDR16H :
293 print_dollarhex_addr16h (cd, info, fields->f_imm8, 0, pc, length);
294 break;
295 case IP2K_OPERAND_ADDR16L :
296 print_dollarhex_addr16l (cd, info, fields->f_imm8, 0, pc, length);
297 break;
298 case IP2K_OPERAND_ADDR16P :
299 print_dollarhex_p (cd, info, fields->f_page3, 0, pc, length);
300 break;
301 case IP2K_OPERAND_BITNO :
302 print_decimal (cd, info, fields->f_bitno, 0, pc, length);
303 break;
304 case IP2K_OPERAND_CBIT :
305 print_normal (cd, info, 0, 0, pc, length);
306 break;
307 case IP2K_OPERAND_DCBIT :
308 print_normal (cd, info, 0, 0, pc, length);
309 break;
310 case IP2K_OPERAND_FR :
311 print_fr (cd, info, fields->f_reg, 0|(1<<CGEN_OPERAND_ABS_ADDR), pc, length);
312 break;
313 case IP2K_OPERAND_LIT8 :
314 print_dollarhex8 (cd, info, fields->f_imm8, 0|(1<<CGEN_OPERAND_SIGNED), pc, length);
315 break;
316 case IP2K_OPERAND_PABITS :
317 print_normal (cd, info, 0, 0, pc, length);
318 break;
319 case IP2K_OPERAND_RETI3 :
320 print_dollarhex (cd, info, fields->f_reti3, 0, pc, length);
321 break;
322 case IP2K_OPERAND_ZBIT :
323 print_normal (cd, info, 0, 0, pc, length);
324 break;
326 default :
327 /* xgettext:c-format */
328 fprintf (stderr, _("Unrecognized field %d while printing insn.\n"),
329 opindex);
330 abort ();
334 cgen_print_fn * const ip2k_cgen_print_handlers[] =
336 print_insn_normal,
340 void
341 ip2k_cgen_init_dis (cd)
342 CGEN_CPU_DESC cd;
344 ip2k_cgen_init_opcode_table (cd);
345 ip2k_cgen_init_ibld_table (cd);
346 cd->print_handlers = & ip2k_cgen_print_handlers[0];
347 cd->print_operand = ip2k_cgen_print_operand;
351 /* Default print handler. */
353 static void
354 print_normal (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
355 void *dis_info,
356 long value,
357 unsigned int attrs,
358 bfd_vma pc ATTRIBUTE_UNUSED,
359 int length ATTRIBUTE_UNUSED)
361 disassemble_info *info = (disassemble_info *) dis_info;
363 #ifdef CGEN_PRINT_NORMAL
364 CGEN_PRINT_NORMAL (cd, info, value, attrs, pc, length);
365 #endif
367 /* Print the operand as directed by the attributes. */
368 if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
369 ; /* nothing to do */
370 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
371 (*info->fprintf_func) (info->stream, "%ld", value);
372 else
373 (*info->fprintf_func) (info->stream, "0x%lx", value);
376 /* Default address handler. */
378 static void
379 print_address (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
380 void *dis_info,
381 bfd_vma value,
382 unsigned int attrs,
383 bfd_vma pc ATTRIBUTE_UNUSED,
384 int length ATTRIBUTE_UNUSED)
386 disassemble_info *info = (disassemble_info *) dis_info;
388 #ifdef CGEN_PRINT_ADDRESS
389 CGEN_PRINT_ADDRESS (cd, info, value, attrs, pc, length);
390 #endif
392 /* Print the operand as directed by the attributes. */
393 if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
394 ; /* nothing to do */
395 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR))
396 (*info->print_address_func) (value, info);
397 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR))
398 (*info->print_address_func) (value, info);
399 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
400 (*info->fprintf_func) (info->stream, "%ld", (long) value);
401 else
402 (*info->fprintf_func) (info->stream, "0x%lx", (long) value);
405 /* Keyword print handler. */
407 static void
408 print_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
409 void *dis_info,
410 CGEN_KEYWORD *keyword_table,
411 long value,
412 unsigned int attrs ATTRIBUTE_UNUSED)
414 disassemble_info *info = (disassemble_info *) dis_info;
415 const CGEN_KEYWORD_ENTRY *ke;
417 ke = cgen_keyword_lookup_value (keyword_table, value);
418 if (ke != NULL)
419 (*info->fprintf_func) (info->stream, "%s", ke->name);
420 else
421 (*info->fprintf_func) (info->stream, "???");
424 /* Default insn printer.
426 DIS_INFO is defined as `void *' so the disassembler needn't know anything
427 about disassemble_info. */
429 static void
430 print_insn_normal (CGEN_CPU_DESC cd,
431 void *dis_info,
432 const CGEN_INSN *insn,
433 CGEN_FIELDS *fields,
434 bfd_vma pc,
435 int length)
437 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
438 disassemble_info *info = (disassemble_info *) dis_info;
439 const CGEN_SYNTAX_CHAR_TYPE *syn;
441 CGEN_INIT_PRINT (cd);
443 for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
445 if (CGEN_SYNTAX_MNEMONIC_P (*syn))
447 (*info->fprintf_func) (info->stream, "%s", CGEN_INSN_MNEMONIC (insn));
448 continue;
450 if (CGEN_SYNTAX_CHAR_P (*syn))
452 (*info->fprintf_func) (info->stream, "%c", CGEN_SYNTAX_CHAR (*syn));
453 continue;
456 /* We have an operand. */
457 ip2k_cgen_print_operand (cd, CGEN_SYNTAX_FIELD (*syn), info,
458 fields, CGEN_INSN_ATTRS (insn), pc, length);
462 /* Subroutine of print_insn. Reads an insn into the given buffers and updates
463 the extract info.
464 Returns 0 if all is well, non-zero otherwise. */
466 static int
467 read_insn (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
468 bfd_vma pc,
469 disassemble_info *info,
470 char *buf,
471 int buflen,
472 CGEN_EXTRACT_INFO *ex_info,
473 unsigned long *insn_value)
475 int status = (*info->read_memory_func) (pc, buf, buflen, info);
476 if (status != 0)
478 (*info->memory_error_func) (status, pc, info);
479 return -1;
482 ex_info->dis_info = info;
483 ex_info->valid = (1 << buflen) - 1;
484 ex_info->insn_bytes = buf;
486 *insn_value = bfd_get_bits (buf, buflen * 8, info->endian == BFD_ENDIAN_BIG);
487 return 0;
490 /* Utility to print an insn.
491 BUF is the base part of the insn, target byte order, BUFLEN bytes long.
492 The result is the size of the insn in bytes or zero for an unknown insn
493 or -1 if an error occurs fetching data (memory_error_func will have
494 been called). */
496 static int
497 print_insn (CGEN_CPU_DESC cd,
498 bfd_vma pc,
499 disassemble_info *info,
500 char *buf,
501 unsigned int buflen)
503 CGEN_INSN_INT insn_value;
504 const CGEN_INSN_LIST *insn_list;
505 CGEN_EXTRACT_INFO ex_info;
506 int basesize;
508 /* Extract base part of instruction, just in case CGEN_DIS_* uses it. */
509 basesize = cd->base_insn_bitsize < buflen * 8 ?
510 cd->base_insn_bitsize : buflen * 8;
511 insn_value = cgen_get_insn_value (cd, buf, basesize);
514 /* Fill in ex_info fields like read_insn would. Don't actually call
515 read_insn, since the incoming buffer is already read (and possibly
516 modified a la m32r). */
517 ex_info.valid = (1 << buflen) - 1;
518 ex_info.dis_info = info;
519 ex_info.insn_bytes = buf;
521 /* The instructions are stored in hash lists.
522 Pick the first one and keep trying until we find the right one. */
524 insn_list = CGEN_DIS_LOOKUP_INSN (cd, buf, insn_value);
525 while (insn_list != NULL)
527 const CGEN_INSN *insn = insn_list->insn;
528 CGEN_FIELDS fields;
529 int length;
530 unsigned long insn_value_cropped;
532 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
533 /* Not needed as insn shouldn't be in hash lists if not supported. */
534 /* Supported by this cpu? */
535 if (! ip2k_cgen_insn_supported (cd, insn))
537 insn_list = CGEN_DIS_NEXT_INSN (insn_list);
538 continue;
540 #endif
542 /* Basic bit mask must be correct. */
543 /* ??? May wish to allow target to defer this check until the extract
544 handler. */
546 /* Base size may exceed this instruction's size. Extract the
547 relevant part from the buffer. */
548 if ((unsigned) (CGEN_INSN_BITSIZE (insn) / 8) < buflen &&
549 (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
550 insn_value_cropped = bfd_get_bits (buf, CGEN_INSN_BITSIZE (insn),
551 info->endian == BFD_ENDIAN_BIG);
552 else
553 insn_value_cropped = insn_value;
555 if ((insn_value_cropped & CGEN_INSN_BASE_MASK (insn))
556 == CGEN_INSN_BASE_VALUE (insn))
558 /* Printing is handled in two passes. The first pass parses the
559 machine insn and extracts the fields. The second pass prints
560 them. */
562 /* Make sure the entire insn is loaded into insn_value, if it
563 can fit. */
564 if (((unsigned) CGEN_INSN_BITSIZE (insn) > cd->base_insn_bitsize) &&
565 (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
567 unsigned long full_insn_value;
568 int rc = read_insn (cd, pc, info, buf,
569 CGEN_INSN_BITSIZE (insn) / 8,
570 & ex_info, & full_insn_value);
571 if (rc != 0)
572 return rc;
573 length = CGEN_EXTRACT_FN (cd, insn)
574 (cd, insn, &ex_info, full_insn_value, &fields, pc);
576 else
577 length = CGEN_EXTRACT_FN (cd, insn)
578 (cd, insn, &ex_info, insn_value_cropped, &fields, pc);
580 /* length < 0 -> error */
581 if (length < 0)
582 return length;
583 if (length > 0)
585 CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length);
586 /* length is in bits, result is in bytes */
587 return length / 8;
591 insn_list = CGEN_DIS_NEXT_INSN (insn_list);
594 return 0;
597 /* Default value for CGEN_PRINT_INSN.
598 The result is the size of the insn in bytes or zero for an unknown insn
599 or -1 if an error occured fetching bytes. */
601 #ifndef CGEN_PRINT_INSN
602 #define CGEN_PRINT_INSN default_print_insn
603 #endif
605 static int
606 default_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info)
608 char buf[CGEN_MAX_INSN_SIZE];
609 int buflen;
610 int status;
612 /* Attempt to read the base part of the insn. */
613 buflen = cd->base_insn_bitsize / 8;
614 status = (*info->read_memory_func) (pc, buf, buflen, info);
616 /* Try again with the minimum part, if min < base. */
617 if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize))
619 buflen = cd->min_insn_bitsize / 8;
620 status = (*info->read_memory_func) (pc, buf, buflen, info);
623 if (status != 0)
625 (*info->memory_error_func) (status, pc, info);
626 return -1;
629 return print_insn (cd, pc, info, buf, buflen);
632 /* Main entry point.
633 Print one instruction from PC on INFO->STREAM.
634 Return the size of the instruction (in bytes). */
636 typedef struct cpu_desc_list {
637 struct cpu_desc_list *next;
638 int isa;
639 int mach;
640 int endian;
641 CGEN_CPU_DESC cd;
642 } cpu_desc_list;
645 print_insn_ip2k (bfd_vma pc, disassemble_info *info)
647 static cpu_desc_list *cd_list = 0;
648 cpu_desc_list *cl = 0;
649 static CGEN_CPU_DESC cd = 0;
650 static int prev_isa;
651 static int prev_mach;
652 static int prev_endian;
653 int length;
654 int isa,mach;
655 int endian = (info->endian == BFD_ENDIAN_BIG
656 ? CGEN_ENDIAN_BIG
657 : CGEN_ENDIAN_LITTLE);
658 enum bfd_architecture arch;
660 /* ??? gdb will set mach but leave the architecture as "unknown" */
661 #ifndef CGEN_BFD_ARCH
662 #define CGEN_BFD_ARCH bfd_arch_ip2k
663 #endif
664 arch = info->arch;
665 if (arch == bfd_arch_unknown)
666 arch = CGEN_BFD_ARCH;
668 /* There's no standard way to compute the machine or isa number
669 so we leave it to the target. */
670 #ifdef CGEN_COMPUTE_MACH
671 mach = CGEN_COMPUTE_MACH (info);
672 #else
673 mach = info->mach;
674 #endif
676 #ifdef CGEN_COMPUTE_ISA
677 isa = CGEN_COMPUTE_ISA (info);
678 #else
679 isa = info->insn_sets;
680 #endif
682 /* If we've switched cpu's, try to find a handle we've used before */
683 if (cd
684 && (isa != prev_isa
685 || mach != prev_mach
686 || endian != prev_endian))
688 cd = 0;
689 for (cl = cd_list; cl; cl = cl->next)
691 if (cl->isa == isa &&
692 cl->mach == mach &&
693 cl->endian == endian)
695 cd = cl->cd;
696 break;
701 /* If we haven't initialized yet, initialize the opcode table. */
702 if (! cd)
704 const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach);
705 const char *mach_name;
707 if (!arch_type)
708 abort ();
709 mach_name = arch_type->printable_name;
711 prev_isa = isa;
712 prev_mach = mach;
713 prev_endian = endian;
714 cd = ip2k_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa,
715 CGEN_CPU_OPEN_BFDMACH, mach_name,
716 CGEN_CPU_OPEN_ENDIAN, prev_endian,
717 CGEN_CPU_OPEN_END);
718 if (!cd)
719 abort ();
721 /* save this away for future reference */
722 cl = xmalloc (sizeof (struct cpu_desc_list));
723 cl->cd = cd;
724 cl->isa = isa;
725 cl->mach = mach;
726 cl->endian = endian;
727 cl->next = cd_list;
728 cd_list = cl;
730 ip2k_cgen_init_dis (cd);
733 /* We try to have as much common code as possible.
734 But at this point some targets need to take over. */
735 /* ??? Some targets may need a hook elsewhere. Try to avoid this,
736 but if not possible try to move this hook elsewhere rather than
737 have two hooks. */
738 length = CGEN_PRINT_INSN (cd, pc, info);
739 if (length > 0)
740 return length;
741 if (length < 0)
742 return -1;
744 (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
745 return cd->default_insn_bitsize / 8;