rubyx/lib/risc/builtin/integer.rb

#integer related kernel functions
module Risc
  module Builtin
    module Integer
      module ClassMethods
        include AST::Sexp
        include CompileHelper

        def mod4 context
          compiler = compiler_for(:Integer,:mod4 ,{})
          return compiler.method
        end
        def putint context
          compiler = compiler_for(:Integer,:putint ,{})
          return compiler.method
        end

        def +( context )
          source = "plus"
          compiler = compiler_for(:Integer,:+ ,{other: :Integer})
          me , other = compiler.self_and_int_arg(source + "1")
          # reduce me and other to integers
          compiler.reduce_int( source + "2", me )
          compiler.reduce_int( source + "3", other )
          compiler.add_code Risc.op( source + "4", :+ , me , other)
          compiler.add_new_int(me , other)
          compiler.add_reg_to_slot( source + "5" , other , :message , :return_value)
          compiler.add_mom( Mom::ReturnSequence.new)
          return compiler.method
        end
        def div10( context )
          s = "div_10 "
          compiler = compiler_for(:Integer,:div10 ,{})
          me = compiler.add_known( :receiver )
          tmp = compiler.add_known( :receiver )
          q = compiler.add_known( :receiver )
          compiler.reduce_int( s , me )
          compiler.reduce_int( s , tmp )
          compiler.reduce_int( s , q )
          const = compiler.use_reg :fixnum , 1
          compiler.add_load_data( s , 1 , const )
          # int tmp = self >> 1
          compiler.add_code Risc.op( s , :>> , tmp , const)
          # int q = self >> 2
          compiler.add_load_data( s , 2 , const)
          compiler.add_code Risc.op( s , :>> , q , const)
          # q = q + tmp
          compiler.add_code Risc.op( s , :+ , q , tmp )
          # tmp = q >> 4
          compiler.add_load_data( s , 4 , const)
          compiler.add_transfer( s, q , tmp)
          compiler.add_code Risc.op( s , :>> , tmp , const)
          # q = q + tmp
          compiler.add_code Risc.op( s , :+ , q , tmp )
          # tmp = q >> 8
          compiler.add_load_data( s , 8 , const)
          compiler.add_transfer( s, q , tmp)
          compiler.add_code Risc.op( s , :>> , tmp , const)
          # q = q + tmp
          compiler.add_code Risc.op( s , :+ , q , tmp )
          # tmp = q >> 16
          compiler.add_load_data( s , 16 , const)
          compiler.add_transfer( s, q , tmp)
          compiler.add_code Risc.op( s , :>> , tmp , const)
          # q = q + tmp
          compiler.add_code Risc.op( s , :+ , q , tmp )
          # q = q >> 3
          compiler.add_load_data( s , 3 , const)
          compiler.add_code Risc.op( s , :>> , q , const)
          # tmp = q * 10
          compiler.add_load_data( s , 10 , const)
          compiler.add_transfer( s, q , tmp)
          compiler.add_code Risc.op( s , :* , tmp , const)
          # tmp = self - tmp
          compiler.add_code Risc.op( s , :- , me , tmp )
          compiler.add_transfer( s , me , tmp)
          # tmp = tmp + 6
          compiler.add_load_data( s , 6 , const)
          compiler.add_code Risc.op( s , :+ , tmp , const )
          # tmp = tmp >> 4
          compiler.add_load_data( s , 4 , const)
          compiler.add_code Risc.op( s , :>> , tmp , const )
          # return q + tmp
          compiler.add_code Risc.op( s , :+ , q , tmp )

          compiler.add_new_int(q , tmp)
          compiler.add_reg_to_slot( s , tmp , :message , :return_value)

          compiler.add_mom( Mom::ReturnSequence.new)
          return compiler.method
        end
      end
      extend ClassMethods
    end
  end
end
transformations according to todays post 2014-06-13 23:19:12 +02:00			`#integer related kernel functions`
rename register to risc seems to fit the layer much better as we really have a very reduced instruction set 2017-01-19 08:02:29 +01:00			`module Risc`
finally scoping builtin to register had put this off because it breaks history but now the references to register stuff which builtin is off course full of, become much shorter 2015-06-29 20:03:58 +02:00			`module Builtin`
			`module Integer`
			`module ClassMethods`
stop pinning self and frame before: r0-message , r1-self , r2-frame , r3-new_message , r4 + tmps now: r0-message , r1-new_message , r2 + tmps programs got smaller, less fuss also fix in return implementation that got the address from the wrong message 2015-10-18 16:20:19 +02:00			`include AST::Sexp`
using compiler_for to create all building compilers unify api, create defaults and especially pass the right types into the typed method creation 2018-03-18 17:38:35 +01:00			`include CompileHelper`
fix test result, but not test yet 2015-08-07 15:46:55 +02:00
serious bit fiddling, div10 using shift magic forgot that arm has no division (or respectively only later models have) many magic formulae out there, none seem to work 1000% on the interpreter. some big 0 ending numbers are 1 off. 2015-11-13 19:46:27 +01:00			`def mod4 context`
using compiler_for to create all building compilers unify api, create defaults and especially pass the right types into the typed method creation 2018-03-18 17:38:35 +01:00			`compiler = compiler_for(:Integer,:mod4 ,{})`
use compiler to generate methods and their instructions 2015-10-28 20:37:42 +01:00			`return compiler.method`
plus function, indentation 2015-08-05 17:49:37 +02:00			`end`
change args argument to create method to be hash was array and didn’t carry types and names 2015-11-11 19:41:02 +01:00			`def putint context`
using compiler_for to create all building compilers unify api, create defaults and especially pass the right types into the typed method creation 2018-03-18 17:38:35 +01:00			`compiler = compiler_for(:Integer,:putint ,{})`
use compiler to generate methods and their instructions 2015-10-28 20:37:42 +01:00			`return compiler.method`
plus function, indentation 2015-08-05 17:49:37 +02:00			`end`
change args argument to create method to be hash was array and didn’t carry types and names 2015-11-11 19:41:02 +01:00
add an integer plus not correctly handling integer objects yet 2018-03-30 16:09:02 +02:00			`def +( context )`
			`source = "plus"`
remove the :int shorthand 2018-03-31 18:17:55 +02:00			`compiler = compiler_for(:Integer,:+ ,{other: :Integer})`
move some compiler helpers to the compiler itself 2018-04-01 13:09:30 +02:00			`me , other = compiler.self_and_int_arg(source + "1")`
add an integer plus not correctly handling integer objects yet 2018-03-30 16:09:02 +02:00			`# reduce me and other to integers`
fix integer plus mostly forgot the return sequence 2018-04-01 13:56:01 +02:00			`compiler.reduce_int( source + "2", me )`
			`compiler.reduce_int( source + "3", other )`
fix helper and start on arg test 2018-03-30 17:05:38 +02:00			`compiler.add_code Risc.op( source + "4", :+ , me , other)`
move wip tests 2018-04-01 13:01:17 +02:00			`compiler.add_new_int(me , other)`
get those integers crated and used 2018-03-31 19:21:27 +02:00			`compiler.add_reg_to_slot( source + "5" , other , :message , :return_value)`
fix integer plus mostly forgot the return sequence 2018-04-01 13:56:01 +02:00			`compiler.add_mom( Mom::ReturnSequence.new)`
add an integer plus not correctly handling integer objects yet 2018-03-30 16:09:02 +02:00			`return compiler.method`
			`end`
fix div10 return sequence did not return at all before 2018-03-24 15:51:26 +01:00			`def div10( context )`
fix div10 by reducing the incoming integer to fixnum and then pushing the fixnum result into a new integer 2018-04-01 13:50:13 +02:00			`s = "div_10 "`
using compiler_for to create all building compilers unify api, create defaults and especially pass the right types into the typed method creation 2018-03-18 17:38:35 +01:00			`compiler = compiler_for(:Integer,:div10 ,{})`
rename self to receiver just because it is a keyword and can’t be used 2018-03-14 15:56:13 +01:00			`me = compiler.add_known( :receiver )`
			`tmp = compiler.add_known( :receiver )`
			`q = compiler.add_known( :receiver )`
fix div10 by reducing the incoming integer to fixnum and then pushing the fixnum result into a new integer 2018-04-01 13:50:13 +02:00			`compiler.reduce_int( s , me )`
			`compiler.reduce_int( s , tmp )`
			`compiler.reduce_int( s , q )`
			`const = compiler.use_reg :fixnum , 1`
			`compiler.add_load_data( s , 1 , const )`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# int tmp = self >> 1`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :>> , tmp , const)`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# int q = self >> 2`
introduce load_data instruction which just loads data to a register (used internally) as opposed to integers, which are objects 2018-03-31 11:38:30 +02:00			`compiler.add_load_data( s , 2 , const)`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :>> , q , const)`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# q = q + tmp`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :+ , q , tmp )`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# tmp = q >> 4`
introduce load_data instruction which just loads data to a register (used internally) as opposed to integers, which are objects 2018-03-31 11:38:30 +02:00			`compiler.add_load_data( s , 4 , const)`
tighter integration with factory methods for adding code define methods to collapse the code Register. in add_code Register.factory_method most instructions done, except op and branch that are rare 2016-12-28 19:37:54 +01:00			`compiler.add_transfer( s, q , tmp)`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :>> , tmp , const)`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# q = q + tmp`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :+ , q , tmp )`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# tmp = q >> 8`
introduce load_data instruction which just loads data to a register (used internally) as opposed to integers, which are objects 2018-03-31 11:38:30 +02:00			`compiler.add_load_data( s , 8 , const)`
tighter integration with factory methods for adding code define methods to collapse the code Register. in add_code Register.factory_method most instructions done, except op and branch that are rare 2016-12-28 19:37:54 +01:00			`compiler.add_transfer( s, q , tmp)`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :>> , tmp , const)`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# q = q + tmp`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :+ , q , tmp )`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# tmp = q >> 16`
introduce load_data instruction which just loads data to a register (used internally) as opposed to integers, which are objects 2018-03-31 11:38:30 +02:00			`compiler.add_load_data( s , 16 , const)`
tighter integration with factory methods for adding code define methods to collapse the code Register. in add_code Register.factory_method most instructions done, except op and branch that are rare 2016-12-28 19:37:54 +01:00			`compiler.add_transfer( s, q , tmp)`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :>> , tmp , const)`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# q = q + tmp`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :+ , q , tmp )`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# q = q >> 3`
introduce load_data instruction which just loads data to a register (used internally) as opposed to integers, which are objects 2018-03-31 11:38:30 +02:00			`compiler.add_load_data( s , 3 , const)`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :>> , q , const)`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# tmp = q * 10`
introduce load_data instruction which just loads data to a register (used internally) as opposed to integers, which are objects 2018-03-31 11:38:30 +02:00			`compiler.add_load_data( s , 10 , const)`
tighter integration with factory methods for adding code define methods to collapse the code Register. in add_code Register.factory_method most instructions done, except op and branch that are rare 2016-12-28 19:37:54 +01:00			`compiler.add_transfer( s, q , tmp)`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :* , tmp , const)`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# tmp = self - tmp`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :- , me , tmp )`
tighter integration with factory methods for adding code define methods to collapse the code Register. in add_code Register.factory_method most instructions done, except op and branch that are rare 2016-12-28 19:37:54 +01:00			`compiler.add_transfer( s , me , tmp)`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# tmp = tmp + 6`
introduce load_data instruction which just loads data to a register (used internally) as opposed to integers, which are objects 2018-03-31 11:38:30 +02:00			`compiler.add_load_data( s , 6 , const)`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :+ , tmp , const )`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# tmp = tmp >> 4`
introduce load_data instruction which just loads data to a register (used internally) as opposed to integers, which are objects 2018-03-31 11:38:30 +02:00			`compiler.add_load_data( s , 4 , const)`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :>> , tmp , const )`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`# return q + tmp`
change operators to symbols 2018-03-24 16:53:27 +01:00			`compiler.add_code Risc.op( s , :+ , q , tmp )`
move wip tests 2018-04-01 13:01:17 +02:00
fix div10 by reducing the incoming integer to fixnum and then pushing the fixnum result into a new integer 2018-04-01 13:50:13 +02:00			`compiler.add_new_int(q , tmp)`
			`compiler.add_reg_to_slot( s , tmp , :message , :return_value)`
move wip tests 2018-04-01 13:01:17 +02:00
fix div10 return sequence did not return at all before 2018-03-24 15:51:26 +01:00			`compiler.add_mom( Mom::ReturnSequence.new)`
implement the div10 as assembler easy after the some version worked because it’s not arm it probably twice as long as need be better (any?) optimisation would take care of that still, nice to see it works 2015-11-21 13:20:25 +01:00			`return compiler.method`
			`end`
finally scoping builtin to register had put this off because it breaks history but now the references to register stuff which builtin is off course full of, become much shorter 2015-06-29 20:03:58 +02:00			`end`
			`extend ClassMethods`
change to module style like other modules in this dir 2014-09-11 14:08:56 +02:00			`end`
transformations according to todays post 2014-06-13 23:19:12 +02:00			`end`
fix method seperation Since Compiled method split into Method and CompiledMethodInfo (parfait/vm) lots of call syntax changes 2015-05-24 12:31:33 +02:00			`end`