From 836089a2495316c18789fc849cc6156447c06823 Mon Sep 17 00:00:00 2001 From: Torsten Ruger Date: Sun, 21 Jun 2015 21:00:16 +0300 Subject: [PATCH] clean up Get/SetSlot document and make arguments consistent --- lib/register/instructions/get_slot.rb | 30 +++++++++++++------ .../instructions/register_transfer.rb | 11 +++++-- lib/register/instructions/set_slot.rb | 29 ++++++++++++------ lib/register/passes/frame_implementation.rb | 4 +-- lib/register/passes/return_implementation.rb | 6 ++-- lib/register/passes/set_implementation.rb | 2 +- 6 files changed, 56 insertions(+), 26 deletions(-) diff --git a/lib/register/instructions/get_slot.rb b/lib/register/instructions/get_slot.rb index e90433f1..0206418f 100644 --- a/lib/register/instructions/get_slot.rb +++ b/lib/register/instructions/get_slot.rb @@ -1,16 +1,28 @@ module Register - # offset memory get access - # so the value to be set must be given as the first register - # the second argument holds the base address - # and the third a possible (small) offset into the "object" + + # GetSlot moves data into a register from memory. + # SetSlot moves data into memory from a register. + # Both use a base memory (a register) + + # While the virtual machine has only one instruction (Set) to move data between slots, + # the register has two, namely GetSlot and SetSlot # - # if for example the value is pointed to by a register, a VariableGet (load) is needed first + # This is because that is what cpu's can do. In programming terms this would be accessing + # an element in an array, in the case of GetSlot setting the value in the array. + + # btw: to move data between registers, use RegisterTransfer + class GetSlot < Instruction - def initialize value , reference , index = 0 - @value = value - @reference = reference + + # If you had a c array and index offset + # the instruction would do register = array[index] + # The arguments are in the order that makes sense for the Instruciton name + # So GetSlot means the slot (array and index) moves to the register (last argument) + def initialize array , index , register + @register = register + @array = array @index = index end - attr_accessor :value , :reference , :index + attr_accessor :register , :array , :index end end diff --git a/lib/register/instructions/register_transfer.rb b/lib/register/instructions/register_transfer.rb index 44d4f59b..a901dabd 100644 --- a/lib/register/instructions/register_transfer.rb +++ b/lib/register/instructions/register_transfer.rb @@ -1,7 +1,14 @@ module Register - #transfer the constents of one register to another. possibly called move in some cpus + # transfer the constents of one register to another. + # possibly called move in some cpus + # There are other instructions to move data from / to memory, namely GetSlot and SetSlot + + # Get/Set Slot move data around in vm objects, but transfer moves the objects (in the machine) + # + # Also it is used for moving temorary data + class RegisterTransfer < Instruction def initialize from , to @from = wrap_register(from) @@ -9,4 +16,4 @@ module Register end attr_reader :from, :to end -end \ No newline at end of file +end diff --git a/lib/register/instructions/set_slot.rb b/lib/register/instructions/set_slot.rb index 85c430fc..ac0a80ab 100644 --- a/lib/register/instructions/set_slot.rb +++ b/lib/register/instructions/set_slot.rb @@ -1,16 +1,27 @@ module Register - # offset memory set access - # so the value must be given as the first register - # the second argument holds the base address - # and the third a possible (small) offset into the "object" + + # SetSlot moves data into memory from a register. + # GetSlot moves data into a register from memory. + # Both use a base memory (a register) + + # While the virtual machine has only one instruction (Set) to move data between slots, + # the register has two, namely GetSlot and SetSlot # - # if for example the value is pointed to by a register, a VariableGet (load) is needed first + # This is because that is what cpu's can do. In programming terms this would be accessing + # an element in an array, in the case of SetSlot setting the register in the array. + + # btw: to move data between registers, use RegisterTransfer + class SetSlot < Instruction - def initialize value , reference , index = 0 - @value = value - @reference = reference + + # If you had a c array and index offset + # the instruction would do array[index] = register + # So SGetSlot means the register (first argument) moves to the slot (array and index) + def initialize register , array , index + @register = register + @array = array @index = index end - attr_accessor :value , :reference , :index + attr_accessor :register , :array , :index end end diff --git a/lib/register/passes/frame_implementation.rb b/lib/register/passes/frame_implementation.rb index d02109e6..fcf8a2d6 100644 --- a/lib/register/passes/frame_implementation.rb +++ b/lib/register/passes/frame_implementation.rb @@ -39,11 +39,11 @@ module Register ind = Parfait::Space.object_space.get_layout().index_of( kind ) raise "index not found for #{kind}.#{kind.class}" unless ind # load the frame/message from space by index - new_codes << GetSlot.new( frame_tmp , space_tmp , 5 ) + new_codes << GetSlot.new( space_tmp , 5 , frame_tmp ) # save the frame in real frame register new_codes << RegisterTransfer.new( RegisterReference.frame_reg , frame_tmp ) # get the next_frame - new_codes << GetSlot.new( frame_tmp , frame_tmp , 2 ) # 2 index of next_frame + new_codes << GetSlot.new( frame_tmp , 2 , frame_tmp) # 2 index of next_frame # save next frame into space new_codes << SetSlot.new( frame_tmp , space_tmp , ind) block.replace(code , new_codes ) diff --git a/lib/register/passes/return_implementation.rb b/lib/register/passes/return_implementation.rb index d02a9d9f..07d69183 100644 --- a/lib/register/passes/return_implementation.rb +++ b/lib/register/passes/return_implementation.rb @@ -8,10 +8,10 @@ module Register # move the current message to new_message new_codes << RegisterTransfer.new( slot::MESSAGE_REGISTER , slot::NEW_MESSAGE_REGISTER ) # and restore the message from saved value in new_message - new_codes << GetSlot.new( slot::MESSAGE_REGISTER , slot::NEW_MESSAGE_REGISTER , Virtual::MESSAGE_CALLER ) + new_codes << GetSlot.new( slot::NEW_MESSAGE_REGISTER , Virtual::MESSAGE_CALLER , slot::MESSAGE_REGISTER) # "roll out" self and frame into their registers - new_codes << GetSlot.new( slot::SELF_REGISTER ,slot::MESSAGE_REGISTER , Virtual::MESSAGE_SELF ) - new_codes << GetSlot.new( slot::FRAME_REGISTER ,slot::MESSAGE_REGISTER , Virtual::MESSAGE_FRAME ) + new_codes << GetSlot.new( slot::MESSAGE_REGISTER , Virtual::MESSAGE_SELF , slot::SELF_REGISTER ) + new_codes << GetSlot.new( slot::MESSAGE_REGISTER , Virtual::MESSAGE_FRAME , slot::FRAME_REGISTER ) #load the return address into pc, affecting return. (other cpus have commands for this, but not arm) new_codes << FunctionReturn.new( slot::MESSAGE_REGISTER , Virtual::MESSAGE_RETURN_ADDRESS ) block.replace(code , new_codes ) diff --git a/lib/register/passes/set_implementation.rb b/lib/register/passes/set_implementation.rb index 5afb1d90..d4f45eb6 100644 --- a/lib/register/passes/set_implementation.rb +++ b/lib/register/passes/set_implementation.rb @@ -35,7 +35,7 @@ module Register if( code.from.is_a?(Parfait::Value) or code.from.is_a?(Symbol)) move1 = LoadConstant.new( tmp , code.from ) else # while otherwise we "load" - move1 = GetSlot.new( tmp , code.from.reg , code.from.index ) + move1 = GetSlot.new( code.from.reg , code.from.index , tmp ) end move2 = SetSlot.new( tmp , to , code.to.index ) block.replace(code , [move1,move2] )