From eed9ba082fbb5dfe61905eab6009b8cecf6b565b Mon Sep 17 00:00:00 2001 From: Torsten Date: Sun, 8 Mar 2020 12:05:25 +0200 Subject: [PATCH] Fix div10 and test fix and use load_data (similar to load_constant) and integrate into load_object when appropriate (ie for integers) --- lib/risc/callable_compiler.rb | 11 +++- lib/risc/instructions/load_data.rb | 7 +- lib/slot_machine/macro/div10.rb | 2 +- test/risc/instructions/test_load_data.rb | 24 +++++++ test/risc/test_callable_compiler.rb | 5 ++ test/slot_machine/macro/test_div10.rb | 81 ++++++++++++------------ 6 files changed, 85 insertions(+), 45 deletions(-) create mode 100644 test/risc/instructions/test_load_data.rb diff --git a/lib/risc/callable_compiler.rb b/lib/risc/callable_compiler.rb index d64d9245..e070ce14 100644 --- a/lib/risc/callable_compiler.rb +++ b/lib/risc/callable_compiler.rb @@ -90,12 +90,19 @@ module Risc copied end - # Load a constant, meaning create a LoadConstant instruction for the constant + # Load a constant, meaning create a LoadConstant or LoadData instruction for the + # given constant. Integers create LoadData (meaning the integer is encoded into + # the actual instruction), Parfait::Objects create LoadConstant, where a pointer + # to the object is loaded. # add the instruction to the code and return the register_value that was created # for further use # register may be passed in (epecially in mcro building) as second arg def load_object( object , into = nil) - ins = Risc.load_constant("load to #{object}" , object , into) + if(object.is_a? Integer) + ins = Risc.load_data("load data #{object}" , object , into) + else + ins = Risc.load_constant("load to #{object}" , object , into) + end ins.register.set_compiler(self) add_code ins # todo for constants (not objects) diff --git a/lib/risc/instructions/load_data.rb b/lib/risc/instructions/load_data.rb index 58ab2d97..43a9286e 100644 --- a/lib/risc/instructions/load_data.rb +++ b/lib/risc/instructions/load_data.rb @@ -22,7 +22,10 @@ module Risc end end - def self.load_data( source , constant , register ) - LoadData.new( source , constant , register) + def self.load_data( source , value , register = nil ) + raise "can only load integers, not #{value}" unless value.is_a?(Integer) + type = Parfait.object_space.get_type_by_class_name(:Integer) + register = RegisterValue.new( "fix_#{value}".to_sym , type ) unless register + LoadData.new( source , value , register) end end diff --git a/lib/slot_machine/macro/div10.rb b/lib/slot_machine/macro/div10.rb index 5395da08..c09c4e74 100644 --- a/lib/slot_machine/macro/div10.rb +++ b/lib/slot_machine/macro/div10.rb @@ -12,7 +12,7 @@ module SlotMachine transfer( integer_self , integer_1) transfer( integer_self , integer_reg) - load_object( Parfait::Integer.new(1) , integer_const) + load_object( 1 , integer_const) integer_1.op :>> , integer_const diff --git a/test/risc/instructions/test_load_data.rb b/test/risc/instructions/test_load_data.rb new file mode 100644 index 00000000..dd2b3f9b --- /dev/null +++ b/test/risc/instructions/test_load_data.rb @@ -0,0 +1,24 @@ +require_relative "../helper" + +module Risc + class TestLoadData < MiniTest::Test + def setup + Parfait.boot!({}) + end + def risc(i) + Risc.load_data("source" , 1) + end + def test_const + assert_equal LoadData , risc(1).class + end + def test_val + assert_equal 1 , risc(1).constant + end + def test_reg + assert_equal :fix_1 , risc(1).register.symbol + end + def test_reg_type + assert_equal "Integer_Type" , risc(1).register.type.name + end + end +end diff --git a/test/risc/test_callable_compiler.rb b/test/risc/test_callable_compiler.rb index dbddc4be..8230b424 100644 --- a/test/risc/test_callable_compiler.rb +++ b/test/risc/test_callable_compiler.rb @@ -31,5 +31,10 @@ module Risc assert_equal LoadConstant , @compiler.current.class assert_equal Parfait::Space , @compiler.current.constant.class end + def test_load_data + object = @compiler.load_object(1) + assert_equal LoadData , @compiler.current.class + assert_equal Integer , @compiler.current.constant.class + end end end diff --git a/test/slot_machine/macro/test_div10.rb b/test/slot_machine/macro/test_div10.rb index 389d1c37..f54b348d 100644 --- a/test/slot_machine/macro/test_div10.rb +++ b/test/slot_machine/macro/test_div10.rb @@ -14,53 +14,54 @@ module SlotMachine assert_equal Risc::MethodCompiler , @method.to_risc.class end def test_risc_length - assert_equal 69 , @method.to_risc.risc_instructions.length + assert_equal 68 , @method.to_risc.risc_instructions.length end def test_allocate assert_allocate end def test_return - assert_return(61) + assert_return(60) end def test_all - assert_slot_to_reg risc(23) , :r0 , 2 , :r2 - assert_slot_to_reg risc(24) , :r2 , 2 , :r2 - assert_transfer risc(25) , :r2 , :r3 - assert_transfer risc(26) , :r2 , :r4 - assert_data risc(27) , 1 - assert_operator risc(28) , :>> , :r3 , :r5 - assert_data risc(29) , 2 - assert_operator risc(30) , :>> , :r4 , :r5 - assert_operator risc(31) , :+ , :r4 , :r3 - assert_data risc(32) , 4 - assert_transfer risc(33) , :r4 , :r3 - assert_operator risc(34) , :>> , :r4 , :r3 - assert_operator risc(35) , :+ , :r4 , :r3 - assert_data risc(36) , 8 - assert_transfer risc(37) , :r4 , :r3 - assert_operator risc(38) , :>> , :r3 , :r5 - assert_operator risc(39) , :+ , :r4 , :r3 - assert_data risc(40) , 16 - assert_transfer risc(41) , :r4 , :r3 - assert_operator risc(42) , :>> , :r3 , :r5 - assert_operator risc(43) , :+ , :r4 , :r3 - assert_data risc(44) , 3 - assert_operator risc(45) , :>> , :r4 , :r5 - assert_data risc(46) , 10 - assert_transfer risc(47) , :r4 , :r3 - assert_operator risc(48) , :* , :r3 , :r5 - assert_operator risc(49) , :- , :r2 , :r3 - assert_transfer risc(50) , :r2 , :r3 - assert_data risc(51) , 6 - assert_operator risc(52) , :+ , :r3 , :r5 - assert_data risc(53) , 4 - assert_operator risc(54) , :>> , :r3 , :r5 - assert_operator risc(55) , :+ , :r4 , :r3 - assert_reg_to_slot risc(56) , :r4 , :r1 , 2 - assert_reg_to_slot risc(57) , :r1 , :r0 , 5 - assert_slot_to_reg risc(58),:r0 , 5 , :r2 - assert_reg_to_slot risc(59) , :r2 , :r0 , 5 - assert_branch risc(60) , "return_label" + assert_slot_to_reg 23 , "message" , 2 , "message.receiver" + assert_slot_to_reg 24 , "message.receiver" , 2 , "message.receiver.data_1" + assert_transfer 25 , "message.receiver.data_1" , "integer_1" + assert_transfer 26 , "message.receiver.data_1" , "integer_reg" + assert_data 27 , 1 + assert_operator 28 , :>> , :integer_1 , :integer_const + assert_data 29 , 2 + assert_operator 30 , :>> , :integer_reg , :integer_const + assert_operator 31 , :+ , :integer_reg , :integer_1 + assert_data 32 , 4 + assert_transfer 33 , :integer_reg , :integer_1 + assert_operator 34 , :>> , :integer_reg , :integer_1 + assert_operator 35 , :+ , :integer_reg , :integer_1 + assert_data 36 , 8 + assert_transfer 37 , :integer_reg , :integer_1 + assert_operator 38 , :>> , :integer_1 , :integer_const + assert_operator 39 , :+ , :integer_reg , :integer_1 + assert_data 40 , 16 + assert_transfer 41 , :integer_reg , :integer_1 + assert_operator 42 , :>> , :integer_1 , :integer_const + assert_operator 43 , :+ , :integer_reg , :integer_1 + assert_data 44 , 3 + assert_operator 45 , :>> , :integer_reg , :integer_const + assert_data 46 , 10 + assert_transfer 47 , :integer_reg , :integer_1 + assert_operator 48 , :* , :integer_1 , :integer_const + assert_transfer 49 , "message.receiver.data_1" , :integer_1 + # assert_operator 50 , :- , :r2 , :integer_1 + assert_data 50 , 6 + assert_operator 51 , :+ , :integer_1 , :integer_const + assert_data 52 , 4 + assert_operator 53 , :>> , :integer_1 , :integer_const + assert_operator 54 , :+ , :integer_reg , :integer_1 + assert_reg_to_slot 55 , :integer_reg , "id_factory_.next_object" , 2 + assert_reg_to_slot 56 , "id_factory_.next_object" , :message , 5 + assert_slot_to_reg 57 ,:message , 5 , "message.return_value" + assert_reg_to_slot 58 , "message.return_value" , :message , 5 + assert_branch 59 , "return_label" + assert_label 60 , "return_label" end end end