2020-05-14 12:35:00 -04:00
|
|
|
# Parse built-in script and make rbinc file
|
|
|
|
|
|
|
|
require 'ripper'
|
2020-07-09 22:49:50 -04:00
|
|
|
require 'stringio'
|
|
|
|
require_relative 'ruby_vm/helpers/c_escape'
|
2020-05-14 12:35:00 -04:00
|
|
|
|
|
|
|
def string_literal(lit, str = [])
|
|
|
|
while lit
|
|
|
|
case lit.first
|
|
|
|
when :string_concat, :string_embexpr, :string_content
|
|
|
|
_, *lit = lit
|
|
|
|
lit.each {|s| string_literal(s, str)}
|
|
|
|
return str
|
|
|
|
when :string_literal
|
|
|
|
_, lit = lit
|
|
|
|
when :@tstring_content
|
|
|
|
str << lit[1]
|
|
|
|
return str
|
|
|
|
else
|
|
|
|
raise "unexpected #{lit.first}"
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2019-11-07 02:58:00 -05:00
|
|
|
|
2020-05-14 12:35:00 -04:00
|
|
|
def inline_text argc, arg1
|
2019-11-25 22:20:53 -05:00
|
|
|
raise "argc (#{argc}) of inline! should be 1" unless argc == 1
|
2020-05-14 12:35:00 -04:00
|
|
|
arg1 = string_literal(arg1)
|
|
|
|
raise "1st argument should be string literal" unless arg1
|
|
|
|
arg1.join("").rstrip
|
2019-11-25 22:20:53 -05:00
|
|
|
end
|
|
|
|
|
2019-12-13 03:26:12 -05:00
|
|
|
def make_cfunc_name inlines, name, lineno
|
|
|
|
case name
|
|
|
|
when /\[\]/
|
|
|
|
name = '_GETTER'
|
|
|
|
when /\[\]=/
|
|
|
|
name = '_SETTER'
|
|
|
|
else
|
|
|
|
name = name.tr('!?', 'EP')
|
|
|
|
end
|
|
|
|
|
|
|
|
base = "builtin_inline_#{name}_#{lineno}"
|
|
|
|
if inlines[base]
|
|
|
|
1000.times{|i|
|
|
|
|
name = "#{base}_#{i}"
|
|
|
|
return name unless inlines[name]
|
|
|
|
}
|
|
|
|
raise "too many functions in same line..."
|
|
|
|
else
|
|
|
|
base
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
support all locals for cexpr!, cstmt!
Primitve.cexpr! and .cstmt! can access Ruby's parameter and
*local variables* (note that local parameters are also local
variables). However recent changes only allow to access
parameters. This patch fix it.
For example, the following code can work:
def foo a, b, k: :kw, **kwrest
c = a + b
d = k
e = kwrest
p Primitive.cstmt!(%q(rb_p(rb_ary_new_from_args(5, a, b, c, d, e));
return Qnil;))
end
2020-07-04 04:23:34 -04:00
|
|
|
def collect_locals tree
|
2020-12-12 09:09:11 -05:00
|
|
|
_type, name, (line, _cols) = tree
|
support all locals for cexpr!, cstmt!
Primitve.cexpr! and .cstmt! can access Ruby's parameter and
*local variables* (note that local parameters are also local
variables). However recent changes only allow to access
parameters. This patch fix it.
For example, the following code can work:
def foo a, b, k: :kw, **kwrest
c = a + b
d = k
e = kwrest
p Primitive.cstmt!(%q(rb_p(rb_ary_new_from_args(5, a, b, c, d, e));
return Qnil;))
end
2020-07-04 04:23:34 -04:00
|
|
|
if locals = LOCALS_DB[[name, line]]
|
|
|
|
locals
|
|
|
|
else
|
|
|
|
if false # for debugging
|
|
|
|
pp LOCALS_DB
|
|
|
|
raise "not found: [#{name}, #{line}]"
|
2020-06-14 02:45:24 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
support all locals for cexpr!, cstmt!
Primitve.cexpr! and .cstmt! can access Ruby's parameter and
*local variables* (note that local parameters are also local
variables). However recent changes only allow to access
parameters. This patch fix it.
For example, the following code can work:
def foo a, b, k: :kw, **kwrest
c = a + b
d = k
e = kwrest
p Primitive.cstmt!(%q(rb_p(rb_ary_new_from_args(5, a, b, c, d, e));
return Qnil;))
end
2020-07-04 04:23:34 -04:00
|
|
|
def collect_builtin base, tree, name, bs, inlines, locals = nil
|
2020-05-14 12:35:00 -04:00
|
|
|
while tree
|
2020-12-12 09:09:11 -05:00
|
|
|
recv = sep = mid = args = nil
|
2020-05-14 12:35:00 -04:00
|
|
|
case tree.first
|
|
|
|
when :def
|
support all locals for cexpr!, cstmt!
Primitve.cexpr! and .cstmt! can access Ruby's parameter and
*local variables* (note that local parameters are also local
variables). However recent changes only allow to access
parameters. This patch fix it.
For example, the following code can work:
def foo a, b, k: :kw, **kwrest
c = a + b
d = k
e = kwrest
p Primitive.cstmt!(%q(rb_p(rb_ary_new_from_args(5, a, b, c, d, e));
return Qnil;))
end
2020-07-04 04:23:34 -04:00
|
|
|
locals = collect_locals(tree[1])
|
2020-05-14 12:35:00 -04:00
|
|
|
tree = tree[3]
|
2019-11-11 02:38:46 -05:00
|
|
|
next
|
2020-05-14 12:35:00 -04:00
|
|
|
when :defs
|
support all locals for cexpr!, cstmt!
Primitve.cexpr! and .cstmt! can access Ruby's parameter and
*local variables* (note that local parameters are also local
variables). However recent changes only allow to access
parameters. This patch fix it.
For example, the following code can work:
def foo a, b, k: :kw, **kwrest
c = a + b
d = k
e = kwrest
p Primitive.cstmt!(%q(rb_p(rb_ary_new_from_args(5, a, b, c, d, e));
return Qnil;))
end
2020-07-04 04:23:34 -04:00
|
|
|
locals = collect_locals(tree[3])
|
2020-05-14 12:35:00 -04:00
|
|
|
tree = tree[5]
|
|
|
|
next
|
|
|
|
when :class
|
|
|
|
name = 'class'
|
|
|
|
tree = tree[3]
|
|
|
|
next
|
|
|
|
when :sclass, :module
|
|
|
|
name = 'class'
|
|
|
|
tree = tree[2]
|
2019-11-11 02:38:46 -05:00
|
|
|
next
|
2020-05-14 12:35:00 -04:00
|
|
|
when :method_add_arg
|
|
|
|
_, mid, (_, (_, args)) = tree
|
|
|
|
case mid.first
|
2020-05-17 21:09:28 -04:00
|
|
|
when :call
|
|
|
|
_, recv, sep, mid = mid
|
2020-05-14 12:35:00 -04:00
|
|
|
when :fcall
|
|
|
|
_, mid = mid
|
|
|
|
else
|
|
|
|
mid = nil
|
|
|
|
end
|
|
|
|
when :vcall
|
|
|
|
_, mid = tree
|
|
|
|
when :command # FCALL
|
|
|
|
_, mid, (_, args) = tree
|
2020-05-17 21:09:28 -04:00
|
|
|
when :call, :command_call # CALL
|
|
|
|
_, recv, sep, mid, (_, args) = tree
|
2019-11-11 02:38:46 -05:00
|
|
|
end
|
`Primitive.mandatory_only?` for fast path
Compare with the C methods, A built-in methods written in Ruby is
slower if only mandatory parameters are given because it needs to
check the argumens and fill default values for optional and keyword
parameters (C methods can check the number of parameters with `argc`,
so there are no overhead). Passing mandatory arguments are common
(optional arguments are exceptional, in many cases) so it is important
to provide the fast path for such common cases.
`Primitive.mandatory_only?` is a special builtin function used with
`if` expression like that:
```ruby
def self.at(time, subsec = false, unit = :microsecond, in: nil)
if Primitive.mandatory_only?
Primitive.time_s_at1(time)
else
Primitive.time_s_at(time, subsec, unit, Primitive.arg!(:in))
end
end
```
and it makes two ISeq,
```
def self.at(time, subsec = false, unit = :microsecond, in: nil)
Primitive.time_s_at(time, subsec, unit, Primitive.arg!(:in))
end
def self.at(time)
Primitive.time_s_at1(time)
end
```
and (2) is pointed by (1). Note that `Primitive.mandatory_only?`
should be used only in a condition of an `if` statement and the
`if` statement should be equal to the methdo body (you can not
put any expression before and after the `if` statement).
A method entry with `mandatory_only?` (`Time.at` on the above case)
is marked as `iseq_overload`. When the method will be dispatch only
with mandatory arguments (`Time.at(0)` for example), make another
method entry with ISeq (2) as mandatory only method entry and it
will be cached in an inline method cache.
The idea is similar discussed in https://bugs.ruby-lang.org/issues/16254
but it only checks mandatory parameters or more, because many cases
only mandatory parameters are given. If we find other cases (optional
or keyword parameters are used frequently and it hurts performance),
we can extend the feature.
2021-11-12 12:12:20 -05:00
|
|
|
|
2020-05-14 12:35:00 -04:00
|
|
|
if mid
|
2020-12-31 10:51:12 -05:00
|
|
|
raise "unknown sexp: #{mid.inspect}" unless %i[@ident @const].include?(mid.first)
|
2020-05-14 12:35:00 -04:00
|
|
|
_, mid, (lineno,) = mid
|
2020-05-17 21:09:28 -04:00
|
|
|
if recv
|
|
|
|
func_name = nil
|
|
|
|
case recv.first
|
2020-05-31 02:51:40 -04:00
|
|
|
when :var_ref
|
|
|
|
_, recv = recv
|
|
|
|
if recv.first == :@const and recv[1] == "Primitive"
|
|
|
|
func_name = mid.to_s
|
|
|
|
end
|
2020-05-17 21:09:28 -04:00
|
|
|
when :vcall
|
|
|
|
_, recv = recv
|
|
|
|
if recv.first == :@ident and recv[1] == "__builtin"
|
|
|
|
func_name = mid.to_s
|
|
|
|
end
|
|
|
|
end
|
|
|
|
collect_builtin(base, recv, name, bs, inlines) unless func_name
|
|
|
|
else
|
|
|
|
func_name = mid[/\A__builtin_(.+)/, 1]
|
|
|
|
end
|
|
|
|
if func_name
|
|
|
|
cfunc_name = func_name
|
2020-05-14 12:35:00 -04:00
|
|
|
args.pop unless (args ||= []).last
|
|
|
|
argc = args.size
|
2019-11-07 02:58:00 -05:00
|
|
|
|
`Primitive.mandatory_only?` for fast path
Compare with the C methods, A built-in methods written in Ruby is
slower if only mandatory parameters are given because it needs to
check the argumens and fill default values for optional and keyword
parameters (C methods can check the number of parameters with `argc`,
so there are no overhead). Passing mandatory arguments are common
(optional arguments are exceptional, in many cases) so it is important
to provide the fast path for such common cases.
`Primitive.mandatory_only?` is a special builtin function used with
`if` expression like that:
```ruby
def self.at(time, subsec = false, unit = :microsecond, in: nil)
if Primitive.mandatory_only?
Primitive.time_s_at1(time)
else
Primitive.time_s_at(time, subsec, unit, Primitive.arg!(:in))
end
end
```
and it makes two ISeq,
```
def self.at(time, subsec = false, unit = :microsecond, in: nil)
Primitive.time_s_at(time, subsec, unit, Primitive.arg!(:in))
end
def self.at(time)
Primitive.time_s_at1(time)
end
```
and (2) is pointed by (1). Note that `Primitive.mandatory_only?`
should be used only in a condition of an `if` statement and the
`if` statement should be equal to the methdo body (you can not
put any expression before and after the `if` statement).
A method entry with `mandatory_only?` (`Time.at` on the above case)
is marked as `iseq_overload`. When the method will be dispatch only
with mandatory arguments (`Time.at(0)` for example), make another
method entry with ISeq (2) as mandatory only method entry and it
will be cached in an inline method cache.
The idea is similar discussed in https://bugs.ruby-lang.org/issues/16254
but it only checks mandatory parameters or more, because many cases
only mandatory parameters are given. If we find other cases (optional
or keyword parameters are used frequently and it hurts performance),
we can extend the feature.
2021-11-12 12:12:20 -05:00
|
|
|
if /(.+)[\!\?]\z/ =~ func_name
|
2019-11-25 22:20:53 -05:00
|
|
|
case $1
|
2020-06-20 20:13:03 -04:00
|
|
|
when 'attr'
|
|
|
|
text = inline_text(argc, args.first)
|
|
|
|
if text != 'inline'
|
|
|
|
raise "Only 'inline' is allowed to be annotated (but got: '#{text}')"
|
|
|
|
end
|
|
|
|
break
|
2019-11-25 22:20:53 -05:00
|
|
|
when 'cstmt'
|
2020-05-14 12:35:00 -04:00
|
|
|
text = inline_text argc, args.first
|
2019-11-25 22:20:53 -05:00
|
|
|
|
2019-12-13 03:26:12 -05:00
|
|
|
func_name = "_bi#{inlines.size}"
|
|
|
|
cfunc_name = make_cfunc_name(inlines, name, lineno)
|
support all locals for cexpr!, cstmt!
Primitve.cexpr! and .cstmt! can access Ruby's parameter and
*local variables* (note that local parameters are also local
variables). However recent changes only allow to access
parameters. This patch fix it.
For example, the following code can work:
def foo a, b, k: :kw, **kwrest
c = a + b
d = k
e = kwrest
p Primitive.cstmt!(%q(rb_p(rb_ary_new_from_args(5, a, b, c, d, e));
return Qnil;))
end
2020-07-04 04:23:34 -04:00
|
|
|
inlines[cfunc_name] = [lineno, text, locals, func_name]
|
2019-11-25 22:20:53 -05:00
|
|
|
argc -= 1
|
|
|
|
when 'cexpr', 'cconst'
|
2020-05-14 12:35:00 -04:00
|
|
|
text = inline_text argc, args.first
|
2019-11-25 22:20:53 -05:00
|
|
|
code = "return #{text};"
|
|
|
|
|
2019-12-13 03:26:12 -05:00
|
|
|
func_name = "_bi#{inlines.size}"
|
|
|
|
cfunc_name = make_cfunc_name(inlines, name, lineno)
|
|
|
|
|
support all locals for cexpr!, cstmt!
Primitve.cexpr! and .cstmt! can access Ruby's parameter and
*local variables* (note that local parameters are also local
variables). However recent changes only allow to access
parameters. This patch fix it.
For example, the following code can work:
def foo a, b, k: :kw, **kwrest
c = a + b
d = k
e = kwrest
p Primitive.cstmt!(%q(rb_p(rb_ary_new_from_args(5, a, b, c, d, e));
return Qnil;))
end
2020-07-04 04:23:34 -04:00
|
|
|
locals = [] if $1 == 'cconst'
|
|
|
|
inlines[cfunc_name] = [lineno, code, locals, func_name]
|
2019-11-25 22:20:53 -05:00
|
|
|
argc -= 1
|
|
|
|
when 'cinit'
|
2020-05-14 12:35:00 -04:00
|
|
|
text = inline_text argc, args.first
|
2020-07-04 21:43:08 -04:00
|
|
|
func_name = nil # required
|
|
|
|
inlines[inlines.size] = [lineno, text, nil, nil]
|
2019-11-25 22:20:53 -05:00
|
|
|
argc -= 1
|
`Primitive.mandatory_only?` for fast path
Compare with the C methods, A built-in methods written in Ruby is
slower if only mandatory parameters are given because it needs to
check the argumens and fill default values for optional and keyword
parameters (C methods can check the number of parameters with `argc`,
so there are no overhead). Passing mandatory arguments are common
(optional arguments are exceptional, in many cases) so it is important
to provide the fast path for such common cases.
`Primitive.mandatory_only?` is a special builtin function used with
`if` expression like that:
```ruby
def self.at(time, subsec = false, unit = :microsecond, in: nil)
if Primitive.mandatory_only?
Primitive.time_s_at1(time)
else
Primitive.time_s_at(time, subsec, unit, Primitive.arg!(:in))
end
end
```
and it makes two ISeq,
```
def self.at(time, subsec = false, unit = :microsecond, in: nil)
Primitive.time_s_at(time, subsec, unit, Primitive.arg!(:in))
end
def self.at(time)
Primitive.time_s_at1(time)
end
```
and (2) is pointed by (1). Note that `Primitive.mandatory_only?`
should be used only in a condition of an `if` statement and the
`if` statement should be equal to the methdo body (you can not
put any expression before and after the `if` statement).
A method entry with `mandatory_only?` (`Time.at` on the above case)
is marked as `iseq_overload`. When the method will be dispatch only
with mandatory arguments (`Time.at(0)` for example), make another
method entry with ISeq (2) as mandatory only method entry and it
will be cached in an inline method cache.
The idea is similar discussed in https://bugs.ruby-lang.org/issues/16254
but it only checks mandatory parameters or more, because many cases
only mandatory parameters are given. If we find other cases (optional
or keyword parameters are used frequently and it hurts performance),
we can extend the feature.
2021-11-12 12:12:20 -05:00
|
|
|
when 'mandatory_only'
|
|
|
|
func_name = nil
|
2020-12-29 11:22:11 -05:00
|
|
|
when 'arg'
|
|
|
|
argc == 1 or raise "unexpected argument number #{argc}"
|
|
|
|
(arg = args.first)[0] == :symbol_literal or raise "symbol literal expected #{args}"
|
|
|
|
(arg = arg[1])[0] == :symbol or raise "symbol expected #{arg}"
|
|
|
|
(var = arg[1] and var = var[1]) or raise "argument name expected #{arg}"
|
|
|
|
func_name = nil
|
2019-11-25 22:20:53 -05:00
|
|
|
end
|
2019-11-07 02:58:00 -05:00
|
|
|
end
|
2019-11-11 02:38:46 -05:00
|
|
|
|
|
|
|
if bs[func_name] &&
|
2019-12-13 03:26:12 -05:00
|
|
|
bs[func_name] != [argc, cfunc_name]
|
2019-11-11 02:38:46 -05:00
|
|
|
raise "same builtin function \"#{func_name}\", but different arity (was #{bs[func_name]} but #{argc})"
|
|
|
|
end
|
|
|
|
|
2019-12-13 03:26:12 -05:00
|
|
|
bs[func_name] = [argc, cfunc_name] if func_name
|
2019-11-07 02:58:00 -05:00
|
|
|
end
|
2020-05-14 12:35:00 -04:00
|
|
|
break unless tree = args
|
2019-11-07 02:58:00 -05:00
|
|
|
end
|
2020-05-14 12:35:00 -04:00
|
|
|
|
|
|
|
tree.each do |t|
|
support all locals for cexpr!, cstmt!
Primitve.cexpr! and .cstmt! can access Ruby's parameter and
*local variables* (note that local parameters are also local
variables). However recent changes only allow to access
parameters. This patch fix it.
For example, the following code can work:
def foo a, b, k: :kw, **kwrest
c = a + b
d = k
e = kwrest
p Primitive.cstmt!(%q(rb_p(rb_ary_new_from_args(5, a, b, c, d, e));
return Qnil;))
end
2020-07-04 04:23:34 -04:00
|
|
|
collect_builtin base, t, name, bs, inlines, locals if Array === t
|
2020-05-14 12:35:00 -04:00
|
|
|
end
|
|
|
|
break
|
|
|
|
end
|
2019-11-07 02:58:00 -05:00
|
|
|
end
|
support all locals for cexpr!, cstmt!
Primitve.cexpr! and .cstmt! can access Ruby's parameter and
*local variables* (note that local parameters are also local
variables). However recent changes only allow to access
parameters. This patch fix it.
For example, the following code can work:
def foo a, b, k: :kw, **kwrest
c = a + b
d = k
e = kwrest
p Primitive.cstmt!(%q(rb_p(rb_ary_new_from_args(5, a, b, c, d, e));
return Qnil;))
end
2020-07-04 04:23:34 -04:00
|
|
|
|
2019-11-07 02:58:00 -05:00
|
|
|
# ruby mk_builtin_loader.rb TARGET_FILE.rb
|
2019-11-08 02:24:24 -05:00
|
|
|
# #=> generate TARGET_FILE.rbinc
|
2019-11-07 02:58:00 -05:00
|
|
|
#
|
|
|
|
|
support all locals for cexpr!, cstmt!
Primitve.cexpr! and .cstmt! can access Ruby's parameter and
*local variables* (note that local parameters are also local
variables). However recent changes only allow to access
parameters. This patch fix it.
For example, the following code can work:
def foo a, b, k: :kw, **kwrest
c = a + b
d = k
e = kwrest
p Primitive.cstmt!(%q(rb_p(rb_ary_new_from_args(5, a, b, c, d, e));
return Qnil;))
end
2020-07-04 04:23:34 -04:00
|
|
|
LOCALS_DB = {} # [method_name, first_line] = locals
|
|
|
|
|
|
|
|
def collect_iseq iseq_ary
|
|
|
|
# iseq_ary.each_with_index{|e, i| p [i, e]}
|
|
|
|
label = iseq_ary[5]
|
|
|
|
first_line = iseq_ary[8]
|
|
|
|
type = iseq_ary[9]
|
|
|
|
locals = iseq_ary[10]
|
|
|
|
insns = iseq_ary[13]
|
|
|
|
|
|
|
|
if type == :method
|
|
|
|
LOCALS_DB[[label, first_line].freeze] = locals
|
|
|
|
end
|
|
|
|
|
|
|
|
insns.each{|insn|
|
|
|
|
case insn
|
|
|
|
when Integer
|
|
|
|
# ignore
|
|
|
|
when Array
|
|
|
|
# p insn.shift # insn name
|
|
|
|
insn.each{|op|
|
|
|
|
if Array === op && op[0] == "YARVInstructionSequence/SimpleDataFormat"
|
|
|
|
collect_iseq op
|
|
|
|
end
|
|
|
|
}
|
|
|
|
end
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
2020-07-09 22:49:50 -04:00
|
|
|
def generate_cexpr(ofile, lineno, line_file, body_lineno, text, locals, func_name)
|
|
|
|
f = StringIO.new
|
|
|
|
f.puts '{'
|
|
|
|
lineno += 1
|
|
|
|
locals.reverse_each.with_index{|param, i|
|
|
|
|
next unless Symbol === param
|
|
|
|
f.puts "MAYBE_UNUSED(const VALUE) #{param} = rb_vm_lvar(ec, #{-3 - i});"
|
|
|
|
lineno += 1
|
|
|
|
}
|
|
|
|
f.puts "#line #{body_lineno} \"#{line_file}\""
|
|
|
|
lineno += 1
|
|
|
|
|
|
|
|
f.puts text
|
|
|
|
lineno += text.count("\n") + 1
|
|
|
|
|
|
|
|
f.puts "#line #{lineno + 2} \"#{ofile}\"" # TODO: restore line number.
|
|
|
|
f.puts "}"
|
|
|
|
f.puts
|
|
|
|
lineno += 3
|
|
|
|
|
|
|
|
return lineno, f.string
|
|
|
|
end
|
|
|
|
|
2019-11-07 02:58:00 -05:00
|
|
|
def mk_builtin_header file
|
|
|
|
base = File.basename(file, '.rb')
|
2019-11-26 05:08:56 -05:00
|
|
|
ofile = "#{file}inc"
|
2019-11-07 02:58:00 -05:00
|
|
|
|
2019-11-11 02:38:46 -05:00
|
|
|
# bs = { func_name => argc }
|
support all locals for cexpr!, cstmt!
Primitve.cexpr! and .cstmt! can access Ruby's parameter and
*local variables* (note that local parameters are also local
variables). However recent changes only allow to access
parameters. This patch fix it.
For example, the following code can work:
def foo a, b, k: :kw, **kwrest
c = a + b
d = k
e = kwrest
p Primitive.cstmt!(%q(rb_p(rb_ary_new_from_args(5, a, b, c, d, e));
return Qnil;))
end
2020-07-04 04:23:34 -04:00
|
|
|
code = File.read(file)
|
|
|
|
collect_iseq RubyVM::InstructionSequence.compile(code).to_a
|
|
|
|
collect_builtin(base, Ripper.sexp(code), 'top', bs = {}, inlines = {})
|
2019-11-07 02:58:00 -05:00
|
|
|
|
2019-11-26 05:08:56 -05:00
|
|
|
begin
|
|
|
|
f = open(ofile, 'w')
|
2019-12-22 20:37:30 -05:00
|
|
|
rescue Errno::EACCES
|
2019-11-26 05:08:56 -05:00
|
|
|
# Fall back to the current directory
|
|
|
|
f = open(File.basename(ofile), 'w')
|
|
|
|
end
|
|
|
|
begin
|
2020-06-28 01:12:26 -04:00
|
|
|
if File::ALT_SEPARATOR
|
|
|
|
file = file.tr(File::ALT_SEPARATOR, File::SEPARATOR)
|
|
|
|
ofile = ofile.tr(File::ALT_SEPARATOR, File::SEPARATOR)
|
|
|
|
end
|
2020-06-28 01:13:48 -04:00
|
|
|
lineno = __LINE__
|
2019-11-08 02:37:42 -05:00
|
|
|
f.puts "// -*- c -*-"
|
2019-11-07 02:58:00 -05:00
|
|
|
f.puts "// DO NOT MODIFY THIS FILE DIRECTLY."
|
|
|
|
f.puts "// auto-generated file"
|
|
|
|
f.puts "// by #{__FILE__}"
|
|
|
|
f.puts "// with #{file}"
|
2019-12-04 03:16:30 -05:00
|
|
|
f.puts '#include "internal/compilers.h" /* for MAYBE_UNUSED */'
|
|
|
|
f.puts '#include "internal/warnings.h" /* for COMPILER_WARNING_PUSH */'
|
|
|
|
f.puts '#include "ruby/ruby.h" /* for VALUE */'
|
|
|
|
f.puts '#include "builtin.h" /* for RB_BUILTIN_FUNCTION */'
|
|
|
|
f.puts 'struct rb_execution_context_struct; /* in vm_core.h */'
|
2019-11-07 02:58:00 -05:00
|
|
|
f.puts
|
2020-06-28 01:13:48 -04:00
|
|
|
lineno = __LINE__ - lineno - 1
|
2020-06-28 00:20:40 -04:00
|
|
|
line_file = file
|
2019-11-11 02:38:46 -05:00
|
|
|
|
support all locals for cexpr!, cstmt!
Primitve.cexpr! and .cstmt! can access Ruby's parameter and
*local variables* (note that local parameters are also local
variables). However recent changes only allow to access
parameters. This patch fix it.
For example, the following code can work:
def foo a, b, k: :kw, **kwrest
c = a + b
d = k
e = kwrest
p Primitive.cstmt!(%q(rb_p(rb_ary_new_from_args(5, a, b, c, d, e));
return Qnil;))
end
2020-07-04 04:23:34 -04:00
|
|
|
inlines.each{|cfunc_name, (body_lineno, text, locals, func_name)|
|
2019-12-13 03:26:12 -05:00
|
|
|
if String === cfunc_name
|
2020-07-09 22:49:50 -04:00
|
|
|
f.puts "static VALUE #{cfunc_name}(struct rb_execution_context_struct *ec, const VALUE self)"
|
2019-11-11 02:38:46 -05:00
|
|
|
lineno += 1
|
2020-07-09 22:49:50 -04:00
|
|
|
lineno, str = generate_cexpr(ofile, lineno, line_file, body_lineno, text, locals, func_name)
|
|
|
|
f.write str
|
2019-11-25 22:20:53 -05:00
|
|
|
else
|
|
|
|
# cinit!
|
|
|
|
f.puts "#line #{body_lineno} \"#{line_file}\""
|
|
|
|
lineno += 1
|
|
|
|
f.puts text
|
|
|
|
lineno += text.count("\n") + 1
|
|
|
|
f.puts "#line #{lineno + 2} \"#{ofile}\"" # TODO: restore line number.
|
|
|
|
lineno += 1
|
|
|
|
end
|
2019-11-11 02:38:46 -05:00
|
|
|
}
|
2019-11-07 02:58:00 -05:00
|
|
|
|
2020-07-09 08:43:42 -04:00
|
|
|
bs.each_pair{|func, (argc, cfunc_name)|
|
2020-07-12 22:43:24 -04:00
|
|
|
decl = ', VALUE' * argc
|
|
|
|
argv = argc \
|
|
|
|
. times \
|
|
|
|
. map {|i|", argv[#{i}]"} \
|
|
|
|
. join('')
|
2020-07-09 08:43:42 -04:00
|
|
|
f.puts %'static void'
|
2020-07-12 22:43:24 -04:00
|
|
|
f.puts %'mjit_compile_invokebuiltin_for_#{func}(FILE *f, long index, unsigned stack_size, bool inlinable_p)'
|
2020-07-09 08:43:42 -04:00
|
|
|
f.puts %'{'
|
2020-07-12 22:43:24 -04:00
|
|
|
f.puts %' fprintf(f, " VALUE self = GET_SELF();\\n");'
|
|
|
|
f.puts %' fprintf(f, " typedef VALUE (*func)(rb_execution_context_t *, VALUE#{decl});\\n");'
|
2020-07-09 22:49:50 -04:00
|
|
|
if inlines.has_key? cfunc_name
|
|
|
|
body_lineno, text, locals, func_name = inlines[cfunc_name]
|
|
|
|
lineno, str = generate_cexpr(ofile, lineno, line_file, body_lineno, text, locals, func_name)
|
2020-07-12 22:43:24 -04:00
|
|
|
f.puts %' if (inlinable_p) {'
|
|
|
|
str.gsub(/^(?!#)/, ' ').each_line {|i|
|
|
|
|
j = RubyVM::CEscape.rstring2cstr(i).dup
|
|
|
|
j.sub!(/^ return\b/ , ' val =')
|
|
|
|
f.printf(%' fprintf(f, "%%s", %s);\n', j)
|
2020-07-09 22:49:50 -04:00
|
|
|
}
|
2020-07-12 22:43:24 -04:00
|
|
|
f.puts(%' return;')
|
|
|
|
f.puts(%' }')
|
|
|
|
end
|
|
|
|
if argc > 0
|
|
|
|
f.puts %' if (index == -1) {'
|
|
|
|
f.puts %' fprintf(f, " const VALUE *argv = &stack[%d];\\n", stack_size - #{argc});'
|
|
|
|
f.puts %' }'
|
|
|
|
f.puts %' else {'
|
|
|
|
f.puts %' fprintf(f, " const unsigned int lnum = GET_ISEQ()->body->local_table_size;\\n");'
|
|
|
|
f.puts %' fprintf(f, " const VALUE *argv = GET_EP() - lnum - VM_ENV_DATA_SIZE + 1 + %ld;\\n", index);'
|
|
|
|
f.puts %' }'
|
2020-07-09 22:49:50 -04:00
|
|
|
end
|
2021-08-16 00:52:17 -04:00
|
|
|
f.puts %' fprintf(f, " func f = (func)%"PRIuVALUE"; /* == #{cfunc_name} */\\n", (VALUE)#{cfunc_name});'
|
2020-07-12 22:43:24 -04:00
|
|
|
f.puts %' fprintf(f, " val = f(ec, self#{argv});\\n");'
|
2020-07-09 08:43:42 -04:00
|
|
|
f.puts %'}'
|
|
|
|
f.puts
|
|
|
|
}
|
|
|
|
|
2019-12-28 20:07:17 -05:00
|
|
|
f.puts "void Init_builtin_#{base}(void)"
|
2019-11-07 02:58:00 -05:00
|
|
|
f.puts "{"
|
|
|
|
|
|
|
|
table = "#{base}_table"
|
|
|
|
f.puts " // table definition"
|
|
|
|
f.puts " static const struct rb_builtin_function #{table}[] = {"
|
2019-12-13 03:26:12 -05:00
|
|
|
bs.each.with_index{|(func, (argc, cfunc_name)), i|
|
2020-07-09 08:43:42 -04:00
|
|
|
f.puts " RB_BUILTIN_FUNCTION(#{i}, #{func}, #{cfunc_name}, #{argc}, mjit_compile_invokebuiltin_for_#{func}),"
|
2019-11-07 02:58:00 -05:00
|
|
|
}
|
2020-07-09 08:43:42 -04:00
|
|
|
f.puts " RB_BUILTIN_FUNCTION(-1, NULL, NULL, 0, 0),"
|
2019-11-07 02:58:00 -05:00
|
|
|
f.puts " };"
|
|
|
|
|
|
|
|
f.puts
|
|
|
|
f.puts " // arity_check"
|
2019-11-08 01:13:24 -05:00
|
|
|
f.puts "COMPILER_WARNING_PUSH"
|
2021-04-29 08:31:05 -04:00
|
|
|
f.puts "#if GCC_VERSION_SINCE(5, 1, 0) || defined __clang__"
|
2019-11-08 01:13:24 -05:00
|
|
|
f.puts "COMPILER_WARNING_ERROR(-Wincompatible-pointer-types)"
|
|
|
|
f.puts "#endif"
|
2019-12-13 03:26:12 -05:00
|
|
|
bs.each{|func, (argc, cfunc_name)|
|
|
|
|
f.puts " if (0) rb_builtin_function_check_arity#{argc}(#{cfunc_name});"
|
2019-11-07 02:58:00 -05:00
|
|
|
}
|
2019-11-08 01:13:24 -05:00
|
|
|
f.puts "COMPILER_WARNING_POP"
|
|
|
|
|
2019-11-07 02:58:00 -05:00
|
|
|
f.puts
|
|
|
|
f.puts " // load"
|
2019-11-09 05:43:14 -05:00
|
|
|
f.puts " rb_load_with_builtin_functions(#{base.dump}, #{table});"
|
2019-11-07 02:58:00 -05:00
|
|
|
|
|
|
|
f.puts "}"
|
2019-11-26 05:08:56 -05:00
|
|
|
ensure
|
|
|
|
f.close
|
|
|
|
end
|
2019-11-07 02:58:00 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
ARGV.each{|file|
|
|
|
|
# feature.rb => load_feature.inc
|
2019-11-09 05:43:14 -05:00
|
|
|
mk_builtin_header file
|
2019-11-07 02:58:00 -05:00
|
|
|
}
|