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

Subversion Repositories or1k

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

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


/* abstract.c -- Abstract entities
   Copyright (C) 1999 Damjan Lampret, lampret@opencores.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"
#include "sim-config.h"
 
#include "parse.h"
#include "abstract.h"
#include "labels.h"
#include "arch.h"
#include "execute.h"
#include "sprs.h"
#include "stats.h"
#include "except.h"
#include "debug_unit.h"
#include "opcode/or32.h"
#include "support/profile.h"
 
extern unsigned long reg[];
extern char *disassembled;
 
/* This is an abstract+physical memory array rather than only physical
   memory array */
static unsigned long *simmem32;
 
/* 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 = (struct dev_memarea *)0;
 
/* These are set by mmu if cache inhibit bit is set for current acces.  */
int data_ci, insn_ci;
 
/* Virtual address of current access. */
unsigned long cur_vadd;
 
/* Calculates bit mask to fit the data */
unsigned long bit_mask (unsigned long 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.) */
void register_memoryarea_mask(unsigned long addr_mask, unsigned long addr_compare,
                         unsigned long size, unsigned granularity, unsigned mc_dev,
                         unsigned long (readfunc)(unsigned long),
                         void (writefunc)(unsigned long, unsigned long))
{
  struct dev_memarea **pptmp;
  unsigned long size_mask = bit_mask (size);
  int found_error = 0;
  addr_compare &= addr_mask;
 
  debug(5, "addr & %08x == %08x to %08x, size %08x, gran %iB\n", addr_mask, addr_compare, addr_compare | bit_mask (size), size, granularity);
  /* 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 & %08x == %08x to %08x, size %08x, gran %iB\n", addr_mask, addr_compare, addr_compare | bit_mask (size), size, granularity);
      }
      found_error = 1;
      fprintf (stderr, "and\taddr & %08x == %08x to %08x, size %08x, gran %iB\n", (*pptmp)->addr_mask, (*pptmp)->addr_compare,
        (*pptmp)->addr_compare | (*pptmp)->size_mask, (*pptmp)->size, (*pptmp)->granularity);
    }
 
  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)->granularity = granularity;
  (*pptmp)->readfunc = readfunc;
  (*pptmp)->writefunc = writefunc;
  (*pptmp)->log = 0;
  (*pptmp)->delayr = 2;
  (*pptmp)->delayw = 2;
  (*pptmp)->next = NULL;
}
 
/* 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 means that this device will be checked first for match
   and will be accessed in case in overlaping memory spaces.
   Only one device can have this set to 1 (used for memory controller) */
void register_memoryarea(unsigned long addr,
                         unsigned long size, unsigned granularity, unsigned mc_dev,
                         unsigned long (readfunc)(unsigned long),
                         void (writefunc)(unsigned long, unsigned long))
{
  unsigned long size_mask = bit_mask (size);
  unsigned long addr_mask = ~size_mask;
  register_memoryarea_mask (addr_mask, addr & addr_mask,
                      size_mask + 1, granularity, mc_dev,
                      readfunc, writefunc);
}
 
 
/* Check if access is to registered area of memory. */
inline struct dev_memarea *verify_memoryarea(unsigned long 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 */
  IFF (config.mc.enabled) {
    /* 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;
  } else {
    /* Check list of registered devices. */
    for(ptmp = dev_list; ptmp; ptmp = ptmp->next)
      if ((addr & ptmp->addr_mask) == (ptmp->addr_compare & ptmp->addr_mask))
        return cur_area = ptmp;
  }
  return cur_area = NULL;
}
 
/* Finds the memory area for the address and adjust the read and write delays for it. */
void adjust_rw_delay(unsigned long memaddr, unsigned long delayr, unsigned long delayw)
{
  if (verify_memoryarea(memaddr)) {
    cur_area->delayr = delayr;
    cur_area->delayw = delayw;
  }
}
 
inline unsigned long evalsim_mem32(unsigned long memaddr)
{
  unsigned long temp;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 4:
      temp = cur_area->readfunc(memaddr);
      runtime.sim.mem_cycles += cur_area->delayr;
      break;
    case 1:
      temp = cur_area->readfunc(memaddr) << 24;
      temp |= cur_area->readfunc(memaddr + 1) << 16;
      temp |= cur_area->readfunc(memaddr + 2) << 8;
      temp |= cur_area->readfunc(memaddr + 3);
      runtime.sim.mem_cycles += cur_area->delayr * 4;
      break;
    case 2:
      temp = cur_area->readfunc(memaddr) << 16;
      temp |= cur_area->readfunc(memaddr + 2);
      runtime.sim.mem_cycles += cur_area->delayr * 2;
      break;
    }
  }
  return temp;
}
 
unsigned short evalsim_mem16(unsigned long memaddr)
{
  unsigned long temp;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      temp = cur_area->readfunc(memaddr) << 8;
      temp |= cur_area->readfunc(memaddr + 1);
      runtime.sim.mem_cycles += cur_area->delayr * 2;
      break;
    case 2:
      temp = cur_area->readfunc(memaddr);
      runtime.sim.mem_cycles += cur_area->delayr;
      break;
    case 4:
      temp = evalsim_mem32 (memaddr & ~3ul);
      if (memaddr & 2)
        temp &= 0xffff;
      else
        temp >>= 16;
      break;
    }
  }
  return temp;
}
 
unsigned char evalsim_mem8(unsigned long memaddr)
{
  unsigned long temp;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      temp = cur_area->readfunc(memaddr);
      runtime.sim.mem_cycles += cur_area->delayr;
      break;
    case 2:
      temp = evalsim_mem16 (memaddr & ~1ul);
      if (memaddr & 1)
        temp &= 0xff;
      else
        temp >>= 8;
      break;
    case 4:
      temp = evalsim_mem32 (memaddr & ~3ul);
      temp >>= 8 * (3 - (memaddr & 3));
      temp &= 0xff;
      break;
    }
  }
  return temp;
}
 
/* Returns 32-bit values from mem array. Big endian version. */
unsigned long read_mem(unsigned long memaddr,int* breakpoint)
{
  unsigned long temp;
  struct dev_memarea *dev;
 
  cur_vadd = memaddr;
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
  temp = evalsim_mem32(memaddr);
  if (!cur_area) {
    printf("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
    temp = 0;
  }
 
  if (!pending.valid && cur_area->log)
    fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
/* Returns 32-bit values from mem array. Big endian version. */
unsigned long eval_mem32(unsigned long memaddr,int* breakpoint)
{
 
  unsigned long temp;
  struct dev_memarea *dev;
 
  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 */
 
  cur_vadd = memaddr;
 
  memaddr = dmmu_translate(memaddr, 0);
  if (pending.valid)
    return 0;
 
  temp = dc_simulate_read(memaddr, 4);
  if (!cur_area) {
    printf("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
    temp = 0;
  }
 
  if (!pending.valid && cur_area->log)
    fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
/* Returns 32-bit values from mem array. Big endian version. */
unsigned long eval_insn(unsigned long memaddr,int* breakpoint)
{
  unsigned long temp;
  struct dev_memarea *dev;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_32 | MPROF_FETCH);
//  memaddr = simulate_ic_mmu_fetch(memaddr);
  cur_vadd = pc;
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
  if (config.ic.enabled)
    temp = ic_simulate_fetch(memaddr);
  else
    temp = evalsim_mem32(memaddr);
  if (!cur_area) {
    printf("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
    temp = 0;
  }
 
  if (!pending.valid && cur_area->log)
    fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
/* Returns 16-bit values from mem array. Big endian version. */
 
unsigned short eval_mem16(unsigned long memaddr,int* breakpoint)
{
  unsigned short temp;
 
  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 */
 
  cur_vadd = memaddr;
 
  memaddr = dmmu_translate(memaddr, 0);
  if (pending.valid)
    return 0;
 
  temp = (unsigned short)dc_simulate_read(memaddr, 2);
  if (!cur_area) {
    printf("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
    temp = 0;
  }
 
  if (!pending.valid && cur_area->log)
    fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
/* Returns 8-bit values from mem array. */
 
unsigned char eval_mem8(unsigned long memaddr,int* breakpoint)
{
  unsigned char temp;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_8 | MPROF_READ);
 
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr);  /* 28/05/01 CZ */
 
  cur_vadd = memaddr;
 
  memaddr = dmmu_translate(memaddr, 0);
  if (pending.valid)
    return 0;
 
  temp = (unsigned char)dc_simulate_read(memaddr, 1);
  if (!cur_area) {
    printf("EXCEPTION: read out of memory (8-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
    temp = 0;
  }
 
  if (!pending.valid && cur_area->log)
    fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
void setsim_mem32(unsigned long memaddr, unsigned long value)
{
  struct dev_memarea *dev;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 4:
      cur_area->writefunc(memaddr, value);
      runtime.sim.mem_cycles += cur_area->delayw;
      break;
    case 1:
      cur_area->writefunc(memaddr    , (value >> 24) & 0xFF);
      cur_area->writefunc(memaddr + 1, (value >> 16) & 0xFF);
      cur_area->writefunc(memaddr + 2, (value >>  8) & 0xFF);
      cur_area->writefunc(memaddr + 3, (value      ) & 0xFF);
      runtime.sim.mem_cycles += cur_area->delayw * 4;
      break;
    case 2:
      cur_area->writefunc(memaddr, (value >> 16) & 0xFFFF);
      cur_area->writefunc(memaddr + 2, value & 0xFFFF);
      runtime.sim.mem_cycles += cur_area->delayw * 2;
      break;
    }
  } else {
    printf("EXCEPTION: write out of memory (32-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
  }
}
 
void setsim_mem16(unsigned long memaddr, unsigned short value)
{
  unsigned long temp;
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      cur_area->writefunc(memaddr, (value >> 8) & 0xFF);
      cur_area->writefunc(memaddr + 1, value & 0xFF);
      runtime.sim.mem_cycles += cur_area->delayw * 2;
      break;
    case 2:
      cur_area->writefunc(memaddr, value & 0xFFFF);
      runtime.sim.mem_cycles += cur_area->delayw;
      break;
    case 4:
      temp = evalsim_mem32 (memaddr & ~3ul);
      temp &= 0xffff << ((memaddr & 2) ? 16 : 0);
      temp |= (unsigned long)(value & 0xffff) << ((memaddr & 2) ? 0 : 16);
      setsim_mem32 (memaddr & ~3ul, temp);
      break;
    }
  } else {
    printf("EXCEPTION: write out of memory (16-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
  }
}
 
void setsim_mem8(unsigned long memaddr, unsigned char value)
{
  unsigned long temp;
  if (verify_memoryarea(memaddr)) {
    switch (cur_area->granularity) {
    case 1:
      cur_area->writefunc(memaddr, value);
      runtime.sim.mem_cycles += cur_area->delayw;
      break;
    case 2:
      temp = evalsim_mem16 (memaddr & ~1ul);
      temp &= 0xff << ((memaddr & 1) ? 8 : 0);
      temp |= (unsigned short)(value & 0xff) << ((memaddr & 1) ? 0 : 8);
      setsim_mem16 (memaddr & ~1ul, temp);
      break;
    case 4:
      temp = evalsim_mem32 (memaddr & ~3ul);
      temp &= ~(0xff << (8 * (3 - (memaddr & 3))));
      temp |= (unsigned long)(value & 0xff) << (8 * (3 - (memaddr & 3)));
      setsim_mem32 (memaddr & ~3ul, temp);
      break;
    }
  } else {
    printf("EXCEPTION: write out of memory (8-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
  }
}
 
/* Set mem, 32-bit. Big endian version. */
 
void set_mem32(unsigned long memaddr, unsigned long value,int* breakpoint)
{
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_32 | MPROF_WRITE);
 
  if (memaddr & 3) {
    except_handle (EXCEPT_ALIGN, memaddr);
    return;
  }
 
  cur_vadd = memaddr;
  memaddr = dmmu_translate(memaddr, 1);;
  /* If we produced exception don't set anything */
  if (pending.valid)
    return;
 
  if (config.debug.enabled) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  if (cur_area->log)
    fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);
 
  dc_simulate_write(memaddr, value, 4);
}
 
/* Set mem, 16-bit. Big endian version. */
 
void set_mem16(unsigned long memaddr, unsigned short value,int* breakpoint)
{
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_16 | MPROF_WRITE);
 
  if (memaddr & 1) {
    except_handle (EXCEPT_ALIGN, memaddr);
    return;
  }
 
  cur_vadd = memaddr;
  memaddr = dmmu_translate(memaddr, 1);;
  /* If we produced exception don't set anything */
  if (pending.valid)
    return;
 
  if (config.debug.enabled) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  if (cur_area->log)
    fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);
 
  dc_simulate_write(memaddr, (unsigned long)value, 2);
}
 
/* Set mem, 8-bit. */
 
void set_mem8(unsigned long memaddr, unsigned char value,int* breakpoint)
{
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_8 | MPROF_WRITE);
 
  cur_vadd = memaddr;
  memaddr = dmmu_translate(memaddr, 1);;
  /* If we produced exception don't set anything */
  if (pending.valid) return;
 
  if (config.debug.enabled) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  if (cur_area->log)
    fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);
 
  dc_simulate_write(memaddr, (unsigned long)value, 1);
}
 
void dumpmemory(unsigned int from, unsigned int to, int disasm, int nl)
{
  unsigned int i, j;
  struct label_entry *tmp;
  int breakpoint = 0;
  int ilen = disasm ? 4 : 16;
 
  for(i = from; i < to; i += ilen) {
    printf("%.8x: ", i);
    for (j = 0; j < ilen;) {
      int data = -1;
      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("%02x ", data = evalsim_mem8(i+j));
        } else printf("XX ");
        j++;
      } else {
        int breakpoint;
        unsigned int _insn = read_mem(i, &breakpoint);
        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(": %08x ", (unsigned long)_insn);
          if (index >= 0) {
            disassemble_insn (_insn);
            printf(" %s", disassembled);
          } else
            printf("<invalid>");
        } else printf("XXXXXXXX");
        j += len;
      }
    }
    if (nl)
      printf ("\n");
  }
}
 
unsigned long simmem_read_word(unsigned long addr) {
  return simmem32[(cur_area->misc + (addr & cur_area->size_mask)) >> 2];
}
 
void simmem_write_word(unsigned long addr, unsigned long value) {
  simmem32[(cur_area->misc + (addr & cur_area->size_mask)) >> 2] = value;
}
 
unsigned long simmem_read_zero(unsigned long addr) {
  if (config.sim.verbose)
    fprintf (stderr, "WARNING: memory read from non-read memory area 0x%08x.\n", addr);
  return 0;
}
 
void simmem_write_null(unsigned long addr, unsigned long value) {
  if (config.sim.verbose)
    fprintf (stderr, "WARNING: memory write to 0x%08x, non-write memory area (value 0x%08x).\n", addr, value);
}
 
/* Initialize memory table from a config struct */
 
void init_memory_table ()
{
  unsigned long memory_needed = 0;
 
  /* If nothing was defined, use default memory block */
  if (config.memory.nmemories) {
    int i;
    for (i = 0; i < config.memory.nmemories; i++) {
      unsigned long start = config.memory.table[i].baseaddr;
      unsigned long length = config.memory.table[i].size;
      char *type = config.memory.table[i].name;
      int rd = config.memory.table[i].delayr;
      int wd = config.memory.table[i].delayw;
      int ce = config.memory.table[i].ce;
      if (config.sim.verbose)
        debug (1, "%08X %08X (%i KB): %s (activated by CE%i; read delay = %icyc, write delay = %icyc)\n",
          start, length, length >> 10, type, ce, rd, wd);
      register_memoryarea(start, length, 4, 0, &simmem_read_word, &simmem_write_word);
      cur_area->misc = memory_needed;
      cur_area->chip_select = ce;
      cur_area->valid = 1;
      cur_area->delayw = wd;
      cur_area->delayr = rd;
      if (config.memory.table[i].log[0] != '\0') {
        if ((cur_area->log = fopen (config.memory.table[i].log, "wt+")) == NULL)
          fprintf (stderr, "WARNING: Cannot open '%s'.\n", config.memory.table[i].log);
      } else
        cur_area->log = NULL;
      memory_needed += cur_area->size;
    }
    printf ("\n");
  } else {
    if (config.sim.verbose)
      fprintf (stderr, "WARNING: Memory not defined, assuming standard configuration.\n");
    register_memoryarea(DEFAULT_MEMORY_START, DEFAULT_MEMORY_LEN, 4, 0, &simmem_read_word, &simmem_write_word);
    cur_area->misc = memory_needed;
    cur_area->chip_select = 0;
    cur_area->valid = 1;
    cur_area->delayw = 1;
    cur_area->delayr = 1;
    cur_area->log = NULL;
    memory_needed += cur_area->size;
  }
 
  simmem32 = (unsigned long *) malloc (sizeof (unsigned long) * ((memory_needed + 3) / 4));
  if (!simmem32) {
    fprintf (stderr, "Failed to allocate sim memory. Aborting\n");
    exit (-1);
  }
}
 
/* Changes read/write memory in read/write only */
 
void lock_memory_table ()
{
  struct dev_memarea *ptmp;
 
  /* Check list of registered devices. */
  for(ptmp = dev_list; ptmp; ptmp = ptmp->next) {
    if (ptmp->delayr < 0 && ptmp->readfunc == &simmem_read_word)
      ptmp->readfunc = &simmem_read_zero;
    if (ptmp->delayw < 0 && ptmp->writefunc == &simmem_write_word)
      ptmp->writefunc = &simmem_write_null;
 
    /* If this mem area is not for memory chip under MC control
       then this area is valid all the time */
    if (ptmp->readfunc != &simmem_read_word) {
      ptmp->valid = 1;
      ptmp->chip_select = -1;
    }
  }
}
 
/* Closes files, etc. */
 
void done_memory_table ()
{
  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 ()
{
  struct dev_memarea *ptmp;
 
  /* Check list of registered devices. */
  for(ptmp = dev_list; ptmp; ptmp = ptmp->next) {
    printf ("addr & %08x == %08x to %08x, size %08x, gran %iB\n",
      ptmp->addr_mask, ptmp->addr_compare, ptmp->addr_compare | bit_mask (ptmp->size),
      ptmp->size, ptmp->granularity);
    printf ("\t");
    if (ptmp->delayr >= 0)
      printf ("read delay = %i cycles, ", ptmp->delayr);
    else
      printf ("reads not possible, ");
 
    if (ptmp->delayw >= 0)
      printf ("write delay = %i cycles", ptmp->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, "%i%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
4			`This file is part of OpenRISC 1000 Architectural Simulator.`
5
6			`This program is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License as published by`
8			`the Free Software Foundation; either version 2 of the License, or`
9			`(at your option) any later version.`
10
11			`This program is distributed in the hope that it will be useful,`
12			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
14			`GNU General Public License for more details.`
15
16			`You should have received a copy of the GNU General Public License`
17			`along with this program; if not, write to the Free Software`
18			`Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */`
19
20	66	lampret	`/* Abstract memory and routines that go with this. I need to`
21	2	cvs	`add all sorts of other abstract entities. Currently we have`
22			`only memory. */`
23
24	221	markom	`#include <stdlib.h>`
25	2	cvs	`#include <stdio.h>`
26			`#include <ctype.h>`
27			`#include <string.h>`
28
29	6	lampret	`#include "config.h"`
30	7	jrydberg	`#include "sim-config.h"`
31	6	lampret
32	2	cvs	`#include "parse.h"`
33			`#include "abstract.h"`
34	261	markom	`#include "labels.h"`
35	2	cvs	`#include "arch.h"`
36			`#include "execute.h"`
37	32	lampret	`#include "sprs.h"`
38	35	lampret	`#include "stats.h"`
39	32	lampret	`#include "except.h"`
40	123	markom	`#include "debug_unit.h"`
41	134	markom	`#include "opcode/or32.h"`
42	547	markom	`#include "support/profile.h"`
43	2	cvs
44			`extern unsigned long reg[];`
45	138	markom	`extern char *disassembled;`
46	2	cvs
47	28	lampret	`/* This is an abstract+physical memory array rather than only physical`
48			`memory array */`
49	538	markom	`static unsigned long *simmem32;`
50	2	cvs
51	30	lampret	`/* Pointer to memory area descriptions that are assigned to individual`
52			`peripheral devices. */`
53			`struct dev_memarea *dev_list;`
54
55	221	markom	`/* Temporary variable to increase speed. */`
56			`struct dev_memarea *cur_area;`
57
58	970	simons	`/* Pointer to memory controller device descriptor. */`
59			`struct dev_memarea mc_area = (struct dev_memarea )0;`
60
61	638	simons	`/* These are set by mmu if cache inhibit bit is set for current acces. */`
62			`int data_ci, insn_ci;`
63
64	525	simons	`/* Virtual address of current access. */`
65			`unsigned long cur_vadd;`
66
67	261	markom	`/* Calculates bit mask to fit the data */`
68			`unsigned long bit_mask (unsigned long data) {`
69			`int i = 0;`
70			`data--;`
71	382	markom	`while (data >> i)`
72	261	markom	`data \|= 1 << i++;`
73			`return data;`
74			`}`
75
76			`/* Register read and write function for a memory area.`
77			`addr is inside the area, if addr & addr_mask == addr_compare`
78			`(used also by peripheral devices like 16450 UART etc.) */`
79			`void register_memoryarea_mask(unsigned long addr_mask, unsigned long addr_compare,`
80	970	simons	`unsigned long size, unsigned granularity, unsigned mc_dev,`
81	239	markom	`unsigned long (readfunc)(unsigned long),`
82	261	markom	`void (writefunc)(unsigned long, unsigned long))`
83	30	lampret	`{`
84	239	markom	`struct dev_memarea **pptmp;`
85	261	markom	`unsigned long size_mask = bit_mask (size);`
86			`int found_error = 0;`
87			`addr_compare &= addr_mask;`
88	221	markom
89	382	markom	`debug(5, "addr & %08x == %08x to %08x, size %08x, gran %iB\n", addr_mask, addr_compare, addr_compare \| bit_mask (size), size, granularity);`
90	239	markom	`/* Go to the end of the list. */`
91	261	markom	`for(pptmp = &dev_list; pptmp; pptmp = &(pptmp)->next)`
92			`if ((addr_compare >= (pptmp)->addr_compare) && (addr_compare < (pptmp)->addr_compare + (*pptmp)->size)`
93			`\|\| (addr_compare + size > (pptmp)->addr_compare) && (addr_compare < (pptmp)->addr_compare + (*pptmp)->size)) {`
94	262	markom	`if (!found_error) {`
95	261	markom	`fprintf (stderr, "ERROR: Overlapping memory area(s):\n");`
96	262	markom	`fprintf (stderr, "\taddr & %08x == %08x to %08x, size %08x, gran %iB\n", addr_mask, addr_compare, addr_compare \| bit_mask (size), size, granularity);`
97			`}`
98	261	markom	`found_error = 1;`
99	424	markom	`fprintf (stderr, "and\taddr & %08x == %08x to %08x, size %08x, gran %iB\n", (pptmp)->addr_mask, (pptmp)->addr_compare,`
100	261	markom	`(pptmp)->addr_compare \| (pptmp)->size_mask, (pptmp)->size, (pptmp)->granularity);`
101			`}`
102
103			`if (found_error)`
104			`exit (-1);`
105	537	markom
106	239	markom	`cur_area = pptmp = (struct dev_memarea )malloc(sizeof(struct dev_memarea));`
107	970	simons
108			`if (mc_dev)`
109			`mc_area = *pptmp;`
110
111	261	markom	`(*pptmp)->addr_mask = addr_mask;`
112			`(*pptmp)->addr_compare = addr_compare;`
113	239	markom	`(*pptmp)->size = size;`
114	261	markom	`(*pptmp)->size_mask = size_mask;`
115	239	markom	`(*pptmp)->granularity = granularity;`
116			`(*pptmp)->readfunc = readfunc;`
117			`(*pptmp)->writefunc = writefunc;`
118	479	markom	`(*pptmp)->log = 0;`
119	882	simons	`(*pptmp)->delayr = 2;`
120			`(*pptmp)->delayw = 2;`
121	239	markom	`(*pptmp)->next = NULL;`
122	261	markom	`}`
123	221	markom
124	261	markom	`/* Register read and write function for a memory area.`
125			`Memory areas should be aligned. Memory area is rounded up to`
126			`fit the nearest 2^n aligment.`
127	970	simons	`(used also by peripheral devices like 16450 UART etc.)`
128			`If mc_dev is 1, this means that this device will be checked first for match`
129			`and will be accessed in case in overlaping memory spaces.`
130			`Only one device can have this set to 1 (used for memory controller) */`
131	261	markom	`void register_memoryarea(unsigned long addr,`
132	970	simons	`unsigned long size, unsigned granularity, unsigned mc_dev,`
133	261	markom	`unsigned long (readfunc)(unsigned long),`
134			`void (writefunc)(unsigned long, unsigned long))`
135			`{`
136			`unsigned long size_mask = bit_mask (size);`
137			`unsigned long addr_mask = ~size_mask;`
138			`register_memoryarea_mask (addr_mask, addr & addr_mask,`
139	970	simons	`size_mask + 1, granularity, mc_dev,`
140	261	markom	`readfunc, writefunc);`
141	30	lampret	`}`
142
143	261	markom
144	30	lampret	`/* Check if access is to registered area of memory. */`
145	560	markom	`inline struct dev_memarea *verify_memoryarea(unsigned long addr)`
146	30	lampret	`{`
147	239	markom	`struct dev_memarea *ptmp;`
148	221	markom
149	970	simons	`/* Check memory controller space first */`
150			`if (mc_area && (addr & mc_area->addr_mask) == (mc_area->addr_compare & mc_area->addr_mask))`
151			`return cur_area = mc_area;`
152
153			`/* Check cached value */`
154	560	markom	`if (cur_area && (addr & cur_area->addr_mask) == (cur_area->addr_compare & cur_area->addr_mask))`
155			`return cur_area;`
156
157			`/* When mc is enabled, we must check valid also, otherwise we assume it is nonzero */`
158			`IFF (config.mc.enabled) {`
159			`/* Check list of registered devices. */`
160			`for(ptmp = dev_list; ptmp; ptmp = ptmp->next)`
161			`if ((addr & ptmp->addr_mask) == (ptmp->addr_compare & ptmp->addr_mask) && ptmp->valid)`
162			`return cur_area = ptmp;`
163			`} else {`
164			`/* Check list of registered devices. */`
165			`for(ptmp = dev_list; ptmp; ptmp = ptmp->next)`
166			`if ((addr & ptmp->addr_mask) == (ptmp->addr_compare & ptmp->addr_mask))`
167			`return cur_area = ptmp;`
168			`}`
169	239	markom	`return cur_area = NULL;`
170	30	lampret	`}`
171
172	882	simons	`/* Finds the memory area for the address and adjust the read and write delays for it. */`
173			`void adjust_rw_delay(unsigned long memaddr, unsigned long delayr, unsigned long delayw)`
174			`{`
175			`if (verify_memoryarea(memaddr)) {`
176			`cur_area->delayr = delayr;`
177			`cur_area->delayw = delayw;`
178			`}`
179			`}`
180
181	560	markom	`inline unsigned long evalsim_mem32(unsigned long memaddr)`
182			`{`
183			`unsigned long temp;`
184
185			`if (verify_memoryarea(memaddr)) {`
186			`switch(cur_area->granularity) {`
187			`case 4:`
188			`temp = cur_area->readfunc(memaddr);`
189	884	markom	`runtime.sim.mem_cycles += cur_area->delayr;`
190	560	markom	`break;`
191			`case 1:`
192			`temp = cur_area->readfunc(memaddr) << 24;`
193			`temp \|= cur_area->readfunc(memaddr + 1) << 16;`
194			`temp \|= cur_area->readfunc(memaddr + 2) << 8;`
195			`temp \|= cur_area->readfunc(memaddr + 3);`
196	884	markom	`runtime.sim.mem_cycles += cur_area->delayr * 4;`
197	560	markom	`break;`
198			`case 2:`
199			`temp = cur_area->readfunc(memaddr) << 16;`
200			`temp \|= cur_area->readfunc(memaddr + 2);`
201	884	markom	`runtime.sim.mem_cycles += cur_area->delayr * 2;`
202	560	markom	`break;`
203			`}`
204			`}`
205			`return temp;`
206			`}`
207
208			`unsigned short evalsim_mem16(unsigned long memaddr)`
209			`{`
210			`unsigned long temp;`
211
212			`if (verify_memoryarea(memaddr)) {`
213			`switch(cur_area->granularity) {`
214			`case 1:`
215			`temp = cur_area->readfunc(memaddr) << 8;`
216			`temp \|= cur_area->readfunc(memaddr + 1);`
217	884	markom	`runtime.sim.mem_cycles += cur_area->delayr * 2;`
218	560	markom	`break;`
219			`case 2:`
220			`temp = cur_area->readfunc(memaddr);`
221	884	markom	`runtime.sim.mem_cycles += cur_area->delayr;`
222	560	markom	`break;`
223			`case 4:`
224			`temp = evalsim_mem32 (memaddr & ~3ul);`
225			`if (memaddr & 2)`
226			`temp &= 0xffff;`
227			`else`
228			`temp >>= 16;`
229			`break;`
230			`}`
231			`}`
232			`return temp;`
233			`}`
234
235			`unsigned char evalsim_mem8(unsigned long memaddr)`
236			`{`
237			`unsigned long temp;`
238
239			`if (verify_memoryarea(memaddr)) {`
240			`switch(cur_area->granularity) {`
241			`case 1:`
242			`temp = cur_area->readfunc(memaddr);`
243	884	markom	`runtime.sim.mem_cycles += cur_area->delayr;`
244	560	markom	`break;`
245			`case 2:`
246			`temp = evalsim_mem16 (memaddr & ~1ul);`
247			`if (memaddr & 1)`
248			`temp &= 0xff;`
249			`else`
250			`temp >>= 8;`
251			`break;`
252			`case 4:`
253			`temp = evalsim_mem32 (memaddr & ~3ul);`
254			`temp >>= 8 * (3 - (memaddr & 3));`
255			`temp &= 0xff;`
256			`break;`
257			`}`
258			`}`
259			`return temp;`
260			`}`
261
262	2	cvs	`/* Returns 32-bit values from mem array. Big endian version. */`
263	349	simons	`unsigned long read_mem(unsigned long memaddr,int* breakpoint)`
264			`{`
265			`unsigned long temp;`
266			`struct dev_memarea *dev;`
267
268	525	simons	`cur_vadd = memaddr;`
269	550	markom	`if (config.debug.enabled)`
270	349	simons	`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
271			`temp = evalsim_mem32(memaddr);`
272	611	simons	`if (!cur_area) {`
273			`printf("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);`
274			`except_handle(EXCEPT_BUSERR, cur_vadd);`
275			`temp = 0;`
276			`}`
277
278	599	simons	`if (!pending.valid && cur_area->log)`
279	587	markom	`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
280	550	markom	`if (config.debug.enabled)`
281	349	simons	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
282			`return temp;`
283	537	markom	`}`
284	349	simons
285			`/* Returns 32-bit values from mem array. Big endian version. */`
286	123	markom	`unsigned long eval_mem32(unsigned long memaddr,int* breakpoint)`
287	2	cvs	`{`
288	6	lampret
289	239	markom	`unsigned long temp;`
290			`struct dev_memarea *dev;`
291	123	markom
292	547	markom	`if (config.sim.mprofile)`
293			`mprofile (memaddr, MPROF_32 \| MPROF_READ);`
294
295	538	markom	`if (memaddr & 3) {`
296			`except_handle (EXCEPT_ALIGN, memaddr);`
297			`return 0;`
298			`}`
299	557	markom
300	631	simons	`if (config.debug.enabled)`
301			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
302
303	574	markom	`cur_vadd = memaddr;`
304	631	simons
305			`memaddr = dmmu_translate(memaddr, 0);`
306	574	markom	`if (pending.valid)`
307			`return 0;`
308
309	631	simons	`temp = dc_simulate_read(memaddr, 4);`
310	611	simons	`if (!cur_area) {`
311			`printf("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);`
312			`except_handle(EXCEPT_BUSERR, cur_vadd);`
313			`temp = 0;`
314			`}`
315
316	599	simons	`if (!pending.valid && cur_area->log)`
317	587	markom	`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
318	550	markom	`if (config.debug.enabled)`
319	270	markom	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
320	239	markom	`return temp;`
321	66	lampret	`}`
322
323	349	simons	`/* Returns 32-bit values from mem array. Big endian version. */`
324			`unsigned long eval_insn(unsigned long memaddr,int* breakpoint)`
325			`{`
326			`unsigned long temp;`
327			`struct dev_memarea *dev;`
328
329	547	markom	`if (config.sim.mprofile)`
330			`mprofile (memaddr, MPROF_32 \| MPROF_FETCH);`
331	532	markom	`// memaddr = simulate_ic_mmu_fetch(memaddr);`
332	525	simons	`cur_vadd = pc;`
333	550	markom	`if (config.debug.enabled)`
334	349	simons	`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
335	631	simons	`if (config.ic.enabled)`
336			`temp = ic_simulate_fetch(memaddr);`
337			`else`
338			`temp = evalsim_mem32(memaddr);`
339	611	simons	`if (!cur_area) {`
340			`printf("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);`
341			`except_handle(EXCEPT_BUSERR, cur_vadd);`
342			`temp = 0;`
343			`}`
344
345	599	simons	`if (!pending.valid && cur_area->log)`
346	587	markom	`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
347	550	markom	`if (config.debug.enabled)`
348	349	simons	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
349			`return temp;`
350			`}`
351
352	2	cvs	`/* Returns 16-bit values from mem array. Big endian version. */`
353
354	123	markom	`unsigned short eval_mem16(unsigned long memaddr,int* breakpoint)`
355	2	cvs	`{`
356	239	markom	`unsigned short temp;`
357	547	markom
358			`if (config.sim.mprofile)`
359			`mprofile (memaddr, MPROF_16 \| MPROF_READ);`
360
361	538	markom	`if (memaddr & 1) {`
362			`except_handle (EXCEPT_ALIGN, memaddr);`
363			`return 0;`
364			`}`
365	574	markom
366	631	simons	`if (config.debug.enabled)`
367			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
368
369	574	markom	`cur_vadd = memaddr;`
370	631	simons
371			`memaddr = dmmu_translate(memaddr, 0);`
372	574	markom	`if (pending.valid)`
373			`return 0;`
374	66	lampret
375	631	simons	`temp = (unsigned short)dc_simulate_read(memaddr, 2);`
376	611	simons	`if (!cur_area) {`
377			`printf("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);`
378			`except_handle(EXCEPT_BUSERR, cur_vadd);`
379			`temp = 0;`
380			`}`
381
382	599	simons	`if (!pending.valid && cur_area->log)`
383	587	markom	`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
384	550	markom	`if (config.debug.enabled)`
385	270	markom	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
386	239	markom	`return temp;`
387	66	lampret	`}`
388
389	6	lampret	`/* Returns 8-bit values from mem array. */`
390	2	cvs
391	123	markom	`unsigned char eval_mem8(unsigned long memaddr,int* breakpoint)`
392	221	markom	`{`
393	631	simons	`unsigned char temp;`
394	547	markom
395			`if (config.sim.mprofile)`
396			`mprofile (memaddr, MPROF_8 \| MPROF_READ);`
397
398	631	simons	`if (config.debug.enabled)`
399			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
400
401	525	simons	`cur_vadd = memaddr;`
402	631	simons
403			`memaddr = dmmu_translate(memaddr, 0);`
404	458	simons	`if (pending.valid)`
405			`return 0;`
406	6	lampret
407	631	simons	`temp = (unsigned char)dc_simulate_read(memaddr, 1);`
408	611	simons	`if (!cur_area) {`
409			`printf("EXCEPTION: read out of memory (8-bit access to %.8lx)\n", memaddr);`
410			`except_handle(EXCEPT_BUSERR, cur_vadd);`
411			`temp = 0;`
412			`}`
413
414	599	simons	`if (!pending.valid && cur_area->log)`
415	587	markom	`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
416	550	markom	`if (config.debug.enabled)`
417	270	markom	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
418	239	markom	`return temp;`
419	66	lampret	`}`
420
421			`void setsim_mem32(unsigned long memaddr, unsigned long value)`
422			`{`
423	239	markom	`struct dev_memarea *dev;`
424	66	lampret
425	239	markom	`if (verify_memoryarea(memaddr)) {`
426			`switch(cur_area->granularity) {`
427	538	markom	`case 4:`
428			`cur_area->writefunc(memaddr, value);`
429	884	markom	`runtime.sim.mem_cycles += cur_area->delayw;`
430	538	markom	`break;`
431	239	markom	`case 1:`
432	251	erez	`cur_area->writefunc(memaddr , (value >> 24) & 0xFF);`
433	239	markom	`cur_area->writefunc(memaddr + 1, (value >> 16) & 0xFF);`
434	251	erez	`cur_area->writefunc(memaddr + 2, (value >> 8) & 0xFF);`
435			`cur_area->writefunc(memaddr + 3, (value ) & 0xFF);`
436	884	markom	`runtime.sim.mem_cycles += cur_area->delayw * 4;`
437	239	markom	`break;`
438			`case 2:`
439			`cur_area->writefunc(memaddr, (value >> 16) & 0xFFFF);`
440			`cur_area->writefunc(memaddr + 2, value & 0xFFFF);`
441	884	markom	`runtime.sim.mem_cycles += cur_area->delayw * 2;`
442	239	markom	`break;`
443	242	markom	`}`
444	239	markom	`} else {`
445			`printf("EXCEPTION: write out of memory (32-bit access to %.8lx)\n", memaddr);`
446	525	simons	`except_handle(EXCEPT_BUSERR, cur_vadd);`
447	239	markom	`}`
448	2	cvs	`}`
449
450	66	lampret	`void setsim_mem16(unsigned long memaddr, unsigned short value)`
451			`{`
452	538	markom	`unsigned long temp;`
453	239	markom	`if (verify_memoryarea(memaddr)) {`
454			`switch(cur_area->granularity) {`
455			`case 1:`
456			`cur_area->writefunc(memaddr, (value >> 8) & 0xFF);`
457			`cur_area->writefunc(memaddr + 1, value & 0xFF);`
458	884	markom	`runtime.sim.mem_cycles += cur_area->delayw * 2;`
459	239	markom	`break;`
460			`case 2:`
461	251	erez	`cur_area->writefunc(memaddr, value & 0xFFFF);`
462	884	markom	`runtime.sim.mem_cycles += cur_area->delayw;`
463	239	markom	`break;`
464			`case 4:`
465	538	markom	`temp = evalsim_mem32 (memaddr & ~3ul);`
466	546	simons	`temp &= 0xffff << ((memaddr & 2) ? 16 : 0);`
467			`temp \|= (unsigned long)(value & 0xffff) << ((memaddr & 2) ? 0 : 16);`
468	538	markom	`setsim_mem32 (memaddr & ~3ul, temp);`
469	239	markom	`break;`
470			`}`
471			`} else {`
472			`printf("EXCEPTION: write out of memory (16-bit access to %.8lx)\n", memaddr);`
473	525	simons	`except_handle(EXCEPT_BUSERR, cur_vadd);`
474	239	markom	`}`
475	2	cvs	`}`
476
477	66	lampret	`void setsim_mem8(unsigned long memaddr, unsigned char value)`
478			`{`
479	538	markom	`unsigned long temp;`
480	239	markom	`if (verify_memoryarea(memaddr)) {`
481	538	markom	`switch (cur_area->granularity) {`
482			`case 1:`
483	239	markom	`cur_area->writefunc(memaddr, value);`
484	884	markom	`runtime.sim.mem_cycles += cur_area->delayw;`
485	538	markom	`break;`
486			`case 2:`
487			`temp = evalsim_mem16 (memaddr & ~1ul);`
488	546	simons	`temp &= 0xff << ((memaddr & 1) ? 8 : 0);`
489			`temp \|= (unsigned short)(value & 0xff) << ((memaddr & 1) ? 0 : 8);`
490	538	markom	`setsim_mem16 (memaddr & ~1ul, temp);`
491			`break;`
492			`case 4:`
493			`temp = evalsim_mem32 (memaddr & ~3ul);`
494			`temp &= ~(0xff << (8 * (3 - (memaddr & 3))));`
495			`temp \|= (unsigned long)(value & 0xff) << (8 * (3 - (memaddr & 3)));`
496			`setsim_mem32 (memaddr & ~3ul, temp);`
497			`break;`
498	239	markom	`}`
499			`} else {`
500			`printf("EXCEPTION: write out of memory (8-bit access to %.8lx)\n", memaddr);`

Browse

Tools

Subversion Repositories or1k

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