| /* ARC target-dependent stuff. Extension structure access functions |
| Copyright (C) 1995-2016 Free Software Foundation, Inc. |
| |
| This file is part of libopcodes. |
| |
| This library is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3, or (at your option) |
| any later version. |
| |
| It is distributed in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY |
| or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public |
| License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
| MA 02110-1301, USA. */ |
| |
| #include "sysdep.h" |
| #include <stdlib.h> |
| #include <stdio.h> |
| |
| #include "bfd.h" |
| #include "arc-ext.h" |
| #include "elf/arc.h" |
| #include "libiberty.h" |
| |
| |
| /* This module provides support for extensions to the ARC processor |
| architecture. */ |
| |
| |
| /* Local constants. */ |
| |
| #define FIRST_EXTENSION_CORE_REGISTER 32 |
| #define LAST_EXTENSION_CORE_REGISTER 59 |
| #define FIRST_EXTENSION_CONDITION_CODE 0x10 |
| #define LAST_EXTENSION_CONDITION_CODE 0x1f |
| |
| #define NUM_EXT_CORE \ |
| (LAST_EXTENSION_CORE_REGISTER - FIRST_EXTENSION_CORE_REGISTER + 1) |
| #define NUM_EXT_COND \ |
| (LAST_EXTENSION_CONDITION_CODE - FIRST_EXTENSION_CONDITION_CODE + 1) |
| #define INST_HASH_BITS 6 |
| #define INST_HASH_SIZE (1 << INST_HASH_BITS) |
| #define INST_HASH_MASK (INST_HASH_SIZE - 1) |
| |
| |
| /* Local types. */ |
| |
| /* These types define the information stored in the table. */ |
| |
| struct ExtInstruction |
| { |
| char major; |
| char minor; |
| char flags; |
| char* name; |
| struct ExtInstruction* next; |
| }; |
| |
| struct ExtAuxRegister |
| { |
| long address; |
| char* name; |
| struct ExtAuxRegister* next; |
| }; |
| |
| struct ExtCoreRegister |
| { |
| short number; |
| enum ExtReadWrite rw; |
| char* name; |
| }; |
| |
| struct arcExtMap |
| { |
| struct ExtAuxRegister* auxRegisters; |
| struct ExtInstruction* instructions[INST_HASH_SIZE]; |
| struct ExtCoreRegister coreRegisters[NUM_EXT_CORE]; |
| char* condCodes[NUM_EXT_COND]; |
| }; |
| |
| |
| /* Local data. */ |
| |
| /* Extension table. */ |
| static struct arcExtMap arc_extension_map; |
| |
| |
| /* Local macros. */ |
| |
| /* A hash function used to map instructions into the table. */ |
| #define INST_HASH(MAJOR, MINOR) ((((MAJOR) << 3) ^ (MINOR)) & INST_HASH_MASK) |
| |
| |
| /* Local functions. */ |
| |
| static void |
| create_map (unsigned char *block, |
| unsigned long length) |
| { |
| unsigned char *p = block; |
| |
| while (p && p < (block + length)) |
| { |
| /* p[0] == length of record |
| p[1] == type of record |
| For instructions: |
| p[2] = opcode |
| p[3] = minor opcode (if opcode == 3) |
| p[4] = flags |
| p[5]+ = name |
| For core regs and condition codes: |
| p[2] = value |
| p[3]+ = name |
| For auxiliary regs: |
| p[2..5] = value |
| p[6]+ = name |
| (value is p[2]<<24|p[3]<<16|p[4]<<8|p[5]). */ |
| |
| /* The sequence of records is temrinated by an "empty" |
| record. */ |
| if (p[0] == 0) |
| break; |
| |
| switch (p[1]) |
| { |
| case EXT_INSTRUCTION: |
| { |
| struct ExtInstruction *insn = XNEW (struct ExtInstruction); |
| int major = p[2]; |
| int minor = p[3]; |
| struct ExtInstruction **bucket = |
| &arc_extension_map.instructions[INST_HASH (major, minor)]; |
| |
| insn->name = xstrdup ((char *) (p + 5)); |
| insn->major = major; |
| insn->minor = minor; |
| insn->flags = p[4]; |
| insn->next = *bucket; |
| *bucket = insn; |
| break; |
| } |
| |
| case EXT_CORE_REGISTER: |
| { |
| unsigned char number = p[2]; |
| char* name = (char *) (p + 3); |
| |
| arc_extension_map. |
| coreRegisters[number - FIRST_EXTENSION_CORE_REGISTER].number |
| = number; |
| arc_extension_map. |
| coreRegisters[number - FIRST_EXTENSION_CORE_REGISTER].rw |
| = REG_READWRITE; |
| arc_extension_map. |
| coreRegisters[number - FIRST_EXTENSION_CORE_REGISTER].name |
| = xstrdup (name); |
| break; |
| } |
| |
| case EXT_LONG_CORE_REGISTER: |
| { |
| unsigned char number = p[2]; |
| char* name = (char *) (p + 7); |
| enum ExtReadWrite rw = p[6]; |
| |
| arc_extension_map. |
| coreRegisters[number - FIRST_EXTENSION_CORE_REGISTER].number |
| = number; |
| arc_extension_map. |
| coreRegisters[number - FIRST_EXTENSION_CORE_REGISTER].rw |
| = rw; |
| arc_extension_map. |
| coreRegisters[number - FIRST_EXTENSION_CORE_REGISTER].name |
| = xstrdup (name); |
| } |
| |
| case EXT_COND_CODE: |
| { |
| char *cc_name = xstrdup ((char *) (p + 3)); |
| |
| arc_extension_map. |
| condCodes[p[2] - FIRST_EXTENSION_CONDITION_CODE] |
| = cc_name; |
| break; |
| } |
| |
| case EXT_AUX_REGISTER: |
| { |
| /* Trickier -- need to store linked list of these. */ |
| struct ExtAuxRegister *newAuxRegister |
| = XNEW (struct ExtAuxRegister); |
| char *aux_name = xstrdup ((char *) (p + 6)); |
| |
| newAuxRegister->name = aux_name; |
| newAuxRegister->address = (p[2] << 24) | (p[3] << 16) |
| | (p[4] << 8) | p[5]; |
| newAuxRegister->next = arc_extension_map.auxRegisters; |
| arc_extension_map.auxRegisters = newAuxRegister; |
| break; |
| } |
| |
| default: |
| break; |
| } |
| |
| p += p[0]; /* Move on to next record. */ |
| } |
| } |
| |
| |
| /* Free memory that has been allocated for the extensions. */ |
| |
| static void |
| destroy_map (void) |
| { |
| struct ExtAuxRegister *r; |
| unsigned int i; |
| |
| /* Free auxiliary registers. */ |
| r = arc_extension_map.auxRegisters; |
| while (r) |
| { |
| /* N.B. after r has been freed, r->next is invalid! */ |
| struct ExtAuxRegister* next = r->next; |
| |
| free (r->name); |
| free (r); |
| r = next; |
| } |
| |
| /* Free instructions. */ |
| for (i = 0; i < INST_HASH_SIZE; i++) |
| { |
| struct ExtInstruction *insn = arc_extension_map.instructions[i]; |
| |
| while (insn) |
| { |
| /* N.B. after insn has been freed, insn->next is invalid! */ |
| struct ExtInstruction *next = insn->next; |
| |
| free (insn->name); |
| free (insn); |
| insn = next; |
| } |
| } |
| |
| /* Free core registers. */ |
| for (i = 0; i < NUM_EXT_CORE; i++) |
| { |
| if (arc_extension_map.coreRegisters[i].name) |
| free (arc_extension_map.coreRegisters[i].name); |
| } |
| |
| /* Free condition codes. */ |
| for (i = 0; i < NUM_EXT_COND; i++) |
| { |
| if (arc_extension_map.condCodes[i]) |
| free (arc_extension_map.condCodes[i]); |
| } |
| |
| memset (&arc_extension_map, 0, sizeof (arc_extension_map)); |
| } |
| |
| |
| static const char * |
| ExtReadWrite_image (enum ExtReadWrite val) |
| { |
| switch (val) |
| { |
| case REG_INVALID : return "INVALID"; |
| case REG_READ : return "RO"; |
| case REG_WRITE : return "WO"; |
| case REG_READWRITE: return "R/W"; |
| default : return "???"; |
| } |
| } |
| |
| |
| /* Externally visible functions. */ |
| |
| /* Get the name of an extension instruction. */ |
| |
| const char * |
| arcExtMap_instName (int opcode, |
| int insn, |
| int *flags) |
| { |
| /* Here the following tasks need to be done. First of all, the |
| opcode stored in the Extension Map is the real opcode. However, |
| the subopcode stored in the instruction to be disassembled is |
| mangled. We pass (in minor opcode), the instruction word. Here |
| we will un-mangle it and get the real subopcode which we can look |
| for in the Extension Map. This function is used both for the |
| ARCTangent and the ARCompact, so we would also need some sort of |
| a way to distinguish between the two architectures. This is |
| because the ARCTangent does not do any of this mangling so we |
| have no issues there. */ |
| |
| /* If P[22:23] is 0 or 2 then un-mangle using iiiiiI. If it is 1 |
| then use iiiiIi. Now, if P is 3 then check M[5:5] and if it is 0 |
| then un-mangle using iiiiiI else iiiiii. */ |
| |
| unsigned char minor; |
| struct ExtInstruction *temp; |
| |
| /* 16-bit instructions. */ |
| if (0x08 <= opcode && opcode <= 0x0b) |
| { |
| unsigned char b, c, i; |
| |
| b = (insn & 0x0700) >> 8; |
| c = (insn & 0x00e0) >> 5; |
| i = (insn & 0x001f); |
| |
| if (i) |
| minor = i; |
| else |
| minor = (c == 0x07) ? b : c; |
| } |
| /* 32-bit instructions. */ |
| else |
| { |
| unsigned char I, A, B; |
| |
| I = (insn & 0x003f0000) >> 16; |
| A = (insn & 0x0000003f); |
| B = ((insn & 0x07000000) >> 24) | ((insn & 0x00007000) >> 9); |
| |
| if (I != 0x2f) |
| { |
| #ifndef UNMANGLED |
| switch (P) |
| { |
| case 3: |
| if (M) |
| { |
| minor = I; |
| break; |
| } |
| case 0: |
| case 2: |
| minor = (I >> 1) | ((I & 0x1) << 5); |
| break; |
| case 1: |
| minor = (I >> 1) | (I & 0x1) | ((I & 0x2) << 4); |
| } |
| #else |
| minor = I; |
| #endif |
| } |
| else |
| { |
| if (A != 0x3f) |
| minor = A; |
| else |
| minor = B; |
| } |
| } |
| |
| temp = arc_extension_map.instructions[INST_HASH (opcode, minor)]; |
| while (temp) |
| { |
| if ((temp->major == opcode) && (temp->minor == minor)) |
| { |
| *flags = temp->flags; |
| return temp->name; |
| } |
| temp = temp->next; |
| } |
| |
| return NULL; |
| } |
| |
| /* Get the name of an extension core register. */ |
| |
| const char * |
| arcExtMap_coreRegName (int regnum) |
| { |
| if (regnum < FIRST_EXTENSION_CORE_REGISTER |
| || regnum > LAST_EXTENSION_CONDITION_CODE) |
| return NULL; |
| return arc_extension_map. |
| coreRegisters[regnum - FIRST_EXTENSION_CORE_REGISTER].name; |
| } |
| |
| /* Get the access mode of an extension core register. */ |
| |
| enum ExtReadWrite |
| arcExtMap_coreReadWrite (int regnum) |
| { |
| if (regnum < FIRST_EXTENSION_CORE_REGISTER |
| || regnum > LAST_EXTENSION_CONDITION_CODE) |
| return REG_INVALID; |
| return arc_extension_map. |
| coreRegisters[regnum - FIRST_EXTENSION_CORE_REGISTER].rw; |
| } |
| |
| /* Get the name of an extension condition code. */ |
| |
| const char * |
| arcExtMap_condCodeName (int code) |
| { |
| if (code < FIRST_EXTENSION_CONDITION_CODE |
| || code > LAST_EXTENSION_CONDITION_CODE) |
| return NULL; |
| return arc_extension_map. |
| condCodes[code - FIRST_EXTENSION_CONDITION_CODE]; |
| } |
| |
| /* Get the name of an extension auxiliary register. */ |
| |
| const char * |
| arcExtMap_auxRegName (long address) |
| { |
| /* Walk the list of auxiliary register names and find the name. */ |
| struct ExtAuxRegister *r; |
| |
| for (r = arc_extension_map.auxRegisters; r; r = r->next) |
| { |
| if (r->address == address) |
| return (const char *)r->name; |
| } |
| return NULL; |
| } |
| |
| /* Load extensions described in .arcextmap and |
| .gnu.linkonce.arcextmap.* ELF section. */ |
| |
| void |
| build_ARC_extmap (bfd *text_bfd) |
| { |
| asection *sect; |
| |
| /* The map is built each time gdb loads an executable file - so free |
| any existing map, as the map defined by the new file may differ |
| from the old. */ |
| destroy_map (); |
| |
| for (sect = text_bfd->sections; sect != NULL; sect = sect->next) |
| if (!strncmp (sect->name, |
| ".gnu.linkonce.arcextmap.", |
| sizeof (".gnu.linkonce.arcextmap.") - 1) |
| || !strcmp (sect->name,".arcextmap")) |
| { |
| bfd_size_type count = bfd_get_section_size (sect); |
| unsigned char* buffer = xmalloc (count); |
| |
| if (buffer) |
| { |
| if (bfd_get_section_contents (text_bfd, sect, buffer, 0, count)) |
| create_map (buffer, count); |
| free (buffer); |
| } |
| } |
| } |
| |
| |
| void |
| dump_ARC_extmap (void) |
| { |
| struct ExtAuxRegister *r; |
| int i; |
| |
| r = arc_extension_map.auxRegisters; |
| |
| while (r) |
| { |
| printf ("AUX : %s %ld\n", r->name, r->address); |
| r = r->next; |
| } |
| |
| for (i = 0; i < INST_HASH_SIZE; i++) |
| { |
| struct ExtInstruction *insn; |
| |
| for (insn = arc_extension_map.instructions[i]; |
| insn != NULL; insn = insn->next) |
| printf ("INST: %d %d %x %s\n", insn->major, insn->minor, |
| insn->flags, insn->name); |
| } |
| |
| for (i = 0; i < NUM_EXT_CORE; i++) |
| { |
| struct ExtCoreRegister reg = arc_extension_map.coreRegisters[i]; |
| |
| if (reg.name) |
| printf ("CORE: %s %d %s\n", reg.name, reg.number, |
| ExtReadWrite_image (reg.rw)); |
| } |
| |
| for (i = 0; i < NUM_EXT_COND; i++) |
| if (arc_extension_map.condCodes[i]) |
| printf ("COND: %s\n", arc_extension_map.condCodes[i]); |
| } |