vamos

#!/usr/bin/env python2.7
#
# vamos [optoins] <amiga binary> [args ...]
#
# run an m68k AmigaOS binary
#
# written by Christian Vogelgsang (chris@vogelgsang.org)

import sys
import argparse
import os

from musashi import m68k

from amitools.vamos.CPU import CPU
from amitools.vamos.MEM import MEM
from amitools.vamos.Log import *
from amitools.vamos.Vamos import Vamos
from amitools.vamos.Exceptions import *
from amitools.vamos.AccessMemory import AccessMemory
from amitools.vamos.VamosConfig import VamosConfig
from amitools.vamos.PathManager import PathManager
from amitools.vamos.VamosRun import VamosRun
from amitools.vamos.Process import Process

# ----- classes -----

class MusashiCPU(CPU):
  def __init__(self):
    CPU.__init__(self,"musashi")
    m68k.cpu_init()
    m68k.trap_init()
  def w_reg(self,reg, val):
    m68k.set_reg(reg,val)
  def r_reg(self,reg):
    return m68k.get_reg(reg)
  def w_pc(self, val):
    m68k.set_reg(m68k.M68K_REG_PC,val)
  def r_pc(self):
    return m68k.get_reg(m68k.M68K_REG_PC)
  def w_sr(self, val):
    m68k.set_reg(m68k.M68K_REG_SR,val)
  def r_sr(sefl):
    return m68k.get_reg(m68k.M68K_REG_SR)
  def pulse_reset(self):
    m68k.pulse_reset()
  def execute(self, num_cycles):
    return m68k.execute(num_cycles)
  def end(self):
    m68k.end_timeslice()
  def trap_setup(self, func, auto_rts=False, one_shot=False):
    flags = m68k.TRAP_DEFAULT
    if auto_rts:
      flags |= m68k.TRAP_AUTO_RTS
    if one_shot:
      flags |= m68k.TRAP_ONE_SHOT
    return m68k.trap_setup(func, flags)
  def trap_free(self, tid):
    m68k.trap_free(tid)

class MusashiMEM(MEM):
  def __init__(self):
    MEM.__init__(self,"musashi")
  def init(self,ram_size_kib):
    self.ram_size = ram_size_kib * 1024
    return m68k.mem_init(ram_size_kib)
  def free(self):
    m68k.mem_free()
  def reserve_special_range(self,num_pages):
    return m68k.mem_reserve_special_range(num_pages)
  def set_special_range_read_func(self,page_addr, width, func):
    m68k.mem_set_special_range_read_func(page_addr, width, func)
  def set_special_range_write_func(self,page_addr, width, func):
    m68k.mem_set_special_range_write_func(page_addr, width, func)
  def set_mem_trace_mode(self,on):
    m68k.mem_set_trace_mode(on)
  def set_mem_trace_func(self,func):
    m68k.mem_set_trace_func(func)
  def read_ram(self,width, addr):
    return m68k.mem_ram_read(width, addr)
  def write_ram(self,width, addr, val):
    m68k.mem_ram_write(width,addr,val)
  def read_ram_block(self,addr,size,data):
    m68k.mem_ram_read_block(addr,size,data)
  def write_ram_block(self,addr,size,data):
    m68k.mem_ram_write_block(addr,size,data)
  def clear_ram_block(self,addr,size,value):
    m68k.mem_ram_clear_block(addr,size,value)
  
# ----- main -----------------------------------------------------------------
# retrieve vamos home and data dir
home_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
data_dir = os.path.join(home_dir, "data")

# --- args --
parser = argparse.ArgumentParser()
parser.add_argument('bin', help="AmigaOS binary to run")
parser.add_argument('args', nargs='*', help="AmigaOS binary arguments")
parser.add_argument('-v', '--verbose', action='store_true', default=False, help="be more verbos")
parser.add_argument('-q', '--quiet', action='store_true', default=False, help="do not output any logging")
parser.add_argument('-y', '--max-cycles', action='store', type=int, default=0, help="maximum number of cycles to execute")
parser.add_argument('-B', '--cycles-per-block', action='store', type=int, default=1000, help="cycles per block")
parser.add_argument('-l', '--logging', action='store', default=None, help="logging settings: <chan>:<level>,*:<level>,...")
parser.add_argument('-L', '--log-file', action='store', default=None, help="write all log messages to a file")
parser.add_argument('-O', '--lib-options', action='append', default=None, help="set lib options: <lib>:<key>=<value>,...")
parser.add_argument('-m', '--ram-size', action='store', default=1024, type=int, help="set RAM size in KiB")
parser.add_argument('-s', '--stack-size', action='store', default=4, help="set stack size in KiB")
parser.add_argument('-t', '--memory-trace', action='store_true', default=False, help="enable memory tracing (slower)")
parser.add_argument('-T', '--internal-memory-trace', action='store_true', default=False, help="enable internal memory tracing (slow)")
parser.add_argument('-I', '--instr-trace', action='store_true', default=False, help="enable instruction trace")
parser.add_argument('-r', '--reg-dump', action='store_true', default=False, help="add register dump to instruction trace")
parser.add_argument('-c', '--config-file', action='store', default=None, help="vamos config file")
parser.add_argument('-a', '--assign', action='append', default=None, help="add AmigaOS assign: name:[+]/sys/path[,/more/path]")
parser.add_argument('-V', '--volume', action='append', default=None, help="define AmigaOS volume: name:/abs/sys/path")
parser.add_argument('-A', '--auto-assign', action='store', default=None, help="define auto assign ami path, e.g. vol:/ami/path")
parser.add_argument('-p', '--path', action='append', default=None, help="define command search ami path, e.g. c:")
parser.add_argument('-D', '--data-dir', action='store', default=data_dir, help="set vamos data directory (default: %s)" % data_dir)
parser.add_argument('-b', '--benchmark', action='store_true', default=False, help="enable benchmarking")
parser.add_argument('-C', '--cpu', action='store', default="68000", help="Set type of CPU to emulate (68000 or 68020)")
args = parser.parse_args()

# --- init config ---
cfg = VamosConfig(extra_file=args.config_file, args=args)

# --- init logging ---
if not log_setup(cfg.logging, cfg.verbose, cfg.quiet, cfg.log_file):
  log_help()
  sys.exit(1)
cfg.log()

# ----- vamos! ---------------------------------------------------------------
cpu = MusashiCPU()
mem = MusashiMEM()
log_main.info("setting up main memory with %s KiB RAM: top=%06x" % (cfg.ram_size, cfg.ram_size * 1024))
if not mem.init(cfg.ram_size):
  log_main.error("can't allocate vamos RAM: %d KiB" % cfg.ram_size)
  sys.exit(1)
  
vamos = Vamos(mem, cpu, cfg)

# enable mem trace?
if cfg.memory_trace:
  mem.set_mem_trace_mode(1)
  mem.set_mem_trace_func(vamos.label_mgr.trace_mem)
  if not log_mem.isEnabledFor(logging.DEBUG):
    log_mem.setLevel(logging.DEBUG)
# enable internal memory trace?
if cfg.internal_memory_trace:
  AccessMemory.label_mgr = vamos.label_mgr
  if not log_mem_int.isEnabledFor(logging.INFO):
    log_mem_int.setLevel(logging.INFO)

# set invalid access handler for memory
m68k.mem_set_invalid_func(vamos.error_tracker.report_invalid_memory)

# --- setup vamos ---
if not vamos.init(cfg):
  sys.exit(1)

# --- create main process ---
proc = Process(vamos, args.bin, args.args, stack_size=cfg.stack_size*1024)
if not proc.ok:
  sys.exit(1)
vamos.set_main_process(proc)

# ------ main loop ------
# set CPU type
if cfg.cpu in ('68000', '000', '00'):
  m68k.set_cpu_type(m68k.M68K_CPU_TYPE_68000)
elif cfg.cpu in ('68020', '020', '20'):
  m68k.set_cpu_type(m68k.M68K_CPU_TYPE_68020)
else:
  log_main.error("Invalid CPU type: %s" % cfg.cpu)
  sys.exit(1)

# init cpu and initial registers
run = VamosRun(vamos, args.benchmark)
run.init_cpu()

# set reset opcode/trap handler
m68k.set_reset_instr_callback(run.reset_func)

# enable instruction trace?
def instr_hook():
  # add register dump
  if cfg.reg_dump:
    res = cpu.dump_state()
    for r in res:
      log_instr.info(r)
  # disassemble line
  pc = m68k.get_reg(m68k.M68K_REG_PC)
  label = vamos.label_mgr.get_mem_str(pc)
  txt = m68k.disassemble(pc, m68k.M68K_CPU_TYPE_68000)
  log_instr.info("%-40s  %06x    %s" % (label, pc, txt))

if cfg.instr_trace:
  if not log_instr.isEnabledFor(logging.INFO):
    log_instr.setLevel(logging.INFO)
  m68k.set_instr_hook_callback(instr_hook)

# main loop
exit_code = run.run(cfg.cycles_per_block, cfg.max_cycles)

# free process
proc.free()

# shutdown vamos
vamos.cleanup()

# clean up native memory module
mem.free()

# exit
sys.exit(exit_code)