/* Instruction printing code for the ARC.
- Copyright (C) 1994 Free Software Foundation, Inc.
+ Copyright (C) 1994, 1995 Free Software Foundation, Inc.
Contributed by Doug Evans (dje@cygnus.com).
This program is free software; you can redistribute it and/or modify
#include "dis-asm.h"
#include "opcode/arc.h"
+#include "libelf.h"
+#include "elf/arc.h"
+
+static int print_insn_arc_base_little PARAMS ((bfd_vma, disassemble_info *));
+static int print_insn_arc_host_little PARAMS ((bfd_vma, disassemble_info *));
+static int print_insn_arc_graphics_little PARAMS ((bfd_vma, disassemble_info *));
+static int print_insn_arc_audio_little PARAMS ((bfd_vma, disassemble_info *));
+static int print_insn_arc_base_big PARAMS ((bfd_vma, disassemble_info *));
+static int print_insn_arc_host_big PARAMS ((bfd_vma, disassemble_info *));
+static int print_insn_arc_graphics_big PARAMS ((bfd_vma, disassemble_info *));
+static int print_insn_arc_audio_big PARAMS ((bfd_vma, disassemble_info *));
+
+static int print_insn PARAMS ((bfd_vma, disassemble_info *, int, int));
/* Print one instruction from PC on INFO->STREAM.
Return the size of the instruction (4 or 8 for the ARC). */
-int
-print_insn_arc (pc, info)
+static int
+print_insn (pc, info, mach, big_p)
bfd_vma pc;
- struct disassemble_info *info;
+ disassemble_info *info;
+ int mach;
+ int big_p;
{
const struct arc_opcode *opcode,*opcode_end;
bfd_byte buffer[4];
arc_insn insn[2];
int got_limm_p = 0;
static int initialized = 0;
+ static int current_mach = 0;
- if (!initialized)
+ if (!initialized || mach != current_mach)
{
- /* ??? Hmmm... what do we pass here? */
- arc_opcode_init_tables (ARC_HAVE_MULT_SHIFT);
initialized = 1;
+ current_mach = arc_get_opcode_mach (mach, big_p);
+ arc_opcode_init_tables (current_mach);
}
status = (*info->read_memory_func) (pc, buffer, 4, info);
(*info->memory_error_func) (status, pc, info);
return -1;
}
- insn[0] = bfd_getb32 (buffer);
+ if (big_p)
+ insn[0] = bfd_getb32 (buffer);
+ else
+ insn[0] = bfd_getl32 (buffer);
- func (stream, "%08lx\t", insn[0]);
+ (*func) (stream, "%08lx\t", insn[0]);
opcode_end = arc_opcodes + arc_opcodes_count;
for (opcode = arc_opcodes; opcode < opcode_end; opcode++)
const struct arc_operand *operand;
const struct arc_operand_value *opval;
+ /* Basic bit mask must be correct. */
if ((insn[0] & opcode->mask) != opcode->value)
continue;
+ /* Supported by this cpu? */
+ if (! arc_opcode_supported (opcode))
+ continue;
+
/* Make two passes over the operands. First see if any of them
have extraction functions, and, if they do, make sure the
instruction is valid. */
/* Instructions like "add.f r0,r1,1" are tricky because the ".f" gets
printed first, but we don't know how to print it until we've processed
the regs. Since we're scanning all the args before printing the insn
- anyways, it's quite easy. */
+ anyways, it's actually quite easy. */
for (syn = opcode->syntax; *syn; ++syn)
{
(*info->memory_error_func) (status, pc, info);
return -1;
}
- insn[1] = bfd_getb32 (buffer);
+ if (big_p)
+ insn[1] = bfd_getb32 (buffer);
+ else
+ insn[1] = bfd_getl32 (buffer);
got_limm_p = 1;
}
{
if (*syn != '%' || *++syn == '%')
{
- func (stream, "%c", *syn);
+ (*func) (stream, "%c", *syn);
continue;
}
aren't defined yet. For these cases just print the
number suitably decorated. */
if (opval)
- func (stream, "%s%s",
- mods & ARC_MOD_DOT ? "." : "",
- opval->name);
+ (*func) (stream, "%s%s",
+ mods & ARC_MOD_DOT ? "." : "",
+ opval->name);
else
- func (stream, "%s%c%d",
- mods & ARC_MOD_DOT ? "." : "",
- operand->fmt, value);
+ (*func) (stream, "%s%c%d",
+ mods & ARC_MOD_DOT ? "." : "",
+ operand->fmt, value);
}
}
- else if (operand->flags & ARC_OPERAND_RELATIVE)
- (*info->print_address_func) (pc + value, info);
+ else if (operand->flags & ARC_OPERAND_RELATIVE_BRANCH)
+ (*info->print_address_func) (pc + 4 + value, info);
/* ??? Not all cases of this are currently caught. */
- else if (operand->flags & ARC_OPERAND_ABSOLUTE)
+ else if (operand->flags & ARC_OPERAND_ABSOLUTE_BRANCH)
+ (*info->print_address_func) ((bfd_vma) value & 0xffffffff, info);
+ else if (operand->flags & ARC_OPERAND_ADDRESS)
(*info->print_address_func) ((bfd_vma) value & 0xffffffff, info);
else if (opval)
/* Note that this case catches both normal and auxiliary regs. */
- func (stream, "%s", opval->name);
+ (*func) (stream, "%s", opval->name);
else
- func (stream, "%ld", value);
+ (*func) (stream, "%ld", value);
}
/* We have found and printed an instruction; return. */
return got_limm_p ? 8 : 4;
}
- func (stream, "*unknown*");
+ (*func) (stream, "*unknown*");
return 4;
}
+
+/* Given MACH, one of bfd_mach_arc_xxx, return the print_insn function to use.
+ This does things a non-standard way (the "standard" way would be to copy
+ this code into disassemble.c). Since there are more than a couple of
+ variants, hiding all this crud here seems cleaner. */
+
+disassembler_ftype
+arc_get_disassembler (mach, big_p)
+ int mach;
+ int big_p;
+{
+ switch (mach)
+ {
+ case bfd_mach_arc_base:
+ return big_p ? print_insn_arc_base_big : print_insn_arc_base_little;
+ case bfd_mach_arc_host:
+ return big_p ? print_insn_arc_host_big : print_insn_arc_host_little;
+ case bfd_mach_arc_graphics:
+ return big_p ? print_insn_arc_graphics_big : print_insn_arc_graphics_little;
+ case bfd_mach_arc_audio:
+ return big_p ? print_insn_arc_audio_big : print_insn_arc_audio_little;
+ }
+ return print_insn_arc_base_little;
+}
+
+static int
+print_insn_arc_base_little (pc, info)
+ bfd_vma pc;
+ disassemble_info *info;
+{
+ return print_insn (pc, info, bfd_mach_arc_base, 0);
+}
+
+static int
+print_insn_arc_host_little (pc, info)
+ bfd_vma pc;
+ disassemble_info *info;
+{
+ return print_insn (pc, info, bfd_mach_arc_host, 0);
+}
+
+static int
+print_insn_arc_graphics_little (pc, info)
+ bfd_vma pc;
+ disassemble_info *info;
+{
+ return print_insn (pc, info, bfd_mach_arc_graphics, 0);
+}
+
+static int
+print_insn_arc_audio_little (pc, info)
+ bfd_vma pc;
+ disassemble_info *info;
+{
+ return print_insn (pc, info, bfd_mach_arc_audio, 0);
+}
+
+static int
+print_insn_arc_base_big (pc, info)
+ bfd_vma pc;
+ disassemble_info *info;
+{
+ return print_insn (pc, info, bfd_mach_arc_base, 1);
+}
+
+static int
+print_insn_arc_host_big (pc, info)
+ bfd_vma pc;
+ disassemble_info *info;
+{
+ return print_insn (pc, info, bfd_mach_arc_host, 1);
+}
+
+static int
+print_insn_arc_graphics_big (pc, info)
+ bfd_vma pc;
+ disassemble_info *info;
+{
+ return print_insn (pc, info, bfd_mach_arc_graphics, 1);
+}
+
+static int
+print_insn_arc_audio_big (pc, info)
+ bfd_vma pc;
+ disassemble_info *info;
+{
+ return print_insn (pc, info, bfd_mach_arc_audio, 1);
+}
projects / deliverable / binutils-gdb.git / blobdiff