rubyx/lib/risc
Torsten Ruger a350325b6b fix function call and simple call logic
Before creating DynamicJump, the FunctionCall got a register for a
possible jump address. Now that is handled by DynamicJump and
FunctionCall just needs the method, from which it determines the
binaryCode address
2018-05-19 12:21:20 +03:00
..
builtin fix function call and simple call logic 2018-05-19 12:21:20 +03:00
instructions fix function call and simple call logic 2018-05-19 12:21:20 +03:00
position random checkin 2018-05-14 12:38:44 +03:00
binary_writer.rb another million index fixes 2018-05-14 15:17:04 +03:00
boot.rb remove unused methods 2018-05-14 20:50:52 +03:00
builder.rb another million index fixes 2018-05-14 15:17:04 +03:00
collector.rb random checkin 2018-05-14 12:38:44 +03:00
instruction.rb let builder pass the source down, but inly once 2018-04-18 19:27:46 +03:00
interpreter_platform.rb fix interpreter to use positions 2018-05-17 20:14:59 +03:00
interpreter.rb fix function call and simple call logic 2018-05-19 12:21:20 +03:00
machine.rb make the interpreter platform 2018-05-17 09:31:36 +03:00
method_compiler.rb pass a source into the builder 2018-04-18 19:12:30 +03:00
padding.rb rename register to risc 2017-01-19 09:02:29 +02:00
platform.rb make the interpreter platform 2018-05-17 09:31:36 +03:00
position.rb getter by position 2018-05-17 20:13:33 +03:00
README.md polish docs 2018-03-11 16:11:15 +05:30
risc_value.rb random checkin 2018-05-14 12:38:44 +03:00
text_writer.rb another million index fixes 2018-05-14 15:17:04 +03:00

Risc Machine

The RiscMachine, is an abstract machine with registers. Think of it as an arm machine with normal instruction names. It is not however an abstraction of existing hardware, but only of that subset that we need.

Our primary objective is to compile typed code to this level, so the register machine has:

  • object access instructions
  • object load
  • object oriented call semantics
  • extended (and extensible) branching
  • normal integer operators (but no sub word instructions)

All data is in objects.

The register machine is aware of Parfait objects, and specifically uses Message and Frame to express call semantics.

Calls and syscalls

The RiscMachine only uses 1 fixed register, the currently worked on Message. (and assumes a program counter and flags, neither of which are directly manipulated)

There is no stack, rather messages form a linked list, and preparing to call, the data is pre-filled into the next message. Calling then means moving the new message to the current one and jumping to the address of the method. Returning is the somewhat reverse process.

Syscalls are implemented by one Syscall instruction. The Risc machine does not specify/limit the meaning or number of syscalls. This is implemented by the level below, eg the arm/interpreter.

Interpreter

There is an interpreter that can interpret compiled register machine programs. This is very handy for debugging (and nothing else).

Even more handy is the graphical interface for the interpreter, which is in it's own repository: rubyx-debugger.

Arm / Elf

There is also a (very straightforward) transformation to arm instructions. Together with the also quite minimal elf module, arm binaries can be produced.

These binaries have no external dependencies and in fact can not even call c at the moment (only syscalls :-)).