From a9196e9cd65150de5f20f841ba2660589f1516e2 Mon Sep 17 00:00:00 2001
From: Torsten Ruger <torsten@villataika.fi>
Date: Wed, 21 Mar 2018 18:54:42 +0530
Subject: [PATCH] implement simple_calls to_risc

---
 lib/mom/instruction/simple_call.rb        | 17 ++++++++++++++---
 lib/mom/instruction/slot_load.rb          |  2 +-
 test/mom/assign/test_assign_local_send.rb | 13 ++++---------
 test/vool/to_mom/test_if_condition.rb     | 13 ++++++-------
 4 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/lib/mom/instruction/simple_call.rb b/lib/mom/instruction/simple_call.rb
index 1187ac70..350f02b1 100644
--- a/lib/mom/instruction/simple_call.rb
+++ b/lib/mom/instruction/simple_call.rb
@@ -5,7 +5,7 @@ module Mom
   # actually call it.
   #
   # As the call setup is done beforehand (for both simple and cached call), the
-  # calling really means just jumping to the address. Simple.
+  # calling really means mostly jumping to the address. Simple.
   #
   class SimpleCall < Instruction
     attr_reader :method
@@ -13,8 +13,19 @@ module Mom
     def initialize(method)
       @method = method
     end
-    def to_risc(context)
-      Risc::Label.new(self,"SimpleCall")
+
+    # To call the method, we determine the jumpable address (method.binary), move that
+    # into a register and issue a FunctionCall
+    #
+    # For returning, we add a label after the call, and load it's address into the
+    # return_address of the next_message, for the ReturnSequence to pick it up.
+    def to_risc(compiler)
+      reg = compiler.use_reg(:int)
+      return_label = Risc::Label.new(self,"continue")
+      load =  SlotLoad.new([:message,:next_message,:return_address],[return_label])
+      moves = load.to_risc(compiler)
+      moves << Risc::FunctionCall.new(self, reg)
+      moves << return_label
     end
 
   end
diff --git a/lib/mom/instruction/slot_load.rb b/lib/mom/instruction/slot_load.rb
index 0c48aff0..d10c2501 100644
--- a/lib/mom/instruction/slot_load.rb
+++ b/lib/mom/instruction/slot_load.rb
@@ -102,7 +102,7 @@ module Mom
       type = known_object.respond_to?(:ct_type) ? known_object.ct_type : :int
       right = compiler.use_reg( type )
       case known_object
-      when Constant , Parfait::Object
+      when Constant , Parfait::Object , Risc::Label
         const  = Risc.load_constant(instruction, self , right)
       when Symbol
         const = Risc::SlotToReg.new( instruction , Risc.resolve_to_register(known_object) ,
diff --git a/test/mom/assign/test_assign_local_send.rb b/test/mom/assign/test_assign_local_send.rb
index b4b11335..1dbc8720 100644
--- a/test/mom/assign/test_assign_local_send.rb
+++ b/test/mom/assign/test_assign_local_send.rb
@@ -9,21 +9,16 @@ module Risc
       @input = "r = 5.mod4"
       @expect = [LoadConstant, SlotToReg, RegToSlot, LoadConstant, SlotToReg, SlotToReg ,
                  RegToSlot, LoadConstant, SlotToReg, SlotToReg, RegToSlot, LoadConstant ,
-                 SlotToReg, RegToSlot, Label, SlotToReg, SlotToReg, RegToSlot]
+                 SlotToReg, RegToSlot, LoadConstant, SlotToReg, RegToSlot, FunctionCall ,
+                 Label, SlotToReg, SlotToReg, RegToSlot]
     end
     def test_local_assign_instructions
       assert_nil msg = check_nil , msg
     end
 
-    def ttest_constant_load
+    def test_constant_load
       produced = produce_body
-      assert_equal 5 , produced.constant.known_object.value
+      assert_equal 5 , produced.next(11).constant.known_object.value
     end
-
-    def ttest_slot_move
-      produced = produce_body
-      assert_equal produced.next.register , produced.register
-    end
-
   end
 end
diff --git a/test/vool/to_mom/test_if_condition.rb b/test/vool/to_mom/test_if_condition.rb
index 5fa12079..7d3b95e0 100644
--- a/test/vool/to_mom/test_if_condition.rb
+++ b/test/vool/to_mom/test_if_condition.rb
@@ -12,19 +12,18 @@ module Vool
     end
 
     def test_condition
-      assert_equal TruthCheck , @ins.next(11).class
+      assert_equal TruthCheck , @ins.next(4).class
     end
     def test_condition_is_slot
-      assert_equal SlotDefinition , @ins.next(11).condition.class , @ins
+      assert_equal SlotDefinition , @ins.next(4).condition.class , @ins
     end
     def test_hoisted_dynamic_call
-      assert_equal DynamicCall , @ins.next(9).class
+      assert_equal SimpleCall , @ins.next(2).class
+      assert_equal :mod4 , @ins.next(2).method.name
     end
     def test_array
-      check_array [NotSameCheck, SlotLoad, MessageSetup, ArgumentTransfer, SimpleCall, SlotLoad ,
-                    Label, MessageSetup, ArgumentTransfer, DynamicCall, SlotLoad, TruthCheck ,
-                    Label, MessageSetup, ArgumentTransfer, SimpleCall, Jump, Label ,
-                    MessageSetup, ArgumentTransfer, SimpleCall, Label] , @ins
+      check_array [MessageSetup, ArgumentTransfer, SimpleCall, SlotLoad, TruthCheck, Label ,
+                    SlotLoad, Jump, Label, SlotLoad, Label] , @ins
     end
 
   end