org/jpc/emulator/processor/DescriptorTableSegment.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.processor;
  31
  32 import java.io.*;
  33
  34 import org.jpc.emulator.StatusDumper;
  35 import org.jpc.emulator.SRLoader;
  36 import org.jpc.emulator.SRDumper;
  37 import org.jpc.emulator.memory.AddressSpace;
  38
  39 /**
  40  *
  41  * @author Chris Dennis
  42  */
  43 public class DescriptorTableSegment extends Segment
  44 {
  45     private final int base;
  46     private final long limit;
  47
  48     public void dumpStatusPartial(StatusDumper output)
  49     {
  50         super.dumpStatusPartial(output);
  51         output.println("\tbase " + base + " limit " + limit);
  52     }
  53
  54     public void dumpStatus(StatusDumper output)
  55     {
  56         if(output.dumped(this))
  57             return;
  58
  59         output.println("#" + output.objectNumber(this) + ": DescriptorTableSegment:");
  60         dumpStatusPartial(output);
  61         output.endObject();
  62     }
  63
  64     public void dumpSRPartial(SRDumper output) throws IOException
  65     {
  66         super.dumpSRPartial(output);
  67         output.dumpInt(base);
  68         output.dumpLong(limit);
  69     }
  70
  71     public DescriptorTableSegment(SRLoader input) throws IOException
  72     {
  73         super(input);
  74         base = input.loadInt();
  75         limit = input.loadLong();
  76     }
  77
  78     public DescriptorTableSegment(AddressSpace memory, int base, int limit)
  79     {
  80         super(memory, true);
  81         this.base = base;
  82         this.limit = 0xffffffffL & limit;
  83     }
  84
  85     public int getLimit()
  86     {
  87         return (int) limit;
  88     }
  89
  90     public int getBase()
  91     {
  92         return base;
  93     }
  94
  95     public int getSelector()
  96     {
  97         System.err.println("Critical error: No selector for a descriptor table segment.");
  98         throw new IllegalStateException("No selector for a descriptor table segment");
  99     }
 100
 101     public boolean setSelector(int selector)
 102     {
 103         System.err.println("Critical error: Can not set selector for a descriptor table segment.");
 104         throw new IllegalStateException("Cannot set a selector for a descriptor table segment");
 105     }
 106
 107     public void checkAddress(int offset)
 108     {
 109         if ((0xffffffffL & offset) > limit)
 110         {
 111             System.err.println("Emulated: Offset beyond end of Descriptor Table Segment: Offset=" +
 112                 Integer.toHexString(offset) + ", limit=" + Long.toHexString(limit));
 113             throw new ProcessorException(ProcessorException.Type.GENERAL_PROTECTION, offset, true);
 114         }
 115     }
 116
 117     public int translateAddressRead(int offset)
 118     {
 119         checkAddress(offset);
 120         return base + offset;
 121     }
 122
 123     public int translateAddressWrite(int offset)
 124     {
 125         checkAddress(offset);
 126         return base + offset;
 127     }
 128
 129     public int getDPL()
 130     {
 131         System.err.println("Critical error: Descriptor Table Segment getDPL().");
 132         throw new IllegalStateException("[LG]DTR getDPL(): " + getClass().toString());
 133     }
 134
 135     public int getRPL()
 136     {
 137         System.err.println("Critical error: Descriptor Table Segment getRPL().");
 138         throw new IllegalStateException("[LG]DTR getRPL(): " + getClass().toString());
 139     }
 140
 141     public void setRPL(int cpl)
 142     {
 143         System.err.println("Critical error: Descriptor Table Segment setRPL().");
 144         throw new IllegalStateException("[LG]DTR setDPL(): " + getClass().toString());
 145     }
 146
 147     public boolean getDefaultSizeFlag()
 148     {
 149         System.err.println("Critical error: Descriptor Table Segment getDefaultSizeFlag().");
 150         throw new IllegalStateException("[LG]DTR getDefaultSizeFlag(): " + getClass().toString());
 151     }
 152
 153     public int getType()
 154     {
 155         System.err.println("Critical error: Descriptor Table Segment getType().");
 156         throw new IllegalStateException("[LG]DTR getType(): " + getClass().toString());
 157     }
 158
 159     public boolean isPresent()
 160     {
 161         return true;
 162     }
 163
 164     public boolean isSystem()
 165     {
 166         return true;
 167     }
 168
 169     public void printState()
 170     {
 171         System.out.println("Descriptor Table Segment");
 172         System.out.print("base: " + Integer.toHexString(base));
 173         System.out.println("limit: " + Long.toHexString(limit));
 174     }
 175 }