1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
ruby--ruby/tool/mk_builtin_loader.rb

371 lines
11 KiB
Ruby
Raw Normal View History

2020-05-14 12:35:00 -04:00
# Parse built-in script and make rbinc file
require 'ripper'
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
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
end
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
def collect_locals tree
_type, name, (line, _cols) = tree
if locals = LOCALS_DB[[name, line]]
locals
else
if false # for debugging
pp LOCALS_DB
raise "not found: [#{name}, #{line}]"
end
end
end
def collect_builtin base, tree, name, bs, inlines, locals = nil
2020-05-14 12:35:00 -04:00
while tree
recv = sep = mid = args = nil
2020-05-14 12:35:00 -04:00
case tree.first
when :def
locals = collect_locals(tree[1])
2020-05-14 12:35:00 -04:00
tree = tree[3]
next
2020-05-14 12:35:00 -04:00
when :defs
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]
next
2020-05-14 12:35:00 -04:00
when :method_add_arg
_, mid, (_, (_, args)) = tree
case mid.first
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
when :call, :command_call # CALL
_, recv, sep, mid, (_, args) = tree
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
raise "unknown sexp: #{mid.inspect}" unless %i[@ident @const].include?(mid.first)
2020-05-14 12:35:00 -04:00
_, mid, (lineno,) = mid
if recv
func_name = nil
case recv.first
when :var_ref
_, recv = recv
if recv.first == :@const and recv[1] == "Primitive"
func_name = mid.to_s
end
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
case $1
when 'attr'
text = inline_text(argc, args.first)
if text != 'inline'
raise "Only 'inline' is allowed to be annotated (but got: '#{text}')"
end
break
when 'cstmt'
2020-05-14 12:35:00 -04:00
text = inline_text argc, args.first
func_name = "_bi#{inlines.size}"
cfunc_name = make_cfunc_name(inlines, name, lineno)
inlines[cfunc_name] = [lineno, text, locals, func_name]
argc -= 1
when 'cexpr', 'cconst'
2020-05-14 12:35:00 -04:00
text = inline_text argc, args.first
code = "return #{text};"
func_name = "_bi#{inlines.size}"
cfunc_name = make_cfunc_name(inlines, name, lineno)
locals = [] if $1 == 'cconst'
inlines[cfunc_name] = [lineno, code, locals, func_name]
argc -= 1
when 'cinit'
2020-05-14 12:35:00 -04:00
text = inline_text argc, args.first
func_name = nil # required
inlines[inlines.size] = [lineno, text, nil, nil]
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
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
end
2019-11-07 02:58:00 -05:00
end
if bs[func_name] &&
bs[func_name] != [argc, cfunc_name]
raise "same builtin function \"#{func_name}\", but different arity (was #{bs[func_name]} but #{argc})"
end
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|
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
2019-11-07 02:58:00 -05:00
# ruby mk_builtin_loader.rb TARGET_FILE.rb
# #=> generate TARGET_FILE.rbinc
2019-11-07 02:58:00 -05: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
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')
ofile = "#{file}inc"
2019-11-07 02:58:00 -05:00
# bs = { func_name => argc }
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
begin
f = open(ofile, 'w')
rescue Errno::EACCES
# Fall back to the current directory
f = open(File.basename(ofile), 'w')
end
begin
if File::ALT_SEPARATOR
file = file.tr(File::ALT_SEPARATOR, File::SEPARATOR)
ofile = ofile.tr(File::ALT_SEPARATOR, File::SEPARATOR)
end
lineno = __LINE__
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}"
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
lineno = __LINE__ - lineno - 1
line_file = file
inlines.each{|cfunc_name, (body_lineno, text, locals, func_name)|
if String === cfunc_name
f.puts "static VALUE #{cfunc_name}(struct rb_execution_context_struct *ec, const VALUE self)"
lineno += 1
lineno, str = generate_cexpr(ofile, lineno, line_file, body_lineno, text, locals, func_name)
f.write str
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-07 02:58:00 -05:00
bs.each_pair{|func, (argc, cfunc_name)|
decl = ', VALUE' * argc
argv = argc \
. times \
. map {|i|", argv[#{i}]"} \
. join('')
f.puts %'static void'
f.puts %'mjit_compile_invokebuiltin_for_#{func}(FILE *f, long index, unsigned stack_size, bool inlinable_p)'
f.puts %'{'
f.puts %' fprintf(f, " VALUE self = GET_SELF();\\n");'
f.puts %' fprintf(f, " typedef VALUE (*func)(rb_execution_context_t *, VALUE#{decl});\\n");'
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)
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)
}
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 %' }'
end
f.puts %' fprintf(f, " func f = (func)%"PRIuVALUE"; /* == #{cfunc_name} */\\n", (VALUE)#{cfunc_name});'
f.puts %' fprintf(f, " val = f(ec, self#{argv});\\n");'
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}[] = {"
bs.each.with_index{|(func, (argc, cfunc_name)), i|
f.puts " RB_BUILTIN_FUNCTION(#{i}, #{func}, #{cfunc_name}, #{argc}, mjit_compile_invokebuiltin_for_#{func}),"
2019-11-07 02:58:00 -05: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"
f.puts "COMPILER_WARNING_PUSH"
f.puts "#if GCC_VERSION_SINCE(5, 1, 0) || defined __clang__"
f.puts "COMPILER_WARNING_ERROR(-Wincompatible-pointer-types)"
f.puts "#endif"
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
}
f.puts "COMPILER_WARNING_POP"
2019-11-07 02:58:00 -05:00
f.puts
f.puts " // load"
f.puts " rb_load_with_builtin_functions(#{base.dump}, #{table});"
2019-11-07 02:58:00 -05:00
f.puts "}"
ensure
f.close
end
2019-11-07 02:58:00 -05:00
end
ARGV.each{|file|
# feature.rb => load_feature.inc
mk_builtin_header file
2019-11-07 02:58:00 -05:00
}