ruby-x/rubyx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename risc_value to register_value

Browse Source 
almost to register, but it still carries that value
This commit is contained in:
Torsten Ruger
2018-06-29 11:39:07 +03:00
parent 606c7bf906
commit d50893bb0f
21 changed files with 67 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
lib/risc/builder.rb
View File

@ -162,7 +162,7 @@ module Risc
# by the slots. All data (at any time) is in one of the instance variables of these two
# objects. Risc defines module methods with the same names (and _reg)
def self.resolve_to_register( reference )
return reference if reference.is_a?(RiscValue)
return reference if reference.is_a?(RegisterValue)
case reference
when :message
return message_reg
@ -175,7 +175,7 @@ module Risc
# The first arg is a class name (possibly lowercase) and the second an instance variable name.
def self.resolve_type( object , compiler )
object = object.type if object.is_a?(RiscValue)
object = object.type if object.is_a?(RegisterValue)
case object
when :name
type = Parfait.object_space.get_class_by_name( :Word ).instance_type
@ -206,7 +206,7 @@ module Risc
# The class can be mapped to a register, and so we get a memory address (reg+index)
# Third arg, compiler, is only needed to resolve receiver/arguments/frame
def self.resolve_to_index(object , variable_name ,compiler = nil)
return variable_name if variable_name.is_a?(Integer) or variable_name.is_a?(RiscValue)
return variable_name if variable_name.is_a?(Integer) or variable_name.is_a?(RegisterValue)
type = resolve_type(object , compiler)
index = type.variable_index(variable_name)
raise "Index not found for #{variable_name} in #{object} of type #{type}" unless index

4
lib/risc/builtin/object.rb
View File

@ -104,12 +104,12 @@ module Risc
# This relies on linux to save and restore all registers
#
def save_message(builder)
r8 = RiscValue.new( :r8 , :Message)
r8 = RegisterValue.new( :r8 , :Message)
builder.add_code Risc.transfer("save_message", Risc.message_reg , r8 )
end
def restore_message(builder)
r8 = RiscValue.new( :r8 , :Message)
r8 = RegisterValue.new( :r8 , :Message)
return_tmp = builder.compiler.use_reg :fixnum
source = "_restore_message"
# get the sys return out of the way

2
lib/risc/builtin/word.rb
View File

@ -9,7 +9,7 @@ module Risc
builder = compiler.builder(true, compiler.method)
builder.add_slot_to_reg( "putstring" , :message , :receiver , :new_message )
index = Parfait::Word.get_length_index
reg = RiscValue.new(:r2 , :Integer)
reg = RegisterValue.new(:r2 , :Integer)
builder.add_slot_to_reg( "putstring" , :new_message , index , reg )
Risc::Builtin::Object.emit_syscall( builder , :putstring )
compiler.add_mom( Mom::ReturnSequence.new)

2
lib/risc/instructions/function_return.rb
View File

@ -7,7 +7,7 @@ module Risc
def initialize( source , register )
super(source)
@register = register
raise "Not register #{register}" unless RiscValue.look_like_reg(register)
raise "Not register #{register}" unless RegisterValue.look_like_reg(register)
end
attr_reader :register

6
lib/risc/instructions/getter.rb
View File

@ -23,9 +23,9 @@ module Risc
@index = index
@register = register
raise "index #{index}" if index.is_a?(Numeric) and index < 0
raise "Not integer or reg #{index}" unless index.is_a?(Numeric) or RiscValue.look_like_reg(index)
raise "Not register #{register}" unless RiscValue.look_like_reg(register)
raise "Not register #{array}" unless RiscValue.look_like_reg(array)
raise "Not integer or reg #{index}" unless index.is_a?(Numeric) or RegisterValue.look_like_reg(index)
raise "Not register #{register}" unless RegisterValue.look_like_reg(register)
raise "Not register #{array}" unless RegisterValue.look_like_reg(array)
end
attr_accessor :array , :index , :register

2
lib/risc/instructions/load_constant.rb
View File

@ -10,7 +10,7 @@ module Risc
@register = register
@constant = constant
raise "Not Constant #{constant}" if constant.is_a?(Mom::SlotDefinition)
raise "Not register #{register}" unless RiscValue.look_like_reg(register)
raise "Not register #{register}" unless RegisterValue.look_like_reg(register)
end
attr_accessor :register , :constant

2
lib/risc/instructions/load_data.rb
View File

@ -13,7 +13,7 @@ module Risc
@register = register
@constant = constant
raise "Not Integer #{constant}" unless constant.is_a?(Integer)
raise "Not register #{register}" unless RiscValue.look_like_reg(register)
raise "Not register #{register}" unless RegisterValue.look_like_reg(register)
end
attr_accessor :register , :constant

4
lib/risc/instructions/operator_instruction.rb
View File

@ -17,8 +17,8 @@ module Risc
raise "unsuported operator :#{operator}:" unless Risc.operators.include?(operator)
@left = left
@right = right
raise "Not register #{left}" unless RiscValue.look_like_reg(left)
raise "Not register #{right}" unless RiscValue.look_like_reg(right)
raise "Not register #{left}" unless RegisterValue.look_like_reg(left)
raise "Not register #{right}" unless RegisterValue.look_like_reg(right)
end
attr_reader :operator, :left , :right

6
lib/risc/instructions/setter.rb
View File

@ -22,9 +22,9 @@ module Risc
@array = array
@index = index
# raise "index 0 " if index < 0
raise "Not integer or reg #{index}" unless index.is_a?(Numeric) or RiscValue.look_like_reg(index)
raise "Not register #{register}" unless RiscValue.look_like_reg(register)
raise "Not register #{array}" unless RiscValue.look_like_reg(array)
raise "Not integer or reg #{index}" unless index.is_a?(Numeric) or RegisterValue.look_like_reg(index)
raise "Not register #{register}" unless RegisterValue.look_like_reg(register)
raise "Not register #{array}" unless RegisterValue.look_like_reg(array)
end
attr_accessor :register , :array , :index

4
lib/risc/instructions/transfer.rb
View File

@ -20,8 +20,8 @@ module Risc
super(source)
@from = from
@to = to
raise "Fix me #{from}" unless from.is_a? RiscValue
raise "Fix me #{to}" unless to.is_a? RiscValue
raise "Fix me #{from}" unless from.is_a? RegisterValue
raise "Fix me #{to}" unless to.is_a? RegisterValue
end
attr_reader :from, :to

6
lib/risc/interpreter.rb
View File

@ -70,8 +70,8 @@ module Risc
end
def get_register( reg )
reg = reg.symbol if reg.is_a? Risc::RiscValue
raise "Not a register #{reg}" unless Risc::RiscValue.look_like_reg(reg)
reg = reg.symbol if reg.is_a? Risc::RegisterValue
raise "Not a register #{reg}" unless Risc::RegisterValue.look_like_reg(reg)
@registers[reg]
end
@ -87,7 +87,7 @@ module Risc
@flags[:minus] = false
end
return if old === val
reg = reg.symbol if reg.is_a? Risc::RiscValue
reg = reg.symbol if reg.is_a? Risc::RegisterValue
val = Parfait.object_space.nil_object if val.nil? #because that's what real code has
@registers[reg] = val
trigger(:register_changed, reg , old , val)

28
lib/risc/risc_value.rb → lib/risc/register_value.rb
View File

@ -1,8 +1,8 @@
module Risc
# RiscValue is like a variable name, a storage location. The location is a register off course.
# RegisterValue is like a variable name, a storage location. The location is a register off course.
class RiscValue
class RegisterValue
attr_reader :symbol , :type , :value
@ -26,7 +26,7 @@ module Risc
end
def self.look_like_reg is_it
return true if is_it.is_a? RiscValue
return true if is_it.is_a? RegisterValue
return false unless is_it.is_a? Symbol
if( [:lr , :pc].include? is_it )
return true
@ -40,7 +40,7 @@ module Risc
def == other
return false if other.nil?
return false if other.class != RiscValue
return false if other.class != RegisterValue
symbol == other.symbol
end
@ -49,7 +49,7 @@ module Risc
int = @symbol[1,3].to_i
raise "No more registers #{self}" if int > 11
sym = "r#{int + 1}".to_sym
RiscValue.new( sym , type, value)
RegisterValue.new( sym , type, value)
end
def rxf_reference_name
@ -57,16 +57,16 @@ module Risc
end
# can't overload "=" , so use shift for it.
# move the right side to the left. Left (this) is a RiscValue
# move the right side to the left. Left (this) is a RegisterValue
# right value may be
# - constant (Parfait object) , resulting in a LoadConstant
# - another RiscValue, resulting in a Transfer instruction
# - another RegisterValue, resulting in a Transfer instruction
# - an RValue, resulting in an SlotToReg
def <<( right )
case right
when Parfait::Object , Symbol
ins = Risc.load_constant("#{right.class} to #{self.type}" , right , self)
when RiscValue
when RegisterValue
ins = Risc.transfer("#{right.type} to #{self.type}" , right , self)
when RValue
ins = Risc.slot_to_reg("#{right.register.type}[#{right.index}] -> #{self.type}" , right.register , right.index , self)
@ -78,7 +78,7 @@ module Risc
end
def -( right )
raise "operators only on registers, not #{right.class}" unless right.is_a? RiscValue
raise "operators only on registers, not #{right.class}" unless right.is_a? RegisterValue
op = Risc.op("#{self.type} - #{right.type}", :- , self , right )
builder.add_code(op) if builder
op
@ -92,7 +92,7 @@ module Risc
end
end
# Just a struct, see comment for [] of RiscValue
# Just a struct, see comment for [] of RegisterValue
#
class RValue
attr_reader :register , :index , :builder
@ -103,7 +103,7 @@ module Risc
# fullfil the objects purpose by creating a RegToSlot instruction from
# itself (the slot) and the register given
def <<( reg )
raise "not reg #{reg}" unless reg.is_a?(RiscValue)
raise "not reg #{reg}" unless reg.is_a?(RegisterValue)
reg_to_slot = Risc.reg_to_slot("#{reg.type} -> #{register.type}[#{index}]" , reg , register, index)
builder.add_code(reg_to_slot) if builder
reg_to_slot
@ -113,19 +113,19 @@ module Risc
# The register we use to store the current message object is :r0
def self.message_reg
RiscValue.new :r0 , :Message
RegisterValue.new :r0 , :Message
end
# The register we use to store the new message object is :r3
# The new message is the one being built, to be sent
def self.new_message_reg
RiscValue.new :r1 , :Message
RegisterValue.new :r1 , :Message
end
# The first scratch register. There is a next_reg_use to get a next and next.
# Current thinking is that scratch is schatch between instructions
def self.tmp_reg( type , value = nil)
RiscValue.new :r1 , type , value
RegisterValue.new :r1 , type , value
end
end