Update the address and phone number of the FSF
[external/binutils.git] / opcodes / maxq-dis.c
1 /* Instruction printing code for the MAXQ
2
3    Copyright 2004, 2005 Free Software Foundation, Inc.
4
5    Written by Vineet Sharma(vineets@noida.hcltech.com) Inderpreet
6    S.(inderpreetb@noida.hcltech.com)
7
8    This file is part of GDB.
9
10    This program is free software; you can redistribute it and/or modify it
11    under the terms of the GNU General Public License as published by the Free 
12    Software Foundation; either version 2 of the License, or (at your option)
13    any later version.
14
15    This program is distributed in the hope that it will be useful, but
16    WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
17    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
18    for more details.
19
20    You should have received a copy of the GNU General Public License along
21    with this program; if not, write to the Free Software Foundation, Inc., 
22    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
23
24 #include "sysdep.h"
25 #include "dis-asm.h"
26 #include "opcode/maxq.h"
27
28 struct _group_info
29 {
30   unsigned char group_no;
31   unsigned char sub_opcode;
32   unsigned char src;
33   unsigned char dst;
34   unsigned char fbit;
35   unsigned char bit_no;
36   unsigned char flag;
37
38 };
39
40 typedef struct _group_info group_info;
41
42 #define SRC     0x01
43 #define DST     0x02
44 #define FORMAT  0x04
45 #define BIT_NO  0x08
46 #define SUB_OP  0x10
47
48 #define MASK_LOW_BYTE 0x0f
49 #define MASK_HIGH_BYTE 0xf0
50
51 /* Flags for retrieving the bits from the op-code.  */
52 #define _DECODE_LOWNIB_LOWBYTE  0x000f
53 #define _DECODE_HIGHNIB_LOWBYTE 0x00f0
54 #define _DECODE_LOWNIB_HIGHBYTE 0x0f00
55 #define _DECODE_HIGHNIB_HIGHBYTE 0xf000
56 #define _DECODE_HIGHBYTE 0xff00
57 #define _DECODE_LOWBYTE  0x00ff
58 #define _DECODE_4TO6_HIGHBYTE 0x7000
59 #define _DECODE_4TO6_LOWBYTE 0x0070
60 #define _DECODE_0TO6_HIGHBYTE 0x7f00
61 #define _DECODE_0TO2_HIGHBYTE 0x0700
62 #define _DECODE_GET_F_HIGHBYTE 0x8000
63 #define _DECODE_BIT7_HIGHBYTE 0x8000
64 #define _DECODE_BIT7_LOWBYTE 0x0080
65 #define _DECODE_GET_CARRY 0x10000
66 #define _DECODE_BIT0_LOWBYTE 0x1
67 #define _DECODE_BIT6AND7_HIGHBYTE 0xc000
68
69 /* Module and Register Indexed of System Registers.  */
70 #define _CURR_ACC_MODINDEX 0xa
71 #define _CURR_ACC_REGINDEX 0x0
72 #define _PSF_REG_MODINDEX  0x8
73 #define _PSF_REG_REGINDEX  0x4
74 #define _PFX_REG_MODINDEX  0xb
75 #define _PFX0_REG_REGINDEX 0x0
76 #define _PFX2_REG_REGINDEX 0x2
77 #define _DP_REG_MODINDEX   0xf
78 #define _DP0_REG_REGINDEX  0x3
79 #define _DP1_REG_REGINDEX  0x7
80 #define _IP_REG_MODINDEX   0xc
81 #define _IP_REG_REGINDEX   0x0
82 #define _IIR_REG_MODINDEX  0x8
83 #define _IIR_REG_REGINDEX  0xb
84 #define _SP_REG_MODINDEX   0xd
85 #define _SP_REG_REGINDEX   0x1
86 #define _IC_REG_MODINDEX   0x8
87 #define _IC_REG_REGINDEX   0x5
88 #define _LC_REG_MODINDEX   0xe
89 #define _LC0_REG_REGINDEX  0x0
90 #define _LC1_REG_REGINDEX  0x1
91 #define _LC2_REG_REGINDEX  0x2
92 #define _LC3_REG_REGINDEX  0x3
93
94 /* Flags for finding the bits in PSF Register.  */
95 #define SIM_ALU_DECODE_CARRY_BIT_POS  0x2
96 #define SIM_ALU_DECODE_SIGN_BIT_POS   0x40
97 #define SIM_ALU_DECODE_ZERO_BIT_POS   0x80
98 #define SIM_ALU_DECODE_EQUAL_BIT_POS  0x1
99 #define SIM_ALU_DECODE_IGE_BIT_POS    0x1
100
101 /* Number Of Op-code Groups.  */
102 unsigned char const SIM_ALU_DECODE_OPCODE_GROUPS = 11;
103
104 /* Op-code Groups.  */
105 unsigned char const SIM_ALU_DECODE_LOGICAL_XCHG_OP_GROUP = 1;
106
107 /* Group1: AND/OR/XOR/ADD/SUB Operations: fxxx 1010 ssss ssss.  */
108 unsigned char const SIM_ALU_DECODE_AND_OR_ADD_SUB_OP_GROUP = 2;
109
110 /* Group2: Logical Operations: 1000 1010 xxxx 1010.  */
111 unsigned char const SIM_ALU_DECODE_BIT_OP_GROUP = 3;
112
113 /* XCHG/Bit Operations: 1xxx 1010 xxxx 1010.  */
114 unsigned char const SIM_ALU_DECODE_SET_DEST_BIT_GROUP = 4;
115
116 /* Move value in bit of destination register: 1ddd dddd xbbb 0111.  */
117 unsigned char const SIM_ALU_DECODE_JUMP_OP_GROUP = 5;
118
119 #define JUMP_CHECK(insn)   \
120    (   ((insn & _DECODE_4TO6_HIGHBYTE) == 0x0000) \
121     || ((insn & _DECODE_4TO6_HIGHBYTE) == 0x2000) \
122     || ((insn & _DECODE_4TO6_HIGHBYTE) == 0x6000) \
123     || ((insn & _DECODE_4TO6_HIGHBYTE) == 0x1000) \
124     || ((insn & _DECODE_4TO6_HIGHBYTE) == 0x5000) \
125     || ((insn & _DECODE_4TO6_HIGHBYTE) == 0x3000) \
126     || ((insn & _DECODE_4TO6_HIGHBYTE) == 0x7000) \
127     || ((insn & _DECODE_4TO6_HIGHBYTE) == 0x4000) )
128
129 /* JUMP operations: fxxx 1100 ssss ssss */
130 unsigned char const SIM_ALU_DECODE_RET_OP_GROUP = 6;
131
132 /* RET Operations: 1xxx 1100 0000 1101 */
133 unsigned char const SIM_ALU_DECODE_MOVE_SRC_DST_GROUP = 7;
134
135 /* Move src into dest register: fddd dddd ssss ssss */
136 unsigned char const SIM_ALU_DECODE_SET_SRC_BIT_GROUP = 8;
137
138 /* Move value in bit of source register: fbbb 0111 ssss ssss */
139 unsigned char const SIM_ALU_DECODE_DJNZ_CALL_PUSH_OP_GROUP = 9;
140
141 /* PUSH, DJNZ and CALL operations: fxxx 1101 ssss ssss */
142 unsigned char const SIM_ALU_DECODE_POP_OP_GROUP = 10;
143
144 /* POP operation: 1ddd dddd 0000 1101 */
145 unsigned char const SIM_ALU_DECODE_CMP_SRC_OP_GROUP = 11;
146
147 /* GLOBAL */
148 char unres_reg_name[20];
149
150 static char *
151 get_reg_name (unsigned char reg_code, type1 arg_pos)
152 {
153   unsigned char module;
154   unsigned char index;
155   int ix = 0;
156   reg_entry const *reg_x;
157   mem_access_syntax const *syntax;
158   mem_access *mem_acc;
159
160   module = 0;
161   index = 0;
162   module = (reg_code & MASK_LOW_BYTE);
163   index = (reg_code & MASK_HIGH_BYTE);
164   index = index >> 4;
165
166   /* Search the system register table.  */
167   for (reg_x = &system_reg_table[0]; reg_x->reg_name != NULL; ++reg_x)
168     if ((reg_x->Mod_name == module) && (reg_x->Mod_index == index))
169       return reg_x->reg_name;
170
171   /* Serch pheripheral table.  */
172   for (ix = 0; ix < num_of_reg; ix++)
173     {
174       reg_x = &new_reg_table[ix];
175
176       if ((reg_x->Mod_name == module) && (reg_x->Mod_index == index))
177         return reg_x->reg_name;
178     }
179
180   for (mem_acc = &mem_table[0]; mem_acc->name != NULL || !mem_acc; ++mem_acc)
181     {
182       if (reg_code == mem_acc->opcode)
183         {
184           for (syntax = mem_access_syntax_table;
185                mem_access_syntax_table != NULL || mem_access_syntax_table->name;
186                ++syntax)
187             if (!strcmp (mem_acc->name, syntax->name))
188               {
189                 if ((arg_pos == syntax->type) || (syntax->type == BOTH))
190                   return mem_acc->name;
191
192                 break;
193               }
194         }
195     }
196
197   memset (unres_reg_name, 0, 20);
198   sprintf (unres_reg_name, "%01x%01xh", index, module);
199
200   return unres_reg_name;
201 }
202
203 static bfd_boolean
204 check_move (unsigned char insn0, unsigned char insn8)
205 {
206   bfd_boolean first = FALSE;
207   bfd_boolean second = FALSE;
208   char *first_reg;
209   char *second_reg;
210   reg_entry const *reg_x;
211   const unsigned char module1 = insn0 & MASK_LOW_BYTE;
212   const unsigned char index1 = ((insn0 & 0x70) >> 4);
213   const unsigned char module2 = insn8 & MASK_LOW_BYTE;
214   const unsigned char index2 = ((insn8 & MASK_HIGH_BYTE) >> 4);
215
216   /* DST */
217   if (((insn0 & MASK_LOW_BYTE) == MASK_LOW_BYTE)
218       && ((index1 == 0) || (index1 == 1) || (index1 == 2) || (index1 == 5)
219           || (index1 == 4) || (index1 == 6)))
220     first = TRUE;
221
222   else if (((insn0 & MASK_LOW_BYTE) == 0x0D) && (index1 == 0))
223     first = TRUE;
224
225   else if ((module1 == 0x0E)
226            && ((index1 == 0) || (index1 == 1) || (index1 == 2)))
227     first = TRUE;
228
229   else
230     {
231       for (reg_x = &system_reg_table[0]; reg_x->reg_name != NULL && reg_x;
232            ++reg_x)
233         {
234           if ((reg_x->Mod_name == module1) && (reg_x->Mod_index == index1)
235               && ((reg_x->rtype == Reg_16W) || (reg_x->rtype == Reg_8W)))
236             {
237               /* IP not allowed.  */
238               if ((reg_x->Mod_name == 0x0C) && (reg_x->Mod_index == 0x00))
239                 continue;
240
241               /* A[AP] not allowed.  */
242               if ((reg_x->Mod_name == 0x0A) && (reg_x->Mod_index == 0x01))
243                 continue;
244               first_reg = reg_x->reg_name;
245               first = TRUE;
246               break;
247             }
248         }
249     }
250
251   if (!first)
252     /* No need to check further.  */
253     return FALSE;
254
255   if (insn0 & 0x80)
256     {
257       /* SRC */
258       if (((insn8 & MASK_LOW_BYTE) == MASK_LOW_BYTE)
259           && ((index2 == 0) || (index2 == 1) || (index2 == 2) || (index2 == 4)
260               || (index2 == 5) || (index2 == 6)))
261         second = TRUE;
262
263       else if (((insn8 & MASK_LOW_BYTE) == 0x0D) && (index2 == 0))
264         second = TRUE;
265
266       else if ((module2 == 0x0E)
267                && ((index2 == 0) || (index2 == 1) || (index2 == 2)))
268         second = TRUE;
269
270       else
271         {
272           for (reg_x = &system_reg_table[0];
273                reg_x->reg_name != NULL && reg_x;
274                ++reg_x)
275             {
276               if ((reg_x->Mod_name == (insn8 & MASK_LOW_BYTE))
277                   && (reg_x->Mod_index == (((insn8 & 0xf0) >> 4))))
278                 {
279                   second = TRUE;
280                   second_reg = reg_x->reg_name;
281                   break;
282                 }
283             }
284         }       
285
286       if (second)
287         {
288           if ((module1 == 0x0A && index1 == 0x0)
289               && (module2 == 0x0A && index2 == 0x01))
290             return FALSE;
291
292           return TRUE;
293         }
294
295       return FALSE;
296     }
297
298   return first;
299 }
300
301 static void
302 maxq_print_arg (MAX_ARG_TYPE              arg,
303                 struct disassemble_info * info,
304                 group_info                grp)
305 {
306   switch (arg)
307     {
308     case FLAG_C:
309       info->fprintf_func (info->stream, "C");
310       break;
311     case FLAG_NC:
312       info->fprintf_func (info->stream, "NC");
313       break;
314
315     case FLAG_Z:
316       info->fprintf_func (info->stream, "Z");
317       break;
318
319     case FLAG_NZ:
320       info->fprintf_func (info->stream, "NZ");
321       break;
322
323     case FLAG_S:
324       info->fprintf_func (info->stream, "S");
325       break;
326
327     case FLAG_E:
328       info->fprintf_func (info->stream, "E");
329       break;
330
331     case FLAG_NE:
332       info->fprintf_func (info->stream, "NE");
333       break;
334
335     case ACC_BIT:
336       info->fprintf_func (info->stream, "Acc");
337       if ((grp.flag & BIT_NO) == BIT_NO)
338         info->fprintf_func (info->stream, ".%d", grp.bit_no);
339       break;
340
341     case A_BIT_0:
342       info->fprintf_func (info->stream, "#0");
343       break;
344     case A_BIT_1:
345       info->fprintf_func (info->stream, "#1");
346       break;
347
348     default:
349       break;
350     }
351 }
352
353 static unsigned char
354 get_group (const unsigned int insn)
355 {
356   if (check_move ((insn >> 8), (insn & _DECODE_LOWBYTE)))
357     return 8;
358
359   if ((insn & _DECODE_LOWNIB_HIGHBYTE) == 0x0A00)
360     {
361       /* && condition with sec part added on 26 May for resolving 2 & 3 grp
362          conflict.  */
363       if (((insn & _DECODE_LOWNIB_LOWBYTE) == 0x000A)
364           && ((insn & _DECODE_GET_F_HIGHBYTE) == 0x8000))
365         {
366           if ((insn & _DECODE_HIGHNIB_HIGHBYTE) == 0x8000)
367             return 2;
368           else
369             return 3;
370         }
371
372       return 1;
373     }
374   else if ((insn & _DECODE_LOWNIB_HIGHBYTE) == 0x0C00)
375     {
376       if (((insn & _DECODE_LOWBYTE) == 0x000D) && JUMP_CHECK (insn)
377           && ((insn & _DECODE_GET_F_HIGHBYTE) == 0x8000))
378         return 6;
379       else if ((insn & _DECODE_LOWBYTE) == 0x008D)
380         return 7;
381
382       return 5;
383     }
384   else if (((insn & _DECODE_LOWNIB_HIGHBYTE) == 0x0D00)
385            && (((insn & _DECODE_4TO6_HIGHBYTE) == 0x3000)
386                || ((insn & _DECODE_4TO6_HIGHBYTE) == 0x4000)
387                || ((insn & _DECODE_4TO6_HIGHBYTE) == 0x5000)
388                || ((insn & _DECODE_4TO6_HIGHBYTE) == 0x0000)))
389     return 10;
390
391   else if ((insn & _DECODE_LOWBYTE) == 0x000D)
392     return 11;
393
394   else if ((insn & _DECODE_LOWBYTE) == 0x008D)
395     return 12;
396
397   else if ((insn & _DECODE_0TO6_HIGHBYTE) == 0x7800)
398     return 13;
399
400   else if ((insn & _DECODE_LOWNIB_HIGHBYTE) == 0x0700)
401     return 9;
402
403   else if (((insn & _DECODE_LOWNIB_LOWBYTE) == 0x0007)
404            && ((insn & _DECODE_GET_F_HIGHBYTE) == 0x8000))
405     return 4;
406
407   return 8;
408 }
409
410 static void
411 get_insn_opcode (const unsigned int insn, group_info *i)
412 {
413   static unsigned char pfx_flag = 0;
414   static unsigned char count_for_pfx = 0;
415
416   i->flag ^= i->flag;
417   i->bit_no ^= i->bit_no;
418   i->dst ^= i->dst;
419   i->fbit ^= i->fbit;
420   i->group_no ^= i->group_no;
421   i->src ^= i->src;
422   i->sub_opcode ^= i->sub_opcode;
423
424   if (count_for_pfx > 0)
425     count_for_pfx++;
426
427   if (((insn >> 8) == 0x0b) || ((insn >> 8) == 0x2b))
428     {
429       pfx_flag = 1;
430       count_for_pfx = 1;
431     }
432
433   i->group_no = get_group (insn);
434
435   if (pfx_flag && (i->group_no == 0x0D) && (count_for_pfx == 2)
436       && ((insn & _DECODE_0TO6_HIGHBYTE) == 0x7800))
437     {
438       i->group_no = 0x08;
439       count_for_pfx = 0;
440       pfx_flag ^= pfx_flag;
441     }
442
443   switch (i->group_no)
444     {
445     case 1:
446       i->sub_opcode = ((insn & _DECODE_4TO6_HIGHBYTE) >> 12);
447       i->flag |= SUB_OP;
448       i->src = ((insn & _DECODE_LOWBYTE));
449       i->flag |= SRC;
450       i->fbit = ((insn & _DECODE_GET_F_HIGHBYTE) >> 15);
451       i->flag |= FORMAT;
452       break;
453
454     case 2:
455       i->sub_opcode = ((insn & _DECODE_HIGHNIB_LOWBYTE) >> 4);
456       i->flag |= SUB_OP;
457       break;
458
459     case 3:
460       i->sub_opcode = ((insn & _DECODE_HIGHNIB_HIGHBYTE) >> 12);
461       i->flag |= SUB_OP;
462       i->bit_no = ((insn & _DECODE_HIGHNIB_LOWBYTE) >> 4);
463       i->flag |= BIT_NO;
464       break;
465
466     case 4:
467       i->sub_opcode = ((insn & _DECODE_BIT7_LOWBYTE) >> 7);
468       i->flag |= SUB_OP;
469       i->dst = ((insn & _DECODE_0TO6_HIGHBYTE) >> 8);
470       i->flag |= DST;
471       i->bit_no = ((insn & _DECODE_4TO6_LOWBYTE) >> 4);
472       i->flag |= BIT_NO;
473       break;
474
475     case 5:
476       i->sub_opcode = ((insn & _DECODE_4TO6_HIGHBYTE) >> 12);
477       i->flag |= SUB_OP;
478       i->src = ((insn & _DECODE_LOWBYTE));
479       i->flag |= SRC;
480       i->fbit = ((insn & _DECODE_GET_F_HIGHBYTE) >> 15);
481       i->flag |= FORMAT;
482       break;
483
484     case 6:
485       i->sub_opcode = ((insn & _DECODE_HIGHNIB_HIGHBYTE) >> 12);
486       i->flag |= SUB_OP;
487       break;
488
489     case 7:
490       i->sub_opcode = ((insn & _DECODE_HIGHNIB_HIGHBYTE) >> 12);
491       i->flag |= SUB_OP;
492       break;
493
494     case 8:
495       i->dst = ((insn & _DECODE_0TO6_HIGHBYTE) >> 8);
496       i->flag |= DST;
497       i->src = ((insn & _DECODE_LOWBYTE));
498       i->flag |= SRC;
499       i->fbit = ((insn & _DECODE_GET_F_HIGHBYTE) >> 15);
500       i->flag |= FORMAT;
501       break;
502
503     case 9:
504       i->sub_opcode = ((insn & _DECODE_0TO2_HIGHBYTE) >> 8);
505       i->flag |= SUB_OP;
506       i->bit_no = ((insn & _DECODE_4TO6_HIGHBYTE) >> 12);
507       i->flag |= BIT_NO;
508       i->fbit = ((insn & _DECODE_GET_F_HIGHBYTE) >> 15);
509       i->flag |= FORMAT;
510       i->src = ((insn & _DECODE_LOWBYTE));
511       i->flag |= SRC;
512       break;
513
514     case 10:
515       i->sub_opcode = ((insn & _DECODE_4TO6_HIGHBYTE) >> 12);
516       i->flag |= SUB_OP;
517       i->src = ((insn & _DECODE_LOWBYTE));
518       i->flag |= SRC;
519       i->fbit = ((insn & _DECODE_GET_F_HIGHBYTE) >> 15);
520       i->flag |= FORMAT;
521       break;
522
523     case 11:
524       i->dst = ((insn & _DECODE_0TO6_HIGHBYTE) >> 8);
525       i->flag |= DST;
526       break;
527
528     case 12:
529       i->dst = ((insn & _DECODE_0TO6_HIGHBYTE) >> 8);
530       i->flag |= DST;
531       break;
532
533     case 13:
534       i->sub_opcode = ((insn & _DECODE_4TO6_HIGHBYTE) >> 12);
535       i->flag |= SUB_OP;
536       i->src = ((insn & _DECODE_LOWBYTE));
537       i->flag |= SRC;
538       i->fbit = ((insn & _DECODE_GET_F_HIGHBYTE) >> 15);
539       i->flag |= FORMAT;
540       break;
541
542     }
543   return;
544 }
545
546
547 /* Print one instruction from MEMADDR on INFO->STREAM. Return the size of the 
548    instruction (always 2 on MAXQ20).  */
549
550 static int
551 print_insn (bfd_vma memaddr, struct disassemble_info *info,
552             enum bfd_endian endianess)
553 {
554   /* The raw instruction.  */
555   unsigned char insn[2], insn0, insn8, derived_code;
556   unsigned int format;
557   unsigned int actual_operands;
558   unsigned int i;
559   /* The group_info collected/decoded.  */
560   group_info grp;
561   MAXQ20_OPCODE_INFO const *opcode;
562   int status;
563
564   format = 0;
565
566   status = info->read_memory_func (memaddr, (bfd_byte *) & insn[0], 2, info);
567
568   if (status != 0)
569     {
570       info->memory_error_func (status, memaddr, info);
571       return -1;
572     }
573
574   insn8 = insn[1];
575   insn0 = insn[0];
576
577   /* FIXME: Endianness always little.  */
578   if (endianess == BFD_ENDIAN_BIG)
579     get_insn_opcode (((insn[0] << 8) | (insn[1])), &grp);
580   else
581     get_insn_opcode (((insn[1] << 8) | (insn[0])), &grp);
582
583   derived_code = ((grp.group_no << 4) | grp.sub_opcode);
584
585   if (insn[0] == 0 && insn[1] == 0)
586     {
587       info->fprintf_func (info->stream, "00 00");
588       return 2;
589     }
590
591   /* The opcode is always in insn0.  */
592   for (opcode = &op_table[0]; opcode->name != NULL; ++opcode)
593     {
594       if (opcode->instr_id == derived_code)
595         {
596           if (opcode->instr_id == 0x3D)
597             {
598               if ((grp.bit_no == 0) && (opcode->arg[1] != A_BIT_0))
599                 continue;
600               if ((grp.bit_no == 1) && (opcode->arg[1] != A_BIT_1))
601                 continue;
602               if ((grp.bit_no == 3) && (opcode->arg[0] != 0))
603                 continue;
604             }
605
606           info->fprintf_func (info->stream, "%s ", opcode->name);
607
608           actual_operands = 0;
609
610           if ((grp.flag & SRC) == SRC)
611             actual_operands++;
612
613           if ((grp.flag & DST) == DST)
614             actual_operands++;
615
616           /* If Implict FLAG in the Instruction.  */
617           if ((opcode->op_number > actual_operands)
618               && !((grp.flag & SRC) == SRC) && !((grp.flag & DST) == DST))
619             {
620               for (i = 0; i < opcode->op_number; i++)
621                 {
622                   if (i == 1 && (opcode->arg[1] != NO_ARG))
623                     info->fprintf_func (info->stream, ",");
624                   maxq_print_arg (opcode->arg[i], info, grp);
625                 }
626             }
627
628           /* DST is ABSENT in the grp.  */
629           if ((opcode->op_number > actual_operands)
630               && ((grp.flag & SRC) == SRC))
631             {
632               maxq_print_arg (opcode->arg[0], info, grp);
633               info->fprintf_func (info->stream, " ");
634
635               if (opcode->instr_id == 0xA4)
636                 info->fprintf_func (info->stream, "LC[0]");
637
638               if (opcode->instr_id == 0xA5)
639                 info->fprintf_func (info->stream, "LC[1]");
640
641               if ((grp.flag & SRC) == SRC)
642                 info->fprintf_func (info->stream, ",");
643             }
644
645           if ((grp.flag & DST) == DST)
646             {
647               if ((grp.flag & BIT_NO) == BIT_NO)
648                 {
649                   info->fprintf_func (info->stream, " %s.%d",
650                                       get_reg_name (grp.dst,
651                                                     (type1) 0 /*DST*/),
652                                       grp.bit_no);
653                 }
654               else
655                 info->fprintf_func (info->stream, " %s",
656                                     get_reg_name (grp.dst, (type1) 0));
657             }
658
659           /* SRC is ABSENT in the grp.  */
660           if ((opcode->op_number > actual_operands)
661               && ((grp.flag & DST) == DST))
662             {
663               info->fprintf_func (info->stream, ",");
664               maxq_print_arg (opcode->arg[1], info, grp);
665               info->fprintf_func (info->stream, " ");
666             }
667
668           if ((grp.flag & SRC) == SRC)
669             {
670               if ((grp.flag & DST) == DST)
671                 info->fprintf_func (info->stream, ",");
672
673               if ((grp.flag & BIT_NO) == BIT_NO)
674                 {
675                   format = opcode->format;
676
677                   if ((grp.flag & FORMAT) == FORMAT)
678                     format = grp.fbit;
679                   if (format == 1)
680                     info->fprintf_func (info->stream, " %s.%d",
681                                         get_reg_name (grp.src,
682                                                       (type1) 1 /*SRC*/),
683                                         grp.bit_no);
684                   if (format == 0)
685                     info->fprintf_func (info->stream, " #%02xh.%d",
686                                         grp.src, grp.bit_no);
687                 }
688               else
689                 {
690                   format = opcode->format;
691
692                   if ((grp.flag & FORMAT) == FORMAT)
693                     format = grp.fbit;
694                   if (format == 1)
695                     info->fprintf_func (info->stream, " %s",
696                                         get_reg_name (grp.src,
697                                                       (type1) 1 /*SRC*/));
698                   if (format == 0)
699                     info->fprintf_func (info->stream, " #%02xh",
700                                         (grp.src));
701                 }
702             }
703
704           return 2;
705         }
706     }
707
708   info->fprintf_func (info->stream, "Unable to Decode :  %02x %02x",
709                       insn[0], insn[1]);
710   return 2;                     
711 }
712
713 int
714 print_insn_maxq_little (bfd_vma memaddr, struct disassemble_info *info)
715 {
716   return print_insn (memaddr, info, BFD_ENDIAN_LITTLE);
717 }