From 776a97986d072ee8af6ee70051d94339c4cd5ccd Mon Sep 17 00:00:00 2001 From: Torsten Ruger Date: Fri, 11 May 2018 18:36:45 +0300 Subject: [PATCH] fix instruction positioning use at as at and only compute difference when needed (to determine if there is a jump in binary) Easier to understand that way --- lib/parfait/binary_code.rb | 12 ++++---- lib/risc/machine.rb | 2 +- lib/risc/position.rb | 2 +- lib/risc/position/code_position.rb | 8 +++++- lib/risc/position/instruction_position.rb | 28 ++++++++++++++----- lib/risc/position/object_position.rb | 4 +-- lib/risc/text_writer.rb | 2 +- test/arm/helper.rb | 7 +++++ test/arm/test_call.rb | 3 +- test/arm/test_logic.rb | 6 ++-- test/arm/test_move.rb | 2 +- .../position/test_instruction_position.rb | 1 + test/risc/position/test_object_position.rb | 8 +++--- test/risc/test_machine.rb | 4 +-- 14 files changed, 60 insertions(+), 29 deletions(-) diff --git a/lib/parfait/binary_code.rb b/lib/parfait/binary_code.rb index d85a8a5e..94e94234 100644 --- a/lib/parfait/binary_code.rb +++ b/lib/parfait/binary_code.rb @@ -17,14 +17,16 @@ module Parfait end def extend_to(total_size) if total_size > self.data_length - unless @next - @next = BinaryCode.new(1) - #puts "extending #{total_size - data_length} in #{self}" - Risc::Position.reset(self) if Risc::Position.set?(self) - end + extend_one unless @next @next.extend_to(total_size - data_length) end end + def extend_one + @next = BinaryCode.new(1) + #puts "extending #{total_size - data_length} in #{self}" + Risc::Position.reset(self) if Risc::Position.set?(self) + end + def to_s "BinaryCode #{Risc::Position.set?(self) ? Risc::Position.get(self): self.object_id.to_s(16)}" end diff --git a/lib/risc/machine.rb b/lib/risc/machine.rb index 26001b63..5696a597 100644 --- a/lib/risc/machine.rb +++ b/lib/risc/machine.rb @@ -112,7 +112,7 @@ module Risc next unless method.is_a? Parfait::TypedMethod before = at Position.set( method.binary , at , method) - Position.set( method.cpu_instructions, 3 , method.binary) + Position.set( method.cpu_instructions, at + 12 , method.binary) # before = at # nekst = method.binary # while(nekst) diff --git a/lib/risc/position.rb b/lib/risc/position.rb index e0fee773..4f75a730 100644 --- a/lib/risc/position.rb +++ b/lib/risc/position.rb @@ -65,7 +65,7 @@ module Risc when Arm::Instruction , Risc::Label InstructionPosition.new(object,at , extra) else - ObjectPosition.new(at) + ObjectPosition.new(at,object) end end end diff --git a/lib/risc/position/code_position.rb b/lib/risc/position/code_position.rb index 88992e77..a5ffbc48 100644 --- a/lib/risc/position/code_position.rb +++ b/lib/risc/position/code_position.rb @@ -1,10 +1,16 @@ module Risc module Position + # BinaryCodes form a linked list + # + # We want to keep all code for a method continous, so we propagate Positions + # class CodePosition < ObjectPosition + attr_reader :code , :method + def initialize(code, pos , method) - super(pos) + super(pos,code) @code = code @method = method end diff --git a/lib/risc/position/instruction_position.rb b/lib/risc/position/instruction_position.rb index 8eec7c7b..1c02d977 100644 --- a/lib/risc/position/instruction_position.rb +++ b/lib/risc/position/instruction_position.rb @@ -1,23 +1,37 @@ module Risc module Position + # Instructions are also a linked list, but their position is not really + # the position of the object. + # Rather it is the position of the assembled code in the binary. + # (Luckily arm is sane, so this is realtively simple) + # + # Really we only need to calculate Positions at a jump, so between the + # Jump and the label it jumps too. The other instructions are "just" fill. + # But off course we need to propagate positions to get it right. + # + # Assembled instructions are kept in BinaryCode objects. + # When propagating positions we have to see that the next position assembles into + # the same BinaryCode, or else move it and the code along + # class InstructionPosition < ObjectPosition attr_reader :instruction , :binary def initialize(instruction, pos , binary) raise "not set " unless binary - super(pos) + super(pos, instruction) @instruction = instruction @binary = binary end - def init(at) + diff = at - Position.get(@binary).at + if( diff % 60 == 13*4) + @binary.extend_one unless @binary.next + @binary = @binary.next + raise "end of line " unless @binary + at = Position.get(@binary).at + 3*4 + end return unless instruction.next at += instruction.byte_length - bin = binary - if( 12 == at % 60) - at = 12 - bin = binary.next - end Position.set(instruction.next, at , binary) end diff --git a/lib/risc/position/object_position.rb b/lib/risc/position/object_position.rb index a483525b..61613af3 100644 --- a/lib/risc/position/object_position.rb +++ b/lib/risc/position/object_position.rb @@ -1,9 +1,9 @@ module Risc module Position class ObjectPosition - attr_reader :at + attr_reader :at , :object - def initialize( at ) + def initialize( at , object) @at = at raise "not int #{self}-#{at}" unless @at.is_a?(Integer) end diff --git a/lib/risc/text_writer.rb b/lib/risc/text_writer.rb index 2d620bf6..d91236ad 100644 --- a/lib/risc/text_writer.rb +++ b/lib/risc/text_writer.rb @@ -72,7 +72,7 @@ module Risc def write_any( obj ) write_any_log( obj , "Write") if @stream.length != Position.get(obj).at - puts "Write #{obj.class}:0x#{obj.object_id.to_s(16)} at 0x#{stream_position.to_s(16)} not #{Position.get(obj)}" + #puts "Write #{obj.class}:0x#{obj.object_id.to_s(16)} at 0x#{stream_position.to_s(16)} not #{Position.get(obj)}" end write_any_out(obj) write_any_log( obj , "Wrote") diff --git a/test/arm/helper.rb b/test/arm/helper.rb index 1c36a88d..ab2ecf77 100644 --- a/test/arm/helper.rb +++ b/test/arm/helper.rb @@ -5,9 +5,16 @@ require_relative "../helper" # tests are named as per assembler code, ie test_mov testing mov instruction module Arm + class FakeBin + def byte_length + 4 + end + end module ArmHelper def setup @machine = Arm::ArmMachine + @binary = FakeBin.new + Risc::Position.set(@binary , 0) end # code is what the generator spits out, at least one instruction worth (.first) diff --git a/test/arm/test_call.rb b/test/arm/test_call.rb index 989e46ac..d1888139 100644 --- a/test/arm/test_call.rb +++ b/test/arm/test_call.rb @@ -19,8 +19,9 @@ module Arm Risc.machine.boot bin = Parfait::BinaryCode.new(1) Risc::Position.set(bin , 0x20) + Risc::Position.set(@binary , 0) code = @machine.call( bin ,{} )#this jumps to the next instruction - Risc::Position.set(code , 0, 1) + Risc::Position.set(code , 0, @binary) assert_code code , :call, [0x09,0x0,0x0,0xeb] end def test_swi diff --git a/test/arm/test_logic.rb b/test/arm/test_logic.rb index 5316f8cf..14f785a7 100644 --- a/test/arm/test_logic.rb +++ b/test/arm/test_logic.rb @@ -82,7 +82,7 @@ module Arm end def test_too_big_add code = @machine.add :r1 , :r1, 0x222 - Risc::Position.set(code,0,1) + Risc::Position.set(code,0,@binary) # add 0x02 (first instruction) and then 0x220 shifted assert_code code , :add , [0x02,0x1c,0x91,0xe2] #e2 91 1e 02 # added extra instruction to add "extra" @@ -91,13 +91,13 @@ module Arm def label( pos = 0x22 + 8) l = Risc.label("some" , "Label") - Risc::Position.set(l,pos , 1) + Risc::Position.set(l,pos , @binary) l end def test_move_object code = @machine.add( :r1 , label) - Risc::Position.set(code,0,0) + Risc::Position.set(code,0,@binary) assert_code code , :add , [0x22,0x10,0x9f,0xe2] #e2 9f 10 22 end diff --git a/test/arm/test_move.rb b/test/arm/test_move.rb index fe732da9..1b3fac07 100644 --- a/test/arm/test_move.rb +++ b/test/arm/test_move.rb @@ -22,7 +22,7 @@ module Arm end def test_mov_big code = @machine.mov :r0, 0x222 # is not 8 bit and can't be rotated by the arm system in one instruction - Risc::Position.set(code,0,1) + Risc::Position.set(code,0,@binary) # mov 512(0x200) = e3 a0 0c 02 add 34(0x22) = e2 90 00 22 assert_code code , :mov , [ 0x02,0x0c,0xb0,0xe3] assert_code code.next , :add , [ 0x22,0x00,0x90,0xe2] diff --git a/test/risc/position/test_instruction_position.rb b/test/risc/position/test_instruction_position.rb index 24297221..20e64227 100644 --- a/test/risc/position/test_instruction_position.rb +++ b/test/risc/position/test_instruction_position.rb @@ -7,6 +7,7 @@ module Risc def setup Risc.machine.boot @binary = Parfait::BinaryCode.new(1) + Position.set(@binary , 0) @label = Label.new("hi","ho") end def test_set_instr diff --git a/test/risc/position/test_object_position.rb b/test/risc/position/test_object_position.rb index 9f5c7da2..b49d2179 100644 --- a/test/risc/position/test_object_position.rb +++ b/test/risc/position/test_object_position.rb @@ -6,21 +6,21 @@ module Risc class TestPositionBasic < MiniTest::Test def test_creation_ok - assert ObjectPosition.new(0) + assert ObjectPosition.new(0,self) end def test_creation_fail assert_raises {Position.new("0")} end def test_add - res = ObjectPosition.new(0) + 5 + res = ObjectPosition.new(0,self) + 5 assert_equal 5 , res end def test_sub - res = ObjectPosition.new(5) - 1 + res = ObjectPosition.new(5,self) - 1 assert_equal 4 , res end def test_sub_pos - res = ObjectPosition.new(5) - ObjectPosition.new(1) + res = ObjectPosition.new(5,self) - ObjectPosition.new(1,self) assert_equal 4 , res end def test_set diff --git a/test/risc/test_machine.rb b/test/risc/test_machine.rb index b88f0e8a..cf748f42 100644 --- a/test/risc/test_machine.rb +++ b/test/risc/test_machine.rb @@ -39,7 +39,7 @@ module Risc assert_equal Parfait::BinaryCode , @machine.binary_init.class end def test_has_jump - assert_equal "ea0011f4" , @machine.binary_init.get_word(1).to_s(16) + assert_equal "ea000fb4" , @machine.binary_init.get_word(1).to_s(16) end def test_pos_bin assert_equal "0x0" , Position.get(@machine.binary_init).to_s @@ -48,7 +48,7 @@ module Risc assert_equal 12 , Position.get(@machine.cpu_init).at end def test_cpu_at - assert_equal 3 , Position.get(@machine.cpu_init.first).at + assert_equal "0x3ee4" , Position.get(@machine.cpu_init.first).to_s end def test_cpu_bin assert_equal "0x3ed8" , Position.get(Position.get(@machine.cpu_init.first).binary).to_s