/* Target dependent code for ARC processor family, for GDB, the GNU debugger.

   Copyright 2005, 2008, 2009 Free Software Foundation, Inc.

   Contributed by Codito Technologies Pvt. Ltd. (www.codito.com)

   Authors:
      Soam Vasani          <soam.vasani@codito.com>
      Ramana Radhakrishnan <ramana.radhakrishnan@codito.com>
      Richard Stuckey      <richard.stuckey@arc.com>

   This file is part of GDB.

   This program 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 of the License, or
   (at your option) any later version.

   This program 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, see <http://www.gnu.org/licenses/>.  */

/******************************************************************************/
/*                                                                            */
/* Outline:                                                                   */
/*     This module provides support for the ARC processor family's target     */
/*     dependencies.  In particular, it has knowledge of the processor ABI.   */
/*                                                                            */
/*     See                                                                    */
/*           ARCompact Instruction Set Architecture                           */
/*                   Programmer's Reference                                   */
/*                         (5115-018)                                         */
/*                                                                            */
/*     for a description of ARC processor architecture, and                   */
/*                                                                            */
/*           System V ABI Supplement                                          */
/*                   4093-004                                                 */
/*                                                                            */
/*     for a complete definition of the ABI.                                  */
/*                                                                            */
/*                                                                            */
/* Stack Frame Layout:                                                        */
/*     This shows the layout of the stack frame for the general case of a     */
/*     function call; a given function might not have a variable number of    */
/*     arguments or local variables, or might not save any registers, so it   */
/*     would not have the corresponding frame areas.  Additionally, a leaf    */
/*     function (i.e. one which calls no other functions) does not need to    */
/*     save the contents of the BLINK register (which holds its return        */
/*     address), and a function might not have a frame pointer.               */
/*                                                                            */
/*     N.B. the stack grows downward, so SP points below FP in memory; SP     */
/*          always points to the last used word on the stack, not the first   */
/*          one.                                                              */
/*                                                                            */
/*                   |                       |   |                            */
/*                   |      arg word N       |   | caller's                   */
/*                   |           :           |   | frame                      */
/*                   |      arg word 10      |   |                            */
/*                   |      arg word 9       |   |                            */
/*       old SP ---> |-----------------------| --                             */
/*                   |   var arg word 8      |   |                            */
/*                   |           :           |   |                            */
/*                   |   var arg word P+1    |   |                            */
/*                   |-----------------------|   |                            */
/*                   |                       |   |                            */
/*                   |      callee-saved     |   |                            */
/*                   |        registers      |   |                            */
/*                   |                       |   |                            */
/*                   |-----------------------|   |                            */
/*                   |      saved blink (*)  |   |                            */
/*                   |-----------------------|   | callee's                   */
/*                   |      saved FP         |   | frame                      */
/*           FP ---> |-----------------------|   |                            */
/*                   |                       |   |                            */
/*                   |         local         |   |                            */
/*                   |       variables       |   |                            */
/*                   |                       |   |                            */
/*                   |       register        |   |                            */
/*                   |      spill area       |   |                            */
/*                   |                       |   |                            */
/*                   |     outgoing args     |   |                            */
/*                   |                       |   |                            */
/*           SP ---> |-----------------------| --                             */
/*                   |                       |                                */
/*                   |         unused        |                                */
/*                   |                       |                                */
/*                               |                                            */
/*                               |                                            */
/*                               V                                            */
/*                           downwards                                        */
/*                                                                            */
/*     The list of arguments to be passed to a function is considered to be a */
/*     sequence of N words (as though all the parameters were stored in order */
/*     in memory with each parameter occupying an integral number of words).  */
/*     Words 1 .. 8 are passed in registers 0 .. 7; if the function has more  */
/*     than 8 words of arguments then words 9 .. N are passed on the stack in */
/*     the caller's frame.                                                    */
/*                                                                            */
/*     If the function has a variable number of arguments, e.g. it has a form */
/*     such as                                                                */
/*                      function(p1, p2, ...);                                */
/*                                                                            */
/*     and P words are required to hold the values of the named parameters    */
/*     (which are passed in registers 0 .. P-1), then the remaining 8 - P     */
/*     words passed in registers P .. 7 are spilled into the top of the frame */
/*     so that the anonymous parameter words occupy a continous region.       */
/*                                                                            */
/*     (*) if saved.                                                          */
/*                                                                            */
/* Usage:                                                                     */
/*     The module exports a function _initialize_arc_tdep: the call to this   */
/*     function is generated by the gdb build mechanism, so this function     */
/*     should not be explicitly called.                                       */
/*                                                                            */
/*     The operations provided by this module are registered with gdb during  */
/*     initialization; gdb then calls them via function pointers, rather than */
/*     by name (this allows gdb to handle multiple target architectures):     */
/*                                                                            */
/*          set_gdbarch_XXX (gdbarch, <function>);                            */
/*                                                                            */
/*                                                                            */
/* Build Configuration:                                                       */
/*     The ARC gdb may be built in two different configurations, according to */
/*     the nature of the target that it is to debug:                          */
/*                                                                            */
/*     1) arc-elf32:                                                          */
/*           for debugging 'bare-metal' builds of user code (i.e. built with  */
/*           newlib)                                                          */
/*                                                                            */
/*           ARC-specific modules:                                            */
/*                arc-tdep                                                    */
/*                arc-elf32-tdep                                              */
/*                arc-xiss                                                    */
/*                arc-jtag                                                    */
/*                arc-jtag-ops                                                */
/*                arc-jtag-actionpoints                                       */
/*                arc-gpio                                                    */
/*                arc-remote-fileio                                           */
/*                arc-registers                                               */
/*                arc-architecture                                            */
/*                arc-board                                                   */
/*                arc-arguments                                               */
/*                arc-memory                                                  */
/*                arc-inst-tracing                                            */
/*                                                                            */
/*     2) arc-linux-uclibc:                                                   */
/*           for deugging user mode Linux applications, via communication to  */
/*           the remote gdbserver process, running on Linux for ARC700        */
/*                                                                            */
/*           ARC-specific modules:                                            */
/*                arc-tdep                                                    */
/*                arc-linux-tdep                                              */
/*                                                                            */
/*     This module provides operations which are common to both; operations   */
/*     which are specific to one, or which have different variants in each    */
/*     configuration, are provided by the other modules.                      */
/*                                                                            */
/*                                                                            */
/* Debug Targets:                                                             */
/*     The ARC gdb supports a number of debug targets.  These are:            */
/*                                                                            */
/*         arc-elf32-gdb                                                      */
/*             built-in simulator                       'target sim'          */
/*             ARCangel 4 h/w emulator                  'target arcjtag'      */
/*             dynamically loaded xISS simulator        'target arcxiss'      */
/*             separately executing xISS simulator      'target remote'       */
/*                                                                            */
/*         arc-linux-uclibc-gdb                                               */
/*             gdbserver running on ARC Linux           'target remote'       */
/*                                                                            */
/*     It should, in theory, be possible for either debugger to connect to    */
/*     any remote target which supports the gdb Remote Serial Protocol.       */
/*     However, any such target MUST agree with the debugger on the register  */
/*     numbering scheme that is used, as this controls the order of register  */
/*     contents held in the RSP 'G' (set all registers) packet and the 'g'    */
/*     (get all registers) response packet, as well as the register numbers   */
/*     used in the 'P' (set one register) and 'p' (get one register) packets, */
/*     and in the 'T' stop reply packet.  The schemes used by each debugger   */
/*     are defined in the arc-elf32-tdep and arc-linux-tdep modules.          */
/*                                                                            */
/******************************************************************************/

/* system header files */
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <byteswap.h>

/* gdb header files */
#include "defs.h"
#include "config.h"
#include "arch-utils.h"
#include "dis-asm.h"
#include "frame.h"
#include "frame-unwind.h"
#include "inferior.h"
#include "regcache.h"
#include "reggroups.h"
#include "trad-frame.h"
#include "dwarf2-frame.h"
#include "gdbcore.h"
#include "observer.h"
#include "osabi.h"
#include "gdbcmd.h"
#include "block.h"
#include "dictionary.h"
#include "language.h"
#include "demangle.h"
#include "objfiles.h"
#include "gdb_assert.h"

/* ARC header files */

/* N.B. one and only one of ARC_ELF32_TARGET and ARC_LINUX_TARGET must be defined!  */

#ifdef ARC_ELF32_TARGET
#ifdef ARC_LINUX_TARGET
#error ARC build is not correctly configured (both flags set)
#else
#include "config/arc/tm-embed.h"
#endif
#else
#ifdef ARC_LINUX_TARGET
#include "config/arc/tm-linux.h"
#else
#error ARC build is not correctly configured (no flag set)
#endif
#endif

#include "opcode/arc.h"
#include "opcodes/arc-dis.h"
#include "opcodes/arc-ext.h"
#include "opcodes/arcompact-dis.h"
#include "arc-support.h"
#include "arc-tdep.h"


/* -------------------------------------------------------------------------- */
/*                               local types                                  */
/* -------------------------------------------------------------------------- */

typedef struct
{
    const char  *name;
    CORE_ADDR    address;
    Boolean      is_argument;
    Boolean      is_callee;
    Boolean      is_array;
    unsigned int size;
    unsigned int element_size;
} LocalVariable;


/* The frame unwind cache for the ARC.  */

typedef struct
{
    /* BLINK save location offset from previous SP (-ve value).  */
    int blink_save_offset_from_prev_sp;

    /* The stack pointer at the time this frame was created; i.e. the
       caller's stack pointer when this function was called.  It is used
       to identify this frame.  */
    CORE_ADDR prev_sp;

    /* The frame base (as held in FP).
       N.B. this is NOT the address of the lowest word in the frame!  */
    CORE_ADDR frame_base;

    /* Change in SP from previous SP (-ve value) - this is computed by scanning
       the prologue of the function: initially 0, it is updated for each
       instruction which changes SP (either explicitly by a subtraction from SP
       or implicitly by a push operation), so at each point in the prologue it
       gives the difference between the previous SP (i.e. before the function
       was called) and the current SP at that point; at the end of the prologue
       it holds the total change in SP, i.e. the size of the frame.  */
    LONGEST delta_sp;

    /* Offset of old stack pointer from frame base (+ve value).  */
    LONGEST old_sp_offset_from_fp;

    /* Is this a leaf function? */
    Boolean is_leaf;
    /* Is there a frame pointer? */
    Boolean uses_fp;

    /* Offsets for each register in the stack frame.  */
    struct trad_frame_saved_reg *saved_regs;
    unsigned int                 saved_regs_mask;
} UnwindCache;


/* -------------------------------------------------------------------------- */
/*                               local data                                   */
/* -------------------------------------------------------------------------- */

#define DEBUG_COMMAND               "arc-debug"
#define SHOW_FRAME_COMMAND          "arc-show-frame"
#define SHOW_FRAME_COMMAND_USAGE    "Usage: " SHOW_FRAME_COMMAND " [ <FRAME> ]\n"

#define NEW_LINE                     _("\n")


/* -------------------------------------------------------------------------- */
/*                               externally visible data                      */
/* -------------------------------------------------------------------------- */

/* Global debug flag.  */
Boolean arc_debug_target;


/* -------------------------------------------------------------------------- */
/*                               local macros                                 */
/* -------------------------------------------------------------------------- */

#define WORD_ALIGNED(addr)         ((addr) & ~(BYTES_IN_WORD - 1))
#define WORDS_OCCUPIED(bytes)      (((bytes) + BYTES_IN_WORD - 1) / BYTES_IN_WORD)
#define ROUND_UP_TO_WORDS(bytes)   (WORDS_OCCUPIED(bytes) * BYTES_IN_WORD)


/* Macros to be used with disassembling the prologue and update the frame info.
   The *FI macros are to update the frame info and the ACT macros are to
   actually do the action on a corresponding match.  */

#define IS_INSTRUCTION(insn_name, search_string)    !strcmp(insn_name, search_string)

#define CHECK_OPERAND_STRING_AND_ACT(target_check, search_string, action) \
    if (strstr(target_check, search_string) == target_check)              \
    {                                                                     \
        action;                                                           \
        return TRUE;                                                      \
    }


/* The frame info changes by changing the decrementing the delta_sp and setting
   the leaf function flag to be False (if this function prologue is saving blink
   then it must be going to call another function - so it can not be a leaf!);
   also the offset of the blink register save location from the previous value
   of sp is recorded.  This will eventually used to compute the address of the
   save location:

           <blink saved address> = <prev sp> + <blink offset from prev sp>

   The addition (+=) below is because the sp offset and the instruction offset
   are negative - so incrementing the sp offset by the instruction offset is
   actually making the sp offset more negative, correctly reflecting that SP
   is moving further down the downwards-growing stack.  */

#define PUSH_BLINK(offset)                                           \
    {                                                                \
        info->delta_sp += offset;                                    \
        info->blink_save_offset_from_prev_sp = (int) info->delta_sp; \
        info->is_leaf = FALSE;                                       \
    }

#define PUSH_BLINK_ACT                          \
    do {                                        \
           if (info) PUSH_BLINK(instr->_offset) \
       } while (0);


#define IS_PUSH_BLINK_FI(state) CHECK_OPERAND_STRING_AND_ACT(state->operandBuffer, "blink", PUSH_BLINK_ACT)


/* At the point that that FP is pushed onto the stack (so saving the dynamic
   link chain pointer to the previous frame), at the address that will be the
   base of the new frame, we know the offset of SP from the previous SP - so the
   offset of the old SP from the new frame base is known (the -ve delta_sp is
   negated to give the +ve old_sp_offset_from_fp).  */
#define PUSH_FP_ACT  do {                                                       \
                            if (info)                                           \
                            {                                                   \
                                 info->delta_sp += instr->_offset;              \
                                 info->old_sp_offset_from_fp = -info->delta_sp; \
                        }} while (0);

#define IS_PUSH_FP_FI(state) CHECK_OPERAND_STRING_AND_ACT(state->operandBuffer, "fp", PUSH_FP_ACT)


#define UPDATE_FP_ACT    do {                         \
                             if (info)                \
                                info->uses_fp = TRUE; \
                          } while (0);

#define IS_UPDATE_FP_FI(state)                                                    \
   if (IS_INSTRUCTION(state->instrBuffer, "mov"))                                 \
   {                                                                              \
      CHECK_OPERAND_STRING_AND_ACT(state->operandBuffer, "fp,sp", UPDATE_FP_ACT); \
   }


#define UPDATE_STACK_SPACE(state)    do {                                                 \
                                       if (info) {                                        \
                                          /* Eat up sp,sp.  */                            \
                                          int immediate = atoi(state->operandBuffer + 6); \
                                          info->delta_sp -= immediate;                    \
                                      }} while (0);


#define IS_SUB_SP_FI(state)                                                                    \
    if (IS_INSTRUCTION(state->instrBuffer, "sub") ||                                           \
        IS_INSTRUCTION(state->instrBuffer, "sub_s"))                                           \
    {                                                                                          \
        CHECK_OPERAND_STRING_AND_ACT(state->operandBuffer, "sp,sp", UPDATE_STACK_SPACE(state)) \
    }


/* -------------------------------------------------------------------------- */
/*                              forward declarations                          */
/* -------------------------------------------------------------------------- */

static CORE_ADDR scan_prologue (CORE_ADDR          entrypoint,
                                struct frame_info *next_frame,
                                UnwindCache       *info);


/* -------------------------------------------------------------------------- */
/*                               local debug functions                        */
/* -------------------------------------------------------------------------- */

/* Print information for a frame.  */

static void
printFrameInfo (const char  *message,
                UnwindCache *info,
                Boolean      addresses_known)
{
    unsigned int i;

    DEBUG("-------------------\n");
    DEBUG("%s (info = %p)\n",     message, info);
    DEBUG("prev_sp               = %lx\n", (long unsigned int) info->prev_sp);
    DEBUG("frame_base            = %lx\n", (long unsigned int) info->frame_base);
    DEBUG("blink offset          = %d\n",                      info->blink_save_offset_from_prev_sp);
    DEBUG("delta_sp              = %d\n",  (int)               info->delta_sp);
    DEBUG("old_sp_offset_from_fp = %d\n",  (int)               info->old_sp_offset_from_fp);
    DEBUG("is_leaf = %d, uses_fp = %d\n", info->is_leaf, info->uses_fp);

     for (i = ARC_ABI_FIRST_CALLEE_SAVED_REGISTER; i < ARC_ABI_LAST_CALLEE_SAVED_REGISTER; i++)
     {
        if (info->saved_regs_mask & (1 << i))
            DEBUG("saved register R%02d %s 0x%lx\n",
                  i,
                  (addresses_known) ? "address" : "offset",
                  (unsigned long) info->saved_regs[i].addr);
    }
    DEBUG("-------------------\n");
}


static const char*
ARC_Debugger_OperandType_Image (enum ARC_Debugger_OperandType value)
{
    switch (value)
    {
        case ARC_LIMM          : return "LIMM";
        case ARC_SHIMM         : return "SHIMM";
        case ARC_REGISTER      : return "REGISTER";
        case ARCOMPACT_REGISTER: return "COMPACT REGISTER";
        case ARC_UNDEFINED     : return "UNDEFINED";
    }
    return "?";
}


/* Print the instruction state returned by the disassembler.
   Used for internal debugging only.  */

static void
printInsnState (struct arcDisState state)
{
    DEBUG("---------------------------------\n");
    DEBUG("Instruction Length %d\n",          state.instructionLen);
    DEBUG("Opcode [0x%x] : Cond [%x]\n",      state._opcode, state._cond);
    DEBUG("Words 1 [%lx] : 2 [%lx]\n",        state.words[0], state.words[1]);
    DEBUG("Ea present [%x] : memload [%x]\n", state._ea_present, state._mem_load);
    DEBUG("Load Length [%d]:\n",              state._load_len);
    DEBUG("Address Writeback [%d]\n",         state._addrWriteBack);
    DEBUG("EA reg1 is [%x] offset [%x]\n",    state.ea_reg1, state._offset);
    DEBUG("EA reg2 is [%x]\n",                state.ea_reg2);
    DEBUG("Instr   buffer is %s\n",           state.instrBuffer);
    DEBUG("Operand buffer is %s\n",           state.operandBuffer);
    DEBUG("SourceType is %s\n",               ARC_Debugger_OperandType_Image(state.sourceType));
    DEBUG("Source operand is %u\n",           state.source_operand.registerNum);   /* All fields of the union have same type.  */
    DEBUG("Flow is %d\n",                     state.flow);
    DEBUG("Branch is %d\n",                   state.isBranch);
    DEBUG("---------------------------------\n");
}


/* -------------------------------------------------------------------------- */
/*                     local functions for the disassembler                   */
/* -------------------------------------------------------------------------- */

/* Wrapper for the target_read_memory function.  */

static int
read_memory_for_disassembler (bfd_vma                  memaddr,
                              bfd_byte                *myaddr,
                              unsigned int             length,
                              struct disassemble_info *info)    // unused
{
    return target_read_memory((CORE_ADDR) memaddr, (gdb_byte*) myaddr, (int) length);
}


/* This is a callback function which gets called by gdb whenever the current
   object file changes.  */

static void
set_disassembler (struct objfile *objfile)
{
    if (objfile)
    {
       /* The ARC libopcodes wants obfd so that it can find out what CPU
          extensions are defined in the file.  */
        set_gdbarch_print_insn(current_gdbarch, arcompact_get_disassembler(objfile->obfd));
//      dump_ARC_extmap();
    }
}


/* This function is supplied to gdb as the disassembler until such time as we do
   have a disassembler available.  */

static int
dummy_disassembler (bfd_vma address, disassemble_info *info)
{
    error(_("No disassembly operation yet available (no executable file loaded)"));
    return 0;
}


/* -------------------------------------------------------------------------- */
/*               local functions for decoding call chains                     */
/* -------------------------------------------------------------------------- */

/* Simple utility function to create a new frame cache structure.  */

static UnwindCache*
create_cache (struct frame_info *next_frame)
{
    UnwindCache *cache = FRAME_OBSTACK_ZALLOC (UnwindCache);

    /* Zero all fields.  */
    cache->blink_save_offset_from_prev_sp = 0;
    cache->prev_sp                        = 0;
    cache->frame_base                     = 0;
    cache->delta_sp                       = 0;
    cache->old_sp_offset_from_fp          = 0;
    cache->is_leaf                        = FALSE;
    cache->uses_fp                        = FALSE;

    /* Allocate space for saved register info.  */
    cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);

    return cache;
}


/* Compute the previous frame's stack pointer (which is also the frame's ID's
   stack address), and this frame's base pointer.  */

static void
find_previous_stack_pointer (UnwindCache       *info,
                             struct frame_info *next_frame)
{
    ENTERARGS("next_frame = %p", next_frame);

    /* If the frame has a frame pointer.  */
    if (info->uses_fp)
    {
        ULONGEST     this_base;
        unsigned int i;

        /* The SP was moved to the FP. This indicates that a new frame
           was created. Get THIS frame's FP value by unwinding it from
           the next frame. The old contents of FP were saved in the location
           at the base of this frame, so this also gives us the address of
           the FP save location.  */
	this_base = frame_unwind_register_unsigned(next_frame, ARC_FP_REGNUM);
        info->frame_base                     = (CORE_ADDR) this_base;
        info->saved_regs[ARC_FP_REGNUM].addr = (long long) this_base;

        /* The previous SP is the current frame base + the difference between
           that frame base and the previous SP.  */
        info->prev_sp = info->frame_base + (CORE_ADDR) info->old_sp_offset_from_fp;

        for (i = ARC_ABI_FIRST_CALLEE_SAVED_REGISTER; i < ARC_ABI_LAST_CALLEE_SAVED_REGISTER; i++)
        {
            /* If this register has been saved, add the previous stack pointer
               to the offset from the previous stack pointer at which the
               register was saved, so giving the address at which it was saved.  */
            if (info->saved_regs_mask & (1 << i))
            {
                info->saved_regs[i].addr += info->prev_sp;

#ifdef DUMP_SAVED_REGISTERS
                /* This is a really useful debugging aid: we can debug a test
                   program which loads known values into the callee-saved
                   registers, then calls another function which uses those
                   registers (and hence must save them) then hits a breakpoint;
                   traversing the stack chain (e.g. with the 'where' command)
                   should then execute this code, and we should see those known
                   values being dumped, so showing that we have got the right
                   addresses for the save locations!  */
                {
                    unsigned int contents;

                    DEBUG("saved R%02d is at 0x%lx\n", i, (long unsigned int) info->saved_regs[i].addr);

                    if (target_read_memory((CORE_ADDR) info->saved_regs[i].addr,
                                           (gdb_byte*) &contents,
                                           BYTES_IN_REGISTER) == 0)
                    {
                        DEBUG("saved R%02d contents: 0x%0x\n", i, contents);
                    }
                }
#endif
            }
        }
    }
    else
    {
        ULONGEST this_sp;

        /* Get the stack pointer for this frame by getting the saved SP
           from the next frame.  */
 	this_sp = frame_unwind_register_unsigned (next_frame, ARC_SP_REGNUM);

        /* The previous SP is this frame's SP plus the known difference between
           the previous SP and this frame's SP (the delta_sp is negated as it is
           a negative quantity).  */
        info->prev_sp = (CORE_ADDR) (this_sp + (ULONGEST) (-info->delta_sp));

        /* Assume that the FP is this frame's SP.  */
        info->frame_base = (CORE_ADDR) this_sp;
    }

    /* If the function owning this frame is not a leaf function.  */
    if (!info->is_leaf)
    {
        /* Usually blink is saved above the callee save registers and below the
           space created for variable arguments. The quantity

                    info->blink_save_offset_from_prev_sp

           is negative, so adding it to the the previous SP gives the address of
           a location further down the stack from that SP.  */
        info->saved_regs[ARC_BLINK_REGNUM].addr =
            (LONGEST) (info->prev_sp + info->blink_save_offset_from_prev_sp);
    }
}


/* The workhorse : frame_unwind_cache for the ARC700 target.  */

static UnwindCache *
frame_unwind_cache (struct frame_info *next_frame,
                    void             **this_prologue_cache)
{
    ENTERMSG;

    if ((*this_prologue_cache) == NULL)
    {
        CORE_ADDR    entrypoint = frame_func_unwind(next_frame, NORMAL_FRAME);
        UnwindCache *cache      = create_cache(next_frame);

        /* Return the newly-created cache.  */
        *this_prologue_cache = cache;

        /* Prologue analysis does the rest... */

        /* Currently our scan prologue does not support getting input for the
           frame unwinder.  */
        (void) scan_prologue(entrypoint, next_frame, cache);
    }

    return *this_prologue_cache;
}


/* -------------------------------------------------------------------------- */
/*               local functions for decoding function prologues              */
/* -------------------------------------------------------------------------- */

/* This function determines whether the given register, which is being saved
   by a function prologue on the stack at a known offset from the current SP,
   is a callee-saved register.  If it is, the information in the frame unwind
   cache is updated.  */

static Boolean
is_callee_saved_register (unsigned int  reg,
                          int           offset,
                          UnwindCache * info)
{
    if (ARC_ABI_FIRST_CALLEE_SAVED_REGISTER <= reg && reg <= ARC_ABI_LAST_CALLEE_SAVED_REGISTER)
    {
        DEBUG("register R%02u saved\n", reg);

        if (info)
        {
            /* We can not determine the address of the location in the stack
               frame in which the register was saved, as we do not (yet) know
               the frame or stack pointers for the frame; so the most we can do
               is to record the offset from the old SP of that location, which
               we can compute as we know the offset of SP from the old SP, and
               the offset of the location from SP (which is the offset in the
               store instruction).

               N.B. the stack grows downward, so the store offset is positive,
                    but the delta-SP is negative, so the save offset is also
                    negative.

                                             |            |
                              old sp ------> |------------|
                            /                |            |  \
                            :                |            |  :
                            :                |            |  :    -ve
                            :                |            |  : save offset
                            :                |------------|  :
                    -ve     :                |  save loc  |  /
                  delta sp  :                |------------| <--- store address
                            :            /   |            |
                            :     +ve    :   |            |
                            :    store   :   |            |
                            :    offset  :   |            |
                            \            \   |            |
                              sp' ---------> |            |
                                             |            |
                                             |            |
                                             |------------| <---- frame base
                                             |            |
                                             |            |
                                             |            |
                                             |     |      |
                                                   |
                                                   V
                                               downwards

               where sp' is the stack pointer at the current point in the code */

            info->saved_regs[reg].addr = info->delta_sp + offset;

            /* We now know that this register has been saved, so set the
               corresponding bit in the save mask.  */
            info->saved_regs_mask |= (1 << reg);

            printFrameInfo("after callee register save", info, FALSE);

            return TRUE;
        }
    }

    return FALSE;
}


/* This function determines whether the given disassembled instruction may be
   part of a function prologue.  If it is, the information in the frame unwind
   cache may be updated.  */

static Boolean
is_in_prologue (UnwindCache *info, struct arcDisState *instr)
{
    /* Might be a push or a pop */
    if (instr->_opcode == 0x3)
    {
        if (instr->_addrWriteBack != (char) 0)
        {
            /* This is a st.a instruction.  */
            if (instr->ea_reg1 == ARC_ABI_STACK_POINTER)
            {
                if (instr->_offset == -4)
                {
                    /* This is a push something at SP.  */
                    /* Is it a push of the blink?  */
                    IS_PUSH_BLINK_FI(instr);

                    /* Is it a push for fp?  */
                    IS_PUSH_FP_FI(instr);
                }
                else
                {
                    if (instr->sourceType == ARC_REGISTER )
                    {
                        /* st.a <reg>, [sp,<offset>] */

                        if (is_callee_saved_register(instr->source_operand.registerNum,
                                                     instr->_offset,
                                                     info))
                        {
                            /* This is a push onto the stack, so change delta_sp.  */
                            info->delta_sp += instr->_offset;
                            return TRUE;
                        }
                    }
                }
           }
        }
        else
        {
            if (instr->sourceType == ARC_REGISTER )
            {
                /* Is this a store of some register onto the stack using the
                   stack pointer?  */
                if (instr->ea_reg1 == ARC_ABI_STACK_POINTER)
                {
                    /* st <reg>, [sp,offset] */

                    if (is_callee_saved_register(instr->source_operand.registerNum,
                                                 instr->_offset,
                                                 info))
                        /* This is NOT a push onto the stack, so do not change delta_sp.  */
                        return TRUE;
                }

                /* Is this the store of some register on the stack using the
                   frame pointer? We check for argument registers getting saved
                   and restored.  */
                if (instr->ea_reg1 == ARC_ABI_FRAME_POINTER)
                {
                    if (IS_ARGUMENT_REGISTER(instr->source_operand.registerNum))
                    {
                        /* Saving argument registers. Don't set the bits in the
                           saved mask, just skip.  */
                        return TRUE;
                    }
                }
            }
        }
    }

    else if (instr->_opcode == 0x4)
    {
        /* A major opcode 0x4 instruction.  */
        /* We are usually interested in a mov or a sub.  */
        IS_UPDATE_FP_FI(instr);
        IS_SUB_SP_FI(instr);
    }

    else if (instr->_opcode == 0x18)
    {
        /* sub_s sp,sp,constant */
        IS_SUB_SP_FI(instr);

        /* push_s blink */
        if (strcmp(instr->instrBuffer, "push_s") == 0)
        {
            if (strcmp(instr->operandBuffer, "blink") == 0)
            {
                if (info)
                {
                    /* SP is decremented by the push_s instruction (before it
                       stores blink at the stack location addressed by SP).  */
                    PUSH_BLINK(-BYTES_IN_REGISTER)
                }
                return TRUE;
            }
        }
        else if (strcmp(instr->instrBuffer, "st_s") == 0)
        {
            unsigned int reg;
            int          offset;

            if (sscanf(instr->operandBuffer, "r%u,[sp,%d]", &reg, &offset) == 2)
            {
                /* st_s <reg>,[sp,<offset>] */

                if (is_callee_saved_register(reg, offset, info))
                    /* This is NOT a push onto the stack, so do not change delta_sp.  */
                    return TRUE;
            }
        }
    }

    return FALSE;
}


/* Scan the prologue and update the corresponding frame cache for the frame
   unwinder for unwinding frames without debug info. In such a situation GDB
   attempts to parse the prologue for this purpose. This currently would attempt
   to parse the prologue generated by our gcc 2.95 compiler (we should support
   Metaware generated binaries at some suitable point of time).

   This function is called with:
      entrypoint : the address of the functon entry point
      next_frame : the next frame to be filled in (if need be)
      info       : the existing cached info.

   Returns: the address of the first instruction after the prologue.

   This function is called by our unwinder as well as from arc_skip_prologue
   in the case that it cannot detect the end of the prologue.

   'next_frame' and 'info' are NULL if this function is called from
   arc_skip_prologue in an attempt to discover the end of the prologue.
   In this case we don't fill in the 'info' structure that is passed in.

   TODOs:
      1. Support 32 bit normal frames generated by GCC 2.95
      2. Support 16 and 32 bit mixed frames generated by GCC 2.95
      3. Support 32 bit normal variadic function frames by GCC 2.95
      4. Support 32 bit normal frames from GCC 3.4.x with variadic args
      5. Support 16 and 32 bit normal frames from GCC 3.4.x with variadic args
      6. Support 16 and 32 bit mixed frames generated by GCC 3.4.x
      7. Support Metaware generated prologues
           (The difference is in the use of thunks to identify the saving and
            restoring of callee saves: may have to do some hackery even in
            next_pc, since the call is going to create its own set of problems
            with our stack setup).

   We attempt to use the disassembler interface from the opcodes library to do
   our disassembling.

   The usual 32 bit normal gcc -O0 prologue looks like this:

   Complete Prologue for all GCC frames (Cases #1 to #6 in TODOs above):

      sub  sp, sp, limm         ; space for variadic arguments
      st.a blink, [sp,-4]       ; push blink (if not a leaf function) - decrements sp
      sub  sp, sp , limm        ; (optional space creation for callee saves)
      st   r13, [sp]            ; push of first callee saved register
      st   r14, [sp,4]          ; push of next callee saved register
      ...
      st.a fp , [sp,-4]         ; push fp (if fp has to be saved) - decrements sp
      mov  fp , sp              ; set the current frame up correctly
      sub  sp , sp , #immediate ; create space for local vars on the stack   */

/* 3 instructions before and after callee saves, and max number of saves; assume each is 4-byte inst.  */
#define MAX_PROLOGUE_LENGTH   ((6 + (ARC_ABI_LAST_CALLEE_SAVED_REGISTER - ARC_ABI_FIRST_CALLEE_SAVED_REGISTER + 1)) * 4)

static CORE_ADDR
scan_prologue (CORE_ADDR          entrypoint,
               struct frame_info *next_frame,
               UnwindCache       *info)
{
    ENTERARGS("next_frame = %p, info = %p", next_frame, info);

    {
        /* Will be set to end of prologue.  */
        CORE_ADDR               prologue_ends_pc = entrypoint;
        struct disassemble_info di;

        /* An arbitrary limit on the length of the prologue. If next_frame is
           NULL this means that there was no debug info and we are called from
           arc_skip_prologue; otherwise, if we know the frame, we can find the
           pc within the function.

           N.B. that pc will usually be after the end of the prologue, but
                it could actually be within the prologue (i.e. execution has
                halted within the prologue, e.g. at a breakpoint); in that
                case, do NOT go beyond that pc, as the instructions at the
                pc and after have not been executed yet, so have had no effect!  */
        CORE_ADDR final_pc = (next_frame) ? frame_pc_unwind(next_frame)
                                          : entrypoint + MAX_PROLOGUE_LENGTH;

        if (info)
        {
            /* Assume that the function is a leaf function until we find out
               that it is not (i.e. when we find the 'push blink' instruction
               in the prologue).  */
            info->is_leaf = TRUE;

            /* No registers known to be saved, as yet.  */
            info->saved_regs_mask = 0;
        }

        /* Initializations to use the opcodes library.  */
        arc_initialize_disassembler(&di);

        DEBUG("Prologue PC: %lx\n", (unsigned long) prologue_ends_pc);
        DEBUG("Final    PC: %lx\n", (unsigned long) final_pc);

        /* Look at each instruction in the prologue.  */
        while (prologue_ends_pc < final_pc)
        {
            struct arcDisState current_instr = arcAnalyzeInstr(prologue_ends_pc, &di);

            printInsnState(current_instr);

            /* If this instruction is in the prologue, fields in the info will be updated,
               and the saved registers mask may be updated.  */
            if (!is_in_prologue(info, &current_instr))
            {
                /* Found a instruction that is not in the prologue.  */
                DEBUG("End of Prologue reached \n");
                break;
            }

            prologue_ends_pc += current_instr.instructionLen;
        }

        /* Means we were not called from arc_skip_prologue.  */
        if (!((next_frame == NULL) && (info == NULL)))
        {
            printFrameInfo("after prologue", info, FALSE);

            find_previous_stack_pointer(info, next_frame);

            /* The PC is found in blink (the actual register or located on the stack).  */
            info->saved_regs[ARC_PC_REGNUM] = info->saved_regs[ARC_BLINK_REGNUM];

            printFrameInfo("after previous SP found", info, TRUE);
        }

        return prologue_ends_pc;
    }
}


/* -------------------------------------------------------------------------- */
/*              local functions for handling function return values           */
/* -------------------------------------------------------------------------- */

/* This function gets the return value of a function from the registers used to
   return it, according to the convention used by the ABI.

   Parameters:
      type     : the information for the return type of the function
      regcache : the register cache holding the register contents
      valbuf   : a buffer to be filled with the return value
*/

static void
extract_return_value (struct type     *type,
                      struct regcache *regcache,
                      gdb_byte        *valbuf)

{
    unsigned int len = TYPE_LENGTH (type);

    ENTERMSG;

    if (len <= BYTES_IN_REGISTER)
    {
        ULONGEST val;

        /* Get the return value from one register.  */
        regcache_cooked_read_unsigned (regcache, ARC_ABI_RETURN_REGNUM, &val);
        store_unsigned_integer (valbuf, (int) len, val);

        DEBUG("returning 0x%08lX\n", (unsigned long) val);
    }
    else if (len <= BYTES_IN_REGISTER * 2)
    {
        ULONGEST low, high;

        /* Get the return value from two registers.  */
        regcache_cooked_read_unsigned (regcache, ARC_ABI_RETURN_LOW_REGNUM,  &low);
        regcache_cooked_read_unsigned (regcache, ARC_ABI_RETURN_HIGH_REGNUM, &high);

        store_unsigned_integer (valbuf,                     BYTES_IN_REGISTER,             low);
        store_unsigned_integer (valbuf + BYTES_IN_REGISTER, (int) len - BYTES_IN_REGISTER, high);

        DEBUG("returning 0x%08lX%08lX\n",
              (unsigned long) high, (unsigned long) low);
    }
    else
        error(_("%s: type length %u too large"), __FUNCTION__, len);
}


/* This function loads the return value of a function into the registers used to
   return it, according to the convention used by the ABI.

   Parameters:
      type     : the information for the return type of the function
      regcache : the register cache holding the register contents
      valbuf   : a buffer holding the return value
*/

static void
store_return_value (struct type     *type,
                    struct regcache *regcache,
                    const  gdb_byte *valbuf)
{
    unsigned int len = TYPE_LENGTH (type);

    ENTERMSG;

    if (len <= BYTES_IN_REGISTER)
    {
        ULONGEST val;

        /* Put the return value into one register.  */
        val = extract_unsigned_integer (valbuf, (int) len);
        regcache_cooked_write_unsigned (regcache, ARC_ABI_RETURN_REGNUM, val);

        DEBUG("storing 0x%08lX\n", (unsigned long) val);
    }
    else if (len <= BYTES_IN_REGISTER * 2)
    {
        ULONGEST low, high;

        /* Put the return value into  two registers.  */
        low  = extract_unsigned_integer (valbuf,                     BYTES_IN_REGISTER);
        high = extract_unsigned_integer (valbuf + BYTES_IN_REGISTER, (int) len - BYTES_IN_REGISTER);

        regcache_cooked_write_unsigned (regcache, ARC_ABI_RETURN_LOW_REGNUM,  low);
        regcache_cooked_write_unsigned (regcache, ARC_ABI_RETURN_HIGH_REGNUM, high);

        DEBUG("storing 0x%08lX%08lX\n",
              (unsigned long) high, (unsigned long) low);
    }
    else
        error(_("arc_store_return_value: type length too large."));
}


/* -------------------------------------------------------------------------- */
/*                 local functions for handling the stack frame               */
/* -------------------------------------------------------------------------- */

/* This is copied from file stack.c in the gdb sources.
   It identifies a frame from information (such as frame number) given by the
   user (in the frame_exp parameter).  */

static struct frame_info*
parse_frame_specification_1 (const char *frame_exp,
                             const char *message,
                             int        *selected_frame_p)
{
    int           numargs = 0;
    struct value *args[4];
    CORE_ADDR     addrs[ARRAY_SIZE (args)];

    if (frame_exp)
    {
        while (TRUE)
        {
            char           *addr_string;
            struct cleanup *cleanup;
            const char     *p;

            /* Skip leading white space.  */
            while (isspace (*frame_exp))
                frame_exp++;

            if (*frame_exp == '\0')
                break;

            /* Parse the argument, extract it, save it.  */
            for (p = frame_exp; (*p != '\0') && !isspace (*p); p++);

            addr_string = savestring (frame_exp, (size_t) (p - frame_exp));
            frame_exp   = p;
            cleanup     = make_cleanup (xfree, addr_string);

            /* NOTE: Parse and evaluate expression, but do not use
               functions such as parse_and_eval_long or
               parse_and_eval_address to also extract the value.
               Instead value_as_long and value_as_address are used.
               This avoids problems with expressions that contain
               side-effects.  */
            if (numargs >= (int) ARRAY_SIZE (args))
                error (_("Too many args in frame specification"));

            args[numargs++] = parse_and_eval (addr_string);

            do_cleanups (cleanup);
        }
    }

    /* If no args, default to the selected frame.  */
    if (numargs == 0)
    {
        if (selected_frame_p != NULL)
            (*selected_frame_p) = 1;
        return get_selected_frame (message);
    }

    /* None of the remaining use the selected frame.  */
    if (selected_frame_p != NULL)
        (*selected_frame_p) = 0;

    /* Assume the single arg[0] is an integer, and try using that to
       select a frame relative to current.  */
    if (numargs == 1)
    {
        int                level = (int) value_as_long (args[0]);
        struct frame_info *fid   = find_relative_frame (get_current_frame (), &level);

        if (level == 0)
            /* find_relative_frame was successful.  */
            return fid;
    }

    /* Convert each value into a corresponding address.  */
    {
        int i;
        for (i = 0; i < numargs; i++)
            addrs[i] = value_as_address (args[i]);
    }

    /* Assume that the single arg[0] is an address, use that to identify
       a frame with a matching ID.  Should this also accept stack/pc or
       stack/pc/special.  */
    if (numargs == 1)
    {
        struct frame_id id = frame_id_build_wild (addrs[0]);
        struct frame_info *fid;

        /* If (s)he specifies the frame with an address, he deserves
           what (s)he gets.  Still, give the highest one that matches.
           (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
           know).  */
        for (fid = get_current_frame ();
             fid != NULL;
             fid = get_prev_frame (fid))
        {
            if (frame_id_eq (id, get_frame_id (fid)))
            {
                while (frame_id_eq (id, frame_unwind_id (fid)))
                    fid = get_prev_frame (fid);
                return fid;
            }
        }
    }

    /* We couldn't identify the frame as an existing frame, but
       perhaps we can create one with a single argument.  */
    if (numargs == 1)
        return create_new_frame (addrs[0], 0);
    else if (numargs == 2)
        return create_new_frame (addrs[0], addrs[1]);
    else
        error (_("Too many args in frame specification"));
}


/* Return an array (and count) of the local variables and parameters declared
   in the function which owns the given frame.

   Parameters:
      frame    : the frame information for the function
      variables: a pointer to an existing array of variable information (may be NULL)
      count    : (IN/OUT) the total number of variables found
      callee   : TRUE if the function is a callee of another function

   Result:
      A pointer to an array containing one element for each parameter, and, if
      'callee' is FALSE, each local variable, of the function.  */

static LocalVariable*
find_variables (struct frame_info *frame,
                LocalVariable     *variables,
                unsigned int      *count,
                Boolean            callee)
{
    struct block *block = get_frame_block (frame, 0);
    unsigned int  vars  = *count;

    while (block)
    {
        struct dict_iterator iter;
        struct symbol       *sym;

        ALL_BLOCK_SYMBOLS (block, iter, sym)
        {
            Boolean   is_arg = (SYMBOL_CLASS(sym) == LOC_COMPUTED_ARG);
            CORE_ADDR addr;

            switch (SYMBOL_CLASS (sym))
            {
                case LOC_COMPUTED:
                case LOC_COMPUTED_ARG:
                    addr = SYMBOL_OPS (sym)->get_variable_address(sym, frame);

                    /* For callees, we are only interested in the arguments.  */
                    if ((addr != 0) && (!callee || is_arg))
                    {
                        struct type *type = SYMBOL_TYPE (sym);

                        vars++;
                        variables = xrealloc(variables, sizeof(LocalVariable) * vars);

                        if (variables)
                        {
                            LocalVariable *var = &variables[vars - 1];

                            var->name        = SYMBOL_PRINT_NAME (sym);
                            var->address     = addr;
                            var->is_callee   = callee;
                            var->is_argument = is_arg;
                            var->is_array    = (TYPE_CODE (type) == TYPE_CODE_ARRAY);
                            var->size        = SYMBOL_OPS (sym)->get_variable_size(sym, frame);

                            if (var->is_array)
                                var->element_size = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
                        }
                        else
                        {
                            *count = 0;
                            return NULL;
                        }
                    }
                    break;

                default:
                  /* Ignore symbols which are not locals.  */
                  break;
            }
        }

        /* After handling the function's top-level block, stop.  Don't continue
           to its superblock, the block of per-file symbols.  */
        if (BLOCK_FUNCTION (block))
            break;
        block = BLOCK_SUPERBLOCK (block);
    }

    *count = vars;
    return variables;
}


/* Return an array (and count) of the local variables declared in the function
   which owns the given frame, and also those declared in the function which is
   the callee (if any) of that function in the current call chain.  */

static LocalVariable*
find_local_variables (struct frame_info *frame, unsigned int *count)
{
    struct frame_info *callee = get_next_frame(frame);
    LocalVariable     *variables;

    *count = 0;

    variables = find_variables(frame, NULL, count, FALSE);

    if (callee)
        variables = find_variables(callee, variables, count, TRUE);

    return variables;
}


/* Try to add the name of a local variable or function parameter to a line of
   output, if a given address lies within the range of locations occupied by
   that data item.

   Parameters:
      line                   : the line in which any output is to be placed
      location               : the address of a location on the stack
      variables              : an array of local variables and parameters
      num_variables          : the number of elements in the array
      is_following_element   : set to TRUE if the location lies within an
                               array element, and it is not the 0th element
      elements_are_word_sized: set to TRUE if the array element is word-sized

   Returns TRUE if the given location holds a local variable or parameter
   (i.e. information has been added to the line of output).  */

static Boolean
add_local_name (char          *line,
                CORE_ADDR      location,
                LocalVariable *variables,
                unsigned int   num_variables,
                Boolean       *is_following_element,
                Boolean       *elements_are_word_sized)
{
    unsigned int i;

    *is_following_element    = FALSE;
    *elements_are_word_sized = FALSE;

    /* Look at each of the local variables / parameters in the array.  */
    for (i = 0; i < num_variables; i++)
    {
        LocalVariable *var   = &variables[i];
        int            index = -1;

        /* is the variable an array?  */
        if (var->is_array)
        {
            /* If we know the size of the array, and the size of its elements. */
            if (var->size > 0 && var->element_size > 0)
            {
                /* What is the offset of the given stack location from the start
                   of the array?  */
                int offset = (int) ((long int) location - (long int) var->address);

                /* Does that offset actually lie within the array?  */
                if (0 <= offset && offset < (int) var->size)
                {
                    /* Compute the index of the array element which contains the
                       location.  */
                    index = offset / var->element_size;
                }

                if (var->element_size == BYTES_IN_WORD)
                    *elements_are_word_sized = FALSE;
            }
        }

        /* If the variable starts in the given location, or the variable is an
           array and one of its elements contains the location. */
        if (var->address == location || index >= 0)
        {
            int n;

            /* What is the variable?  */
            if (var->is_callee)
                n = sprintf(line, _("callee parameter"));
            else if (var->is_argument)
                n = sprintf(line, _("parameter"));
            else
                n = sprintf(line, _("local variable"));

            line[n] = ' ';
            n++;
            n += sprintf(line + n, _("'%s'"),  var->name);
            line[n] = ' ';

            /* If it is an array element.  */
            if (index >= 0)
            {
                /* Add the array element index to the output.  */
                (void) sprintf(line + n, _("[%u]"), index);

                /* Is it an element which follows another element?  */
                *is_following_element = (index > 0);
            }
            else if (var->size > BYTES_IN_WORD)
            {
                /* It occupies more than one word.  */
                (void) sprintf(line + n + 1, _("(%u words)"),
                               WORDS_OCCUPIED(var->size));
            }

            return TRUE;
        }
     }

    return FALSE;
}


/* Try to identify the given frame, and output that identification.  */

static void
identify_frame (struct frame_info *frame)
{
    enum language          func_lang = language_unknown;
    char                  *func_name = NULL;
    char                  *demangled = NULL;
    struct symbol         *func;
    struct symtab_and_line sal;

    find_frame_sal (frame, &sal);
    func = get_frame_function (frame);

    /* Have we found the function owning the frame?  */
    if (func)
    {
        func_name = DEPRECATED_SYMBOL_NAME (func);
        func_lang = SYMBOL_LANGUAGE        (func);
    }
    else
    {
        struct minimal_symbol *msymbol;

        /* Try to find the symbol most closely associated with the PC
           corresponding to the frame.  */
        msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (frame));

        if (msymbol != NULL)
        {
            func_name = DEPRECATED_SYMBOL_NAME (msymbol);
            func_lang = SYMBOL_LANGUAGE        (msymbol);
        }
    }

    /* Have we found a name?  */
    if (func_name)
    {
        /* If user wants to see raw output, no problem.
           (demangle is a global flag which can be set by user command).  */
        if (demangle)
        {
            demangled = language_demangle (language_def (func_lang),
                                           func_name,
                                           DMGL_ANSI | DMGL_PARAMS);

            /* If the demangler fails, try the demangled name from the symbol
               table. That'll have parameters, but that's preferable to
               displaying a mangled name.  */
            if (demangled == NULL)
            {
                if (func == NULL)
                    func_name = _("<unknown function>");
                else
                    func_name = SYMBOL_PRINT_NAME (func);
            }
            else
                func_name = demangled;
        }
    }
    else
        func_name = _("<unknown function>");

    printf_filtered(_("Frame of function: %s"), func_name);
    if (sal.symtab)
        printf_filtered(_(" (%s:%d)"), sal.symtab->filename, sal.line);
    printf_filtered(NEW_LINE);

    if (demangled != NULL)
        xfree (demangled);
}


/* -------------------------------------------------------------------------- */
/*                       local functions called from gdb                      */
/* -------------------------------------------------------------------------- */

/*  Standard register type for the ARC platform.
    It would be builtin_type_uint32 until we consider the DSP extensions.  */

static struct type *
arc_register_type (struct gdbarch *gdbarch, int regnum)
{
    return builtin_type_uint32;
}


/* Skip the prologue for the function at pc.
   Returns the address of the first instruction after the prologue. */

static CORE_ADDR
arc_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
    CORE_ADDR function_addr, function_end = 0;
    char     *function_name;

   /* This is done by checking from the line information read from the DWARF,
      if possible; otherwise, we scan the function prologue to find its end.  */

    ENTERMSG;

    /* If we're in a dummy frame, don't even try to skip the prologue.  */
    if (deprecated_pc_in_call_dummy (pc))
        return pc;

    /* See what the symbol table says.  */
    if (find_pc_partial_function (pc, &function_name, &function_addr, &function_end))
    {
        /* Found a function.  */
        struct symbol *sym = lookup_symbol (function_name, NULL, VAR_DOMAIN, NULL, NULL);

        if ((sym != NULL) && SYMBOL_LANGUAGE (sym) != language_asm)
        {
            /* Don't use this trick for assembly source files.  */
            struct symtab_and_line sal = find_pc_line (function_addr, 0);

            if ((sal.line != 0) && (sal.end < function_end))
                return sal.end;
        }
    }

    /* Find the address of the first instruction after the prologue by scanning
       through it - no other information is needed, so pass NULL for the other
       parameters.  */
    return scan_prologue(pc, NULL, NULL);
}


/* Construct frame id for the normal frame.  */

static void
arc_frame_this_id (struct frame_info *next_frame,
                   void             **this_prologue_cache,
                   struct frame_id   *this_id)
{
    ENTERMSG;

    /* FIXME: to what should *this_id be set if the frame base can not be found? */

    {
        /* Find the entry point of the function which owns the frame.  */
        CORE_ADDR entrypoint = frame_func_unwind (next_frame, NORMAL_FRAME);

        /* This is meant to halt the backtrace at the entry point (_start)
           (it assumes that there is no code at a lower address).  */
        if (entrypoint > gdbarch_tdep (current_gdbarch)->lowest_pc)
        {
            UnwindCache *info = frame_unwind_cache (next_frame, this_prologue_cache);
            CORE_ADDR    base = info->prev_sp;

            /* Hopefully the prologue analysis either correctly determined the
               frame's base (which is the SP from the previous frame), or set
               that base to "NULL".  */

            if (base != 0)
            {
                /* Build the ID from the frame base address.  */
                *this_id = frame_id_build (base, entrypoint);

#if 0
                printf("*** Frame ID: %x ==> (%x %x %x)\n",
                       base,
                       this_id->stack_addr,
                       this_id->code_addr,
                       this_id->special_addr);
#endif
            }
        }
    }
}


/* Unwind and obtain the register information.  */

static void
arc_frame_prev_register (struct frame_info *next_frame,
                         void             **this_prologue_cache,
                         int                regnum,
                         int               *optimized,
                         enum lval_type    *lval,
                         CORE_ADDR         *addr,
                         int               *realnum,
                         gdb_byte          *buffer)
{
    ENTERARGS("regnum %d ", regnum);

    {
        UnwindCache *info = frame_unwind_cache (next_frame, this_prologue_cache);

        /* If we are asked to unwind the PC, then we need to return blink
           instead: the saved value of PC points into this frame's function's prologue,
           not the next frame's function's resume location.  */
        if (regnum == ARC_PC_REGNUM)
            regnum = ARC_BLINK_REGNUM;

        /* SP is generally not saved to the stack, but this frame is identified
           by next_frame's stack pointer at the time of the call. The value was
           already reconstructed into prev_sp.  */
        if (regnum == ARC_SP_REGNUM)
        {
            /* This value is not an L-value, i.e. it can not be changed, because
               it is implicit in the structure of the call-chain.  */
            *lval = not_lval;

            if (buffer)
                store_unsigned_integer (buffer, BYTES_IN_REGISTER, info->prev_sp);
            return;
        }

        trad_frame_get_prev_register (next_frame,
                                      info->saved_regs,
                                      regnum,
                                      optimized,
                                      lval,
                                      addr,
                                      realnum,
                                      buffer);

        DEBUG("-*-*-*\n Regnum = %d, buffer = %p\n", regnum, buffer);
    }
}


/* This function is passed to gdb to enable it to unwind frames.  */

static const struct frame_unwind *
arc_frame_sniffer (struct frame_info *next_frame)
{
    static const struct frame_unwind arc_frame_unwind =
    {
        NORMAL_FRAME,                // type
        arc_frame_this_id,           // this_id
        arc_frame_prev_register,     // prev_register
        NULL,                        // unwind_data
        NULL,                        // sniffer
        NULL,                        // prev_pc
        NULL                         // dealloc_cache
    };

    return &arc_frame_unwind;
}


/* Get the breakpoint which is appropriate for address at which it is to be set.

   Return whatever is in the ARC-private tdep structure (this has been set up
   according to the correct target / architecture chosen).

   Fortunately, the ARC processor does not have separate instruction sets (like
   the ARM's normal 32-bit and 16-bit Thumb instructions), so the bp instruction
   to be used does not depend on the address (although the ARC does have both
   16- and 32-bit instructions, they may be freely intermixed).  */

static const unsigned char *
arc_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
{
    struct gdbarch_tdep *tdep = gdbarch_tdep       (gdbarch);
    int    end                = gdbarch_byte_order (gdbarch);

    /* Return the breakpoint instruction length.  */
    *lenptr = (int) tdep->breakpoint_size;

    /* Return the breakpoint instruction code.  */
    if (end == BFD_ENDIAN_LITTLE)
        return tdep->le_breakpoint_instruction;
    if (end == BFD_ENDIAN_BIG)
        return tdep->be_breakpoint_instruction;

    internal_error (__FILE__, __LINE__, "target endianness is not known");
}


/* Determine whether the given register is a member of the given group.

   Returns 0, 1, or -1:
      0 means the register is not in the group.
      1 means the register is in the group.
     -1 means the tdep has nothing to say about this register and group.  */

static int
arc_register_reggroup_p (struct gdbarch  *gdbarch,
                         int              regnum,
                         struct reggroup *group)
{
    struct gdbarch_tdep *tdep        = gdbarch_tdep (gdbarch);
    int                  tdep_answer = tdep->register_reggroup_p (regnum, group);

    /* If the configuration-specific tdep knows about this register.  */
    if (tdep_answer != -1)
        return tdep_answer;

    if (group == all_reggroup)
        return 1;

    if (group == save_reggroup || group == restore_reggroup)
    {
        /* Don't save/restore read-only registers.  */
	return (!gdbarch_cannot_store_register(current_gdbarch, regnum));
    }

    if (group == system_reggroup)
    {
        if (regnum == ARC_ILINK1_REGNUM ||
            regnum == ARC_ILINK2_REGNUM)
            return 1;

        return 0;
    }

    internal_error(__FILE__, __LINE__, _("bad register group"));
    return 0;
}


/* This function is used by the DWARF-2 frame sniffer.
   It is the architecture-specific register state initialization function:
   it tells gdb how to find certain registers in the DWARF-2 Call Frame Information.  */

static void
arc_dwarf2_frame_init_reg (struct gdbarch                *gdbarch,
                           int                            regnum,
                           struct dwarf2_frame_state_reg *reg,
                           struct frame_info             *info)
{
//  ENTERARGS("Regno no:%d, 0x%x", regnum, (unsigned int) regnum);

    /* Make sure that we know the number of the PC!  */
    arc_check_pc_defined(gdbarch);

    /* The return address column.  */
    if (regnum == ARC_PC_REGNUM)
        reg->how = DWARF2_FRAME_REG_RA;

    /* The call frame address.  */
    if (regnum == ARC_SP_REGNUM)
        reg->how = DWARF2_FRAME_REG_CFA;
}


/* Unwind the frame to find the previous frame's PC.  */

static CORE_ADDR
arc_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
    ULONGEST pc;

    /* Make sure that we know the number of the PC!  */
    arc_check_pc_defined(gdbarch);

    pc = frame_unwind_register_unsigned (next_frame, ARC_PC_REGNUM);

    DEBUG("unwind PC: 0x%08lx\n", (unsigned long) pc);

    return (CORE_ADDR) pc;
}


/* Unwind the frame to find the previous frame's SP.  */

static CORE_ADDR
arc_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
    ULONGEST sp;

    sp  = frame_unwind_register_unsigned (next_frame, ARC_SP_REGNUM);

    DEBUG("unwind SP: 0x%08lx\n", (unsigned long) sp);

    return (CORE_ADDR) sp;
}


/* This function returns the convention used by the ABI for returning a result
   of the given type from a function; it may also be required to:

     a) set the return value (this is for the situation where the debugger user
        has issued a "return <value>" command to request immediate return from
        the current function with the given result; or

     b) get the return value ((this is for the situation where the debugger user
        has executed a "call <function>" command to execute the specified
        function in the target program, and that function has a non-void result
        which must be returned to the user.

  Parameters:
      gdbarch : gdbarch structure for the backend to use if needed
      valtype : the information for the return type of the function
      regcache: the register cache to be used for altered register values
      readbuf : if non-NULL, read the return value into this buffer
      writebuf: if non-NULL, write the return value from this buffer
 */

static enum return_value_convention
arc_return_value (struct gdbarch  *gdbarch,
                  struct type     *valtype,
                  struct regcache *regcache,
                  gdb_byte        *readbuf,
                  const gdb_byte  *writebuf)
{
    ENTERARGS("readbuf = %p, writebuf = %p", readbuf, writebuf);

    {
        /* If the return type is a struct, or a union, or would occupy more
           than two registers, the ABI uses the "struct return convention": the
           calling function passes a hidden first parameter to the callee (in R0).
           That parameter is the address at which the value being returned
           should be stored.  Otherwise, the result is returned in registers.  */
        Boolean is_struct_return = (TYPE_CODE   (valtype) == TYPE_CODE_STRUCT ||
                                    TYPE_CODE   (valtype) == TYPE_CODE_UNION  ||
                                    TYPE_LENGTH (valtype) > 2 * BYTES_IN_REGISTER);

        /* case a) */
        if (writebuf != NULL)
        {
            /* gdb should not ask us to set a struct return value: it should
               know the struct return location and write the value there
               itself.  */
            gdb_assert (!is_struct_return);
            store_return_value (valtype, regcache, writebuf);
        }

        /* case b) */
        if (readbuf != NULL)
        {
            /* gdb should not ask us to get a struct return value: it should
               know the struct return location and read the value from there
               itself.  */
            gdb_assert (!is_struct_return);
            extract_return_value (valtype, regcache, readbuf);
        }

        return (is_struct_return) ? RETURN_VALUE_STRUCT_CONVENTION
                                  : RETURN_VALUE_REGISTER_CONVENTION;
    }
}


/* Assuming that next_frame->prev is a dummy, return the frame ID of that dummy
   frame.  The frame ID's base needs to match the TOS value saved by
   save_dummy_frame_tos() (!!!! WHAT IS THIS???), and the PC to match the dummy
   frame's breakpoint.  */

static struct frame_id
arc_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
    return frame_id_build (arc_unwind_sp (gdbarch, next_frame),
                           frame_pc_unwind (next_frame));
}


/* Signal Trampoline Frame Unwinder.
   These unwinders allow frame unwinding to happen from within signal handlers.  */

static UnwindCache *
arc_sigtramp_frame_cache (struct frame_info *next_frame,
                          void             **this_cache)
{
    ENTERMSG;

    if (*this_cache == NULL)
    {
        struct gdbarch_tdep *tdep  = gdbarch_tdep (current_gdbarch);
        UnwindCache         *cache = create_cache(next_frame);
        gdb_byte             buf[BYTES_IN_REGISTER];

        *this_cache = cache;

        /* Get the stack pointer and use it as the frame base.  */
        frame_unwind_register (next_frame, ARC_SP_REGNUM, buf);
        cache->frame_base = (CORE_ADDR) extract_unsigned_integer (buf, BYTES_IN_REGISTER);

        /* If the ARC-private target-dependent info has a table of offsets of
           saved register contents within a O/S signal context structure.  */
        if (tdep->sc_reg_offset)
        {
            /* Find the address of the sigcontext structure.  */
            CORE_ADDR    addr = tdep->sigcontext_addr (next_frame);
            unsigned int i;

            /* For each register, if its contents have been saved within the
               sigcontext structure, determine the address of those contents.  */
            for (i = 0; i < tdep->sc_num_regs; i++)
                if (tdep->sc_reg_offset[i] != REGISTER_NOT_PRESENT)
                    cache->saved_regs[i].addr = (LONGEST) (addr + tdep->sc_reg_offset[i]);
        }
    }

    return *this_cache;
}


/* Construct id for the given frame.  */

static void
arc_sigtramp_frame_this_id (struct frame_info *next_frame,
                            void             **this_cache,
                            struct frame_id   *this_id)
{
    UnwindCache *cache;

    ENTERMSG;

    cache = arc_sigtramp_frame_cache (next_frame, this_cache);

    *this_id = frame_id_build (cache->frame_base, frame_pc_unwind (next_frame));
}


/* Retrieve the value of the register in the frame.  */

static void
arc_sigtramp_frame_prev_register (struct frame_info *next_frame,
                                  void             **this_cache,
                                  int                regnum,
                                  int               *optimizedp,
                                  enum lval_type    *lvalp,
                                  CORE_ADDR         *addrp,
                                  int               *realnump,
                                  gdb_byte          *valuep)
{
    ENTERMSG;

    {
        struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);

        /* Make sure we've initialized the cache.  */
        UnwindCache *cache = arc_sigtramp_frame_cache (next_frame, this_cache);

        /* On a signal, the PC is in ret.  */
        if (regnum == ARC_PC_REGNUM)
            regnum = tdep->pc_regnum_in_sigcontext;

        trad_frame_get_prev_register (next_frame,
                                      cache->saved_regs,
                                      regnum,
                                      optimizedp,
                                      lvalp,
                                      addrp,
                                      realnump,
                                      valuep);
    }
}


static const struct frame_unwind *
arc_sigtramp_frame_sniffer (struct frame_info *next_frame)
{
    ENTERMSG;

    {
        struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (next_frame));

        /* We don't even bother if we don't have a sigcontext_addr handler.  */
        if ((tdep->sigcontext_addr != NULL) &&
            (tdep->is_sigtramp     != NULL) &&
            tdep->is_sigtramp (next_frame))
        {
            static const struct frame_unwind arc_sigtramp_frame_unwind =
            {
                SIGTRAMP_FRAME,                   // type
                arc_sigtramp_frame_this_id,       // this_id
                arc_sigtramp_frame_prev_register, // prev_register
                NULL,                             // unwind_data
                NULL,                             // sniffer
                NULL,                             // prev_pc
                NULL                              // dealloc_cache
            };

            return &arc_sigtramp_frame_unwind;
        }

        return NULL;
    }
}


/* Allow calls to be made to functions defined in the debuggee (A.K.A dummy calls).

   Parameters:
      gdbarch      : gdbarch structure for the backend to use if needed.
      function     : the function to be called
      regcache     : the register cache to be used for altered register values
      bp_addr      : return address for the breakpoint.
      nargs        : the number of arguments to the function
      args         : the arguments to be passed to the function
      sp           : current value of SP.
      struct_return: 1 if structures are returned by the function.
      struct_addr  : hidden address for returning a struct.  */

static CORE_ADDR
arc_push_dummy_call (struct gdbarch  *gdbarch,
                     struct value    *function,
                     struct regcache *regcache,
                     CORE_ADDR        bp_addr,
                     int              nargs,
                     struct value   **args,
                     CORE_ADDR        sp,
                     int              struct_return,
                     CORE_ADDR        struct_addr)

{
    int arg_reg = ARC_ABI_FIRST_ARGUMENT_REGISTER;

    ENTERARGS("nargs = %d, struct_return = %d", nargs, struct_return);

    /* Push the return address.  */
    regcache_cooked_write_unsigned (regcache, ARC_BLINK_REGNUM, bp_addr);

    DEBUG("set BLINK = %X\n", (unsigned int) bp_addr);

    /* Are we returning a value using a structure return instead of a normal
       value return? If so, struct_addr is the address of the reserved space
       for the return structure to be written on the stack, and that address
       is passed to that function as a hidden first argument.  */

    if (struct_return)
    {
        /* Pass the return address in the first argument register.  */
        regcache_cooked_write_unsigned (regcache, arg_reg, struct_addr);

        DEBUG("struct return address 0x%08lX passed in R%d", struct_addr, arg_reg);

        arg_reg++;
    }

    /* If the function has arguments.  */
    if (nargs > 0)
    {
        Boolean      big_endian  = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG;
        unsigned int total_space = 0;
        gdb_byte    *memory_image;
        gdb_byte    *data;
        int          i;

        /* How much space do the arguments occupy in total?
           N.B. must round each argument's size up to an integral number of words.  */
        for (i = 0; i < nargs; i++)
        {
            unsigned int len   = TYPE_LENGTH (value_type (args[i]));
            unsigned int space = ROUND_UP_TO_WORDS(len);

            total_space += space;

            DEBUG("function arg[%d]: %d bytes -> %d\n", i, len, space);
        }

        /* Allocate a buffer to hold a memory image of the arguments.  */
        memory_image = XCALLOC((size_t) total_space, gdb_byte);
        if (memory_image == NULL)
        {
            /* could not do the call! */
            return 0;
        }

        /* Now copy all of the arguments into the buffer, correctly aligned.  */
        data = memory_image;
        for (i = 0; i < nargs; i++)
        {
            unsigned int len    = TYPE_LENGTH (value_type (args[i]));
            unsigned int space  = ROUND_UP_TO_WORDS(len);
            gdb_byte*    actual = data;
            unsigned int w;

            /* Parameters smaller than a word are normally aligned by gcc to the
               least significant byte, so if we have a big-endian target we put
               the data at the end of the word rather than at the start.  */
            if ((len < BYTES_IN_WORD) && big_endian)
               actual += BYTES_IN_WORD - len;

            (void) memcpy(actual, value_contents (args[i]), (size_t) len);

            DEBUG("function arg[%d] =", i);
            for (w = 0; w < space / BYTES_IN_WORD; w++)
                DEBUG(" 0x%08X", *((int*) data + w));
            DEBUG("\n");

            data += space;
        }

        /* Now load as much as possible of the memory image into registers.  */
        data = memory_image;
        while (arg_reg <= ARC_ABI_LAST_ARGUMENT_REGISTER)
        {
            ARC_RegisterContents contents = *(ARC_RegisterContents*) data;

            DEBUG("passing 0x%08X in register R%d\n", (unsigned int) contents, arg_reg);

            /* Convert to target byte order if necessary.  */
            if (HOST_AND_TARGET_ENDIANNESS_DIFFER(gdbarch))
            {
                contents = __bswap_32(contents);
                DEBUG("byte-swapped to 0x%08X\n", contents);
            }

            regcache_cooked_write_unsigned (regcache,
                                            arg_reg,
                                            (ULONGEST) contents);

            data        += BYTES_IN_REGISTER;
            total_space -= BYTES_IN_REGISTER;

            /* If all the data is now in registers.  */
            if (total_space == 0)
                break;

            arg_reg++;
        }

        /* If there is any data left, push it onto the stack (in a single write operation).  */
        if (total_space > 0)
        {
            DEBUG("passing %d bytes on stack\n", total_space);

            sp -= total_space;
            write_memory (sp, data, (int) total_space);
        }

        xfree(memory_image);
    }

    /* Finally, update the SP register.  */
    regcache_cooked_write_unsigned (regcache, ARC_SP_REGNUM, sp);

    DEBUG("set SP = %X\n", (unsigned int) sp);

    return sp;
}


/* Align frame.  */

static CORE_ADDR
arc_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
{
    /* Align to the normal alignment on the stack).  */
    return WORD_ALIGNED(sp);
}


/* Print interesting information about the floating point processor
   (if present) or emulator.  */

static void
arc_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
                      struct frame_info *frame, const char *args)
{
    printf(_("Software FPU\n"));
}


/* Set the main_name to "_main" if required.
   This is set as an observer of inferior_created.  */

static void
arc_set_main_name (struct target_ops *objfile, int from_tty)
{
    /* Old ARC toolchains prepend an underscore to symbol names.  If there is
       an _main but no main, then we're probably debugging a binary that was
       made with the old toolchain.  */
    struct minimal_symbol *umainsym = lookup_minimal_symbol ("_main", NULL, NULL);
    struct minimal_symbol *mainsym  = lookup_minimal_symbol ("main",  NULL, NULL);

    if ((umainsym != NULL) && (mainsym == NULL))
    {
        set_main_name ("_main");
    }

    /* If we don't have any symbols, the default, i.e. "main", will get used.  */
}


/* This initialization function is called by gdb.
   See gdbarch.h for a description of its parameters.  */

static struct gdbarch*
arc_gdbarch_init (struct gdbarch_info  info,
                  struct gdbarch_list *arches)
{
    /* Allocate the ARC-private target-dependent information structure, and the
       gdb target-independent information structure.  */
    struct gdbarch_tdep *tdep    = xmalloc (sizeof (struct gdbarch_tdep));
    struct gdbarch      *gdbarch = gdbarch_alloc (&info, tdep);

    memset(tdep, 0, sizeof(*tdep));

    /* Put stuff in gdbarch. */

    /* Breakpoint manipulation.  */
    set_gdbarch_breakpoint_from_pc  (gdbarch, arc_breakpoint_from_pc);
    set_gdbarch_decr_pc_after_break (gdbarch, 0);

    info.osabi = CONFIG_OSABI;
    gdbarch_init_osabi(info, gdbarch);

    /* Characters are unsigned by default.  */
    set_gdbarch_char_signed (gdbarch, 0);

    set_gdbarch_sp_regnum        (gdbarch, ARC_SP_REGNUM);
    set_gdbarch_register_type    (gdbarch, arc_register_type);
    set_gdbarch_print_float_info (gdbarch, arc_print_float_info);

    /* Advance PC across function entry code.  */
    set_gdbarch_skip_prologue (gdbarch, arc_skip_prologue);

    /* Hook in the Dwarf-2 frame sniffer.  */
    dwarf2_frame_set_init_reg   (gdbarch, arc_dwarf2_frame_init_reg);
    frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);

    /* Signal frames.  */
    frame_unwind_append_sniffer (gdbarch, arc_sigtramp_frame_sniffer);

    /* The stack grows downward.  */
    set_gdbarch_inner_than      (gdbarch, core_addr_lessthan);
    set_gdbarch_unwind_pc       (gdbarch, arc_unwind_pc);
    set_gdbarch_unwind_sp       (gdbarch, arc_unwind_sp);
    set_gdbarch_unwind_dummy_id (gdbarch, arc_unwind_dummy_id);
    frame_unwind_append_sniffer (gdbarch, arc_frame_sniffer);
    set_gdbarch_return_value    (gdbarch, arc_return_value);

    /* Add the ARC register groups.  */
    reggroup_add (gdbarch, general_reggroup);
    reggroup_add (gdbarch, all_reggroup);
    reggroup_add (gdbarch, system_reggroup);

    set_gdbarch_register_reggroup_p (gdbarch, arc_register_reggroup_p);

    set_gdbarch_cannot_step_breakpoint (gdbarch, 1);
    set_gdbarch_frame_align(gdbarch, arc_frame_align);

    /* Dummy Frame handling.  */
    set_gdbarch_push_dummy_call     (gdbarch, arc_push_dummy_call);
    set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);

    /* N.B. we do not want to call arcompact_get_disassembler at this point, as we do
            not as yet have an executable file, so do not know whether we want
            the disassembler for the A4 architecture (still supported by the
            opcodes library!) or the one for the ARCompact architecture; also,
            it is better to pass the arcompact_get_disassembler function a valid bfd
            structure, rather than a faked one, so that it can read the ARC-
            specific sections in the ELF file (for whatever reason...).

            So just set up a dummy disassembler at this point (gdb requires that
            *some* disassembler is defined for an architecture), and set up a
            callback which will set up the appropriate disassembler once an
            executable file has been selected for debugging.  */

#if 0
    {
        /* The arc libopcodes wants abfd so that it can find out what CPU
           extensions are there.  */
        bfd abfd;

        abfd.sections = NULL;

        set_gdbarch_print_insn(gdbarch, arcompact_get_disassembler(&abfd));
    }
#endif
    set_gdbarch_print_insn(gdbarch, dummy_disassembler);
    (void) observer_attach_new_objfile(set_disassembler);

    /* Set main_name to _main if necessary.  Ideally we'd want a hook that
       gets called when symbols are loaded, but it seems there isn't one; so
       we'll use this.  This will not work if the user does "target remote
       ..." and then "add-symbol-file ...".  */
    (void) observer_attach_inferior_created (arc_set_main_name);

    /* Initialize the target-dependent modules (if any).  */
    CONFIG_INIT_TDEP

    /* Return a pointer to the new object - indicates that a new architecture
       has been created.  */
    return gdbarch;
}


static void
arc_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
{
    /* Do nothing.  */
}


/* -------------------------------------------------------------------------- */
/*                     local functions implementing commands                  */
/* -------------------------------------------------------------------------- */

/* <command>  [ <frame> ]
   Display annotated stack frame.  */

static void
arc_show_stack_frame_command (char *arg, int from_tty)
{
    struct frame_info *fi;
    gdb_byte           value[MAX_REGISTER_SIZE];
    CORE_ADDR          pc, fp, sp, old_sp;
    CORE_ADDR          addr;
    enum lval_type     lval;
    int                optimized;
    int                realnum;
    int                frame_size;
    unsigned int      *frame_contents;
    LocalVariable     *variables;
    unsigned int       num_variables;

    /* Find the frame.  */
    fi = parse_frame_specification_1 (arg, _("No stack."), NULL);
    gdb_assert(fi != NULL);

    /* Find out PC, FP and SP for the frame.  */
    pc = get_frame_pc(fi);
    sp = get_frame_sp(fi);
    get_frame_register(fi, ARC_FP_REGNUM, value);
    fp = (CORE_ADDR) extract_unsigned_integer (value, BYTES_IN_REGISTER);

    DEBUG("*** PC = %x, FP = %x, SP = %x\n", (unsigned int) pc, (unsigned int) fp, (unsigned int) sp);

    if (pc == 0)
    {
        warning(_("invalid frame"));
        return;
    }

    frame_register_unwind (fi, ARC_SP_REGNUM, &optimized, &lval, &addr, &realnum, value);
    old_sp = (CORE_ADDR) extract_unsigned_integer (value, BYTES_IN_REGISTER);

    /* Find the local variables and parameters.  */
    variables = find_local_variables(fi, &num_variables);

    printf_filtered(NEW_LINE);
    identify_frame(fi);

    DEBUG(_("\n\n*** FRAME: 0x%x .. 0x%x\n\n"), (unsigned int) sp, (unsigned int) (old_sp - 1));

    frame_size = (int) (old_sp - sp);

    frame_contents = xmalloc((size_t) frame_size);

    if (frame_contents)
    {
        /* Read all of the frame's contents from target memory.  */
        if (target_read_memory(sp, (gdb_byte*) frame_contents, frame_size) == 0)
        {
            int          numregs       = ARC_TOTAL_REGS;
            int          i             = frame_size / BYTES_IN_WORD - 1;
            unsigned int the_same      = 0;
            unsigned int previous_word = 0;
            Boolean      first_word    = TRUE;
            Boolean      is_following_element;
            Boolean      elements_are_word_sized;

            addr = old_sp - BYTES_IN_WORD;

            printf_filtered(NEW_LINE);

            /* Traverse the frame from high address to low address, one word at a time.  */
            while (i >= 0)
            {
                unsigned int this_word = frame_contents[i];
                Boolean      print     = first_word;        /* Always print the first word. */
                char         line[256];
                int          n;

                /* Start with a blank line.  */
                (void) memset(line, (int) ' ', sizeof(line));

                /* Does FP and/or SP address this particular stack location?  */
                if (addr == sp && fp == sp)
                {
                    (void) strcpy(line + 14, _("SP/FP ===> "));
                    line[25] = ' ';
                    print = TRUE;
                }
                else if (addr == sp)
                {
                    (void) strcpy(line + 17, _("SP ===> "));
                    line[25] = ' ';
                    print = TRUE;
                }
                else if (addr == fp)
                {
                    (void) strcpy(line + 17, _("FP ===> "));
                    line[25] = ' ';
                    print = TRUE;
                }

                /* Does this stack location hold a local variable or parameter?  */
                if ((add_local_name(line + 38,
                                    addr,
                                    variables,
                                    num_variables,
                                    &is_following_element,
                                    &elements_are_word_sized)))
                {
                    /* Yes - so we want to print it (but this may be revised below!).  */
                    print = TRUE;
                }
                else
                {
                    int r;

                    /* Does this location hold a saved register?  */
                    for (r = 0; r < numregs; r++)
                    {
                        if (r != ARC_SP_REGNUM &&
                            gdbarch_register_reggroup_p (current_gdbarch, r, all_reggroup))
                        {
                            CORE_ADDR saved_addr;

                            /* Find out the location of the saved register without
                               fetching the corresponding value.  */
                            frame_register_unwind (fi, r, &optimized, &lval, &saved_addr, &realnum, NULL);

                            if (!optimized && lval == lval_memory && saved_addr == addr)
                            {
                                (void) sprintf(line + 38, _("saved register '%s'"), gdbarch_register_name(current_gdbarch, r));
                                print = TRUE;
                                break;
                            }
                        }
                    }
                }

                /* Do we think we need to print out the line?  */
                if (print)
                {
                    /* If the location is a non-zeroth word-sized array element,
                       and this word is the same as the previous word.  */
                    if (is_following_element && elements_are_word_sized && (this_word == previous_word))
                    {
                        /* No need to print it - one more word the same!  */
                        the_same++;
                        print = FALSE;
                    }
                }
                else
                {
                    /* N.B. this will not be the first word (since print is FALSE) */

                    /* This location does not hold anything "interesting",  but
                       if this word is not the same as the previous word, we
                       want to print it. */
                    if (this_word == previous_word)
                        the_same++;
                    else
                        print = TRUE;
                }

                /* OK, now we really know whether we need to print out the line.  */
                if (print)
                {
                    n = sprintf(line, _("0x%08X:"), (unsigned int) addr);
                    line[n] = ' ';

                    n = sprintf(line + 25, "%08X", this_word);
                    line[25 + n] = ' ';

                    n = (int) sizeof(line) - 1;
                    while (line[n] == ' ') n--;
                    line[n + 1] = '\0';

                    /* If we did not print the previous word because it was the
                       same as the word before, but not the same as any preceding
                       words, print it now (there is no point in outputting a
                       message which says simply "... 1 words omitted" - we might
                       just as well print out the word!  */
                    if (the_same == 1)
                        printf_filtered(_("0x%08X:              %08X\n"), (unsigned int) addr + BYTES_IN_WORD, previous_word);
                    else if (the_same != 0)
                        /* 2 or more words the same... */
                        printf_filtered(_("... %u words omitted\n"), the_same);

                    /* Now print out the line with the current word (and other information).  */
                    printf_filtered(_("%s\n"), line);

                    /* No words omitted.  */
                    the_same = 0;
                }

                first_word    = FALSE;
                previous_word = this_word;

                addr -= BYTES_IN_WORD;
                i--;
            }

            printf_filtered(NEW_LINE);
        }

        xfree(frame_contents);
    }

    xfree(variables);
}


/* -------------------------------------------------------------------------- */
/*                               externally visible functions                 */
/* -------------------------------------------------------------------------- */

/* Initialize the module. This function is called from the gdb core on start-up.  */

void
_initialize_arc_tdep (void)
{
    /* Register the ARC processor architecture with gdb, providing an
       initialization function and a dump function; 'bfd_arch_arc' is
       an enumeration value specifically denoting the ARC architecture.  */
    gdbarch_register(bfd_arch_arc, arc_gdbarch_init, arc_dump_tdep);

    /* Register ARC-specific commands with gdb.  */

    add_setshow_boolean_cmd(DEBUG_COMMAND,
                            no_class,
                            &arc_debug_target,
                            _("Set whether to print ARC debug messages.\n"),
                            _("Show whether to print ARC debug messages.\n"),
                            _("If set debug messages are printed.\n"),
                            NULL,
                            NULL,
                            &setlist,
                            &showlist);

    (void) add_cmd(SHOW_FRAME_COMMAND,
                   class_obscure,
                   arc_show_stack_frame_command,
                   _("Display the stack frame with annotation.\n"
                     SHOW_FRAME_COMMAND_USAGE
                     "<FRAME> may be the number or address of a frame.\n"),
                   &cmdlist);
}


/* Initialize the info structure to enable the disassembler to be used.  */

void
arc_initialize_disassembler (struct disassemble_info *info)
{
    /* N.B. this type cast is not strictly correct: the return types differ!  */
    init_disassemble_info(info, gdb_stdout, (fprintf_ftype) fprintf_filtered);
    info->arch             = gdbarch_bfd_arch_info(current_gdbarch)->arch;
    info->mach             = gdbarch_bfd_arch_info(current_gdbarch)->mach;
    info->endian           = gdbarch_byte_order   (current_gdbarch);
    info->read_memory_func = read_memory_for_disassembler;
}

/******************************************************************************/