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 997

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;
 
  if (config.dc.enabled)
    temp = dc_simulate_read(memaddr, 4);
  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 (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 (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;
 
  if (config.dc.enabled)
    temp = (unsigned short)dc_simulate_read(memaddr, 2);
  else {
    temp = evalsim_mem16(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 (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;
 
  if (config.dc.enabled)
    temp = (unsigned char)dc_simulate_read(memaddr, 1);
  else {
    temp = evalsim_mem8(memaddr);
    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 (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);
  }
 
  dc_simulate_write(memaddr, value, 4);
 
  if (cur_area->log)
    fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);
}
 
/* 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);
  }
 
  dc_simulate_write(memaddr, (unsigned long)value, 2);
 
  if (cur_area->log)
    fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);
}
 
/* 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);
  }
 
  dc_simulate_write(memaddr, (unsigned long)value, 1);
 
  if (cur_area->log)
    fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);
}
 
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	997	markom	`PRINTF("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);`
274	611	simons	`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	992	simons	`if (config.dc.enabled)`
310			`temp = dc_simulate_read(memaddr, 4);`
311			`else {`
312			`temp = evalsim_mem32(memaddr);`
313			`if (!cur_area) {`
314	997	markom	`PRINTF("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);`
315	992	simons	`except_handle(EXCEPT_BUSERR, cur_vadd);`
316			`temp = 0;`
317			`}`
318	611	simons	`}`
319
320	550	markom	`if (config.debug.enabled)`
321	270	markom	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
322	239	markom	`return temp;`
323	66	lampret	`}`
324
325	349	simons	`/* Returns 32-bit values from mem array. Big endian version. */`
326			`unsigned long eval_insn(unsigned long memaddr,int* breakpoint)`
327			`{`
328			`unsigned long temp;`
329			`struct dev_memarea *dev;`
330
331	547	markom	`if (config.sim.mprofile)`
332			`mprofile (memaddr, MPROF_32 \| MPROF_FETCH);`
333	532	markom	`// memaddr = simulate_ic_mmu_fetch(memaddr);`
334	525	simons	`cur_vadd = pc;`
335	550	markom	`if (config.debug.enabled)`
336	349	simons	`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
337	631	simons	`if (config.ic.enabled)`
338			`temp = ic_simulate_fetch(memaddr);`
339	992	simons	`else {`
340	631	simons	`temp = evalsim_mem32(memaddr);`
341	992	simons	`if (!cur_area) {`
342	997	markom	`PRINTF("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);`
343	992	simons	`except_handle(EXCEPT_BUSERR, cur_vadd);`
344			`temp = 0;`
345			`}`
346	611	simons	`}`
347
348	550	markom	`if (config.debug.enabled)`
349	349	simons	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
350			`return temp;`
351			`}`
352
353	2	cvs	`/* Returns 16-bit values from mem array. Big endian version. */`
354
355	123	markom	`unsigned short eval_mem16(unsigned long memaddr,int* breakpoint)`
356	2	cvs	`{`
357	239	markom	`unsigned short temp;`
358	547	markom
359			`if (config.sim.mprofile)`
360			`mprofile (memaddr, MPROF_16 \| MPROF_READ);`
361
362	538	markom	`if (memaddr & 1) {`
363			`except_handle (EXCEPT_ALIGN, memaddr);`
364			`return 0;`
365			`}`
366	574	markom
367	631	simons	`if (config.debug.enabled)`
368			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
369
370	574	markom	`cur_vadd = memaddr;`
371	631	simons
372			`memaddr = dmmu_translate(memaddr, 0);`
373	574	markom	`if (pending.valid)`
374			`return 0;`
375	66	lampret
376	992	simons	`if (config.dc.enabled)`
377			`temp = (unsigned short)dc_simulate_read(memaddr, 2);`
378			`else {`
379			`temp = evalsim_mem16(memaddr);`
380			`if (!cur_area) {`
381	997	markom	`PRINTF("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);`
382	992	simons	`except_handle(EXCEPT_BUSERR, cur_vadd);`
383			`temp = 0;`
384			`}`
385	611	simons	`}`
386
387	550	markom	`if (config.debug.enabled)`
388	270	markom	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
389	239	markom	`return temp;`
390	66	lampret	`}`
391
392	6	lampret	`/* Returns 8-bit values from mem array. */`
393	2	cvs
394	123	markom	`unsigned char eval_mem8(unsigned long memaddr,int* breakpoint)`
395	221	markom	`{`
396	631	simons	`unsigned char temp;`
397	547	markom
398			`if (config.sim.mprofile)`
399			`mprofile (memaddr, MPROF_8 \| MPROF_READ);`
400
401	631	simons	`if (config.debug.enabled)`
402			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
403
404	525	simons	`cur_vadd = memaddr;`
405	631	simons
406			`memaddr = dmmu_translate(memaddr, 0);`
407	458	simons	`if (pending.valid)`
408			`return 0;`
409	6	lampret
410	992	simons	`if (config.dc.enabled)`
411			`temp = (unsigned char)dc_simulate_read(memaddr, 1);`
412			`else {`
413			`temp = evalsim_mem8(memaddr);`
414			`if (!cur_area) {`
415	997	markom	`PRINTF("EXCEPTION: read out of memory (8-bit access to %.8lx)\n", memaddr);`
416	992	simons	`except_handle(EXCEPT_BUSERR, cur_vadd);`
417			`temp = 0;`
418			`}`
419	611	simons	`}`
420
421	550	markom	`if (config.debug.enabled)`
422	270	markom	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
423	239	markom	`return temp;`
424	66	lampret	`}`
425
426			`void setsim_mem32(unsigned long memaddr, unsigned long value)`
427			`{`
428	239	markom	`struct dev_memarea *dev;`
429	66	lampret
430	239	markom	`if (verify_memoryarea(memaddr)) {`
431			`switch(cur_area->granularity) {`
432	538	markom	`case 4:`
433			`cur_area->writefunc(memaddr, value);`
434	884	markom	`runtime.sim.mem_cycles += cur_area->delayw;`
435	538	markom	`break;`
436	239	markom	`case 1:`
437	251	erez	`cur_area->writefunc(memaddr , (value >> 24) & 0xFF);`
438	239	markom	`cur_area->writefunc(memaddr + 1, (value >> 16) & 0xFF);`
439	251	erez	`cur_area->writefunc(memaddr + 2, (value >> 8) & 0xFF);`
440			`cur_area->writefunc(memaddr + 3, (value ) & 0xFF);`
441	884	markom	`runtime.sim.mem_cycles += cur_area->delayw * 4;`
442	239	markom	`break;`
443			`case 2:`
444			`cur_area->writefunc(memaddr, (value >> 16) & 0xFFFF);`
445			`cur_area->writefunc(memaddr + 2, value & 0xFFFF);`
446	884	markom	`runtime.sim.mem_cycles += cur_area->delayw * 2;`
447	239	markom	`break;`
448	242	markom	`}`
449	239	markom	`} else {`
450	997	markom	`PRINTF("EXCEPTION: write out of memory (32-bit access to %.8lx)\n", memaddr);`
451	525	simons	`except_handle(EXCEPT_BUSERR, cur_vadd);`
452	239	markom	`}`
453	2	cvs	`}`
454
455	66	lampret	`void setsim_mem16(unsigned long memaddr, unsigned short value)`
456			`{`
457	538	markom	`unsigned long temp;`
458	239	markom	`if (verify_memoryarea(memaddr)) {`
459			`switch(cur_area->granularity) {`
460			`case 1:`
461			`cur_area->writefunc(memaddr, (value >> 8) & 0xFF);`
462			`cur_area->writefunc(memaddr + 1, value & 0xFF);`
463	884	markom	`runtime.sim.mem_cycles += cur_area->delayw * 2;`
464	239	markom	`break;`
465			`case 2:`
466	251	erez	`cur_area->writefunc(memaddr, value & 0xFFFF);`
467	884	markom	`runtime.sim.mem_cycles += cur_area->delayw;`
468	239	markom	`break;`
469			`case 4:`
470	538	markom	`temp = evalsim_mem32 (memaddr & ~3ul);`
471	546	simons	`temp &= 0xffff << ((memaddr & 2) ? 16 : 0);`
472			`temp \|= (unsigned long)(value & 0xffff) << ((memaddr & 2) ? 0 : 16);`
473	538	markom	`setsim_mem32 (memaddr & ~3ul, temp);`
474	239	markom	`break;`
475			`}`
476			`} else {`
477	997	markom	`PRINTF("EXCEPTION: write out of memory (16-bit access to %.8lx)\n", memaddr);`
478	525	simons	`except_handle(EXCEPT_BUSERR, cur_vadd);`
479	239	markom	`}`
480	2	cvs	`}`
481
482	66	lampret	`void setsim_mem8(unsigned long memaddr, unsigned char value)`
483			`{`
484	538	markom	`unsigned long temp;`
485	239	markom	`if (verify_memoryarea(memaddr)) {`
486	538	markom	`switch (cur_area->granularity) {`
487			`case 1:`
488	239	markom	`cur_area->writefunc(memaddr, value);`
489	884	markom	`runtime.sim.mem_cycles += cur_area->delayw;`
490	538	markom	`break;`
491			`case 2:`
492			`temp = evalsim_mem16 (memaddr & ~1ul);`
493	546	simons	`temp &= 0xff << ((memaddr & 1) ? 8 : 0);`
494			`temp \|= (unsigned short)(value & 0xff) << ((memaddr & 1) ? 0 : 8);`
495	538	markom	`setsim_mem16 (memaddr & ~1ul, temp);`
496			`break;`
497			`case 4:`
498			`temp = evalsim_mem32 (memaddr & ~3ul);`
499			`temp &= ~(0xff << (8 * (3 - (memaddr & 3))));`
500			`temp \|= (unsigned long)(value & 0xff) << (8 * (3 - (memaddr & 3)));`

Browse

Tools

Subversion Repositories or1k

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