start to move slot_load code to register_value

the iea is to iterate through register_values while reducing the slot_load to a number of Slot_to_regs
wip

lib/mom/instruction/slot_load.rb

@@ -22,7 +22,7 @@ module Mom
   #        SlotDefinition (see there)
   #
   # @right: A SlotDefinition with slots or a Mom::Constant
-  # original_source: optinally another mom instrucion that wil be passed down to created
+  # original_source: optinally another mom instruction that wil be passed down to created
   #   risc instructions. (Because SlotLoad is often used internally in mom)
   class SlotLoad < Instruction
     attr_reader :left , :right , :original_source
@@ -39,38 +39,59 @@ module Mom
     end
 
     def to_risc(compiler)
+      #puts "RISC #{self}"
       const = @right.to_register(compiler , original_source)
       left_slots = @left.slots
       case @left.known_object
       when Symbol
-        left = Risc.message_reg
-        left_index = Risc.resolve_to_index(@left.known_object , left_slots.first)
-        if left_slots.length > 1
-          # swap the existing target (with a new reg) and update the index
-          new_left = compiler.use_reg( :Object )
-          const << Risc::SlotToReg.new( original_source , left ,left_index, new_left)
-          left = new_left
-          left_index = Risc.resolve_to_index(left_slots[0] , left_slots[1] ,compiler)
-          if left_slots.length > 2
-            #same again, once more updating target
-            new_left = compiler.use_reg( :Object )
-            const << Risc::SlotToReg.new( original_source , left ,left_index, new_left)
-            left = new_left
-            left_index = Risc.resolve_to_index(left_slots[1] , left_slots[2] ,compiler)
-          end
-          raise "more slots not implemented #{left_slots}" if left_slots.length > 3
-        end
+        sym_to_risc(compiler , const)
       when Parfait::CacheEntry
         left = compiler.use_reg( :Object )
         const << Risc.load_constant(original_source, @left.known_object , left)
         left_index = Risc.resolve_to_index(:cache_entry , left_slots.first)
+        const << Risc.reg_to_slot(original_source, const.register , left, left_index)
       else
         raise "We have left #{@left.known_object}"
       end
-      const << Risc.reg_to_slot(original_source, const.register , left, left_index)
       compiler.reset_regs
       return const
     end
+
+    def sym_to_risc(compiler , const)
+      left_slots = @left.slots
+      raise "Not Message #{object}" unless @left.known_object == :message
+      left = Risc.message_reg
+      slot = left_slots.shift
+      left = left.resolve_and_add( slot , const , compiler)
+
+      #left_index = Risc.resolve_to_index(@left.known_object , left_slots.first)
+
+      const << Risc.reg_to_slot(original_source, const.register , left, left_index)
+    end
+
+    def old_sym_to_risc(compiler , const)
+      left = Risc.message_reg
+      left_slots = @left.slots
+      left_index = Risc.resolve_to_index(@left.known_object , left_slots.first)
+      if left_slots.length > 1
+        # swap the existing target (with a new reg) and update the index
+        new_left = compiler.use_reg( :Object )
+        const << Risc::SlotToReg.new( original_source , left ,left_index, new_left)
+        left = new_left
+        left_index = Risc.resolve_to_index(left_slots[0] , left_slots[1] ,compiler)
+        if left_slots.length > 2
+          #same again, once more updating target
+          new_left = compiler.use_reg( :Object )
+          const << Risc::SlotToReg.new( original_source , left ,left_index, new_left)
+          left = new_left
+          left_index = Risc.resolve_to_index(left_slots[1] , left_slots[2] ,compiler)
+        end
+        raise "more slots not implemented #{left_slots}" if left_slots.length > 3
+      end
+      const << Risc.reg_to_slot(original_source, const.register , left, left_index)
+    end
+
+
   end
 
 end

lib/risc/register_value.rb

@@ -15,6 +15,47 @@ module Risc
       @value = value
     end
 
+    # using the registers type, resolve the slot to an index
+    # Using the index and the register, add a SlotToReg to the instruction
+    def resolve_and_add(slot , instruction , compiler)
+      index = resolve_index( slot )
+      new_left = get_new_left( slot , compiler )
+      instruction << Risc::SlotToReg.new( "SlotLoad #{type}[#{slot}]" , @symbol ,index, new_left)
+      new_left
+    end
+
+    # resolve the given slot name (instance variable name) to an index using the type
+    # RegisterValue has the current type, so we just look up the index in the type
+    def resolve_index(slot)
+      #puts "TYPE #{type} obj:#{object} var:#{slot} comp:#{compiler}"
+      type = Parfait.object_space.get_type_by_class_name(@type)
+      index = type.variable_index(slot)
+      raise "Index not found for #{slot} in #{type} of type #{@type}" unless index
+      return index
+    end
+
+    # when following variables in resolve_and_add, get a new RegisterValue
+    # that represents the new value.
+    # Ie in "normal case" a the same register, with the type of the slot
+    #  (the not normal case, the first reduction, uses a new register, as we don't
+    #   overwrite the message)
+    # We get the type with resolve_new_type
+    def get_new_left(slot, compiler)
+      new_type = resolve_new_type(slot , compiler)
+      if( @symbol == :r0 )
+        new_left = compiler.use_reg( new_type )
+      else
+        new_left = RegisterValue.new( @symbol , new_type)
+      end
+      new_left
+    end
+
+    # resolve the type of the slot, by inferring from it's name
+    # Currently this is implemented in Risc.resolve_type , but code shoudl be moved here
+    def resolve_new_type(slot, compiler)
+      Risc.resolve_type(slot , compiler)
+    end
+
     def to_s
       s = "#{symbol}:#{type}"
       s += ":#{value}" if value