arc-ext.c File Reference

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "arc-ext.h"
#include "arc.h"
#include "libiberty.h"
#include "sysdep.h"

Go to the source code of this file.

Classes
struct	ExtInstruction
struct	ExtAuxRegister
struct	ExtCoreRegister
struct	arcExtMap

Macros
#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)
#define	INST_HASH(MAJOR, MINOR)   ((((MAJOR) << 3) ^ (MINOR)) & INST_HASH_MASK)

Functions
static const char *	ExtReadWrite_image (enum ExtReadWrite val)
const char *	arcExtMap_instName (int opcode, int insn, int *flags)
const char *	arcExtMap_coreRegName (int regnum)
enum ExtReadWrite	arcExtMap_coreReadWrite (int regnum)
const char *	arcExtMap_condCodeName (int code)
const char *	arcExtMap_auxRegName (long address)
void	build_ARC_extmap (void *text_bfd)
void	dump_ARC_extmap (void)

Variables
static struct arcExtMap	arc_extension_map

Macro Definition Documentation

FIRST_EXTENSION_CONDITION_CODE

#define FIRST_EXTENSION_CONDITION_CODE   0x10

Definition at line 55 of file arc-ext.c.

FIRST_EXTENSION_CORE_REGISTER

#define FIRST_EXTENSION_CORE_REGISTER   32

Definition at line 53 of file arc-ext.c.

INST_HASH

#define INST_HASH	(		MAJOR,
			MINOR
	)		((((MAJOR) << 3) ^ (MINOR)) & INST_HASH_MASK)

Definition at line 116 of file arc-ext.c.

INST_HASH_BITS

#define INST_HASH_BITS   6

Definition at line 60 of file arc-ext.c.

INST_HASH_MASK

#define INST_HASH_MASK   (INST_HASH_SIZE - 1)

Definition at line 62 of file arc-ext.c.

INST_HASH_SIZE

#define INST_HASH_SIZE   (1 << INST_HASH_BITS)

Definition at line 61 of file arc-ext.c.

LAST_EXTENSION_CONDITION_CODE

#define LAST_EXTENSION_CONDITION_CODE   0x1f

Definition at line 56 of file arc-ext.c.

LAST_EXTENSION_CORE_REGISTER

#define LAST_EXTENSION_CORE_REGISTER   59

Definition at line 54 of file arc-ext.c.

NUM_EXT_COND

#define NUM_EXT_COND   (LAST_EXTENSION_CONDITION_CODE - FIRST_EXTENSION_CONDITION_CODE + 1)

Definition at line 59 of file arc-ext.c.

NUM_EXT_CORE

#define NUM_EXT_CORE   (LAST_EXTENSION_CORE_REGISTER - FIRST_EXTENSION_CORE_REGISTER + 1)

Definition at line 58 of file arc-ext.c.

Function Documentation

arcExtMap_auxRegName()

const char* arcExtMap_auxRegName

(

long

address

)

Definition at line 435 of file arc-ext.c.

{
  /* 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;
}

References ExtAuxRegister::address, arc_extension_map, arcExtMap::auxRegisters, NULL, and r.

Referenced by _auxRegName().

arcExtMap_condCodeName()

const char* arcExtMap_condCodeName

(

int

code

)

Definition at line 424 of file arc-ext.c.

{
    if (code < FIRST_EXTENSION_CONDITION_CODE || code > LAST_EXTENSION_CONDITION_CODE) {
        return NULL;
    }
    return arc_extension_map.condCodes[code - FIRST_EXTENSION_CONDITION_CODE];
}

References arc_extension_map, arcExtMap::condCodes, FIRST_EXTENSION_CONDITION_CODE, LAST_EXTENSION_CONDITION_CODE, and NULL.

Referenced by _condCodeName().

arcExtMap_coreReadWrite()

enum ExtReadWrite arcExtMap_coreReadWrite

(

int

regnum

)

Definition at line 402 of file arc-ext.c.

{
    if (regnum < FIRST_EXTENSION_CORE_REGISTER || regnum > LAST_EXTENSION_CORE_REGISTER) {
        return REG_INVALID;
    }
    return arc_extension_map.coreRegisters[regnum - FIRST_EXTENSION_CORE_REGISTER].rw;
}

References arc_extension_map, arcExtMap::coreRegisters, FIRST_EXTENSION_CORE_REGISTER, LAST_EXTENSION_CORE_REGISTER, ExtCoreRegister::name, and NULL.

arcExtMap_coreRegName()

const char* arcExtMap_coreRegName

(

int

regnum

)

Definition at line 402 of file arc-ext.c.

{
    if (regnum < FIRST_EXTENSION_CORE_REGISTER || regnum > LAST_EXTENSION_CORE_REGISTER) {
        return NULL;
    }
    return arc_extension_map.coreRegisters[regnum - FIRST_EXTENSION_CORE_REGISTER].name;
}

Referenced by _coreRegName().

arcExtMap_instName()

const char* arcExtMap_instName	(	int	opcode,
		int	insn,
		int *	flags
	)

Definition at line 300 of file arc-ext.c.

{
  /* 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;
 
  if (*flags != E_ARC_MACH_A4) /* ARCompact extension instructions.  */
    {
      /* 16-bit instructions.  */
      if (0x08 <= opcode && opcode <= 0x0b)
    {
      /* I - set but not used */
      unsigned char /* I, */ b, c, i;
 
      /* I = (insn & 0xf800) >> 11; */
      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
    {
      /* P, M - set but not used */
      unsigned char /* P, M, */ I, A, B;
 
      /* P = (insn & 0x00c00000) >> 22; */
      /* M = (insn & 0x00000020); */
      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;
            }
        }
    }
  } else { /* ARCTangent extension instructions.  */
      minor = insn;
  }
 
  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;
}

References A, arc_extension_map, b, B, c, E_ARC_MACH_A4, ExtInstruction::flags, flags, I, i, INST_HASH, arcExtMap::instructions, M, ExtInstruction::major, ExtInstruction::minor, minor, ExtInstruction::name, ExtInstruction::next, NULL, and P.

Referenced by _instName().

build_ARC_extmap()

void build_ARC_extmap

(

void *

text_bfd

)

Definition at line 453 of file arc-ext.c.

{
#if 0
  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);
          }
      }
#endif
}

References bfd_get_section_contents(), bfd_get_section_size, count, free(), bfd_section::name, bfd_section::next, NULL, and xmalloc.

dump_ARC_extmap()

void dump_ARC_extmap

(

void

)

Definition at line 483 of file arc-ext.c.

{
    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]);
        }
    }
}

References arc_extension_map, arcExtMap::auxRegisters, arcExtMap::condCodes, arcExtMap::coreRegisters, ExtReadWrite_image(), ExtInstruction::flags, i, INST_HASH_SIZE, arcExtMap::instructions, ExtInstruction::major, ExtInstruction::minor, ExtInstruction::name, ExtInstruction::next, NULL, NUM_EXT_COND, NUM_EXT_CORE, printf(), r, and reg.

ExtReadWrite_image()

static const char* ExtReadWrite_image ( enum ExtReadWrite  val )

static

Definition at line 280 of file arc-ext.c.

{
    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 "???";
    }
}

References test-lz4-speed::default, REG_INVALID, REG_READ, REG_READWRITE, REG_WRITE, and val.

Referenced by dump_ARC_extmap().

Variable Documentation

arc_extension_map

struct arcExtMap arc_extension_map

static

Definition at line 1 of file arc-ext.c.

Referenced by arcExtMap_auxRegName(), arcExtMap_condCodeName(), arcExtMap_coreReadWrite(), arcExtMap_instName(), and dump_ARC_extmap().