rubyx/lib/risc/machine.rb
Torsten Ruger 1505df894a remove translation
from machine, which is quickly becoming a linker
2018-07-01 11:58:06 +03:00

162 lines
5.2 KiB
Ruby

require_relative "collector"
require_relative "binary_writer"
module Risc
# The Risc Machine is an abstraction of the register level. This is seperate from the
# actual assembler level to allow for several cpu architectures.
# The Instructions (see class Instruction) define what the machine can do (ie load/store/maths)
# From code, the next step down is Vool, then Mom (in two steps)
#
# The next step transforms to the register machine layer, which is quite close to what actually
# executes. The step after transforms to Arm, which creates executables.
#
class Machine
include Util::Logging
log_level :info
def initialize
@risc_init = nil
@constants = []
@next_address = nil
end
attr_reader :constants , :cpu_init
attr_reader :platform
# machine keeps a list of all objects and their positions.
# this is lazily created with a collector
def object_positions
Collector.collect_space if Position.positions.length < 2 #one is the label
Position.positions
end
# lazy init risc_init
def risc_init
@risc_init ||= Branch.new( "__initial_branch__" , Parfait.object_space.get_init.risc_instructions )
end
# add a constant (which get created during compilation and need to be linked)
def add_constant(const)
raise "Must be Parfait #{const}" unless const.is_a?(Parfait::Object)
@constants << const
end
# hand out a return address for use as constant the address is added
def get_address
10.times do # 10 for whole pages
@next_address = Parfait::ReturnAddress.new(0,@next_address)
add_constant( @next_address )
end unless @next_address
addr = @next_address
@next_address = @next_address.next_integer
addr
end
# To create binaries, objects (and labels) need to have a position
# (so objects can be loaded and branches know where to jump)
#
# Position in the order
# - initial jump
# - all objects
# - all code (BinaryCode objects)
# As code length may change during assembly, this way at least the objects stay
# in place and we don't have to deal with changing loading code
def position_all
#need the initial jump at 0 and then functions
Position.new(cpu_init).set(0)
code_start = position_objects( @platform.padding )
# and then everything code
position_code(code_start)
end
# go through everything that is not code (BinaryCode) and set position
# padded_length is what determines an objects (byte) length
# return final position that is stored in code_start
def position_objects(at)
# want to have the objects first in the executable
sorted = object_positions.keys.sort do |left,right|
left.class.name <=> right.class.name
end
previous = nil
sorted.each do |objekt|
next unless Position.is_object(objekt)
before = at
raise objekt.class unless( Position.set?(objekt)) #debug check
position = Position.get(objekt).set(at)
previous.position_listener(objekt) if previous
previous = position
at += objekt.padded_length
log.debug "Object #{objekt.class}:#{before.to_s(16)} len: #{(at - before).to_s(16)}"
end
at
end
# Position all BinaryCode.
#
# So that all code from one method is layed out linearly (for debugging)
# we go through methods, and then through all codes from the method
#
# start at code_start.
def position_code(code_start)
Parfait.object_space.types.values.each do |type|
next unless type.methods
type.methods.each_method do |method|
#next unless method.name == :main or method.name == :__init__
Position.log.debug "Method start #{code_start.to_s(16)} #{method.name}"
code_pos = CodeListener.init(method.binary)
InstructionListener.init(method.cpu_instructions, method.binary)
code_pos.position_listener( LabelListener.new(method.cpu_instructions))
code_pos.set(code_start)
code_start = Position.get(method.binary.last_code).next_slot
end
end
end
# Create Binary code for all methods and the initial jump
# BinaryWriter handles the writing from instructions into BinaryCode objects
#
# current (poor) design throws an exception when the assembly can't fit
# constant loads into one instruction.
#
def create_binary
methods = object_positions.keys.find_all{|obj| obj.is_a? Parfait::TypedMethod}
prerun(methods)
assemble(methods)
log.debug "BinaryInit #{cpu_init.object_id.to_s(16)}"
end
def prerun(methods)
methods.each do |method|
method.cpu_instructions.each {|i| i.precheck }
end
end
def assemble(methods)
methods.each do |method|
writer = BinaryWriter.new(method.binary)
writer.assemble(method.cpu_instructions)
end
end
def boot
initialize
Position.clear_positions
Builtin.boot_functions
self
end
end
# Module function to retrieve singleton
def self.machine
unless defined?(@machine)
@machine = Machine.new
end
@machine
end
end
require_relative "parfait_boot"