binutils-gdb/sim/frv/frv.c

1599 lines
42 KiB
C
Raw Normal View History

/* frv simulator support code
Copyright (C) 1998-2015 Free Software Foundation, Inc.
Contributed by Red Hat.
This file is part of the GNU simulators.
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/>. */
#define WANT_CPU
#define WANT_CPU_FRVBF
#include "sim-main.h"
#include "cgen-mem.h"
#include "cgen-ops.h"
#include "cgen-engine.h"
#include "cgen-par.h"
#include "bfd.h"
#include "gdb/sim-frv.h"
#include <math.h>
/* Maintain a flag in order to know when to write the address of the next
VLIW instruction into the LR register. Used by JMPL. JMPIL, and CALL
insns. */
int frvbf_write_next_vliw_addr_to_LR;
/* The contents of BUF are in target byte order. */
int
frvbf_fetch_register (SIM_CPU *current_cpu, int rn, unsigned char *buf, int len)
{
if (SIM_FRV_GR0_REGNUM <= rn && rn <= SIM_FRV_GR63_REGNUM)
{
int hi_available, lo_available;
int grn = rn - SIM_FRV_GR0_REGNUM;
frv_gr_registers_available (current_cpu, &hi_available, &lo_available);
if ((grn < 32 && !lo_available) || (grn >= 32 && !hi_available))
return 0;
else
SETTSI (buf, GET_H_GR (grn));
}
else if (SIM_FRV_FR0_REGNUM <= rn && rn <= SIM_FRV_FR63_REGNUM)
{
int hi_available, lo_available;
int frn = rn - SIM_FRV_FR0_REGNUM;
frv_fr_registers_available (current_cpu, &hi_available, &lo_available);
if ((frn < 32 && !lo_available) || (frn >= 32 && !hi_available))
return 0;
else
SETTSI (buf, GET_H_FR (frn));
}
else if (rn == SIM_FRV_PC_REGNUM)
SETTSI (buf, GET_H_PC ());
else if (SIM_FRV_SPR0_REGNUM <= rn && rn <= SIM_FRV_SPR4095_REGNUM)
{
/* Make sure the register is implemented. */
FRV_REGISTER_CONTROL *control = CPU_REGISTER_CONTROL (current_cpu);
int spr = rn - SIM_FRV_SPR0_REGNUM;
if (! control->spr[spr].implemented)
return 0;
SETTSI (buf, GET_H_SPR (spr));
}
else
{
SETTSI (buf, 0xdeadbeef);
return 0;
}
return len;
}
/* The contents of BUF are in target byte order. */
int
frvbf_store_register (SIM_CPU *current_cpu, int rn, unsigned char *buf, int len)
{
if (SIM_FRV_GR0_REGNUM <= rn && rn <= SIM_FRV_GR63_REGNUM)
{
int hi_available, lo_available;
int grn = rn - SIM_FRV_GR0_REGNUM;
frv_gr_registers_available (current_cpu, &hi_available, &lo_available);
if ((grn < 32 && !lo_available) || (grn >= 32 && !hi_available))
return 0;
else
SET_H_GR (grn, GETTSI (buf));
}
else if (SIM_FRV_FR0_REGNUM <= rn && rn <= SIM_FRV_FR63_REGNUM)
{
int hi_available, lo_available;
int frn = rn - SIM_FRV_FR0_REGNUM;
frv_fr_registers_available (current_cpu, &hi_available, &lo_available);
if ((frn < 32 && !lo_available) || (frn >= 32 && !hi_available))
return 0;
else
SET_H_FR (frn, GETTSI (buf));
}
else if (rn == SIM_FRV_PC_REGNUM)
SET_H_PC (GETTSI (buf));
else if (SIM_FRV_SPR0_REGNUM <= rn && rn <= SIM_FRV_SPR4095_REGNUM)
{
/* Make sure the register is implemented. */
FRV_REGISTER_CONTROL *control = CPU_REGISTER_CONTROL (current_cpu);
int spr = rn - SIM_FRV_SPR0_REGNUM;
if (! control->spr[spr].implemented)
return 0;
SET_H_SPR (spr, GETTSI (buf));
}
else
return 0;
return len;
}
/* Cover fns to access the general registers. */
USI
frvbf_h_gr_get_handler (SIM_CPU *current_cpu, UINT gr)
{
frv_check_gr_access (current_cpu, gr);
return CPU (h_gr[gr]);
}
void
frvbf_h_gr_set_handler (SIM_CPU *current_cpu, UINT gr, USI newval)
{
frv_check_gr_access (current_cpu, gr);
if (gr == 0)
return; /* Storing into gr0 has no effect. */
CPU (h_gr[gr]) = newval;
}
/* Cover fns to access the floating point registers. */
SF
frvbf_h_fr_get_handler (SIM_CPU *current_cpu, UINT fr)
{
frv_check_fr_access (current_cpu, fr);
return CPU (h_fr[fr]);
}
void
frvbf_h_fr_set_handler (SIM_CPU *current_cpu, UINT fr, SF newval)
{
frv_check_fr_access (current_cpu, fr);
CPU (h_fr[fr]) = newval;
}
/* Cover fns to access the general registers as double words. */
static UINT
check_register_alignment (SIM_CPU *current_cpu, UINT reg, int align_mask)
{
if (reg & align_mask)
{
SIM_DESC sd = CPU_STATE (current_cpu);
switch (STATE_ARCHITECTURE (sd)->mach)
{
2004-03-01 11:11:46 +01:00
/* Note: there is a discrepancy between V2.2 of the FR400
instruction manual and the various FR4xx LSI specs.
The former claims that unaligned registers cause a
register_exception while the latter say it's an
illegal_instruction. The LSI specs appear to be
correct; in fact, the FR4xx series is not documented
as having a register_exception. */
case bfd_mach_fr400:
2004-03-01 11:11:46 +01:00
case bfd_mach_fr450:
case bfd_mach_fr550:
frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
break;
case bfd_mach_frvtomcat:
case bfd_mach_fr500:
case bfd_mach_frv:
frv_queue_register_exception_interrupt (current_cpu,
FRV_REC_UNALIGNED);
break;
default:
break;
}
reg &= ~align_mask;
}
return reg;
}
static UINT
check_fr_register_alignment (SIM_CPU *current_cpu, UINT reg, int align_mask)
{
if (reg & align_mask)
{
SIM_DESC sd = CPU_STATE (current_cpu);
switch (STATE_ARCHITECTURE (sd)->mach)
{
2004-03-01 11:11:46 +01:00
/* See comment in check_register_alignment(). */
case bfd_mach_fr400:
2004-03-01 11:11:46 +01:00
case bfd_mach_fr450:
case bfd_mach_fr550:
frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
break;
case bfd_mach_frvtomcat:
case bfd_mach_fr500:
case bfd_mach_frv:
{
struct frv_fp_exception_info fp_info = {
FSR_NO_EXCEPTION, FTT_INVALID_FR
};
frv_queue_fp_exception_interrupt (current_cpu, & fp_info);
}
break;
default:
break;
}
reg &= ~align_mask;
}
return reg;
}
static UINT
check_memory_alignment (SIM_CPU *current_cpu, SI address, int align_mask)
{
if (address & align_mask)
{
SIM_DESC sd = CPU_STATE (current_cpu);
switch (STATE_ARCHITECTURE (sd)->mach)
{
2004-03-01 11:11:46 +01:00
/* See comment in check_register_alignment(). */
case bfd_mach_fr400:
2004-03-01 11:11:46 +01:00
case bfd_mach_fr450:
frv_queue_data_access_error_interrupt (current_cpu, address);
break;
case bfd_mach_frvtomcat:
case bfd_mach_fr500:
case bfd_mach_frv:
frv_queue_mem_address_not_aligned_interrupt (current_cpu, address);
break;
default:
break;
}
address &= ~align_mask;
}
return address;
}
DI
frvbf_h_gr_double_get_handler (SIM_CPU *current_cpu, UINT gr)
{
DI value;
if (gr == 0)
return 0; /* gr0 is always 0. */
/* Check the register alignment. */
gr = check_register_alignment (current_cpu, gr, 1);
value = GET_H_GR (gr);
value <<= 32;
value |= (USI) GET_H_GR (gr + 1);
return value;
}
void
frvbf_h_gr_double_set_handler (SIM_CPU *current_cpu, UINT gr, DI newval)
{
if (gr == 0)
return; /* Storing into gr0 has no effect. */
/* Check the register alignment. */
gr = check_register_alignment (current_cpu, gr, 1);
SET_H_GR (gr , (newval >> 32) & 0xffffffff);
SET_H_GR (gr + 1, (newval ) & 0xffffffff);
}
/* Cover fns to access the floating point register as double words. */
DF
frvbf_h_fr_double_get_handler (SIM_CPU *current_cpu, UINT fr)
{
union {
SF as_sf[2];
DF as_df;
} value;
/* Check the register alignment. */
fr = check_fr_register_alignment (current_cpu, fr, 1);
if (CURRENT_HOST_BYTE_ORDER == LITTLE_ENDIAN)
{
value.as_sf[1] = GET_H_FR (fr);
value.as_sf[0] = GET_H_FR (fr + 1);
}
else
{
value.as_sf[0] = GET_H_FR (fr);
value.as_sf[1] = GET_H_FR (fr + 1);
}
return value.as_df;
}
void
frvbf_h_fr_double_set_handler (SIM_CPU *current_cpu, UINT fr, DF newval)
{
union {
SF as_sf[2];
DF as_df;
} value;
/* Check the register alignment. */
fr = check_fr_register_alignment (current_cpu, fr, 1);
value.as_df = newval;
if (CURRENT_HOST_BYTE_ORDER == LITTLE_ENDIAN)
{
SET_H_FR (fr , value.as_sf[1]);
SET_H_FR (fr + 1, value.as_sf[0]);
}
else
{
SET_H_FR (fr , value.as_sf[0]);
SET_H_FR (fr + 1, value.as_sf[1]);
}
}
/* Cover fns to access the floating point register as integer words. */
USI
frvbf_h_fr_int_get_handler (SIM_CPU *current_cpu, UINT fr)
{
union {
SF as_sf;
USI as_usi;
} value;
value.as_sf = GET_H_FR (fr);
return value.as_usi;
}
void
frvbf_h_fr_int_set_handler (SIM_CPU *current_cpu, UINT fr, USI newval)
{
union {
SF as_sf;
USI as_usi;
} value;
value.as_usi = newval;
SET_H_FR (fr, value.as_sf);
}
/* Cover fns to access the coprocessor registers as double words. */
DI
frvbf_h_cpr_double_get_handler (SIM_CPU *current_cpu, UINT cpr)
{
DI value;
/* Check the register alignment. */
cpr = check_register_alignment (current_cpu, cpr, 1);
value = GET_H_CPR (cpr);
value <<= 32;
value |= (USI) GET_H_CPR (cpr + 1);
return value;
}
void
frvbf_h_cpr_double_set_handler (SIM_CPU *current_cpu, UINT cpr, DI newval)
{
/* Check the register alignment. */
cpr = check_register_alignment (current_cpu, cpr, 1);
SET_H_CPR (cpr , (newval >> 32) & 0xffffffff);
SET_H_CPR (cpr + 1, (newval ) & 0xffffffff);
}
/* Cover fns to write registers as quad words. */
void
frvbf_h_gr_quad_set_handler (SIM_CPU *current_cpu, UINT gr, SI *newval)
{
if (gr == 0)
return; /* Storing into gr0 has no effect. */
/* Check the register alignment. */
gr = check_register_alignment (current_cpu, gr, 3);
SET_H_GR (gr , newval[0]);
SET_H_GR (gr + 1, newval[1]);
SET_H_GR (gr + 2, newval[2]);
SET_H_GR (gr + 3, newval[3]);
}
void
frvbf_h_fr_quad_set_handler (SIM_CPU *current_cpu, UINT fr, SI *newval)
{
/* Check the register alignment. */
fr = check_fr_register_alignment (current_cpu, fr, 3);
SET_H_FR (fr , newval[0]);
SET_H_FR (fr + 1, newval[1]);
SET_H_FR (fr + 2, newval[2]);
SET_H_FR (fr + 3, newval[3]);
}
void
frvbf_h_cpr_quad_set_handler (SIM_CPU *current_cpu, UINT cpr, SI *newval)
{
/* Check the register alignment. */
cpr = check_register_alignment (current_cpu, cpr, 3);
SET_H_CPR (cpr , newval[0]);
SET_H_CPR (cpr + 1, newval[1]);
SET_H_CPR (cpr + 2, newval[2]);
SET_H_CPR (cpr + 3, newval[3]);
}
/* Cover fns to access the special purpose registers. */
USI
frvbf_h_spr_get_handler (SIM_CPU *current_cpu, UINT spr)
{
/* Check access restrictions. */
frv_check_spr_read_access (current_cpu, spr);
switch (spr)
{
case H_SPR_PSR:
return spr_psr_get_handler (current_cpu);
case H_SPR_TBR:
return spr_tbr_get_handler (current_cpu);
case H_SPR_BPSR:
return spr_bpsr_get_handler (current_cpu);
case H_SPR_CCR:
return spr_ccr_get_handler (current_cpu);
case H_SPR_CCCR:
return spr_cccr_get_handler (current_cpu);
case H_SPR_SR0:
case H_SPR_SR1:
case H_SPR_SR2:
case H_SPR_SR3:
return spr_sr_get_handler (current_cpu, spr);
break;
default:
return CPU (h_spr[spr]);
}
return 0;
}
void
frvbf_h_spr_set_handler (SIM_CPU *current_cpu, UINT spr, USI newval)
{
FRV_REGISTER_CONTROL *control;
USI mask;
USI oldval;
/* Check access restrictions. */
frv_check_spr_write_access (current_cpu, spr);
/* Only set those fields which are writeable. */
control = CPU_REGISTER_CONTROL (current_cpu);
mask = control->spr[spr].read_only_mask;
oldval = GET_H_SPR (spr);
newval = (newval & ~mask) | (oldval & mask);
/* Some registers are represented by individual components which are
referenced more often than the register itself. */
switch (spr)
{
case H_SPR_PSR:
spr_psr_set_handler (current_cpu, newval);
break;
case H_SPR_TBR:
spr_tbr_set_handler (current_cpu, newval);
break;
case H_SPR_BPSR:
spr_bpsr_set_handler (current_cpu, newval);
break;
case H_SPR_CCR:
spr_ccr_set_handler (current_cpu, newval);
break;
case H_SPR_CCCR:
spr_cccr_set_handler (current_cpu, newval);
break;
case H_SPR_SR0:
case H_SPR_SR1:
case H_SPR_SR2:
case H_SPR_SR3:
spr_sr_set_handler (current_cpu, spr, newval);
break;
case H_SPR_IHSR8:
frv_cache_reconfigure (current_cpu, CPU_INSN_CACHE (current_cpu));
break;
default:
CPU (h_spr[spr]) = newval;
break;
}
}
/* Cover fns to access the gr_hi and gr_lo registers. */
UHI
frvbf_h_gr_hi_get_handler (SIM_CPU *current_cpu, UINT gr)
{
return (GET_H_GR(gr) >> 16) & 0xffff;
}
void
frvbf_h_gr_hi_set_handler (SIM_CPU *current_cpu, UINT gr, UHI newval)
{
USI value = (GET_H_GR (gr) & 0xffff) | (newval << 16);
SET_H_GR (gr, value);
}
UHI
frvbf_h_gr_lo_get_handler (SIM_CPU *current_cpu, UINT gr)
{
return GET_H_GR(gr) & 0xffff;
}
void
frvbf_h_gr_lo_set_handler (SIM_CPU *current_cpu, UINT gr, UHI newval)
{
USI value = (GET_H_GR (gr) & 0xffff0000) | (newval & 0xffff);
SET_H_GR (gr, value);
}
/* Cover fns to access the tbr bits. */
USI
spr_tbr_get_handler (SIM_CPU *current_cpu)
{
int tbr = ((GET_H_TBR_TBA () & 0xfffff) << 12) |
((GET_H_TBR_TT () & 0xff) << 4);
return tbr;
}
void
spr_tbr_set_handler (SIM_CPU *current_cpu, USI newval)
{
int tbr = newval;
SET_H_TBR_TBA ((tbr >> 12) & 0xfffff) ;
SET_H_TBR_TT ((tbr >> 4) & 0xff) ;
}
/* Cover fns to access the bpsr bits. */
USI
spr_bpsr_get_handler (SIM_CPU *current_cpu)
{
int bpsr = ((GET_H_BPSR_BS () & 0x1) << 12) |
((GET_H_BPSR_BET () & 0x1) );
return bpsr;
}
void
spr_bpsr_set_handler (SIM_CPU *current_cpu, USI newval)
{
int bpsr = newval;
SET_H_BPSR_BS ((bpsr >> 12) & 1);
SET_H_BPSR_BET ((bpsr ) & 1);
}
/* Cover fns to access the psr bits. */
USI
spr_psr_get_handler (SIM_CPU *current_cpu)
{
int psr = ((GET_H_PSR_IMPLE () & 0xf) << 28) |
((GET_H_PSR_VER () & 0xf) << 24) |
((GET_H_PSR_ICE () & 0x1) << 16) |
((GET_H_PSR_NEM () & 0x1) << 14) |
((GET_H_PSR_CM () & 0x1) << 13) |
((GET_H_PSR_BE () & 0x1) << 12) |
((GET_H_PSR_ESR () & 0x1) << 11) |
((GET_H_PSR_EF () & 0x1) << 8) |
((GET_H_PSR_EM () & 0x1) << 7) |
((GET_H_PSR_PIL () & 0xf) << 3) |
((GET_H_PSR_S () & 0x1) << 2) |
((GET_H_PSR_PS () & 0x1) << 1) |
((GET_H_PSR_ET () & 0x1) );
return psr;
}
void
spr_psr_set_handler (SIM_CPU *current_cpu, USI newval)
{
/* The handler for PSR.S references the value of PSR.ESR, so set PSR.S
first. */
SET_H_PSR_S ((newval >> 2) & 1);
SET_H_PSR_IMPLE ((newval >> 28) & 0xf);
SET_H_PSR_VER ((newval >> 24) & 0xf);
SET_H_PSR_ICE ((newval >> 16) & 1);
SET_H_PSR_NEM ((newval >> 14) & 1);
SET_H_PSR_CM ((newval >> 13) & 1);
SET_H_PSR_BE ((newval >> 12) & 1);
SET_H_PSR_ESR ((newval >> 11) & 1);
SET_H_PSR_EF ((newval >> 8) & 1);
SET_H_PSR_EM ((newval >> 7) & 1);
SET_H_PSR_PIL ((newval >> 3) & 0xf);
SET_H_PSR_PS ((newval >> 1) & 1);
SET_H_PSR_ET ((newval ) & 1);
}
void
frvbf_h_psr_s_set_handler (SIM_CPU *current_cpu, BI newval)
{
/* If switching from user to supervisor mode, or vice-versa, then switch
the supervisor/user context. */
int psr_s = GET_H_PSR_S ();
if (psr_s != (newval & 1))
{
frvbf_switch_supervisor_user_context (current_cpu);
CPU (h_psr_s) = newval & 1;
}
}
/* Cover fns to access the ccr bits. */
USI
spr_ccr_get_handler (SIM_CPU *current_cpu)
{
int ccr = ((GET_H_ICCR (H_ICCR_ICC3) & 0xf) << 28) |
((GET_H_ICCR (H_ICCR_ICC2) & 0xf) << 24) |
((GET_H_ICCR (H_ICCR_ICC1) & 0xf) << 20) |
((GET_H_ICCR (H_ICCR_ICC0) & 0xf) << 16) |
((GET_H_FCCR (H_FCCR_FCC3) & 0xf) << 12) |
((GET_H_FCCR (H_FCCR_FCC2) & 0xf) << 8) |
((GET_H_FCCR (H_FCCR_FCC1) & 0xf) << 4) |
((GET_H_FCCR (H_FCCR_FCC0) & 0xf) );
return ccr;
}
void
spr_ccr_set_handler (SIM_CPU *current_cpu, USI newval)
{
int ccr = newval;
SET_H_ICCR (H_ICCR_ICC3, (newval >> 28) & 0xf);
SET_H_ICCR (H_ICCR_ICC2, (newval >> 24) & 0xf);
SET_H_ICCR (H_ICCR_ICC1, (newval >> 20) & 0xf);
SET_H_ICCR (H_ICCR_ICC0, (newval >> 16) & 0xf);
SET_H_FCCR (H_FCCR_FCC3, (newval >> 12) & 0xf);
SET_H_FCCR (H_FCCR_FCC2, (newval >> 8) & 0xf);
SET_H_FCCR (H_FCCR_FCC1, (newval >> 4) & 0xf);
SET_H_FCCR (H_FCCR_FCC0, (newval ) & 0xf);
}
QI
frvbf_set_icc_for_shift_right (
SIM_CPU *current_cpu, SI value, SI shift, QI icc
)
{
/* Set the C flag of the given icc to the logical OR of the bits shifted
out. */
int mask = (1 << shift) - 1;
if ((value & mask) != 0)
return icc | 0x1;
return icc & 0xe;
}
QI
frvbf_set_icc_for_shift_left (
SIM_CPU *current_cpu, SI value, SI shift, QI icc
)
{
/* Set the V flag of the given icc to the logical OR of the bits shifted
out. */
int mask = ((1 << shift) - 1) << (32 - shift);
if ((value & mask) != 0)
return icc | 0x2;
return icc & 0xd;
}
/* Cover fns to access the cccr bits. */
USI
spr_cccr_get_handler (SIM_CPU *current_cpu)
{
int cccr = ((GET_H_CCCR (H_CCCR_CC7) & 0x3) << 14) |
((GET_H_CCCR (H_CCCR_CC6) & 0x3) << 12) |
((GET_H_CCCR (H_CCCR_CC5) & 0x3) << 10) |
((GET_H_CCCR (H_CCCR_CC4) & 0x3) << 8) |
((GET_H_CCCR (H_CCCR_CC3) & 0x3) << 6) |
((GET_H_CCCR (H_CCCR_CC2) & 0x3) << 4) |
((GET_H_CCCR (H_CCCR_CC1) & 0x3) << 2) |
((GET_H_CCCR (H_CCCR_CC0) & 0x3) );
return cccr;
}
void
spr_cccr_set_handler (SIM_CPU *current_cpu, USI newval)
{
int cccr = newval;
SET_H_CCCR (H_CCCR_CC7, (newval >> 14) & 0x3);
SET_H_CCCR (H_CCCR_CC6, (newval >> 12) & 0x3);
SET_H_CCCR (H_CCCR_CC5, (newval >> 10) & 0x3);
SET_H_CCCR (H_CCCR_CC4, (newval >> 8) & 0x3);
SET_H_CCCR (H_CCCR_CC3, (newval >> 6) & 0x3);
SET_H_CCCR (H_CCCR_CC2, (newval >> 4) & 0x3);
SET_H_CCCR (H_CCCR_CC1, (newval >> 2) & 0x3);
SET_H_CCCR (H_CCCR_CC0, (newval ) & 0x3);
}
/* Cover fns to access the sr bits. */
USI
spr_sr_get_handler (SIM_CPU *current_cpu, UINT spr)
{
/* If PSR.ESR is not set, then SR0-3 map onto SGR4-7 which will be GR4-7,
otherwise the correct mapping of USG4-7 or SGR4-7 will be in SR0-3. */
int psr_esr = GET_H_PSR_ESR ();
if (! psr_esr)
return GET_H_GR (4 + (spr - H_SPR_SR0));
return CPU (h_spr[spr]);
}
void
spr_sr_set_handler (SIM_CPU *current_cpu, UINT spr, USI newval)
{
/* If PSR.ESR is not set, then SR0-3 map onto SGR4-7 which will be GR4-7,
otherwise the correct mapping of USG4-7 or SGR4-7 will be in SR0-3. */
int psr_esr = GET_H_PSR_ESR ();
if (! psr_esr)
SET_H_GR (4 + (spr - H_SPR_SR0), newval);
else
CPU (h_spr[spr]) = newval;
}
/* Switch SR0-SR4 with GR4-GR7 if PSR.ESR is set. */
void
frvbf_switch_supervisor_user_context (SIM_CPU *current_cpu)
{
if (GET_H_PSR_ESR ())
{
/* We need to be in supervisor mode to swap the registers. Access the
PSR.S directly in order to avoid recursive context switches. */
int i;
int save_psr_s = CPU (h_psr_s);
CPU (h_psr_s) = 1;
for (i = 0; i < 4; ++i)
{
int gr = i + 4;
int spr = i + H_SPR_SR0;
SI tmp = GET_H_SPR (spr);
SET_H_SPR (spr, GET_H_GR (gr));
SET_H_GR (gr, tmp);
}
CPU (h_psr_s) = save_psr_s;
}
}
/* Handle load/store of quad registers. */
void
frvbf_load_quad_GR (SIM_CPU *current_cpu, PCADDR pc, SI address, SI targ_ix)
{
int i;
SI value[4];
/* Check memory alignment */
address = check_memory_alignment (current_cpu, address, 0xf);
/* If we need to count cycles, then the cache operation will be
initiated from the model profiling functions.
See frvbf_model_.... */
if (model_insn)
{
CPU_LOAD_ADDRESS (current_cpu) = address;
CPU_LOAD_LENGTH (current_cpu) = 16;
}
else
{
for (i = 0; i < 4; ++i)
{
value[i] = frvbf_read_mem_SI (current_cpu, pc, address);
address += 4;
}
sim_queue_fn_xi_write (current_cpu, frvbf_h_gr_quad_set_handler, targ_ix,
value);
}
}
void
frvbf_store_quad_GR (SIM_CPU *current_cpu, PCADDR pc, SI address, SI src_ix)
{
int i;
SI value[4];
USI hsr0;
/* Check register and memory alignment. */
src_ix = check_register_alignment (current_cpu, src_ix, 3);
address = check_memory_alignment (current_cpu, address, 0xf);
for (i = 0; i < 4; ++i)
{
/* GR0 is always 0. */
if (src_ix == 0)
value[i] = 0;
else
value[i] = GET_H_GR (src_ix + i);
}
hsr0 = GET_HSR0 ();
if (GET_HSR0_DCE (hsr0))
sim_queue_fn_mem_xi_write (current_cpu, frvbf_mem_set_XI, address, value);
else
sim_queue_mem_xi_write (current_cpu, address, value);
}
void
frvbf_load_quad_FRint (SIM_CPU *current_cpu, PCADDR pc, SI address, SI targ_ix)
{
int i;
SI value[4];
/* Check memory alignment */
address = check_memory_alignment (current_cpu, address, 0xf);
/* If we need to count cycles, then the cache operation will be
initiated from the model profiling functions.
See frvbf_model_.... */
if (model_insn)
{
CPU_LOAD_ADDRESS (current_cpu) = address;
CPU_LOAD_LENGTH (current_cpu) = 16;
}
else
{
for (i = 0; i < 4; ++i)
{
value[i] = frvbf_read_mem_SI (current_cpu, pc, address);
address += 4;
}
sim_queue_fn_xi_write (current_cpu, frvbf_h_fr_quad_set_handler, targ_ix,
value);
}
}
void
frvbf_store_quad_FRint (SIM_CPU *current_cpu, PCADDR pc, SI address, SI src_ix)
{
int i;
SI value[4];
USI hsr0;
/* Check register and memory alignment. */
src_ix = check_fr_register_alignment (current_cpu, src_ix, 3);
address = check_memory_alignment (current_cpu, address, 0xf);
for (i = 0; i < 4; ++i)
value[i] = GET_H_FR (src_ix + i);
hsr0 = GET_HSR0 ();
if (GET_HSR0_DCE (hsr0))
sim_queue_fn_mem_xi_write (current_cpu, frvbf_mem_set_XI, address, value);
else
sim_queue_mem_xi_write (current_cpu, address, value);
}
void
frvbf_load_quad_CPR (SIM_CPU *current_cpu, PCADDR pc, SI address, SI targ_ix)
{
int i;
SI value[4];
/* Check memory alignment */
address = check_memory_alignment (current_cpu, address, 0xf);
/* If we need to count cycles, then the cache operation will be
initiated from the model profiling functions.
See frvbf_model_.... */
if (model_insn)
{
CPU_LOAD_ADDRESS (current_cpu) = address;
CPU_LOAD_LENGTH (current_cpu) = 16;
}
else
{
for (i = 0; i < 4; ++i)
{
value[i] = frvbf_read_mem_SI (current_cpu, pc, address);
address += 4;
}
sim_queue_fn_xi_write (current_cpu, frvbf_h_cpr_quad_set_handler, targ_ix,
value);
}
}
void
frvbf_store_quad_CPR (SIM_CPU *current_cpu, PCADDR pc, SI address, SI src_ix)
{
int i;
SI value[4];
USI hsr0;
/* Check register and memory alignment. */
src_ix = check_register_alignment (current_cpu, src_ix, 3);
address = check_memory_alignment (current_cpu, address, 0xf);
for (i = 0; i < 4; ++i)
value[i] = GET_H_CPR (src_ix + i);
hsr0 = GET_HSR0 ();
if (GET_HSR0_DCE (hsr0))
sim_queue_fn_mem_xi_write (current_cpu, frvbf_mem_set_XI, address, value);
else
sim_queue_mem_xi_write (current_cpu, address, value);
}
void
frvbf_signed_integer_divide (
SIM_CPU *current_cpu, SI arg1, SI arg2, int target_index, int non_excepting
)
{
enum frv_dtt dtt = FRV_DTT_NO_EXCEPTION;
if (arg1 == 0x80000000 && arg2 == -1)
{
/* 0x80000000/(-1) must result in 0x7fffffff when ISR.EDE is set
otherwise it may result in 0x7fffffff (sparc compatibility) or
0x80000000 (C language compatibility). */
USI isr;
dtt = FRV_DTT_OVERFLOW;
isr = GET_ISR ();
if (GET_ISR_EDE (isr))
sim_queue_fn_si_write (current_cpu, frvbf_h_gr_set, target_index,
0x7fffffff);
else
sim_queue_fn_si_write (current_cpu, frvbf_h_gr_set, target_index,
0x80000000);
frvbf_force_update (current_cpu); /* Force update of target register. */
}
else if (arg2 == 0)
dtt = FRV_DTT_DIVISION_BY_ZERO;
else
sim_queue_fn_si_write (current_cpu, frvbf_h_gr_set, target_index,
arg1 / arg2);
/* Check for exceptions. */
if (dtt != FRV_DTT_NO_EXCEPTION)
dtt = frvbf_division_exception (current_cpu, dtt, target_index,
non_excepting);
if (non_excepting && dtt == FRV_DTT_NO_EXCEPTION)
{
/* Non excepting instruction. Clear the NE flag for the target
register. */
SI NE_flags[2];
GET_NE_FLAGS (NE_flags, H_SPR_GNER0);
CLEAR_NE_FLAG (NE_flags, target_index);
SET_NE_FLAGS (H_SPR_GNER0, NE_flags);
}
}
void
frvbf_unsigned_integer_divide (
SIM_CPU *current_cpu, USI arg1, USI arg2, int target_index, int non_excepting
)
{
if (arg2 == 0)
frvbf_division_exception (current_cpu, FRV_DTT_DIVISION_BY_ZERO,
target_index, non_excepting);
else
{
sim_queue_fn_si_write (current_cpu, frvbf_h_gr_set, target_index,
arg1 / arg2);
if (non_excepting)
{
/* Non excepting instruction. Clear the NE flag for the target
register. */
SI NE_flags[2];
GET_NE_FLAGS (NE_flags, H_SPR_GNER0);
CLEAR_NE_FLAG (NE_flags, target_index);
SET_NE_FLAGS (H_SPR_GNER0, NE_flags);
}
}
}
/* Clear accumulators. */
void
frvbf_clear_accumulators (SIM_CPU *current_cpu, SI acc_ix, int A)
{
SIM_DESC sd = CPU_STATE (current_cpu);
2004-03-01 11:11:46 +01:00
int acc_mask =
(STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr500) ? 7 :
(STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr550) ? 7 :
(STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr450) ? 11 :
(STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr400) ? 3 :
63;
FRV_PROFILE_STATE *ps = CPU_PROFILE_STATE (current_cpu);
ps->mclracc_acc = acc_ix;
ps->mclracc_A = A;
if (A == 0 || acc_ix != 0) /* Clear 1 accumuator? */
{
/* This instruction is a nop if the referenced accumulator is not
implemented. */
2004-03-01 11:11:46 +01:00
if ((acc_ix & acc_mask) == acc_ix)
sim_queue_fn_di_write (current_cpu, frvbf_h_acc40S_set, acc_ix, 0);
}
else
{
/* Clear all implemented accumulators. */
int i;
2004-03-01 11:11:46 +01:00
for (i = 0; i <= acc_mask; ++i)
if ((i & acc_mask) == i)
sim_queue_fn_di_write (current_cpu, frvbf_h_acc40S_set, i, 0);
}
}
/* Functions to aid insn semantics. */
/* Compute the result of the SCAN and SCANI insns after the shift and xor. */
SI
frvbf_scan_result (SIM_CPU *current_cpu, SI value)
{
SI i;
SI mask;
if (value == 0)
return 63;
/* Find the position of the first non-zero bit.
The loop will terminate since there is guaranteed to be at least one
non-zero bit. */
mask = 1 << (sizeof (mask) * 8 - 1);
for (i = 0; (value & mask) == 0; ++i)
value <<= 1;
return i;
}
/* Compute the result of the cut insns. */
SI
frvbf_cut (SIM_CPU *current_cpu, SI reg1, SI reg2, SI cut_point)
{
SI result;
cut_point &= 0x3f;
if (cut_point < 32)
{
result = reg1 << cut_point;
result |= (reg2 >> (32 - cut_point)) & ((1 << cut_point) - 1);
}
else
result = reg2 << (cut_point - 32);
return result;
}
/* Compute the result of the cut insns. */
SI
frvbf_media_cut (SIM_CPU *current_cpu, DI acc, SI cut_point)
{
/* The cut point is the lower 6 bits (signed) of what we are passed. */
cut_point = cut_point << 26 >> 26;
/* The cut_point is relative to bit 40 of 64 bits. */
if (cut_point >= 0)
return (acc << (cut_point + 24)) >> 32;
/* Extend the sign bit (bit 40) for negative cuts. */
if (cut_point == -32)
return (acc << 24) >> 63; /* Special case for full shiftout. */
return (acc << 24) >> (32 + -cut_point);
}
/* Compute the result of the cut insns. */
SI
frvbf_media_cut_ss (SIM_CPU *current_cpu, DI acc, SI cut_point)
{
/* The cut point is the lower 6 bits (signed) of what we are passed. */
cut_point = cut_point << 26 >> 26;
if (cut_point >= 0)
{
/* The cut_point is relative to bit 40 of 64 bits. */
DI shifted = acc << (cut_point + 24);
DI unshifted = shifted >> (cut_point + 24);
/* The result will be saturated if significant bits are shifted out. */
if (unshifted != acc)
{
if (acc < 0)
return 0x80000000;
return 0x7fffffff;
}
}
/* The result will not be saturated, so use the code for the normal cut. */
return frvbf_media_cut (current_cpu, acc, cut_point);
}
/* Compute the result of int accumulator cut (SCUTSS). */
SI
frvbf_iacc_cut (SIM_CPU *current_cpu, DI acc, SI cut_point)
{
DI lower, upper;
/* The cut point is the lower 7 bits (signed) of what we are passed. */
cut_point = cut_point << 25 >> 25;
/* Conceptually, the operation is on a 128-bit sign-extension of ACC.
The top bit of the return value corresponds to bit (63 - CUT_POINT)
of this 128-bit value.
Since we can't deal with 128-bit values very easily, convert the
operation into an equivalent 64-bit one. */
if (cut_point < 0)
{
/* Avoid an undefined shift operation. */
if (cut_point == -64)
acc >>= 63;
else
acc >>= -cut_point;
cut_point = 0;
}
/* Get the shifted but unsaturated result. Set LOWER to the lowest
32 bits of the result and UPPER to the result >> 31. */
if (cut_point < 32)
{
/* The cut loses the (32 - CUT_POINT) least significant bits.
Round the result up if the most significant of these lost bits
is 1. */
lower = acc >> (32 - cut_point);
if (lower < 0x7fffffff)
if (acc & LSBIT64 (32 - cut_point - 1))
lower++;
upper = lower >> 31;
}
else
{
lower = acc << (cut_point - 32);
upper = acc >> (63 - cut_point);
}
/* Saturate the result. */
if (upper < -1)
return ~0x7fffffff;
else if (upper > 0)
return 0x7fffffff;
else
return lower;
}
/* Compute the result of shift-left-arithmetic-with-saturation (SLASS). */
SI
frvbf_shift_left_arith_saturate (SIM_CPU *current_cpu, SI arg1, SI arg2)
{
int neg_arg1;
/* FIXME: what to do with negative shift amt? */
if (arg2 <= 0)
return arg1;
if (arg1 == 0)
return 0;
/* Signed shift by 31 or greater saturates by definition. */
if (arg2 >= 31)
if (arg1 > 0)
return (SI) 0x7fffffff;
else
return (SI) 0x80000000;
/* OK, arg2 is between 1 and 31. */
neg_arg1 = (arg1 < 0);
do {
arg1 <<= 1;
/* Check for sign bit change (saturation). */
if (neg_arg1 && (arg1 >= 0))
return (SI) 0x80000000;
else if (!neg_arg1 && (arg1 < 0))
return (SI) 0x7fffffff;
} while (--arg2 > 0);
return arg1;
}
/* Simulate the media custom insns. */
void
frvbf_media_cop (SIM_CPU *current_cpu, int cop_num)
{
/* The semantics of the insn are a nop, since it is implementation defined.
We do need to check whether it's implemented and set up for MTRAP
if it's not. */
USI msr0 = GET_MSR (0);
if (GET_MSR_EMCI (msr0) == 0)
{
/* no interrupt queued at this time. */
frv_set_mp_exception_registers (current_cpu, MTT_UNIMPLEMENTED_MPOP, 0);
}
}
/* Simulate the media average (MAVEH) insn. */
static HI
do_media_average (SIM_CPU *current_cpu, HI arg1, HI arg2)
{
SIM_DESC sd = CPU_STATE (current_cpu);
SI sum = (arg1 + arg2);
HI result = sum >> 1;
int rounding_value;
2004-03-01 11:11:46 +01:00
/* On fr4xx and fr550, check the rounding mode. On other machines
rounding is always toward negative infinity and the result is
already correctly rounded. */
switch (STATE_ARCHITECTURE (sd)->mach)
{
/* Need to check rounding mode. */
case bfd_mach_fr400:
2004-03-01 11:11:46 +01:00
case bfd_mach_fr450:
case bfd_mach_fr550:
/* Check whether rounding will be required. Rounding will be required
if the sum is an odd number. */
rounding_value = sum & 1;
if (rounding_value)
{
USI msr0 = GET_MSR (0);
/* Check MSR0.SRDAV to determine which bits control the rounding. */
if (GET_MSR_SRDAV (msr0))
{
/* MSR0.RD controls rounding. */
switch (GET_MSR_RD (msr0))
{
case 0:
/* Round to nearest. */
if (result >= 0)
++result;
break;
case 1:
/* Round toward 0. */
if (result < 0)
++result;
break;
case 2:
/* Round toward positive infinity. */
++result;
break;
case 3:
/* Round toward negative infinity. The result is already
correctly rounded. */
break;
default:
abort ();
break;
}
}
else
{
/* MSR0.RDAV controls rounding. If set, round toward positive
infinity. Otherwise the result is already rounded correctly
toward negative infinity. */
if (GET_MSR_RDAV (msr0))
++result;
}
}
break;
default:
break;
}
return result;
}
SI
frvbf_media_average (SIM_CPU *current_cpu, SI reg1, SI reg2)
{
SI result;
result = do_media_average (current_cpu, reg1 & 0xffff, reg2 & 0xffff);
result &= 0xffff;
result |= do_media_average (current_cpu, (reg1 >> 16) & 0xffff,
(reg2 >> 16) & 0xffff) << 16;
return result;
}
/* Maintain a flag in order to know when to write the address of the next
VLIW instruction into the LR register. Used by JMPL. JMPIL, and CALL. */
void
frvbf_set_write_next_vliw_addr_to_LR (SIM_CPU *current_cpu, int value)
{
frvbf_write_next_vliw_addr_to_LR = value;
}
void
frvbf_set_ne_index (SIM_CPU *current_cpu, int index)
{
USI NE_flags[2];
/* Save the target register so interrupt processing can set its NE flag
in the event of an exception. */
frv_interrupt_state.ne_index = index;
/* Clear the NE flag of the target register. It will be reset if necessary
in the event of an exception. */
GET_NE_FLAGS (NE_flags, H_SPR_FNER0);
CLEAR_NE_FLAG (NE_flags, index);
SET_NE_FLAGS (H_SPR_FNER0, NE_flags);
}
void
frvbf_force_update (SIM_CPU *current_cpu)
{
CGEN_WRITE_QUEUE *q = CPU_WRITE_QUEUE (current_cpu);
int ix = CGEN_WRITE_QUEUE_INDEX (q);
if (ix > 0)
{
CGEN_WRITE_QUEUE_ELEMENT *item = CGEN_WRITE_QUEUE_ELEMENT (q, ix - 1);
item->flags |= FRV_WRITE_QUEUE_FORCE_WRITE;
}
}
/* Condition code logic. */
enum cr_ops {
andcr, orcr, xorcr, nandcr, norcr, andncr, orncr, nandncr, norncr,
num_cr_ops
};
enum cr_result {cr_undefined, cr_undefined1, cr_false, cr_true};
static enum cr_result
cr_logic[num_cr_ops][4][4] = {
/* andcr */
{
/* undefined undefined false true */
/* undefined */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined},
/* undefined */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined},
/* false */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined},
/* true */ {cr_undefined, cr_undefined, cr_false, cr_true }
},
/* orcr */
{
/* undefined undefined false true */
/* undefined */ {cr_undefined, cr_undefined, cr_false, cr_true },
/* undefined */ {cr_undefined, cr_undefined, cr_false, cr_true },
/* false */ {cr_false, cr_false, cr_false, cr_true },
/* true */ {cr_true, cr_true, cr_true, cr_true }
},
/* xorcr */
{
/* undefined undefined false true */
/* undefined */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined},
/* undefined */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined},
/* false */ {cr_undefined, cr_undefined, cr_false, cr_true },
/* true */ {cr_true, cr_true, cr_true, cr_false }
},
/* nandcr */
{
/* undefined undefined false true */
/* undefined */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined},
/* undefined */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined},
/* false */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined},
/* true */ {cr_undefined, cr_undefined, cr_true, cr_false }
},
/* norcr */
{
/* undefined undefined false true */
/* undefined */ {cr_undefined, cr_undefined, cr_true, cr_false },
/* undefined */ {cr_undefined, cr_undefined, cr_true, cr_false },
/* false */ {cr_true, cr_true, cr_true, cr_false },
/* true */ {cr_false, cr_false, cr_false, cr_false }
},
/* andncr */
{
/* undefined undefined false true */
/* undefined */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined},
/* undefined */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined},
/* false */ {cr_undefined, cr_undefined, cr_false, cr_true },
/* true */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined}
},
/* orncr */
{
/* undefined undefined false true */
/* undefined */ {cr_undefined, cr_undefined, cr_false, cr_true },
/* undefined */ {cr_undefined, cr_undefined, cr_false, cr_true },
/* false */ {cr_true, cr_true, cr_true, cr_true },
/* true */ {cr_false, cr_false, cr_false, cr_true }
},
/* nandncr */
{
/* undefined undefined false true */
/* undefined */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined},
/* undefined */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined},
/* false */ {cr_undefined, cr_undefined, cr_true, cr_false },
/* true */ {cr_undefined, cr_undefined, cr_undefined, cr_undefined}
},
/* norncr */
{
/* undefined undefined false true */
/* undefined */ {cr_undefined, cr_undefined, cr_true, cr_false },
/* undefined */ {cr_undefined, cr_undefined, cr_true, cr_false },
/* false */ {cr_false, cr_false, cr_false, cr_false },
/* true */ {cr_true, cr_true, cr_true, cr_false }
}
};
UQI
frvbf_cr_logic (SIM_CPU *current_cpu, SI operation, UQI arg1, UQI arg2)
{
return cr_logic[operation][arg1][arg2];
}
/* Cache Manipulation. */
void
frvbf_insn_cache_preload (SIM_CPU *current_cpu, SI address, USI length, int lock)
{
/* If we need to count cycles, then the cache operation will be
initiated from the model profiling functions.
See frvbf_model_.... */
int hsr0 = GET_HSR0 ();
if (GET_HSR0_ICE (hsr0))
{
if (model_insn)
{
CPU_LOAD_ADDRESS (current_cpu) = address;
CPU_LOAD_LENGTH (current_cpu) = length;
CPU_LOAD_LOCK (current_cpu) = lock;
}
else
{
FRV_CACHE *cache = CPU_INSN_CACHE (current_cpu);
frv_cache_preload (cache, address, length, lock);
}
}
}
void
frvbf_data_cache_preload (SIM_CPU *current_cpu, SI address, USI length, int lock)
{
/* If we need to count cycles, then the cache operation will be
initiated from the model profiling functions.
See frvbf_model_.... */
int hsr0 = GET_HSR0 ();
if (GET_HSR0_DCE (hsr0))
{
if (model_insn)
{
CPU_LOAD_ADDRESS (current_cpu) = address;
CPU_LOAD_LENGTH (current_cpu) = length;
CPU_LOAD_LOCK (current_cpu) = lock;
}
else
{
FRV_CACHE *cache = CPU_DATA_CACHE (current_cpu);
frv_cache_preload (cache, address, length, lock);
}
}
}
void
frvbf_insn_cache_unlock (SIM_CPU *current_cpu, SI address)
{
/* If we need to count cycles, then the cache operation will be
initiated from the model profiling functions.
See frvbf_model_.... */
int hsr0 = GET_HSR0 ();
if (GET_HSR0_ICE (hsr0))
{
if (model_insn)
CPU_LOAD_ADDRESS (current_cpu) = address;
else
{
FRV_CACHE *cache = CPU_INSN_CACHE (current_cpu);
frv_cache_unlock (cache, address);
}
}
}
void
frvbf_data_cache_unlock (SIM_CPU *current_cpu, SI address)
{
/* If we need to count cycles, then the cache operation will be
initiated from the model profiling functions.
See frvbf_model_.... */
int hsr0 = GET_HSR0 ();
if (GET_HSR0_DCE (hsr0))
{
if (model_insn)
CPU_LOAD_ADDRESS (current_cpu) = address;
else
{
FRV_CACHE *cache = CPU_DATA_CACHE (current_cpu);
frv_cache_unlock (cache, address);
}
}
}
void
frvbf_insn_cache_invalidate (SIM_CPU *current_cpu, SI address, int all)
{
/* Make sure the insn was specified properly. -1 will be passed for ALL
for a icei with A=0. */
if (all == -1)
{
frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
return;
}
/* If we need to count cycles, then the cache operation will be
initiated from the model profiling functions.
See frvbf_model_.... */
if (model_insn)
{
/* Record the all-entries flag for use in profiling. */
FRV_PROFILE_STATE *ps = CPU_PROFILE_STATE (current_cpu);
ps->all_cache_entries = all;
CPU_LOAD_ADDRESS (current_cpu) = address;
}
else
{
FRV_CACHE *cache = CPU_INSN_CACHE (current_cpu);
if (all)
frv_cache_invalidate_all (cache, 0/* flush? */);
else
frv_cache_invalidate (cache, address, 0/* flush? */);
}
}
void
frvbf_data_cache_invalidate (SIM_CPU *current_cpu, SI address, int all)
{
/* Make sure the insn was specified properly. -1 will be passed for ALL
for a dcei with A=0. */
if (all == -1)
{
frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
return;
}
/* If we need to count cycles, then the cache operation will be
initiated from the model profiling functions.
See frvbf_model_.... */
if (model_insn)
{
/* Record the all-entries flag for use in profiling. */
FRV_PROFILE_STATE *ps = CPU_PROFILE_STATE (current_cpu);
ps->all_cache_entries = all;
CPU_LOAD_ADDRESS (current_cpu) = address;
}
else
{
FRV_CACHE *cache = CPU_DATA_CACHE (current_cpu);
if (all)
frv_cache_invalidate_all (cache, 0/* flush? */);
else
frv_cache_invalidate (cache, address, 0/* flush? */);
}
}
void
frvbf_data_cache_flush (SIM_CPU *current_cpu, SI address, int all)
{
/* Make sure the insn was specified properly. -1 will be passed for ALL
for a dcef with A=0. */
if (all == -1)
{
frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
return;
}
/* If we need to count cycles, then the cache operation will be
initiated from the model profiling functions.
See frvbf_model_.... */
if (model_insn)
{
/* Record the all-entries flag for use in profiling. */
FRV_PROFILE_STATE *ps = CPU_PROFILE_STATE (current_cpu);
ps->all_cache_entries = all;
CPU_LOAD_ADDRESS (current_cpu) = address;
}
else
{
FRV_CACHE *cache = CPU_DATA_CACHE (current_cpu);
if (all)
frv_cache_invalidate_all (cache, 1/* flush? */);
else
frv_cache_invalidate (cache, address, 1/* flush? */);
}
}