URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [stable_0_2_0_rc2/] [or1ksim/] [cpu/] [common/] [abstract.c] - Blame information for rev 1557

Go to most recent revision | Details | Compare with Previous | View Log


/* abstract.c -- Abstract entities
   Copyright (C) 1999 Damjan Lampret, lampret@opencores.org
   Copyright (C) 2005 Gy�rgy `nog' Jeney, nog@sdf.lonestar.org
 
This file is part of OpenRISC 1000 Architectural Simulator.
 
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 2 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, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
/* Abstract memory and routines that go with this. I need to
add all sorts of other abstract entities. Currently we have
only memory. */
 
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
 
#include "config.h"
 
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
 
#include "port.h"
 
#include "arch.h"
#include "parse.h"
#include "abstract.h"
#include "sim-config.h"
#include "labels.h"
#include "except.h"
#include "debug_unit.h"
#include "opcode/or32.h"
#include "spr_defs.h"
#include "execute.h"
#include "sprs.h"
#include "support/profile.h"
#include "dmmu.h"
#include "immu.h"
#include "dcache_model.h"
#include "icache_model.h"
#include "debug.h"
#include "stats.h"
 
#if DYNAMIC_EXECUTION
#include "dyn_rec.h"
#endif
 
extern char *disassembled;
 
/* Pointer to memory area descriptions that are assigned to individual
   peripheral devices. */
struct dev_memarea *dev_list;
 
/* Temporary variable to increase speed.  */
struct dev_memarea *cur_area;
 
/* Pointer to memory controller device descriptor.  */
struct dev_memarea *mc_area = NULL;
 
/* These are set by mmu if cache inhibit bit is set for current acces.  */
int data_ci, insn_ci;
 
/* Virtual address of current access. */
static oraddr_t cur_vadd;
 
/* Read functions */
uint32_t eval_mem_32_inv(oraddr_t, void *);
uint16_t eval_mem_16_inv(oraddr_t, void *);
uint8_t eval_mem_8_inv(oraddr_t, void *);
uint32_t eval_mem_32_inv_direct(oraddr_t, void *);
uint16_t eval_mem_16_inv_direct(oraddr_t, void *);
uint8_t eval_mem_8_inv_direct(oraddr_t, void *);
 
/* Write functions */
void set_mem_32_inv(oraddr_t, uint32_t, void *);
void set_mem_16_inv(oraddr_t, uint16_t, void *);
void set_mem_8_inv(oraddr_t, uint8_t, void *);
void set_mem_32_inv_direct(oraddr_t, uint32_t, void *);
void set_mem_16_inv_direct(oraddr_t, uint16_t, void *);
void set_mem_8_inv_direct(oraddr_t, uint8_t, void *);
 
/* Calculates bit mask to fit the data */
static unsigned int bit_mask (uint32_t data) {
  int i = 0;
  data--;
  while (data >> i)
    data |= 1 << i++;
  return data;
}
 
/* Register read and write function for a memory area.
   addr is inside the area, if addr & addr_mask == addr_compare
   (used also by peripheral devices like 16450 UART etc.) */
struct dev_memarea *register_memoryarea_mask(oraddr_t addr_mask,
                                             oraddr_t addr_compare,
                                             uint32_t size, unsigned mc_dev)
{
  struct dev_memarea **pptmp;
  unsigned int size_mask = bit_mask (size);
  int found_error = 0;
  addr_compare &= addr_mask;
 
  debug(5, "addr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR", size %08"PRIx32"\n",
        addr_mask, addr_compare, addr_compare | bit_mask (size), size);
  /* Go to the end of the list. */
  for(pptmp = &dev_list; *pptmp; pptmp = &(*pptmp)->next)
    if (((addr_compare >= (*pptmp)->addr_compare) &&
         (addr_compare < (*pptmp)->addr_compare + (*pptmp)->size)) ||
        ((addr_compare + size > (*pptmp)->addr_compare) &&
         (addr_compare < (*pptmp)->addr_compare + (*pptmp)->size))) {
      if (!found_error) {
        fprintf (stderr, "ERROR: Overlapping memory area(s):\n");
        fprintf (stderr, "\taddr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR
                         ", size %08"PRIx32"\n",
                 addr_mask, addr_compare, addr_compare | bit_mask (size), size);
      }
      found_error = 1;
      fprintf (stderr, "and\taddr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR
                       ", size %08"PRIx32"\n",
               (*pptmp)->addr_mask, (*pptmp)->addr_compare,
               (*pptmp)->addr_compare | (*pptmp)->size_mask, (*pptmp)->size);
    }
 
  if (found_error)
    exit (-1);
 
  cur_area = *pptmp = (struct dev_memarea *)malloc(sizeof(struct dev_memarea));
 
  if (mc_dev)
    mc_area = *pptmp;
 
  (*pptmp)->addr_mask = addr_mask;
  (*pptmp)->addr_compare = addr_compare;
  (*pptmp)->size = size;
  (*pptmp)->size_mask = size_mask;
  (*pptmp)->log = NULL;
  (*pptmp)->valid = 1;
  (*pptmp)->next = NULL;
 
  return *pptmp;
}
 
/* Register read and write function for a memory area.
   Memory areas should be aligned. Memory area is rounded up to
   fit the nearest 2^n aligment.
   (used also by peripheral devices like 16450 UART etc.)
   If mc_dev is 1, this device will be checked first for a match
   and will be accessed in case of overlaping memory areas.
   Only one device can have this set to 1 (used for memory controller) */
struct dev_memarea *reg_mem_area(oraddr_t addr, uint32_t size, unsigned mc_dev,
                                 struct mem_ops *ops)
{
  unsigned int size_mask = bit_mask (size);
  unsigned int addr_mask = ~size_mask;
  struct dev_memarea *mem;
 
  mem = register_memoryarea_mask(addr_mask, addr & addr_mask, size_mask + 1,
                                 mc_dev);
 
  memcpy(&mem->ops, ops, sizeof(struct mem_ops));
  memcpy(&mem->direct_ops, ops, sizeof(struct mem_ops));
 
  if(!ops->readfunc32) {
    mem->ops.readfunc32 = eval_mem_32_inv;
    mem->direct_ops.readfunc32 = eval_mem_32_inv_direct;
    mem->direct_ops.read_dat32 = mem;
  }
  if(!ops->readfunc16) {
    mem->ops.readfunc16 = eval_mem_16_inv;
    mem->direct_ops.readfunc16 = eval_mem_16_inv_direct;
    mem->direct_ops.read_dat16 = mem;
  }
  if(!ops->readfunc8) {
    mem->ops.readfunc8 = eval_mem_8_inv;
    mem->direct_ops.readfunc8 = eval_mem_8_inv_direct;
    mem->direct_ops.read_dat8 = mem;
  }
 
  if(!ops->writefunc32) {
    mem->ops.writefunc32 = set_mem_32_inv;
    mem->direct_ops.writefunc32 = set_mem_32_inv_direct;
    mem->direct_ops.write_dat32 = mem;
  }
  if(!ops->writefunc16) {
    mem->ops.writefunc16 = set_mem_16_inv;
    mem->direct_ops.writefunc16 = set_mem_16_inv_direct;
    mem->direct_ops.write_dat16 = mem;
  }
  if(!ops->writefunc8) {
    mem->ops.writefunc8 = set_mem_8_inv;
    mem->direct_ops.writefunc8 = set_mem_8_inv_direct;
    mem->direct_ops.write_dat8 = mem;
  }
 
  if(!ops->writeprog8) {
    mem->ops.writeprog8 = mem->ops.writefunc8;
    mem->ops.writeprog8_dat = mem->ops.write_dat8;
  }
 
  if(!ops->writeprog32) {
    mem->ops.writeprog32 = mem->ops.writefunc32;
    mem->ops.writeprog32_dat = mem->ops.write_dat32;
  }
 
  if(ops->log) {
    if(!(mem->log = fopen(ops->log, "w")))
      PRINTF("ERR: Unable to open %s to log memory acesses to\n", ops->log);
  }
 
  return mem;
}
 
/* Check if access is to registered area of memory. */
inline struct dev_memarea *verify_memoryarea(oraddr_t addr)
{
  struct dev_memarea *ptmp;
 
  /* Check memory controller space first */
  if (mc_area && (addr & mc_area->addr_mask) == (mc_area->addr_compare & mc_area->addr_mask))
    return cur_area = mc_area;
 
  /* Check cached value */
  if (cur_area && (addr & cur_area->addr_mask) == (cur_area->addr_compare & cur_area->addr_mask))
    return cur_area;
 
  /* When mc is enabled, we must check valid also, otherwise we assume it is nonzero */
  /* Check list of registered devices. */
  for(ptmp = dev_list; ptmp; ptmp = ptmp->next)
    if ((addr & ptmp->addr_mask) == (ptmp->addr_compare & ptmp->addr_mask) && ptmp->valid)
      return cur_area = ptmp;
  return cur_area = NULL;
}
 
/* Sets the valid bit (Used only by memory controllers) */
void set_mem_valid(struct dev_memarea *mem, int valid)
{
  mem->valid = valid;
}
 
/* Adjusts the read and write delays for the memory area pointed to by mem. */
void adjust_rw_delay(struct dev_memarea *mem, int delayr, int delayw)
{
  mem->ops.delayr = delayr;
  mem->ops.delayw = delayw;
}
 
uint8_t eval_mem_8_inv(oraddr_t memaddr, void *dat)
{
  except_handle(EXCEPT_BUSERR, cur_vadd);
  return 0;
}
 
uint16_t eval_mem_16_inv(oraddr_t memaddr, void *dat)
{
  except_handle(EXCEPT_BUSERR, cur_vadd);
  return 0;
}
 
uint32_t eval_mem_32_inv(oraddr_t memaddr, void *dat)
{
  except_handle(EXCEPT_BUSERR, cur_vadd);
  return 0;
}
 
void set_mem_8_inv(oraddr_t memaddr, uint8_t val, void *dat)
{
  except_handle(EXCEPT_BUSERR, cur_vadd);
}
 
void set_mem_16_inv(oraddr_t memaddr, uint16_t val, void *dat)
{
  except_handle(EXCEPT_BUSERR, cur_vadd);
}
 
void set_mem_32_inv(oraddr_t memaddr, uint32_t val, void *dat)
{
  except_handle(EXCEPT_BUSERR, cur_vadd);
}
 
uint8_t eval_mem_8_inv_direct(oraddr_t memaddr, void *dat)
{
  struct dev_memarea *mem = dat;
 
  PRINTF("ERROR: Invalid 8-bit direct read from memory %"PRIxADDR"\n",
         mem->addr_compare | memaddr);
  return 0;
}
 
uint16_t eval_mem_16_inv_direct(oraddr_t memaddr, void *dat)
{
  struct dev_memarea *mem = dat;
 
  PRINTF("ERROR: Invalid 16-bit direct read from memory %"PRIxADDR"\n",
         mem->addr_compare | memaddr);
  return 0;
}
 
uint32_t eval_mem_32_inv_direct(oraddr_t memaddr, void *dat)
{
  struct dev_memarea *mem = dat;
 
  PRINTF("ERROR: Invalid 32-bit direct read from memory %"PRIxADDR"\n",
         mem->addr_compare | memaddr);
  return 0;
}
 
void set_mem_8_inv_direct(oraddr_t memaddr, uint8_t val, void *dat)
{
  struct dev_memarea *mem = dat;
 
  PRINTF("ERROR: Invalid 32-bit direct write to memory %"PRIxADDR"\n",
         mem->addr_compare | memaddr);
}
 
void set_mem_16_inv_direct(oraddr_t memaddr, uint16_t val, void *dat)
{
  struct dev_memarea *mem = dat;
 
  PRINTF("ERROR: Invalid 16-bit direct write to memory %"PRIxADDR"\n",
         mem->addr_compare | memaddr);
}
 
void set_mem_32_inv_direct(oraddr_t memaddr, uint32_t val, void *dat)
{
  struct dev_memarea *mem = dat;
 
  PRINTF("ERROR: Invalid 32-bit direct write to memory %"PRIxADDR"\n",
         mem->addr_compare | memaddr);
}
 
/* For cpu accesses
 *
 * NOTE: This function _is_ only called from eval_mem32 below and
 * {i,d}c_simulate_read.  _Don't_ call it from anywere else.
 */
inline uint32_t evalsim_mem32(oraddr_t memaddr, oraddr_t vaddr)
{
  struct dev_memarea *mem;
 
  if((mem = verify_memoryarea(memaddr))) {
    runtime.sim.mem_cycles += mem->ops.delayr;
    return mem->ops.readfunc32(memaddr & mem->size_mask, mem->ops.read_dat32);
  } else {
    PRINTF("EXCEPTION: read out of memory (32-bit access to %"PRIxADDR")\n",
           memaddr);
    except_handle(EXCEPT_BUSERR, vaddr);
  }
 
  return 0;
}
 
/* For cpu accesses
 *
 * NOTE: This function _is_ only called from eval_mem16 below and
 * {i,d}c_simulate_read.  _Don't_ call it from anywere else.
 */
inline uint16_t evalsim_mem16(oraddr_t memaddr, oraddr_t vaddr)
{
  struct dev_memarea *mem;
 
  if((mem = verify_memoryarea(memaddr))) {
    runtime.sim.mem_cycles += mem->ops.delayr;
    return mem->ops.readfunc16(memaddr & mem->size_mask, mem->ops.read_dat16);
  } else {
    PRINTF("EXCEPTION: read out of memory (16-bit access to %"PRIxADDR")\n",
           memaddr);
    except_handle(EXCEPT_BUSERR, vaddr);
  }
 
  return 0;
}
 
/* For cpu accesses
 *
 * NOTE: This function _is_ only called from eval_mem8 below and
 * {i,d}c_simulate_read.  _Don't_ call it from anywere else.
 */
inline uint8_t evalsim_mem8(oraddr_t memaddr, oraddr_t vaddr)
{
  struct dev_memarea *mem;
 
  if((mem = verify_memoryarea(memaddr))) {
    runtime.sim.mem_cycles += mem->ops.delayr;
    return mem->ops.readfunc8(memaddr & mem->size_mask, mem->ops.read_dat8);
  } else {
    PRINTF("EXCEPTION: read out of memory (8-bit access to %"PRIxADDR")\n",
           memaddr);
    except_handle(EXCEPT_BUSERR, vaddr);
  }
 
  return 0;
}
 
/* Returns 32-bit values from mem array. Big endian version.
 *
 * STATISTICS OK (only used for cpu_access, that is architectural access)
 */
uint32_t eval_mem32(oraddr_t memaddr,int* breakpoint)
{
  uint32_t temp;
  oraddr_t phys_memaddr;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_32 | MPROF_READ);
 
  if (memaddr & 3) {
    except_handle (EXCEPT_ALIGN, memaddr);
    return 0;
  }
 
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
 
  phys_memaddr = dmmu_translate(memaddr, 0);
  if (except_pending)
    return 0;
 
  if (config.dc.enabled)
    temp = dc_simulate_read(phys_memaddr, memaddr, 4);
  else
    temp = evalsim_mem32(phys_memaddr, memaddr);
 
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
 
  return temp;
}
 
/* for simulator accesses, the ones that cpu wouldn't do
 *
 * STATISTICS OK
 */
uint32_t eval_direct32(oraddr_t memaddr, int through_mmu, int through_dc)
{
  oraddr_t phys_memaddr;
  struct dev_memarea *mem;
 
  if (memaddr & 3) {
    PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
    return 0;
  }
 
  phys_memaddr = memaddr;
 
  if (through_mmu)
    phys_memaddr = peek_into_dtlb(memaddr, 0, through_dc);
 
  if (through_dc)
    return dc_simulate_read(phys_memaddr, memaddr, 4);
  else {
    if((mem = verify_memoryarea(phys_memaddr)))
      return mem->direct_ops.readfunc32(phys_memaddr & mem->size_mask,
                                        mem->direct_ops.read_dat32);
    else
      PRINTF("ERR: 32-bit read out of memory area: %"PRIxADDR" (physical: %"
             PRIxADDR"\n", memaddr, phys_memaddr);
  }
 
  return 0;
}
 
 
/* Returns 32-bit values from mem array. Big endian version.
 *
 * STATISTICS OK (only used for cpu_access, that is architectural access)
 */
uint32_t eval_insn(oraddr_t memaddr, int* breakpoint)
{
  uint32_t temp;
  oraddr_t phys_memaddr;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_32 | MPROF_FETCH);
//  memaddr = simulate_ic_mmu_fetch(memaddr);
 
  phys_memaddr = memaddr;
#if !(DYNAMIC_EXECUTION)
  phys_memaddr = immu_translate(memaddr);
 
  if (except_pending)
    return 0;
#endif
 
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr);
 
  if (config.ic.enabled)
    temp = ic_simulate_fetch(phys_memaddr, memaddr);
  else
    temp = evalsim_mem32(phys_memaddr, memaddr);
 
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);
  return temp;
}
 
/* Returns 32-bit values from mem array. Big endian version.
 *
 * STATISTICS OK
 */
uint32_t eval_insn_direct(oraddr_t memaddr, int through_mmu)
{
  if(through_mmu)
    memaddr = peek_into_itlb(memaddr);
 
  return eval_direct32(memaddr, 0, 0);
}
 
 
/* Returns 16-bit values from mem array. Big endian version.
 *
 * STATISTICS OK (only used for cpu_access, that is architectural access)
 */
uint16_t eval_mem16(oraddr_t memaddr,int* breakpoint)
{
  uint16_t temp;
  oraddr_t phys_memaddr;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_16 | MPROF_READ);
 
  if (memaddr & 1) {
    except_handle (EXCEPT_ALIGN, memaddr);
    return 0;
  }
 
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
 
  phys_memaddr = dmmu_translate(memaddr, 0);
  if (except_pending)
    return 0;
 
  if (config.dc.enabled)
    temp = dc_simulate_read(phys_memaddr, memaddr, 2);
  else
    temp = evalsim_mem16(phys_memaddr, memaddr);
 
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
 
  return temp;
}
 
/* for simulator accesses, the ones that cpu wouldn't do
 *
 * STATISTICS OK.
 */
uint16_t eval_direct16(oraddr_t memaddr, int through_mmu, int through_dc)
{
  oraddr_t phys_memaddr;
  struct dev_memarea *mem;
 
  if (memaddr & 1) {
    PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
    return 0;
  }
 
  phys_memaddr = memaddr;
 
  if (through_mmu)
    phys_memaddr = peek_into_dtlb(memaddr, 0, through_dc);
 
  if (through_dc)
    return dc_simulate_read(phys_memaddr, memaddr, 2);
  else {
    if((mem = verify_memoryarea(phys_memaddr)))
      return mem->direct_ops.readfunc16(phys_memaddr & mem->size_mask,
                                        mem->direct_ops.read_dat16);
    else
      PRINTF("ERR: 16-bit read out of memory area: %"PRIxADDR" (physical: %"
             PRIxADDR"\n", memaddr, phys_memaddr);
  }
 
  return 0;
}
 
/* Returns 8-bit values from mem array.
 *
 * STATISTICS OK (only used for cpu_access, that is architectural access)
 */
uint8_t eval_mem8(oraddr_t memaddr,int* breakpoint)
{
  uint8_t temp;
  oraddr_t phys_memaddr;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_8 | MPROF_READ);
 
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr);  /* 28/05/01 CZ */
 
  phys_memaddr = dmmu_translate(memaddr, 0);
  if (except_pending)
    return 0;
 
  if (config.dc.enabled)
    temp = dc_simulate_read(phys_memaddr, memaddr, 1);
  else
    temp = evalsim_mem8(phys_memaddr, memaddr);
 
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
/* for simulator accesses, the ones that cpu wouldn't do
 *
 * STATISTICS OK.
 */
uint8_t eval_direct8(oraddr_t memaddr, int through_mmu, int through_dc)
{
  oraddr_t phys_memaddr;
  struct dev_memarea *mem;
 
  phys_memaddr = memaddr;
 
  if (through_mmu)
    phys_memaddr = peek_into_dtlb(memaddr, 0, through_dc);
 
  if (through_dc)
    return dc_simulate_read(phys_memaddr, memaddr, 1);
  else {
    if((mem = verify_memoryarea(phys_memaddr)))
      return mem->direct_ops.readfunc8(phys_memaddr & mem->size_mask,
                                       mem->direct_ops.read_dat8);
    else
      PRINTF("ERR: 8-bit read out of memory area: %"PRIxADDR" (physical: %"
             PRIxADDR"\n", memaddr, phys_memaddr);
  }
 
  return 0;
}
 
/* For cpu accesses
 *
 * NOTE: This function _is_ only called from set_mem32 below and
 * dc_simulate_write.  _Don't_ call it from anywere else.
 */
inline void setsim_mem32(oraddr_t memaddr, oraddr_t vaddr, uint32_t value)
{
  struct dev_memarea *mem;
 
  if((mem = verify_memoryarea(memaddr))) {
    cur_vadd = vaddr;
    runtime.sim.mem_cycles += mem->ops.delayw;
    mem->ops.writefunc32(memaddr & mem->size_mask, value, mem->ops.write_dat32);
#if DYNAMIC_EXECUTION
    dyn_checkwrite(memaddr);
#endif
  } else {
    PRINTF("EXCEPTION: write out of memory (32-bit access to %"PRIxADDR")\n",
           memaddr);
    except_handle(EXCEPT_BUSERR, vaddr);
  }
}
 
/* For cpu accesses
 *
 * NOTE: This function _is_ only called from set_mem16 below and
 * dc_simulate_write.  _Don't_ call it from anywere else.
 */
inline void setsim_mem16(oraddr_t memaddr, oraddr_t vaddr, uint16_t value)
{
  struct dev_memarea *mem;
 
  if((mem = verify_memoryarea(memaddr))) {
    cur_vadd = vaddr;
    runtime.sim.mem_cycles += mem->ops.delayw;
    mem->ops.writefunc16(memaddr & mem->size_mask, value, mem->ops.write_dat16);
#if DYNAMIC_EXECUTION
    dyn_checkwrite(memaddr);
#endif
  } else {
    PRINTF("EXCEPTION: write out of memory (16-bit access to %"PRIxADDR")\n",
           memaddr);
    except_handle(EXCEPT_BUSERR, vaddr);
  }
}
 
/* For cpu accesses
 *
 * NOTE: This function _is_ only called from set_mem8 below and
 * dc_simulate_write.  _Don't_ call it from anywere else.
 */
inline void setsim_mem8(oraddr_t memaddr, oraddr_t vaddr, uint8_t value)
{
  struct dev_memarea *mem;
 
  if((mem = verify_memoryarea(memaddr))) {
    cur_vadd = vaddr;
    runtime.sim.mem_cycles += mem->ops.delayw;
    mem->ops.writefunc8(memaddr & mem->size_mask, value, mem->ops.write_dat8);
#if DYNAMIC_EXECUTION
    dyn_checkwrite(memaddr);
#endif
  } else {
    PRINTF("EXCEPTION: write out of memory (8-bit access to %"PRIxADDR")\n",
           memaddr);
    except_handle(EXCEPT_BUSERR, vaddr);
  }
}
 
/* Set mem, 32-bit. Big endian version.
 *
 * STATISTICS OK. (the only suspicious usage is in sim-cmd.c,
 *                 where this instruction is used for patching memory,
 *                 wether this is cpu or architectual access is yet to
 *                 be decided)
 */
void set_mem32(oraddr_t memaddr, uint32_t value, int* breakpoint)
{
  oraddr_t phys_memaddr;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_32 | MPROF_WRITE);
 
  if (memaddr & 3) {
    except_handle (EXCEPT_ALIGN, memaddr);
    return;
  }
 
  phys_memaddr = dmmu_translate(memaddr, 1);;
  /* If we produced exception don't set anything */
  if (except_pending)
    return;
 
  if (config.debug.enabled) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  if(config.dc.enabled)
    dc_simulate_write(phys_memaddr, memaddr, value, 4);
  else
    setsim_mem32(phys_memaddr, memaddr, value);
 
  if (cur_area && cur_area->log)
    fprintf (cur_area->log, "[%"PRIxADDR"] -> write %08"PRIx32"\n", memaddr,
             value);
}
 
/*
 * STATISTICS NOT OK.
 */
void set_direct32(oraddr_t memaddr, uint32_t value, int through_mmu,
                  int through_dc)
{
  oraddr_t phys_memaddr;
  struct dev_memarea *mem;
 
  if (memaddr & 3) {
    PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
    return;
  }
 
  phys_memaddr = memaddr;
 
  if (through_mmu) {
    /* 0 - no write access, we do not want a DPF exception do we ;)
     */
    phys_memaddr = peek_into_dtlb(memaddr, 1, through_dc);
  }
 
  if(through_dc)
    dc_simulate_write(memaddr, memaddr, value, 4);
  else {
    if((mem = verify_memoryarea(phys_memaddr)))
      mem->direct_ops.writefunc32(phys_memaddr & mem->size_mask, value,
                                  mem->direct_ops.write_dat32);
    else
      PRINTF("ERR: 32-bit write out of memory area: %"PRIxADDR" (physical: %"
             PRIxADDR")\n", memaddr, phys_memaddr);
  }
 
  if (cur_area && cur_area->log)
    fprintf (cur_area->log, "[%"PRIxADDR"] -> DIRECT write %08"PRIx32"\n",
             memaddr, value);
}
 
 
/* Set mem, 16-bit. Big endian version. */
 
void set_mem16(oraddr_t memaddr, uint16_t value, int* breakpoint)
{
  oraddr_t phys_memaddr;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_16 | MPROF_WRITE);
 
  if (memaddr & 1) {
    except_handle (EXCEPT_ALIGN, memaddr);
    return;
  }
 
  phys_memaddr = dmmu_translate(memaddr, 1);;
  /* If we produced exception don't set anything */
  if (except_pending)
    return;
 
  if (config.debug.enabled) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  if(config.dc.enabled)
    dc_simulate_write(phys_memaddr, memaddr, value, 2);
  else
    setsim_mem16(phys_memaddr, memaddr, value);
 
  if (cur_area && cur_area->log)
    fprintf (cur_area->log, "[%"PRIxADDR"] -> write %04"PRIx16"\n", memaddr,
             value);
}
 
/*
 * STATISTICS NOT OK.
 */
void set_direct16(oraddr_t memaddr, uint16_t value, int through_mmu,
                  int through_dc)
{
  oraddr_t phys_memaddr;
  struct dev_memarea *mem;
 
  if (memaddr & 1) {
    PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
    return;
  }
 
  phys_memaddr = memaddr;
 
  if (through_mmu) {
    /* 0 - no write access, we do not want a DPF exception do we ;)
     */
    phys_memaddr = peek_into_dtlb(memaddr, 0, through_dc);
  }
 
  if(through_dc)
    dc_simulate_write(memaddr, memaddr, value, 2);
  else {
    if((mem = verify_memoryarea(phys_memaddr)))
      mem->direct_ops.writefunc16(phys_memaddr & mem->size_mask, value,
                                  mem->direct_ops.write_dat16);
    else
      PRINTF("ERR: 16-bit write out of memory area: %"PRIxADDR" (physical: %"
             PRIxADDR"\n", memaddr, phys_memaddr);
  }
 
  if (cur_area && cur_area->log)
    fprintf (cur_area->log, "[%"PRIxADDR"] -> DIRECT write %04"PRIx16"\n",
             memaddr, value);
}
 
/* Set mem, 8-bit. */
void set_mem8(oraddr_t memaddr, uint8_t value, int* breakpoint)
{
  oraddr_t phys_memaddr;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_8 | MPROF_WRITE);
 
  phys_memaddr = memaddr;
 
  phys_memaddr = dmmu_translate(memaddr, 1);;
  /* If we produced exception don't set anything */
  if (except_pending) return;
 
  if (config.debug.enabled) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  if(config.dc.enabled)
    dc_simulate_write(phys_memaddr, memaddr, value, 1);
  else
    setsim_mem8(phys_memaddr, memaddr, value);
 
  if (cur_area && cur_area->log)
    fprintf (cur_area->log, "[%"PRIxADDR"] -> write %02"PRIx8"\n", memaddr,
             value);
}
 
/*
 * STATISTICS NOT OK.
 */
void set_direct8(oraddr_t memaddr, uint8_t value, int through_mmu,
                 int through_dc)
{
  oraddr_t phys_memaddr;
  struct dev_memarea *mem;
 
  phys_memaddr = memaddr;
 
  if (through_mmu) {
    /* 0 - no write access, we do not want a DPF exception do we ;)
     */
    phys_memaddr = peek_into_dtlb(memaddr, 0, through_dc);
  }
 
  if(through_dc)
    dc_simulate_write(phys_memaddr, memaddr, value, 1);
  else {
    if((mem = verify_memoryarea(phys_memaddr)))
      mem->direct_ops.writefunc8(phys_memaddr & mem->size_mask, value,
                                 mem->direct_ops.write_dat8);
    else
      PRINTF("ERR: 8-bit write out of memory area: %"PRIxADDR" (physical: %"
             PRIxADDR"\n", memaddr, phys_memaddr);
  }
 
  if (cur_area && cur_area->log)
    fprintf (cur_area->log, "[%"PRIxADDR"] -> DIRECT write %02"PRIx8"\n",
             memaddr, value);
}
 
 
/* set_program32 - same as set_direct32, but it also writes to memory that is
 *                 non-writeable to the rest of the sim.  Used to do program
 *                 loading.
 */
void set_program32(oraddr_t memaddr, uint32_t value)
{
  struct dev_memarea *mem;
 
  if(memaddr & 3) {
    PRINTF("%s(): ERR unaligned 32-bit program write\n", __FUNCTION__);
    return;
  }
 
  if((mem = verify_memoryarea(memaddr))) {
    mem->ops.writeprog32(memaddr & mem->size_mask, value,
                         mem->ops.writeprog32_dat);
  } else
    PRINTF("ERR: 32-bit program load out of memory area: %"PRIxADDR"\n",
           memaddr);
}
 
/* set_program8 - same as set_direct8, but it also writes to memory that is
 *                non-writeable to the rest of the sim.  Used to do program
 *                loading.
 */
void set_program8(oraddr_t memaddr, uint8_t value)
{
  struct dev_memarea *mem;
 
  if((mem = verify_memoryarea(memaddr))) {
    mem->ops.writeprog8(memaddr & mem->size_mask, value,
                        mem->ops.writeprog8_dat);
  } else
    PRINTF("ERR: 8-bit program load out of memory area: %"PRIxADDR"\n",
           memaddr);
}
 
void dumpmemory(oraddr_t from, oraddr_t to, int disasm, int nl)
{
  oraddr_t i, j;
  struct label_entry *tmp;
  int ilen = disasm ? 4 : 16;
 
  for(i = from; i < to; i += ilen) {
    PRINTF("%"PRIxADDR": ", i);
    for (j = 0; j < ilen;) {
      if (!disasm) {
        tmp = NULL;
        if (verify_memoryarea(i + j)) {
          struct label_entry *entry;
          entry = get_label(i + j);
          if (entry)
            PRINTF("(%s)", entry->name);
          PRINTF("%02"PRIx8" ", eval_direct8(i + j, 0, 0));
        } else PRINTF("XX ");
        j++;
      } else {
        uint32_t _insn = eval_direct32(i, 0, 0);
        int index = insn_decode (_insn);
        int len = insn_len (index);
 
        tmp = NULL;
        if (verify_memoryarea(i + j)) {
          struct label_entry *entry;
          entry = get_label(i + j);
          if (entry)
            PRINTF("(%s)", entry->name);
 
          PRINTF(": %08"PRIx32" ", _insn);
          if (index >= 0) {
            disassemble_insn (_insn);
            PRINTF(" %s", disassembled);
          } else
            PRINTF("<invalid>");
        } else PRINTF("XXXXXXXX");
        j += len;
      }
    }
    if (nl)
      PRINTF ("\n");
  }
}
 
/* Closes files, etc. */
 
void done_memory_table (void)
{
  struct dev_memarea *ptmp;
 
  /* Check list of registered devices. */
  for(ptmp = dev_list; ptmp; ptmp = ptmp->next) {
    if (ptmp->log)
      fclose (ptmp->log);
  }
}
 
/* Displays current memory configuration */
 
void memory_table_status (void)
{
  struct dev_memarea *ptmp;
 
  /* Check list of registered devices. */
  for(ptmp = dev_list; ptmp; ptmp = ptmp->next) {
    PRINTF ("addr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR", size %"PRIx32"\n",
      ptmp->addr_mask, ptmp->addr_compare, ptmp->addr_compare | bit_mask (ptmp->size),
      ptmp->size);
    PRINTF ("\t");
    if (ptmp->ops.delayr >= 0)
      PRINTF ("read delay = %i cycles, ", ptmp->ops.delayr);
    else
      PRINTF ("reads not possible, ");
 
    if (ptmp->ops.delayw >= 0)
      PRINTF ("write delay = %i cycles", ptmp->ops.delayw);
    else
      PRINTF ("writes not possible");
 
    if (ptmp->log)
      PRINTF (", (logged)\n");
    else
      PRINTF ("\n");
  }
}
 
/* Outputs time in pretty form to dest string */
 
char *generate_time_pretty (char *dest, long time_ps)
{
  int exp3 = 0;
  if (time_ps) {
    while ((time_ps % 1000) == 0) {
      time_ps /= 1000;
      exp3++;
    }
  }
  sprintf (dest, "%li%cs", time_ps, "pnum"[exp3]);
  return dest;
}

Line No.	Rev	Author	Line
1	2	cvs	`/* abstract.c -- Abstract entities`
2			`Copyright (C) 1999 Damjan Lampret, lampret@opencores.org`
3	1486	nogj	Copyright (C) 2005 Gy�rgy `nog' Jeney, nog@sdf.lonestar.org
4	2	cvs
5			`This file is part of OpenRISC 1000 Architectural Simulator.`
6
7			`This program is free software; you can redistribute it and/or modify`
8			`it under the terms of the GNU General Public License as published by`
9			`the Free Software Foundation; either version 2 of the License, or`
10			`(at your option) any later version.`
11
12			`This program is distributed in the hope that it will be useful,`
13			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`GNU General Public License for more details.`
16
17			`You should have received a copy of the GNU General Public License`
18			`along with this program; if not, write to the Free Software`
19			`Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */`
20
21	66	lampret	`/* Abstract memory and routines that go with this. I need to`
22	2	cvs	`add all sorts of other abstract entities. Currently we have`
23			`only memory. */`
24
25	221	markom	`#include <stdlib.h>`
26	2	cvs	`#include <stdio.h>`
27			`#include <ctype.h>`
28			`#include <string.h>`
29
30	6	lampret	`#include "config.h"`
31	1350	nogj
32			`#ifdef HAVE_INTTYPES_H`
33			`#include <inttypes.h>`
34			`#endif`
35
36			`#include "port.h"`
37	6	lampret
38	1350	nogj	`#include "arch.h"`
39	2	cvs	`#include "parse.h"`
40			`#include "abstract.h"`
41	1358	nogj	`#include "sim-config.h"`
42	261	markom	`#include "labels.h"`
43	32	lampret	`#include "except.h"`
44	123	markom	`#include "debug_unit.h"`
45	134	markom	`#include "opcode/or32.h"`
46	1432	nogj	`#include "spr_defs.h"`
47			`#include "execute.h"`
48			`#include "sprs.h"`
49	547	markom	`#include "support/profile.h"`
50	1308	phoenix	`#include "dmmu.h"`
51	1446	nogj	`#include "immu.h"`
52	1308	phoenix	`#include "dcache_model.h"`
53			`#include "icache_model.h"`
54			`#include "debug.h"`
55	1344	nogj	`#include "stats.h"`
56	2	cvs
57	1452	nogj	`#if DYNAMIC_EXECUTION`
58			`#include "dyn_rec.h"`
59			`#endif`
60
61	138	markom	`extern char *disassembled;`
62	2	cvs
63	30	lampret	`/* Pointer to memory area descriptions that are assigned to individual`
64			`peripheral devices. */`
65			`struct dev_memarea *dev_list;`
66
67	221	markom	`/* Temporary variable to increase speed. */`
68			`struct dev_memarea *cur_area;`
69
70	970	simons	`/* Pointer to memory controller device descriptor. */`
71	1486	nogj	`struct dev_memarea *mc_area = NULL;`
72	970	simons
73	638	simons	`/* These are set by mmu if cache inhibit bit is set for current acces. */`
74			`int data_ci, insn_ci;`
75
76	525	simons	`/* Virtual address of current access. */`
77	1486	nogj	`static oraddr_t cur_vadd;`
78	525	simons
79	1486	nogj	`/* Read functions */`
80			`uint32_t eval_mem_32_inv(oraddr_t, void *);`
81			`uint16_t eval_mem_16_inv(oraddr_t, void *);`
82			`uint8_t eval_mem_8_inv(oraddr_t, void *);`
83			`uint32_t eval_mem_32_inv_direct(oraddr_t, void *);`
84			`uint16_t eval_mem_16_inv_direct(oraddr_t, void *);`
85			`uint8_t eval_mem_8_inv_direct(oraddr_t, void *);`
86
87			`/* Write functions */`
88			`void set_mem_32_inv(oraddr_t, uint32_t, void *);`
89			`void set_mem_16_inv(oraddr_t, uint16_t, void *);`
90			`void set_mem_8_inv(oraddr_t, uint8_t, void *);`
91			`void set_mem_32_inv_direct(oraddr_t, uint32_t, void *);`
92			`void set_mem_16_inv_direct(oraddr_t, uint16_t, void *);`
93			`void set_mem_8_inv_direct(oraddr_t, uint8_t, void *);`
94
95	261	markom	`/* Calculates bit mask to fit the data */`
96	1486	nogj	`static unsigned int bit_mask (uint32_t data) {`
97	261	markom	`int i = 0;`
98			`data--;`
99	382	markom	`while (data >> i)`
100	261	markom	`data \|= 1 << i++;`
101			`return data;`
102			`}`
103
104			`/* Register read and write function for a memory area.`
105			`addr is inside the area, if addr & addr_mask == addr_compare`
106			`(used also by peripheral devices like 16450 UART etc.) */`
107	1486	nogj	`struct dev_memarea *register_memoryarea_mask(oraddr_t addr_mask,`
108			`oraddr_t addr_compare,`
109			`uint32_t size, unsigned mc_dev)`
110	30	lampret	`{`
111	239	markom	`struct dev_memarea **pptmp;`
112	1350	nogj	`unsigned int size_mask = bit_mask (size);`
113	261	markom	`int found_error = 0;`
114			`addr_compare &= addr_mask;`
115	221	markom
116	1486	nogj	`debug(5, "addr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR", size %08"PRIx32"\n",`
117			`addr_mask, addr_compare, addr_compare \| bit_mask (size), size);`
118	239	markom	`/* Go to the end of the list. */`
119	261	markom	`for(pptmp = &dev_list; pptmp; pptmp = &(pptmp)->next)`
120	1557	nogj	`if (((addr_compare >= (*pptmp)->addr_compare) &&`
121			`(addr_compare < (pptmp)->addr_compare + (pptmp)->size)) \|\|`
122			`((addr_compare + size > (*pptmp)->addr_compare) &&`
123			`(addr_compare < (pptmp)->addr_compare + (pptmp)->size))) {`
124	262	markom	`if (!found_error) {`
125	261	markom	`fprintf (stderr, "ERROR: Overlapping memory area(s):\n");`
126	1350	nogj	`fprintf (stderr, "\taddr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR`
127	1486	nogj	`", size %08"PRIx32"\n",`
128			`addr_mask, addr_compare, addr_compare \| bit_mask (size), size);`
129	262	markom	`}`
130	261	markom	`found_error = 1;`
131	1350	nogj	`fprintf (stderr, "and\taddr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR`
132	1486	nogj	`", size %08"PRIx32"\n",`
133	1308	phoenix	`(pptmp)->addr_mask, (pptmp)->addr_compare,`
134	1486	nogj	`(pptmp)->addr_compare \| (pptmp)->size_mask, (*pptmp)->size);`
135	261	markom	`}`
136
137			`if (found_error)`
138			`exit (-1);`
139	537	markom
140	239	markom	`cur_area = pptmp = (struct dev_memarea )malloc(sizeof(struct dev_memarea));`
141	970	simons
142			`if (mc_dev)`
143			`mc_area = *pptmp;`
144
145	261	markom	`(*pptmp)->addr_mask = addr_mask;`
146			`(*pptmp)->addr_compare = addr_compare;`
147	239	markom	`(*pptmp)->size = size;`
148	261	markom	`(*pptmp)->size_mask = size_mask;`
149	1486	nogj	`(*pptmp)->log = NULL;`
150			`(*pptmp)->valid = 1;`
151	239	markom	`(*pptmp)->next = NULL;`
152	1486	nogj
153			`return *pptmp;`
154	261	markom	`}`
155	221	markom
156	261	markom	`/* Register read and write function for a memory area.`
157			`Memory areas should be aligned. Memory area is rounded up to`
158			`fit the nearest 2^n aligment.`
159	970	simons	`(used also by peripheral devices like 16450 UART etc.)`
160	1486	nogj	`If mc_dev is 1, this device will be checked first for a match`
161			`and will be accessed in case of overlaping memory areas.`
162	970	simons	`Only one device can have this set to 1 (used for memory controller) */`
163	1486	nogj	`struct dev_memarea *reg_mem_area(oraddr_t addr, uint32_t size, unsigned mc_dev,`
164			`struct mem_ops *ops)`
165	261	markom	`{`
166	1350	nogj	`unsigned int size_mask = bit_mask (size);`
167			`unsigned int addr_mask = ~size_mask;`
168	1486	nogj	`struct dev_memarea *mem;`
169
170			`mem = register_memoryarea_mask(addr_mask, addr & addr_mask, size_mask + 1,`
171			`mc_dev);`
172
173			`memcpy(&mem->ops, ops, sizeof(struct mem_ops));`
174			`memcpy(&mem->direct_ops, ops, sizeof(struct mem_ops));`
175
176			`if(!ops->readfunc32) {`
177			`mem->ops.readfunc32 = eval_mem_32_inv;`
178			`mem->direct_ops.readfunc32 = eval_mem_32_inv_direct;`
179			`mem->direct_ops.read_dat32 = mem;`
180			`}`
181			`if(!ops->readfunc16) {`
182			`mem->ops.readfunc16 = eval_mem_16_inv;`
183			`mem->direct_ops.readfunc16 = eval_mem_16_inv_direct;`
184			`mem->direct_ops.read_dat16 = mem;`
185			`}`
186			`if(!ops->readfunc8) {`
187			`mem->ops.readfunc8 = eval_mem_8_inv;`
188			`mem->direct_ops.readfunc8 = eval_mem_8_inv_direct;`
189			`mem->direct_ops.read_dat8 = mem;`
190			`}`
191
192			`if(!ops->writefunc32) {`
193			`mem->ops.writefunc32 = set_mem_32_inv;`
194			`mem->direct_ops.writefunc32 = set_mem_32_inv_direct;`
195			`mem->direct_ops.write_dat32 = mem;`
196			`}`
197			`if(!ops->writefunc16) {`
198			`mem->ops.writefunc16 = set_mem_16_inv;`
199			`mem->direct_ops.writefunc16 = set_mem_16_inv_direct;`
200			`mem->direct_ops.write_dat16 = mem;`
201			`}`
202			`if(!ops->writefunc8) {`
203			`mem->ops.writefunc8 = set_mem_8_inv;`
204			`mem->direct_ops.writefunc8 = set_mem_8_inv_direct;`
205			`mem->direct_ops.write_dat8 = mem;`
206			`}`
207
208	1556	nogj	`if(!ops->writeprog8) {`
209			`mem->ops.writeprog8 = mem->ops.writefunc8;`
210			`mem->ops.writeprog8_dat = mem->ops.write_dat8;`
211	1486	nogj	`}`
212
213	1556	nogj	`if(!ops->writeprog32) {`
214			`mem->ops.writeprog32 = mem->ops.writefunc32;`
215			`mem->ops.writeprog32_dat = mem->ops.write_dat32;`
216			`}`
217
218	1486	nogj	`if(ops->log) {`
219			`if(!(mem->log = fopen(ops->log, "w")))`
220			`PRINTF("ERR: Unable to open %s to log memory acesses to\n", ops->log);`
221			`}`
222
223			`return mem;`
224	30	lampret	`}`
225
226			`/* Check if access is to registered area of memory. */`
227	1350	nogj	`inline struct dev_memarea *verify_memoryarea(oraddr_t addr)`
228	30	lampret	`{`
229	239	markom	`struct dev_memarea *ptmp;`
230	221	markom
231	970	simons	`/* Check memory controller space first */`
232			`if (mc_area && (addr & mc_area->addr_mask) == (mc_area->addr_compare & mc_area->addr_mask))`
233			`return cur_area = mc_area;`
234
235			`/* Check cached value */`
236	560	markom	`if (cur_area && (addr & cur_area->addr_mask) == (cur_area->addr_compare & cur_area->addr_mask))`
237			`return cur_area;`
238
239			`/* When mc is enabled, we must check valid also, otherwise we assume it is nonzero */`
240	1375	nogj	`/* Check list of registered devices. */`
241			`for(ptmp = dev_list; ptmp; ptmp = ptmp->next)`
242			`if ((addr & ptmp->addr_mask) == (ptmp->addr_compare & ptmp->addr_mask) && ptmp->valid)`
243			`return cur_area = ptmp;`
244	239	markom	`return cur_area = NULL;`
245	30	lampret	`}`
246
247	1486	nogj	`/* Sets the valid bit (Used only by memory controllers) */`
248			`void set_mem_valid(struct dev_memarea *mem, int valid)`
249	882	simons	`{`
250	1486	nogj	`mem->valid = valid;`
251	882	simons	`}`
252
253	1486	nogj	`/* Adjusts the read and write delays for the memory area pointed to by mem. */`
254			`void adjust_rw_delay(struct dev_memarea *mem, int delayr, int delayw)`
255	560	markom	`{`
256	1486	nogj	`mem->ops.delayr = delayr;`
257			`mem->ops.delayw = delayw;`
258	1319	phoenix	`}`
259	560	markom
260	1486	nogj	`uint8_t eval_mem_8_inv(oraddr_t memaddr, void *dat)`
261	1319	phoenix	`{`
262	1486	nogj	`except_handle(EXCEPT_BUSERR, cur_vadd);`
263			`return 0;`
264	1319	phoenix	`}`
265
266	1486	nogj	`uint16_t eval_mem_16_inv(oraddr_t memaddr, void *dat)`
267	1319	phoenix	`{`
268	1486	nogj	`except_handle(EXCEPT_BUSERR, cur_vadd);`
269			`return 0;`
270			`}`
271	1319	phoenix
272	1486	nogj	`uint32_t eval_mem_32_inv(oraddr_t memaddr, void *dat)`
273			`{`
274			`except_handle(EXCEPT_BUSERR, cur_vadd);`
275			`return 0;`
276	560	markom	`}`
277
278	1486	nogj	`void set_mem_8_inv(oraddr_t memaddr, uint8_t val, void *dat)`
279	560	markom	`{`
280	1486	nogj	`except_handle(EXCEPT_BUSERR, cur_vadd);`
281	1319	phoenix	`}`
282	560	markom
283	1486	nogj	`void set_mem_16_inv(oraddr_t memaddr, uint16_t val, void *dat)`
284	1319	phoenix	`{`
285	1486	nogj	`except_handle(EXCEPT_BUSERR, cur_vadd);`
286	1319	phoenix	`}`
287
288	1486	nogj	`void set_mem_32_inv(oraddr_t memaddr, uint32_t val, void *dat)`
289	1319	phoenix	`{`
290	1486	nogj	`except_handle(EXCEPT_BUSERR, cur_vadd);`
291			`}`
292	1319	phoenix
293	1486	nogj	`uint8_t eval_mem_8_inv_direct(oraddr_t memaddr, void *dat)`
294			`{`
295			`struct dev_memarea *mem = dat;`
296
297			`PRINTF("ERROR: Invalid 8-bit direct read from memory %"PRIxADDR"\n",`
298			`mem->addr_compare \| memaddr);`
299			`return 0;`
300	560	markom	`}`
301
302	1486	nogj	`uint16_t eval_mem_16_inv_direct(oraddr_t memaddr, void *dat)`
303	560	markom	`{`
304	1486	nogj	`struct dev_memarea *mem = dat;`
305
306			`PRINTF("ERROR: Invalid 16-bit direct read from memory %"PRIxADDR"\n",`
307			`mem->addr_compare \| memaddr);`
308			`return 0;`
309	1319	phoenix	`}`
310	560	markom
311	1486	nogj	`uint32_t eval_mem_32_inv_direct(oraddr_t memaddr, void *dat)`
312	1319	phoenix	`{`
313	1486	nogj	`struct dev_memarea *mem = dat;`
314
315			`PRINTF("ERROR: Invalid 32-bit direct read from memory %"PRIxADDR"\n",`
316			`mem->addr_compare \| memaddr);`
317			`return 0;`
318	1319	phoenix	`}`
319
320	1486	nogj	`void set_mem_8_inv_direct(oraddr_t memaddr, uint8_t val, void *dat)`
321	1319	phoenix	`{`
322	1486	nogj	`struct dev_memarea *mem = dat;`
323	1319	phoenix
324	1486	nogj	`PRINTF("ERROR: Invalid 32-bit direct write to memory %"PRIxADDR"\n",`
325			`mem->addr_compare \| memaddr);`
326			`}`
327
328			`void set_mem_16_inv_direct(oraddr_t memaddr, uint16_t val, void *dat)`
329			`{`
330			`struct dev_memarea *mem = dat;`
331
332			`PRINTF("ERROR: Invalid 16-bit direct write to memory %"PRIxADDR"\n",`
333			`mem->addr_compare \| memaddr);`
334			`}`
335
336			`void set_mem_32_inv_direct(oraddr_t memaddr, uint32_t val, void *dat)`
337			`{`
338			`struct dev_memarea *mem = dat;`
339
340			`PRINTF("ERROR: Invalid 32-bit direct write to memory %"PRIxADDR"\n",`
341			`mem->addr_compare \| memaddr);`
342			`}`
343
344			`/* For cpu accesses`
345			`*`
346			`* NOTE: This function _is_ only called from eval_mem32 below and`
347			`* {i,d}c_simulate_read. _Don't_ call it from anywere else.`
348			`*/`
349			`inline uint32_t evalsim_mem32(oraddr_t memaddr, oraddr_t vaddr)`
350			`{`
351			`struct dev_memarea *mem;`
352
353			`if((mem = verify_memoryarea(memaddr))) {`
354			`runtime.sim.mem_cycles += mem->ops.delayr;`
355			`return mem->ops.readfunc32(memaddr & mem->size_mask, mem->ops.read_dat32);`
356			`} else {`
357			`PRINTF("EXCEPTION: read out of memory (32-bit access to %"PRIxADDR")\n",`
358			`memaddr);`
359			`except_handle(EXCEPT_BUSERR, vaddr);`
360	560	markom	`}`
361	1486	nogj
362			`return 0;`
363	560	markom	`}`
364
365	1486	nogj	`/* For cpu accesses`
366			`*`
367			`* NOTE: This function _is_ only called from eval_mem16 below and`
368			`* {i,d}c_simulate_read. _Don't_ call it from anywere else.`
369			`*/`
370			`inline uint16_t evalsim_mem16(oraddr_t memaddr, oraddr_t vaddr)`
371			`{`
372			`struct dev_memarea *mem;`
373
374			`if((mem = verify_memoryarea(memaddr))) {`
375			`runtime.sim.mem_cycles += mem->ops.delayr;`
376			`return mem->ops.readfunc16(memaddr & mem->size_mask, mem->ops.read_dat16);`
377			`} else {`
378			`PRINTF("EXCEPTION: read out of memory (16-bit access to %"PRIxADDR")\n",`
379			`memaddr);`
380			`except_handle(EXCEPT_BUSERR, vaddr);`
381			`}`
382
383			`return 0;`
384			`}`
385
386			`/* For cpu accesses`
387			`*`
388			`* NOTE: This function _is_ only called from eval_mem8 below and`
389			`* {i,d}c_simulate_read. _Don't_ call it from anywere else.`
390			`*/`
391			`inline uint8_t evalsim_mem8(oraddr_t memaddr, oraddr_t vaddr)`
392			`{`
393			`struct dev_memarea *mem;`
394
395			`if((mem = verify_memoryarea(memaddr))) {`
396			`runtime.sim.mem_cycles += mem->ops.delayr;`
397			`return mem->ops.readfunc8(memaddr & mem->size_mask, mem->ops.read_dat8);`
398			`} else {`
399			`PRINTF("EXCEPTION: read out of memory (8-bit access to %"PRIxADDR")\n",`
400			`memaddr);`
401			`except_handle(EXCEPT_BUSERR, vaddr);`
402			`}`
403
404			`return 0;`
405			`}`
406
407	1319	phoenix	`/* Returns 32-bit values from mem array. Big endian version.`
408			`*`
409			`* STATISTICS OK (only used for cpu_access, that is architectural access)`
410			`*/`
411	1350	nogj	`uint32_t eval_mem32(oraddr_t memaddr,int* breakpoint)`
412	2	cvs	`{`
413	1350	nogj	`uint32_t temp;`
414	1486	nogj	`oraddr_t phys_memaddr;`
415	123	markom
416	547	markom	`if (config.sim.mprofile)`
417			`mprofile (memaddr, MPROF_32 \| MPROF_READ);`
418
419	538	markom	`if (memaddr & 3) {`
420			`except_handle (EXCEPT_ALIGN, memaddr);`
421			`return 0;`
422			`}`
423	557	markom
424	631	simons	`if (config.debug.enabled)`
425			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
426
427	1486	nogj	`phys_memaddr = dmmu_translate(memaddr, 0);`
428	1386	nogj	`if (except_pending)`
429	574	markom	`return 0;`
430
431	992	simons	`if (config.dc.enabled)`
432	1486	nogj	`temp = dc_simulate_read(phys_memaddr, memaddr, 4);`
433			`else`
434			`temp = evalsim_mem32(phys_memaddr, memaddr);`
435	611	simons
436	550	markom	`if (config.debug.enabled)`
437	270	markom	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
438	1486	nogj
439	239	markom	`return temp;`
440	66	lampret	`}`
441
442	1319	phoenix	`/* for simulator accesses, the ones that cpu wouldn't do`
443			`*`
444			`* STATISTICS OK`
445			`*/`
446	1487	nogj	`uint32_t eval_direct32(oraddr_t memaddr, int through_mmu, int through_dc)`
447	1240	phoenix	`{`
448	1486	nogj	`oraddr_t phys_memaddr;`
449			`struct dev_memarea *mem;`
450	1240	phoenix
451			`if (memaddr & 3) {`
452			`PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);`
453	1486	nogj	`return 0;`
454	1240	phoenix	`}`
455
456	1486	nogj	`phys_memaddr = memaddr;`
457	1240	phoenix
458			`if (through_mmu)`
459	1486	nogj	`phys_memaddr = peek_into_dtlb(memaddr, 0, through_dc);`
460	1240	phoenix
461			`if (through_dc)`
462	1486	nogj	`return dc_simulate_read(phys_memaddr, memaddr, 4);`
463	1240	phoenix	`else {`
464	1486	nogj	`if((mem = verify_memoryarea(phys_memaddr)))`
465			`return mem->direct_ops.readfunc32(phys_memaddr & mem->size_mask,`
466			`mem->direct_ops.read_dat32);`
467			`else`
468			`PRINTF("ERR: 32-bit read out of memory area: %"PRIxADDR" (physical: %"`
469			`PRIxADDR"\n", memaddr, phys_memaddr);`
470	1240	phoenix	`}`
471
472	1486	nogj	`return 0;`
473	1240	phoenix	`}`
474
475
476	1319	phoenix	`/* Returns 32-bit values from mem array. Big endian version.`
477			`*`
478			`* STATISTICS OK (only used for cpu_access, that is architectural access)`
479			`*/`
480	1386	nogj	`uint32_t eval_insn(oraddr_t memaddr, int* breakpoint)`
481	349	simons	`{`
482	1350	nogj	`uint32_t temp;`
483	1486	nogj	`oraddr_t phys_memaddr;`
484	349	simons
485	547	markom	`if (config.sim.mprofile)`
486			`mprofile (memaddr, MPROF_32 \| MPROF_FETCH);`
487	532	markom	`// memaddr = simulate_ic_mmu_fetch(memaddr);`
488	1244	hpanther
489	1486	nogj	`phys_memaddr = memaddr;`
490	1452	nogj	`#if !(DYNAMIC_EXECUTION)`
491	1486	nogj	`phys_memaddr = immu_translate(memaddr);`
492	1386	nogj
493			`if (except_pending)`
494			`return 0;`
495	1452	nogj	`#endif`
496	1386	nogj
497			`if (config.debug.enabled)`
498			`*breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr);`
499
500	631	simons	`if (config.ic.enabled)`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [stable_0_2_0_rc2/] [or1ksim/] [cpu/] [common/] [abstract.c] - Blame information for rev 1557