ducky.cpu package

Subpackages

• ducky.cpu.coprocessor package
  • Submodules
    • ducky.cpu.coprocessor.control module
    • ducky.cpu.coprocessor.math_copro module
  • Module contents

Submodules

• ducky.cpu.assemble module
• ducky.cpu.instructions module
• ducky.cpu.registers module

Module contents

class ducky.cpu.CPU(machine, cpuid, memory_controller, cores=1)

Bases: ducky.interfaces.ISnapshotable, ducky.interfaces.IMachineWorker

boot()

die(exc)

halt()

load_state(state)

on_core_alive(core)

Triggered when one of cores goes alive.

on_core_halted(core)

Signal CPU that one of cores is no longer alive.

on_core_running(core)

Signal CPU that one of cores is now running.

on_core_suspended(core)

Signal CPU that one of cores is now suspended.

save_state(parent)

suspend()

wake_up()

class ducky.cpu.CPUCore(coreid, cpu, memory_controller)

Bases: ducky.interfaces.ISnapshotable, ducky.interfaces.IMachineWorker

This class represents the main workhorse, one of CPU cores. Reads instructions, executes them, has registers, caches, handles interrupts, ...

Parameters:

• coreid (int) – id of this core. Usually, it’s its serial number but it has no special meaning.
• cpu (ducky.cpu.CPU) – CPU that owns this core.
• memory_controller (ducky.mm.MemoryController) – use this controller to access main memory.

FP()

IP()

REG(reg)

SP()

backtrace()

boot()

change_runnable_state(alive=None, running=None, idle=None)

check_protected_ins()

Raise AccessViolationError if core is not running in privileged mode.

This method should be used by instruction handlers that require privileged mode, e.g. protected instructions.

Raises:AccessViolationError – if the core is not in privileged mode

check_protected_port(port)

create_frame()

Create new call stack frame. Push IP and FP registers and set FP value to SP.

destroy_frame()

Destroy current call frame. Pop FP and IP from stack, by popping FP restores previous frame.

Raises:CPUException – if current frame does not match last created frame.

die(exc)

do_int(index)

Handle software interrupt. Real software interrupts cause CPU state to be saved and new stack and register values are prepared by __enter_interrupt method, virtual interrupts are simply triggered without any prior changes of CPU state.

Parameters:index (int) – interrupt number

exit_interrupt()

Restore CPU state after running a interrupt routine. Call frame is destroyed, registers are restored, stack is returned back to memory pool.

flags

halt()

has_coprocessor(name)

init_debug_set()

irq(index)

load_state(state)

pop(*regs)

push(*regs)

raw_pop()

Pop value from stack. 4 byte number is read from address in SP, then SP is incremented by four.

Returns:popped value Return type:u32

raw_push(val)

Push value on stack. SP is decremented by four, and value is written at this new address.

Parameters:val (u32) – value to be pushed

reset(new_ip=0)

Reset core’s state. All registers are set to zero, all flags are set to zero, except HWINT flag which is set to one, and IP is set to requested value.

Parameters:new_ip (u32_t) – new IP value, defaults to zero

run()

save_state(parent)

step()

Perform one “step” - fetch next instruction, increment IP, and execute instruction’s code (see inst_* methods)

suspend()

wake_up()

class ducky.cpu.CPUCoreState

Bases: ducky.snapshot.SnapshotNode

exception ducky.cpu.CPUException(msg, core=None, ip=None)

Bases: exceptions.Exception

Base class for CPU-related exceptions.

Parameters:

• msg (string) – message describing exceptional state.
• core (ducky.cpu.CPUCore) – CPU core that raised exception, if any.
• ip (u32_t) – address of an instruction that caused exception, if any.

class ducky.cpu.CPUState(*fields)

Bases: ducky.snapshot.SnapshotNode

get_core_state_by_id(coreid)

get_core_states()

class ducky.cpu.CoreFlags

Bases: ducky.util.Flags

ducky.cpu.DEFAULT_CORE_INST_CACHE_SIZE = 256

Default size of core instruction cache, in instructions.

ducky.cpu.DEFAULT_IVT_ADDRESS = 0

Default IVT address

ducky.cpu.DEFAULT_PT_ADDRESS = 65536

Default PT address

class ducky.cpu.InstructionCache(mmu, size, *args, **kwargs)

Bases: ducky.util.LRUCache

Simple instruction cache class, based on LRU dictionary, with a limited size.

Parameters:

• core (ducky.cpu.CPUCore) – CPU core that owns this cache.
• size (int) – maximal number of entries this cache can store.

get_object(addr)

Read instruction from memory. This method is responsible for the real job of fetching instructions and filling the cache.

Parameters:addr (u24) – absolute address to read from Returns:instruction Return type:InstBinaryFormat_Master

get_object_jit(addr)

Read instruction from memory. This method is responsible for the real job of fetching instructions and filling the cache.

Parameters:addr (u24) – absolute address to read from Returns:instruction Return type:InstBinaryFormat_Master

class ducky.cpu.InterruptVector(ip=0, sp=0)

Bases: object

Interrupt vector table entry.

SIZE = 8

exception ducky.cpu.InvalidInstructionSetError(inst_set, *args, **kwargs)

Bases: ducky.cpu.CPUException

Raised when switch to unknown or invalid instruction set is requested.

Parameters:inst_set (int) – instruction set id.

exception ducky.cpu.InvalidOpcodeError(opcode, *args, **kwargs)

Bases: ducky.cpu.CPUException

Raised when unknown or invalid opcode is found in instruction.

Parameters:opcode (int) – wrong opcode.

class ducky.cpu.MMU(core, memory_controller)

Bases: ducky.interfaces.ISnapshotable

Memory management unit (aka MMU) provides a single point handling all core’s memory operations. All memory reads and writes must go through this unit, which is then responsible for all translations, access control, and caching.

Parameters:

• core (ducky.cpu.CPUCore) – parent core.
• memory_controller (ducky.mm.MemoryController) – memory controller that provides access to the main memory.

check_access(access, addr, align=None)

Check attempted access against PTE. Be aware that each check can be turned off by configuration file.

Parameters:

• access – read, write or execute.
• addr (u24) – memory address.
• align (int) – if set, operation is expected to be aligned to this boundary.

Raises:

ducky.errors.AccessViolationError – when access is denied.

full_read_u16(addr)

full_read_u32(addr, not_execute=True)

full_read_u8(addr)

full_write_u16(addr, value)

full_write_u32(addr, value)

full_write_u8(addr, value)

get_pte(addr)

Find out PTE for particular physical address. If PTE is not in internal PTE cache, it is fetched from PTE table.

Parameters:addr (u24) – memory address.

halt()

release_ptes()

reset()

set_access_methods()

Set parent core’s memory-access methods to proper shortcuts.

class ducky.cpu.StackFrame(fp)

Bases: object

ducky.cpu.cmd_bt(console, cmd)

Print current backtrace

ducky.cpu.cmd_cont(console, cmd)

Continue execution until next breakpoint is reached: cont

ducky.cpu.cmd_core_state(console, cmd)

Print core state

ducky.cpu.cmd_next(console, cmd)

Proceed to the next instruction in the same stack frame.

ducky.cpu.cmd_set_core(console, cmd)

Set core address of default core used by control commands: sc <coreid>

ducky.cpu.cmd_step(console, cmd)

Step one instruction forward

ducky.cpu.do_log_cpu_core_state(core, logger=None, disassemble=True, inst_set=None)

Log state of a CPU core. Content of its registers, and other interesting or useful internal variables are logged.

Parameters:

• core (ducky.cpu.CPUCore) – core whose state should be logged.
• logger – called for each line of output to actualy log it. By default, core’s ducky.cpu.CPUCore.DEBUG() method is used.

ducky.cpu.log_cpu_core_state(*args, **kwargs)

This is a wrapper for ducky.cpu.do_log_cpu_core_state function. Its main purpose is to be removed when debug mode is not set, therefore all debug calls of ducky.cpu.do_log_cpu_core_state will disappear from code, making such code effectively “quiet”.