/* Extract packed single values: */
#define FP_PS_upper(v) (((v) >> 32) & (unsigned)0xFFFFFFFF)
#define FP_PS_lower(v) ((v) & (unsigned)0xFFFFFFFF)
-#define FP_PS_cat(u,l) (((unsigned64)((u) & (unsigned)0xFFFFFFFF) << 32) \
- | (unsigned64)((l) & 0xFFFFFFFF))
+#define FP_PS_cat(u,l) (((uint64_t)((u) & (unsigned)0xFFFFFFFF) << 32) \
+ | (uint64_t)((l) & 0xFFFFFFFF))
/* Explicit QNaN values. */
#define FPQNaN_SINGLE (0x7FBFFFFF)
address_word cia,
int fcr)
{
- unsigned32 value = 0;
+ uint32_t value = 0;
switch (fcr)
{
int fcr,
unsigned_word value)
{
- unsigned32 v;
+ uint32_t v;
v = VL4_8(value);
switch (fcr)
/* Comparison operations. */
static sim_fpu_status
-fp_test(unsigned64 op1,
- unsigned64 op2,
+fp_test(uint64_t op1,
+ uint64_t op2,
FP_formats fmt,
int abs,
int cond,
void
fp_cmp(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
+ uint64_t op1,
+ uint64_t op2,
FP_formats fmt,
int abs,
int cond,
/* Basic arithmetic operations. */
-static unsigned64
+static uint64_t
fp_unary(sim_cpu *cpu,
address_word cia,
int (*sim_fpu_op)(sim_fpu *, const sim_fpu *),
- unsigned64 op,
+ uint64_t op,
FP_formats fmt)
{
sim_fpu wop;
sim_fpu_round round = rounding_mode (GETRM());
sim_fpu_denorm denorm = denorm_mode (cpu);
sim_fpu_status status = 0;
- unsigned64 result = 0;
+ uint64_t result = 0;
/* The format type has already been checked: */
switch (fmt)
{
case fmt_single:
{
- unsigned32 res;
+ uint32_t res;
sim_fpu_32to (&wop, op);
status |= (*sim_fpu_op) (&ans, &wop);
status |= sim_fpu_round_32 (&ans, round, denorm);
}
case fmt_double:
{
- unsigned64 res;
+ uint64_t res;
sim_fpu_64to (&wop, op);
status |= (*sim_fpu_op) (&ans, &wop);
status |= sim_fpu_round_64 (&ans, round, denorm);
case fmt_ps:
{
int status_u = 0, status_l = 0;
- unsigned32 res_u, res_l;
+ uint32_t res_u, res_l;
sim_fpu_32to (&wop, FP_PS_upper(op));
status_u |= (*sim_fpu_op) (&ans, &wop);
sim_fpu_to32 (&res_u, &ans);
return result;
}
-static unsigned64
+static uint64_t
fp_binary(sim_cpu *cpu,
address_word cia,
int (*sim_fpu_op)(sim_fpu *, const sim_fpu *, const sim_fpu *),
- unsigned64 op1,
- unsigned64 op2,
+ uint64_t op1,
+ uint64_t op2,
FP_formats fmt)
{
sim_fpu wop1;
sim_fpu_round round = rounding_mode (GETRM());
sim_fpu_denorm denorm = denorm_mode (cpu);
sim_fpu_status status = 0;
- unsigned64 result = 0;
+ uint64_t result = 0;
/* The format type has already been checked: */
switch (fmt)
{
case fmt_single:
{
- unsigned32 res;
+ uint32_t res;
sim_fpu_32to (&wop1, op1);
sim_fpu_32to (&wop2, op2);
status |= (*sim_fpu_op) (&ans, &wop1, &wop2);
}
case fmt_double:
{
- unsigned64 res;
+ uint64_t res;
sim_fpu_64to (&wop1, op1);
sim_fpu_64to (&wop2, op2);
status |= (*sim_fpu_op) (&ans, &wop1, &wop2);
case fmt_ps:
{
int status_u = 0, status_l = 0;
- unsigned32 res_u, res_l;
+ uint32_t res_u, res_l;
sim_fpu_32to (&wop1, FP_PS_upper(op1));
sim_fpu_32to (&wop2, FP_PS_upper(op2));
status_u |= (*sim_fpu_op) (&ans, &wop1, &wop2);
/* Common MAC code for single operands (.s or .d), defers setting FCSR. */
static sim_fpu_status
inner_mac(int (*sim_fpu_op)(sim_fpu *, const sim_fpu *, const sim_fpu *),
- unsigned64 op1,
- unsigned64 op2,
- unsigned64 op3,
+ uint64_t op1,
+ uint64_t op2,
+ uint64_t op3,
int scale,
int negate,
FP_formats fmt,
sim_fpu_round round,
sim_fpu_denorm denorm,
- unsigned64 *result)
+ uint64_t *result)
{
sim_fpu wop1;
sim_fpu wop2;
sim_fpu ans;
sim_fpu_status status = 0;
sim_fpu_status op_status;
- unsigned64 temp = 0;
+ uint64_t temp = 0;
switch (fmt)
{
case fmt_single:
{
- unsigned32 res;
+ uint32_t res;
sim_fpu_32to (&wop1, op1);
sim_fpu_32to (&wop2, op2);
status |= sim_fpu_mul (&ans, &wop1, &wop2);
}
case fmt_double:
{
- unsigned64 res;
+ uint64_t res;
sim_fpu_64to (&wop1, op1);
sim_fpu_64to (&wop2, op2);
status |= sim_fpu_mul (&ans, &wop1, &wop2);
argument is an adjustment to the exponent of the intermediate
product op1*op2. It is currently non-zero for rsqrt2 (-1), which
requires an effective division by 2. */
-static unsigned64
+static uint64_t
fp_mac(sim_cpu *cpu,
address_word cia,
int (*sim_fpu_op)(sim_fpu *, const sim_fpu *, const sim_fpu *),
- unsigned64 op1,
- unsigned64 op2,
- unsigned64 op3,
+ uint64_t op1,
+ uint64_t op2,
+ uint64_t op3,
int scale,
int negate,
FP_formats fmt)
sim_fpu_round round = rounding_mode (GETRM());
sim_fpu_denorm denorm = denorm_mode (cpu);
sim_fpu_status status = 0;
- unsigned64 result = 0;
+ uint64_t result = 0;
/* The format type has already been checked: */
switch (fmt)
case fmt_ps:
{
int status_u, status_l;
- unsigned64 result_u, result_l;
+ uint64_t result_u, result_l;
status_u = inner_mac(sim_fpu_op, FP_PS_upper(op1), FP_PS_upper(op2),
FP_PS_upper(op3), scale, negate, fmt_single,
round, denorm, &result_u);
/* Common rsqrt code for single operands (.s or .d), intermediate rounding. */
static sim_fpu_status
-inner_rsqrt(unsigned64 op1,
+inner_rsqrt(uint64_t op1,
FP_formats fmt,
sim_fpu_round round,
sim_fpu_denorm denorm,
- unsigned64 *result)
+ uint64_t *result)
{
sim_fpu wop1;
sim_fpu ans;
sim_fpu_status status = 0;
sim_fpu_status op_status;
- unsigned64 temp = 0;
+ uint64_t temp = 0;
switch (fmt)
{
case fmt_single:
{
- unsigned32 res;
+ uint32_t res;
sim_fpu_32to (&wop1, op1);
status |= sim_fpu_sqrt (&ans, &wop1);
status |= sim_fpu_round_32 (&ans, status, round);
}
case fmt_double:
{
- unsigned64 res;
+ uint64_t res;
sim_fpu_64to (&wop1, op1);
status |= sim_fpu_sqrt (&ans, &wop1);
status |= sim_fpu_round_64 (&ans, round, denorm);
return status;
}
-static unsigned64
+static uint64_t
fp_inv_sqrt(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
+ uint64_t op1,
FP_formats fmt)
{
sim_fpu_round round = rounding_mode (GETRM());
sim_fpu_round denorm = denorm_mode (cpu);
sim_fpu_status status = 0;
- unsigned64 result = 0;
+ uint64_t result = 0;
/* The format type has already been checked: */
switch (fmt)
case fmt_ps:
{
int status_u, status_l;
- unsigned64 result_u, result_l;
+ uint64_t result_u, result_l;
status_u = inner_rsqrt (FP_PS_upper(op1), fmt_single, round, denorm,
&result_u);
status_l = inner_rsqrt (FP_PS_lower(op1), fmt_single, round, denorm,
}
-unsigned64
+uint64_t
fp_abs(sim_cpu *cpu,
address_word cia,
- unsigned64 op,
+ uint64_t op,
FP_formats fmt)
{
return fp_unary(cpu, cia, &sim_fpu_abs, op, fmt);
}
-unsigned64
+uint64_t
fp_neg(sim_cpu *cpu,
address_word cia,
- unsigned64 op,
+ uint64_t op,
FP_formats fmt)
{
return fp_unary(cpu, cia, &sim_fpu_neg, op, fmt);
}
-unsigned64
+uint64_t
fp_add(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
+ uint64_t op1,
+ uint64_t op2,
FP_formats fmt)
{
return fp_binary(cpu, cia, &sim_fpu_add, op1, op2, fmt);
}
-unsigned64
+uint64_t
fp_sub(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
+ uint64_t op1,
+ uint64_t op2,
FP_formats fmt)
{
return fp_binary(cpu, cia, &sim_fpu_sub, op1, op2, fmt);
}
-unsigned64
+uint64_t
fp_mul(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
+ uint64_t op1,
+ uint64_t op2,
FP_formats fmt)
{
return fp_binary(cpu, cia, &sim_fpu_mul, op1, op2, fmt);
}
-unsigned64
+uint64_t
fp_div(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
+ uint64_t op1,
+ uint64_t op2,
FP_formats fmt)
{
return fp_binary(cpu, cia, &sim_fpu_div, op1, op2, fmt);
}
-unsigned64
+uint64_t
fp_recip(sim_cpu *cpu,
address_word cia,
- unsigned64 op,
+ uint64_t op,
FP_formats fmt)
{
return fp_unary(cpu, cia, &sim_fpu_inv, op, fmt);
}
-unsigned64
+uint64_t
fp_sqrt(sim_cpu *cpu,
address_word cia,
- unsigned64 op,
+ uint64_t op,
FP_formats fmt)
{
return fp_unary(cpu, cia, &sim_fpu_sqrt, op, fmt);
}
-unsigned64
+uint64_t
fp_rsqrt(sim_cpu *cpu,
address_word cia,
- unsigned64 op,
+ uint64_t op,
FP_formats fmt)
{
return fp_inv_sqrt(cpu, cia, op, fmt);
}
-unsigned64
+uint64_t
fp_madd(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
- unsigned64 op3,
+ uint64_t op1,
+ uint64_t op2,
+ uint64_t op3,
FP_formats fmt)
{
return fp_mac(cpu, cia, &sim_fpu_add, op1, op2, op3, 0, 0, fmt);
}
-unsigned64
+uint64_t
fp_msub(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
- unsigned64 op3,
+ uint64_t op1,
+ uint64_t op2,
+ uint64_t op3,
FP_formats fmt)
{
return fp_mac(cpu, cia, &sim_fpu_sub, op1, op2, op3, 0, 0, fmt);
}
-unsigned64
+uint64_t
fp_nmadd(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
- unsigned64 op3,
+ uint64_t op1,
+ uint64_t op2,
+ uint64_t op3,
FP_formats fmt)
{
return fp_mac(cpu, cia, &sim_fpu_add, op1, op2, op3, 0, 1, fmt);
}
-unsigned64
+uint64_t
fp_nmsub(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
- unsigned64 op3,
+ uint64_t op1,
+ uint64_t op2,
+ uint64_t op3,
FP_formats fmt)
{
return fp_mac(cpu, cia, &sim_fpu_sub, op1, op2, op3, 0, 1, fmt);
/* MIPS-3D ASE operations. */
/* Variant of fp_binary for *r.ps MIPS-3D operations. */
-static unsigned64
+static uint64_t
fp_binary_r(sim_cpu *cpu,
address_word cia,
int (*sim_fpu_op)(sim_fpu *, const sim_fpu *, const sim_fpu *),
- unsigned64 op1,
- unsigned64 op2)
+ uint64_t op1,
+ uint64_t op2)
{
sim_fpu wop1;
sim_fpu wop2;
sim_fpu_round round = rounding_mode (GETRM ());
sim_fpu_denorm denorm = denorm_mode (cpu);
sim_fpu_status status_u, status_l;
- unsigned64 result;
- unsigned32 res_u, res_l;
+ uint64_t result;
+ uint32_t res_u, res_l;
/* The format must be fmt_ps. */
status_u = 0;
return result;
}
-unsigned64
+uint64_t
fp_add_r(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
+ uint64_t op1,
+ uint64_t op2,
FP_formats fmt)
{
return fp_binary_r (cpu, cia, &sim_fpu_add, op1, op2);
}
-unsigned64
+uint64_t
fp_mul_r(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
+ uint64_t op1,
+ uint64_t op2,
FP_formats fmt)
{
return fp_binary_r (cpu, cia, &sim_fpu_mul, op1, op2);
return fpu_inv1 (f, l);
}
-unsigned64
+uint64_t
fp_recip1(sim_cpu *cpu,
address_word cia,
- unsigned64 op,
+ uint64_t op,
FP_formats fmt)
{
switch (fmt)
return 0;
}
-unsigned64
+uint64_t
fp_recip2(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
+ uint64_t op1,
+ uint64_t op2,
FP_formats fmt)
{
- static const unsigned64 one_single = UNSIGNED64 (0x3F800000);
- static const unsigned64 one_double = UNSIGNED64 (0x3FF0000000000000);
- static const unsigned64 one_ps = (UNSIGNED64 (0x3F800000) << 32 | UNSIGNED64 (0x3F800000));
- unsigned64 one;
+ static const uint64_t one_single = UNSIGNED64 (0x3F800000);
+ static const uint64_t one_double = UNSIGNED64 (0x3FF0000000000000);
+ static const uint64_t one_ps = (UNSIGNED64 (0x3F800000) << 32 | UNSIGNED64 (0x3F800000));
+ uint64_t one;
/* Implemented as nmsub fd, 1, fs, ft. */
switch (fmt)
return fpu_inv_sqrt1 (f, l);
}
-unsigned64
+uint64_t
fp_rsqrt1(sim_cpu *cpu,
address_word cia,
- unsigned64 op,
+ uint64_t op,
FP_formats fmt)
{
switch (fmt)
return 0;
}
-unsigned64
+uint64_t
fp_rsqrt2(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
+ uint64_t op1,
+ uint64_t op2,
FP_formats fmt)
{
- static const unsigned64 half_single = UNSIGNED64 (0x3F000000);
- static const unsigned64 half_double = UNSIGNED64 (0x3FE0000000000000);
- static const unsigned64 half_ps = (UNSIGNED64 (0x3F000000) << 32 | UNSIGNED64 (0x3F000000));
- unsigned64 half;
+ static const uint64_t half_single = UNSIGNED64 (0x3F000000);
+ static const uint64_t half_double = UNSIGNED64 (0x3FE0000000000000);
+ static const uint64_t half_ps = (UNSIGNED64 (0x3F000000) << 32 | UNSIGNED64 (0x3F000000));
+ uint64_t half;
/* Implemented as (nmsub fd, 0.5, fs, ft)/2, where the divide is
done by scaling the exponent during multiply. */
sim_fpu wop;
sim_fpu_round round = rounding_mode (rm);
sim_fpu_denorm denorm = denorm_mode (cpu);
- unsigned32 result32;
- unsigned64 result64;
+ uint32_t result32;
+ uint64_t result64;
sim_fpu_status status = 0;
/* Convert the input to sim_fpu internal format */
return result64;
}
-unsigned64
+uint64_t
ps_lower(sim_cpu *cpu,
address_word cia,
- unsigned64 op)
+ uint64_t op)
{
return FP_PS_lower (op);
}
-unsigned64
+uint64_t
ps_upper(sim_cpu *cpu,
address_word cia,
- unsigned64 op)
+ uint64_t op)
{
return FP_PS_upper(op);
}
-unsigned64
+uint64_t
pack_ps(sim_cpu *cpu,
address_word cia,
- unsigned64 op1,
- unsigned64 op2,
+ uint64_t op1,
+ uint64_t op2,
FP_formats fmt)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
/* The registers must specify FPRs valid for operands of type
"fmt". If they are not valid, the result is undefined. */
case fmt_single:
{
sim_fpu wop;
- unsigned32 res_u, res_l;
+ uint32_t res_u, res_l;
sim_fpu_32to (&wop, op1);
sim_fpu_to32 (&res_u, &wop);
sim_fpu_32to (&wop, op2);
return result;
}
-unsigned64
+uint64_t
convert_ps (sim_cpu *cpu,
address_word cia,
int rm,
- unsigned64 op,
+ uint64_t op,
FP_formats from,
FP_formats to)
{
sim_fpu wop_u, wop_l;
sim_fpu_round round = rounding_mode (rm);
sim_fpu_denorm denorm = denorm_mode (cpu);
- unsigned32 res_u, res_l;
- unsigned64 result;
+ uint32_t res_u, res_l;
+ uint64_t result;
sim_fpu_status status_u = 0, status_l = 0;
/* As convert, but used only for paired values (formats PS, PW) */
case fmt_word: /* fmt_pw */
status_u |= sim_fpu_to32u (&res_u, &wop_u, round);
status_l |= sim_fpu_to32u (&res_l, &wop_l, round);
- result = (((unsigned64)res_u) << 32) | (unsigned64)res_l;
+ result = (((uint64_t)res_u) << 32) | (uint64_t)res_l;
break;
case fmt_ps:
status_u |= sim_fpu_round_32 (&wop_u, 0, round);
:function:::void:do_ph_op:int rd, int rs, int rt, int op, int sat
{
int i;
- signed32 h0 = 0;
- signed16 h1, h2;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned32 result = 0;
+ int32_t h0 = 0;
+ int16_t h1, h2;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint32_t result = 0;
for (i = 0; i < 32; i += 16, v1 >>= 16, v2 >>= 16)
{
- h1 = (signed16)(v1 & 0xffff);
- h2 = (signed16)(v2 & 0xffff);
+ h1 = (int16_t)(v1 & 0xffff);
+ h2 = (int16_t)(v2 & 0xffff);
if (op == 0) // ADD
- h0 = (signed32)h1 + (signed32)h2;
+ h0 = (int32_t)h1 + (int32_t)h2;
else if (op == 1) // SUB
- h0 = (signed32)h1 - (signed32)h2;
+ h0 = (int32_t)h1 - (int32_t)h2;
else // MUL
- h0 = (signed32)h1 * (signed32)h2;
- if (h0 > (signed32)0x7fff || h0 < (signed32)0xffff8000)
+ h0 = (int32_t)h1 * (int32_t)h2;
+ if (h0 > (int32_t)0x7fff || h0 < (int32_t)0xffff8000)
{
if (op == 0 || op == 1) // ADD, SUB
DSPCR |= DSPCR_OUFLAG4;
DSPCR |= DSPCR_OUFLAG5;
if (sat == 1)
{
- if (h0 > (signed32)0x7fff)
+ if (h0 > (int32_t)0x7fff)
h0 = 0x7fff;
else
h0 = 0x8000;
}
}
- result |= ((unsigned32)((unsigned16)h0) << i);
+ result |= ((uint32_t)((uint16_t)h0) << i);
}
GPR[rd] = EXTEND32 (result);
}
// op: 0 = ADD, 1 = SUB
:function:::void:do_w_op:int rd, int rs, int rt, int op
{
- signed64 h0;
- signed32 h1, h2;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned32 result = 0;
- h1 = (signed32)v1;
- h2 = (signed32)v2;
+ int64_t h0;
+ int32_t h1, h2;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint32_t result = 0;
+ h1 = (int32_t)v1;
+ h2 = (int32_t)v2;
if (op == 0) // ADD
- h0 = (signed64)h1 + (signed64)h2;
+ h0 = (int64_t)h1 + (int64_t)h2;
else // SUB
- h0 = (signed64)h1 - (signed64)h2;
+ h0 = (int64_t)h1 - (int64_t)h2;
if (((h0 & 0x100000000LL) >> 1) != (h0 & 0x80000000))
{
DSPCR |= DSPCR_OUFLAG4;
:function:::void:do_qb_op:int rd, int rs, int rt, int op, int sat
{
int i;
- unsigned32 h0;
- unsigned8 h1, h2;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned32 result = 0;
+ uint32_t h0;
+ uint8_t h1, h2;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint32_t result = 0;
for (i = 0; i < 32; i += 8, v1 >>= 8, v2 >>= 8)
{
- h1 = (unsigned8)(v1 & 0xff);
- h2 = (unsigned8)(v2 & 0xff);
+ h1 = (uint8_t)(v1 & 0xff);
+ h2 = (uint8_t)(v2 & 0xff);
if (op == 0) // ADD
- h0 = (unsigned32)h1 + (unsigned32)h2;
+ h0 = (uint32_t)h1 + (uint32_t)h2;
else // SUB
- h0 = (unsigned32)h1 - (unsigned32)h2;
+ h0 = (uint32_t)h1 - (uint32_t)h2;
if (h0 & 0x100)
{
DSPCR |= DSPCR_OUFLAG4;
h0 = 0;
}
}
- result |= ((unsigned32)((unsigned8)h0) << i);
+ result |= ((uint32_t)((uint8_t)h0) << i);
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_qb_shift:int rd, int rt, int shift, int op
{
int i, j;
- unsigned8 h0;
- unsigned32 v1 = GPR[rt];
- unsigned32 result = 0;
+ uint8_t h0;
+ uint32_t v1 = GPR[rt];
+ uint32_t result = 0;
for (i = 0; i < 32; i += 8, v1 >>= 8)
{
- h0 = (unsigned8)(v1 & 0xff);
+ h0 = (uint8_t)(v1 & 0xff);
if (op == 0) // left
{
for (j = 7; j >= 8 - shift; j--)
}
else // right
h0 = h0 >> shift;
- result |= ((unsigned32)h0 << i);
+ result |= ((uint32_t)h0 << i);
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_ph_shift:int rd, int rt, int shift, int op, int sat
{
int i, j;
- signed16 h0;
- unsigned32 v1 = GPR[rt];
- unsigned32 result = 0;
+ int16_t h0;
+ uint32_t v1 = GPR[rt];
+ uint32_t result = 0;
int setcond;
for (i = 0; i < 32; i += 16, v1 >>= 16)
{
- h0 = (signed16)(v1 & 0xffff);
+ h0 = (int16_t)(v1 & 0xffff);
if (op == 0) // left
{
setcond = 0;
h0 = h0 >> shift;
}
- result |= ((unsigned32)((unsigned16)h0) << i);
+ result |= ((uint32_t)((uint16_t)h0) << i);
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_w_shll:int rd, int rt, int shift
{
int i;
- unsigned32 v1 = GPR[rt];
- unsigned32 result = 0;
+ uint32_t v1 = GPR[rt];
+ uint32_t result = 0;
int setcond = 0;
if (v1 & (1 << 31))
{
:function:::void:do_ph_s_absq:int rd, int rt
{
int i;
- signed16 h0;
- unsigned32 v1 = GPR[rt];
- unsigned32 result = 0;
+ int16_t h0;
+ uint32_t v1 = GPR[rt];
+ uint32_t result = 0;
for (i = 0; i < 32; i += 16, v1 >>= 16)
{
- h0 = (signed16)(v1 & 0xffff);
- if (h0 == (signed16)0x8000)
+ h0 = (int16_t)(v1 & 0xffff);
+ if (h0 == (int16_t)0x8000)
{
DSPCR |= DSPCR_OUFLAG4;
h0 = 0x7fff;
}
else if (h0 & 0x8000)
h0 = -h0;
- result |= ((unsigned32)((unsigned16)h0) << i);
+ result |= ((uint32_t)((uint16_t)h0) << i);
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_w_s_absq:int rd, int rt
{
- unsigned32 v1 = GPR[rt];
- signed32 h0 = (signed32)v1;
- if (h0 == (signed32)0x80000000)
+ uint32_t v1 = GPR[rt];
+ int32_t h0 = (int32_t)v1;
+ if (h0 == (int32_t)0x80000000)
{
DSPCR |= DSPCR_OUFLAG4;
h0 = 0x7fffffff;
:function:::void:do_qb_s_absq:int rd, int rt
{
int i;
- signed8 q0;
- unsigned32 v1 = GPR[rt];
- unsigned32 result = 0;
+ int8_t q0;
+ uint32_t v1 = GPR[rt];
+ uint32_t result = 0;
for (i = 0; i < 32; i += 8, v1 >>= 8)
{
- q0 = (signed8)(v1 & 0xff);
- if (q0 == (signed8)0x80)
+ q0 = (int8_t)(v1 & 0xff);
+ if (q0 == (int8_t)0x80)
{
DSPCR |= DSPCR_OUFLAG4;
q0 = 0x7f;
}
else if (q0 & 0x80)
q0 = -q0;
- result |= ((unsigned32)((unsigned8)q0) << i);
+ result |= ((uint32_t)((uint8_t)q0) << i);
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_addsc:int rd, int rs, int rt
{
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned64 h0;
- h0 = (unsigned64)v1 + (unsigned64)v2;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint64_t h0;
+ h0 = (uint64_t)v1 + (uint64_t)v2;
if (h0 & 0x100000000LL)
DSPCR |= DSPCR_CARRY;
GPR[rd] = EXTEND32 (h0);
:function:::void:do_addwc:int rd, int rs, int rt
{
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned64 h0;
- signed32 h1 = (signed32) v1;
- signed32 h2 = (signed32) v2;
- h0 = (signed64)h1 + (signed64)h2
- + (signed64)((DSPCR >> DSPCR_CARRY_SHIFT) & DSPCR_CARRY_MASK);
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint64_t h0;
+ int32_t h1 = (int32_t) v1;
+ int32_t h2 = (int32_t) v2;
+ h0 = (int64_t)h1 + (int64_t)h2
+ + (int64_t)((DSPCR >> DSPCR_CARRY_SHIFT) & DSPCR_CARRY_MASK);
if (((h0 & 0x100000000LL) >> 1) != (h0 & 0x80000000))
DSPCR |= DSPCR_OUFLAG4;
GPR[rd] = EXTEND32 (h0);
:function:::void:do_bitrev:int rd, int rt
{
int i;
- unsigned32 v1 = GPR[rt];
- unsigned32 h1 = 0;
+ uint32_t v1 = GPR[rt];
+ uint32_t h1 = 0;
for (i = 0; i < 16; i++)
{
if (v1 & (1 << i))
// op: 0 = EXTPV, 1 = EXTPDPV
:function:::void:do_extpv:int rt, int ac, int rs, int op
{
- unsigned32 size = GPR[rs] & 0x1f;
+ uint32_t size = GPR[rs] & 0x1f;
do_extp (SD_, rt, ac, size, op);
}
// op: 0 = EXTRV, 1 = EXTRV_R, 2 = EXTRV_RS
:function:::void:do_extrv:int rt, int ac, int rs, int op
{
- unsigned32 shift = GPR[rs] & 0x1f;
+ uint32_t shift = GPR[rs] & 0x1f;
do_w_extr (SD_, rt, ac, shift, op);
}
:function:::void:do_extrv_s_h:int rt, int ac, int rs
{
- unsigned32 shift = GPR[rs] & 0x1f;
+ uint32_t shift = GPR[rs] & 0x1f;
do_h_extr (SD_, rt, ac, shift);
}
:function:::void:do_insv:int rt, int rs
{
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned32 pos = (DSPCR >> DSPCR_POS_SHIFT) & DSPCR_POS_MASK;
- unsigned32 size = (DSPCR >> DSPCR_SCOUNT_SHIFT) & DSPCR_SCOUNT_MASK;
- unsigned32 mask1, mask2, mask3, result;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint32_t pos = (DSPCR >> DSPCR_POS_SHIFT) & DSPCR_POS_MASK;
+ uint32_t size = (DSPCR >> DSPCR_SCOUNT_SHIFT) & DSPCR_SCOUNT_MASK;
+ uint32_t mask1, mask2, mask3, result;
if (size < 32)
mask1 = (1 << size) - 1;
else
:function:::void:do_modsub:int rd, int rs, int rt
{
- unsigned32 result = 0;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned32 decr = v2 & 0xff;
- unsigned32 lastindex = (v2 & 0xffff00) >> 8;
+ uint32_t result = 0;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint32_t decr = v2 & 0xff;
+ uint32_t lastindex = (v2 & 0xffff00) >> 8;
if (v1 == 0)
result = lastindex;
else
:function:::void:do_mthlip:int rs, int ac
{
- unsigned32 pos = (DSPCR >> DSPCR_POS_SHIFT) & DSPCR_POS_MASK;
+ uint32_t pos = (DSPCR >> DSPCR_POS_SHIFT) & DSPCR_POS_MASK;
DSPHI(ac) = DSPLO(ac);
DSPLO(ac) = GPR[rs];
if (pos >= 32)
:function:::void:do_mulsaq_s_w_ph:int ac, int rs, int rt
{
int i;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed16 h1, h2;
- signed32 result;
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- signed64 prod = (signed64)((((unsigned64)hi) << 32) + (unsigned64)lo);
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int16_t h1, h2;
+ int32_t result;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ int64_t prod = (int64_t)((((uint64_t)hi) << 32) + (uint64_t)lo);
for (i = 0; i < 32; i += 16, v1 >>= 16, v2 >>= 16)
{
- h1 = (signed16)(v1 & 0xffff);
- h2 = (signed16)(v2 & 0xffff);
- if (h1 == (signed16)0x8000 && h2 == (signed16)0x8000)
+ h1 = (int16_t)(v1 & 0xffff);
+ h2 = (int16_t)(v2 & 0xffff);
+ if (h1 == (int16_t)0x8000 && h2 == (int16_t)0x8000)
{
DSPCR |= (1 << (DSPCR_OUFLAG_SHIFT + ac));
- result = (signed32) 0x7fffffff;
+ result = (int32_t) 0x7fffffff;
}
else
- result = ((signed32)h1 * (signed32)h2) << 1;
+ result = ((int32_t)h1 * (int32_t)h2) << 1;
if (i == 0)
- prod -= (signed64) result;
+ prod -= (int64_t) result;
else
- prod += (signed64) result;
+ prod += (int64_t) result;
}
DSPLO(ac) = EXTEND32 (prod);
DSPHI(ac) = EXTEND32 (prod >> 32);
:function:::void:do_ph_packrl:int rd, int rs, int rt
{
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
GPR[rd] = EXTEND32 ((v1 << 16) + (v2 >> 16));
}
:function:::void:do_qb_pick:int rd, int rs, int rt
{
int i, j;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned8 h1, h2;
- unsigned32 result = 0;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint8_t h1, h2;
+ uint32_t result = 0;
for (i = 0, j = 0; i < 32; i += 8, j++, v1 >>= 8, v2 >>= 8)
{
- h1 = (unsigned8)(v1 & 0xff);
- h2 = (unsigned8)(v2 & 0xff);
+ h1 = (uint8_t)(v1 & 0xff);
+ h2 = (uint8_t)(v2 & 0xff);
if (DSPCR & (1 << (DSPCR_CCOND_SHIFT + j)))
- result |= (unsigned32)(h1 << i);
+ result |= (uint32_t)(h1 << i);
else
- result |= (unsigned32)(h2 << i);
+ result |= (uint32_t)(h2 << i);
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_ph_pick:int rd, int rs, int rt
{
int i, j;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned16 h1, h2;
- unsigned32 result = 0;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint16_t h1, h2;
+ uint32_t result = 0;
for (i = 0, j = 0; i < 32; i += 16, j++, v1 >>= 16, v2 >>= 16)
{
- h1 = (unsigned16)(v1 & 0xffff);
- h2 = (unsigned16)(v2 & 0xffff);
+ h1 = (uint16_t)(v1 & 0xffff);
+ h2 = (uint16_t)(v2 & 0xffff);
if (DSPCR & (1 << (DSPCR_CCOND_SHIFT + j)))
- result |= (unsigned32)(h1 << i);
+ result |= (uint32_t)(h1 << i);
else
- result |= (unsigned32)(h2 << i);
+ result |= (uint32_t)(h2 << i);
}
GPR[rd] = EXTEND32 (result);
}
// op: 0 = QBR, 1 = QBRA, 2 = QBL, 3 = QBLA
:function:::void:do_qb_ph_precequ:int rd, int rt, int op
{
- unsigned32 v1 = GPR[rt];
+ uint32_t v1 = GPR[rt];
if (op == 0)
GPR[rd] = EXTEND32 ((v1 & 0xff00) << 15) | ((v1 & 0xff) << 7);
else if (op == 1)
// op: 0 = QBR, 1 = QBRA, 2 = QBL, 3 = QBLA
:function:::void:do_qb_ph_preceu:int rd, int rt, int op
{
- unsigned32 v1 = GPR[rt];
+ uint32_t v1 = GPR[rt];
if (op == 0)
GPR[rd] = EXTEND32 ((v1 & 0xff00) << 8) | (v1 & 0xff);
else if (op == 1)
// op: 0 = .PHL, 1 = PHR
:function:::void:do_w_preceq:int rd, int rt, int op
{
- unsigned32 v1 = GPR[rt];
+ uint32_t v1 = GPR[rt];
if (op == 0)
GPR[rd] = EXTEND32 (v1 & 0xffff0000);
else if (op == 1)
:function:::void:do_w_ph_precrq:int rd, int rs, int rt
{
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned32 tempu = (v1 & 0xffff0000) >> 16;
- unsigned32 tempv = (v2 & 0xffff0000) >> 16;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint32_t tempu = (v1 & 0xffff0000) >> 16;
+ uint32_t tempv = (v2 & 0xffff0000) >> 16;
GPR[rd] = EXTEND32 ((tempu << 16) | tempv);
}
// sat: 0 = PRECRQ.QB.PH, 1 = PRECRQU_S.QB.PH
:function:::void:do_ph_qb_precrq:int rd, int rs, int rt, int sat
{
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned32 tempu = 0, tempv = 0, tempw = 0, tempx = 0;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint32_t tempu = 0, tempv = 0, tempw = 0, tempx = 0;
if (sat == 0)
{
tempu = (v1 & 0xff000000) >> 24;
DSPCR |= DSPCR_OUFLAG6;
tempu = 0;
}
- else if (!(v1 & 0x80000000) && ((v1 >> 16) > (unsigned32)0x7f80))
+ else if (!(v1 & 0x80000000) && ((v1 >> 16) > (uint32_t)0x7f80))
{
DSPCR |= DSPCR_OUFLAG6;
tempu = 0xff;
DSPCR |= DSPCR_OUFLAG6;
tempv = 0;
}
- else if (!(v1 & 0x8000) && ((v1 & 0xffff) > (unsigned32)0x7f80))
+ else if (!(v1 & 0x8000) && ((v1 & 0xffff) > (uint32_t)0x7f80))
{
DSPCR |= DSPCR_OUFLAG6;
tempv = 0xff;
DSPCR |= DSPCR_OUFLAG6;
tempw = 0;
}
- else if (!(v2 & 0x80000000) && ((v2 >> 16) > (unsigned32)0x7f80))
+ else if (!(v2 & 0x80000000) && ((v2 >> 16) > (uint32_t)0x7f80))
{
DSPCR |= DSPCR_OUFLAG6;
tempw = 0xff;
DSPCR |= DSPCR_OUFLAG6;
tempx = 0;
}
- else if (!(v2 & 0x8000) && ((v2 & 0xffff) > (unsigned32)0x7f80))
+ else if (!(v2 & 0x8000) && ((v2 & 0xffff) > (uint32_t)0x7f80))
{
DSPCR |= DSPCR_OUFLAG6;
tempx = 0xff;
:function:::void:do_w_ph_rs_precrq:int rd, int rs, int rt
{
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed32 h1 = (signed32)v1;
- signed32 h2 = (signed32)v2;
- signed64 temp1 = (signed64)h1 + (signed64)0x8000;
- signed32 temp2;
- signed64 temp3 = (signed64)h2 + (signed64)0x8000;
- signed32 temp4;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int32_t h1 = (int32_t)v1;
+ int32_t h2 = (int32_t)v2;
+ int64_t temp1 = (int64_t)h1 + (int64_t)0x8000;
+ int32_t temp2;
+ int64_t temp3 = (int64_t)h2 + (int64_t)0x8000;
+ int32_t temp4;
if (((temp1 & 0x100000000LL) >> 1) != (temp1 & 0x80000000))
{
DSPCR |= DSPCR_OUFLAG6;
temp2 = 0x7fff;
}
else
- temp2 = (signed32)((temp1 & 0xffff0000) >> 16);
+ temp2 = (int32_t)((temp1 & 0xffff0000) >> 16);
if (((temp3 & 0x100000000LL) >> 1) != (temp3 & 0x80000000))
{
DSPCR |= DSPCR_OUFLAG6;
temp4 = 0x7fff;
}
else
- temp4 = (signed32)((temp3 & 0xffff0000) >> 16);
+ temp4 = (int32_t)((temp3 & 0xffff0000) >> 16);
GPR[rd] = EXTEND32 ((temp2 << 16) | temp4);
}
:function:::void:do_qb_w_raddu:int rd, int rs
{
int i;
- unsigned8 h0;
- unsigned32 v1 = GPR[rs];
- unsigned32 result = 0;
+ uint8_t h0;
+ uint32_t v1 = GPR[rs];
+ uint32_t result = 0;
for (i = 0; i < 32; i += 8, v1 >>= 8)
{
- h0 = (unsigned8)(v1 & 0xff);
- result += (unsigned32)h0;
+ h0 = (uint8_t)(v1 & 0xff);
+ result += (uint32_t)h0;
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_rddsp:int rd, int mask
{
- unsigned32 result = 0;
+ uint32_t result = 0;
if (mask & 0x1)
{
result &= (~DSPCR_POS_SMASK);
GPR[rd] = EXTEND32 ((p2 << 24) | (p2 << 16) | (p2 << 8) | p2);
else if (op == 1)
{
- unsigned32 v1 = GPR[p2] & 0xff;
+ uint32_t v1 = GPR[p2] & 0xff;
GPR[rd] = EXTEND32 ((v1 << 24) | (v1 << 16) | (v1 << 8) | v1);
}
else if (op == 2)
{
- signed32 v1 = p2;
+ int32_t v1 = p2;
if (v1 & 0x200)
v1 |= 0xfffffc00;
GPR[rd] = EXTEND32 ((v1 << 16) | (v1 & 0xffff));
}
else if (op == 3)
{
- unsigned32 v1 = GPR[p2];
+ uint32_t v1 = GPR[p2];
v1 = v1 & 0xffff;
GPR[rd] = EXTEND32 ((v1 << 16) | v1);
}
:function:::void:do_shilov:int ac, int rs
{
- signed32 shift = GPR[rs] & 0x3f;
+ int32_t shift = GPR[rs] & 0x3f;
do_shilo (SD_, ac, shift);
}
// sat: 0 = normal, 1 = saturate/rounding
:function:::void:do_ph_shl:int rd, int rt, int rs, int op, int sat
{
- unsigned32 shift = GPR[rs] & 0xf;
+ uint32_t shift = GPR[rs] & 0xf;
do_ph_shift (SD_, rd, rt, shift, op, sat);
}
// op: 0 = SHLLV, 1 = SHRLV
:function:::void:do_qb_shl:int rd, int rt, int rs, int op
{
- unsigned32 shift = GPR[rs] & 0x7;
+ uint32_t shift = GPR[rs] & 0x7;
do_qb_shift (SD_, rd, rt, shift, op);
}
:function:::void:do_w_s_shllv:int rd, int rt, int rs
{
- unsigned32 shift = GPR[rs] & 0x1f;
+ uint32_t shift = GPR[rs] & 0x1f;
do_w_shll (SD_, rd, rt, shift);
}
:function:::void:do_ph_shrlv:int rd, int rt, int rs
{
- unsigned32 shift = GPR[rs] & 0xf;
+ uint32_t shift = GPR[rs] & 0xf;
do_ph_shrl (SD_, rd, rt, shift);
}
:function:::void:do_w_r_shrav:int rd, int rt, int rs
{
- unsigned32 shift = GPR[rs] & 0x1f;
+ uint32_t shift = GPR[rs] & 0x1f;
do_w_shra (SD_, rd, rt, shift);
}
:function:::void:do_wrdsp:int rs, int mask
{
- unsigned32 v1 = GPR[rs];
+ uint32_t v1 = GPR[rs];
if (mask & 0x1)
{
DSPCR &= (~DSPCR_POS_SMASK);
// round: 0 = no rounding, 1 = rounding
:function:::void:do_qb_shrav:int rd, int rt, int rs, int round
{
- unsigned32 shift = GPR[rs] & 0x7;
+ uint32_t shift = GPR[rs] & 0x7;
do_qb_shra (SD_, rd, rt, shift, round);
}
:function:::void:do_append:int rt, int rs, int sa
{
- unsigned32 v0 = GPR[rs];
- unsigned32 v1 = GPR[rt];
- unsigned32 result;
- unsigned32 mask = (1 << sa) - 1;
+ uint32_t v0 = GPR[rs];
+ uint32_t v1 = GPR[rt];
+ uint32_t result;
+ uint32_t mask = (1 << sa) - 1;
result = (v1 << sa) | (v0 & mask);
GPR[rt] = EXTEND32 (result);
}
:function:::void:do_balign:int rt, int rs, int bp
{
- unsigned32 v0 = GPR[rs];
- unsigned32 v1 = GPR[rt];
- unsigned32 result;
+ uint32_t v0 = GPR[rs];
+ uint32_t v1 = GPR[rt];
+ uint32_t result;
if (bp == 0)
result = v1;
else
:function:::void:do_ph_w_mulsa:int ac, int rs, int rt
{
int i;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed16 h1, h2;
- signed32 result;
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- signed64 prod = (signed64)((((unsigned64)hi) << 32) + (unsigned64)lo);
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int16_t h1, h2;
+ int32_t result;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ int64_t prod = (int64_t)((((uint64_t)hi) << 32) + (uint64_t)lo);
for (i = 0; i < 32; i += 16, v1 >>= 16, v2 >>= 16)
{
- h1 = (signed16)(v1 & 0xffff);
- h2 = (signed16)(v2 & 0xffff);
- result = (signed32)h1 * (signed32)h2;
+ h1 = (int16_t)(v1 & 0xffff);
+ h2 = (int16_t)(v2 & 0xffff);
+ result = (int32_t)h1 * (int32_t)h2;
if (i == 0)
- prod -= (signed64) result;
+ prod -= (int64_t) result;
else
- prod += (signed64) result;
+ prod += (int64_t) result;
}
DSPLO(ac) = EXTEND32 (prod);
DSPHI(ac) = EXTEND32 (prod >> 32);
:function:::void:do_ph_qb_precr:int rd, int rs, int rt
{
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned32 tempu = (v1 & 0xff0000) >> 16;
- unsigned32 tempv = (v1 & 0xff);
- unsigned32 tempw = (v2 & 0xff0000) >> 16;
- unsigned32 tempx = (v2 & 0xff);
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint32_t tempu = (v1 & 0xff0000) >> 16;
+ uint32_t tempv = (v1 & 0xff);
+ uint32_t tempw = (v2 & 0xff0000) >> 16;
+ uint32_t tempx = (v2 & 0xff);
GPR[rd] = EXTEND32 ((tempu << 24) | (tempv << 16) | (tempw << 8) | tempx);
}
:function:::void:do_prepend:int rt, int rs, int sa
{
- unsigned32 v0 = GPR[rs];
- unsigned32 v1 = GPR[rt];
- unsigned32 result;
+ uint32_t v0 = GPR[rs];
+ uint32_t v1 = GPR[rt];
+ uint32_t result;
if (sa == 0)
result = v1;
else
:function:::void:do_w_shra:int rd, int rt, int shift
{
- unsigned32 result = GPR[rt];
- signed32 h0 = (signed32)result;
+ uint32_t result = GPR[rt];
+ int32_t h0 = (int32_t)result;
if (shift != 0 && (h0 & (1 << (shift-1))))
h0 = (h0 >> shift) + 1;
else
:function:::void:do_qb_muleu:int rd, int rs, int rt, int loc
{
int i;
- unsigned32 result = 0;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned16 h1, h2;
- unsigned32 prod;
+ uint32_t result = 0;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint16_t h1, h2;
+ uint32_t prod;
if (loc == 0)
v1 >>= 16;
for (i = 0; i < 32; i += 16, v1 >>= 8, v2 >>= 16)
{
- h1 = (unsigned16)(v1 & 0xff);
- h2 = (unsigned16)(v2 & 0xffff);
- prod = (unsigned32)h1 * (unsigned32)h2;
+ h1 = (uint16_t)(v1 & 0xff);
+ h2 = (uint16_t)(v2 & 0xffff);
+ prod = (uint32_t)h1 * (uint32_t)h2;
if (prod > 0xffff)
{
DSPCR |= DSPCR_OUFLAG5;
prod = 0xffff;
}
- result |= ((unsigned32)prod << i);
+ result |= ((uint32_t)prod << i);
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_ph_mulq:int rd, int rs, int rt, int round
{
int i;
- unsigned32 result = 0;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed16 h1, h2;
- signed32 prod;
+ uint32_t result = 0;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int16_t h1, h2;
+ int32_t prod;
for (i = 0; i < 32; i += 16, v1 >>= 16, v2 >>= 16)
{
- h1 = (signed16)(v1 & 0xffff);
- h2 = (signed16)(v2 & 0xffff);
- if (h1 == (signed16)0x8000 && h2 == (signed16)0x8000)
+ h1 = (int16_t)(v1 & 0xffff);
+ h2 = (int16_t)(v2 & 0xffff);
+ if (h1 == (int16_t)0x8000 && h2 == (int16_t)0x8000)
{
DSPCR |= DSPCR_OUFLAG5;
prod = 0x7fffffff;
}
else
{
- prod = ((signed32)h1 * (signed32)h2) << 1;
+ prod = ((int32_t)h1 * (int32_t)h2) << 1;
if (round == 1)
- prod += (signed32)0x8000;
+ prod += (int32_t)0x8000;
}
- result |= (((unsigned32)prod >> 16) << i);
+ result |= (((uint32_t)prod >> 16) << i);
}
GPR[rd] = EXTEND32 (result);
}
// loc: 0 = phl, 1 = phr
:function:::void:do_ph_muleq:int rd, int rs, int rt, int loc
{
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed16 h1, h2;
- signed32 prod;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int16_t h1, h2;
+ int32_t prod;
if (loc == 0)
{
- h1 = (signed16)(v1 >> 16);
- h2 = (signed16)(v2 >> 16);
+ h1 = (int16_t)(v1 >> 16);
+ h2 = (int16_t)(v2 >> 16);
}
else
{
- h1 = (signed16)(v1 & 0xffff);
- h2 = (signed16)(v2 & 0xffff);
+ h1 = (int16_t)(v1 & 0xffff);
+ h2 = (int16_t)(v2 & 0xffff);
}
- if (h1 == (signed16)0x8000 && h2 == (signed16)0x8000)
+ if (h1 == (int16_t)0x8000 && h2 == (int16_t)0x8000)
{
DSPCR |= DSPCR_OUFLAG5;
prod = 0x7fffffff;
}
else
- prod = ((signed32)h1 * (signed32)h2) << 1;
+ prod = ((int32_t)h1 * (int32_t)h2) << 1;
GPR[rd] = EXTEND32 (prod);
}
:function:::void:do_qb_dot_product:int ac, int rs, int rt, int op, int loc
{
int i;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned8 h1, h2;
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- unsigned64 prod = (((unsigned64)hi) << 32) + (unsigned64)lo;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint8_t h1, h2;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ uint64_t prod = (((uint64_t)hi) << 32) + (uint64_t)lo;
if (loc == 0)
{
v1 >>= 16;
}
for (i = 0; i < 16; i += 8, v1 >>= 8, v2 >>= 8)
{
- h1 = (unsigned8)(v1 & 0xff);
- h2 = (unsigned8)(v2 & 0xff);
+ h1 = (uint8_t)(v1 & 0xff);
+ h2 = (uint8_t)(v2 & 0xff);
if (op == 0) // DPAU
- prod += (unsigned64)h1 * (unsigned64)h2;
+ prod += (uint64_t)h1 * (uint64_t)h2;
else // DPSU
- prod -= (unsigned64)h1 * (unsigned64)h2;
+ prod -= (uint64_t)h1 * (uint64_t)h2;
}
DSPLO(ac) = EXTEND32 (prod);
DSPHI(ac) = EXTEND32 (prod >> 32);
:function:::void:do_ph_dot_product:int ac, int rs, int rt, int op
{
int i;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed16 h1, h2;
- signed32 result;
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- signed64 prod = (signed64)((((unsigned64)hi) << 32) + (unsigned64)lo);
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int16_t h1, h2;
+ int32_t result;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ int64_t prod = (int64_t)((((uint64_t)hi) << 32) + (uint64_t)lo);
for (i = 0; i < 32; i += 16, v1 >>= 16, v2 >>= 16)
{
- h1 = (signed16)(v1 & 0xffff);
- h2 = (signed16)(v2 & 0xffff);
- if (h1 == (signed16)0x8000 && h2 == (signed16)0x8000)
+ h1 = (int16_t)(v1 & 0xffff);
+ h2 = (int16_t)(v2 & 0xffff);
+ if (h1 == (int16_t)0x8000 && h2 == (int16_t)0x8000)
{
DSPCR |= (1 << (DSPCR_OUFLAG_SHIFT + ac));
- result = (signed32)0x7fffffff;
+ result = (int32_t)0x7fffffff;
}
else
- result = ((signed32)h1 * (signed32)h2) << 1;
+ result = ((int32_t)h1 * (int32_t)h2) << 1;
if (op == 0) // DPAQ
- prod += (signed64)result;
+ prod += (int64_t)result;
else // DPSQ
- prod -= (signed64)result;
+ prod -= (int64_t)result;
}
DSPLO(ac) = EXTEND32 (prod);
DSPHI(ac) = EXTEND32 (prod >> 32);
// op: 0 = DPAQ 1 = DPSQ
:function:::void:do_w_dot_product:int ac, int rs, int rt, int op
{
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed32 h1, h2;
- signed64 result;
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- unsigned32 resultlo;
- unsigned32 resulthi;
- unsigned32 carry;
- unsigned64 temp1;
- signed64 temp2;
- h1 = (signed32) v1;
- h2 = (signed32) v2;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int32_t h1, h2;
+ int64_t result;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ uint32_t resultlo;
+ uint32_t resulthi;
+ uint32_t carry;
+ uint64_t temp1;
+ int64_t temp2;
+ h1 = (int32_t) v1;
+ h2 = (int32_t) v2;
if (h1 == 0x80000000 && h2 == 0x80000000)
{
DSPCR |= (1 << (DSPCR_OUFLAG_SHIFT + ac));
- result = (signed64) 0x7fffffffffffffffLL;
+ result = (int64_t) 0x7fffffffffffffffLL;
}
else
- result = ((signed64)h1 * (signed64)h2) << 1;
- resultlo = (unsigned32)(result);
- resulthi = (unsigned32)(result >> 32);
+ result = ((int64_t)h1 * (int64_t)h2) << 1;
+ resultlo = (uint32_t)(result);
+ resulthi = (uint32_t)(result >> 32);
if (op ==0) // DPAQ
{
- temp1 = (unsigned64)lo + (unsigned64)resultlo;
- carry = (unsigned32)((temp1 >> 32) & 1);
- temp2 = (signed64)((signed32)hi) + (signed64)((signed32)resulthi) +
- (signed64)((signed32)carry);
+ temp1 = (uint64_t)lo + (uint64_t)resultlo;
+ carry = (uint32_t)((temp1 >> 32) & 1);
+ temp2 = (int64_t)((int32_t)hi) + (int64_t)((int32_t)resulthi) +
+ (int64_t)((int32_t)carry);
}
else // DPSQ
{
- temp1 = (unsigned64)lo - (unsigned64)resultlo;
- carry = (unsigned32)((temp1 >> 32) & 1);
- temp2 = (signed64)((signed32)hi) - (signed64)((signed32)resulthi) -
- (signed64)((signed32)carry);
+ temp1 = (uint64_t)lo - (uint64_t)resultlo;
+ carry = (uint32_t)((temp1 >> 32) & 1);
+ temp2 = (int64_t)((int32_t)hi) - (int64_t)((int32_t)resulthi) -
+ (int64_t)((int32_t)carry);
}
if (((temp2 & 0x100000000LL) >> 1) != (temp2 & 0x80000000LL))
{
:function:::void:do_ph_maq:int ac, int rs, int rt, int op, int loc
{
int i;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed16 h1, h2;
- signed32 result;
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- signed64 prod = (signed64)((((unsigned64)hi) << 32) + (unsigned64)lo);
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int16_t h1, h2;
+ int32_t result;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ int64_t prod = (int64_t)((((uint64_t)hi) << 32) + (uint64_t)lo);
if (loc == 0)
{
- h1 = (signed16)(v1 >> 16);
- h2 = (signed16)(v2 >> 16);
+ h1 = (int16_t)(v1 >> 16);
+ h2 = (int16_t)(v2 >> 16);
}
else
{
- h1 = (signed16)(v1 & 0xffff);
- h2 = (signed16)(v2 & 0xffff);
+ h1 = (int16_t)(v1 & 0xffff);
+ h2 = (int16_t)(v2 & 0xffff);
}
- if (h1 == (signed16)0x8000 && h2 == (signed16)0x8000)
+ if (h1 == (int16_t)0x8000 && h2 == (int16_t)0x8000)
{
DSPCR |= (1 << (DSPCR_OUFLAG_SHIFT + ac));
- result = (signed32)0x7fffffff;
+ result = (int32_t)0x7fffffff;
}
else
- result = ((signed32)h1 * (signed32)h2) << 1;
- prod += (signed64)result;
+ result = ((int32_t)h1 * (int32_t)h2) << 1;
+ prod += (int64_t)result;
if (op == 1) // MAQ_SA
{
if (prod & 0x8000000000000000LL)
{
for (i = 62; i >= 31; i--)
{
- if (!(prod & ((signed64)1 << i)))
+ if (!(prod & ((int64_t)1 << i)))
{
DSPCR |= (1 << (DSPCR_OUFLAG_SHIFT + ac));
prod = 0xffffffff80000000LL;
{
for (i = 62; i >= 31; i--)
{
- if (prod & ((signed64)1 << i))
+ if (prod & ((int64_t)1 << i))
{
DSPCR |= (1 << (DSPCR_OUFLAG_SHIFT + ac));
prod = 0x7fffffff;
:function:::void:do_qb_cmpu:int rs, int rt, int op
{
int i, j;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned8 h1, h2;
- unsigned32 mask;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint8_t h1, h2;
+ uint32_t mask;
for (i = 0, j = 0; i < 32; i += 8, j++, v1 >>= 8, v2 >>= 8)
{
- h1 = (unsigned8)(v1 & 0xff);
- h2 = (unsigned8)(v2 & 0xff);
+ h1 = (uint8_t)(v1 & 0xff);
+ h2 = (uint8_t)(v2 & 0xff);
mask = ~(1 << (DSPCR_CCOND_SHIFT + j));
DSPCR &= mask;
if (op == 0) // EQ
:function:::void:do_qb_cmpgu:int rd, int rs, int rt, int op
{
int i, j;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned8 h1, h2;
- unsigned32 result = 0;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint8_t h1, h2;
+ uint32_t result = 0;
for (i = 0, j = 0; i < 32; i += 8, j++, v1 >>= 8, v2 >>= 8)
{
- h1 = (unsigned8)(v1 & 0xff);
- h2 = (unsigned8)(v2 & 0xff);
+ h1 = (uint8_t)(v1 & 0xff);
+ h2 = (uint8_t)(v2 & 0xff);
if (op == 0) // EQ
result |= ((h1 == h2) << j);
else if (op == 1) // LT
:function:::void:do_ph_cmpu:int rs, int rt, int op
{
int i, j;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed16 h1, h2;
- unsigned32 mask;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int16_t h1, h2;
+ uint32_t mask;
for (i = 0, j = 0; i < 32; i += 16, j++, v1 >>= 16, v2 >>= 16)
{
- h1 = (signed16)(v1 & 0xffff);
- h2 = (signed16)(v2 & 0xffff);
+ h1 = (int16_t)(v1 & 0xffff);
+ h2 = (int16_t)(v2 & 0xffff);
mask = ~(1 << (DSPCR_CCOND_SHIFT + j));
DSPCR &= mask;
if (op == 0) // EQ
:function:::void:do_w_extr:int rt, int ac, int shift, int op
{
int i;
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- unsigned64 prod = (((unsigned64)hi) << 32) + (unsigned64)lo;
- signed64 result = (signed64)prod;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ uint64_t prod = (((uint64_t)hi) << 32) + (uint64_t)lo;
+ int64_t result = (int64_t)prod;
int setcond = 0;
if (!(prod & 0x8000000000000000LL))
{
for (i = 62; i >= (shift + 31); i--)
{
- if (prod & ((unsigned64)1 << i))
+ if (prod & ((uint64_t)1 << i))
{
DSPCR |= DSPCR_OUFLAG7;
setcond = 1;
{
for (i = 62; i >= (shift + 31); i--)
{
- if (!(prod & ((unsigned64)1 << i)))
+ if (!(prod & ((uint64_t)1 << i)))
{
DSPCR |= DSPCR_OUFLAG7;
setcond = 2;
:function:::void:do_h_extr:int rt, int ac, int shift
{
int i;
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- unsigned64 prod = (((unsigned64)hi) << 32) + (unsigned64)lo;
- signed64 result = (signed64)prod;
- signed64 value = 0xffffffffffff8000LL;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ uint64_t prod = (((uint64_t)hi) << 32) + (uint64_t)lo;
+ int64_t result = (int64_t)prod;
+ int64_t value = 0xffffffffffff8000LL;
result >>= shift;
if (result > 0x7fff)
{
// op: 0 = EXTP, 1 = EXTPDP
:function:::void:do_extp:int rt, int ac, int size, int op
{
- signed32 pos = (DSPCR >> DSPCR_POS_SHIFT) & DSPCR_POS_MASK;
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- unsigned64 prod = (((unsigned64)hi) << 32) + (unsigned64)lo;
- unsigned64 result = 0;
+ int32_t pos = (DSPCR >> DSPCR_POS_SHIFT) & DSPCR_POS_MASK;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ uint64_t prod = (((uint64_t)hi) << 32) + (uint64_t)lo;
+ uint64_t result = 0;
if (pos - (size + 1) >= -1)
{
prod >>= (pos - size);
- result = prod & (((unsigned64)1 << (size + 1)) - 1);
+ result = prod & (((uint64_t)1 << (size + 1)) - 1);
DSPCR &= (~DSPCR_EFI_SMASK);
if (op == 1) // EXTPDP
{
:function:::void:do_shilo:int ac, int shift
{
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- unsigned64 prod = (((unsigned64)hi) << 32) + (unsigned64)lo;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ uint64_t prod = (((uint64_t)hi) << 32) + (uint64_t)lo;
if (shift > 31)
shift = shift - 64;
if (shift >= 0)
"bposge32 <OFFSET>"
*dsp:
{
- unsigned32 pos = (DSPCR >> DSPCR_POS_SHIFT) & DSPCR_POS_MASK;
+ uint32_t pos = (DSPCR >> DSPCR_POS_SHIFT) & DSPCR_POS_MASK;
address_word offset = EXTEND16 (OFFSET) << 2;
if (pos >= 32)
{
:function:::void:do_u_ph_op:int rd, int rs, int rt, int op, int sat
{
int i;
- unsigned32 h0;
- unsigned16 h1, h2;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned32 result = 0;
+ uint32_t h0;
+ uint16_t h1, h2;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint32_t result = 0;
for (i = 0; i < 32; i += 16, v1 >>= 16, v2 >>= 16)
{
- h1 = (unsigned16)(v1 & 0xffff);
- h2 = (unsigned16)(v2 & 0xffff);
+ h1 = (uint16_t)(v1 & 0xffff);
+ h2 = (uint16_t)(v2 & 0xffff);
if (op == 0) // ADD
- h0 = (unsigned32)h1 + (unsigned32)h2;
+ h0 = (uint32_t)h1 + (uint32_t)h2;
else // SUB
- h0 = (unsigned32)h1 - (unsigned32)h2;
- if (op == 0 && (h0 > (unsigned32)0x0000ffff)) // ADD SAT
+ h0 = (uint32_t)h1 - (uint32_t)h2;
+ if (op == 0 && (h0 > (uint32_t)0x0000ffff)) // ADD SAT
{
DSPCR |= DSPCR_OUFLAG4;
if (sat == 1)
if (sat == 1)
h0 = 0x0;
}
- result |= ((unsigned32)((unsigned16)h0) << i);
+ result |= ((uint32_t)((uint16_t)h0) << i);
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_uh_qb_op:int rd, int rs, int rt, int op, int round
{
int i;
- unsigned32 h0;
- unsigned8 h1, h2;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned32 result = 0;
+ uint32_t h0;
+ uint8_t h1, h2;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint32_t result = 0;
for (i = 0; i < 32; i += 8, v1 >>= 8, v2 >>= 8)
{
- h1 = (unsigned8)(v1 & 0xff);
- h2 = (unsigned8)(v2 & 0xff);
+ h1 = (uint8_t)(v1 & 0xff);
+ h2 = (uint8_t)(v2 & 0xff);
if (op == 0) // ADD
- h0 = (unsigned32)h1 + (unsigned32)h2;
+ h0 = (uint32_t)h1 + (uint32_t)h2;
else // SUB
- h0 = (unsigned32)h1 - (unsigned32)h2;
+ h0 = (uint32_t)h1 - (uint32_t)h2;
if (round == 1)
h0 = (h0 + 1) >> 1;
else
h0 = h0 >> 1;
- result |= ((unsigned32)((unsigned8)h0) << i);
+ result |= ((uint32_t)((uint8_t)h0) << i);
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_qb_cmpgdu:int rd, int rs, int rt, int op
{
int i, j;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned8 h1, h2;
- unsigned32 result = 0;
- unsigned32 mask;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint8_t h1, h2;
+ uint32_t result = 0;
+ uint32_t mask;
for (i = 0, j = 0; i < 32; i += 8, j++, v1 >>= 8, v2 >>= 8)
{
- h1 = (unsigned8)(v1 & 0xff);
- h2 = (unsigned8)(v2 & 0xff);
+ h1 = (uint8_t)(v1 & 0xff);
+ h2 = (uint8_t)(v2 & 0xff);
mask = ~(1 << (DSPCR_CCOND_SHIFT + j));
DSPCR &= mask;
if (op == 0) // EQ
:function:::void:do_w_ph_dot_product:int ac, int rs, int rt, int op
{
int i;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed16 h1, h2;
- signed32 result;
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- signed64 prod = (signed64)((((unsigned64)hi) << 32) + (unsigned64)lo);
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int16_t h1, h2;
+ int32_t result;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ int64_t prod = (int64_t)((((uint64_t)hi) << 32) + (uint64_t)lo);
for (i = 0; i < 32; i += 16, v1 >>= 16, v2 >>= 16)
{
- h1 = (signed16)(v1 & 0xffff);
- h2 = (signed16)(v2 & 0xffff);
- result = (signed32)h1 * (signed32)h2;
+ h1 = (int16_t)(v1 & 0xffff);
+ h2 = (int16_t)(v2 & 0xffff);
+ result = (int32_t)h1 * (int32_t)h2;
if (op == 0) // DPA
- prod += (signed64)result;
+ prod += (int64_t)result;
else // DPS
- prod -= (signed64)result;
+ prod -= (int64_t)result;
}
DSPLO(ac) = EXTEND32 (prod);
DSPHI(ac) = EXTEND32 (prod >> 32);
// round: 0 = no rounding, 1 = rounding
:function:::void:do_w_mulq:int rd, int rs, int rt, int round
{
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed32 w1, w2;
- signed64 prod;
- unsigned32 result;
- w1 = (signed32) v1;
- w2 = (signed32) v2;
- if (w1 == (signed32) 0x80000000 && w2 == (signed32) 0x80000000)
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int32_t w1, w2;
+ int64_t prod;
+ uint32_t result;
+ w1 = (int32_t) v1;
+ w2 = (int32_t) v2;
+ if (w1 == (int32_t) 0x80000000 && w2 == (int32_t) 0x80000000)
{
DSPCR |= DSPCR_OUFLAG5;
prod = 0x7fffffff;
}
else
{
- prod = ((signed64) w1 * (signed64) w2) << 1;
+ prod = ((int64_t) w1 * (int64_t) w2) << 1;
if (round == 1)
prod += 0x0000000080000000LL;
prod = prod >> 32;
}
- result = (unsigned32) prod;
+ result = (uint32_t) prod;
GPR[rd] = EXTEND32 (result);
}
// round: 0 = no rounding, 1 = rounding
:function:::void:do_precr_sra:int rt, int rs, int sa, int round
{
- unsigned32 v1 = GPR[rt];
- unsigned32 v2 = GPR[rs];
- signed32 w1 = (signed32) v1;
- signed32 w2 = (signed32) v2;
- signed32 result;
+ uint32_t v1 = GPR[rt];
+ uint32_t v2 = GPR[rs];
+ int32_t w1 = (int32_t) v1;
+ int32_t w2 = (int32_t) v2;
+ int32_t result;
if (sa != 0)
{
if (round == 1 && (w1 & (1 << (sa - 1))))
:function:::void:do_qb_shra:int rd, int rt, int shift, int round
{
int i, j;
- signed8 q0;
- unsigned32 v1 = GPR[rt];
- unsigned32 result = 0;
+ int8_t q0;
+ uint32_t v1 = GPR[rt];
+ uint32_t result = 0;
for (i = 0; i < 32; i += 8, v1 >>= 8)
{
- q0 = (signed8)(v1 & 0xff);
+ q0 = (int8_t)(v1 & 0xff);
if (shift != 0)
{
if (round == 1 && (q0 & (1 << (shift - 1))))
else
q0 = q0 >> shift;
}
- result |= ((unsigned32)((unsigned8)q0) << i);
+ result |= ((uint32_t)((uint8_t)q0) << i);
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_ph_shrl:int rd, int rt, int shift
{
int i, j;
- unsigned16 h0;
- unsigned32 v1 = GPR[rt];
- unsigned32 result = 0;
+ uint16_t h0;
+ uint32_t v1 = GPR[rt];
+ uint32_t result = 0;
for (i = 0; i < 32; i += 16, v1 >>= 16)
{
- h0 = (unsigned16)(v1 & 0xffff);
+ h0 = (uint16_t)(v1 & 0xffff);
h0 = h0 >> shift;
- result |= ((unsigned32)h0 << i);
+ result |= ((uint32_t)h0 << i);
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_qh_ph_op:int rd, int rs, int rt, int op, int round
{
int i;
- signed32 h0;
- signed16 h1, h2;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- unsigned32 result = 0;
+ int32_t h0;
+ int16_t h1, h2;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ uint32_t result = 0;
for (i = 0; i < 32; i += 16, v1 >>= 16, v2 >>= 16)
{
- h1 = (signed16)(v1 & 0xffff);
- h2 = (signed16)(v2 & 0xffff);
+ h1 = (int16_t)(v1 & 0xffff);
+ h2 = (int16_t)(v2 & 0xffff);
if (op == 0) // ADD
- h0 = (signed32)h1 + (signed32)h2;
+ h0 = (int32_t)h1 + (int32_t)h2;
else // SUB
- h0 = (signed32)h1 - (signed32)h2;
+ h0 = (int32_t)h1 - (int32_t)h2;
if (round == 1)
h0 = (h0 + 1) >> 1;
else
h0 = h0 >> 1;
- result |= ((unsigned32)((unsigned16)h0) << i);
+ result |= ((uint32_t)((uint16_t)h0) << i);
}
GPR[rd] = EXTEND32 (result);
}
:function:::void:do_qh_w_op:int rd, int rs, int rt, int op, int round
{
int i;
- signed64 v0;
- signed32 v1 = (signed32)GPR[rs];
- signed32 v2 = (signed32)GPR[rt];
+ int64_t v0;
+ int32_t v1 = (int32_t)GPR[rs];
+ int32_t v2 = (int32_t)GPR[rt];
if (op == 0) // ADD
- v0 = (signed64)v1 + (signed64)v2;
+ v0 = (int64_t)v1 + (int64_t)v2;
else // SUB
- v0 = (signed64)v1 - (signed64)v2;
+ v0 = (int64_t)v1 - (int64_t)v2;
if (round == 1)
v0 = (v0 + 1) >> 1;
else
:function:::void:do_x_w_ph_dot_product:int ac, int rs, int rt, int op
{
int i;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed16 h1, h2;
- signed32 result;
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- signed64 prod = (signed64)((((unsigned64)hi) << 32) + (unsigned64)lo);
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int16_t h1, h2;
+ int32_t result;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ int64_t prod = (int64_t)((((uint64_t)hi) << 32) + (uint64_t)lo);
for (i = 0; i < 32; i += 16, v1 >>= 16, v2 <<= 16)
{
- h1 = (signed16)(v1 & 0xffff);
- h2 = (signed16)((v2 & 0xffff0000) >> 16);
- result = (signed32)h1 * (signed32)h2;
+ h1 = (int16_t)(v1 & 0xffff);
+ h2 = (int16_t)((v2 & 0xffff0000) >> 16);
+ result = (int32_t)h1 * (int32_t)h2;
if (op == 0) // DPAX
- prod += (signed64)result;
+ prod += (int64_t)result;
else // DPSX
- prod -= (signed64)result;
+ prod -= (int64_t)result;
}
DSPLO(ac) = EXTEND32 (prod);
DSPHI(ac) = EXTEND32 (prod >> 32);
:function:::void:do_qx_w_ph_dot_product:int ac, int rs, int rt, int op, int sat
{
int i;
- unsigned32 v1 = GPR[rs];
- unsigned32 v2 = GPR[rt];
- signed16 h1, h2;
- signed32 result;
- unsigned32 lo = DSPLO(ac);
- unsigned32 hi = DSPHI(ac);
- signed64 prod = (signed64)((((unsigned64)hi) << 32) + (unsigned64)lo);
- signed64 max, min;
+ uint32_t v1 = GPR[rs];
+ uint32_t v2 = GPR[rt];
+ int16_t h1, h2;
+ int32_t result;
+ uint32_t lo = DSPLO(ac);
+ uint32_t hi = DSPHI(ac);
+ int64_t prod = (int64_t)((((uint64_t)hi) << 32) + (uint64_t)lo);
+ int64_t max, min;
for (i = 0; i < 32; i += 16, v1 >>= 16, v2 <<= 16)
{
- h1 = (signed16)(v1 & 0xffff);
- h2 = (signed16)((v2 & 0xffff0000) >> 16);
- if (h1 == (signed16)0x8000 && h2 == (signed16)0x8000)
+ h1 = (int16_t)(v1 & 0xffff);
+ h2 = (int16_t)((v2 & 0xffff0000) >> 16);
+ if (h1 == (int16_t)0x8000 && h2 == (int16_t)0x8000)
{
DSPCR |= (1 << (DSPCR_OUFLAG_SHIFT + ac));
result = 0x7fffffff;
}
else
- result = ((signed32)h1 * (signed32)h2) << 1;
+ result = ((int32_t)h1 * (int32_t)h2) << 1;
if (op == 0) // DPAQX
- prod += (signed64)result;
+ prod += (int64_t)result;
else // DPSQX
- prod -= (signed64)result;
+ prod -= (int64_t)result;
}
// Saturation on the accumulator.
if (sat == 1)
{
- max = (signed64) 0x7fffffffLL;
- min = (signed64) 0xffffffff80000000LL;
+ max = (int64_t) 0x7fffffffLL;
+ min = (int64_t) 0xffffffff80000000LL;
if (prod > max)
{
DSPCR |= (1 << (DSPCR_OUFLAG_SHIFT + ac));
for (loop = 0; (loop < idt_monitor_size); loop += 4)
{
address_word vaddr = (idt_monitor_base + loop);
- unsigned32 insn = (RSVD_INSTRUCTION |
+ uint32_t insn = (RSVD_INSTRUCTION |
(((loop >> 2) & RSVD_INSTRUCTION_ARG_MASK)
<< RSVD_INSTRUCTION_ARG_SHIFT));
H2T (insn);
unsigned loop;
for (loop = 0; (loop < 24); loop++)
{
- unsigned32 value = ((0x500 - 8) / 8); /* default UNDEFINED reason code */
+ uint32_t value = ((0x500 - 8) / 8); /* default UNDEFINED reason code */
switch (loop)
{
case 0: /* read */
(pmon_monitor_base != 0) ||
(lsipmon_monitor_base != 0))
{
- unsigned32 halt[2] = { 0x2404002f /* addiu r4, r0, 47 */,
+ uint32_t halt[2] = { 0x2404002f /* addiu r4, r0, 47 */,
HALT_INSTRUCTION /* BREAK */ };
H2T (halt[0]);
H2T (halt[1]);
if (length == 8)
{
cpu->fgr[rn - FGR_BASE] =
- (unsigned32) T2H_8 (*(unsigned64*)memory);
+ (uint32_t) T2H_8 (*(uint64_t*)memory);
return 8;
}
else
{
- cpu->fgr[rn - FGR_BASE] = T2H_4 (*(unsigned32*)memory);
+ cpu->fgr[rn - FGR_BASE] = T2H_4 (*(uint32_t*)memory);
return 4;
}
}
{
if (length == 8)
{
- cpu->fgr[rn - FGR_BASE] = T2H_8 (*(unsigned64*)memory);
+ cpu->fgr[rn - FGR_BASE] = T2H_8 (*(uint64_t*)memory);
return 8;
}
else
{
- cpu->fgr[rn - FGR_BASE] = T2H_4 (*(unsigned32*)memory);
+ cpu->fgr[rn - FGR_BASE] = T2H_4 (*(uint32_t*)memory);
return 4;
}
}
if (length == 8)
{
cpu->registers[rn] =
- (unsigned32) T2H_8 (*(unsigned64*)memory);
+ (uint32_t) T2H_8 (*(uint64_t*)memory);
return 8;
}
else
{
- cpu->registers[rn] = T2H_4 (*(unsigned32*)memory);
+ cpu->registers[rn] = T2H_4 (*(uint32_t*)memory);
return 4;
}
}
{
if (length == 8)
{
- cpu->registers[rn] = T2H_8 (*(unsigned64*)memory);
+ cpu->registers[rn] = T2H_8 (*(uint64_t*)memory);
return 8;
}
else
{
- cpu->registers[rn] = (signed32) T2H_4(*(unsigned32*)memory);
+ cpu->registers[rn] = (int32_t) T2H_4(*(uint32_t*)memory);
return 4;
}
}
{
if (length == 8)
{
- *(unsigned64*)memory =
- H2T_8 ((unsigned32) (cpu->fgr[rn - FGR_BASE]));
+ *(uint64_t*)memory =
+ H2T_8 ((uint32_t) (cpu->fgr[rn - FGR_BASE]));
return 8;
}
else
{
- *(unsigned32*)memory = H2T_4 (cpu->fgr[rn - FGR_BASE]);
+ *(uint32_t*)memory = H2T_4 (cpu->fgr[rn - FGR_BASE]);
return 4;
}
}
{
if (length == 8)
{
- *(unsigned64*)memory = H2T_8 (cpu->fgr[rn - FGR_BASE]);
+ *(uint64_t*)memory = H2T_8 (cpu->fgr[rn - FGR_BASE]);
return 8;
}
else
{
- *(unsigned32*)memory = H2T_4 ((unsigned32)(cpu->fgr[rn - FGR_BASE]));
+ *(uint32_t*)memory = H2T_4 ((uint32_t)(cpu->fgr[rn - FGR_BASE]));
return 4;
}
}
{
if (length == 8)
{
- *(unsigned64*)memory =
- H2T_8 ((unsigned32) (cpu->registers[rn]));
+ *(uint64_t*)memory =
+ H2T_8 ((uint32_t) (cpu->registers[rn]));
return 8;
}
else
{
- *(unsigned32*)memory = H2T_4 ((unsigned32)(cpu->registers[rn]));
+ *(uint32_t*)memory = H2T_4 ((uint32_t)(cpu->registers[rn]));
return 4;
}
}
{
if (length == 8)
{
- *(unsigned64*)memory =
- H2T_8 ((unsigned64) (cpu->registers[rn]));
+ *(uint64_t*)memory =
+ H2T_8 ((uint64_t) (cpu->registers[rn]));
return 8;
}
else
{
- *(unsigned32*)memory = H2T_4 ((unsigned32)(cpu->registers[rn]));
+ *(uint32_t*)memory = H2T_4 ((uint32_t)(cpu->registers[rn]));
return 4;
}
}
These addresses work as is on 64-bit targets but
can be truncated for 32-bit targets. */
if (WITH_TARGET_WORD_BITSIZE == 32)
- pc = (unsigned32) pc;
+ pc = (uint32_t) pc;
CPU_PC_SET (cpu, pc);
}
/* CPR[0,rd] = GPR[rt]; */
default:
if (op == cp0_mfc0 || op == cp0_dmfc0)
- GPR[rt] = (signed_word) (signed32) COP0_GPR[rd];
+ GPR[rt] = (signed_word) (int32_t) COP0_GPR[rd];
else
COP0_GPR[rd] = GPR[rt];
#if 0
&& rd == 16)
{
/* [D]MFC0 RT,C0_CONFIG,SEL */
- signed32 cfg = 0;
+ int32_t cfg = 0;
switch (sel)
{
case 0:
*mips16:
*vr4100:
{
- unsigned32 temp = (basepc (SD_) & ~3) + (IMMED << 2);
+ uint32_t temp = (basepc (SD_) & ~3) + (IMMED << 2);
GPR[TRX] = EXTEND32 (temp);
}
*mips16:
*vr4100:
{
- unsigned32 temp = (basepc (SD_) & ~3) + EXTEND16 (IMMEDIATE);
+ uint32_t temp = (basepc (SD_) & ~3) + EXTEND16 (IMMEDIATE);
GPR[TRX] = EXTEND32 (temp);
}
*mips16e:
{
TRACE_ALU_INPUT1 (GPR[TRX]);
- GPR[TRX] = (unsigned_word)(unsigned8)(GPR[TRX]);
+ GPR[TRX] = (unsigned_word)(uint8_t)(GPR[TRX]);
TRACE_ALU_RESULT (GPR[TRX]);
}
*mips16e:
{
TRACE_ALU_INPUT1 (GPR[TRX]);
- GPR[TRX] = (unsigned_word)(unsigned16)(GPR[TRX]);
+ GPR[TRX] = (unsigned_word)(uint16_t)(GPR[TRX]);
TRACE_ALU_RESULT (GPR[TRX]);
}
{
check_u64 (SD_, instruction_0);
TRACE_ALU_INPUT1 (GPR[TRX]);
- GPR[TRX] = (unsigned_word)(unsigned32)(GPR[TRX]);
+ GPR[TRX] = (unsigned_word)(uint32_t)(GPR[TRX]);
TRACE_ALU_RESULT (GPR[TRX]);
}
the (not guaranteed portable) assumption that right shifts of signed
quantities in C do sign extension. */
-typedef unsigned64 unsigned48;
+typedef uint64_t unsigned48;
#define MASK48 (UNSIGNED64 (0xffffffffffff))
-typedef unsigned32 unsigned24;
+typedef uint32_t unsigned24;
#define MASK24 (UNSIGNED32 (0xffffff))
typedef enum {
sel_imm /* immediate select */
} VT_select;
-#define OB_MAX ((unsigned8)0xFF)
-#define QH_MIN ((signed16)0x8000)
-#define QH_MAX ((signed16)0x7FFF)
+#define OB_MAX ((uint8_t)0xFF)
+#define QH_MIN ((int16_t)0x8000)
+#define QH_MAX ((int16_t)0x7FFF)
-#define OB_CLAMP(x) ((unsigned8)((x) > OB_MAX ? OB_MAX : (x)))
-#define QH_CLAMP(x) ((signed16)((x) < QH_MIN ? QH_MIN : \
+#define OB_CLAMP(x) ((uint8_t)((x) > OB_MAX ? OB_MAX : (x)))
+#define QH_CLAMP(x) ((int16_t)((x) < QH_MIN ? QH_MIN : \
((x) > QH_MAX ? QH_MAX : (x))))
#define MX_FMT(fmtsel) (((fmtsel) & 0x1) == 0 ? mdmx_ob : mdmx_qh)
(((fmtsel) & 0x18) == 0x10 ? sel_vect : sel_imm))
#define QH_ELEM(v,fmtsel) \
- ((signed16)(((v) >> (((fmtsel) & 0xC) << 2)) & 0xFFFF))
+ ((int16_t)(((v) >> (((fmtsel) & 0xC) << 2)) & 0xFFFF))
#define OB_ELEM(v,fmtsel) \
- ((unsigned8)(((v) >> (((fmtsel) & 0xE) << 2)) & 0xFF))
+ ((uint8_t)(((v) >> (((fmtsel) & 0xE) << 2)) & 0xFF))
-typedef signed16 (*QH_FUNC)(signed16, signed16);
-typedef unsigned8 (*OB_FUNC)(unsigned8, unsigned8);
+typedef int16_t (*QH_FUNC)(int16_t, int16_t);
+typedef uint8_t (*OB_FUNC)(uint8_t, uint8_t);
/* vectorized logical operators */
-static signed16
-AndQH(signed16 ts, signed16 tt)
+static int16_t
+AndQH(int16_t ts, int16_t tt)
{
- return (signed16)((unsigned16)ts & (unsigned16)tt);
+ return (int16_t)((uint16_t)ts & (uint16_t)tt);
}
-static unsigned8
-AndOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+AndOB(uint8_t ts, uint8_t tt)
{
return ts & tt;
}
-static signed16
-NorQH(signed16 ts, signed16 tt)
+static int16_t
+NorQH(int16_t ts, int16_t tt)
{
- return (signed16)(((unsigned16)ts | (unsigned16)tt) ^ 0xFFFF);
+ return (int16_t)(((uint16_t)ts | (uint16_t)tt) ^ 0xFFFF);
}
-static unsigned8
-NorOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+NorOB(uint8_t ts, uint8_t tt)
{
return (ts | tt) ^ 0xFF;
}
-static signed16
-OrQH(signed16 ts, signed16 tt)
+static int16_t
+OrQH(int16_t ts, int16_t tt)
{
- return (signed16)((unsigned16)ts | (unsigned16)tt);
+ return (int16_t)((uint16_t)ts | (uint16_t)tt);
}
-static unsigned8
-OrOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+OrOB(uint8_t ts, uint8_t tt)
{
return ts | tt;
}
-static signed16
-XorQH(signed16 ts, signed16 tt)
+static int16_t
+XorQH(int16_t ts, int16_t tt)
{
- return (signed16)((unsigned16)ts ^ (unsigned16)tt);
+ return (int16_t)((uint16_t)ts ^ (uint16_t)tt);
}
-static unsigned8
-XorOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+XorOB(uint8_t ts, uint8_t tt)
{
return ts ^ tt;
}
-static signed16
-SLLQH(signed16 ts, signed16 tt)
+static int16_t
+SLLQH(int16_t ts, int16_t tt)
{
- unsigned32 s = (unsigned32)tt & 0xF;
- return (signed16)(((unsigned32)ts << s) & 0xFFFF);
+ uint32_t s = (uint32_t)tt & 0xF;
+ return (int16_t)(((uint32_t)ts << s) & 0xFFFF);
}
-static unsigned8
-SLLOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+SLLOB(uint8_t ts, uint8_t tt)
{
- unsigned32 s = tt & 0x7;
+ uint32_t s = tt & 0x7;
return (ts << s) & 0xFF;
}
-static signed16
-SRLQH(signed16 ts, signed16 tt)
+static int16_t
+SRLQH(int16_t ts, int16_t tt)
{
- unsigned32 s = (unsigned32)tt & 0xF;
- return (signed16)((unsigned16)ts >> s);
+ uint32_t s = (uint32_t)tt & 0xF;
+ return (int16_t)((uint16_t)ts >> s);
}
-static unsigned8
-SRLOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+SRLOB(uint8_t ts, uint8_t tt)
{
- unsigned32 s = tt & 0x7;
+ uint32_t s = tt & 0x7;
return ts >> s;
}
/* Vectorized arithmetic operators. */
-static signed16
-AddQH(signed16 ts, signed16 tt)
+static int16_t
+AddQH(int16_t ts, int16_t tt)
{
- signed32 t = (signed32)ts + (signed32)tt;
+ int32_t t = (int32_t)ts + (int32_t)tt;
return QH_CLAMP(t);
}
-static unsigned8
-AddOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+AddOB(uint8_t ts, uint8_t tt)
{
- unsigned32 t = (unsigned32)ts + (unsigned32)tt;
+ uint32_t t = (uint32_t)ts + (uint32_t)tt;
return OB_CLAMP(t);
}
-static signed16
-SubQH(signed16 ts, signed16 tt)
+static int16_t
+SubQH(int16_t ts, int16_t tt)
{
- signed32 t = (signed32)ts - (signed32)tt;
+ int32_t t = (int32_t)ts - (int32_t)tt;
return QH_CLAMP(t);
}
-static unsigned8
-SubOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+SubOB(uint8_t ts, uint8_t tt)
{
- signed32 t;
- t = (signed32)ts - (signed32)tt;
+ int32_t t;
+ t = (int32_t)ts - (int32_t)tt;
if (t < 0)
t = 0;
- return (unsigned8)t;
+ return (uint8_t)t;
}
-static signed16
-MinQH(signed16 ts, signed16 tt)
+static int16_t
+MinQH(int16_t ts, int16_t tt)
{
return (ts < tt ? ts : tt);
}
-static unsigned8
-MinOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+MinOB(uint8_t ts, uint8_t tt)
{
return (ts < tt ? ts : tt);
}
-static signed16
-MaxQH(signed16 ts, signed16 tt)
+static int16_t
+MaxQH(int16_t ts, int16_t tt)
{
return (ts > tt ? ts : tt);
}
-static unsigned8
-MaxOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+MaxOB(uint8_t ts, uint8_t tt)
{
return (ts > tt ? ts : tt);
}
-static signed16
-MulQH(signed16 ts, signed16 tt)
+static int16_t
+MulQH(int16_t ts, int16_t tt)
{
- signed32 t = (signed32)ts * (signed32)tt;
+ int32_t t = (int32_t)ts * (int32_t)tt;
return QH_CLAMP(t);
}
-static unsigned8
-MulOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+MulOB(uint8_t ts, uint8_t tt)
{
- unsigned32 t = (unsigned32)ts * (unsigned32)tt;
+ uint32_t t = (uint32_t)ts * (uint32_t)tt;
return OB_CLAMP(t);
}
/* "msgn" and "sra" are defined only for QH format. */
-static signed16
-MsgnQH(signed16 ts, signed16 tt)
+static int16_t
+MsgnQH(int16_t ts, int16_t tt)
{
- signed16 t;
+ int16_t t;
if (ts < 0)
t = (tt == QH_MIN ? QH_MAX : -tt);
else if (ts == 0)
return t;
}
-static signed16
-SRAQH(signed16 ts, signed16 tt)
+static int16_t
+SRAQH(int16_t ts, int16_t tt)
{
- unsigned32 s = (unsigned32)tt & 0xF;
- return (signed16)((signed32)ts >> s);
+ uint32_t s = (uint32_t)tt & 0xF;
+ return (int16_t)((int32_t)ts >> s);
}
/* "pabsdiff" and "pavg" are defined only for OB format. */
-static unsigned8
-AbsDiffOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+AbsDiffOB(uint8_t ts, uint8_t tt)
{
return (ts >= tt ? ts - tt : tt - ts);
}
-static unsigned8
-AvgOB(unsigned8 ts, unsigned8 tt)
+static uint8_t
+AvgOB(uint8_t ts, uint8_t tt)
{
- return ((unsigned32)ts + (unsigned32)tt + 1) >> 1;
+ return ((uint32_t)ts + (uint32_t)tt + 1) >> 1;
}
/* Auxiliary functions for CPR updates. */
/* Vector mapping for QH format. */
-static unsigned64
-qh_vector_op(unsigned64 v1, unsigned64 v2, QH_FUNC func)
+static uint64_t
+qh_vector_op(uint64_t v1, uint64_t v2, QH_FUNC func)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i;
- signed16 h, h1, h2;
+ int16_t h, h1, h2;
for (i = 0; i < 64; i += 16)
{
- h1 = (signed16)(v1 & 0xFFFF); v1 >>= 16;
- h2 = (signed16)(v2 & 0xFFFF); v2 >>= 16;
+ h1 = (int16_t)(v1 & 0xFFFF); v1 >>= 16;
+ h2 = (int16_t)(v2 & 0xFFFF); v2 >>= 16;
h = (*func)(h1, h2);
- result |= ((unsigned64)((unsigned16)h) << i);
+ result |= ((uint64_t)((uint16_t)h) << i);
}
return result;
}
-static unsigned64
-qh_map_op(unsigned64 v1, signed16 h2, QH_FUNC func)
+static uint64_t
+qh_map_op(uint64_t v1, int16_t h2, QH_FUNC func)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i;
- signed16 h, h1;
+ int16_t h, h1;
for (i = 0; i < 64; i += 16)
{
- h1 = (signed16)(v1 & 0xFFFF); v1 >>= 16;
+ h1 = (int16_t)(v1 & 0xFFFF); v1 >>= 16;
h = (*func)(h1, h2);
- result |= ((unsigned64)((unsigned16)h) << i);
+ result |= ((uint64_t)((uint16_t)h) << i);
}
return result;
}
/* Vector operations for OB format. */
-static unsigned64
-ob_vector_op(unsigned64 v1, unsigned64 v2, OB_FUNC func)
+static uint64_t
+ob_vector_op(uint64_t v1, uint64_t v2, OB_FUNC func)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i;
- unsigned8 b, b1, b2;
+ uint8_t b, b1, b2;
for (i = 0; i < 64; i += 8)
{
b1 = v1 & 0xFF; v1 >>= 8;
b2 = v2 & 0xFF; v2 >>= 8;
b = (*func)(b1, b2);
- result |= ((unsigned64)b << i);
+ result |= ((uint64_t)b << i);
}
return result;
}
-static unsigned64
-ob_map_op(unsigned64 v1, unsigned8 b2, OB_FUNC func)
+static uint64_t
+ob_map_op(uint64_t v1, uint8_t b2, OB_FUNC func)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i;
- unsigned8 b, b1;
+ uint8_t b, b1;
for (i = 0; i < 64; i += 8)
{
b1 = v1 & 0xFF; v1 >>= 8;
b = (*func)(b1, b2);
- result |= ((unsigned64)b << i);
+ result |= ((uint64_t)b << i);
}
return result;
}
/* Primary entry for operations that update CPRs. */
-unsigned64
+uint64_t
mdmx_cpr_op(sim_cpu *cpu,
address_word cia,
int op,
- unsigned64 op1,
+ uint64_t op1,
int vt,
MX_fmtsel fmtsel)
{
- unsigned64 op2;
- unsigned64 result = 0;
+ uint64_t op2;
+ uint64_t result = 0;
switch (MX_FMT (fmtsel))
{
/* Operations that update CCs */
static void
-qh_vector_test(sim_cpu *cpu, unsigned64 v1, unsigned64 v2, int cond)
+qh_vector_test(sim_cpu *cpu, uint64_t v1, uint64_t v2, int cond)
{
int i;
- signed16 h1, h2;
+ int16_t h1, h2;
int boolean;
for (i = 0; i < 4; i++)
{
- h1 = (signed16)(v1 & 0xFFFF); v1 >>= 16;
- h2 = (signed16)(v2 & 0xFFFF); v2 >>= 16;
+ h1 = (int16_t)(v1 & 0xFFFF); v1 >>= 16;
+ h2 = (int16_t)(v2 & 0xFFFF); v2 >>= 16;
boolean = ((cond & MX_C_EQ) && (h1 == h2)) ||
((cond & MX_C_LT) && (h1 < h2));
SETFCC(i, boolean);
}
static void
-qh_map_test(sim_cpu *cpu, unsigned64 v1, signed16 h2, int cond)
+qh_map_test(sim_cpu *cpu, uint64_t v1, int16_t h2, int cond)
{
int i;
- signed16 h1;
+ int16_t h1;
int boolean;
for (i = 0; i < 4; i++)
{
- h1 = (signed16)(v1 & 0xFFFF); v1 >>= 16;
+ h1 = (int16_t)(v1 & 0xFFFF); v1 >>= 16;
boolean = ((cond & MX_C_EQ) && (h1 == h2)) ||
((cond & MX_C_LT) && (h1 < h2));
SETFCC(i, boolean);
}
static void
-ob_vector_test(sim_cpu *cpu, unsigned64 v1, unsigned64 v2, int cond)
+ob_vector_test(sim_cpu *cpu, uint64_t v1, uint64_t v2, int cond)
{
int i;
- unsigned8 b1, b2;
+ uint8_t b1, b2;
int boolean;
for (i = 0; i < 8; i++)
}
static void
-ob_map_test(sim_cpu *cpu, unsigned64 v1, unsigned8 b2, int cond)
+ob_map_test(sim_cpu *cpu, uint64_t v1, uint8_t b2, int cond)
{
int i;
- unsigned8 b1;
+ uint8_t b1;
int boolean;
for (i = 0; i < 8; i++)
{
- b1 = (unsigned8)(v1 & 0xFF); v1 >>= 8;
+ b1 = (uint8_t)(v1 & 0xFF); v1 >>= 8;
boolean = ((cond & MX_C_EQ) && (b1 == b2)) ||
((cond & MX_C_LT) && (b1 < b2));
SETFCC(i, boolean);
mdmx_cc_op(sim_cpu *cpu,
address_word cia,
int cond,
- unsigned64 v1,
+ uint64_t v1,
int vt,
MX_fmtsel fmtsel)
{
- unsigned64 op2;
+ uint64_t op2;
switch (MX_FMT (fmtsel))
{
/* Pick operations. */
-static unsigned64
-qh_vector_pick(sim_cpu *cpu, unsigned64 v1, unsigned64 v2, int tf)
+static uint64_t
+qh_vector_pick(sim_cpu *cpu, uint64_t v1, uint64_t v2, int tf)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i, s;
- unsigned16 h;
+ uint16_t h;
s = 0;
for (i = 0; i < 4; i++)
{
h = ((GETFCC(i) == tf) ? (v1 & 0xFFFF) : (v2 & 0xFFFF));
v1 >>= 16; v2 >>= 16;
- result |= ((unsigned64)h << s);
+ result |= ((uint64_t)h << s);
s += 16;
}
return result;
}
-static unsigned64
-qh_map_pick(sim_cpu *cpu, unsigned64 v1, signed16 h2, int tf)
+static uint64_t
+qh_map_pick(sim_cpu *cpu, uint64_t v1, int16_t h2, int tf)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i, s;
- unsigned16 h;
+ uint16_t h;
s = 0;
for (i = 0; i < 4; i++)
{
- h = (GETFCC(i) == tf) ? (v1 & 0xFFFF) : (unsigned16)h2;
+ h = (GETFCC(i) == tf) ? (v1 & 0xFFFF) : (uint16_t)h2;
v1 >>= 16;
- result |= ((unsigned64)h << s);
+ result |= ((uint64_t)h << s);
s += 16;
}
return result;
}
-static unsigned64
-ob_vector_pick(sim_cpu *cpu, unsigned64 v1, unsigned64 v2, int tf)
+static uint64_t
+ob_vector_pick(sim_cpu *cpu, uint64_t v1, uint64_t v2, int tf)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i, s;
- unsigned8 b;
+ uint8_t b;
s = 0;
for (i = 0; i < 8; i++)
{
b = (GETFCC(i) == tf) ? (v1 & 0xFF) : (v2 & 0xFF);
v1 >>= 8; v2 >>= 8;
- result |= ((unsigned64)b << s);
+ result |= ((uint64_t)b << s);
s += 8;
}
return result;
}
-static unsigned64
-ob_map_pick(sim_cpu *cpu, unsigned64 v1, unsigned8 b2, int tf)
+static uint64_t
+ob_map_pick(sim_cpu *cpu, uint64_t v1, uint8_t b2, int tf)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i, s;
- unsigned8 b;
+ uint8_t b;
s = 0;
for (i = 0; i < 8; i++)
{
b = (GETFCC(i) == tf) ? (v1 & 0xFF) : b2;
v1 >>= 8;
- result |= ((unsigned64)b << s);
+ result |= ((uint64_t)b << s);
s += 8;
}
return result;
}
-unsigned64
+uint64_t
mdmx_pick_op(sim_cpu *cpu,
address_word cia,
int tf,
- unsigned64 v1,
+ uint64_t v1,
int vt,
MX_fmtsel fmtsel)
{
- unsigned64 result = 0;
- unsigned64 op2;
+ uint64_t result = 0;
+ uint64_t op2;
switch (MX_FMT (fmtsel))
{
/* Accumulators. */
-typedef void (*QH_ACC)(signed48 *a, signed16 ts, signed16 tt);
+typedef void (*QH_ACC)(signed48 *a, int16_t ts, int16_t tt);
static void
-AccAddAQH(signed48 *a, signed16 ts, signed16 tt)
+AccAddAQH(signed48 *a, int16_t ts, int16_t tt)
{
*a += (signed48)ts + (signed48)tt;
}
static void
-AccAddLQH(signed48 *a, signed16 ts, signed16 tt)
+AccAddLQH(signed48 *a, int16_t ts, int16_t tt)
{
*a = (signed48)ts + (signed48)tt;
}
static void
-AccMulAQH(signed48 *a, signed16 ts, signed16 tt)
+AccMulAQH(signed48 *a, int16_t ts, int16_t tt)
{
*a += (signed48)ts * (signed48)tt;
}
static void
-AccMulLQH(signed48 *a, signed16 ts, signed16 tt)
+AccMulLQH(signed48 *a, int16_t ts, int16_t tt)
{
*a = (signed48)ts * (signed48)tt;
}
static void
-SubMulAQH(signed48 *a, signed16 ts, signed16 tt)
+SubMulAQH(signed48 *a, int16_t ts, int16_t tt)
{
*a -= (signed48)ts * (signed48)tt;
}
static void
-SubMulLQH(signed48 *a, signed16 ts, signed16 tt)
+SubMulLQH(signed48 *a, int16_t ts, int16_t tt)
{
*a = -((signed48)ts * (signed48)tt);
}
static void
-AccSubAQH(signed48 *a, signed16 ts, signed16 tt)
+AccSubAQH(signed48 *a, int16_t ts, int16_t tt)
{
*a += (signed48)ts - (signed48)tt;
}
static void
-AccSubLQH(signed48 *a, signed16 ts, signed16 tt)
+AccSubLQH(signed48 *a, int16_t ts, int16_t tt)
{
*a = (signed48)ts - (signed48)tt;
}
-typedef void (*OB_ACC)(signed24 *acc, unsigned8 ts, unsigned8 tt);
+typedef void (*OB_ACC)(signed24 *acc, uint8_t ts, uint8_t tt);
static void
-AccAddAOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+AccAddAOB(signed24 *a, uint8_t ts, uint8_t tt)
{
*a += (signed24)ts + (signed24)tt;
}
static void
-AccAddLOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+AccAddLOB(signed24 *a, uint8_t ts, uint8_t tt)
{
*a = (signed24)ts + (signed24)tt;
}
static void
-AccMulAOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+AccMulAOB(signed24 *a, uint8_t ts, uint8_t tt)
{
*a += (signed24)ts * (signed24)tt;
}
static void
-AccMulLOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+AccMulLOB(signed24 *a, uint8_t ts, uint8_t tt)
{
*a = (signed24)ts * (signed24)tt;
}
static void
-SubMulAOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+SubMulAOB(signed24 *a, uint8_t ts, uint8_t tt)
{
*a -= (signed24)ts * (signed24)tt;
}
static void
-SubMulLOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+SubMulLOB(signed24 *a, uint8_t ts, uint8_t tt)
{
*a = -((signed24)ts * (signed24)tt);
}
static void
-AccSubAOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+AccSubAOB(signed24 *a, uint8_t ts, uint8_t tt)
{
*a += (signed24)ts - (signed24)tt;
}
static void
-AccSubLOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+AccSubLOB(signed24 *a, uint8_t ts, uint8_t tt)
{
*a = (signed24)ts - (signed24)tt;
}
static void
-AccAbsDiffOB(signed24 *a, unsigned8 ts, unsigned8 tt)
+AccAbsDiffOB(signed24 *a, uint8_t ts, uint8_t tt)
{
- unsigned8 t = (ts >= tt ? ts - tt : tt - ts);
+ uint8_t t = (ts >= tt ? ts - tt : tt - ts);
*a += (signed24)t;
}
static void
-qh_vector_acc(signed48 a[], unsigned64 v1, unsigned64 v2, QH_ACC acc)
+qh_vector_acc(signed48 a[], uint64_t v1, uint64_t v2, QH_ACC acc)
{
int i;
- signed16 h1, h2;
+ int16_t h1, h2;
for (i = 0; i < 4; i++)
{
- h1 = (signed16)(v1 & 0xFFFF); v1 >>= 16;
- h2 = (signed16)(v2 & 0xFFFF); v2 >>= 16;
+ h1 = (int16_t)(v1 & 0xFFFF); v1 >>= 16;
+ h2 = (int16_t)(v2 & 0xFFFF); v2 >>= 16;
(*acc)(&a[i], h1, h2);
}
}
static void
-qh_map_acc(signed48 a[], unsigned64 v1, signed16 h2, QH_ACC acc)
+qh_map_acc(signed48 a[], uint64_t v1, int16_t h2, QH_ACC acc)
{
int i;
- signed16 h1;
+ int16_t h1;
for (i = 0; i < 4; i++)
{
- h1 = (signed16)(v1 & 0xFFFF); v1 >>= 16;
+ h1 = (int16_t)(v1 & 0xFFFF); v1 >>= 16;
(*acc)(&a[i], h1, h2);
}
}
static void
-ob_vector_acc(signed24 a[], unsigned64 v1, unsigned64 v2, OB_ACC acc)
+ob_vector_acc(signed24 a[], uint64_t v1, uint64_t v2, OB_ACC acc)
{
int i;
- unsigned8 b1, b2;
+ uint8_t b1, b2;
for (i = 0; i < 8; i++)
{
}
static void
-ob_map_acc(signed24 a[], unsigned64 v1, unsigned8 b2, OB_ACC acc)
+ob_map_acc(signed24 a[], uint64_t v1, uint8_t b2, OB_ACC acc)
{
int i;
- unsigned8 b1;
+ uint8_t b1;
for (i = 0; i < 8; i++)
{
mdmx_acc_op(sim_cpu *cpu,
address_word cia,
int op,
- unsigned64 op1,
+ uint64_t op1,
int vt,
MX_fmtsel fmtsel)
{
- unsigned64 op2;
+ uint64_t op2;
switch (MX_FMT (fmtsel))
{
/* Reading and writing accumulator (no conversion). */
-unsigned64
+uint64_t
mdmx_rac_op(sim_cpu *cpu,
address_word cia,
int op,
int fmt)
{
- unsigned64 result;
+ uint64_t result;
unsigned int shift;
int i;
mdmx_wacl(sim_cpu *cpu,
address_word cia,
int fmt,
- unsigned64 vs,
- unsigned64 vt)
+ uint64_t vs,
+ uint64_t vt)
{
int i;
case MX_FMT_QH:
for (i = 0; i < 4; i++)
{
- signed32 s = (signed16)(vs & 0xFFFF);
+ int32_t s = (int16_t)(vs & 0xFFFF);
ACC.qh[i] = ((signed48)s << 16) | (vt & 0xFFFF);
vs >>= 16; vt >>= 16;
}
case MX_FMT_OB:
for (i = 0; i < 8; i++)
{
- signed16 s = (signed8)(vs & 0xFF);
+ int16_t s = (int8_t)(vs & 0xFF);
ACC.ob[i] = ((signed24)s << 8) | (vt & 0xFF);
vs >>= 8; vt >>= 8;
}
mdmx_wach(sim_cpu *cpu,
address_word cia,
int fmt,
- unsigned64 vs)
+ uint64_t vs)
{
int i;
case MX_FMT_QH:
for (i = 0; i < 4; i++)
{
- signed32 s = (signed16)(vs & 0xFFFF);
+ int32_t s = (int16_t)(vs & 0xFFFF);
ACC.qh[i] &= ~((signed48)0xFFFF << 32);
ACC.qh[i] |= ((signed48)s << 32);
vs >>= 16;
/* Reading and writing accumulator (rounding conversions).
Enumerating function guarantees s >= 0 for QH ops. */
-typedef signed16 (*QH_ROUND)(signed48 a, signed16 s);
+typedef int16_t (*QH_ROUND)(signed48 a, int16_t s);
#define QH_BIT(n) ((unsigned48)1 << (n))
#define QH_ONES(n) (((unsigned48)1 << (n))-1)
-static signed16
-RNASQH(signed48 a, signed16 s)
+static int16_t
+RNASQH(signed48 a, int16_t s)
{
signed48 t;
- signed16 result = 0;
+ int16_t result = 0;
if (s > 48)
result = 0;
if (t < QH_MIN)
t = QH_MIN;
}
- result = (signed16)t;
+ result = (int16_t)t;
}
return result;
}
-static signed16
-RNAUQH(signed48 a, signed16 s)
+static int16_t
+RNAUQH(signed48 a, int16_t s)
{
unsigned48 t;
- signed16 result;
+ int16_t result;
if (s > 48)
result = 0;
t++;
if (t > 0xFFFF)
t = 0xFFFF;
- result = (signed16)t;
+ result = (int16_t)t;
}
return result;
}
-static signed16
-RNESQH(signed48 a, signed16 s)
+static int16_t
+RNESQH(signed48 a, int16_t s)
{
signed48 t;
- signed16 result = 0;
+ int16_t result = 0;
if (s > 47)
result = 0;
if (t < QH_MIN)
t = QH_MIN;
}
- result = (signed16)t;
+ result = (int16_t)t;
}
return result;
}
-static signed16
-RNEUQH(signed48 a, signed16 s)
+static int16_t
+RNEUQH(signed48 a, int16_t s)
{
unsigned48 t;
- signed16 result;
+ int16_t result;
if (s > 48)
result = 0;
}
if (t > 0xFFFF)
t = 0xFFFF;
- result = (signed16)t;
+ result = (int16_t)t;
}
return result;
}
-static signed16
-RZSQH(signed48 a, signed16 s)
+static int16_t
+RZSQH(signed48 a, int16_t s)
{
signed48 t;
- signed16 result = 0;
+ int16_t result = 0;
if (s > 47)
result = 0;
if (t < QH_MIN)
t = QH_MIN;
}
- result = (signed16)t;
+ result = (int16_t)t;
}
return result;
}
-static signed16
-RZUQH(signed48 a, signed16 s)
+static int16_t
+RZUQH(signed48 a, int16_t s)
{
unsigned48 t;
- signed16 result = 0;
+ int16_t result = 0;
if (s > 48)
result = 0;
t = ((unsigned48)a & MASK48) >> s;
if (t > 0xFFFF)
t = 0xFFFF;
- result = (signed16)t;
+ result = (int16_t)t;
}
return result;
}
-typedef unsigned8 (*OB_ROUND)(signed24 a, unsigned8 s);
+typedef uint8_t (*OB_ROUND)(signed24 a, uint8_t s);
#define OB_BIT(n) ((unsigned24)1 << (n))
#define OB_ONES(n) (((unsigned24)1 << (n))-1)
-static unsigned8
-RNAUOB(signed24 a, unsigned8 s)
+static uint8_t
+RNAUOB(signed24 a, uint8_t s)
{
- unsigned8 result;
+ uint8_t result;
unsigned24 t;
if (s > 24)
return result;
}
-static unsigned8
-RNEUOB(signed24 a, unsigned8 s)
+static uint8_t
+RNEUOB(signed24 a, uint8_t s)
{
- unsigned8 result;
+ uint8_t result;
unsigned24 t;
if (s > 24)
return result;
}
-static unsigned8
-RZUOB(signed24 a, unsigned8 s)
+static uint8_t
+RZUOB(signed24 a, uint8_t s)
{
- unsigned8 result;
+ uint8_t result;
unsigned24 t;
if (s >= 24)
};
-static unsigned64
-qh_vector_round(sim_cpu *cpu, address_word cia, unsigned64 v2, QH_ROUND round)
+static uint64_t
+qh_vector_round(sim_cpu *cpu, address_word cia, uint64_t v2, QH_ROUND round)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i, s;
- signed16 h, h2;
+ int16_t h, h2;
s = 0;
for (i = 0; i < 4; i++)
{
- h2 = (signed16)(v2 & 0xFFFF);
+ h2 = (int16_t)(v2 & 0xFFFF);
if (h2 >= 0)
h = (*round)(ACC.qh[i], h2);
else
h = 0xdead;
}
v2 >>= 16;
- result |= ((unsigned64)((unsigned16)h) << s);
+ result |= ((uint64_t)((uint16_t)h) << s);
s += 16;
}
return result;
}
-static unsigned64
-qh_map_round(sim_cpu *cpu, address_word cia, signed16 h2, QH_ROUND round)
+static uint64_t
+qh_map_round(sim_cpu *cpu, address_word cia, int16_t h2, QH_ROUND round)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i, s;
- signed16 h;
+ int16_t h;
s = 0;
for (i = 0; i < 4; i++)
UnpredictableResult ();
h = 0xdead;
}
- result |= ((unsigned64)((unsigned16)h) << s);
+ result |= ((uint64_t)((uint16_t)h) << s);
s += 16;
}
return result;
}
-static unsigned64
-ob_vector_round(sim_cpu *cpu, address_word cia, unsigned64 v2, OB_ROUND round)
+static uint64_t
+ob_vector_round(sim_cpu *cpu, address_word cia, uint64_t v2, OB_ROUND round)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i, s;
- unsigned8 b, b2;
+ uint8_t b, b2;
s = 0;
for (i = 0; i < 8; i++)
{
b2 = v2 & 0xFF; v2 >>= 8;
b = (*round)(ACC.ob[i], b2);
- result |= ((unsigned64)b << s);
+ result |= ((uint64_t)b << s);
s += 8;
}
return result;
}
-static unsigned64
-ob_map_round(sim_cpu *cpu, address_word cia, unsigned8 b2, OB_ROUND round)
+static uint64_t
+ob_map_round(sim_cpu *cpu, address_word cia, uint8_t b2, OB_ROUND round)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i, s;
- unsigned8 b;
+ uint8_t b;
s = 0;
for (i = 0; i < 8; i++)
{
b = (*round)(ACC.ob[i], b2);
- result |= ((unsigned64)b << s);
+ result |= ((uint64_t)b << s);
s += 8;
}
return result;
}
-unsigned64
+uint64_t
mdmx_round_op(sim_cpu *cpu,
address_word cia,
int rm,
int vt,
MX_fmtsel fmtsel)
{
- unsigned64 op2;
- unsigned64 result = 0;
+ uint64_t op2;
+ uint64_t result = 0;
switch (MX_FMT (fmtsel))
{
};
-unsigned64
+uint64_t
mdmx_shuffle(sim_cpu *cpu,
address_word cia,
int shop,
- unsigned64 op1,
- unsigned64 op2)
+ uint64_t op1,
+ uint64_t op2)
{
- unsigned64 result = 0;
+ uint64_t result = 0;
int i, s;
int op;
s = 0;
for (i = 0; i < 4; i++)
{
- unsigned64 v;
+ uint64_t v;
switch (qh_shuffle[op][i].source)
{
s = 0;
for (i = 0; i < 8; i++)
{
- unsigned8 b;
+ uint8_t b;
unsigned int ishift = 8*ob_shuffle[op][i].index;
switch (ob_shuffle[op][i].source)
Unpredictable ();
b = 0;
}
- result |= ((unsigned64)b << s);
+ result |= ((uint64_t)b << s);
s += 8;
}
}
*mdmx:
*sb1:
{
- unsigned64 result;
+ uint64_t result;
int s;
check_mdmx (SD_, instruction_0);
check_mdmx_fmtop (SD_, instruction_0, FMTOP);
*mdmx:
*sb1:
{
- unsigned64 result;
+ uint64_t result;
int s;
check_mdmx (SD_, instruction_0);
check_mdmx_fmtop (SD_, instruction_0, FMTOP);
}
-:function:::unsigned32:compute_movep_src_reg:int reg
+:function:::uint32_t:compute_movep_src_reg:int reg
*micromips32:
*micromips64:
{
}
}
-:function:::unsigned32:compute_andi16_imm:int encoded_imm
+:function:::uint32_t:compute_andi16_imm:int encoded_imm
*micromips32:
*micromips64:
{
"bposge32 <IMMEDIATE>"
*micromipsdsp:
{
- unsigned32 pos = (DSPCR >> DSPCR_POS_SHIFT) & DSPCR_POS_MASK;
+ uint32_t pos = (DSPCR >> DSPCR_POS_SHIFT) & DSPCR_POS_MASK;
if (pos >= 32)
NIA = delayslot_micromips (SD_, NIA + (EXTEND12 (IMMEDIATE) << 1), NIA,
MICROMIPS_DELAYSLOT_SIZE_ANY);
Programmers Volume III, Revision 0.95, section 4.9. */
if ((SR & (status_KSU_mask|status_EXL|status_ERL|status_UX))
== (ksu_user << status_KSU_shift))
- return (address_word)((signed32)base + (signed32)offset);
+ return (address_word)((int32_t)base + (int32_t)offset);
#endif
return base + offset;
}
// Helper used by check_mt_hilo, check_mult_hilo, and check_div_hilo
// to check for restrictions (2) and (3) above.
//
-:function:::int:check_mf_cycles:hilo_history *history, signed64 time, const char *new
+:function:::int:check_mf_cycles:hilo_history *history, int64_t time, const char *new
{
if (history->mf.timestamp + 3 > time)
{
*vr4100:
*vr5000:
{
- signed64 time = sim_events_time (SD);
+ int64_t time = sim_events_time (SD);
int ok = check_mf_cycles (SD_, history, time, "MT");
history->mt.timestamp = time;
history->mt.cia = CIA;
*mipsIV:
*mipsV:
{
- signed64 time = sim_events_time (SD);
+ int64_t time = sim_events_time (SD);
int ok = (! MIPS_MACH_HAS_MT_HILO_HAZARD (SD)
|| check_mf_cycles (SD_, history, time, "MT"));
history->mt.timestamp = time;
*micromips32:
*micromips64:
{
- signed64 time = sim_events_time (SD);
+ int64_t time = sim_events_time (SD);
history->mt.timestamp = time;
history->mt.cia = CIA;
return 1;
*micromips32:
*micromips64:
{
- signed64 time = sim_events_time (SD);
+ int64_t time = sim_events_time (SD);
int ok = 1;
if (peer != NULL
&& peer->mt.timestamp > history->op.timestamp
*vr4100:
*vr5000:
{
- signed64 time = sim_events_time (SD);
+ int64_t time = sim_events_time (SD);
int ok = (check_mf_cycles (SD_, hi, time, "OP")
&& check_mf_cycles (SD_, lo, time, "OP"));
hi->op.timestamp = time;
*mipsIV:
*mipsV:
{
- signed64 time = sim_events_time (SD);
+ int64_t time = sim_events_time (SD);
int ok = (! MIPS_MACH_HAS_MULT_HILO_HAZARD (SD)
|| (check_mf_cycles (SD_, hi, time, "OP")
&& check_mf_cycles (SD_, lo, time, "OP")));
*micromips64:
{
/* FIXME: could record the fact that a stall occured if we want */
- signed64 time = sim_events_time (SD);
+ int64_t time = sim_events_time (SD);
hi->op.timestamp = time;
lo->op.timestamp = time;
hi->op.cia = CIA;
*vr5000:
*r3900:
{
- signed64 time = sim_events_time (SD);
+ int64_t time = sim_events_time (SD);
int ok = (check_mf_cycles (SD_, hi, time, "OP")
&& check_mf_cycles (SD_, lo, time, "OP"));
hi->op.timestamp = time;
*mipsIV:
*mipsV:
{
- signed64 time = sim_events_time (SD);
+ int64_t time = sim_events_time (SD);
int ok = (! MIPS_MACH_HAS_DIV_HILO_HAZARD (SD)
|| (check_mf_cycles (SD_, hi, time, "OP")
&& check_mf_cycles (SD_, lo, time, "OP")));
*micromips32:
*micromips64:
{
- signed64 time = sim_events_time (SD);
+ int64_t time = sim_events_time (SD);
hi->op.timestamp = time;
lo->op.timestamp = time;
hi->op.cia = CIA;
TRACE_ALU_RESULT (GPR[rd]);
}
-:function:::void:do_addi:int rs, int rt, unsigned16 immediate
+:function:::void:do_addi:int rs, int rt, uint16_t immediate
{
if (NotWordValue (GPR[rs]))
Unpredictable ();
{
int s = 32 + shift;
TRACE_ALU_INPUT2 (GPR[rt], s);
- GPR[rd] = ((signed64) GPR[rt]) >> s;
+ GPR[rd] = ((int64_t) GPR[rt]) >> s;
TRACE_ALU_RESULT (GPR[rd]);
}
{
int s = 32 + shift;
TRACE_ALU_INPUT2 (GPR[rt], s);
- GPR[rd] = (unsigned64) GPR[rt] >> s;
+ GPR[rd] = (uint64_t) GPR[rt] >> s;
TRACE_ALU_RESULT (GPR[rd]);
}
:function:::void:do_clo:int rd, int rs
{
- unsigned32 temp = GPR[rs];
- unsigned32 i, mask;
+ uint32_t temp = GPR[rs];
+ uint32_t i, mask;
if (NotWordValue (GPR[rs]))
Unpredictable ();
TRACE_ALU_INPUT1 (GPR[rs]);
- for (mask = ((unsigned32)1<<31), i = 0; i < 32; ++i)
+ for (mask = ((uint32_t)1<<31), i = 0; i < 32; ++i)
{
if ((temp & mask) == 0)
break;
:function:::void:do_clz:int rd, int rs
{
- unsigned32 temp = GPR[rs];
- unsigned32 i, mask;
+ uint32_t temp = GPR[rs];
+ uint32_t i, mask;
if (NotWordValue (GPR[rs]))
Unpredictable ();
TRACE_ALU_INPUT1 (GPR[rs]);
- for (mask = ((unsigned32)1<<31), i = 0; i < 32; ++i)
+ for (mask = ((uint32_t)1<<31), i = 0; i < 32; ++i)
{
if ((temp & mask) != 0)
break;
:function:::void:do_dclo:int rd, int rs
{
- unsigned64 temp = GPR[rs];
- unsigned32 i;
- unsigned64 mask;
+ uint64_t temp = GPR[rs];
+ uint32_t i;
+ uint64_t mask;
TRACE_ALU_INPUT1 (GPR[rs]);
- for (mask = ((unsigned64)1<<63), i = 0; i < 64; ++i)
+ for (mask = ((uint64_t)1<<63), i = 0; i < 64; ++i)
{
if ((temp & mask) == 0)
break;
:function:::void:do_dclz:int rd, int rs
{
- unsigned64 temp = GPR[rs];
- unsigned32 i;
- unsigned64 mask;
+ uint64_t temp = GPR[rs];
+ uint32_t i;
+ uint64_t mask;
TRACE_ALU_INPUT1 (GPR[rs]);
- for (mask = ((unsigned64)1<<63), i = 0; i < 64; ++i)
+ for (mask = ((uint64_t)1<<63), i = 0; i < 64; ++i)
{
if ((temp & mask) != 0)
break;
}
else
{
- unsigned64 memval = 0;
- unsigned64 memval1 = 0;
- unsigned64 mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
+ uint64_t memval = 0;
+ uint64_t memval1 = 0;
+ uint64_t mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
unsigned int shift = 2;
unsigned int reverse = (ReverseEndian ? (mask >> shift) : 0);
unsigned int bigend = (BigEndianCPU ? (mask >> shift) : 0);
}
else
{
- unsigned64 memval = 0;
- unsigned64 memval1 = 0;
+ uint64_t memval = 0;
+ uint64_t memval1 = 0;
LoadMemory (&memval, &memval1, AccessLength_DOUBLEWORD, paddr, vaddr,
isDATA, isREAL);
GPR[rt] = memval;
:function:::void:do_madd:int rs, int rt
{
- signed64 temp;
+ int64_t temp;
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
temp = (U8_4 (VL4_8 (HI), VL4_8 (LO))
- + ((signed64) EXTEND32 (GPR[rt]) * (signed64) EXTEND32 (GPR[rs])));
+ + ((int64_t) EXTEND32 (GPR[rt]) * (int64_t) EXTEND32 (GPR[rs])));
LO = EXTEND32 (temp);
HI = EXTEND32 (VH4_8 (temp));
TRACE_ALU_RESULT2 (HI, LO);
:function:::void:do_dsp_madd:int ac, int rs, int rt
{
- signed64 temp;
+ int64_t temp;
if (ac == 0)
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
temp = (U8_4 (VL4_8 (DSPHI(ac)), VL4_8 (DSPLO(ac)))
- + ((signed64) EXTEND32 (GPR[rt]) * (signed64) EXTEND32 (GPR[rs])));
+ + ((int64_t) EXTEND32 (GPR[rt]) * (int64_t) EXTEND32 (GPR[rs])));
DSPLO(ac) = EXTEND32 (temp);
DSPHI(ac) = EXTEND32 (VH4_8 (temp));
if (ac == 0)
:function:::void:do_maddu:int rs, int rt
{
- unsigned64 temp;
+ uint64_t temp;
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
temp = (U8_4 (VL4_8 (HI), VL4_8 (LO))
- + ((unsigned64) VL4_8 (GPR[rs]) * (unsigned64) VL4_8 (GPR[rt])));
+ + ((uint64_t) VL4_8 (GPR[rs]) * (uint64_t) VL4_8 (GPR[rt])));
ACX += U8_4 (VL4_8 (HI), VL4_8 (LO)) < temp; /* SmartMIPS */
LO = EXTEND32 (temp);
HI = EXTEND32 (VH4_8 (temp));
:function:::void:do_dsp_maddu:int ac, int rs, int rt
{
- unsigned64 temp;
+ uint64_t temp;
if (ac == 0)
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
temp = (U8_4 (VL4_8 (DSPHI(ac)), VL4_8 (DSPLO(ac)))
- + ((unsigned64) VL4_8 (GPR[rs]) * (unsigned64) VL4_8 (GPR[rt])));
+ + ((uint64_t) VL4_8 (GPR[rs]) * (uint64_t) VL4_8 (GPR[rt])));
if (ac == 0)
ACX += U8_4 (VL4_8 (HI), VL4_8 (LO)) < temp; /* SmartMIPS */
DSPLO(ac) = EXTEND32 (temp);
:function:::void:do_msub:int rs, int rt
{
- signed64 temp;
+ int64_t temp;
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
temp = (U8_4 (VL4_8 (HI), VL4_8 (LO))
- - ((signed64) EXTEND32 (GPR[rt]) * (signed64) EXTEND32 (GPR[rs])));
+ - ((int64_t) EXTEND32 (GPR[rt]) * (int64_t) EXTEND32 (GPR[rs])));
LO = EXTEND32 (temp);
HI = EXTEND32 (VH4_8 (temp));
TRACE_ALU_RESULT2 (HI, LO);
:function:::void:do_dsp_msub:int ac, int rs, int rt
{
- signed64 temp;
+ int64_t temp;
if (ac == 0)
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
temp = (U8_4 (VL4_8 (DSPHI(ac)), VL4_8 (DSPLO(ac)))
- - ((signed64) EXTEND32 (GPR[rt]) * (signed64) EXTEND32 (GPR[rs])));
+ - ((int64_t) EXTEND32 (GPR[rt]) * (int64_t) EXTEND32 (GPR[rs])));
DSPLO(ac) = EXTEND32 (temp);
DSPHI(ac) = EXTEND32 (VH4_8 (temp));
if (ac == 0)
:function:::void:do_msubu:int rs, int rt
{
- unsigned64 temp;
+ uint64_t temp;
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
temp = (U8_4 (VL4_8 (HI), VL4_8 (LO))
- - ((unsigned64) VL4_8 (GPR[rs]) * (unsigned64) VL4_8 (GPR[rt])));
+ - ((uint64_t) VL4_8 (GPR[rs]) * (uint64_t) VL4_8 (GPR[rt])));
LO = EXTEND32 (temp);
HI = EXTEND32 (VH4_8 (temp));
TRACE_ALU_RESULT2 (HI, LO);
:function:::void:do_dsp_msubu:int ac, int rs, int rt
{
- unsigned64 temp;
+ uint64_t temp;
if (ac == 0)
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
temp = (U8_4 (VL4_8 (DSPHI(ac)), VL4_8 (DSPLO(ac)))
- - ((unsigned64) VL4_8 (GPR[rs]) * (unsigned64) VL4_8 (GPR[rt])));
+ - ((uint64_t) VL4_8 (GPR[rs]) * (uint64_t) VL4_8 (GPR[rt])));
DSPLO(ac) = EXTEND32 (temp);
DSPHI(ac) = EXTEND32 (VH4_8 (temp));
if (ac == 0)
:function:::void:do_mul:int rd, int rs, int rt
{
- signed64 prod;
+ int64_t prod;
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
- prod = (((signed64)(signed32) GPR[rs])
- * ((signed64)(signed32) GPR[rt]));
+ prod = (((int64_t)(int32_t) GPR[rs])
+ * ((int64_t)(int32_t) GPR[rt]));
GPR[rd] = EXTEND32 (VL4_8 (prod));
TRACE_ALU_RESULT (GPR[rd]);
}
:function:::void:do_dsp_mult:int ac, int rs, int rt
{
- signed64 prod;
+ int64_t prod;
if (ac == 0)
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
- prod = ((signed64)(signed32) GPR[rs])
- * ((signed64)(signed32) GPR[rt]);
+ prod = ((int64_t)(int32_t) GPR[rs])
+ * ((int64_t)(int32_t) GPR[rt]);
DSPLO(ac) = EXTEND32 (VL4_8 (prod));
DSPHI(ac) = EXTEND32 (VH4_8 (prod));
if (ac == 0)
:function:::void:do_dsp_multu:int ac, int rs, int rt
{
- unsigned64 prod;
+ uint64_t prod;
if (ac == 0)
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
- prod = ((unsigned64)(unsigned32) GPR[rs])
- * ((unsigned64)(unsigned32) GPR[rt]);
+ prod = ((uint64_t)(uint32_t) GPR[rs])
+ * ((uint64_t)(uint32_t) GPR[rt]);
DSPLO(ac) = EXTEND32 (VL4_8 (prod));
DSPHI(ac) = EXTEND32 (VH4_8 (prod));
if (ac == 0)
:function:::void:do_sc:int rt, int offsetarg, int basereg, address_word instruction_0
{
- unsigned32 instruction = instruction_0;
+ uint32_t instruction = instruction_0;
address_word base = GPR[basereg];
address_word offset = EXTEND16 (offsetarg);
{
}
else
{
- unsigned64 memval = 0;
- unsigned64 memval1 = 0;
- unsigned64 mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
+ uint64_t memval = 0;
+ uint64_t memval1 = 0;
+ uint64_t mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
address_word reverseendian =
(ReverseEndian ? (mask ^ AccessLength_WORD) : 0);
address_word bigendiancpu =
unsigned int byte;
paddr = ((paddr & ~mask) | ((paddr & mask) ^ reverseendian));
byte = ((vaddr & mask) ^ bigendiancpu);
- memval = ((unsigned64) GPR[rt] << (8 * byte));
+ memval = ((uint64_t) GPR[rt] << (8 * byte));
if (LLBIT)
StoreMemory (AccessLength_WORD, memval, memval1, paddr, vaddr,
isREAL);
}
else
{
- unsigned64 memval = 0;
- unsigned64 memval1 = 0;
+ uint64_t memval = 0;
+ uint64_t memval1 = 0;
memval = GPR[rt];
if (LLBIT)
StoreMemory (AccessLength_DOUBLEWORD, memval, memval1, paddr, vaddr,
:function:::void:do_alnv_ps:int fd, int fs, int ft, int rs, address_word instruction_0
{
- unsigned64 fsx;
- unsigned64 ftx;
- unsigned64 fdx;
+ uint64_t fsx;
+ uint64_t ftx;
+ uint64_t fdx;
check_fpu (SD_);
check_u64 (SD_, instruction_0);
fsx = ValueFPR (fs, fmt_ps);
}
else
{
- unsigned64 fdx;
+ uint64_t fdx;
fdx = PackPS (PSUpper (ValueFPR ((GETFCC (cc+1) == tf) ? fs : fd,
fmt_ps)),
PSLower (ValueFPR ((GETFCC (cc+0) == tf) ? fs : fd,
}
else
{
- unsigned64 memval = 0;
- unsigned64 memval1 = 0;
- unsigned64 mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
+ uint64_t memval = 0;
+ uint64_t memval1 = 0;
+ uint64_t mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
address_word reverseendian =
(ReverseEndian ? (mask ^ AccessLength_WORD) : 0);
address_word bigendiancpu =
unsigned int byte;
paddr = ((paddr & ~mask) | ((paddr & mask) ^ reverseendian));
byte = ((vaddr & mask) ^ bigendiancpu);
- memval = (((unsigned64)COP_SW(1,fs)) << (8 * byte));
+ memval = (((uint64_t)COP_SW(1,fs)) << (8 * byte));
StoreMemory (AccessLength_WORD, memval, memval1, paddr, vaddr,
isREAL);
}
-:function:::void:do_addiu:int rs, int rt, unsigned16 immediate
+:function:::void:do_addiu:int rs, int rt, uint16_t immediate
{
if (NotWordValue (GPR[rs]))
Unpredictable ();
-:function:::void:do_daddiu:int rs, int rt, unsigned16 immediate
+:function:::void:do_daddiu:int rs, int rt, uint16_t immediate
{
TRACE_ALU_INPUT2 (GPR[rs], EXTEND16 (immediate));
GPR[rt] = GPR[rs] + EXTEND16 (immediate);
check_div_hilo (SD_, HIHISTORY, LOHISTORY);
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
{
- signed64 n = GPR[rs];
- signed64 d = GPR[rt];
- signed64 hi;
- signed64 lo;
+ int64_t n = GPR[rs];
+ int64_t d = GPR[rt];
+ int64_t hi;
+ int64_t lo;
if (d == 0)
{
lo = SIGNED64 (0x8000000000000000);
check_div_hilo (SD_, HIHISTORY, LOHISTORY);
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
{
- unsigned64 n = GPR[rs];
- unsigned64 d = GPR[rt];
- unsigned64 hi;
- unsigned64 lo;
+ uint64_t n = GPR[rs];
+ uint64_t d = GPR[rt];
+ uint64_t hi;
+ uint64_t lo;
if (d == 0)
{
lo = SIGNED64 (0x8000000000000000);
check_div_hilo (SD_, HIHISTORY, LOHISTORY);
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
{
- signed32 n = GPR[rs];
- signed32 d = GPR[rt];
+ int32_t n = GPR[rs];
+ int32_t d = GPR[rt];
if (d == 0)
{
LO = EXTEND32 (0x80000000);
check_div_hilo (SD_, HIHISTORY, LOHISTORY);
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
{
- unsigned32 n = GPR[rs];
- unsigned32 d = GPR[rt];
+ uint32_t n = GPR[rs];
+ uint32_t d = GPR[rt];
if (d == 0)
{
LO = EXTEND32 (0x80000000);
:function:::void:do_dmultx:int rs, int rt, int rd, int signed_p
{
- unsigned64 lo;
- unsigned64 hi;
- unsigned64 m00;
- unsigned64 m01;
- unsigned64 m10;
- unsigned64 m11;
- unsigned64 mid;
+ uint64_t lo;
+ uint64_t hi;
+ uint64_t m00;
+ uint64_t m01;
+ uint64_t m10;
+ uint64_t m11;
+ uint64_t mid;
int sign;
- unsigned64 op1 = GPR[rs];
- unsigned64 op2 = GPR[rt];
+ uint64_t op1 = GPR[rs];
+ uint64_t op2 = GPR[rt];
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
/* make signed multiply unsigned */
sign = 0;
if (signed_p)
{
- if ((signed64) op1 < 0)
+ if ((int64_t) op1 < 0)
{
op1 = - op1;
++sign;
}
- if ((signed64) op2 < 0)
+ if ((int64_t) op2 < 0)
{
op2 = - op2;
++sign;
}
}
/* multiply out the 4 sub products */
- m00 = ((unsigned64) VL4_8 (op1) * (unsigned64) VL4_8 (op2));
- m10 = ((unsigned64) VH4_8 (op1) * (unsigned64) VL4_8 (op2));
- m01 = ((unsigned64) VL4_8 (op1) * (unsigned64) VH4_8 (op2));
- m11 = ((unsigned64) VH4_8 (op1) * (unsigned64) VH4_8 (op2));
+ m00 = ((uint64_t) VL4_8 (op1) * (uint64_t) VL4_8 (op2));
+ m10 = ((uint64_t) VH4_8 (op1) * (uint64_t) VL4_8 (op2));
+ m01 = ((uint64_t) VL4_8 (op1) * (uint64_t) VH4_8 (op2));
+ m11 = ((uint64_t) VH4_8 (op1) * (uint64_t) VH4_8 (op2));
/* add the products */
- mid = ((unsigned64) VH4_8 (m00)
- + (unsigned64) VL4_8 (m10)
- + (unsigned64) VL4_8 (m01));
+ mid = ((uint64_t) VH4_8 (m00)
+ + (uint64_t) VL4_8 (m10)
+ + (uint64_t) VL4_8 (m01));
lo = U8_4 (mid, m00);
hi = (m11
- + (unsigned64) VH4_8 (mid)
- + (unsigned64) VH4_8 (m01)
- + (unsigned64) VH4_8 (m10));
+ + (uint64_t) VH4_8 (mid)
+ + (uint64_t) VH4_8 (m01)
+ + (uint64_t) VH4_8 (m10));
/* fix the sign */
if (sign & 1)
{
}
-:function:::unsigned64:do_dror:unsigned64 x,unsigned64 y
+:function:::uint64_t:do_dror:uint64_t x,uint64_t y
{
- unsigned64 result;
+ uint64_t result;
y &= 63;
TRACE_ALU_INPUT2 (x, y);
:function:::void:do_dsra:int rt, int rd, int shift
{
TRACE_ALU_INPUT2 (GPR[rt], shift);
- GPR[rd] = ((signed64) GPR[rt]) >> shift;
+ GPR[rd] = ((int64_t) GPR[rt]) >> shift;
TRACE_ALU_RESULT (GPR[rd]);
}
{
int s = MASKED64 (GPR[rs], 5, 0);
TRACE_ALU_INPUT2 (GPR[rt], s);
- GPR[rd] = ((signed64) GPR[rt]) >> s;
+ GPR[rd] = ((int64_t) GPR[rt]) >> s;
TRACE_ALU_RESULT (GPR[rd]);
}
:function:::void:do_dsrl:int rt, int rd, int shift
{
TRACE_ALU_INPUT2 (GPR[rt], shift);
- GPR[rd] = (unsigned64) GPR[rt] >> shift;
+ GPR[rd] = (uint64_t) GPR[rt] >> shift;
TRACE_ALU_RESULT (GPR[rd]);
}
{
int s = MASKED64 (GPR[rs], 5, 0);
TRACE_ALU_INPUT2 (GPR[rt], s);
- GPR[rd] = (unsigned64) GPR[rt] >> s;
+ GPR[rd] = (uint64_t) GPR[rt] >> s;
TRACE_ALU_RESULT (GPR[rd]);
}
address_word bigendiancpu = (BigEndianCPU ? (mask ^ access) : 0);
unsigned int byte;
address_word paddr;
- unsigned64 memval;
+ uint64_t memval;
address_word vaddr;
paddr = vaddr = loadstore_ea (SD_, base, offset);
unsigned int byte;
unsigned int word;
address_word paddr;
- unsigned64 memval;
+ uint64_t memval;
address_word vaddr;
int nr_lhs_bits;
int nr_rhs_bits;
/* nr_lhs_bits + nr_rhs_bits == 8 * (accesss + 1) */
/* fprintf (stderr, "l[wd]l: 0x%08lx%08lx 0x%08lx%08lx %d:%d %d+%d\n",
- (long) ((unsigned64) vaddr >> 32), (long) vaddr,
- (long) ((unsigned64) paddr >> 32), (long) paddr,
+ (long) ((uint64_t) vaddr >> 32), (long) vaddr,
+ (long) ((uint64_t) paddr >> 32), (long) paddr,
word, byte, nr_lhs_bits, nr_rhs_bits); */
LoadMemory (&memval, NULL, byte, paddr, vaddr, isDATA, isREAL);
rt = (rt & ~lhs_mask) | (temp & lhs_mask);
/* fprintf (stderr, "l[wd]l: 0x%08lx%08lx -> 0x%08lx%08lx & 0x%08lx%08lx -> 0x%08lx%08lx\n",
- (long) ((unsigned64) memval >> 32), (long) memval,
- (long) ((unsigned64) temp >> 32), (long) temp,
- (long) ((unsigned64) lhs_mask >> 32), (long) lhs_mask,
+ (long) ((uint64_t) memval >> 32), (long) memval,
+ (long) ((uint64_t) temp >> 32), (long) temp,
+ (long) ((uint64_t) lhs_mask >> 32), (long) lhs_mask,
(long) (rt >> 32), (long) rt); */
return rt;
}
address_word bigendiancpu = (BigEndianCPU ? -1 : 0);
unsigned int byte;
address_word paddr;
- unsigned64 memval;
+ uint64_t memval;
address_word vaddr;
paddr = vaddr = loadstore_ea (SD_, base, offset);
:function:::void:do_mult:int rs, int rt, int rd
{
- signed64 prod;
+ int64_t prod;
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
- prod = (((signed64)(signed32) GPR[rs])
- * ((signed64)(signed32) GPR[rt]));
+ prod = (((int64_t)(int32_t) GPR[rs])
+ * ((int64_t)(int32_t) GPR[rt]));
LO = EXTEND32 (VL4_8 (prod));
HI = EXTEND32 (VH4_8 (prod));
ACX = 0; /* SmartMIPS */
:function:::void:do_multu:int rs, int rt, int rd
{
- unsigned64 prod;
+ uint64_t prod;
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
- prod = (((unsigned64)(unsigned32) GPR[rs])
- * ((unsigned64)(unsigned32) GPR[rt]));
+ prod = (((uint64_t)(uint32_t) GPR[rs])
+ * ((uint64_t)(uint32_t) GPR[rt]));
LO = EXTEND32 (VL4_8 (prod));
HI = EXTEND32 (VH4_8 (prod));
if (rd != 0)
}
-:function:::unsigned64:do_ror:unsigned32 x,unsigned32 y
+:function:::uint64_t:do_ror:uint32_t x,uint32_t y
{
- unsigned64 result;
+ uint64_t result;
y &= 31;
TRACE_ALU_INPUT2 (x, y);
address_word bigendiancpu = (BigEndianCPU ? (mask ^ access) : 0);
unsigned int byte;
address_word paddr;
- unsigned64 memval;
+ uint64_t memval;
address_word vaddr;
paddr = vaddr = loadstore_ea (SD_, base, offset);
unsigned int byte;
unsigned int word;
address_word paddr;
- unsigned64 memval;
+ uint64_t memval;
address_word vaddr;
int nr_lhs_bits;
int nr_rhs_bits;
nr_rhs_bits = 8 * access - 8 * byte;
/* nr_lhs_bits + nr_rhs_bits == 8 * (accesss + 1) */
/* fprintf (stderr, "s[wd]l: 0x%08lx%08lx 0x%08lx%08lx %d:%d %d+%d\n",
- (long) ((unsigned64) vaddr >> 32), (long) vaddr,
- (long) ((unsigned64) paddr >> 32), (long) paddr,
+ (long) ((uint64_t) vaddr >> 32), (long) vaddr,
+ (long) ((uint64_t) paddr >> 32), (long) paddr,
word, byte, nr_lhs_bits, nr_rhs_bits); */
if (word == 0)
memval = (rt << nr_lhs_bits);
}
/* fprintf (stderr, "s[wd]l: 0x%08lx%08lx -> 0x%08lx%08lx\n",
- (long) ((unsigned64) rt >> 32), (long) rt,
- (long) ((unsigned64) memval >> 32), (long) memval); */
+ (long) ((uint64_t) rt >> 32), (long) rt,
+ (long) ((uint64_t) memval >> 32), (long) memval); */
StoreMemory (byte, memval, 0, paddr, vaddr, isREAL);
}
address_word bigendiancpu = (BigEndianCPU ? -1 : 0);
unsigned int byte;
address_word paddr;
- unsigned64 memval;
+ uint64_t memval;
address_word vaddr;
paddr = vaddr = loadstore_ea (SD_, base, offset);
:function:::void:do_sll:int rt, int rd, int shift
{
- unsigned32 temp = (GPR[rt] << shift);
+ uint32_t temp = (GPR[rt] << shift);
TRACE_ALU_INPUT2 (GPR[rt], shift);
GPR[rd] = EXTEND32 (temp);
TRACE_ALU_RESULT (GPR[rd]);
:function:::void:do_sllv:int rs, int rt, int rd
{
int s = MASKED (GPR[rs], 4, 0);
- unsigned32 temp = (GPR[rt] << s);
+ uint32_t temp = (GPR[rt] << s);
TRACE_ALU_INPUT2 (GPR[rt], s);
GPR[rd] = EXTEND32 (temp);
TRACE_ALU_RESULT (GPR[rd]);
}
-:function:::void:do_slti:int rs, int rt, unsigned16 immediate
+:function:::void:do_slti:int rs, int rt, uint16_t immediate
{
TRACE_ALU_INPUT2 (GPR[rs], EXTEND16 (immediate));
GPR[rt] = ((signed_word) GPR[rs] < (signed_word) EXTEND16 (immediate));
}
-:function:::void:do_sltiu:int rs, int rt, unsigned16 immediate
+:function:::void:do_sltiu:int rs, int rt, uint16_t immediate
{
TRACE_ALU_INPUT2 (GPR[rs], EXTEND16 (immediate));
GPR[rt] = ((unsigned_word) GPR[rs] < (unsigned_word) EXTEND16 (immediate));
:function:::void:do_sra:int rt, int rd, int shift
{
- signed32 temp = (signed32) GPR[rt] >> shift;
+ int32_t temp = (int32_t) GPR[rt] >> shift;
if (NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rt], shift);
:function:::void:do_srav:int rs, int rt, int rd
{
int s = MASKED (GPR[rs], 4, 0);
- signed32 temp = (signed32) GPR[rt] >> s;
+ int32_t temp = (int32_t) GPR[rt] >> s;
if (NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rt], s);
:function:::void:do_srl:int rt, int rd, int shift
{
- unsigned32 temp = (unsigned32) GPR[rt] >> shift;
+ uint32_t temp = (uint32_t) GPR[rt] >> shift;
if (NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rt], shift);
:function:::void:do_srlv:int rs, int rt, int rd
{
int s = MASKED (GPR[rs], 4, 0);
- unsigned32 temp = (unsigned32) GPR[rt] >> s;
+ uint32_t temp = (uint32_t) GPR[rt] >> s;
if (NotWordValue (GPR[rt]))
Unpredictable ();
TRACE_ALU_INPUT2 (GPR[rt], s);
}
-:function:::void:do_xori:int rs, int rt, unsigned16 immediate
+:function:::void:do_xori:int rs, int rt, uint16_t immediate
{
TRACE_ALU_INPUT2 (GPR[rs], immediate);
GPR[rt] = GPR[rs] ^ immediate;
// unsigned_word, which is limited to the size of the machine's registers.
//
-:function:::unsigned64:do_load_double:address_word base, address_word offset
+:function:::uint64_t:do_load_double:address_word base, address_word offset
*mipsII:
*mips32:
*mips32r2:
int bigendian = (BigEndianCPU ? ! ReverseEndian : ReverseEndian);
address_word vaddr;
address_word paddr;
- unsigned64 memval;
- unsigned64 v;
+ uint64_t memval;
+ uint64_t v;
paddr = vaddr = loadstore_ea (SD_, base, offset);
if ((vaddr & AccessLength_DOUBLEWORD) != 0)
sim_core_unaligned_signal);
}
LoadMemory (&memval, NULL, AccessLength_WORD, paddr, vaddr, isDATA, isREAL);
- v = (unsigned64)memval;
+ v = (uint64_t)memval;
LoadMemory (&memval, NULL, AccessLength_WORD, paddr + 4, vaddr + 4, isDATA,
isREAL);
return (bigendian ? ((v << 32) | memval) : (v | (memval << 32)));
// unsigned_word, which is limited to the size of the machine's registers.
//
-:function:::void:do_store_double:address_word base, address_word offset, unsigned64 v
+:function:::void:do_store_double:address_word base, address_word offset, uint64_t v
*mipsII:
*mips32:
*mips32r2:
int bigendian = (BigEndianCPU ? ! ReverseEndian : ReverseEndian);
address_word vaddr;
address_word paddr;
- unsigned64 memval;
+ uint64_t memval;
paddr = vaddr = loadstore_ea (SD_, base, offset);
if ((vaddr & AccessLength_DOUBLEWORD) != 0)
"dmfc1 r<RT>, f<FS>"
*mipsIII:
{
- unsigned64 v;
+ uint64_t v;
check_fpu (SD_);
check_u64 (SD_, instruction_0);
if (SizeFGR () == 64)
"dmtc1 r<RT>, f<FS>"
*mipsIII:
{
- unsigned64 v;
+ uint64_t v;
check_fpu (SD_);
check_u64 (SD_, instruction_0);
if (SizeFGR () == 64)
*mipsII:
*mipsIII:
{
- unsigned64 v;
+ uint64_t v;
check_fpu (SD_);
v = EXTEND32 (FGR[FS]);
PENDING_FILL (RT, v);
:function:::void:do_dsbh:int rd, int rt
{
- union { unsigned64 d; unsigned16 h[4]; } u;
+ union { uint64_t d; uint16_t h[4]; } u;
TRACE_ALU_INPUT1 (GPR[rt]);
u.d = GPR[rt];
u.h[0] = SWAP_2 (u.h[0]);
:function:::void:do_dshd:int rd, int rt
{
- unsigned64 d;
+ uint64_t d;
TRACE_ALU_INPUT1 (GPR[rt]);
d = GPR[rt];
GPR[rd] = ((d >> 48)
:function:::void:do_wsbh:int rd, int rt
{
- union { unsigned32 w; unsigned16 h[2]; } u;
+ union { uint32_t w; uint16_t h[2]; } u;
TRACE_ALU_INPUT1 (GPR[rt]);
u.w = GPR[rt];
u.h[0] = SWAP_2 (u.h[0]);
}
-INLINE_SIM_MAIN (unsigned32)
+INLINE_SIM_MAIN (uint32_t)
ifetch32 (SIM_DESC SD,
sim_cpu *CPU,
address_word cia,
address_word bigendiancpu = (BigEndianCPU ? (mask ^ access) : 0);
unsigned int byte;
address_word paddr = vaddr;
- unsigned64 memval;
+ uint64_t memval;
if ((vaddr & access) != 0)
SignalExceptionInstructionFetch ();
}
-INLINE_SIM_MAIN (unsigned16)
+INLINE_SIM_MAIN (uint16_t)
ifetch16 (SIM_DESC SD,
sim_cpu *CPU,
address_word cia,
address_word bigendiancpu = (BigEndianCPU ? (mask ^ access) : 0);
unsigned int byte;
address_word paddr = vaddr;
- unsigned64 memval;
+ uint64_t memval;
if ((vaddr & access) != 0)
SignalExceptionInstructionFetch ();
{
case 4:
if (PENDING_SLOT_VALUE[index])
- *(unsigned32*)PENDING_SLOT_DEST[index] |=
+ *(uint32_t*)PENDING_SLOT_DEST[index] |=
BIT32 (PENDING_SLOT_BIT[index]);
else
- *(unsigned32*)PENDING_SLOT_DEST[index] &=
+ *(uint32_t*)PENDING_SLOT_DEST[index] &=
BIT32 (PENDING_SLOT_BIT[index]);
break;
case 8:
if (PENDING_SLOT_VALUE[index])
- *(unsigned64*)PENDING_SLOT_DEST[index] |=
+ *(uint64_t*)PENDING_SLOT_DEST[index] |=
BIT64 (PENDING_SLOT_BIT[index]);
else
- *(unsigned64*)PENDING_SLOT_DEST[index] &=
+ *(uint64_t*)PENDING_SLOT_DEST[index] &=
BIT64 (PENDING_SLOT_BIT[index]);
break;
}
switch (PENDING_SLOT_SIZE[index])
{
case 4:
- *(unsigned32*)PENDING_SLOT_DEST[index] =
+ *(uint32_t*)PENDING_SLOT_DEST[index] =
PENDING_SLOT_VALUE[index];
break;
case 8:
- *(unsigned64*)PENDING_SLOT_DEST[index] =
+ *(uint64_t*)PENDING_SLOT_DEST[index] =
PENDING_SLOT_VALUE[index];
break;
}
/* Deprecated macros and types for manipulating 64bit values. Use
../common/sim-bits.h and ../common/sim-endian.h macros instead. */
-typedef signed64 word64;
-typedef unsigned64 uword64;
+typedef int64_t word64;
+typedef uint64_t uword64;
#define WORD64LO(t) (unsigned int)((t)&0xFFFFFFFF)
#define WORD64HI(t) (unsigned int)(((uword64)(t))>>32)
more details. */
typedef struct _hilo_access {
- signed64 timestamp;
+ int64_t timestamp;
address_word cia;
} hilo_access;
#define ALU32_END(ANS) \
if (ALU32_HAD_OVERFLOW) \
SignalExceptionIntegerOverflow (); \
- (ANS) = (signed32) ALU32_OVERFLOW_RESULT
+ (ANS) = (int32_t) ALU32_OVERFLOW_RESULT
#define ALU64_END(ANS) \
int slot_size[PSLOTS];
int slot_bit[PSLOTS];
void *slot_dest[PSLOTS];
- unsigned64 slot_value[PSLOTS];
+ uint64_t slot_value[PSLOTS];
} pending_write_queue;
#ifndef PENDING_TRACE
32 or 64 bits. Since the accumulators are 2's complement with
overflow suppressed, high-order bits can be ignored in most contexts. */
-typedef signed32 signed24;
-typedef signed64 signed48;
+typedef int32_t signed24;
+typedef int64_t signed48;
typedef union {
signed24 ob[8];
/* FPR access. */
-unsigned64 value_fpr (SIM_STATE, int fpr, FP_formats);
+uint64_t value_fpr (SIM_STATE, int fpr, FP_formats);
#define ValueFPR(FPR,FMT) value_fpr (SIM_ARGS, (FPR), (FMT))
-void store_fpr (SIM_STATE, int fpr, FP_formats fmt, unsigned64 value);
+void store_fpr (SIM_STATE, int fpr, FP_formats fmt, uint64_t value);
#define StoreFPR(FPR,FMT,VALUE) store_fpr (SIM_ARGS, (FPR), (FMT), (VALUE))
-unsigned64 ps_lower (SIM_STATE, unsigned64 op);
+uint64_t ps_lower (SIM_STATE, uint64_t op);
#define PSLower(op) ps_lower (SIM_ARGS, op)
-unsigned64 ps_upper (SIM_STATE, unsigned64 op);
+uint64_t ps_upper (SIM_STATE, uint64_t op);
#define PSUpper(op) ps_upper (SIM_ARGS, op)
-unsigned64 pack_ps (SIM_STATE, unsigned64 op1, unsigned64 op2, FP_formats from);
+uint64_t pack_ps (SIM_STATE, uint64_t op1, uint64_t op2, FP_formats from);
#define PackPS(op1,op2) pack_ps (SIM_ARGS, op1, op2, fmt_single)
/* FPU operations. */
-void fp_cmp (SIM_STATE, unsigned64 op1, unsigned64 op2, FP_formats fmt, int abs, int cond, int cc);
+void fp_cmp (SIM_STATE, uint64_t op1, uint64_t op2, FP_formats fmt, int abs, int cond, int cc);
#define Compare(op1,op2,fmt,cond,cc) fp_cmp(SIM_ARGS, op1, op2, fmt, 0, cond, cc)
-unsigned64 fp_abs (SIM_STATE, unsigned64 op, FP_formats fmt);
+uint64_t fp_abs (SIM_STATE, uint64_t op, FP_formats fmt);
#define AbsoluteValue(op,fmt) fp_abs(SIM_ARGS, op, fmt)
-unsigned64 fp_neg (SIM_STATE, unsigned64 op, FP_formats fmt);
+uint64_t fp_neg (SIM_STATE, uint64_t op, FP_formats fmt);
#define Negate(op,fmt) fp_neg(SIM_ARGS, op, fmt)
-unsigned64 fp_add (SIM_STATE, unsigned64 op1, unsigned64 op2, FP_formats fmt);
+uint64_t fp_add (SIM_STATE, uint64_t op1, uint64_t op2, FP_formats fmt);
#define Add(op1,op2,fmt) fp_add(SIM_ARGS, op1, op2, fmt)
-unsigned64 fp_sub (SIM_STATE, unsigned64 op1, unsigned64 op2, FP_formats fmt);
+uint64_t fp_sub (SIM_STATE, uint64_t op1, uint64_t op2, FP_formats fmt);
#define Sub(op1,op2,fmt) fp_sub(SIM_ARGS, op1, op2, fmt)
-unsigned64 fp_mul (SIM_STATE, unsigned64 op1, unsigned64 op2, FP_formats fmt);
+uint64_t fp_mul (SIM_STATE, uint64_t op1, uint64_t op2, FP_formats fmt);
#define Multiply(op1,op2,fmt) fp_mul(SIM_ARGS, op1, op2, fmt)
-unsigned64 fp_div (SIM_STATE, unsigned64 op1, unsigned64 op2, FP_formats fmt);
+uint64_t fp_div (SIM_STATE, uint64_t op1, uint64_t op2, FP_formats fmt);
#define Divide(op1,op2,fmt) fp_div(SIM_ARGS, op1, op2, fmt)
-unsigned64 fp_recip (SIM_STATE, unsigned64 op, FP_formats fmt);
+uint64_t fp_recip (SIM_STATE, uint64_t op, FP_formats fmt);
#define Recip(op,fmt) fp_recip(SIM_ARGS, op, fmt)
-unsigned64 fp_sqrt (SIM_STATE, unsigned64 op, FP_formats fmt);
+uint64_t fp_sqrt (SIM_STATE, uint64_t op, FP_formats fmt);
#define SquareRoot(op,fmt) fp_sqrt(SIM_ARGS, op, fmt)
-unsigned64 fp_rsqrt (SIM_STATE, unsigned64 op, FP_formats fmt);
+uint64_t fp_rsqrt (SIM_STATE, uint64_t op, FP_formats fmt);
#define RSquareRoot(op,fmt) fp_rsqrt(SIM_ARGS, op, fmt)
-unsigned64 fp_madd (SIM_STATE, unsigned64 op1, unsigned64 op2,
- unsigned64 op3, FP_formats fmt);
+uint64_t fp_madd (SIM_STATE, uint64_t op1, uint64_t op2,
+ uint64_t op3, FP_formats fmt);
#define MultiplyAdd(op1,op2,op3,fmt) fp_madd(SIM_ARGS, op1, op2, op3, fmt)
-unsigned64 fp_msub (SIM_STATE, unsigned64 op1, unsigned64 op2,
- unsigned64 op3, FP_formats fmt);
+uint64_t fp_msub (SIM_STATE, uint64_t op1, uint64_t op2,
+ uint64_t op3, FP_formats fmt);
#define MultiplySub(op1,op2,op3,fmt) fp_msub(SIM_ARGS, op1, op2, op3, fmt)
-unsigned64 fp_nmadd (SIM_STATE, unsigned64 op1, unsigned64 op2,
- unsigned64 op3, FP_formats fmt);
+uint64_t fp_nmadd (SIM_STATE, uint64_t op1, uint64_t op2,
+ uint64_t op3, FP_formats fmt);
#define NegMultiplyAdd(op1,op2,op3,fmt) fp_nmadd(SIM_ARGS, op1, op2, op3, fmt)
-unsigned64 fp_nmsub (SIM_STATE, unsigned64 op1, unsigned64 op2,
- unsigned64 op3, FP_formats fmt);
+uint64_t fp_nmsub (SIM_STATE, uint64_t op1, uint64_t op2,
+ uint64_t op3, FP_formats fmt);
#define NegMultiplySub(op1,op2,op3,fmt) fp_nmsub(SIM_ARGS, op1, op2, op3, fmt)
-unsigned64 convert (SIM_STATE, int rm, unsigned64 op, FP_formats from, FP_formats to);
+uint64_t convert (SIM_STATE, int rm, uint64_t op, FP_formats from, FP_formats to);
#define Convert(rm,op,from,to) convert (SIM_ARGS, rm, op, from, to)
-unsigned64 convert_ps (SIM_STATE, int rm, unsigned64 op, FP_formats from,
+uint64_t convert_ps (SIM_STATE, int rm, uint64_t op, FP_formats from,
FP_formats to);
#define ConvertPS(rm,op,from,to) convert_ps (SIM_ARGS, rm, op, from, to)
/* MIPS-3D ASE operations. */
#define CompareAbs(op1,op2,fmt,cond,cc) \
fp_cmp(SIM_ARGS, op1, op2, fmt, 1, cond, cc)
-unsigned64 fp_add_r (SIM_STATE, unsigned64 op1, unsigned64 op2, FP_formats fmt);
+uint64_t fp_add_r (SIM_STATE, uint64_t op1, uint64_t op2, FP_formats fmt);
#define AddR(op1,op2,fmt) fp_add_r(SIM_ARGS, op1, op2, fmt)
-unsigned64 fp_mul_r (SIM_STATE, unsigned64 op1, unsigned64 op2, FP_formats fmt);
+uint64_t fp_mul_r (SIM_STATE, uint64_t op1, uint64_t op2, FP_formats fmt);
#define MultiplyR(op1,op2,fmt) fp_mul_r(SIM_ARGS, op1, op2, fmt)
-unsigned64 fp_recip1 (SIM_STATE, unsigned64 op, FP_formats fmt);
+uint64_t fp_recip1 (SIM_STATE, uint64_t op, FP_formats fmt);
#define Recip1(op,fmt) fp_recip1(SIM_ARGS, op, fmt)
-unsigned64 fp_recip2 (SIM_STATE, unsigned64 op1, unsigned64 op2, FP_formats fmt);
+uint64_t fp_recip2 (SIM_STATE, uint64_t op1, uint64_t op2, FP_formats fmt);
#define Recip2(op1,op2,fmt) fp_recip2(SIM_ARGS, op1, op2, fmt)
-unsigned64 fp_rsqrt1 (SIM_STATE, unsigned64 op, FP_formats fmt);
+uint64_t fp_rsqrt1 (SIM_STATE, uint64_t op, FP_formats fmt);
#define RSquareRoot1(op,fmt) fp_rsqrt1(SIM_ARGS, op, fmt)
-unsigned64 fp_rsqrt2 (SIM_STATE, unsigned64 op1, unsigned64 op2, FP_formats fmt);
+uint64_t fp_rsqrt2 (SIM_STATE, uint64_t op1, uint64_t op2, FP_formats fmt);
#define RSquareRoot2(op1,op2,fmt) fp_rsqrt2(SIM_ARGS, op1, op2, fmt)
#define MX_VECT_ABSD (13) /* SB-1 only. */
#define MX_VECT_AVG (14) /* SB-1 only. */
-unsigned64 mdmx_cpr_op (SIM_STATE, int op, unsigned64 op1, int vt, MX_fmtsel fmtsel);
+uint64_t mdmx_cpr_op (SIM_STATE, int op, uint64_t op1, int vt, MX_fmtsel fmtsel);
#define MX_Add(op1,vt,fmtsel) mdmx_cpr_op(SIM_ARGS, MX_VECT_ADD, op1, vt, fmtsel)
#define MX_And(op1,vt,fmtsel) mdmx_cpr_op(SIM_ARGS, MX_VECT_AND, op1, vt, fmtsel)
#define MX_Max(op1,vt,fmtsel) mdmx_cpr_op(SIM_ARGS, MX_VECT_MAX, op1, vt, fmtsel)
#define MX_C_EQ 0x1
#define MX_C_LT 0x4
-void mdmx_cc_op (SIM_STATE, int cond, unsigned64 op1, int vt, MX_fmtsel fmtsel);
+void mdmx_cc_op (SIM_STATE, int cond, uint64_t op1, int vt, MX_fmtsel fmtsel);
#define MX_Comp(op1,cond,vt,fmtsel) mdmx_cc_op(SIM_ARGS, cond, op1, vt, fmtsel)
-unsigned64 mdmx_pick_op (SIM_STATE, int tf, unsigned64 op1, int vt, MX_fmtsel fmtsel);
+uint64_t mdmx_pick_op (SIM_STATE, int tf, uint64_t op1, int vt, MX_fmtsel fmtsel);
#define MX_Pick(tf,op1,vt,fmtsel) mdmx_pick_op(SIM_ARGS, tf, op1, vt, fmtsel)
#define MX_VECT_ADDA (0)
#define MX_VECT_SUBL (7)
#define MX_VECT_ABSDA (8) /* SB-1 only. */
-void mdmx_acc_op (SIM_STATE, int op, unsigned64 op1, int vt, MX_fmtsel fmtsel);
+void mdmx_acc_op (SIM_STATE, int op, uint64_t op1, int vt, MX_fmtsel fmtsel);
#define MX_AddA(op1,vt,fmtsel) mdmx_acc_op(SIM_ARGS, MX_VECT_ADDA, op1, vt, fmtsel)
#define MX_AddL(op1,vt,fmtsel) mdmx_acc_op(SIM_ARGS, MX_VECT_ADDL, op1, vt, fmtsel)
#define MX_MulA(op1,vt,fmtsel) mdmx_acc_op(SIM_ARGS, MX_VECT_MULA, op1, vt, fmtsel)
#define MX_RAC_M (1)
#define MX_RAC_H (2)
-unsigned64 mdmx_rac_op (SIM_STATE, int, int);
+uint64_t mdmx_rac_op (SIM_STATE, int, int);
#define MX_RAC(op,fmt) mdmx_rac_op(SIM_ARGS, op, fmt)
-void mdmx_wacl (SIM_STATE, int, unsigned64, unsigned64);
+void mdmx_wacl (SIM_STATE, int, uint64_t, uint64_t);
#define MX_WACL(fmt,vs,vt) mdmx_wacl(SIM_ARGS, fmt, vs, vt)
-void mdmx_wach (SIM_STATE, int, unsigned64);
+void mdmx_wach (SIM_STATE, int, uint64_t);
#define MX_WACH(fmt,vs) mdmx_wach(SIM_ARGS, fmt, vs)
#define MX_RND_AS (0)
#define MX_RND_ZS (4)
#define MX_RND_ZU (5)
-unsigned64 mdmx_round_op (SIM_STATE, int, int, MX_fmtsel);
+uint64_t mdmx_round_op (SIM_STATE, int, int, MX_fmtsel);
#define MX_RNAS(vt,fmt) mdmx_round_op(SIM_ARGS, MX_RND_AS, vt, fmt)
#define MX_RNAU(vt,fmt) mdmx_round_op(SIM_ARGS, MX_RND_AU, vt, fmt)
#define MX_RNES(vt,fmt) mdmx_round_op(SIM_ARGS, MX_RND_ES, vt, fmt)
#define MX_RZS(vt,fmt) mdmx_round_op(SIM_ARGS, MX_RND_ZS, vt, fmt)
#define MX_RZU(vt,fmt) mdmx_round_op(SIM_ARGS, MX_RND_ZU, vt, fmt)
-unsigned64 mdmx_shuffle (SIM_STATE, int, unsigned64, unsigned64);
+uint64_t mdmx_shuffle (SIM_STATE, int, uint64_t, uint64_t);
#define MX_SHFL(shop,op1,op2) mdmx_shuffle(SIM_ARGS, shop, op1, op2)
#define Unpredictable() unpredictable (SD_)
#define UnpredictableResult() /* For now, do nothing. */
-INLINE_SIM_MAIN (unsigned32) ifetch32 (SIM_DESC sd, sim_cpu *cpu, address_word cia, address_word vaddr);
+INLINE_SIM_MAIN (uint32_t) ifetch32 (SIM_DESC sd, sim_cpu *cpu, address_word cia, address_word vaddr);
#define IMEM32(CIA) ifetch32 (SD, CPU, (CIA), (CIA))
-INLINE_SIM_MAIN (unsigned16) ifetch16 (SIM_DESC sd, sim_cpu *cpu, address_word cia, address_word vaddr);
+INLINE_SIM_MAIN (uint16_t) ifetch16 (SIM_DESC sd, sim_cpu *cpu, address_word cia, address_word vaddr);
#define IMEM16(CIA) ifetch16 (SD, CPU, (CIA), ((CIA) & ~1))
#define IMEM16_IMMED(CIA,NR) ifetch16 (SD, CPU, (CIA), ((CIA) & ~1) + 2 * (NR))
#define IMEM32_MICROMIPS(CIA) \
"maddp r<RS>, r<RT>"
*smartmips:
{
- unsigned64 res;
- unsigned64 rs, rt;
+ uint64_t res;
+ uint64_t rs, rt;
int i;
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
"multp r<RS>, r<RT>"
*smartmips:
{
- unsigned64 res;
- unsigned64 rs, rt;
+ uint64_t res;
+ uint64_t rs, rt;
int i;
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
"madd r<RD>, r<RS>, r<RT>"
*r3900
{
- signed64 prod = (U8_4 (VL4_8 (HI), VL4_8 (LO))
- + ((signed64) EXTEND32 (GPR[RT])
- * (signed64) EXTEND32 (GPR[RS])));
+ int64_t prod = (U8_4 (VL4_8 (HI), VL4_8 (LO))
+ + ((int64_t) EXTEND32 (GPR[RT])
+ * (int64_t) EXTEND32 (GPR[RS])));
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
LO = EXTEND32 (prod);
"maddu r<RD>, r<RS>, r<RT>"
*r3900
{
- unsigned64 prod = (U8_4 (VL4_8 (HI), VL4_8 (LO))
- + ((unsigned64) VL4_8 (GPR[RS])
- * (unsigned64) VL4_8 (GPR[RT])));
+ uint64_t prod = (U8_4 (VL4_8 (HI), VL4_8 (LO))
+ + ((uint64_t) VL4_8 (GPR[RS])
+ * (uint64_t) VL4_8 (GPR[RT])));
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
LO = EXTEND32 (prod);
// concatenation of the low 32 bits of HI and LO.
:function:::void:do_vr_mul_op:int rd, int rs, int rt, int accumulate_p, int store_hi_p, int unsigned_p, int saturate_p, int subtract_p, int short_p, int double_p
{
- unsigned64 lhs, x, y, xcut, ycut, product, result;
+ uint64_t lhs, x, y, xcut, ycut, product, result;
check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
/* Saturate the result to 32 bits. An unsigned, unsaturated
result is zero-extended to 64 bits, but unsigned overflow
causes all 64 bits to be set. */
- if (!unsigned_p && (unsigned64) EXTEND32 (result) != result)
- result = ((signed64) result < 0 ? -0x7fffffff - 1 : 0x7fffffff);
+ if (!unsigned_p && (uint64_t) EXTEND32 (result) != result)
+ result = ((int64_t) result < 0 ? -0x7fffffff - 1 : 0x7fffffff);
else if (unsigned_p && (result >> 32) != 0)
- result = (unsigned64) 0 - 1;
+ result = (uint64_t) 0 - 1;
}
TRACE_ALU_RESULT (result);
projects / thirdparty / binutils-gdb.git / commitdiff
