/* This file is part of SIS (SPARC instruction simulator)
Copyright (C) 1995-2017 Free Software Foundation, Inc.
Contributed by Jiri Gaisler, European Space Agency
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "config.h"
#include "sis.h"
#include <inttypes.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
int ext_irl[NCPU];
#define SIGN_BIT 0x80000000
/* Add two unsigned 32-bit integers, and calculate the carry out. */
static uint32
add32 (uint32 n1, uint32 n2, int *carry)
{
uint32 result = n1 + n2;
*carry = result < n1 || result < n2;
return result;
}
/* Multiply two 32-bit integers. */
void
mul64 (uint32 n1, uint32 n2, uint32 *result_hi, uint32 *result_lo, int msigned)
{
uint32 lo, mid1, mid2, hi, reg_lo, reg_hi;
int carry;
int sign = 0;
/* If this is a signed multiply, calculate the sign of the result
and make the operands positive. */
if (msigned)
{
sign = (n1 ^ n2) & SIGN_BIT;
if (n1 & SIGN_BIT)
n1 = -n1;
if (n2 & SIGN_BIT)
n2 = -n2;
}
/* We can split the 32x32 into four 16x16 operations. This ensures
that we do not lose precision on 32bit only hosts: */
lo = ((n1 & 0xFFFF) * (n2 & 0xFFFF));
mid1 = ((n1 & 0xFFFF) * ((n2 >> 16) & 0xFFFF));
mid2 = (((n1 >> 16) & 0xFFFF) * (n2 & 0xFFFF));
hi = (((n1 >> 16) & 0xFFFF) * ((n2 >> 16) & 0xFFFF));
/* We now need to add all of these results together, taking care
to propogate the carries from the additions: */
reg_lo = add32 (lo, (mid1 << 16), &carry);
reg_hi = carry;
reg_lo = add32 (reg_lo, (mid2 << 16), &carry);
reg_hi += (carry + ((mid1 >> 16) & 0xFFFF) + ((mid2 >> 16) & 0xFFFF) + hi);
/* Negate result if necessary. */
if (sign)
{
reg_hi = ~ reg_hi;
reg_lo = - reg_lo;
if (reg_lo == 0)
reg_hi++;
}
*result_lo = reg_lo;
*result_hi = reg_hi;
}
/* Divide a 64-bit integer by a 32-bit integer. We cheat and assume
that the host compiler supports long long operations. */
void
div64 (uint32 n1_hi, uint32 n1_low, uint32 n2, uint32 *result, int msigned)
{
uint64 n1;
n1 = ((uint64) n1_hi) << 32;
n1 |= ((uint64) n1_low) & 0xffffffff;
if (msigned)
{
int64 n1_s = (int64) n1;
int32 n2_s = (int32) n2;
n1_s = n1_s / n2_s;
n1 = (uint64) n1_s;
}
else
n1 = n1 / n2;
*result = (uint32) (n1 & 0xffffffff);
}
void
init_regs(sregs)
struct pstate *sregs;
{
int i;
ebase.wphit = 0;
for (i=0; i<NCPU; i++) {
sregs[i].pc = 0;
sregs[i].npc = 4;
sregs[i].trap = 0;
sregs[i].psr &= 0x00f03fdf;
if (cputype == CPU_LEON3)
sregs[i].psr |= 0xF3000080; /* Set supervisor bit */
else
if (cputype == CPU_LEON2)
sregs[i].psr |= 0x00000080; /* Set supervisor bit */
else
sregs[i].psr |= 0x11000080; /* Set supervisor bit */
sregs[i].breakpoint = 0;
sregs[i].fpstate = 0;
sregs[i].fpqn = 0;
sregs[i].ftime = 0;
sregs[i].ltime = 0;
sregs[i].err_mode = 0;
ext_irl[i] = 0;
sregs[i].g[0] = 0;
sregs[i].fs = (float32 *) sregs[i].fd;
sregs[i].fsi = (int32 *) sregs[i].fd;
sregs[i].fsr = 0;
sregs[i].fpu_pres = !nfp;
set_fsr(sregs[i].fsr);
sregs[i].ildreg = 0;
sregs[i].ildtime = 0;
sregs[i].y = 0;
sregs[i].asr17 = 0;
sregs[i].rett_err = 0;
sregs[i].jmpltime = 0;
if (cputype == CPU_LEON3) {
sregs[i].asr17 = 0x04000107 | (i << 28);
if (!nfp) sregs[i].asr17 |= (3 << 10); /* Meiko FPU */
}
sregs[i].cpu = i;
sregs[i].simtime = 0;
sregs[i].pwdtime = 0;
sregs[i].pwdstart = 0;
if (i == 0)
sregs[i].pwd_mode = 0;
else
sregs[i].pwd_mode = 1;
sregs[i].mip = 0;
sregs[i].mstatus = 0;
sregs[i].mie = 0;
sregs[i].mpp = 0;
sregs[i].mode = 1;
sregs[i].lrq = 0;
sregs[i].bphit = 0;
}
}
#ifdef ENABLE_L1CACHE
void
l1data_snoop(uint32 address, uint32 cpu)
{
int i;
for (i=0; i<ncpu; i++) {
if (sregs[i].l1dtags[(address >> L1DLINEBITS) & L1DMASK] == (address >> L1DLINEBITS)) {
if (cpu != i) {
sregs[i].l1dtags[(address >> L1DLINEBITS) & L1DMASK] = 0;
// printf("l1 snoop hit : 0x%08X, %d %d\n", address, cpu, i);
}
}
}
}
void
l1data_update(uint32 address, uint32 cpu)
{
if (sregs[cpu].l1dtags[address >> L1DLINEBITS & L1DMASK] != (address >> L1DLINEBITS))
{
sregs[cpu].l1dtags[(address >> L1DLINEBITS) & L1DMASK] = (address >> L1DLINEBITS);
sregs[cpu].hold += T_L1DMISS;
sregs[cpu].l1dmiss++;
}
}
#endif
