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

@@ -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

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)

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

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

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
 

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

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")

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)

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

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
 

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]

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

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

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