Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## dioscuri.module.cpu
Class CPU

    java.lang.Object
      dioscuri.module.AbstractModule
          dioscuri.module.ModuleCPU
              dioscuri.module.cpu.CPU

All Implemented Interfaces:
  Addressable, Module

    public class CPU

extends ModuleCPU

An implementation of an Intel 8086 hardware CPU module.

Contains 8 32-bit general registers, 4 16-bit segment registers, and 2 status/control registers 'flags' and 'ip'.

Reads instruction stored in Memory and executes these using an opcode lookup-table.

See Also:
  `

  Metadata module ******************************************** general.type : cpu general.name : x86 CPU based on the Intel 8086 processor general.architecture : Von Neumann general.description : Contains 8 32-bit general registers, 4 16-bit segment registers, and 2 status/control registers 'flags' and 'ip'. general.creator : Tessella Support Services, Koninklijke Bibliotheek, Nationaal Archief of the Netherlands general.version : 1.0 general.keywords : CPU, processor, Intel, 8086 general.relations : memory, motherboard general.yearOfIntroduction : 1978 general.yearOfEnding : 1982 general.ancestor : Intel 8080 general.successor : Intel 80186 cpu.clockrateMinimum : 4.77 MHz cpu.clockrateMaximum : 10.00 MHz

  Notes: - Most instructions are implemented as 16 bit. However, a couple of them (including general purpose registers) allow 32-bit computing.

  General information about instruction format: 8086 has instruction layout:
  `

Nested Class Summary

Nested classes/interfaces inherited from interface dioscuri.interfaces.Module
`Module.Type`

Field Summary
`protected boolean` | `asyncEvent`
`protected byte[]` | `ax`
`protected byte[]` | `bp`
`protected byte[]` | `bx`
`protected int` | `codeByte`
`protected int` | `codeByte2`
`protected boolean[]` | `cr0`
`protected boolean[]` | `cr1`
`protected boolean[]` | `cr2`
`protected boolean[]` | `cr3`
`protected boolean[]` | `cr4`
`protected byte[]` | `cs`
`protected byte[]` | `cx`
`protected byte[]` | `di`
`protected Instruction[]` | `doubleByteInstructions`
`protected boolean` | `doubleWord`
`protected byte[]` | `ds`
`protected byte[]` | `dx`
`protected byte[]` | `eax`
`protected byte[]` | `ebp`
`protected byte[]` | `ebx`
`protected byte[]` | `ecx`
`protected byte[]` | `edi`
`protected byte[]` | `edx`
`protected byte[]` | `es`
`protected byte[]` | `esi`
`protected byte[]` | `esp`
`protected boolean[]` | `flags`
`protected byte[]` | `gdtr`
`protected byte[]` | `idtr`
`protected byte[]` | `ip`
`int` | `ips`
`int` | `ipus`
`protected byte[]` | `ldtr`
`protected byte[]` | `oldIP`
`protected int` | `prefixInstruction`
`protected boolean` | `prefixRep`
`protected int` | `prefixRepType`
`static int` | `REGISTER_CR0_AM`
`static int` | `REGISTER_CR0_CD`
`static int` | `REGISTER_CR0_EM`
`static int` | `REGISTER_CR0_ET`
`static int` | `REGISTER_CR0_MP`
`static int` | `REGISTER_CR0_NE`
`static int` | `REGISTER_CR0_NW`
`static int` | `REGISTER_CR0_PE`
`static int` | `REGISTER_CR0_PG`
`static int` | `REGISTER_CR0_TS`
`static int` | `REGISTER_CR0_WP`
`static int` | `REGISTER_FLAGS_AF`
`static int` | `REGISTER_FLAGS_CF`
`static int` | `REGISTER_FLAGS_DF`
`static int` | `REGISTER_FLAGS_IF`
`static int` | `REGISTER_FLAGS_IOPL1`
`static int` | `REGISTER_FLAGS_IOPL2`
`static int` | `REGISTER_FLAGS_NT`
`static int` | `REGISTER_FLAGS_OF`
`static int` | `REGISTER_FLAGS_PF`
`static int` | `REGISTER_FLAGS_SF`
`static int` | `REGISTER_FLAGS_TF`
`static int` | `REGISTER_FLAGS_ZF`
`static int` | `REGISTER_GENERAL_HIGH`
`static int` | `REGISTER_GENERAL_LOW`
`static int` | `REGISTER_HIGH`
`static int` | `REGISTER_INDEX_HIGH`
`static int` | `REGISTER_INDEX_LOW`
`static int` | `REGISTER_LOW`
`static int` | `REGISTER_SEGMENT_HIGH`
`static int` | `REGISTER_SEGMENT_LOW`
`static int` | `REGISTER_SIZE_GENERAL`
`static int` | `REGISTER_SIZE_INDEX`
`static int` | `REGISTER_SIZE_SEGMENT`
`static int` | `REGISTER_SIZE_SPECIAL`
`static int` | `SEGMENT_OVERRIDE_CS`
`static int` | `SEGMENT_OVERRIDE_DS`
`static int` | `SEGMENT_OVERRIDE_ES`
`static int` | `SEGMENT_OVERRIDE_SS`
`protected boolean` | `segmentOverride`
`protected int` | `segmentOverridePointer`
`protected byte[]` | `si`
`protected Instruction[]` | `singleByteInstructions`
`protected byte[]` | `sp`
`protected byte[]` | `ss`
`static byte[]` | `WORD_0X0001`

Fields inherited from class dioscuri.module.AbstractModule
`type`

Constructor Summary
`CPU(Emulator owner)` Class constructor specifying memory

Method Summary
`protected byte[]` | `decodeExtraRegister(int rrrsssBits)` Determine extra register based on rrr/sss bits from addressbyte. Complete register is returned to ensure pass by reference.
`protected byte[]` | `decodeMM(int addrByte)` Using mm bits from addressbyte, retrieve value of displacement (if sss indicates a memory destination).
`protected byte[]` | `decodeRegister(boolean operandWord, int rrrsssBits)` Determine register based on rrr/sss bits from addressbyte. Complete register is returned to ensure pass by reference.
`protected byte[]` | `decodeSegmentRegister(int rrrsssBits)` Determine segment register based on rrr/sss bits from addressbyte. Complete segment register is returned to ensure pass by reference.
`protected byte[]` | `decodeSSSMemDest(byte addrByte, byte[] displacement)` Determine memory destination based on sss bits from addressbyte.
`java.lang.String` | `dumpDebug(java.lang.String data)`
`java.lang.String` | `dumpRegisters()` Returns a dump of the current registers with their value
`protected byte` | `getByteFromCode()` Retrieves a single byte from the code memory segment; updates the ip by one Note: use this method only when next instruction/addressbyte/immediate is needed!
`protected byte` | `getByteFromCode(byte[] displacement)` Retrieves a byte from the code memory segment at given displacement.
`protected byte` | `getByteFromData(byte[] displacement)` Retrieves a byte from the data memory segment.
`protected byte` | `getByteFromExtra(byte[] displacement)` Retrieves a single byte from the extra memory segment.
`protected byte` | `getByteFromMemorySegment(byte addressByte, byte[] offset)` Retrieves a byte from segment memory DS or SS, which is determined from the addressbyte
`protected byte` | `getByteFromStack(byte[] displacement)` Retrieves a single byte from the stack memory segment.
`boolean` | `getCpuInstructionDebug()` Get CPU instruction debug.
`long` | `getCurrentInstructionNumber()` Retrieve current number of instruction (instructions executed so far)
`java.lang.String` | `getDump()` Return a dump of module status
`boolean` | `getFlagValue(char flagLetter)` Returns the value of a named flag.
`byte` | `getIOPortByte(int portAddress)`
`byte[]` | `getIOPortDoubleWord(int portAddress)`
`byte[]` | `getIOPortWord(int portAddress)`
`int` | `getIPS()` Get the Instructions Per Second (ips) for this CPU.
`java.lang.String` | `getNextInstructionInfo()` Retrieve string with information about next instruction to be executed
`java.lang.String` | `getRegisterHex(int register)`
`byte[]` | `getRegisterValue(java.lang.String registerName)` Returns the value of a named register.
`protected byte[]` | `getWordFromCode()` Retrieves a word from the code memory segment; updates the ip by two Note: use this method only when next instruction/addressbyte/immediate is needed!
`protected byte[]` | `getWordFromCode(byte[] displacement)` Retrieves a word from the code memory segment at given displacement Note: does not update IP
`protected byte[]` | `getWordFromData(byte[] displacement)` Retrieves a word from the data memory segment.
`protected byte[]` | `getWordFromExtra(byte[] displacement)` Retrieves a word from extra memory segment.
`protected byte[]` | `getWordFromMemorySegment(byte addressByte, byte[] offset)` Retrieves a word from segment memory DS or SS, which is determined from the addressbyte
`protected byte[]` | `getWordFromStack()` Retrieves a word from the stack; increments stack pointer SP by two.
`protected byte[]` | `getWordFromStack(byte[] displacement)` Retrieves a word from the stack segment.
`protected void` | `incrementInstructionCounter()` Increment current number of instruction by one
`protected boolean` | `initInstructionTables()` Initialise the single and double byte opcode lookup arrays with instructions corresponding to the Intel hexadecimal machinecode values.
`protected boolean` | `initRegisters()` Initialise registers
`void` | `interruptRequest(boolean value)` Set the interrupt request (IRQ).
`boolean` | `isAbnormalTermination()` Returns if CPU halted abnormally or not
`protected boolean` | `isDoubleByte32BitSupported()` Checks if 32-bit is supported by the double byte instruction Note: this instruction should only be used in debug mode, because it unnecessarily slows down the execution.
`boolean` | `isShutdown()` Returns if CPU halted due to full system shutdown or not
`java.lang.String` | `registerDump()`
`boolean` | `reset()` Reset all parameters of module.
`protected void` | `resetPrefixes()` Reset all prefixes
`protected void` | `setByteInMemorySegment(byte addressByte, byte[] disp, byte value)` Sets a byte in segment memory DS or SS, which is determined from the addressbyte
`protected void` | `setByteToCode(byte[] displacement, byte value)` Assigns a byte in the code memory segment (CS:displacement) a new value Note: this method should be avoided because it does not take care of R/M byte differences Instead, use setByteToMemorySegment() Note: does not update IP
`protected void` | `setByteToData(byte[] displacement, byte value)` Assigns a byte in the data memory segment (DS:displacement) a new value Note: this method should be avoided because it does not take care of R/M byte differences Instead, use setByteToMemorySegment()
`protected void` | `setByteToExtra(byte[] displacement, byte value)` Sets byte in memory at ES:DI in the extra memory segment
`protected void` | `setByteToStack(byte value)` Pushes a byte on the stack memory segment (SS:SP) Note: do not use this method, use setWordToMemorySegment instead
`protected void` | `setByteToStack(byte[] displacement, byte value)` Pushes a byte on the stack memory segment Note: do not use this method, use setByteToMemorySegment instead
`void` | `setCpuInstructionDebug(boolean cpuInstructionDebug)` Set the CPU instruction debug.
`void` | `setHoldRequest(boolean value, Module originator)` Sets the CPU hold mode by asserting a Hold Request. This informs the CPU to avoid using the (non-existent) bus as another device (usually via DMA) is using it; it should be scheduled as a asynchronous event in CPU.
`void` | `setIOPortByte(int portAddress, byte data)`
`void` | `setIOPortDoubleWord(int portAddress, byte[] data)`
`void` | `setIOPortWord(int portAddress, byte[] data)`
`void` | `setIPS(int ips)` Set the Instructions Per Second (ips) for this CPU.
`void` | `setIPS(int ips, int lowestUpdatePeriod)` Set the Instructions Per Second (ips) for this CPU.
`boolean` | `setRegisterValue(java.lang.String registerName, byte[] value)` Sets the value of a named register to given value.
`protected void` | `setRunning(boolean status)` Set the boolean that starts and stops the CPU loop
`protected void` | `setShutdown(boolean status)` Set shutdown status
`protected void` | `setWordInMemorySegment(byte addressByte, byte[] disp, byte[] value)` Sets a word in segment memory DS or SS, which is determined from the addressbyte
`protected void` | `setWordToCode(byte[] displacement, byte[] value)` Assigns a word in the code memory segment (CS:displacement) a new value Note: do not use this method directly, use setWordToMemorySegment instead Note: does not update IP
`protected void` | `setWordToData(byte[] displacement, byte[] value)` Assigns a word in the data memory segment (DS:displacement) a new value Note: do not use this method, use setWordToMemorySegment instead
`protected void` | `setWordToExtra(byte[] displacement, byte[] word)` Sets word in memory at ES:DI in the extra memory segment
`protected void` | `setWordToStack(byte[] value)` Pushes a word on the stack memory segment (SS:SP); decrements the stack pointer SP by two.
`protected void` | `setWordToStack(byte[] displacement, byte[] value)` Sets a word in SS segment Note: when using addressbytes, do not use this method, use setWordToMemorySegment instead
`void` | `start()` Starts the module to become active.
`java.lang.String` | `startDebug()`
`void` | `stop()` Stops the module from being active.

Methods inherited from class dioscuri.module.AbstractModule
`getConnection, getConnections, getDebugMode, getExpectedConnections, getType, isConnected, setConnection, setDebugMode`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface dioscuri.interfaces.Module
`getConnection, getConnections, getDebugMode, getExpectedConnections, getType, isConnected, setConnection, setDebugMode`

Field Detail

### asyncEvent

    protected boolean asyncEvent

### ips

    public int ips

### ipus

    public int ipus

### codeByte

    protected int codeByte

### codeByte2

    protected int codeByte2

### ax

    protected byte[] ax

### eax

    protected byte[] eax

### bx

    protected byte[] bx

### ebx

    protected byte[] ebx

### cx

    protected byte[] cx

### ecx

    protected byte[] ecx

### dx

    protected byte[] dx

### edx

    protected byte[] edx

### sp

    protected byte[] sp

### esp

    protected byte[] esp

### bp

    protected byte[] bp

### ebp

    protected byte[] ebp

### si

    protected byte[] si

### esi

    protected byte[] esi

### di

    protected byte[] di

### edi

    protected byte[] edi

### cs

    protected byte[] cs

### ds

    protected byte[] ds

### ss

    protected byte[] ss

### es

    protected byte[] es

### ip

    protected byte[] ip

### oldIP

    protected byte[] oldIP

### flags

    protected boolean[] flags

### cr0

    protected boolean[] cr0

### cr1

    protected boolean[] cr1

### cr2

    protected boolean[] cr2

### cr3

    protected boolean[] cr3

### cr4

    protected boolean[] cr4

### gdtr

    protected byte[] gdtr

### idtr

    protected byte[] idtr

### ldtr

    protected byte[] ldtr

### prefixInstruction

    protected int prefixInstruction

### prefixRep

    protected boolean prefixRep

### prefixRepType

    protected int prefixRepType

### doubleWord

    protected boolean doubleWord

### segmentOverride

    protected boolean segmentOverride

### segmentOverridePointer

    protected int segmentOverridePointer

### singleByteInstructions

    protected Instruction[] singleByteInstructions

### doubleByteInstructions

    protected Instruction[] doubleByteInstructions

### REGISTER_SIZE_GENERAL

    public static final int REGISTER_SIZE_GENERAL

See Also:
  Constant Field Values

### REGISTER_SIZE_INDEX

    public static final int REGISTER_SIZE_INDEX

See Also:
  Constant Field Values

### REGISTER_SIZE_SEGMENT

    public static final int REGISTER_SIZE_SEGMENT

See Also:
  Constant Field Values

### REGISTER_SIZE_SPECIAL

    public static final int REGISTER_SIZE_SPECIAL

See Also:
  Constant Field Values

### REGISTER_LOW

    public static final int REGISTER_LOW

See Also:
  Constant Field Values

### REGISTER_HIGH

    public static final int REGISTER_HIGH

See Also:
  Constant Field Values

### REGISTER_GENERAL_LOW

    public static final int REGISTER_GENERAL_LOW

See Also:
  Constant Field Values

### REGISTER_GENERAL_HIGH

    public static final int REGISTER_GENERAL_HIGH

See Also:
  Constant Field Values

### REGISTER_INDEX_LOW

    public static final int REGISTER_INDEX_LOW

See Also:
  Constant Field Values

### REGISTER_INDEX_HIGH

    public static final int REGISTER_INDEX_HIGH

See Also:
  Constant Field Values

### REGISTER_SEGMENT_LOW

    public static final int REGISTER_SEGMENT_LOW

See Also:
  Constant Field Values

### REGISTER_SEGMENT_HIGH

    public static final int REGISTER_SEGMENT_HIGH

See Also:
  Constant Field Values

### REGISTER_FLAGS_CF

    public static final int REGISTER_FLAGS_CF

See Also:
  Constant Field Values

### REGISTER_FLAGS_PF

    public static final int REGISTER_FLAGS_PF

See Also:
  Constant Field Values

### REGISTER_FLAGS_AF

    public static final int REGISTER_FLAGS_AF

See Also:
  Constant Field Values

### REGISTER_FLAGS_ZF

    public static final int REGISTER_FLAGS_ZF

See Also:
  Constant Field Values

### REGISTER_FLAGS_SF

    public static final int REGISTER_FLAGS_SF

See Also:
  Constant Field Values

### REGISTER_FLAGS_TF

    public static final int REGISTER_FLAGS_TF

See Also:
  Constant Field Values

### REGISTER_FLAGS_IF

    public static final int REGISTER_FLAGS_IF

See Also:
  Constant Field Values

### REGISTER_FLAGS_DF

    public static final int REGISTER_FLAGS_DF

See Also:
  Constant Field Values

### REGISTER_FLAGS_OF

    public static final int REGISTER_FLAGS_OF

See Also:
  Constant Field Values

### REGISTER_FLAGS_IOPL1

    public static final int REGISTER_FLAGS_IOPL1

See Also:
  Constant Field Values

### REGISTER_FLAGS_IOPL2

    public static final int REGISTER_FLAGS_IOPL2

See Also:
  Constant Field Values

### REGISTER_FLAGS_NT

    public static final int REGISTER_FLAGS_NT

See Also:
  Constant Field Values

### REGISTER_CR0_PE

    public static final int REGISTER_CR0_PE

See Also:
  Constant Field Values

### REGISTER_CR0_MP

    public static final int REGISTER_CR0_MP

See Also:
  Constant Field Values

### REGISTER_CR0_EM

    public static final int REGISTER_CR0_EM

See Also:
  Constant Field Values

### REGISTER_CR0_TS

    public static final int REGISTER_CR0_TS

See Also:
  Constant Field Values

### REGISTER_CR0_ET

    public static final int REGISTER_CR0_ET

See Also:
  Constant Field Values

### REGISTER_CR0_NE

    public static final int REGISTER_CR0_NE

See Also:
  Constant Field Values

### REGISTER_CR0_WP

    public static final int REGISTER_CR0_WP

See Also:
  Constant Field Values

### REGISTER_CR0_AM

    public static final int REGISTER_CR0_AM

See Also:
  Constant Field Values

### REGISTER_CR0_NW

    public static final int REGISTER_CR0_NW

See Also:
  Constant Field Values

### REGISTER_CR0_CD

    public static final int REGISTER_CR0_CD

See Also:
  Constant Field Values

### REGISTER_CR0_PG

    public static final int REGISTER_CR0_PG

See Also:
  Constant Field Values

### SEGMENT_OVERRIDE_CS

    public static final int SEGMENT_OVERRIDE_CS

See Also:
  Constant Field Values

### SEGMENT_OVERRIDE_DS

    public static final int SEGMENT_OVERRIDE_DS

See Also:
  Constant Field Values

### SEGMENT_OVERRIDE_ES

    public static final int SEGMENT_OVERRIDE_ES

See Also:
  Constant Field Values

### SEGMENT_OVERRIDE_SS

    public static final int SEGMENT_OVERRIDE_SS

See Also:
  Constant Field Values

### WORD_0X0001

    public static final byte[] WORD_0X0001

Constructor Detail

### CPU

    public CPU(Emulator owner)

  Class constructor specifying memory

  Parameters:
    `owner` -

Method Detail

### reset

    public boolean reset()

  Reset all parameters of module.

  Specified by:
    `reset` in interface `Module`
  Specified by:
    `reset` in class `AbstractModule`
  Returns:
    true iff the AbstractModule was reset properly.
  See Also:
    `AbstractModule`

### start

    public void start()

  Starts the module to become active.

  Provides an empty implementations since many of the subclasses of this abstract module class do not need a start() implementation. The ones that do, can override this method.

  Specified by:
    `start` in interface `Module`
  Overrides:
    `start` in class `AbstractModule`
  See Also:
    `Module`

### stop

    public void stop()

  Stops the module from being active.

  Provides an empty implementations since many of the subclasses of this abstract module class do not need a stop() implementation. The ones that do, can override this method.

  Specified by:
    `stop` in interface `Module`
  Overrides:
    `stop` in class `AbstractModule`
  See Also:
    `Module`

### getDump

    public java.lang.String getDump()

  Return a dump of module status

  Provides a dummy implementation since many of the subclasses of this abstract module class do not need or use a getDump() implementation. The ones that do, can override this method.

  Specified by:
    `getDump` in interface `Module`
  Overrides:
    `getDump` in class `AbstractModule`
  Returns:
    string containing a dump of this module
  See Also:
    `AbstractModule`

### dumpRegisters

    public java.lang.String dumpRegisters()

  Returns a dump of the current registers with their value

  Specified by:
    `dumpRegisters` in class `ModuleCPU`
  Returns:
    String containing a register dump
  See Also:
    `ModuleCPU`

### dumpDebug

    public java.lang.String dumpDebug(java.lang.String data)

  Parameters:
    `data` -
  Returns:
    -

### isAbnormalTermination

    public boolean isAbnormalTermination()

  Returns if CPU halted abnormally or not

  Specified by:
    `isAbnormalTermination` in class `ModuleCPU`
  Returns:
    boolean abnormalTermination true if abnormal, false otherwise
  See Also:
    `ModuleCPU`

### isShutdown

    public boolean isShutdown()

  Returns if CPU halted due to full system shutdown or not

  Specified by:
    `isShutdown` in class `ModuleCPU`
  Returns:
    boolean shutDown true if emulator should shutdown, false otherwise
  See Also:
    `ModuleCPU`

### setShutdown

    protected void setShutdown(boolean status)

  Set shutdown status

  Parameters:
    `status` - true if emulator should shutdown, false otherwise

### setHoldRequest

    public void setHoldRequest(boolean value,
                               Module originator)

  Sets the CPU hold mode by asserting a Hold Request.
  This informs the CPU to avoid using the (non-existent) bus as another device (usually via DMA) is using it; it should be scheduled as a asynchronous event in CPU.

  Specified by:
    `setHoldRequest` in class `ModuleCPU`
  Parameters:
    `value` - state of the Hold Request
    `originator` - -
  See Also:
    `ModuleCPU`

### getIPS

    public int getIPS()

  Get the Instructions Per Second (ips) for this CPU.

  Specified by:
    `getIPS` in class `ModuleCPU`
  Returns:
    the Instructions Per Second (ips) for this CPU.
  See Also:
    `ModuleCPU`

### setIPS

    public void setIPS(int ips)

  Set the Instructions Per Second (ips) for this CPU.

  Specified by:
    `setIPS` in class `ModuleCPU`
  Parameters:
    `ips` - the Instructions Per Second (ips) for this CPU.
  See Also:
    `ModuleCPU`

### setIPS

    public void setIPS(int ips,
                       int lowestUpdatePeriod)

  Set the Instructions Per Second (ips) for this CPU. Also, define what the smallest period is for sending a clockpulse (in microseconds)

  Specified by:
    `setIPS` in class `ModuleCPU`
    `lowestUpdatePeriod` - the lowest update period in microseconds
  See Also:
    `ModuleCPU`

### initRegisters

    protected boolean initRegisters()

  Initialise registers

  Specified by:
    `initRegisters` in class `ModuleCPU`
  Returns:
    true if initialisation is successful, false otherwise
  See Also:
    `ModuleCPU`

### initInstructionTables

    protected boolean initInstructionTables()

  Initialise the single and double byte opcode lookup arrays with instructions corresponding to the Intel hexadecimal machinecode values.

  Specified by:
    `initInstructionTables` in class `ModuleCPU`
  Returns:
  See Also:
    `ModuleCPU`

### setRunning

    protected void setRunning(boolean status)

  Set the boolean that starts and stops the CPU loop

  Specified by:
    `setRunning` in class `ModuleCPU`
  Parameters:
    `status` - sets the isRunning boolean
  See Also:
    `ModuleCPU`

### getRegisterValue

    public byte[] getRegisterValue(java.lang.String registerName)

  Returns the value of a named register.

  Specified by:
    `getRegisterValue` in class `ModuleCPU`
  Returns:
    int[] with value of register, null otherwise
  See Also:
    `ModuleCPU`

### setRegisterValue

    public boolean setRegisterValue(java.lang.String registerName,
                                    byte[] value)

  Sets the value of a named register to given value.

  Specified by:
    `setRegisterValue` in class `ModuleCPU`
    `value` - containing the value
  Returns:
    true if set was successful, false otherwise
  See Also:
    `ModuleCPU`

### getFlagValue

    public boolean getFlagValue(char flagLetter)

  Returns the value of a named flag.

  Parameters:
    `flagLetter` - First letter of flag name
  Returns:
    value of flag

### getNextInstructionInfo

    public java.lang.String getNextInstructionInfo()

  Retrieve string with information about next instruction to be executed

  Specified by:
    `getNextInstructionInfo` in class `ModuleCPU`
  Returns:
    string containing next instruction information
  See Also:
    `ModuleCPU`

### getCurrentInstructionNumber

    public long getCurrentInstructionNumber()

  Retrieve current number of instruction (instructions executed so far)

  Specified by:
    `getCurrentInstructionNumber` in class `ModuleCPU`
  Returns:
    long containing number of instructions
  See Also:
    `ModuleCPU`

### incrementInstructionCounter

    protected void incrementInstructionCounter()

  Increment current number of instruction by one

  Specified by:
    `incrementInstructionCounter` in class `ModuleCPU`
  See Also:
    `ModuleCPU`

### getIOPortByte

    public byte getIOPortByte(int portAddress)
                       throws ModuleException

  Returns:
  Throws:
    `ModuleException`
  See Also:
    `Addressable`

### setIOPortByte

    public void setIOPortByte(int portAddress,
                              byte data)
                       throws ModuleException

  Throws:
    `ModuleException`
  See Also:
    `Addressable`

### getIOPortWord

    public byte[] getIOPortWord(int portAddress)
                         throws ModuleException

  Returns:
  Throws:
    `ModuleException`
  See Also:
    `Addressable`

### setIOPortWord

    public void setIOPortWord(int portAddress,
                              byte[] data)
                       throws ModuleException

  Throws:
    `ModuleException`
  See Also:
    `Addressable`

### getIOPortDoubleWord

    public byte[] getIOPortDoubleWord(int portAddress)
                               throws ModuleException

  Returns:
  Throws:
    `ModuleException`
  See Also:
    `Addressable`

### setIOPortDoubleWord

    public void setIOPortDoubleWord(int portAddress,
                                    byte[] data)
                             throws ModuleException

  Throws:
    `ModuleException`
  See Also:
    `Addressable`

### interruptRequest

    public void interruptRequest(boolean value)

  Set the interrupt request (IRQ).

  Specified by:
    `interruptRequest` in class `ModuleCPU`
  See Also:
    `ModuleCPU`

### resetPrefixes

    protected void resetPrefixes()

  Reset all prefixes

### isDoubleByte32BitSupported

    protected boolean isDoubleByte32BitSupported()

  Checks if 32-bit is supported by the double byte instruction Note: this instruction should only be used in debug mode, because it unnecessarily slows down the execution. Checking is done based on a known 32-bit list. All instructions that are not on the list are assumed to be 16 bit.

  Returns:
    boolean true if 32 bit is supported, false otherwise

### getByteFromCode

    protected byte getByteFromCode()

  Retrieves a single byte from the code memory segment; updates the ip by one Note: use this method only when next instruction/addressbyte/immediate is needed!

  Returns:
    byte at memory address CS:IP

### getByteFromCode

    protected byte getByteFromCode(byte[] displacement)

  Retrieves a byte from the code memory segment at given displacement. Note: when working with addressbytes, do not use this method, use getByteFromMemorySegment instead Note: does not update IP

  Parameters:
    `displacement` - Two byte offset in the current segment
  Returns:
    byte at memory address CS:DISP

### getByteFromData

    protected byte getByteFromData(byte[] displacement)

  Retrieves a byte from the data memory segment. Note: when working with addressbytes, do not use this method, use getByteFromMemorySegment instead

  Parameters:
    `displacement` - Two byte offset in the current data segment
  Returns:
    byte at memory address DS:DISP

### getByteFromStack

    protected byte getByteFromStack(byte[] displacement)

  Retrieves a single byte from the stack memory segment. Note: when working with addressbytes, do not use this method, use getByteFromMemorySegment instead

  Parameters:
    `displacement` - Two byte offset in the current stack segment
  Returns:
    byte at memory address SS:DISP

### getByteFromExtra

    protected byte getByteFromExtra(byte[] displacement)

  Retrieves a single byte from the extra memory segment. Note: when working with addressbytes, do not use this method, use getByteFromMemorySegment instead

  Parameters:
    `displacement` -
  Returns:
    byte at memory address ES:DI

### getWordFromCode

    protected byte[] getWordFromCode()

  Retrieves a word from the code memory segment; updates the ip by two Note: use this method only when next instruction/addressbyte/immediate is needed!

  Returns:
    byte[] with word at memory address CS:IP

### getWordFromCode

    protected byte[] getWordFromCode(byte[] displacement)

  Retrieves a word from the code memory segment at given displacement Note: does not update IP

  Parameters:
    `displacement` -
  Returns:
    byte[] with word at memory address displacement

### getWordFromData

    protected byte[] getWordFromData(byte[] displacement)

  Retrieves a word from the data memory segment. Note: when working with addressbytes, do not use this method, use getWordFromMemorySegment instead

  Parameters:
    `displacement` - Two byte offset in the current data segment
  Returns:
    word at memory address DS:DISP

### getWordFromStack

    protected byte[] getWordFromStack()

  Retrieves a word from the stack; increments stack pointer SP by two. Note: when working with addressbytes, do not use this method, use getWordFromMemorySegment instead

  Returns:
    word at memory address SS:SP

### getWordFromStack

    protected byte[] getWordFromStack(byte[] displacement)

  Retrieves a word from the stack segment. Note: when working with addressbytes, do not use this method, use getWordFromMemorySegment instead

  Parameters:
    `displacement` - Two byte offset in the current stack segment
  Returns:
    word at memory address SS:DISP

### getWordFromExtra

    protected byte[] getWordFromExtra(byte[] displacement)

  Retrieves a word from extra memory segment. Note: when working with addressbytes, do not use this method, use getWordFromMemorySegment instead

  Parameters:
    `displacement` - Two byte offset in the current data segment
  Returns:
    word at memory address ES:DISP

### getByteFromMemorySegment

    protected byte getByteFromMemorySegment(byte addressByte,
                                            byte[] offset)

  Retrieves a byte from segment memory DS or SS, which is determined from the addressbyte

  Parameters:
    `addressByte` - byte whose R/M bits indicate which segment register is to be used
    `offset` - byte[] indicating displacement of word in segment
  Returns:
    byte at memory address SS:disp or DS:disp

### getWordFromMemorySegment

    protected byte[] getWordFromMemorySegment(byte addressByte,
                                              byte[] offset)

  Retrieves a word from segment memory DS or SS, which is determined from the addressbyte

  Parameters:
    `addressByte` - byte whose R/M bits indicate which segment register is to be used
    `offset` - byte[] indicating offset of word in segment
  Returns:
    word at memory address SS:disp or DS:disp

### setByteToCode

    protected void setByteToCode(byte[] displacement,
                                 byte value)

  Assigns a byte in the code memory segment (CS:displacement) a new value Note: this method should be avoided because it does not take care of R/M byte differences Instead, use setByteToMemorySegment() Note: does not update IP

  Parameters:
    `displacement` - Two byte offset in the current code segment
    `value` - New value of the byte

### setWordToCode

    protected void setWordToCode(byte[] displacement,
                                 byte[] value)

  Assigns a word in the code memory segment (CS:displacement) a new value Note: do not use this method directly, use setWordToMemorySegment instead Note: does not update IP

  Parameters:
    `displacement` - Two byte offset in the current code segment
    `value` - New value of the word

### setByteToData

    protected void setByteToData(byte[] displacement,
                                 byte value)

  Assigns a byte in the data memory segment (DS:displacement) a new value Note: this method should be avoided because it does not take care of R/M byte differences Instead, use setByteToMemorySegment()

  Parameters:
    `displacement` - Two byte offset in the current data segment
    `value` - New value of the byte

### setWordToData

    protected void setWordToData(byte[] displacement,
                                 byte[] value)

  Assigns a word in the data memory segment (DS:displacement) a new value Note: do not use this method, use setWordToMemorySegment instead

  Parameters:
    `displacement` - Two byte offset in the current data segment
    `value` - New value of the word

### setByteToExtra

    protected void setByteToExtra(byte[] displacement,
                                  byte value)

  Sets byte in memory at ES:DI in the extra memory segment

  Parameters:
    `displacement` -
    `value` -

### setWordToExtra

    protected void setWordToExtra(byte[] displacement,
                                  byte[] word)

  Sets word in memory at ES:DI in the extra memory segment

  Parameters:
    `displacement` -
    `word` - Value of word to assign

### setByteToStack

    protected void setByteToStack(byte value)

  Pushes a byte on the stack memory segment (SS:SP) Note: do not use this method, use setWordToMemorySegment instead

  Parameters:
    `value` - to be pushed on the stack

### setByteToStack

    protected void setByteToStack(byte[] displacement,
                                  byte value)

  Pushes a byte on the stack memory segment Note: do not use this method, use setByteToMemorySegment instead

  Parameters:
    `displacement` -
    `value` - to be pushed onto the stack

### setWordToStack

    protected void setWordToStack(byte[] value)

  Pushes a word on the stack memory segment (SS:SP); decrements the stack pointer SP by two. Note: do not use this method, use setWordToMemorySegment instead

  Parameters:
    `value` - word to be pushed on the stack

### setWordToStack

    protected void setWordToStack(byte[] displacement,
                                  byte[] value)

  Sets a word in SS segment Note: when using addressbytes, do not use this method, use setWordToMemorySegment instead

  Parameters:
    `displacement` - Displacement within SS segment
    `value` - word to be stored in SS

### setByteInMemorySegment

    protected void setByteInMemorySegment(byte addressByte,
                                          byte[] disp,
                                          byte value)

  Sets a byte in segment memory DS or SS, which is determined from the addressbyte

  Parameters:
    `addressByte` - byte whose R/M bits indicate which segment register is to be used
    `disp` - byte[] indicating displacement of word in segment
    `value` - byte containing value to write to segment:disp

### setWordInMemorySegment

    protected void setWordInMemorySegment(byte addressByte,
                                          byte[] disp,
                                          byte[] value)

  Sets a word in segment memory DS or SS, which is determined from the addressbyte

  Parameters:
    `addressByte` - byte whose R/M bits indicate which segment register is to be used
    `disp` - byte[] indicating displacement of word in segment
    `value` - byte[] containing value to write to segment:disp

### decodeMM

    protected byte[] decodeMM(int addrByte)

  Using mm bits from addressbyte, retrieve value of displacement (if sss indicates a memory destination).

  Parameters:
    `addrByte` - addressbyte following opcode instruction
  Returns:
    memory reference displacement indicated by extra bytes.

### decodeSSSMemDest

    protected byte[] decodeSSSMemDest(byte addrByte,
                                      byte[] displacement)

  Determine memory destination based on sss bits from addressbyte.

  Parameters:
    `addrByte` - addressbyte following opcode instruction
    `displacement` - memory reference displacement from extra bytes
  Returns:
    memory location indication by sss and displacement

### decodeRegister

    protected byte[] decodeRegister(boolean operandWord,
                                    int rrrsssBits)

  Determine register based on rrr/sss bits from addressbyte.
  Complete register is returned to ensure pass by reference.

  Parameters:
    `operandWord` - boolean indicating byte (false) or word (true) size
    `rrrsssBits` - integer value (0 - 7) based on rrr/sss bits from addressbyte
  Returns:
    register indicated by relevant bits from addressbyte

### decodeExtraRegister

    protected byte[] decodeExtraRegister(int rrrsssBits)

  Determine extra register based on rrr/sss bits from addressbyte.
  Complete register is returned to ensure pass by reference.

  Parameters:
    `rrrsssBits` - integer value (0 - 7) based on rrr/sss bits from addressbyte
  Returns:
    register indicated by relevant bits from addressbyte

### decodeSegmentRegister

    protected byte[] decodeSegmentRegister(int rrrsssBits)

  Determine segment register based on rrr/sss bits from addressbyte.
  Complete segment register is returned to ensure pass by reference.

  Parameters:
    `rrrsssBits` - integer value (0 - 7) based on rrr/sss bits from addressbyte
  Returns:
    segment register indicated by relevant bits from addressbyte

### getRegisterHex

    public java.lang.String getRegisterHex(int register)

  Specified by:
    `getRegisterHex` in class `ModuleCPU`
  Returns:
  See Also:
    `ModuleCPU`

### getCpuInstructionDebug

    public boolean getCpuInstructionDebug()

  Get CPU instruction debug.

  Specified by:
    `getCpuInstructionDebug` in class `ModuleCPU`
  Returns:
    cpuInstructionDebug.
  See Also:
    `ModuleCPU`

### setCpuInstructionDebug

    public void setCpuInstructionDebug(boolean cpuInstructionDebug)

  Set the CPU instruction debug.

  Specified by:
    `setCpuInstructionDebug` in class `ModuleCPU`
  Parameters:
    `cpuInstructionDebug` - status of instructionDebug (on/off)
  See Also:
    `ModuleCPU`

### startDebug

    public java.lang.String startDebug()

  Returns:
    -

### registerDump

    public java.lang.String registerDump()

  Returns:
    -

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD