org/jpc/emulator/TraceTrap.java

   1 /*
   2     JPC-RR: A x86 PC Hardware Emulator
   3     Release 1
   4
   5     Copyright (C) 2007-2009 Isis Innovation Limited
   6     Copyright (C) 2009 H. Ilari Liusvaara
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License version 2 as published by
  10     the Free Software Foundation.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License along
  18     with this program; if not, write to the Free Software Foundation, Inc.,
  19     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20
  21     Based on JPC x86 PC Hardware emulator,
  22     A project from the Physics Dept, The University of Oxford
  23
  24     Details about original JPC can be found at:
  25
  26     www-jpc.physics.ox.ac.uk
  27
  28 */
  29
  30 package org.jpc.emulator;
  31
  32 import org.jpc.emulator.processor.Processor;
  33 import java.io.*;
  34
  35 public class TraceTrap extends AbstractHardwareComponent implements TimerResponsive
  36 {
  37     private long traceFlags;
  38     private boolean trapActive;
  39     private Timer trapTimer;
  40     private Processor processor;
  41     public final static long TRACE_STOP_VRETRACE_START = 0x00000001;
  42     public final static long TRACE_STOP_VRETRACE_END = 0x00000002;
  43     public final static long TRACE_STOP_IMMEDIATE = 0x80000000;
  44
  45     public TraceTrap()
  46     {
  47         traceFlags = 0;
  48         trapActive = false;
  49         trapTimer = null;
  50     }
  51
  52     public void setTrapTime(long trapTime)
  53     {
  54         trapTimer.setExpiry(trapTime);
  55     }
  56
  57     public void clearTrapTime()
  58     {
  59         trapTimer.disable();
  60     }
  61
  62     public synchronized boolean getAndClearTrapActive()
  63     {
  64        boolean tmp = trapActive;
  65        trapActive = false;
  66        processor.eflagsMachineHalt = false;
  67        return tmp;
  68     }
  69
  70     public synchronized void setTrapFlag(long flag, boolean status)
  71     {
  72         if(status)
  73             traceFlags |= flag;
  74         else
  75             traceFlags &= ~flag;
  76         System.err.println("Informational: Trap flags now " + traceFlags + ".");
  77     }
  78
  79     public synchronized void setTrapFlags(long flags)
  80     {
  81         long oldFlags = traceFlags;
  82         traceFlags = flags;
  83         if(oldFlags != traceFlags)
  84             System.err.println("Informational: Trap flags now " + traceFlags + ".");
  85     }
  86
  87     public synchronized long getTrapFlags()
  88     {
  89         return traceFlags;
  90     }
  91
  92     public synchronized void doPotentialTrap(long flag)
  93     {
  94         if(((traceFlags | TRACE_STOP_IMMEDIATE) & flag) != 0) {
  95             System.err.println("Informational: Doing trap because of " + (traceFlags & flag) + ".");
  96             trapActive = true;
  97             processor.eflagsMachineHalt = true;
  98         }
  99     }
 100
 101     public boolean initialised()
 102     {
 103         return (trapTimer != null && processor != null);
 104     }
 105
 106     public boolean updated()
 107     {
 108         return (trapTimer != null && processor != null);
 109     }
 110
 111     public void updateComponent(HardwareComponent component)
 112     {
 113         //Nothing to do here.
 114     }
 115
 116     public void acceptComponent(HardwareComponent component)
 117     {
 118         if((component instanceof Clock) && component.initialised())
 119             trapTimer = ((Clock)component).newTimer(this);
 120         if((component instanceof Processor) && component.initialised())
 121             processor = (Processor)component;
 122     }
 123
 124     public void dumpStatusPartial(StatusDumper output)
 125     {
 126         super.dumpStatusPartial(output);
 127         //As PC can't be savestated when running and traps only matter when its running, don't savestate the
 128         //traps.
 129     }
 130
 131     public void dumpStatus(StatusDumper output)
 132     {
 133         if(output.dumped(this))
 134             return;
 135
 136         output.println("#" + output.objectNumber(this) + ": TraceTrap:");
 137         dumpStatusPartial(output);
 138         output.endObject();
 139     }
 140
 141     public void dumpSRPartial(SRDumper output) throws IOException
 142     {
 143         super.dumpSRPartial(output);
 144         output.dumpObject(processor);
 145         output.dumpObject(trapTimer);
 146     }
 147
 148     public TraceTrap(SRLoader input) throws IOException
 149     {
 150         super(input);
 151         processor = (Processor)input.loadObject();
 152         trapTimer = (Timer)input.loadObject();
 153     }
 154
 155     public void callback()
 156     {
 157         doPotentialTrap(TRACE_STOP_IMMEDIATE);
 158     }
 159
 160     public int getTimerType()
 161     {
 162         return 8;
 163     }
 164
 165 }