gdb/insight for ARCompact (from Richard Stuckey)arc-insight_6_8-branch

1 files changed, 1787 insertions, 0 deletions

diff --git a/gdb/arc-xiss.c b/gdb/arc-xiss.c
new file mode 100755
index 0000000..2319f36
--- /dev/null
+++ b/gdb/arc-xiss.c
@@ -0,0 +1,1787 @@
+/* Target dependent code for ARC processor family, for GDB, the GNU debugger.
+
+   Copyright 2009 Free Software Foundation, Inc.
+
+   Contributed by ARC International (www.arc.com)
+
+   Authors:
+      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 creates an instance of a gdb 'target_ops' structure which  */
+/*     contains information and operations for debugging using the ARC xISS   */
+/*     (Fast Instruction Set Simulator) as the target.                        */
+/*                                                                            */
+/* Instruction Tracing:                                                       */
+/*     Two different kind of instruction tracing are supported:               */
+/*                                                                            */
+/*     1) a minimal trace which records only the address of each instruction  */
+/*        which is executed;                                                  */
+/*                                                                            */
+/*     2) a more detailed trace which includes the ordinal number of the      */
+/*        instruction in the trace, condition code settings, instruction      */
+/*        address, instruction disassembly, and the values of source and      */
+/*        destination operands.                                               */
+/*                                                                            */
+/*     The minimal trace is recorded by the xISS in an internal buffer whose  */
+/*     size may be determined by the gdb user; this buffer wraps around, so   */
+/*     that only the addresses of the most recently executed instructions are */
+/*     held. This data may then be saved to a file for subsequent inspection. */
+/*     The trace data is written in an encoding which gives a reduction in    */
+/*     size of approximately 80% compared to the raw data.                    */
+/*                                                                            */
+/*     See the manual                                                         */
+/*                                                                            */
+/*                           ARC GDB-Insight                                  */
+/*                     GNU Debugger With Insight GUI                          */
+/*                           Getting Started                                  */
+/*                                6009-001                                    */
+/*                                                                            */
+/*     for full information on how to use these trace facilities.             */
+/*                                                                            */
+/* Usage:                                                                     */
+/*     The module exports a function _initialize_arc_xiss: the call to this   */
+/*     function is generated by the gdb build mechanism, so this function     */
+/*     should not be explicitly called.                                       */
+/*                                                                            */
+/******************************************************************************/
+
+/* gdb configuration file */
+#include "config.h"
+
+/* This macro should be defined in the configuration file only if the arcint.h
+   file is available.  */
+#ifdef HAVE_LIBXISS
+
+/* system header files */
+#include <unistd.h>
+#include <errno.h>
+#include <dlfcn.h>
+
+/* gdb header files */
+#include "defs.h"
+#include "inferior.h"
+#include "disasm.h"
+#include "gdbcmd.h"
+#include "objfiles.h"
+#include "libiberty.h"
+#include "completer.h"
+#include "gdb_assert.h"
+
+/* ARC header files */
+#include "config/arc/tm-embed.h"
+#include "arc-xiss.h"
+#include "arc-tdep.h"
+#include "arc-elf32-tdep.h"
+#include "arc-architecture.h"
+#include "arc-inst-tracing.h"
+#include "arc-registers.h"
+
+/* This must be defined before arcint.h is included.  */
+#define OEM_USE_OF_DEBUGGER_HEADER_FILES 1
+
+/* This defines the interface by which the xISS is accessed.  */
+#include "arcint.h"
+
+
+/* -------------------------------------------------------------------------- */
+/*                               local types                                  */
+/* -------------------------------------------------------------------------- */
+
+typedef struct ARC* (*ARC_Interface)(void);
+
+typedef enum
+{
+   XISS_HALTED,
+   XISS_STEPPED,
+   XISS_TO_BE_RUN
+} ExecutionStatus;
+
+
+/* N.B. this is taken from arcint.cpp; there must be a better way of doing this!  */
+struct ARC
+{
+    ARC_functab *pftp;     /* Pointer to interface function table.  */
+};
+
+typedef void* WatchpointCookie;
+
+typedef struct _association
+{
+    WatchpointCookie cookie;
+    CORE_ADDR        addr;
+    int              length;
+    int              type;
+} Association;
+
+
+/* -------------------------------------------------------------------------- */
+/*                               local data                                   */
+/* -------------------------------------------------------------------------- */
+
+#define ARC_TARGET_NAME                    "arcxiss"
+#define ARC_INTERFACE                      "get_ARC_interface"
+
+#define SAVE_TRACE_TO_FILE_COMMAND         "arc-xiss-save-trace"
+#define EMPTY_TRACE_BUFFER_COMMAND         "arc-xiss-empty-trace-buffer"
+#define LIST_TRACE_COMMAND                 "arc-xiss-list-trace"
+
+#define SAVE_TRACE_TO_FILE_COMMAND_USAGE   "Usage: " SAVE_TRACE_TO_FILE_COMMAND " <FILE>\n"
+#define EMPTY_TRACE_BUFFER_COMMAND_USAGE   "Usage: " EMPTY_TRACE_BUFFER_COMMAND "\n"
+#define LIST_TRACE_COMMAND_USAGE           "Usage: " LIST_TRACE_COMMAND         " [ FROM=<VALUE> ] [ TO=<VALUE> ] [ <FILE> ]\n"
+
+
+/* N.B. the xISS does not currently use the context parameter supplied for
+        memory read/write operations, so its value is irrelevant.  */
+#define XISS_CONTEXT                       0
+
+
+/* The gdb target operations structure for this target.  */
+static struct target_ops xISS_target_ops;
+
+/* A set of pointers to operations for reading/writing registers/memory in the
+   xISS target. */
+static TargetOperations operations;
+
+/* Handles for access to the xISS target.  */
+static void        *xISS_DLL_handle;
+static struct ARC  *xiss_instance;
+static ARC_functab *xISS_functions;
+
+/* The status of program execution on the xISS target.  */
+static ExecutionStatus xISS_executionStatus;
+
+/* Data for handling instruction tracing.  */
+static Boolean xISS_trace_instructions;
+static char   *xiss_trace_file;
+static int     xiss_trace_buffer_size;
+
+/* This is the table for associating watchpoint details with watchpoint cookies.  */
+static Association *associations;
+static unsigned int num_associations;
+
+/* The address of data to which access caused a watchpoint to trigger.  */
+static CORE_ADDR stopped_data_address;
+
+
+/* -------------------------------------------------------------------------- */
+/*                               local macros                                 */
+/* -------------------------------------------------------------------------- */
+
+#define EXTRACT(argument, type, result)                                    \
+{                                                                          \
+    struct expression *expr  = parse_expression(argument);                 \
+    struct value      *val   = evaluate_expression(expr);                  \
+    struct cleanup    *chain = make_cleanup(free_current_contents, &expr); \
+                                                                           \
+    result = *(type*) (value_contents (val));                              \
+    result ## _specified = TRUE;                                           \
+    do_cleanups (chain);                                                   \
+}
+
+/* This macro must cope with the cases:
+     var = value
+     var =value
+     var= value
+     var=value       */
+#define GET_PARAMETER(var)                                      \
+    if (strncasecmp(argv[i], #var "=", sizeof(#var)) == 0)      \
+    {                                                           \
+        if (argv[i][sizeof(#var)] == '\0')                      \
+        {                                                       \
+            i++;                                                \
+            if (argv[i] == NULL)                                \
+                invalid = TRUE;                                 \
+            else                                                \
+            {                                                   \
+                EXTRACT(argv[i], Ordinal, var)                  \
+                i++;                                            \
+            }                                                   \
+        }                                                       \
+        else                                                    \
+        {                                                       \
+            EXTRACT(argv[i] + sizeof(#var), Ordinal, var)       \
+            i++;                                                \
+        }                                                       \
+    }                                                           \
+    else if (strcasecmp(argv[i], #var) == 0)                    \
+    {                                                           \
+        i++;                                                    \
+        if (argv[i] == NULL)                                    \
+            invalid = TRUE;                                     \
+        else                                                    \
+        {                                                       \
+            if (argv[i][0] == '=')                              \
+            {                                                   \
+                if (argv[i][1] == '\0')                         \
+                {                                               \
+                    i++;                                        \
+                    if (argv[i] == NULL)                        \
+                        invalid = TRUE;                         \
+                    else                                        \
+                    {                                           \
+                        EXTRACT(argv[i], Ordinal, var)          \
+                        i++;                                    \
+                    }                                           \
+                }                                               \
+                else                                            \
+                {                                               \
+                    EXTRACT(argv[i] + 1, Ordinal, var)          \
+                    i++;                                        \
+                }                                               \
+            }                                                   \
+            else                                                \
+                invalid = TRUE;                                 \
+        }                                                       \
+    }
+
+
+#define CHECK_RANGE(source)                                                               \
+{                                                                                         \
+    if (from_specified)                                                                   \
+    {                                                                                     \
+        if (from < first || from > last)                                                  \
+        {                                                                                 \
+            warning(_("%s contains instruction range %llu .. %llu - using %llu as FROM"), \
+                    source, first, last, first);                                          \
+            gdb_flush(gdb_stderr);                                                        \
+            from = first;                                                                 \
+        }                                                                                 \
+    }                                                                                     \
+    else                                                                                  \
+        from = first;                                                                     \
+                                                                                          \
+    if (to_specified)                                                                     \
+    {                                                                                     \
+        if (to < first || to > last)                                                      \
+        {                                                                                 \
+            warning(_("%s contains instruction range %llu .. %llu - using %llu as TO"),   \
+                    source, first, last, last);                                           \
+            gdb_flush(gdb_stderr);                                                        \
+            to = last;                                                                    \
+        }                                                                                 \
+    }                                                                                     \
+    else                                                                                  \
+        to = last;                                                                        \
+}
+
+
+#define XISS_PROPERTY(key,value)   xISS_functions->process_property(xiss_instance, key, value)
+
+#define IS_SUPPORTED(flag)         ((xISS_functions->supports_feature(xiss_instance) & (flag)) != 0)
+
+#define XISS_AUX_REG(hw_regno)     ((ARC_REG_TYPE) hw_regno + (ARC_REG_TYPE) AUX_BASE)
+#define XISS_CORE_REG(hw_regno)    ((ARC_REG_TYPE) hw_regno)
+
+
+/* -------------------------------------------------------------------------- */
+/*                               local functions                              */
+/* -------------------------------------------------------------------------- */
+
+/* -------------------------------------------------------------------------- */
+/* 1)                    functions for watchpoint table                       */
+/* -------------------------------------------------------------------------- */
+
+/* These functions implement a linear lookup table which associate an xISS
+   watchpoint cookie with the watchpoint's address, length and type; this is
+   not very efficient, but is quite sufficient for relatively small numbers of
+   watchpoints.  If we should need to handle large numbers of watchpoints
+   efficiently, a more sophisticated data structure may be required.  */
+
+
+/* Add an association to the table.  */
+
+static void
+associate (WatchpointCookie cookie, CORE_ADDR addr, int length, int type)
+{
+    Association *new  = NULL;
+    unsigned int i;
+
+    for (i = 0; i < num_associations; i++)
+    {
+        Association *association = &associations[i];
+
+        if (association->cookie == NULL)
+        {
+            new = association;
+            break;
+        }
+    }
+
+    if (new == NULL)
+    {
+        Association *new_associations = xrealloc(associations, sizeof(Association) * (num_associations + 1));
+
+        if (new_associations == NULL)
+            nomem(0);
+
+        associations = new_associations;
+        new = &new_associations[num_associations];
+        num_associations++;
+    }
+
+    new->cookie = cookie;
+    new->addr   = addr;
+    new->length = length;
+    new->type   = type;
+}
+
+
+/* Remove an association from the table, returning the cookie. */
+
+static WatchpointCookie
+disassociate (CORE_ADDR addr, int length, int type)
+{
+    unsigned int i;
+
+    for (i = 0; i < num_associations; i++)
+    {
+        Association *association = &associations[i];
+
+        if (association->addr   == addr   &&
+            association->length == length &&
+            association->type   == type)
+        {
+            WatchpointCookie cookie = association->cookie;
+
+            association->cookie = NULL;
+            return cookie;
+        }
+    }
+
+    return NULL;
+}
+
+
+/* Find the address associated with a cookie.  */
+
+static CORE_ADDR
+find (WatchpointCookie cookie)
+{
+    unsigned int i;
+
+    for (i = 0; i < num_associations; i++)
+    {
+        Association *association = &associations[i];
+
+        if (association->cookie == cookie)
+            return association->addr;
+    }
+
+    return 0;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* 2)                functions for reading/writing registers                  */
+/* -------------------------------------------------------------------------- */
+
+/* N.B. the register contents returned by these functions, or supplied to them,
+        are in host byte order - the arcint.cpp interface to the xISS requires
+        this.  */
+
+/* Read a core register on the target.
+
+   Parameters:
+      hw_regno       : the ARC hardware number of the register
+      value          : set to the contents of the register
+      warn_on_failure: TRUE if a warning should be issued if the read fails
+
+   Result: TRUE if the register contents are read. */
+
+static Boolean
+read_xiss_core_register (ARC_RegisterNumber    hw_regno,
+                         ARC_RegisterContents *contents,
+                         Boolean               warn_on_failure)
+{
+    unsigned long value;
+    int           result = xISS_functions->read_reg(xiss_instance, XISS_CORE_REG(hw_regno), &value);
+
+    if (result == 1)
+    {
+        *contents = (ARC_RegisterContents) value;
+        DEBUG("Read value 0x%08X from core register %d\n", *contents, hw_regno);
+        return TRUE;
+    }
+
+    if (warn_on_failure)
+        arc_elf32_core_warning(ERROR_ON_READING_REGISTER, hw_regno);
+    return FALSE;
+}
+
+
+/* Write a core register on the target.
+
+   Parameters:
+      hw_regno       : the ARC hardware number of the register
+      value          : set to the contents of the register
+      warn_on_failure: TRUE if a warning should be issued if the write fails
+
+   Result: TRUE if the register contents are written. */
+
+static Boolean
+write_xiss_core_register (ARC_RegisterNumber   hw_regno,
+                          ARC_RegisterContents contents,
+                          Boolean              warn_on_failure)
+{
+    int result = xISS_functions->write_reg(xiss_instance, XISS_CORE_REG(hw_regno), (unsigned long) contents);
+
+    if (result == 1)
+    {
+        DEBUG("Written value 0x%08X to core register %d\n", contents, hw_regno);
+        return TRUE;
+    }
+
+    if (warn_on_failure)
+        arc_elf32_core_warning(ERROR_ON_WRITING_REGISTER, hw_regno);
+    return FALSE;
+}
+
+
+/* Read an auxiliary register on the target.
+
+   Parameters:
+      hw_regno       : the ARC hardware number of the register
+      value          : set to the contents of the register
+      warn_on_failure: TRUE if a warning should be issued if the read fails
+
+   Result: TRUE if the register contents are read. */
+
+static Boolean
+read_xiss_aux_register (ARC_RegisterNumber    hw_regno,
+                        ARC_RegisterContents *contents,
+                        Boolean               warn_on_failure)
+{
+    unsigned long value;
+    int           result = xISS_functions->read_reg(xiss_instance, XISS_AUX_REG(hw_regno), &value);
+
+    if (result == 1)
+    {
+        *contents = (ARC_RegisterContents) value;
+        DEBUG("Read value 0x%08X from auxiliary register %d\n", *contents, hw_regno);
+        return TRUE;
+    }
+
+    if (warn_on_failure)
+        arc_elf32_aux_warning(ERROR_ON_READING_REGISTER, hw_regno);
+    return FALSE;
+}
+
+
+/* Write an auxiliary register on the target.
+
+   Parameters:
+      hw_regno       : the ARC hardware number of the register
+      value          : the contents of the register
+      warn_on_failure: TRUE if a warning should be issued if the write fails
+
+   Result: TRUE if the register contents are written. */
+
+static Boolean
+write_xiss_aux_register (ARC_RegisterNumber   hw_regno,
+                         ARC_RegisterContents contents,
+                         Boolean              warn_on_failure)
+{
+    ARC_AuxRegisterDefinition *def = arc_find_aux_register_by_hw_number(hw_regno);
+    int                        result;
+
+    if (def)
+        contents = arc_write_value(def, contents);
+
+    result = xISS_functions->write_reg(xiss_instance, XISS_AUX_REG(hw_regno), (unsigned long) contents);
+
+    if (result == 1)
+    {
+        DEBUG("Written value 0x%08X to auxiliary register %d\n", contents, hw_regno);
+        return TRUE;
+    }
+
+    if (warn_on_failure)
+        arc_elf32_aux_warning(ERROR_ON_WRITING_REGISTER, hw_regno);
+    return FALSE;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* 3)                functions for reading/writing memory                     */
+/* -------------------------------------------------------------------------- */
+
+/* These functions should NOT be used within this module: they are intended
+   purely for use by the arc-memory module for reading/writing multiple words
+   of data at word-aligned addresses.  */
+
+static unsigned int
+read_words (ARC_Address  address,
+            ARC_Byte    *data,
+            unsigned int words)
+{
+    DEBUG("reading %u words from 0x%08X in xISS\n", words, address);
+
+    gdb_assert(IS_WORD_ALIGNED(address));
+
+    return (unsigned int) xISS_functions->read_memory
+                              (xiss_instance,
+                               (unsigned long) address,
+                                               data,
+                               (unsigned long) words * BYTES_IN_WORD,
+                                               XISS_CONTEXT);
+}
+
+
+static unsigned int
+write_words (ARC_Address  address,
+             ARC_Byte    *data,
+             unsigned int words)
+{
+    gdb_assert(IS_WORD_ALIGNED(address));
+
+    DEBUG("writing %u words to 0x%08X in xISS\n", words, address);
+
+    return (unsigned int) xISS_functions->write_memory
+                              (xiss_instance,
+                               (unsigned long) address,
+                                               data,
+                               (unsigned long) words * BYTES_IN_WORD,
+                                               XISS_CONTEXT);
+}
+
+
+static unsigned int
+write_pattern (ARC_Address  address,
+               ARC_Word     pattern,
+               unsigned int words)
+{
+    gdb_assert(IS_WORD_ALIGNED(address));
+
+    DEBUG("writing pattern 0x%08X repeated %u times to 0x%08X in xISS\n", pattern, words, address);
+
+    return (unsigned int) xISS_functions->fill_memory
+                              (xiss_instance,
+                               (unsigned long) address,
+                                               &pattern,
+                                               BYTES_IN_WORD,
+                               (unsigned int)  words,
+                                               XISS_CONTEXT);
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* 4)                   functions for xISS interface management               */
+/* -------------------------------------------------------------------------- */
+
+/* Open the interface to the debug target.
+
+   Parameters:
+      systemfile: the .xis file defining the simulated target
+      from_tty  : non-zero if the 'target' command was issued at the terminal
+*/
+
+static Boolean
+open_xISS_interface (const char *systemfile, int from_tty)
+{
+    const char   *xiss_home = getenv("XISS_HOME");
+    char          library[FILENAME_MAX];
+    ARC_Interface arc_interface;
+
+    if (xiss_home == NULL)
+        error(_("Environment variable XISS_HOME is not set"));
+
+    /* Construct the path to the xISS .so file.  */
+    (void) snprintf(library, sizeof(library), "%s/lib/libxiss.so", xiss_home);
+
+    /* Try to dynamically load the shared object library containing the xISS.  */
+    xISS_DLL_handle = dlopen(library, RTLD_LAZY);
+
+    if (xISS_DLL_handle == NULL)
+    {
+        const char *diagnostic = dlerror();
+
+        if (strstr(diagnostic, library))
+            error(_("Can not open xISS shared library %s"), diagnostic);
+        else
+            error(_("Can not open xISS shared library %s: %s"), library, diagnostic);
+    }
+
+    /* Find the function in the library which will create an instacne of the xISS.  */
+    arc_interface = dlsym(xISS_DLL_handle, ARC_INTERFACE);
+
+    if (arc_interface ==  NULL)
+        error(_("Can not find function %s in xISS shared library %s"), ARC_INTERFACE, library);
+
+    /* Create an xISS instance.  */
+    xiss_instance = arc_interface();
+
+    if (xiss_instance == NULL)
+        error(_("Can not create instance of xISS"));
+
+    /* Get a pointer to the table of functions provided by the interface.  */
+    xISS_functions = xiss_instance->pftp;
+
+    DEBUG("xISS interface        : %s\n", xISS_functions->id(xiss_instance));
+    DEBUG("xISS interface version: %d\n", xISS_functions->version(xiss_instance));
+
+    /* Tell the xISS what system file to use to define the simulated target.  */
+    if (XISS_PROPERTY("xiss_sys", systemfile) != 1)
+        error(_("xISS could not process 'xiss_sys' property"));
+
+    if (IS_SUPPORTED(ARC_FEATURE_fill_memory))
+        operations.fill_memory = write_pattern;
+
+    (void) xISS_functions->prepare_for_new_program(xiss_instance, 1);
+
+    /* This is somewhat inelegant, but commands read from scripts in the gdb
+       testsuite are regarded as though they were being input interactively
+       (i.e. from_tty is 1), and interactive queries may be made (such as
+       asking the user whether the program currently being debugged should be
+       killed first) - and these queries hang the tests!
+
+       So, if the environment variable is set, assume that the gdb test suite is
+       being run, so that no such queries will be made.
+
+       It is not possible to make this check in the top-level command handler
+       loop, as the output from some other commands (e.g. 'file') depend on the
+       from_tty parameter passed to them, and the gdb test scripts expect to get
+       the interactive version of the output!  */
+    target_preopen(from_tty && (getenv("ARC_GDB_TEST") == NULL));
+
+    return TRUE;
+}
+
+
+/* Close the JTAG interface to the debug target.
+
+   Parameter:
+      resume: TRUE if program execution on the target should be allowed to resume.  */
+
+static void
+close_xISS_interface (Boolean resume)
+{
+    /* If we have a target connected.  */
+    if (xiss_instance != NULL)
+    {
+        /* It is meaningless to resume execution of the xISS.  */
+        arc_elf32_close(FALSE);
+
+        /* If we are doing instruction tracing.  */
+        if (xiss_trace_file)
+        {
+            /* Ensure that the trace file is closed.  */
+            if (XISS_PROPERTY("trace_file", "") != 1)
+                error(_("xISS could not process 'trace_file' property"));
+        }
+
+        /* Close the connection.  */
+        xISS_functions->destroy(xiss_instance);
+
+        /* Close the library.  */
+        if (dlclose(xISS_DLL_handle) != 0)
+            warning(_("error on closing xISS shared library: %s"), dlerror());
+
+        xiss_instance   = NULL;
+        xISS_functions  = NULL;
+        xISS_DLL_handle = NULL;
+    }
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* 5)                functions for starting/stopping the processor            */
+/* -------------------------------------------------------------------------- */
+
+/* Run the xISS for whatever quantum of instructions that it executes.  */
+static void
+run_processor (void)
+{
+    int result = xISS_functions->run(xiss_instance);
+
+    if (result == 0)
+        warning(_("could not run"));
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* 6)       local functions called from outside this module (from gdb)        */
+/* -------------------------------------------------------------------------- */
+
+/* Connect to the xISS target.
+
+   Parameters:
+      args    : user arguments to the 'target' command
+      from_tty: non-zero if the 'target' command was issued at the terminal
+
+   The arguments may be: <XIS_system_file>
+
+   If the name of a system file is not specified, a file 'default.xis' is
+   assumed.  */
+
+static void
+arc_xISS_open (char *args, int from_tty)
+{
+    char *systemfile = (args) ? args : "default.xis";
+
+    ENTERARGS("\"%s\" (%d)", (args) ? args : "", from_tty);
+
+    if (access(systemfile, R_OK) != 0)
+    {
+        char *file = getenv("XISS_SYSTEM_FILE");
+
+        if (file == NULL)
+            error(_("Invalid xISS system file '%s': %s"), systemfile, strerror(errno));
+        else
+            if (access(file, R_OK) != 0)
+                error(_("Invalid xISS system file '%s': %s"), file, strerror(errno));
+            else
+                systemfile = file;
+    }
+
+    arc_program_is_loaded = FALSE;
+
+    xISS_trace_instructions = FALSE;
+    xiss_trace_file         = NULL;
+    xISS_executionStatus    = XISS_HALTED;
+    xiss_trace_buffer_size  = 0;
+
+    num_associations = 0;
+    associations     = NULL;
+
+    /* Find any well-known aux register numbers that we will need.  */
+    arc_elf32_find_register_numbers();
+
+    /* Just to be sure that it is not in the target stack...  */
+    (void) unpush_target (&xISS_target_ops);
+
+    /* Now try to open the xISS interface.  */
+    if (open_xISS_interface(systemfile, from_tty))
+    {
+        (void) push_target (&xISS_target_ops);
+
+        if (from_tty)
+            printf_filtered (_("Connected to the " ARC_TARGET_NAME " target.\n"));
+    }
+    else
+        error(_("Can not connect to target"));
+}
+
+
+/* Close the connection to the target.  */
+
+static void
+arc_xISS_close (int quitting)    /* Ignored.  */
+{
+    ENTERMSG;
+
+    close_xISS_interface(FALSE);
+
+    xfree(associations);
+    associations     = NULL;
+    num_associations = 0;
+}
+
+
+/* Cause the inferior on the debug target to resume execution, sending a signal
+   if necessary.
+
+   Parameters:
+      ptid  : the thread id of the thread to be resumed (ignored)
+      step  : 1 means single step, 0 run freely.
+      signal: the number of the signal to be sent
+
+   N.B. signals are not supported.  */
+
+static void
+arc_xISS_resume (ptid_t ptid, int step, enum target_signal signal)
+{
+    ENTERARGS("%d, %d, %d", ptid.pid, step, signal);
+
+    if (signal != TARGET_SIGNAL_0)
+        error(_("Signals are not supported by the " ARC_TARGET_NAME " target"));
+
+    if (step)
+    {
+        int result = xISS_functions->step(xiss_instance);
+
+        if (result == 0)
+            error(_("Can not single-step"));
+        else
+            xISS_executionStatus = XISS_STEPPED;
+    }
+    else
+        xISS_executionStatus = XISS_TO_BE_RUN;
+
+    LEAVEMSG;
+}
+
+
+/* Wait for execution on the target to halt (for whatever reason).
+
+   Parameters :
+      ptid  : ignored
+      status: set to indicate status at end of the wait
+*/
+
+static ptid_t
+arc_xISS_wait (ptid_t ptid, struct target_waitstatus *status)
+{
+    ENTERARGS("xISS execution status: %d", xISS_executionStatus);
+
+    /* What was done the last time that execution was resumed?  */
+    switch (xISS_executionStatus)
+    {
+        case XISS_STEPPED:
+            DEBUG("processor has stepped\n");
+            status->kind      = TARGET_WAITKIND_STOPPED;
+            status->value.sig = TARGET_SIGNAL_TRAP;
+            break;
+
+        case XISS_TO_BE_RUN:
+            arc_elf32_execute(status,
+                              run_processor,
+                              NULL,
+                              NULL);
+
+            if (status->kind == TARGET_WAITKIND_EXITED)
+                target_mark_exited (&xISS_target_ops);
+            break;
+
+        case XISS_HALTED:
+            break;
+    }
+
+    LEAVEMSG;
+
+    return inferior_ptid;
+}
+
+
+/* This gets called just before store_regs.  */
+
+static void
+arc_xISS_prepare_to_store (struct regcache *regcache)
+{
+    ENTERMSG;
+}
+
+
+static void
+arc_xISS_files_info (struct target_ops *target)
+{
+    /* Do nothing.  */
+    ENTERMSG;
+}
+
+
+/* Heavy duty arsenal. Kill the process.  */
+
+static void
+arc_xISS_kill (void)
+{
+  ENTERMSG;
+
+  target_mourn_inferior ();
+}
+
+
+/* Load the program into memory via the xISS interface.  */
+
+static void
+arc_xISS_load (char *args, int from_tty)
+{
+    /* The program will be downloaded to the simulator.  */
+    (void) xISS_functions->prepare_for_new_program(xiss_instance, 1);
+
+    arc_elf32_load_program(args, from_tty);
+
+    /* Tell xISS that program is fully loaded.  */
+    if (XISS_PROPERTY("download_complete", "1") != 1)
+        error(_("xISS could not process 'download_complete' property"));
+
+    /* We now have a program ready for execution on the target.  */
+}
+
+
+/* Create the inferior that will be executed upon the target.
+
+   Parameters :
+      exec_file: the executable file containing the program to be executed
+      args     : the command line arguments to be passed to the program
+      env      : the environment (name/value pairs) for the program
+      from_tty : ignored
+ */
+
+static void
+arc_xISS_create_inferior (char *exec_file, char *args, char **env, int from_tty)
+{
+    arc_elf32_create_inferior(exec_file, args, env, &xISS_target_ops);
+}
+
+
+/* Mourn the inferior.  */
+
+static void
+arc_xISS_mourn_inferior (void)
+{
+    ENTERMSG;
+
+//  (void) unpush_target (&xISS_target_ops);
+
+    /* N.B. we must delete all breakpoints from the target here: the gdb core
+            function generic_mourn_inferior marks all breakpoints as not being
+            inserted on the target, with the result that subsequent calls to
+            remove_breakpoints will NOT remove any breakpoints that are set on
+            the target; this means that if target execution is re-started, gdb
+            will attempt to re-insert the breakpoints, which causes a problem
+            with software breakpoints: the target insert_breakpoint function
+            reads the code at the b/p address (which is the s/w b/p instruction)
+            and saves it as the "overwritten" code - so when the breakpoint is
+            subsequently removed, the b/p instruction is written back to the
+            b/p address again!  That is not what is desired...  */
+    (void) remove_breakpoints();
+    generic_mourn_inferior();
+    current_target.to_has_execution = 0;
+}
+
+
+/* Check whether the given thread is alive.  */
+
+static int
+arc_xISS_thread_alive (ptid_t ptid)
+{
+    ENTERMSG;
+
+    /* We only have one thread.  */
+    return 1;
+}
+
+
+/* Check whether our debug target is runnable: return 1 if it is, 0 otherwise. */
+
+static int arc_xISS_can_run (void)
+{
+    /* If we are connected to the xISS i/f, and a program is loaded.  */
+    return (xiss_instance != NULL) && arc_program_is_loaded;
+}
+
+
+/* We do not support asynchronous execution of the target program (i.e. commands
+   like 'run' or 'continue' or 'step' can not be executed in background mode
+   by appending a '&' to them) so we do not need to implement the target stop
+   operation (called by the 'interrupt' command); interrupting a running program
+   is handled by the Ctrl-C mechanism.  */
+
+#if 0
+static void
+arc_xISS_stop (void)
+{
+    ENTERMSG;
+}
+#endif
+
+
+/* Check if we can set a "hardware" watchpoint of type TYPE.  TYPE is
+   one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint, or
+   bp_hardware_breakpoint.  COUNT is the number of such watchpoints used so far
+   (including this one).  OTHERTYPE is the total number of "hardware" breakpoints
+   and watchpoints of other types that are "already" set
+   (0 if type == bp_hardware_breakpoint).
+
+   Result:   0 if hardware watchpoints are not supported
+            -1 if there are not enough hardware watchpoints
+             1 if there are enough hardware watchpoints
+
+   N.B. this is not what is stated in target.h, but it does conform to the use
+        made of this function's result in breakpoint.c!  */
+
+static int
+arc_xISS_can_use_hw_breakpoint (int type, int count, int othertype)
+{
+    ENTERARGS("type %d, count %d", type, count);
+
+    switch (type)
+    {
+         case bp_hardware_watchpoint:
+         case bp_read_watchpoint:
+         case bp_watchpoint:     /* This means bp_write_watchpoint.  */
+             return 1;
+         case bp_hardware_breakpoint:
+             return 0;
+         default:
+             return 0;
+    }
+}
+
+
+/* Insert a "hardware" watchpoint on the target.
+
+   Parameters:
+      addr  : the start address of the region of memory to be watched
+      length: the length in bytes of the region of memory
+      type  : 0 => write, 1 => read, 2 => read/write
+
+   Returns 0 for success, -1 for failure.  */
+
+static int
+arc_xISS_insert_watchpoint (CORE_ADDR addr, int length, int type)
+{
+    WatchpointCookie cookie;
+    unsigned int     options;
+
+    ENTERARGS("0x%08X:%d %d", (unsigned int) addr, length, type);
+
+    gdb_assert(length > 0);
+
+    switch (type)
+    {
+        case 0:
+            options = ARC_WATCHPOINT_write;
+            break;
+        case 1:
+            options = ARC_WATCHPOINT_read;
+            break;
+        case 2:
+            options = ARC_WATCHPOINT_read | ARC_WATCHPOINT_write;
+            break;
+        default:
+            internal_error (__FILE__, __LINE__, _("invalid watchpoint type: %d"), type);
+    }
+
+    if (xISS_functions->set_mem_watchpoint2(xiss_instance, (unsigned long) addr, length, options, &cookie) == 1)
+    {
+        associate(cookie, addr, length, type);
+        return 0;
+    }
+
+    return 1;
+}
+
+
+/* Remove a "hardware" watchpoint from the target.
+
+   Parameters:
+      addr  : the start address of the region of memory being watched
+      length: the length in bytes of the region of memory
+      type  : 0 => write, 1 => read, 2 => read/write
+
+   Returns 0 for success, non-zero for failure.  */
+
+static int
+arc_xISS_remove_watchpoint (CORE_ADDR addr, int length, int type)
+{
+    WatchpointCookie cookie = disassociate(addr, length, type);
+
+    ENTERARGS("0x%x:%d %d", (unsigned int) addr, length, type);
+
+    if (cookie != NULL)
+        return (xISS_functions->remove_watchpoint(xiss_instance, cookie) == 1) ? 0 : 1;
+    return 1;
+}
+
+
+/* Returns non-zero if the execution of the target program has been stopped by
+   the trigger of a "hardware" watchpoint (i.e. on memory read or write), zero
+   otherwise.  */
+
+static int
+arc_xISS_stopped_by_watchpoint (void)
+{
+    WatchpointCookie cookie;
+
+    ENTERMSG;
+
+    if (xISS_functions->stopped_at_watchpoint2(xiss_instance, &cookie) == 1)
+    {
+        /* Regrettably, the arcint i/f does not provide a well-defined means for
+           finding out the address of the data which was accessed - to do this
+           we have had to define a special property which returns the required
+           address!  */
+        int result = XISS_PROPERTY("watchpoint", "return_hit_address");
+
+        if (result == 0)
+        {
+            DEBUG("xISS could not process 'watchpoint/return_hit_address' property");
+
+            /* The most we can do now is retrieve the start address of the
+               watchpoint which was triggered...
+               N.B. we must retrieve the watchpoint address here, rather than in
+                    the arc_xISS_stopped_data_address function, as gdb deletes
+                    all breakpoint and watchpoints from the target as soon as
+                    execution is halted, which removes the cookie from the table!  */
+            stopped_data_address = find(cookie);
+        }
+        else
+            stopped_data_address = (CORE_ADDR) result;
+
+        return 1;
+    }
+
+    return 0;
+}
+
+
+/* Get the address of the data that was read/written causing a h/w watchpoint to
+   trigger; the address is returned in the '*addr' parameter.
+   Returns 0 for failure, non-zero for success.  */
+
+static int
+arc_xISS_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr)
+{
+    ENTERMSG;
+
+    DEBUG("data addr: 0x%08X\n", (unsigned int) stopped_data_address);
+    *addr = stopped_data_address;
+
+    return 1;
+}
+
+
+/* Can a h/w watchpoint 'length' bytes long be set at address 'addr' in target memory?  */
+
+static int
+arc_xISS_region_ok_for_hw_watchpoint (CORE_ADDR addr, int length)
+{
+    /* As far as we know, we can set a h/w watchpoint anywhere.  */
+    return 1;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* 7)                   functions for instruction tracing                     */
+/* -------------------------------------------------------------------------- */
+
+/* Display the instruction at the given address and ordinal position in the
+   instruction trace. */
+
+static void
+display_instruction (Ordinal ordinal, unsigned int address)
+{
+    /* N.B. must use fprintf_filtered here, rather than fprintf_unfiltered, as
+            gdb_print_insn calls fprintf_filtered, and if we mix the use of the
+            two we can get garbled output!  */
+    fprintf_filtered(gdb_stdout, "<0x%016llX>       0x%08X      ", ordinal, address);
+    (void) gdb_print_insn((CORE_ADDR) address, gdb_stdout, NULL);
+    fprintf_filtered(gdb_stdout, "\n");
+}
+
+
+/* Get the ordinal position of the first instruction in the trace buffer in the
+   sequence of executed instructions from the xISS; return 0 if this number cannot
+   be obtained.  */
+
+static Ordinal
+get_instruction_trace_start (void)
+{
+    /* N.B. XISS_PROPERTY returns 0 if the property is not handled.  */
+    int     start_low  = XISS_PROPERTY("instruction_trace", "return_start_count_low");
+    int     start_high = XISS_PROPERTY("instruction_trace", "return_start_count_high");
+    Ordinal start      = ((Ordinal) start_high) << 32 | (Ordinal) start_low;
+
+    DEBUG("get_instruction_trace_start : %llu\n", start);
+
+    return start;
+}
+
+
+/* Encode the instruction trace buffer retrieved from the xISS: the buffer
+   'trace' contains 'length' entries which are all PC values.  The data is
+   recorded in the currently open trace file in a packed format.  */
+
+static void
+encode_instruction_trace (unsigned int trace[], int length)
+{
+    unsigned int lastPC = trace[0];
+    int          i;
+
+    /* Store the first entry in the buffer as an absolute address.  */
+    arc_encode_PC(ABSOLUTE_31_BITS, lastPC / 2);
+
+    /* Look at all the remaining entries, comparing each with the previous one.  */
+    for (i = 1; i < length; i++)
+    {
+        unsigned int thisPC = trace[i];
+        int          delta  = (int) thisPC - (int) lastPC;
+
+        /* Encode the difference in the PC as a relative offset, if possible.
+           Offsets of 0 (branch to current address), 2, 4, 6 and 8 (instruction
+           sizes + optional immediate size) are handled as special cases.  */
+
+        if (delta == 0)
+            arc_encode_PC(NO_CHANGE, 0);
+        else if (delta == 2)
+            arc_encode_PC(PLUS_16_BITS, 0);
+        else if (delta == 4)
+            arc_encode_PC(PLUS_32_BITS, 0);
+        else if (delta == 6)
+            arc_encode_PC(PLUS_48_BITS, 0);
+        else if (delta == 8)
+            arc_encode_PC(PLUS_64_BITS, 0);
+        else if (0 < delta && delta <= MAX_DELTA)
+            arc_encode_PC(DELTA_16_BIT_POSITIVE, ENCODE_DELTA(delta));
+        else if (0 > delta && delta >= -MAX_DELTA)
+            arc_encode_PC(DELTA_16_BIT_NEGATIVE, ENCODE_DELTA(-delta));
+        else
+            arc_encode_PC(ABSOLUTE_31_BITS, thisPC / 2);
+
+        lastPC = thisPC;
+    }
+
+    /* Useful tracing code: dump buffer as raw binary.  */
+#if 0
+    {
+        int binary = open("trace.binary", O_CREAT | O_WRONLY, 0666);
+
+        if (binary == -1)
+            warning(_("could not open file trace.binary"));
+        else
+        {
+            (void) write(binary, trace, length * sizeof(unsigned int));
+            (void) close(binary);
+        }
+    }
+#endif
+}
+
+
+/* Decode the instruction trace buffer retrieved from a file. This is the inverse
+   of the encoding performed by the 'encode_instruction_trace' function.
+   The instruction at each PC value decoded is disassembled and displayed only if
+   its ordinal position in the trace is in the range given by the 'from' and 'to'
+   parameters.  */
+
+static void
+decode_instruction_trace (Ordinal from, Ordinal to, Ordinal ordinal)
+{
+    ARC_ProgramCounterEncoding encoding;
+    unsigned int               thisPC = 0;
+    unsigned int               lastPC = 0;
+    unsigned int               value;
+
+    while (arc_decode_PC(&encoding, &value))
+    {
+        switch (encoding)
+        {
+            case NO_CHANGE:
+                break;
+            case PLUS_16_BITS:
+                thisPC += 2;
+                break;
+            case PLUS_32_BITS:
+                thisPC += 4;
+                break;
+            case PLUS_48_BITS:
+                thisPC += 6;
+                break;
+            case PLUS_64_BITS:
+                thisPC += 8;
+                break;
+            case DELTA_16_BIT_POSITIVE:
+                thisPC += DECODE_DELTA(value);
+                break;
+            case DELTA_16_BIT_NEGATIVE:
+                thisPC -= DECODE_DELTA(value);
+                break;
+            case ABSOLUTE_31_BITS:
+                thisPC = value * 2;
+                break;
+        }
+
+        if (from <= ordinal && ordinal <= to)
+            display_instruction(ordinal, thisPC);
+
+        lastPC = thisPC;
+        ordinal++;
+    }
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* 8)                   helper routines for added commands                    */
+/* -------------------------------------------------------------------------- */
+
+/* Check that the xISS target is actually connected.  */
+
+static void
+check_connected (void)
+{
+    if (xiss_instance == NULL)
+        error(_("Target " ARC_TARGET_NAME " is not connected"));
+}
+
+
+/* Set the size of the buffer to be used by the xISS for instruction trace data.  */
+
+static void
+set_trace_buffer_size (int size)
+{
+    char sz[20];
+
+    (void) snprintf(sz, sizeof(sz), "%d", size);
+
+    if (XISS_PROPERTY("trace_buffer_size", sz) != 1)
+        error(_("xISS could not process 'trace_buffer_size' property"));
+}
+
+
+/* Tell the xISS to switch instruction tracing on or off.  */
+
+static void
+set_xiss_trace (char                    *args,
+                int                      from_tty,
+                struct cmd_list_element *e)
+{
+    check_connected();
+
+    if (XISS_PROPERTY("trace", (xISS_trace_instructions) ? "on" : "off") != 1)
+        error(_("xISS could not process 'trace' property"));
+}
+
+
+/* Show the status of xISS instruction tracing.  */
+
+static void
+show_xiss_trace (struct ui_file          *file,
+                 int                      from_tty,
+                 struct cmd_list_element *c,
+                 const char              *value)
+{
+    /* Value will be either "on" or "off".  */
+    fprintf_filtered(file,
+                     _("xISS instruction tracing is %s.\n"),
+                     value);
+}
+
+
+/* Tell the xISS to write the instruction trace to the file whose name is held
+   in the xiss_trace_file global variable.  */
+
+static void
+set_xiss_trace_file (char                    *args,
+                     int                      from_tty,
+                     struct cmd_list_element *e)
+{
+    check_connected();
+
+    if (xiss_trace_file)
+    {
+        if (XISS_PROPERTY("trace_file", xiss_trace_file) != 1)
+            error(_("xISS could not process 'trace_file' property"));
+    }
+}
+
+
+/* Show the name of the trace file (if any) which is currently receiving
+   instruction tracing output from the xISS.  */
+
+static void
+show_xiss_trace_file (struct ui_file          *file,
+                      int                      from_tty,
+                      struct cmd_list_element *c,
+                      const char              *value)
+{
+    if (*value == '\0')
+        fprintf_filtered(file,
+                         _("No output file is set for xISS instruction tracing.\n"));
+    else
+        fprintf_filtered(file,
+                         _("The output file for xISS instruction tracing is '%s'.\n"),
+                         value);
+}
+
+
+/* Set the size of the buffer used by the xISS for instruction trace data.  */
+
+static void
+set_xiss_trace_buffer_size (char                    *args,
+                            int                      from_tty,
+                            struct cmd_list_element *e)
+{
+    check_connected();
+
+    if (xiss_trace_buffer_size < 0)
+        error(_("Trace buffer size must be non-negative"));
+
+    set_trace_buffer_size(xiss_trace_buffer_size);
+}
+
+
+/* Show the size of the buffer used by the xISS for instruction trace data.  */
+
+static void
+show_xiss_trace_buffer_size (struct ui_file          *file,
+                             int                      from_tty,
+                             struct cmd_list_element *c,
+                             const char              *value)
+{
+    fprintf_filtered(file,
+                     _("The buffer size for xISS instruction tracing is %s entries.\n"),
+                     value);
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* 9)                  local functions implementing commands                  */
+/* -------------------------------------------------------------------------- */
+
+/* Command: <command> <filename>
+
+   Save the contents of the xISS instruction trace buffer to the named file.
+
+   We should eventually change this to use the ui_out stuff rather than
+   printf_filtered.  */
+
+static void
+arc_save_trace_to_file_command (char *arg, int from_tty)
+{
+    int count;
+
+    if (!arg)
+    {
+        printf_filtered (_(SAVE_TRACE_TO_FILE_COMMAND_USAGE));
+        return;
+    }
+
+    check_connected();
+
+    count = xISS_functions->instruction_trace_count(xiss_instance);
+
+    if (count)
+    {
+        unsigned int *buffer;
+
+        if (access(arg, F_OK) == 0)
+            if (!query(_("File already exists. Do you wish to overwrite it?")))
+                return;
+
+        printf_unfiltered(_("%u instructions in trace buffer\n"), count);
+
+        buffer = xmalloc(count * sizeof(unsigned int));
+
+        if (buffer)
+        {
+            Ordinal first = get_instruction_trace_start();
+
+            xISS_functions->get_instruction_traces(xiss_instance, buffer);
+
+            if (arc_start_encoding(arg, first))
+            {
+                encode_instruction_trace(buffer, count);
+                arc_stop_encoding(first + (Ordinal) count - 1);
+            }
+
+            xfree(buffer);
+        }
+        else
+            warning(_("can not allocate buffer to hold instruction trace data"));
+    }
+    else
+        warning(_("no instruction trace data available"));
+}
+
+
+
+/* Command: <command>
+
+   Discard the contents of the xISS instruction trace buffer.  */
+
+static void
+arc_empty_trace_buffer (char *arg, int from_tty)
+{
+    if (arg)
+    {
+        printf_filtered (_(EMPTY_TRACE_BUFFER_COMMAND_USAGE));
+        return;
+    }
+
+    check_connected();
+
+    set_trace_buffer_size(0);
+    set_trace_buffer_size(xiss_trace_buffer_size);
+}
+
+
+/* Command: <command> [ FROM=<from> ] [ TO=<to> ] [ <FILE> ]
+
+   Display some or all of the instruction trace, either from the xISS trace
+   buffer or from a named file.  */
+
+static void
+arc_list_trace (char *arg, int from_tty)
+{
+    char   *file           = NULL;
+    Boolean from_specified = FALSE;
+    Boolean to_specified   = FALSE;
+    Ordinal from           = 0;
+    Ordinal to             = 0;
+    Ordinal first;
+    Ordinal last;
+
+    /* Do we have arguments to the command?  */
+    if (arg)
+    {
+        char  **argv    = buildargv (arg);
+        Boolean invalid = FALSE;
+        int     i       = 0;
+
+        if (argv == NULL)
+            nomem (0);
+
+        while (argv[i] != NULL)
+        {
+//          printf("argv[%d] = %s\n", i, argv[i]);
+
+                GET_PARAMETER(from)
+            else
+                GET_PARAMETER(to)
+            else
+            {
+                /* Assume the argument is the file name.  */
+                file = xstrdup(argv[i]);
+                i++;
+            }
+        }
+
+        freeargv(argv);
+
+        if (invalid)
+        {
+            printf_filtered (_(LIST_TRACE_COMMAND_USAGE));
+            return;
+        }
+
+        DEBUG("FROM = %llu\n", from);
+        DEBUG("TO   = %llu\n", to);
+
+        if (from > to)
+            error("FROM (%lld) > TO (%lld)", from, to);
+    }
+
+    /* If we must get the instruction trace from a file.  */
+    if (file)
+    {
+        /* Try to open the named file and start decoding its contents.  */
+        if (arc_start_decoding(file, &first, &last))
+        {
+            CHECK_RANGE("file")
+            decode_instruction_trace(from, to, first);
+            arc_stop_decoding();
+        }
+
+        xfree(file);
+    }
+    else
+    {
+        unsigned int count;
+
+        check_connected();
+
+        /* Get the number of entries in the xISS instruction trace buffer.  */
+        count = (unsigned int) xISS_functions->instruction_trace_count(xiss_instance);
+
+        if (count > 0)
+        {
+            unsigned int *buffer = xmalloc(count * sizeof(unsigned int));
+
+            if (buffer)
+            {
+                Ordinal i;
+
+                first = get_instruction_trace_start();
+                last  = first + (Ordinal) count - 1;
+
+                CHECK_RANGE("trace buffer")
+
+                /* Get the contents of the xISS instruction trace buffer.  */
+                xISS_functions->get_instruction_traces(xiss_instance, buffer);
+
+                /* Display the required range of the trace.  */
+                for (i = from; i <= to; i++)
+                    display_instruction(i, buffer[(int) (i - from)]);
+
+                xfree(buffer);
+            }
+            else
+                warning(_("can not allocate buffer to hold instruction trace data"));
+        }
+        else
+            warning(_("no instruction trace data available"));
+    }
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* 10)                         initialization functions                       */
+/* -------------------------------------------------------------------------- */
+
+/*  Initialize the xISS target operations.  */
+
+static void
+initialize_xISS_target_ops (void)
+{
+    ENTERMSG;
+
+    xISS_target_ops.to_data = &operations;
+
+    xISS_target_ops.to_shortname = ARC_TARGET_NAME;
+    xISS_target_ops.to_longname  = "xISS debug target (ARC Processors)";
+    xISS_target_ops.to_doc       = "xISS (Fast Instruction Set Simulator) debug target (ARC Processors)";
+
+    xISS_target_ops.to_open   = arc_xISS_open;
+    xISS_target_ops.to_close  = arc_xISS_close;
+    xISS_target_ops.to_resume = arc_xISS_resume;
+    xISS_target_ops.to_wait   = arc_xISS_wait;
+
+    xISS_target_ops.to_fetch_registers  = arc_elf32_fetch_registers;
+    xISS_target_ops.to_store_registers  = arc_elf32_store_registers;
+    xISS_target_ops.to_prepare_to_store = arc_xISS_prepare_to_store;
+    xISS_target_ops.to_xfer_partial     = arc_elf32_xfer_partial;
+    xISS_target_ops.to_files_info       = arc_xISS_files_info;
+
+    xISS_target_ops.to_can_use_hw_breakpoint       = arc_xISS_can_use_hw_breakpoint;
+//  xISS_target_ops.to_insert_hw_breakpoint        = arc_xISS_insert_hw_breakpoint;
+//  xISS_target_ops.to_remove_hw_breakpoint        = arc_xISS_remove_hw_breakpoint;
+    xISS_target_ops.to_insert_watchpoint           = arc_xISS_insert_watchpoint;
+    xISS_target_ops.to_remove_watchpoint           = arc_xISS_remove_watchpoint;
+    xISS_target_ops.to_stopped_by_watchpoint       = arc_xISS_stopped_by_watchpoint;
+    xISS_target_ops.to_stopped_data_address        = arc_xISS_stopped_data_address;
+    xISS_target_ops.to_region_ok_for_hw_watchpoint = arc_xISS_region_ok_for_hw_watchpoint;
+
+    xISS_target_ops.to_insert_breakpoint = arc_elf32_insert_breakpoint;
+    xISS_target_ops.to_remove_breakpoint = arc_elf32_remove_breakpoint;
+
+    xISS_target_ops.to_kill = arc_xISS_kill;
+    xISS_target_ops.to_load = arc_xISS_load;
+
+    xISS_target_ops.to_create_inferior   = arc_xISS_create_inferior;
+    xISS_target_ops.to_mourn_inferior    = arc_xISS_mourn_inferior;
+    xISS_target_ops.to_thread_alive      = arc_xISS_thread_alive;
+//  xISS_target_ops.to_stop              = arc_xISS_stop;
+    xISS_target_ops.to_can_run           = arc_xISS_can_run;
+    xISS_target_ops.to_terminal_inferior = NULL;
+
+    xISS_target_ops.to_stratum = process_stratum;
+
+    xISS_target_ops.to_has_all_memory = 1;
+    xISS_target_ops.to_has_memory     = 1;
+    xISS_target_ops.to_has_stack      = 0;  /* Defer setting this until the program has been loaded.  */
+    xISS_target_ops.to_has_registers  = 1;
+    xISS_target_ops.to_has_execution  = 0;  /* Defer setting this until the program has been started.  */
+
+    xISS_target_ops.to_magic = OPS_MAGIC;
+}
+#endif /* HAVE_LIBXISS */
+
+
+/* -------------------------------------------------------------------------- */
+/*                               externally visible functions                 */
+/* -------------------------------------------------------------------------- */
+
+/* Initialize the module.  This function is called from the gdb core on start-up.  */
+
+/* N.B. the initialization function must be defined even if the rest of this
+        module is excluded, as the call to it from the gdb start-up code is
+        generated by the build mechanism without regard to any conditional
+        compilation!  */
+
+void
+_initialize_arc_xiss (void)
+{
+#ifdef HAVE_LIBXISS
+    struct cmd_list_element *cmnd;
+
+    ENTERMSG;
+
+    operations.read_core_register       = read_xiss_core_register;
+    operations.write_core_register      = write_xiss_core_register;
+    operations.read_auxiliary_register  = read_xiss_aux_register;
+    operations.write_auxiliary_register = write_xiss_aux_register;
+    operations.read_memory              = read_words;
+    operations.write_memory             = write_words;
+    operations.fill_memory              = NULL;
+
+    initialize_xISS_target_ops ();
+    add_target (&xISS_target_ops);
+
+    /* Register ARC-specific commands with gdb.  */
+
+    (void) add_setshow_boolean_cmd
+              ("arc-xiss-trace",
+               class_trace,
+               &xISS_trace_instructions,
+               _("Set whether the xISS should trace instructions.\n"),
+               _("Show whether the xISS should trace instructions.\n"),
+               NULL,
+               set_xiss_trace,
+               show_xiss_trace,
+               &setlist,
+               &showlist);
+
+    add_setshow_optional_filename_cmd
+              ("arc-xiss-trace-file",
+               class_trace,
+               &xiss_trace_file,
+               _("Set the output file for xISS instruction tracing.\n"),
+               _("Show the output file for xISS instruction tracing.\n"),
+               NULL,
+               set_xiss_trace_file,
+               show_xiss_trace_file,
+               &setlist,
+               &showlist);
+
+    (void) add_setshow_zinteger_cmd
+              ("arc-xiss-trace-buffer-size",
+               class_trace,
+               &xiss_trace_buffer_size,
+               _("Set the size of the trace buffer for xISS instruction tracing.\n"),
+               _("Show the size of the trace buffer for xISS instruction tracing.\n"),
+               NULL,
+               set_xiss_trace_buffer_size,
+               show_xiss_trace_buffer_size,
+               &setlist,
+               &showlist);
+
+    cmnd = add_cmd
+              (SAVE_TRACE_TO_FILE_COMMAND,
+               class_trace,
+               arc_save_trace_to_file_command,
+               _("Save the contents of the xISS instruction trace buffer to a file.\n"
+               SAVE_TRACE_TO_FILE_COMMAND_USAGE
+               "<FILE> is a file to hold the xISS instruction trace buffer contents.\n"),
+               &cmdlist);
+    set_cmd_completer (cmnd, filename_completer);
+
+    (void) add_cmd
+              (EMPTY_TRACE_BUFFER_COMMAND,
+               class_trace,
+               arc_empty_trace_buffer,
+               _("Empty xISS instruction trace buffer.\n"
+               EMPTY_TRACE_BUFFER_COMMAND_USAGE),
+               &cmdlist);
+
+    cmnd = add_cmd
+              (LIST_TRACE_COMMAND,
+               class_trace,
+               arc_list_trace,
+               _("Display xISS instruction trace.\n"
+               LIST_TRACE_COMMAND_USAGE),
+               &cmdlist);
+    set_cmd_completer (cmnd, filename_completer);
+
+#endif /* HAVE_LIBXISS */
+}
+
+/******************************************************************************/