path: root/gdb/arc-jtag-actionpoints.c

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

   Copyright 2008, 2009 Free Software Foundation, Inc.

   Contributed by ARC International (www.arc.com)

   Author:
      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 implements hardware breakpoints and watchpoints on the ARC */
/*     processor using actionpoints.                                          */
/*                                                                            */
/*     See                                                                    */
/*                    ARC 700 System Components Reference                     */
/*                                 5126-016                                   */
/*                                                                            */
/*     for a full description of the processor actionpoints mechanism.        */
/*                                                                            */
/******************************************************************************/

/* gdb header files */
#include "defs.h"
#include "inferior.h"
#include "gdb_assert.h"

/* ARC header files */
#include "arc-jtag-actionpoints.h"
#include "arc-registers.h"
#include "arc-elf32-tdep.h"
#include "arc-jtag.h"
#include "arc-jtag-ops.h"
#include "arc-support.h"


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

typedef enum
{
   NOT_IN_USE,
   SINGLE,
   PAIR_0,
   PAIR_1,
   QUAD_0,
   QUAD_1,
   QUAD_2,
   QUAD_3
} Actionpoint_Usage;


/* This information describes an individual actionpoint.  */
typedef struct arc_actionpoint
{
    Actionpoint_Usage    usage;
    Boolean              triggered;
    Boolean              is_exclude;
    unsigned int         length;
    ARC_RegisterContents match_value;
    ARC_RegisterContents match_mask;
    ARC_RegisterContents control;
    ARC_RegisterContents point;
} ARC_ActionPoint;


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

#define SUCCESS          0
#define FAILURE        (-1)

#define MAX_ACTION_POINTS              8
#define MAX_ACTION_POINTS_IN_GROUP     4
#define HW_BP_SIZE                     1


/* Bit masks for the Actionpoint Control Registers AP_ACx (10 low-order bits only).  */
#define AP_TARGET_INSTRUCTION_ADDRESS      0x000
#define AP_TARGET_INSTRUCTION_DATA         0x001
#define AP_TARGET_LOAD_STORE_ADDRESS       0x002
#define AP_TARGET_LOAD_STORE_DATA          0x003
#define AP_TARGET_AUX_REGISTER_ADDRESS     0x004
#define AP_TARGET_AUX_REGISTER_DATA        0x005
#define AP_TARGET_EXTERNAL_PARAMETER_0     0x006
#define AP_TARGET_EXTERNAL_PARAMETER_1     0x007
#define AP_TARGET_MASK                     0x007
#define AP_TARGET_SHIFT                    0

#define AP_TRANSACTION_TYPE_DISABLED       0x000
#define AP_TRANSACTION_TYPE_WRITE          0x010
#define AP_TRANSACTION_TYPE_READ           0x020
#define AP_TRANSACTION_TYPE_ACCESS         0x030
#define AP_TRANSACTION_TYPE_MASK           0x030
#define AP_TRANSACTION_TYPE_SHIFT          4

#define AP_MODE_TRIGGER_IN_RANGE           0x000
#define AP_MODE_TRIGGER_OUTSIDE_RANGE      0x040
#define AP_MODE_MASK                       0x040

#define AP_ACTION_BREAK                    0x000
#define AP_ACTION_EXCEPTION                0x100
#define AP_ACTION_MASK                     0x100

#define AP_PAIR                            0x080
#define AP_QUAD                            0x200


/* Data defining the actionpoints.  */
static unsigned int       num_actionpoints;
static Boolean            full_target_actionpoints;
static ARC_ActionPoint    actionpoints[MAX_ACTION_POINTS];

/* The h/w numbers of the AMV0, AMM0 and AC0 auxiliary registers.  */
static ARC_RegisterNumber amv0_regnum;
static ARC_RegisterNumber amm0_regnum;
static ARC_RegisterNumber ac0_regnum;


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

/* The N actionpoint auxiliary registers (where N is 0 .. MAX_ACTION_POINTS - 1)
   (fortunately, the numbers of the registers are one contiguous block, so
   a simple addition is sufficient here).  */
#define ARC_HW_AMV_REGNUM(n)     (ARC_RegisterNumber) (amv0_regnum + 3 * (n))
#define ARC_HW_AMM_REGNUM(n)     (ARC_RegisterNumber) (amm0_regnum + 3 * (n))
#define ARC_HW_AC_REGNUM(n)      (ARC_RegisterNumber) (ac0_regnum  + 3 * (n))

/* This will give a value in range 0 .. MAX_ACTION_POINTS - 1.  */
#define AP_INSTANCE(ap)          ((ap) - actionpoints)
#define IN_USE(ap)               ((ap)->usage != NOT_IN_USE)


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

#if 0
/* This function checks that a given number is a power of two, and, if so,
   returns a bitmask corresponding to (2 ** number - 1).  */

static Boolean
is_power_of_two (int number, ARC_Word *mask)
{
    unsigned int power = 1;
    unsigned int i;

    *mask = 0;

    for (i = 0; (i < BITS_IN_WORD) && (power <= (unsigned int) number); i++)
    {
        if (power == (unsigned int) number)
            return TRUE;

        power <<= 1;
        *mask = (*mask << 1) + 1;
    }

    /* not a power */
    return FALSE;
}
#endif


/* This function determines whether the ARC processor in the connected target
   provides support for actionpoints (that is a configuratiopn option).  */

static Boolean
target_has_actionpoints (void)
{
    ARC_RegisterNumber   ap_build_regnum;
    ARC_RegisterContents ap_build;

    ap_build_regnum = arc_aux_find_register_number("AP_BUILD", ARC_HW_AP_BUILD_REGNUM);
    amv0_regnum     = arc_aux_find_register_number("AMV0",     ARC_HW_AMV0_REGNUM);
    amm0_regnum     = arc_aux_find_register_number("AMM0",     ARC_HW_AMM0_REGNUM);
    ac0_regnum      = arc_aux_find_register_number("AC0",      ARC_HW_AC0_REGNUM);

    num_actionpoints = 0;

    if (arc_read_jtag_aux_register(ap_build_regnum, &ap_build, TRUE))
    {
        DEBUG("AP_BUILD BCR: 0x%08X\n", ap_build);

        /* AP_BUILD returns 0 if actionpoints are not selected in the
           processor configuration.  */
        if (ap_build != 0)
        {
            /* If the processor's implementation of the actionpoint mechanism is
               the one we know about.  */
            if ((ap_build & AP_BUILD_VERSION) == 0x4)
            {
                 unsigned int type = (ap_build & AP_BUILD_TYPE) >> AP_BUILD_TYPE_SHIFT;
                 unsigned int i;

                 /* The low-order two bits of the type field encode the number
                    of actionpoints supported  by the processor.  */
                 switch (type % 4)
                 {
                     case 0 : num_actionpoints = 2; break;
                     case 1 : num_actionpoints = 4; break;
                     case 2 : num_actionpoints = 8; break;
                     default: internal_error (__FILE__, __LINE__, _("invalid AP_BUILD.TYPE: 0x%X"), type);
                 }

                 /* The next bit specifies whether the processor supports full
                    or minimum targets for the actionpoints.  */
                 full_target_actionpoints = ((type & 4) == 0);

                 for (i = 0; i < MAX_ACTION_POINTS; i++)
                 {
                     actionpoints[i].usage      = NOT_IN_USE;
                     actionpoints[i].triggered  = FALSE;
                     actionpoints[i].is_exclude = FALSE;
                 }

                 DEBUG("ARC processor supports %u %s actionpoints\n",
                       num_actionpoints, (full_target_actionpoints) ? "full" : "minimum");

                 return TRUE;
            }
            else
                warning(_("ARC processor actionpoint mechanism version (0x%x) is not supported."),
                        ap_build & AP_BUILD_VERSION);
        }
    }

    DEBUG("ARC processor supports no actionpoints\n");

    return FALSE;
}


/* This function determines the set of actionpoints that would be required to
   cover exactly the memory region specified by (addr,length), by using one
   actionpoint with an inclusive range, and zero or more actionpoints with
   exclusive ranges.

   The set of values and masks for the actionpoint AMV and AMM registers are
   returned in the actionpoint_value and actionpoint_mask arrays - these must
   be able to hold 4 entries.  The value and mask for the inclusive actionpoint
   are returned as the first elements in the arrays.  */

static unsigned int
map_actionpoints (ARC_Address  addr,
                  unsigned int length,
                  ARC_Address  actionpoint_value[],
                  ARC_Word     actionpoint_mask[])
{
    ARC_Address  first_data = addr;
    ARC_Address  last_data  = first_data + length - 1;
    ARC_Address  include_start;
    ARC_Address  include_end;
    ARC_Word     mask;
    unsigned int power_of_two;
    unsigned int points;

    ENTERARGS("addr 0x%08X, length %d", addr, length);
//  DEBUG("range: %08X .. %08X\n", first_data, last_data);

    /* If the range extends across the midpoint of the address space.  */
    if (((first_data & 0x80000000) == 0) && ((last_data & 0x80000000) != 0))
    {
//      DEBUG("pathological case!\n");

        /* Must cover entire address space.  */
        include_start = 0x00000000;
        include_end   = 0xFFFFFFFF;
        mask          = 0xFFFFFFFF;   // Ignore all bits!
    }
    else
    {
        unsigned int i;

        mask         = 0;
        power_of_two = 1;

        /* Determine what actionpoint would be required to include all of the given
           memory region (this include range may have leading and trailing parts
           that extend beyond the given region).  */
        for (i = 0; i < 32; i++)
        {
            unsigned int include_size = power_of_two;

            include_start = (first_data / include_size) * include_size;
            include_end   = include_start + include_size - 1;

            if (include_start <= first_data && include_end >= last_data)
            {
//              DEBUG("include: 0x%08X .. 0x%08X (mask 0x%08x)\n",
//                     include_start, include_end, mask);
                break;
            }

            mask = (mask << 1) + 1;
            power_of_two <<= 1;
        }
    }

    /* This is the first actionpoint in the list.  */
    actionpoint_value[0] = include_start;
    actionpoint_mask [0] = mask;
    points = 1;


    /* Determine what actionpoints would be required to mask out the leading part
       of the include range.  */
    {
        unsigned int to_be_excluded = first_data - include_start;
        ARC_Address  boundary       = include_start;

        while (to_be_excluded > 0)
        {
            unsigned int j;

            mask         = 0;
            power_of_two = 1;

            for (j = 0; j < 32; j++)
            {
                unsigned int exclude_size  = power_of_two;
                ARC_Address  exclude_start = (first_data / exclude_size - 1) * exclude_size;
                ARC_Address  exclude_end   = exclude_start + exclude_size - 1;

                if (exclude_end < first_data && exclude_start <= boundary)
                {
//                  DEBUG("leading exclude: 0x%08X .. 0x%08X (mask 0x%08x)\n",
//                        exclude_start, exclude_end, mask);

                    to_be_excluded = first_data - exclude_end - 1;
                    boundary       = exclude_end + 1;

                    /* There is no point in returning the details of
                       more than the maximum number of actionpoints that
                       can be linked together (in a quad).  */
                    if (points < MAX_ACTION_POINTS_IN_GROUP)
                    {
                        actionpoint_value[points] = exclude_start;
                        actionpoint_mask [points] = mask;
                    }
                    points++;

                    break;
                }

                mask = (mask << 1) + 1;
                power_of_two <<= 1;
            }
        }
    }

    /* Determine what actionpoints would be required to mask out the trailing
       part of the include range.  */
    {
        unsigned int to_be_excluded = include_end - last_data;
        ARC_Address  boundary       = include_end;

        while (to_be_excluded > 0)
        {
            unsigned int j;

            mask         = 0;
            power_of_two = 1;

            for (j = 0; j < 32; j++)
            {
                unsigned int exclude_size  = power_of_two;
                ARC_Address  exclude_start = (last_data / exclude_size + 1) * exclude_size;
                ARC_Address  exclude_end   = exclude_start + exclude_size - 1;

                if (exclude_start > last_data && exclude_end >= boundary)
                {
//                  DEBUG("trailing exclude: 0x%08X .. 0x%08X (mask 0x%08x)\n",
//                        exclude_start, exclude_end, mask);

                    to_be_excluded = exclude_start - last_data - 1;
                    boundary       = exclude_start - 1;

                    /* There is no point in returning the details of
                       more than the maximum number of actionpoints that
                       can be linked together (in a quad).  */
                    if (points < MAX_ACTION_POINTS_IN_GROUP)
                    {
                        actionpoint_value[points] = exclude_start;
                        actionpoint_mask [points] = mask;
                    }
                    points++;

                    break;
                }

                mask = (mask << 1) + 1;
                power_of_two <<= 1;
            }
        }
    }

    return points;
}


/* Set the given actionpoint on the target by writing to the corresponding set
   of AMV, AMM and AC auxiliary registers.
   Return TRUE if it is set successfully.  */

static Boolean
set_actionpoint_on_target (ARC_ActionPoint *actionpoint)
{
    unsigned int instance = AP_INSTANCE(actionpoint);

    return arc_write_jtag_aux_register(ARC_HW_AMV_REGNUM(instance), actionpoint->match_value, TRUE) &&
           arc_write_jtag_aux_register(ARC_HW_AMM_REGNUM(instance), actionpoint->match_mask,  TRUE) &&
           arc_write_jtag_aux_register(ARC_HW_AC_REGNUM (instance), actionpoint->control,     TRUE);
}


/* Clear the given actionpoint on the target by writing 'DISABLED' to the
   corresponding AC auxiliary register.
   Return TRUE if it is cleared successfully.  */

static Boolean
clear_actionpoint_from_target (ARC_ActionPoint *actionpoint)
{
    return arc_write_jtag_aux_register(ARC_HW_AC_REGNUM (AP_INSTANCE(actionpoint)),
                                       AP_TRANSACTION_TYPE_DISABLED,
                                       TRUE);
}


/* Set the given actionpoint on the target, and update its data structure.
   Return TRUE if it is set successfully.  */

static Boolean
set_actionpoint (ARC_ActionPoint *actionpoint)
{
    Boolean set = set_actionpoint_on_target(actionpoint);

    if (set)
    {
        actionpoint->triggered = FALSE;
        actionpoint->point     = 0;
    }
    else
        actionpoint->usage = NOT_IN_USE;

    return set;
}


/* Insert an actionpoint to cover a range of target memory.

   Parameters:
      bpt        : the information describing a breakpoint (NULL for a watchpoint)
      length     : the length in bytes of the range
      match_value: the value for the actionpoint value   (AMV) aux register
      match_mask : the value for the actionpoint mask    (AMM) aux register
      control    : the value for the actionpoint control (AC)  aux register

   Returns 0 for success, -1 for failure.  */

static int
insert_actionpoint (struct bp_target_info *bpt,
                    unsigned int           length,
                    ARC_RegisterContents   match_value,
                    ARC_RegisterContents   match_mask,
                    ARC_RegisterContents   control)
{
    unsigned int i;

    /* Look for an unused actionpoint.  */
    for (i = 0; i < num_actionpoints; i++)
    {
        ARC_ActionPoint *actionpoint = &actionpoints[i];

        /* Got one!  */
        if (!IN_USE(actionpoint))
        {
            /* Record its data.  */
            actionpoint->match_value = match_value;
            actionpoint->match_mask  = match_mask;
            actionpoint->control     = control;
            actionpoint->is_exclude  = FALSE;
            actionpoint->length      = length;

            /* Try to set it on the target.  */
            if (set_actionpoint(actionpoint))
            {
                 /* Now it is in use.  */
                actionpoint->usage = SINGLE;

                /* Is it a breakpoint?  */
                if (bpt)
                {
                    /* We have not actually saved code from the target program.  */
                    bpt->shadow_len  = 0;
                    bpt->placed_size = (int) actionpoint->length;
                }

                return SUCCESS;
            }
        }
    }

    /* Failed: no free actionpoints.  */
//  warning(_("no actionpoints available"));
    return FAILURE;
}


/* Restore the actionpoints on the target according to their current settings.
   If 'clear_unused' is TRUE, any actionpoints which are unused are explicitly
   cleared on the target.

   Returns 0 for success, -1 for failure.  */

static int
restore_actionpoints (Boolean clear_unused)
{
    unsigned int i;

    /* Look at each of the actionpoints.  */
    for (i = 0; i < num_actionpoints; i++)
    {
        ARC_ActionPoint *actionpoint = &actionpoints[i];

        if (IN_USE(actionpoint))
        {
            if (!set_actionpoint_on_target(actionpoint))
            {
                actionpoint->usage = NOT_IN_USE;
                return FAILURE;
            }
        }
        else if (clear_unused)
        {
            if (!clear_actionpoint_from_target (actionpoint))
                return FAILURE;
        }
    }

    return SUCCESS;
}


/* Find a number of unused actionpoints whose numbers (0..7) lie in a contiguous
   range (allowing for wraparound of the numbers, i.e. % 8).

   Parameters:
      required : the number of unused actionpoints required
      from     : set to the number (0..7) of the first actionpoint
      compacted: set to TRUE if the currently used set of actionpoints
                 had to be compacted to give a contiguous range of unused
                 actionpoints

   Returns TRUE if the required number was found, FALSE otherwise.  */

static Boolean
find_unused_actionpoints (unsigned int  required,
                          unsigned int *from,
                          Boolean      *compacted)
{
    unsigned int unused        = 0;
    unsigned int first_unused  = 0;
    unsigned int i;

    /* How many slots are not currently used?  */
    for (i = 0; i < num_actionpoints; i++)
    {
        ARC_ActionPoint *actionpoint = &actionpoints[i];

        if (!IN_USE(actionpoint))
            unused++;
    }

    DEBUG("%u actionpoints unused, %u required\n", unused, required);

    if (required > unused)
        return FALSE;

    /* When used in pairs or quads, the action points wrap around, e.g. a pair
       might be actionpoints (3, 0), if the target has 4 actionpoints; and a
       quad might be (6, 7, 0, 1), if the target has 8 actionpoints.  */

    /* First try to find 'required' contiguous unused slots.  */
    for (i = 0; i < num_actionpoints + required - 2; i++)
    {
        ARC_ActionPoint *actionpoint = &actionpoints[i % num_actionpoints];

        if (IN_USE(actionpoint))
        {
            /* The first unused one MAY be the next one after this one.  */
            first_unused = i + 1;
        }
        else
        {
            DEBUG("%u: AP%u is unused\n", i, i % num_actionpoints);

            if (i - first_unused + 1 >= required)
            {
                /* A sufficiently large sequence of unused actionpoints has been
                   found.  */
                *from = first_unused % num_actionpoints;
                *compacted = FALSE;
                return TRUE;
            }
        }
    }

    DEBUG("compacting array\n");

    /* There are sufficient unused slots, but they are not contiguous - so move
       all the used ones towards the start of the array so that all the unused
       ones are contiguous at the end of the array.  */
    first_unused = MAX_ACTION_POINTS;

    for (i = 0; i < num_actionpoints; i++)
    {
        ARC_ActionPoint *actionpoint = &actionpoints[i];

        if (IN_USE(actionpoint))
        {
            if (first_unused != MAX_ACTION_POINTS)
            {
                DEBUG("moving %u to %u\n", i, first_unused);

                /* Move the used one into the unused slot.  */
                actionpoints[first_unused] = *actionpoint;

                actionpoint->usage = NOT_IN_USE;

                /* The first unused entry in the array is now the next one after
                   it - this is true whether that next one was the used one that
                   has just been moved, or was the next in a sequence of unused
                   entries.  */
                first_unused++;
            }
        }
        else if (first_unused == MAX_ACTION_POINTS)
        {
            /* This one really is the first unused one we have found.  */
            first_unused = i;
        }
    }

    *from = num_actionpoints - unused;

    DEBUG("from = %u\n", *from);

    *compacted = TRUE;
    return TRUE;
}


/* Insert an actionpoint group to cover a range of target memory.

   Parameters:
      length     : the length in bytes of the range
      number     : the number of actionpoints required
      match_value: the values for the actionpoint value  (AMV) aux registers
      match_mask : the values for the actionpoint mask   (AMM) aux registers
      control    : the value for the actionpoint control (AC)  aux registers

   Returns 0 for success, -1 for failure.  */

static int
insert_actionpoint_group (unsigned int         length,
                          unsigned int         number,
                          ARC_RegisterContents match_value[],
                          ARC_RegisterContents match_mask[],
                          ARC_RegisterContents control)
{
    /* For 2 actionpoints, we can use a pair; for 3 or 4, we must use a quad.  */
    unsigned int required = (number == 2) ? 2 : 4;
    unsigned int first_free;
    Boolean      is_pair  = (required == 2);
    Boolean      compacted;

    gdb_assert(2 <= number && number <= 4);

    /* Try to find the required number of unused actionpoints.  */
    if (find_unused_actionpoints(required, &first_free, &compacted))
    {
        ARC_ActionPoint *actionpoint[MAX_ACTION_POINTS_IN_GROUP];
        unsigned int     i;

        /* Get an array of pointers to the data for those actionpoints.  */
        for (i = 0; i < required; i++)
            actionpoint[i] = &actionpoints[(first_free + i) % num_actionpoints];

        actionpoint[0]->length     = length;
        actionpoint[0]->is_exclude = FALSE;

        /* The Control register for the first actionpoint in the group must be
           set to indicate whether the group is a pair or a quad.  */
        actionpoint[0]->usage       = (is_pair) ? PAIR_0 : QUAD_0;
        actionpoint[0]->match_value = match_value[0];
        actionpoint[0]->match_mask  = match_mask[0];
        actionpoint[0]->control     = control | ((is_pair) ? AP_PAIR : AP_QUAD);

        /* All subsequent actionpoints in the group have exclusive rather than
           inclusive address ranges.  */
        control &= ~AP_MODE_TRIGGER_IN_RANGE;
        control |=  AP_MODE_TRIGGER_OUTSIDE_RANGE;

        for (i = 1; i < number; i++)
        {
            actionpoint[i]->usage       = actionpoint[0]->usage + i;
            actionpoint[i]->match_value = match_value[i];
            actionpoint[i]->match_mask  = match_mask[i];
            actionpoint[i]->control     = control;
            actionpoint[i]->length      = 0;
            actionpoint[i]->is_exclude  = TRUE;
        }

        /* If we are using only 3 of the 4 actionpoints in a quad, the 4th one
           must be disabled (or we could just make it the same as one of the
           other exclusive ones).  */
        if (number == 3)
        {
            ARC_ActionPoint *disabled = actionpoint[3];

            disabled->usage       = QUAD_3;
            disabled->match_value = 0;
            disabled->match_mask  = 0;
            disabled->control     = AP_TRANSACTION_TYPE_DISABLED;
            disabled->length      = 0;
        }

        /* If we had to compact the array of actionpoints in order to get a
           long enough contiguous sequence of unused entries, then set ALL of
           the actionpoints that are now in use, and explicitly clear all that
           are not in use (this is simplest!).  */
        if (compacted)
            return restore_actionpoints(TRUE);

        /* Otherwise, just set the ones for the group, which were previously
           unused.  */
        for (i = 0; i < required; i++)
            if (!set_actionpoint(actionpoint[i]))
                return FAILURE;

        return SUCCESS;
    }

//  warning(_("insufficient actionpoints available"));
    return FAILURE;
}


/* Insert a h/w breakpoint or watchpoint to cover a range of target memory.

   Parameters:
      address : the start address of the range
      control : the value for the actionpoint control (AC) aux register
      length  : the length in bytes of the range
      bpt     : the information describing the breakpoint (NULL for a watchpoint)

   Returns 0 for success, -1 for failure.  */

static int
insert_range (ARC_RegisterContents   address,
              ARC_RegisterContents   control,
              unsigned int           length,
              struct bp_target_info *bpt)
{
    /* At most 4 actionpoints can be connected (as a quad).  */
    ARC_Address  actionpoint_value[MAX_ACTION_POINTS_IN_GROUP];
    ARC_Word     actionpoint_mask [MAX_ACTION_POINTS_IN_GROUP];
    unsigned int actionpoints_needed;

    /* Work out how many actionpoints would be required to exactly cover the
       given memory range.  */
    actionpoints_needed = map_actionpoints(address,
                                           length,
                                           actionpoint_value,
                                           actionpoint_mask);

    if (actionpoints_needed == 1)
        return insert_actionpoint(bpt,
                                  length,
                                  actionpoint_value[0],
                                  actionpoint_mask[0],
                                  control);

    if (actionpoints_needed <= MAX_ACTION_POINTS_IN_GROUP)
        return insert_actionpoint_group(length,
                                        actionpoints_needed,
                                        actionpoint_value,
                                        actionpoint_mask,
                                        control);

    warning (_("break/watchpoint would require %u linked actionpoints, "
               "but at most %u actionpoints may be linked together"),
             actionpoints_needed, MAX_ACTION_POINTS_IN_GROUP);

    return FAILURE;
}


/* Remove an actionpoint from a range of target memory.

   Parameters:
      address : the start address of the range
      length  : the length in bytes of the range

   Returns -1 for failure, 0 for success.  */

static int
remove_actionpoint (CORE_ADDR address, unsigned int length)
{
    unsigned int i;

    /* Look at all the actionpoints.  */
    for (i = 0; i < num_actionpoints; i++)
    {
        ARC_ActionPoint *actionpoint = &actionpoints[i];

        if (IN_USE(actionpoint) && !actionpoint->is_exclude)
        {
            if (actionpoint->match_value == (ARC_RegisterContents) address &&
                actionpoint->length      == length)
            {
                unsigned int points;
                unsigned int p;

                /* Is this the first of a pair or quad?  */
                if ((actionpoint->control & AP_PAIR) != 0)
                    points = 2;
                else if ((actionpoint->control & AP_QUAD) != 0)
                    points = 4;
                else
                    points = 1;

//              DEBUG("points = %u\n", points);

                for (p = 1; p < points; p++)
                {
                    ARC_ActionPoint *next = &actionpoints[(i + p) % num_actionpoints];

                    if (clear_actionpoint_from_target (next))
                        next->usage = NOT_IN_USE;
                    else
                        return FAILURE;
                }

                if (clear_actionpoint_from_target (actionpoint))
                {
                    actionpoint->usage = NOT_IN_USE;
                    return SUCCESS;
                }

                break;
            }
        }
    }

    /* Failed: could not find actionpoint, or could not clear it.  */
    return FAILURE;
}


/* -------------------------------------------------------------------------- */
/*               local functions called from outside this module              */
/* -------------------------------------------------------------------------- */

/* 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_debug_can_use_hw_breakpoint (int type, int count, int othertype)
{
    ENTERARGS("type %d, count %d", type, count);

    if (num_actionpoints == 0)
        return 0;

    /* N.B. this will sometimes give a "false positive" result, i.e. that there
            sufficient actionpoints available when in fact there are not: the
            ARC processor actionpoints can be used for all of the types, but gdb
            assumes that there are separate sets of resources for breakpoints
            and watchpoints, and when asking for a breakpoint does not give the
            number of watchpoints "already" set.

            It is not possible simply to check how many actionpoints are currently
            set, as gdb does not actually set the breakpoints and watchpoints
            until program execution is started or resumed - so when this function
            is called, none are actually set.

            Also, the breakpoints and watchpoints may require pairs or quads of
            actionpoints, rather than single actionpoints, and this will not be
            known until they are set, and their addresses and ranges are known!  */
    return ((int) num_actionpoints >= count + othertype) ? 1 : -1;
}


/* Insert a hardware breakpoint on the target.
   Returns 0 for success, -1 for failure.  */

static int
arc_debug_insert_hw_breakpoint (struct bp_target_info *bpt)
{
    ARC_RegisterContents control = AP_TARGET_INSTRUCTION_ADDRESS |
                                   AP_TRANSACTION_TYPE_READ      |
                                   AP_MODE_TRIGGER_IN_RANGE      |
                                   AP_ACTION_BREAK;

    ENTERARGS("0x%x : %u", (unsigned int) bpt->placed_address, bpt->range);

    /* Is it a range breakpoint?  */
    if (bpt->range)
        return insert_range((ARC_RegisterContents) bpt->placed_address,
                            control,
                            bpt->range,
                            bpt);

    /* No, just a single-instruction breakpoint?  */
    return insert_actionpoint(bpt,
                              HW_BP_SIZE,
                              (ARC_RegisterContents) bpt->placed_address,
                              0,    /* All bits of address.  */
                              control);
}


/* Remove a hardware breakpoint from the target.
   Returns 0 for success, non-zero for failure.  */

static int
arc_debug_remove_hw_breakpoint (struct bp_target_info *bpt)
{
    unsigned int range = (bpt->range) ? bpt->range : HW_BP_SIZE;

    ENTERARGS("0x%x : %u", (unsigned int) bpt->placed_address, range);

    return remove_actionpoint(bpt->placed_address, range);
}


/* 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_debug_insert_watchpoint (CORE_ADDR addr, int length, int type)
{
    ARC_RegisterContents control = AP_TARGET_LOAD_STORE_ADDRESS |
                                   AP_MODE_TRIGGER_IN_RANGE     |
                                   AP_ACTION_BREAK;

    ENTERARGS("0x%08X:%d %d", (unsigned int) addr, length, type);

    gdb_assert(length > 0);

    switch (type)
    {
        case 0:
            control |= AP_TRANSACTION_TYPE_WRITE;  break;
        case 1:
            control |= AP_TRANSACTION_TYPE_READ;   break;
        case 2:
            control |= AP_TRANSACTION_TYPE_ACCESS; break;
        default:
            internal_error (__FILE__, __LINE__, _("invalid watchpoint type: %d"), type);
    }

    return insert_range((ARC_RegisterContents) addr,
                        control,
                        (unsigned int) length,
                        NULL);
}


/* 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_debug_remove_watchpoint (CORE_ADDR addr, int length, int type)
{
    ENTERARGS("0x%x:%d %d", (unsigned int) addr, length, type);

    return remove_actionpoint(addr, (unsigned int) length);
}


/* 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_debug_stopped_by_watchpoint (void)
{
    unsigned int i;

    ENTERMSG;

    /* Look at all of the actionpoints.  */
    for (i = 0; i < num_actionpoints; i++)
    {
        ARC_ActionPoint *actionpoint = &actionpoints[i];

        if (IN_USE(actionpoint) && actionpoint->triggered)
        {
            /* Is it a memory read or write actionpoint?  */
            if ((actionpoint->control & AP_TARGET_LOAD_STORE_ADDRESS) != 0)
            {
                DEBUG("actionpoint %d (load/store) triggered\n", i);
                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_debug_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr)
{
    unsigned int i;

    ENTERMSG;

    /* Look at each of the actionpoints.  */
    for (i = 0; i < num_actionpoints; i++)
    {
        ARC_ActionPoint *actionpoint = &actionpoints[i];

        DEBUG("AP%u: in use = %d, triggered = %d\n", i, IN_USE(actionpoint), actionpoint->triggered);

        /* If this actionpoint has been triggered.  */
        if (IN_USE(actionpoint) && actionpoint->triggered)
        {
            /* Is it a memory read or write actionpoint?  */
            if ((actionpoint->control & AP_TARGET_LOAD_STORE_ADDRESS) != 0)
            {
                DEBUG("actionpoint %d (load/store) triggered by access at 0x%08X\n", i, actionpoint->point);

                /* OK, got the data address!  */
                *addr = (CORE_ADDR) actionpoint->point;
                return 1;
            }
        }
    }

   DEBUG("no watchpoint triggered\n");

    return 0;
}


/* Can a h/w watchpoint 'length' bytes long be set at address 'addr' in target memory?  */

static int
arc_debug_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;
}


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

/* This function is called after a reset of the target has been performed (which
   clears all the aux registers associated with actionpoints).  It attempts to
   restore all actionpoints to their pre-reset settings.

   Returns TRUE if the actionpoints are restored, FALSE otherwise.  */

Boolean
arc_restore_actionpoints_after_reset (void)
{
    return (restore_actionpoints(FALSE) == SUCCESS);
}


/* If the debug target supports actionpoints, set up the function pointers in
   the given target operations structure to point to the functions which
   implement the associated operations.

   Returns TRUE if actionpoints are supported, FALSE otherwise.  */

Boolean
arc_initialize_actionpoint_ops (struct target_ops *debug_ops)
{
    if (target_has_actionpoints())
    {
        debug_ops->to_can_use_hw_breakpoint       = arc_debug_can_use_hw_breakpoint;
        debug_ops->to_insert_hw_breakpoint        = arc_debug_insert_hw_breakpoint;
        debug_ops->to_remove_hw_breakpoint        = arc_debug_remove_hw_breakpoint;
        debug_ops->to_insert_watchpoint           = arc_debug_insert_watchpoint;
        debug_ops->to_remove_watchpoint           = arc_debug_remove_watchpoint;
        debug_ops->to_stopped_by_watchpoint       = arc_debug_stopped_by_watchpoint;
        debug_ops->to_stopped_data_address        = arc_debug_stopped_data_address;
        debug_ops->to_region_ok_for_hw_watchpoint = arc_debug_region_ok_for_hw_watchpoint;

        /* This is the default, but just to make it clear that watchpoints must
           be cleared before execution can resume.  */
        debug_ops->to_have_continuable_watchpoint = 0;

        return TRUE;
    }

    return FALSE;
}


/* Display all the target actionpoints.  */

void
arc_display_actionpoints (void)
{
    unsigned int i;

    char *targets[8] =
    {
        _("Instruction Address"),
        _("Instruction Data"),
        _("Load/Store Address"),
        _("Load/Store Data"),
        _("Aux Register Address"),
        _("Aux Register Data"),
        _("Ext Parameter 0"),
        _("Ext Parameter 1")
    };

    char *transactions[4] =
    {
        _("disabled"),
        _("write"),
        _("read"),
        _("read/write")
    };

    char *explanations[8] =
    {
        _("execution of instruction at address"),
        _("execution of instruction"),
        _("load or store of data at address"),
        _("load or store of data"),
        _("read or write of auxiliary register"),
        _("read or write of auxiliary register contents"),
        _("value"),
        _("value")
    };


    /* Look at each of the actionpoints in turn.  */
    for (i = 0; i < num_actionpoints; i++)
    {
        ARC_ActionPoint *actionpoint = &actionpoints[i];

        if (IN_USE(actionpoint))
        {
            ARC_RegisterContents control = actionpoint->control;
            const unsigned int   targ    = (control & AP_TARGET_MASK          ) >> AP_TARGET_SHIFT;
            const unsigned int   trans   = (control & AP_TRANSACTION_TYPE_MASK) >> AP_TRANSACTION_TYPE_SHIFT;
            const char          *target  = targets     [targ];
            const char          *type    = transactions[trans];
            const char          *mode    = ((control & AP_MODE_MASK) ==
                                             AP_MODE_TRIGGER_OUTSIDE_RANGE) ? _("outside range") : _("in range");
            const char          *action  = ((control & AP_ACTION_MASK) ==
                                             AP_ACTION_BREAK) ? _("break") : _("raise exception");
            const char          *usage;

            switch (actionpoint->usage)
            {
                case SINGLE: usage = _("         "); break;
                case PAIR_0: usage = _(" (Pair 0)"); break;
                case PAIR_1: usage = _(" (Pair 1)"); break;
                case QUAD_0: usage = _(" (Quad 0)"); break;
                case QUAD_1: usage = _(" (Quad 1)"); break;
                case QUAD_2: usage = _(" (Quad 2)"); break;
                case QUAD_3: usage = _(" (Quad 3)"); break;
                default:
                    internal_error (__FILE__, __LINE__, _("invalid AP usage: %u"), actionpoint->usage);
                    return;
            }

            printf_filtered(_("AP %u%s :: "), i, usage);

            printf_filtered(                     _("value    : %08X\n"),                 actionpoint->match_value);
            printf_filtered(    _("                 mask     : %08X\n"),                 actionpoint->match_mask);
            if ((control & AP_TRANSACTION_TYPE_MASK) == AP_TRANSACTION_TYPE_DISABLED)
                printf_filtered(_("                 control  : %08X disabled\n"),        actionpoint->control);
            else
                printf_filtered(_("                 control  : %08X %s, %s on %s %s\n"), actionpoint->control, target, action, type, mode);
            if (actionpoint->triggered)
            {
                const char *explain = explanations[targ];

                printf_filtered(_("                 triggered by %s %08x\n"), explain,   actionpoint->point);
            }
        }
        else
        {
            printf_filtered(_("AP %u          :: not in use\n"), i);
        }
    }
}


/* This function is called as soon as execution of the target program has halted.
   It checks whether the halt is due to an actionpoint trigger, and, if so,
   identifies the actionpoint that has been triggered and finds the address (code
   or data) at which memory access (read, write or execute) has caused the trigger.  */

void
arc_target_halted (void)
{
    ARC_RegisterContents debug;

    ENTERMSG;

    if (arc_read_jtag_aux_register(arc_debug_regnum, &debug, TRUE))
    {
        /* If the bit indicating that an actionpoint has halted the processor is
           set.  */
        if ((debug & DEBUG_ACTIONPOINT_HALT) != 0)
        {
            /* Get the Actionpoints Status Register from the DEBUG register:
               this contains one bit for each actionpoint in the processor
               configuration.  */
            unsigned int ASR = (debug & DEBUG_ACTIONPOINT_STATUS) >>
                                DEBUG_ACTIONPOINT_STATUS_SHIFT;
            unsigned int i;

            /* Now look at each of the actionpoints.  */
            for (i = 0; i < num_actionpoints; i++)
            {
                ARC_ActionPoint *actionpoint = &actionpoints[i];

                actionpoint->triggered = FALSE;

                /* Is the ASR bit for this actionpoint set?  */
                if ((ASR & 1) != 0)
                {
                    if (IN_USE(actionpoint))
                    {
                        actionpoint->triggered = TRUE;

                        /* The AMV register for this action point has been
                           updated with the address to which access has caused
                           the actionpoint to trigger.  */
                        (void) arc_read_jtag_aux_register(ARC_HW_AMV_REGNUM(AP_INSTANCE(actionpoint)),
                                                          &actionpoint->point,
                                                          TRUE);
                    }
                    else
                        internal_error (__FILE__, __LINE__, _("actionpoint %u triggered but not set"), i);
                }

                ASR >>= 1;
            }
        }
    }
}


/* For debugging - just give the values.  */

void
arc_dump_actionpoints (const char *message)
{
    unsigned int i;

    DEBUG("%s\n", message);

    /* Look at each of the actionpoints in turn.  */
    for (i = 0; i < num_actionpoints; i++)
    {
        ARC_ActionPoint *actionpoint = &actionpoints[i];

        DEBUG("slot %u:: ", i);

        if (IN_USE(actionpoint))
        {
            DEBUG(         "value    : %08X\n", actionpoint->match_value);
            DEBUG("         mask     : %08X\n", actionpoint->match_mask);
            DEBUG("         control  : %08X\n", actionpoint->control);
            DEBUG("         triggered: %u\n",   actionpoint->triggered);
            DEBUG("         point    : %08x\n", actionpoint->point);
        }
        else
        {
            DEBUG("not in use\n");
        }
    }
}

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