infosecn1nja
/
metasploit-framework
mirror of https://github.com/infosecn1nja/metasploit-framework.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
metasploit-framework/lib/metasm/samples/dynamic_ruby.rb

1930 lines
59 KiB
Ruby
Raw Blame History

# This file is part of Metasm, the Ruby assembly manipulation suite
# Copyright (C) 2006-2009 Yoann GUILLOT
#
# Licence is LGPL, see LICENCE in the top-level directory
# This sample hacks in the ruby interpreter to allow dynamic loading of shellcodes as object methods
# Also it allows raw modifications to the ruby interpreter memory, for all kind of purposes
# Includes methods to dump the ruby parser AST from the interpreter memory
# elf/linux/x86 only
require 'metasm'
module Metasm
class RubyHack < DynLdr
# basic C defs for ruby AST - ruby1.8 only !
RUBY_INTERN_NODE = <<EOS
struct node {
long flags;
char *file;
long a1;
long a2;
long a3;
};
#define FL_USHIFT 11
#define nd_type(n) ((((struct node*)n)->flags >> FL_USHIFT) & 0xff)
EOS
NODETYPE = [
:method, :fbody, :cfunc, :scope, :block,
:if, :case, :when, :opt_n, :while,
:until, :iter, :for, :break, :next,
:redo, :retry, :begin, :rescue, :resbody,
:ensure, :and, :or, :not, :masgn,
:lasgn, :dasgn, :dasgn_curr, :gasgn, :iasgn,
:cdecl, :cvasgn, :cvdecl, :op_asgn1, :op_asgn2,
:op_asgn_and, :op_asgn_or, :call, :fcall, :vcall,
:super, :zsuper, :array, :zarray, :hash,
:return, :yield, :lvar, :dvar, :gvar, # 50
:ivar, :const, :cvar, :nth_ref, :back_ref,
:match, :match2, :match3, :lit, :str,
:dstr, :xstr, :dxstr, :evstr, :dregx,
:dregx_once, :args, :argscat, :argspush, :splat,
:to_ary, :svalue, :block_arg, :block_pass, :defn,
:defs, :alias, :valias, :undef, :class,
:module, :sclass, :colon2, :colon3, :cref,
:dot2, :dot3, :flip2, :flip3, :attrset,
:self, :nil, :true, :false, :defined,
:newline, :postexe, :alloca, :dmethod, :bmethod, # 100
:memo, :ifunc, :dsym, :attrasgn, :last
]
new_api_c 'void rb_define_method(uintptr_t, char *, uintptr_t (*)(), int)'
new_api_c 'void *rb_method_node(uintptr_t, unsigned id)'
class << self
def set_class_method_raw(klass, meth, code, nparams)
memory_perm(str_ptr(code), code.length, 'rwx')
rb_define_method(rb_obj_to_value(klass), meth, code, nparams)
end
def get_method_node_ptr(klass, meth)
raise "#{klass.inspect} is not a class" if not klass.kind_of? Module
rb_method_node(rb_obj_to_value(klass), meth.to_sym.to_i)
end
# sets up rawopcodes as the method implementation for class klass
# rawopcodes must implement the expected ABI or things will break horribly
# this method is VERY UNSAFE, and breaks everything put in place by the ruby interpreter
# use with EXTREME CAUTION
# nargs arglist
# -2 self, arg_ary
# -1 argc, VALUE*argv, self
# >=0 self, arg0, arg1..
def set_method_binary(klass, methodname, raw, nargs=nil)
nargs ||= klass.instance_method(methodname).arity
if raw.kind_of? EncodedData
baseaddr = str_ptr(raw.data)
bd = raw.binding(baseaddr)
raw.reloc_externals.uniq.each { |ext| bd[ext] = sym_addr(0, ext) or raise "unknown symbol #{ext}" }
raw.fixup(bd)
raw = raw.data
end
(@@prevent_gc ||= {})[[klass, methodname]] = raw
set_class_method_raw(klass, methodname.to_s, raw, nargs)
end
# same as load_binary_method but with an object and not a class
def set_singleton_method_binary(obj, *a)
set_method_binary((class << obj ; self ; end), *a)
end
def read_method_ast(klass, meth)
read_node get_method_node_ptr(klass, meth)
end
def read_singleton_method_ast(klass, meth)
klass = (class << klass ; self ; end)
read_method_ast(klass, meth)
end
def read_node(ptr, cur=nil)
return if ptr == 0 or ptr == 4
type = NODETYPE[(memory_read_int(ptr) >> 11) & 0xff]
v1 = memory_read_int(ptr+8)
v2 = memory_read_int(ptr+12)
v3 = memory_read_int(ptr+16)
case type
when :block, :array, :hash
cur = nil if cur and cur[0] != type
cur ||= [type]
cur << read_node(v1)
n = read_node(v3, cur)
raise "block->next = #{n.inspect}" if n and n[0] != type
cur
when :newline
read_node(v3) # debug/trace usage only
when :if
[type, read_node(v1), read_node(v2), read_node(v3)]
when :cfunc
v2 = {0xffffffff => -1, 0xfffffffe => -2, 0xffffffffffffffff => -1, 0xfffffffffffffffe => -2}[v2] || v2
[type, {:fptr => v1, # c func pointer
:arity => v2}]
when :scope
[type, {:localnr => (v1 != 0 && v1 != 4 ? memory_read_int(v1) : 0), # nr of local vars (+2 for $_/$~)
:cref => read_node(v2)[1..-1]}, # node, starting point for const/@@var resolution
read_node(v3)]
when :cref
cur = nil if cur and cur[0] != type
cur ||= [type]
cur << rb_value_to_obj(v1) if v1 != 0 and v1 != 4
n = read_node(v3, cur)
raise "block->next = #{n.inspect}" if n and n[0] != type
cur
when :call, :fcall, :vcall
[type, read_node(v1), v2.id2name, read_node(v3)]
when :dstr
ret = [type, [:str, rb_value_to_obj(v1)]]
if args = read_node(v3)
raise "#{ret.inspect} with args != array: #{args.inspect}" if args[0] != :array
ret.concat args[1..-1]
end
ret
when :zarray
[:array]
when :lasgn
[type, v3, read_node(v2)]
when :iasgn, :dasgn, :dasgn_curr, :gasgn, :cvasgn
[type, v1.id2name, read_node(v2)]
when :masgn
# multiple assignment: a, b = 42 / lambda { |x, y| }.call(1, 2)
# v3 = remainder storage (a, b, *c = ary => v3=c)
[type, read_node(v1), read_node(v2), read_node(v3)]
when :attrasgn
[type, ((v1 == 1) ? :self : read_node(v1)), v2.id2name, read_node(v3)]
when :lvar
[type, v3]
when :ivar, :dvar, :gvar, :cvar, :const, :attrset
[type, v1.id2name]
when :str
# cannot use _id2ref here, probably the parser does not use standard alloced objects
s = memory_read(memory_read_int(v1+12), memory_read_int(v1+16))
[type, s]
when :lit
[type, rb_value_to_obj(v1)]
when :args # specialcased by rb_call0, invalid in rb_eval
cnt = v3 # nr of required args, copied directly to local_vars
opt = read_node(v1) # :block to execute for each missing arg / with N optargs specified, skip N 1st statements
rest = read_node(v2) # catchall arg in def foo(rq1, rq2, *rest)
[type, cnt, opt, rest]
when :and, :or
[type, read_node(v1), read_node(v2)] # shortcircuit
when :not
[type, read_node(v2)]
when :nil, :true, :false, :self
[type]
when :redo, :retry
[type]
when :case
# [:case, var_test, [:when, cnd, action, [:when, cnd2, action2, else]]]
# => [:case, var_test, [:when, cnd, action], [:when, cnd2, action], else]
cs = [type, read_node(v1), read_node(v2)]
cs << cs[-1].pop while cs[-1][0] == :when and cs[-1][3]
cs
when :when
# [:when, [:array, [test]], then, else]
[type, read_node(v1), read_node(v2), read_node(v3)]
when :iter
# save a block for the following funcall
args = read_node(v1) # assignments with nil, not realized, just to store the arg list (multi args -> :masgn)
body = read_node(v2) # the body statements (multi -> :block)
subj = read_node(v3) # the stuff which is passed the block, probably a :call
[type, args, body, subj]
when :while, :until
[type, read_node(v1), read_node(v2), v3]
when :return, :break, :next, :defined
[type, read_node(v1)]
when :to_ary
[type, read_node(v1)]
when :colon2
[type, read_node(v1), v2.id2name]
when :colon3 # ::Stuff
[type, v2.id2name]
when :method
[type, v1, read_node(v2), v3]
when :alias
[type, v1, v2, v3] # ?
when :evstr
[type, read_node(v2)]
when :dot2, :dot3
[type, read_node(v1), read_node(v2)]
when :splat
[type, read_node(v1)]
when :argscat
[type, read_node(v1), read_node(v2), v3]
when :block_pass
# [args, block, receiver]: foo(bar, &baz) => [:bpass, [:array, bar], [:lvar, baz], [:call, 'foo', bar]] (args in v1&v3!)
[type, read_node(v1), read_node(v2), read_node(v3)]
when :block_arg
[type, v1.id2name, v2, v3]
when :ensure
[type, read_node(v1), v2, read_node(v3)]
else
puts "unhandled #{type.inspect}"
[type, v1, v2, v3]
end
end
end # class << self
end
# a ruby2c C generator for use in the current ruby interpreter
# generates C suitable for shellcode compilation & insertion in the current interpreter
# has hardcoded addresses etc
class RubyLiveCompiler
attr_accessor :cp
RUBY_H = <<EOS
#{DynLdr::RUBY_H}
VALUE rb_ivar_get(VALUE, unsigned);
VALUE rb_ivar_set(VALUE, unsigned, VALUE);
VALUE rb_ivar_defined(VALUE, unsigned);
VALUE rb_cvar_get(VALUE, unsigned);
VALUE rb_cvar_set(VALUE, unsigned, VALUE, int);
VALUE rb_gv_get(const char*);
VALUE rb_gv_set(const char*, VALUE);
VALUE rb_ary_new(void);
VALUE rb_ary_new4(long, VALUE*);
VALUE rb_ary_push(VALUE, VALUE);
VALUE rb_ary_pop(VALUE);
VALUE rb_ary_shift(VALUE);
VALUE rb_hash_new(void);
VALUE rb_hash_aset(VALUE, VALUE, VALUE);
VALUE rb_str_new(const char*, long);
VALUE rb_str_new2(const char*);
VALUE rb_str_cat2(VALUE, const char*);
VALUE rb_str_concat(VALUE, VALUE);
VALUE rb_str_append(VALUE, VALUE);
VALUE rb_obj_as_string(VALUE);
VALUE rb_range_new(VALUE, VALUE, int exclude_end);
VALUE rb_Array(VALUE); // :splat
VALUE rb_ary_to_ary(VALUE);
VALUE rb_hash_aref(VALUE, VALUE);
VALUE rb_funcall3(VALUE, unsigned, int, VALUE*);
VALUE rb_singleton_class(VALUE);
VALUE rb_block_proc(void);
void rb_define_method(VALUE, char *, VALUE (*)(), int);
void *rb_method_node(VALUE, unsigned);
EOS
class Fail < RuntimeError
end
def self.compile(klass, *methlist)
@rcp ||= new
methlist.each { |meth|
ast = RubyHack.read_method_ast(klass, meth)
n = @rcp.compile(ast, klass, meth)
next if not n
raw = RubyHack.compile_c(@rcp.cp.dump_definition(n)).encoded
RubyHack.set_method_binary(klass, meth, raw)
}
self
end
def dump(m=nil)
m ? @cp.dump_definition(m) : @cp.to_s
end
attr_accessor :optim_hint
def initialize(cp=nil)
@cp = cp || DynLdr.host_cpu.new_cparser
@cp.parse RUBY_H
@iter_break = nil
@optim_hint = {}
end
# convert a ruby AST to a new C function
# returns the new function name
def compile(ast, klass, meth, singleton=false)
return if not ast
# TODO handle arbitrary block/yield constructs
# TODO analyse to find/optimize numeric locals that never need a ruby VALUE (ie native int vs INT2FIX)
# TODO detect block/closure exported out of the func & abort compilation
@klass = klass
@meth = meth
@meth_singleton = singleton
mname = escape_varname("m_#{@klass}#{singleton ? '.' : '#'}#{@meth}".gsub('::', '_'))
@cp.parse "static void #{mname}(VALUE self) { }"
@cur_cfunc = @cp.toplevel.symbol[mname]
@cur_cfunc.type.type = value # return type = VALUE, w/o 'missing return statement' warning
@scope = @cur_cfunc.initializer
case ast[0]
when :ivar # attr_reader
ret = fcall('rb_ivar_get', rb_self, rb_intern(ast[1]))
when :attrset # attr_writer
compile_args(@cur_cfunc, [nil, 1])
ret = fcall('rb_ivar_set', rb_self, rb_intern(ast[1]), local(2))
when :scope # standard ruby function
@cref = ast[1][:cref]
if ast[2] and ast[2][0] == :block and ast[2][1] and ast[2][1][0] == :args
compile_args(@cur_cfunc, ast[2][1])
end
want_value = true
if meth.to_s == 'initialize' and not singleton
want_value = false
end
ret = ast_to_c(ast[2], @scope, want_value)
ret = rb_nil if not want_value
#when :cfunc # native ruby extension
else raise "unhandled function ast #{ast.inspect}"
end
@scope.statements << C::Return.new(ret)
mname
end
# return the arity of method 'name' on self
def method_arity(name=@meth)
@meth_singleton ? @klass.method(name).arity : @klass.instance_method(name).arity
end
# find the scope where constname is defined from @cref
def resolve_const_owner(constname)
@cref.find { |cr| cr.constants.map { |c| c.to_s }.include? constname.to_s }
end
# checks if ast maps to a constant, returns it if it does
def check_const(ast)
case ast[0]
when :const
resolve_const_owner(ast[1])
when :colon2
if cst = check_const(ast[1])
cst.const_get(ast[2])
end
when :colon3
::Object.const_get(ast[2])
end
end
def compile_args(func, args)
case method_arity
when -1 # args[1] == 0 and (args[2] or args[3])
compile_args_m1(func, args)
when -2 # args[1] > 0 and (args[2] or args[3])
compile_args_m2(func, args)
else
# fixed arity = args[1]: VALUE func(VALUE self, VALUE local_2, VALUE local_3)
args[1].times { |i|
v = C::Variable.new("local_#{i+2}", value)
@scope.symbol[v.name] = v
func.type.args << v
}
end
end
# update func prototype to reflect arity -1
# VALUE func(int argc, VALUE *argv, VALUE self)
def compile_args_m1(func, args)
c = C::Variable.new("arg_c", C::BaseType.new(:int, :unsigned))
v = C::Variable.new("arg_v", C::Pointer.new(value))
@scope.symbol[c.name] = c
@scope.symbol[v.name] = v
func.type.args.unshift v
func.type.args.unshift c
args[1].times { |i|
local(i+2, C::CExpression[v, :'[]', [i]])
}
if args[2]
# [:block, [:lasgn, 2, [:lit, 4]]]
raise Fail, "unhandled vararglist #{args.inspect}" if args[2][0] != :block
args[2][1..-1].each_with_index { |a, i|
raise Fail, "unhandled arg #{a.inspect}" if a[0] != :lasgn
cnd = C::CExpression[c, :>, i]
thn = C::CExpression[local(a[1], :none), :'=', [v, :'[]', [i]]]
els = C::Block.new(@scope)
ast_to_c(a, els, false)
@scope.statements << C::If.new(cnd, thn, els)
}
end
if args[3]
raise Fail, "unhandled vararglist3 #{args.inspect}" if args[3][0] != :lasgn
skiplen = args[1] + args[2].length - 1
alloc = fcall('rb_ary_new4', [c, :-, [skiplen]], [v, :+, [skiplen]])
local(args[3][1], C::CExpression[[c, :>, skiplen], :'?:', [alloc, fcall('rb_ary_new')]])
end
end
# update func prototype to reflect arity -2
# VALUE func(VALUE self, VALUE arg_array)
def compile_args_m2(func, args)
v = C::Variable.new("arglist", value)
@scope.symbol[v.name] = v
func.type.args << v
args[1].times { |i|
local(i+2, fcall('rb_ary_shift', v))
}
# populate arguments with default values
if args[2]
# [:block, [:lasgn, 2, [:lit, 4]]]
raise Fail, "unhandled vararglist #{args.inspect}" if args[2][0] != :block
args[2][1..-1].each { |a|
raise Fail, "unhandled arg #{a.inspect}" if a[0] != :lasgn
t = C::CExpression[local(a[1], :none), :'=', fcall('rb_ary_shift', v)]
e = C::Block.new(@scope)
ast_to_c([:lasgn, a[1], a[2]], e, false)
@scope.statements << C::If.new(rb_ary_len(v), t, e)
}
end
if args[3]
raise Fail, "unhandled vararglist3 #{args.inspect}" if args[3][0] != :lasgn
local(args[3][1], C::CExpression[v])
end
end
# compile a case/when
# create a real C switch() for Fixnums, and put the others === in the default case
# XXX will get the wrong order for "case x; when 1; when Fixnum; when 3;" ...
def compile_case(ast, scope, want_value)
# this generates
# var = stuff_to_test()
# if (var & 1)
# switch (var >> 1) {
# case 12:
# stuff();
# break;
# default:
# goto default_case;
# }
# else
# default_case:
# if (var == true.object_id || rb_test(rb_funcall(bla, '===', var)))
# foo();
# else {
# default();
# }
#
if want_value == true
ret = get_new_tmp_var('case', want_value)
want_value = ret
elsif want_value
ret = want_value
end
var = ast_to_c(ast[1], scope, want_value || true)
if not var.kind_of? C::Variable
ret ||= get_new_tmp_var('case', want_value)
scope.statements << C::CExpression[ret, :'=', var]
var = ret
end
# the scope to put all case int in
body_int = C::Block.new(scope)
# the scope to put the if (cs === var) cascade
body_other_head = body_other = nil
default = nil
ast[2..-1].each { |cs|
if cs[0] == :when
raise Fail if cs[1][0] != :array
# numeric case, add a case to body_int
if cs[1][1..-1].all? { |cd| cd[0] == :lit and (cd[1].kind_of? Fixnum or cd[1].kind_of? Range) }
cs[1][1..-1].each { |cd|
if cd[1].kind_of? Range
b = cd[1].begin
e = cd[1].end
e -= 1 if cd[1].exclude_end?
raise Fail unless b.kind_of? Integer and e.kind_of? Integer
body_int.statements << C::Case.new(b, e, nil)
else
body_int.statements << C::Case.new(cd[1], nil, nil)
end
}
cb = C::Block.new(scope)
v = ast_to_c(cs[2], cb, want_value)
cb.statements << C::CExpression[ret, :'=', v] if want_value and v != ret
cb.statements << C::Break.new
body_int.statements << cb
# non-numeric (or mixed) case, add if ( cs === var )
else
cnd = nil
cs[1][1..-1].each { |cd|
if (cd[0] == :lit and (cd[1].kind_of?(Fixnum) or cd[1].kind_of?(Symbol))) or
[:nil, :true, :false].include?(cd[0])
# true C equality
cd = C::CExpression[var, :==, ast_to_c(cd, scope)]
else
# own block for ast_to_c to honor lazy evaluation
tb = C::Block.new(scope)
test = rb_test(rb_funcall(ast_to_c(cd, tb), '===', var), tb)
# discard own block unless needed
if tb.statements.empty?
cd = test
else
tb.statements << test
cd = C::CExpression[tb, value]
end
end
cnd = (cnd ? C::CExpression[cnd, :'||', cd] : cd)
}
cb = C::Block.new(scope)
v = ast_to_c(cs[2], cb, want_value)
cb.statements << C::CExpression[ret, :'=', v] if want_value and v != ret
fu = C::If.new(cnd, cb, nil)
if body_other
body_other.belse = fu
else
body_other_head = fu
end
body_other = fu
end
# default case statement
else
cb = C::Block.new(scope)
v = ast_to_c(cs, cb, want_value)
cb.statements << C::CExpression[ret, :'=', v] if want_value and v != ret
default = cb
end
}
# if we use the value of the case, we must add an 'else: nil'
if want_value and not default
default = C::Block.new(scope)
default.statements << C::CExpression[ret, :'=', rb_nil]
end
# assemble everything
scope.statements <<
if body_int.statements.empty?
if body_other
body_other.belse = default
body_other_head
else
raise Fail, "empty case? #{ast.inspect}" if not default
default
end
else
if body_other_head
@default_label_cnt ||= 0
dfl = "default_label_#{@default_label_cnt += 1}"
body_other_head = C::Label.new(dfl, body_other_head)
body_int.statements << C::Case.new('default', nil, C::Goto.new(dfl))
body_other.belse = default if default
end
body_int = C::Switch.new(C::CExpression[var, :>>, 1], body_int)
C::If.new(C::CExpression[var, :&, 1], body_int, body_other_head)
end
ret
end
# create a C::CExpr[toplevel.symbol[name], :funcall, args]
# casts int/strings in arglist to CExpr
def fcall(fname, *arglist)
args = arglist.map { |a| (a.kind_of?(Integer) or a.kind_of?(String)) ? [a] : a }
fv = @cp.toplevel.symbol[fname]
raise "need prototype for #{fname}!" if not fv
C::CExpression[fv, :funcall, args]
end
# the VALUE typedef
def value
@cp.toplevel.symbol['VALUE']
end
# declare a new function variable
# no initializer if init == :none
def declare_newvar(name, initializer)
v = C::Variable.new(name, value)
v.initializer = initializer if initializer != :none
@scope.symbol[v.name] = v
@scope.statements << C::Declaration.new(v)
v
end
# return a string suitable for use as a variable name
# hexencode any char not in [A-z0-9_]
def escape_varname(n)
n.gsub(/[^\w]/) { |c| c.unpack('H*')[0] }
end
# retrieve or create a local var
# pass :none to avoid initializer
def get_var(name, initializer=:none)
name = escape_varname(name)
@scope.symbol[name] ||= declare_newvar(name, initializer || rb_nil)
end
# create a new temporary variable
# XXX put_var ?
def get_new_tmp_var(base=nil, var=nil)
return var if var.kind_of? C::Variable
@tmp_var_id ||= 0
get_var("tmp_#{"#{base}_" if base}#{@tmp_var_id += 1}")
end
# retrieve/create a new local variable with optionnal initializer
def local(n, init=nil)
get_var "local_#{n}", init
end
# retrieve/create a new dynamic variable (block argument/variable)
# pass :none to avoid initializer
def dvar(n, init=nil)
get_var "dvar_#{n}", init
end
# retrieve self (1st func arg)
def rb_self
@scope.symbol['self']
end
# returns a CExpr casting expr to a VALUE*
def rb_cast_pvalue(expr, idx)
C::CExpression[[[expr], C::Pointer.new(value)], :'[]', [idx]]
end
# retrieve the current class, from self->klass
# XXX will segfault with self.kind_of? Fixnum/true/false/nil/sym
def rb_selfclass
rb_cast_pvalue(rb_self, 1)
end
def rb_nil
C::CExpression[[nil.object_id], value]
end
def rb_true
C::CExpression[[true.object_id], value]
end
def rb_false
C::CExpression[[false.object_id], value]
end
# call rb_intern on a string
def rb_intern(n)
# use the current interpreter's value
C::CExpression[n.to_sym.to_i]
end
# create a rb_funcall construct
def rb_funcall(recv, meth, *args)
fcall('rb_funcall', recv, rb_intern(meth), args.length, *args)
end
# ruby bool test of a var
# assigns to a temporary var, and check against false/nil
def rb_test(expr, scope)
if nil.object_id == 0 or false.object_id == 0 # just to be sure
nf = nil.object_id | false.object_id
C::CExpression[[expr, :|, nf], :'!=', nf]
else
if expr.kind_of? C::Variable
tmp = expr
else
tmp = get_new_tmp_var('test')
scope.statements << C::CExpression[tmp, :'=', expr]
end
C::CExpression[[tmp, :'!=', rb_nil], :'&&', [tmp, :'!=', rb_false]]
end
end
# generate C code to raise a RuntimeError, reason
def rb_raise(reason, cls='rb_eRuntimeError')
fcall('rb_raise', rb_global(cls), reason)
end
# return a C expr equivallent to TYPE(expr) == type for non-immediate types
# XXX expr evaluated 3 times
def rb_test_class_type(expr, type)
C::CExpression[[[expr, :>, [7]], :'&&', [[expr, :&, [3]], :==, [0]]], :'&&', [[rb_cast_pvalue(expr, 0), :&, [0x3f]], :'==', [type]]]
end
# return a C expr equivallent to TYPE(expr) == T_ARRAY
def rb_test_class_ary(expr)
rb_test_class_type(expr, 9)
end
# ARY_PTR(expr)
def rb_ary_ptr(expr, idx=nil)
p = C::CExpression[[rb_cast_pvalue(expr, 4)], C::Pointer.new(value)]
idx ? C::CExpression[p, :'[]', [idx]] : p
end
# ARY_LEN(expr)
def rb_ary_len(expr)
rb_cast_pvalue(expr, 2)
end
# TYPE(expr) == T_STRING
def rb_test_class_string(expr)
rb_test_class_type(expr, 7)
end
# STR_PTR(expr)
def rb_str_ptr(expr, idx=nil)
p = C::CExpression[[rb_cast_pvalue(expr, 3)], C::Pointer.new(C::BaseType.new(:char))]
idx ? C::CExpression[p, :'[]', [idx]] : p
end
# STR_LEN(expr)
def rb_str_len(expr)
rb_cast_pvalue(expr, 2)
end
def rb_test_class_hash(expr)
rb_test_class_type(expr, 0xb)
end
# returns a static pointer to the constant
def rb_const(constname, owner = resolve_const_owner(constname))
raise Fail, "no dynamic constant resolution #{constname}" if not owner
cst = owner.const_get(constname)
C::CExpression[[RubyHack.rb_obj_to_value(cst)], value]
end
# compile a :masgn
def rb_masgn(ast, scope, want_value)
raise Fail, "masgn with no rhs #{ast.inspect}" if not ast[2]
raise Fail, "masgn with no lhs array #{ast.inspect}" if not ast[1] or ast[1][0] != :array
if not want_value and ast[2][0] == :array and not ast[3] and ast[2].length == ast[1].length
rb_masgn_optimized(ast, scope)
return nil.object_id
end
full = get_new_tmp_var('masgn', want_value)
ary = ast_to_c(ast[2], scope, full)
scope.statements << C::CExpression[full, :'=', ary] if full != ary
ast[1][1..-1].each_with_index { |e, i|
raise Fail, "weird masgn lhs #{e.inspect} in #{ast.inspect}" if e[-1] != nil
# local_42 = full[i]
e = e.dup
e[-1] = [:rb2cstmt, rb_ary_ptr(full, i)]
ast_to_c(e, scope, false)
}
if ast[3]
raise Fail, "weird masgn lhs #{e.inspect} in #{ast.inspect}" if ast[3][-1] != nil
# local_28 = full[12..-1].to_a
e = ast[3].dup
e[-1] = [:call, [:call, [:rb2cvar, full.name], '[]', [:array, [:dot2, [:lit, ast[1].length-1], [:lit, -1]]]], 'to_a']
ast_to_c(e, scope, false)
end
full
end
def rb_global(cname)
@cp.toplevel.symbol[cname]
end
# compile an optimized :masgn with rhs.length == lhs.length (no need of a ruby array)
def rb_masgn_optimized(ast, scope)
vars = []
ast[2][1..-1].each { |rhs|
var = get_new_tmp_var('masgn_opt')
vars << var
r = ast_to_c(rhs, scope, var)
scope.statements << C::CExpression[var, :'=', r] if var != r
}
ast[1][1..-1].each { |lhs|
var = vars.shift
lhs = lhs.dup
raise Fail, "weird masgn lhs #{lhs.inspect} in #{ast.inspect}" if lhs[-1] != nil
lhs[-1] = [:rb2cvar, var.name]
ast_to_c(lhs, scope, false)
}
end
# the recursive AST to C compiler
# may append C statements to scope
# returns the C::CExpr holding the VALUE of the current ruby statement
# want_value is an optionnal hint as to the returned VALUE is needed or not
# if want_value is a C::Variable, the statements should try to populate this var instead of some random tmp var
# eg to simplify :if encoding unless we have 'foo = if 42;..'
def ast_to_c(ast, scope, want_value = true)
ret =
case ast.to_a[0]
when :block
if ast[1]
ast[1..-2].each { |a| ast_to_c(a, scope, false) }
ast_to_c(ast.last, scope, want_value)
end
when :lvar
local(ast[1])
when :lasgn
if scope == @scope
l = local(ast[1], :none)
else
# w = 4 if false ; p w => should be nil
l = local(ast[1])
end
st = ast_to_c(ast[2], scope, l)
scope.statements << C::CExpression[l, :'=', st] if st != l
l
when :dvar
dvar(ast[1])
when :dasgn_curr
l = dvar(ast[1])
st = ast_to_c(ast[2], scope, l)
scope.statements << C::CExpression[l, :'=', st] if st != l
l
when :ivar
fcall('rb_ivar_get', rb_self, rb_intern(ast[1]))
when :iasgn
if want_value
tmp = get_new_tmp_var("ivar_#{ast[1]}", want_value)
scope.statements << C::CExpression[tmp, :'=', ast_to_c(ast[2], scope)]
scope.statements << fcall('rb_ivar_set', rb_self, rb_intern(ast[1]), tmp)
tmp
else
scope.statements << fcall('rb_ivar_set', rb_self, rb_intern(ast[1]), ast_to_c(ast[2], scope))
end
when :cvar
fcall('rb_cvar_get', rb_selfclass, rb_intern(ast[1]))
when :cvasgn
if want_value
tmp = get_new_tmp_var("cvar_#{ast[1]}", want_value)
scope.statements << C::CExpression[tmp, :'=', ast_to_c(ast[2], scope)]
scope.statements << fcall('rb_cvar_set', rb_selfclass, rb_intern(ast[1]), tmp, rb_false)
tmp
else
scope.statements << fcall('rb_cvar_set', rb_selfclass, rb_intern(ast[1]), ast_to_c(ast[2], scope), rb_false)
end
when :gvar
fcall('rb_gv_get', ast[1])
when :gasgn
if want_value
tmp = get_new_tmp_var("gvar_#{ast[1]}", want_value)
scope.statements << C::CExpression[tmp, :'=', ast_to_c(ast[2], scope)]
scope.statements << fcall('rb_gv_set', ast[1], tmp)
tmp
else
scope.statements << fcall('rb_gv_set', ast[1], ast_to_c(ast[2], scope))
end
when :attrasgn # foo.bar= 42 (same as :call, except for return value)
recv = ast_to_c(ast[1], scope)
raise Fail, "unsupported #{ast.inspect}" if not ast[3] or ast[3][0] != :array
if ast[3].length != 2
if ast[2] != '[]=' or ast[3].length != 3
raise Fail, "unsupported #{ast.inspect}"
end
# foo[4] = 2
idx = ast_to_c(ast[3][1], scope)
end
arg = ast_to_c(ast[3].last, scope)
if want_value
tmp = get_new_tmp_var('call', want_value)
scope.statements << C::CExpression[tmp, :'=', arg]
end
if idx
scope.statements << rb_funcall(recv, ast[2], idx, arg)
else
scope.statements << rb_funcall(recv, ast[2], arg)
end
tmp
when :rb2cvar # hax, used in vararg parsing
get_var(ast[1])
when :rb2cstmt
ast[1]
when :block_arg
local(ast[3], fcall('rb_block_proc'))
when :lit
case ast[1]
when Symbol
# XXX ID2SYM
C::CExpression[[rb_intern(ast[1].to_s), :<<, 8], :|, 0xe]
when Range
fcall('rb_range_new', ast[1].begin.object_id, ast[1].end.object_id, ast[1].exclude_end? ? 0 : 1)
else # true/false/nil/fixnum
ast[1].object_id
end
when :self
rb_self
when :str
fcall('rb_str_new2', ast[1])
when :array
tmp = get_new_tmp_var('ary', want_value)
scope.statements << C::CExpression[tmp, :'=', fcall('rb_ary_new')]
ast[1..-1].each { |e|
scope.statements << fcall('rb_ary_push', tmp, ast_to_c(e, scope))
}
tmp
when :hash
raise Fail, "bad #{ast.inspect}" if ast[1][0] != :array
tmp = get_new_tmp_var('hash', want_value)
scope.statements << C::CExpression[tmp, :'=', fcall('rb_hash_new')]
ki = nil
ast[1][1..-1].each { |k|
if not ki
ki = k
else
scope.statements << fcall('rb_hash_aset', tmp, ast_to_c(ki, scope), ast_to_c(k, scope))
ki = nil
end
}
tmp
when :iter
if v = optimize_iter(ast, scope, want_value)
return v
end
# for full support of :iter, we need access to the interpreter's ruby_block private global variable in eval.c
# we can find it by analysing rb_block_given_p, but this won't work with a static precompiled rubyhack...
# even with access to ruby_block, there we would need to redo PUSH_BLOCK, create a temporary dvar list,
# handle [:break, lol], and do all the stack magic reused in rb_yield (probably incl setjmp etc)
raise Fail, "unsupported iter #{ast[3].inspect} { | #{ast[1].inspect} | #{ast[2].inspect} }"
when :call, :vcall, :fcall
if v = optimize_call(ast, scope, want_value)
return v
end
recv = ((ast[0] == :call) ? ast_to_c(ast[1], scope) : rb_self)
if not ast[3]
f = rb_funcall(recv, ast[2])
elsif ast[3][0] == :array
args = ast[3][1..-1].map { |a| ast_to_c(a, scope) }
f = rb_funcall(recv, ast[2], *args)
elsif ast[3][0] == :splat
args = ast_to_c(ast[3], scope)
if not args.kind_of? C::Variable
tmp = get_new_tmp_var('args', want_value)
scope.statements << C::CExpression[tmp, :'=', args]
args = tmp
end
f = fcall('rb_funcall3', recv, rb_intern(ast[2]), rb_ary_len(args), rb_ary_ptr(args))
# elsif ast[3][0] == :argscat
else
raise Fail, "unsupported #{ast.inspect}"
end
if want_value
tmp ||= get_new_tmp_var('call', want_value)
scope.statements << C::CExpression[tmp, :'=', f]
tmp
else
scope.statements << f
f
end
when :if, :when
if ast[0] == :when and ast[1][0] == :array
cnd = nil
ast[1][1..-1].map { |cd| rb_test(ast_to_c(cd, scope), scope) }.each { |cd|
cnd = (cnd ? C::CExpression[cnd, :'||', cd] : cd)
}
else
cnd = rb_test(ast_to_c(ast[1], scope), scope)
end
tbdy = C::Block.new(scope)
ebdy = C::Block.new(scope) if ast[3] or want_value
if want_value
tmp = get_new_tmp_var('if', want_value)
thn = ast_to_c(ast[2], tbdy, tmp)
tbdy.statements << C::CExpression[tmp, :'=', thn] if tmp != thn
if ast[3]
els = ast_to_c(ast[3], ebdy, tmp)
else
# foo = if bar ; baz ; end => nil if !bar
els = rb_nil
end
ebdy.statements << C::CExpression[tmp, :'=', els] if tmp != els
else
ast_to_c(ast[2], tbdy, false)
ast_to_c(ast[3], ebdy, false)
end
scope.statements << C::If.new(cnd, tbdy, ebdy)
tmp
when :while, :until
pib = @iter_break
@iter_break = nil # XXX foo = while ()...
body = C::Block.new(scope)
if ast[3] == 0 # do .. while();
ast_to_c(ast[2], body, false)
end
t = nil
e = C::Break.new
t, e = e, t if ast[0] == :until
body.statements << C::If.new(rb_test(ast_to_c(ast[1], body), body), t, e)
if ast[3] != 0 # do .. while();
ast_to_c(ast[2], body, false)
end
scope.statements << C::For.new(nil, nil, nil, body)
@iter_break = pib
nil.object_id
when :and, :or, :not
# beware lazy evaluation !
tmp = get_new_tmp_var('and', want_value)
v1 = ast_to_c(ast[1], scope, tmp)
# and/or need that tmp has the actual v1 value (returned when shortcircuit)
scope.statements << C::CExpression[tmp, :'=', v1] if v1 != tmp
v1 = tmp
case ast[0]
when :and
t = C::Block.new(scope)
v2 = ast_to_c(ast[2], t, tmp)
t.statements << C::CExpression[tmp, :'=', v2] if v2 != tmp
when :or
e = C::Block.new(scope)
v2 = ast_to_c(ast[2], e, tmp)
e.statements << C::CExpression[tmp, :'=', v2] if v2 != tmp
when :not
t = C::CExpression[tmp, :'=', rb_false]
e = C::CExpression[tmp, :'=', rb_true]
end
scope.statements << C::If.new(rb_test(v1, scope), t, e)
tmp
when :return
scope.statements << C::Return.new(ast_to_c(ast[1], scope))
nil.object_id
when :break
if @iter_break
v = (ast[1] ? ast_to_c(ast[1], scope, @iter_break) : nil.object_id)
scope.statements << C::CExpression[@iter_break, :'=', [[v], value]] if @iter_break != v
end
scope.statements << C::Break.new
nil.object_id
when nil, :args
nil.object_id
when :nil
rb_nil
when :false
rb_false
when :true
rb_true
when :const
rb_const(ast[1])
when :colon2
if cst = check_const(ast[1])
rb_const(ast[2], cst)
else
fcall('rb_const_get', ast_to_c(ast[1], scope), rb_intern(ast[2]))
end
when :colon3
rb_const(ast[1], ::Object)
when :defined
case ast[1][0]
when :ivar
fcall('rb_ivar_defined', rb_self, rb_intern(ast[1][1]))
else
raise Fail, "unsupported #{ast.inspect}"
end
when :masgn
# parallel assignment: put everything in an Array, then pop everything back?
rb_masgn(ast, scope, want_value)
when :evstr
fcall('rb_obj_as_string', ast_to_c(ast[1], scope))
when :dot2, :dot3
fcall('rb_range_new', ast_to_c(ast[1], scope), ast_to_c(ast[2], scope), ast[0] == :dot2 ? 0 : 1)
when :splat
fcall('rb_Array', ast_to_c(ast[1], scope))
when :to_ary
fcall('rb_ary_to_ary', ast_to_c(ast[1], scope))
when :dstr
# dynamic string: "foo#{bar}baz"
tmp = get_new_tmp_var('dstr')
scope.statements << C::CExpression[tmp, :'=', fcall('rb_str_new2', ast[1][1])]
ast[2..-1].compact.each { |s|
if s[0] == :str # directly append the char*
scope.statements << fcall('rb_str_cat2', tmp, s[1])
else
scope.statements << fcall('rb_str_append', tmp, ast_to_c(s, scope))
end
}
tmp
when :case
compile_case(ast, scope, want_value)
when :ensure
# TODO
ret = ast_to_c(ast[1], scope, want_value)
ast_to_c(ast[3], scope, false)
ret
else
raise Fail, "unsupported #{ast.inspect}"
end
if want_value
ret = C::CExpression[[ret], value] if ret.kind_of? Integer or ret.kind_of? String
ret
end
end
# optional optimization of a call (eg a == 1, c+2, ...)
# return nil for normal rb_funcall, or a C::CExpr to use as retval.
def optimize_call(ast, scope, want_value)
ce = C::CExpression
op = ast[2]
int = C::BaseType.new(:ptr) # signed VALUE
args = ast[3][1..-1] if ast[3] and ast[3][0] == :array
arg0 = args[0] if args and args[0]
if arg0 and arg0[0] == :lit and arg0[1].kind_of? Fixnum
# optimize 'x==42', 'x+42', 'x-42'
o2 = arg0[1]
return if not %w[== > < >= <= + -].include? op
if o2 < 0 and ['+', '-'].include? op
# need o2 >= 0 for overflow detection
op = {'+' => '-', '-' => '+'}[op]
o2 = -o2
return if not o2.kind_of? Fixnum # -0x40000000
end
int_v = o2.object_id
recv = ast_to_c(ast[1], scope)
tmp = get_new_tmp_var('opt', want_value)
if not recv.kind_of? C::Variable
scope.statements << ce[tmp, :'=', recv]
recv = tmp
end
case op
when '=='
# XXX assume == only return true for full equality: if not Fixnum, then always false
# which breaks 1.0 == 1 and maybe others, but its ok
scope.statements << C::If.new(ce[recv, :'==', [int_v]], ce[tmp, :'=', rb_true], ce[tmp, :'=', rb_false])
when '>', '<', '>=', '<='
# do the actual comparison on signed >>1 if both Fixnum
t = C::If.new(
ce[[[[recv], int], :>>, [1]], op.to_sym, [[[int_v], int], :>>, [1]]],
ce[tmp, :'=', rb_true],
ce[tmp, :'=', rb_false])
# fallback to actual rb_funcall
e = ce[tmp, :'=', rb_funcall(recv, op, o2.object_id)]
add_optimized_statement scope, ast[1], recv, 'fixnum' => t, 'other' => e
when '+'
e = ce[recv, :+, [int_v-1]] # overflow to Bignum ?
cnd = ce[[recv, :&, [1]], :'&&', [[[recv], int], :<, [[e], int]]]
t = ce[tmp, :'=', e]
e = ce[tmp, :'=', rb_funcall(recv, op, o2.object_id)]
if @optim_hint[ast[1]] == 'fixnum'
# add_optimized_statement wont handle the overflow check correctly
scope.statements << t
else
scope.statements << C::If.new(cnd, t, e)
end
when '-'
e = ce[recv, :-, [int_v-1]]
cnd = ce[[recv, :&, [1]], :'&&', [[[recv], int], :>, [[e], int]]]
t = ce[tmp, :'=', e]
e = ce[tmp, :'=', rb_funcall(recv, op, o2.object_id)]
if @optim_hint[ast[1]] == 'fixnum'
scope.statements << t
else
scope.statements << C::If.new(cnd, t, e)
end
end
tmp
# Symbol#==
elsif arg0 and arg0[0] == :lit and arg0[1].kind_of? Symbol and op == '=='
s_v = ast_to_c(arg0, scope)
tmp = get_new_tmp_var('opt', want_value)
recv = ast_to_c(ast[1], scope, tmp)
if not recv.kind_of? C::Variable
scope.statements << ce[tmp, :'=', recv]
recv = tmp
end
scope.statements << C::If.new(ce[recv, :'==', [s_v]], ce[tmp, :'=', rb_true], ce[tmp, :'=', rb_false])
tmp
elsif arg0 and op == '<<'
tmp = get_new_tmp_var('opt', want_value)
recv = ast_to_c(ast[1], scope, tmp)
arg = ast_to_c(arg0, scope)
if recv != tmp
scope.statements << ce[tmp, :'=', recv]
recv = tmp
end
ar = fcall('rb_ary_push', recv, arg)
st = fcall('rb_str_concat', recv, arg)
oth = rb_funcall(recv, op, arg)
oth = ce[tmp, :'=', oth] if want_value
add_optimized_statement scope, ast[1], recv, 'ary' => ar, 'string' => st, 'other' => oth
tmp
elsif arg0 and args.length == 1 and op == '[]'
return if ast[1][0] == :const # Expression[42]
tmp = get_new_tmp_var('opt', want_value)
recv = ast_to_c(ast[1], scope, tmp)
if not recv.kind_of? C::Variable
scope.statements << ce[tmp, :'=', recv]
recv = tmp
end
idx = get_new_tmp_var('idx')
arg = ast_to_c(arg0, scope, idx)
if not arg.kind_of? C::Variable
scope.statements << ce[idx, :'=', arg]
arg = idx
end
idx = ce[[idx], int]
ar = C::Block.new(scope)
ar.statements << ce[idx, :'=', [[[arg], int], :>>, [1]]]
ar.statements << C::If.new(ce[idx, :<, [0]], ce[idx, :'=', [idx, :+, rb_ary_len(recv)]], nil)
ar.statements << C::If.new(ce[[idx, :<, [0]], :'||', [idx, :>=, [[rb_ary_len(recv)], int]]],
ce[tmp, :'=', rb_nil],
ce[tmp, :'=', rb_ary_ptr(recv, idx)])
st = C::Block.new(scope)
st.statements << ce[idx, :'=', [[[arg], int], :>>, [1]]]
st.statements << C::If.new(ce[idx, :<, [0]], ce[idx, :'=', [idx, :+, rb_str_len(recv)]], nil)
st.statements << C::If.new(ce[[idx, :<, [0]], :'||', [idx, :>=, [[rb_str_len(recv)], int]]],
ce[tmp, :'=', rb_nil],
ce[tmp, :'=', [[[[rb_str_ptr(recv, idx), :&, [0xff]], :<<, [1]], :|, [1]], value]])
hsh = ce[tmp, :'=', fcall('rb_hash_aref', recv, arg)]
oth = ce[tmp, :'=', rb_funcall(recv, op, arg)]
# ary/string only valid with fixnum argument !
add_optimized_statement scope, ast[1], recv, 'hash' => hsh, 'other' => oth,
'ary_bnd' => ce[tmp, :'=', rb_ary_ptr(recv, ce[[[arg], int], :>>, [1]])],
ce[[arg, :&, 1], :'&&', rb_test_class_ary(recv)] => ar,
ce[[arg, :&, 1], :'&&', rb_test_class_string(recv)] => st
tmp
elsif ast[1] and not arg0 and op == 'empty?'
tmp = get_new_tmp_var('opt', want_value)
recv = ast_to_c(ast[1], scope, tmp)
if not recv.kind_of? C::Variable
scope.statements << ce[tmp, :'=', recv]
recv = tmp
end
ar = C::If.new(rb_ary_len(recv), ce[tmp, :'=', rb_false], ce[tmp, :'=', rb_true])
add_optimized_statement scope, ast[1], recv, 'ary' => ar,
'other' => ce[tmp, :'=', rb_funcall(recv, op)]
tmp
elsif ast[1] and not arg0 and op == 'pop'
tmp = get_new_tmp_var('opt', want_value)
recv = ast_to_c(ast[1], scope, tmp)
if not recv.kind_of? C::Variable
scope.statements << ce[tmp, :'=', recv]
recv = tmp
end
t = fcall('rb_ary_pop', recv)
e = rb_funcall(recv, op)
if want_value
t = ce[tmp, :'=', t]
e = ce[tmp, :'=', e]
end
add_optimized_statement scope, ast[1], recv, 'ary' => t, 'other' => e
tmp
elsif ast[1] and op == 'kind_of?' and arg0 and (arg0[0] == :const or arg0[0] == :colon3)
# TODO check const maps to toplevel when :const
test =
case arg0[1]
when 'Symbol'
tmp = get_new_tmp_var('kindof', want_value)
ce[[ast_to_c(ast[1], scope, tmp), :'&', [0xf]], :'==', [0xe]]
#when 'Numeric', 'Integer'
when 'Fixnum'
tmp = get_new_tmp_var('kindof', want_value)
ce[ast_to_c(ast[1], scope, tmp), :'&', [0x1]]
when 'Array'
rb_test_class_ary(ast_to_c(ast[1], scope))
when 'String'
rb_test_class_string(ast_to_c(ast[1], scope))
else return
end
puts "shortcut may be incorrect for #{ast.inspect}" if arg0[0] == :const
tmp ||= get_new_tmp_var('kindof', want_value)
scope.statements << C::If.new(test, ce[tmp, :'=', rb_true], ce[tmp, :'=', rb_false])
tmp
elsif not ast[1] or ast[1] == [:self]
optimize_call_static(ast, scope, want_value)
end
end
# check if the var falls in an optim_hint, if so generate only selected code
# optim is a hash varclass (keyof @optim_hint) => c_stmt
# optim key can also be a C::Stmt that is used in the If clause
# if optim['ary'] == optim['ary_bnd'], you can omit the latter
# must have an 'other' key that is calls the generic ruby method
def add_optimized_statement(scope, varid, varc, optim={})
cat = @optim_hint[varid]
cat = 'ary' if cat == 'ary_bnd' and not optim['ary_bnd']
if not st = optim[cat]
st = optim['other']
if not cat and optim.keys.all? { |k| k.kind_of? String }
# no need to cascade if we have a hash and can optim ary only
optim.each { |i, s|
case i
when 'ary'; st = C::If.new(rb_test_class_ary(varc), s, st)
when 'hash'; st = C::If.new(rb_test_class_hash(varc), s, st)
when 'string'; st = C::If.new(rb_test_class_string(varc), s, st)
when 'other'; # already done as default case
when 'fixnum'; # add test last
when C::Statement; st = C::If.new(i, s, st)
end
}
if fs = optim['fixnum']
# first test to perform (fast path)
st = C::If.new(C::CExpression[varc, :&, 1], fs, st)
end
end
end
scope.statements << st
end
# return ptr, arity
# ptr is a CExpr pointing to the C func implementing klass#method
def get_cfuncptr(klass, method, singleton=false)
cls = singleton ? (class << klass ; self ; end) : klass
ptr = RubyHack.get_method_node_ptr(cls, method)
return if ptr == 0
ftype = RubyHack::NODETYPE[(RubyHack.memory_read_int(ptr) >> 11) & 0xff]
return if ftype != :cfunc
fast = RubyHack.read_node(ptr)
arity = fast[1][:arity]
fptr = fast[1][:fptr]
fproto = C::Function.new(value, [])
case arity
when -1; fproto.args << C::Variable.new(nil, C::BaseType.new(:int)) << C::Variable.new(nil, C::Pointer.new(value)) << C::Variable.new(nil, value)
when -2; fproto.args << C::Variable.new(nil, value) << C::Variable.new(nil, value)
else (arity+1).times { fproto.args << C::Variable.new(nil, value) }
end
C::CExpression[[fptr], C::Pointer.new(fproto)]
end
# call C funcs directly
# assume private function calls are not virtual and hardlink them here
def optimize_call_static(ast, scope, want_value)
arity = method_arity(ast[2]) rescue return
if ast[2].to_s == @meth.to_s
# self is recursive
fptr = @cur_cfunc
else
fptr = get_cfuncptr(@klass, ast[2], @meth_singleton)
return if not fptr
end
c_arglist = []
if not ast[3]
args = []
elsif ast[3][0] == :array
args = ast[3][1..-1]
elsif ast[3][0] == :splat
args = ast_to_c(ast[3], scope)
if arity != -2 and !args.kind_of?(C::Variable)
tmp = get_new_tmp_var('arg')
scope.statements << C::CExpression[tmp, :'=', args]
args = tmp
end
case arity
when -2
c_arglist << rb_self << args
when -1
c_arglist << [rb_ary_len(args)] << rb_ary_ptr(args) << rb_self
else
cnd = C::CExpression[rb_ary_len(args), :'!=', [arity]]
scope.statements << C::If.new(cnd, rb_raise("#{arity} args expected", 'rb_eArgumentError'), nil)
c_arglist << rb_self
arity.times { |i| c_arglist << rb_ary_ptr(args, i) }
end
arity = :canttouchthis
else return # TODO
end
case arity
when :canttouchthis
when -2
arg = get_new_tmp_var('arg')
scope.statements << C::CExpression[arg, :'=', fcall('rb_ary_new')]
args.each { |a|
scope.statements << fcall('rb_ary_push', arg, ast_to_c(a, scope))
}
c_arglist << rb_self << arg
when -1
case args.length
when 0
argv = C::CExpression[[0], C::Pointer.new(value)]
when 1
val = ast_to_c(args[0], scope)
if not val.kind_of? C::Variable
argv = get_new_tmp_var('argv')
scope.statements << C::CExpression[argv, :'=', val]
val = argv
end
argv = C::CExpression[:'&', val]
else
argv = get_new_tmp_var('argv')
argv.type = C::Array.new(value, args.length)
args.each_with_index { |a, i|
val = ast_to_c(a, scope)
scope.statements << C::CExpression[[argv, :'[]', [i]], :'=', val]
}
end
c_arglist << [args.length] << argv << rb_self
else
c_arglist << rb_self
args.each { |a|
va = get_new_tmp_var('arg')
val = ast_to_c(a, scope, va)
scope.statements << C::CExpression[va, :'=', val] if val != va
c_arglist << va
}
end
f = C::CExpression[fptr, :funcall, c_arglist]
if want_value
ret = get_new_tmp_var('ccall', want_value)
scope.statements << C::CExpression[ret, :'=', f]
ret
else
scope.statements << f
end
end
def optimize_iter(ast, scope, want_value)
b_args, b_body, b_recv = ast[1, 3]
old_ib = @iter_break
if want_value
# a new tmpvar, so we can overwrite it in 'break :foo'
@iter_break = get_new_tmp_var('iterbreak')
else
@iter_break = nil
end
if b_recv[0] == :call and b_recv[2] == 'reverse_each'
# convert ary.reverse_each to ary.reverse.each
b_recv = b_recv.dup
b_recv[1] = [:call, b_recv[1], 'reverse']
b_recv[2] = 'each'
elsif b_recv[0] == :call and b_recv[2] == 'each_key'
# convert hash.each_key to hash.keys.each
b_recv = b_recv.dup
b_recv[1] = [:call, b_recv[1], 'keys']
b_recv[2] = 'each'
end
# loop { }
if b_recv[0] == :fcall and b_recv[2] == 'loop'
body = C::Block.new(scope)
ast_to_c(b_body, body, false)
scope.statements << C::For.new(nil, nil, nil, body)
# int.times { |i| }
elsif b_recv[0] == :call and not b_recv[3] and b_recv[2] == 'times'
limit = get_new_tmp_var('limit')
recv = ast_to_c(b_recv[1], scope, limit)
scope.statements << C::If.new(C::CExpression[:'!', [recv, :&, 1]], rb_raise('only Fixnum#times handled'), nil)
if want_value
scope.statements << C::CExpression[@iter_break, :'=', recv]
end
scope.statements << C::CExpression[limit, :'=', [recv, :>>, 1]]
cntr = get_new_tmp_var('cntr')
cntr.type = C::BaseType.new(:int, :unsigned)
body = C::Block.new(scope)
if b_args and b_args[0] == :dasgn_curr
body.statements << C::CExpression[dvar(b_args[1]), :'=', [[cntr, :<<, 1], :|, 1]]
end
ast_to_c(b_body, body, false)
scope.statements << C::For.new(C::CExpression[cntr, :'=', [[0], cntr.type]], C::CExpression[cntr, :<, limit], C::CExpression[:'++', cntr], body)
# ary.each { |e| }
elsif b_recv[0] == :call and not b_recv[3] and b_recv[2] == 'each' and b_args and
b_args[0] == :dasgn_curr
ary = get_new_tmp_var('ary')
recv = ast_to_c(b_recv[1], scope, ary)
scope.statements << C::CExpression[ary, :'=', recv] if ary != recv
scope.statements << C::If.new(rb_test_class_ary(ary), nil, rb_raise('only Array#each { |e| } handled'))
if want_value
scope.statements << C::CExpression[@iter_break, :'=', ary]
end
cntr = get_new_tmp_var('cntr')
cntr.type = C::BaseType.new(:int, :unsigned)
body = C::Block.new(scope)
if b_args and b_args[0] == :dasgn_curr
body.statements << C::CExpression[dvar(b_args[1]), :'=', [rb_ary_ptr(ary), :'[]', [cntr]]]
end
ast_to_c(b_body, body, false)
scope.statements << C::For.new(C::CExpression[cntr, :'=', [[0], cntr.type]], C::CExpression[cntr, :<, rb_ary_len(ary)], C::CExpression[:'++', cntr], body)
# ary.find { |e| }
elsif b_recv[0] == :call and not b_recv[3] and b_recv[2] == 'find' and b_args and
b_args[0] == :dasgn_curr
ary = get_new_tmp_var('ary')
recv = ast_to_c(b_recv[1], scope, ary)
scope.statements << C::CExpression[ary, :'=', recv] if ary != recv
scope.statements << C::If.new(rb_test_class_ary(ary), nil, rb_raise('only Array#find { |e| } handled'))
if want_value
scope.statements << C::CExpression[@iter_break, :'=', rb_nil]
end
cntr = get_new_tmp_var('cntr')
cntr.type = C::BaseType.new(:int, :unsigned)
body = C::Block.new(scope)
if b_args and b_args[0] == :dasgn_curr
body.statements << C::CExpression[dvar(b_args[1]), :'=', [rb_ary_ptr(ary), :'[]', [cntr]]]
end
# same as #each up to this point (except default retval), now add a 'if (body_value) break ary[cntr];'
# XXX 'find { next true }'
found = ast_to_c(b_body, body)
t = C::Block.new(body)
t.statements << C::CExpression[@iter_break, :'=', rb_ary_ptr(ary, cntr)]
t.statements << C::Break.new
body.statements << C::If.new(rb_test(found, body), t, nil)
scope.statements << C::For.new(C::CExpression[cntr, :'=', [[0], cntr.type]], C::CExpression[cntr, :<, rb_ary_len(ary)], C::CExpression[:'++', cntr], body)
# ary.map { |e| }
elsif b_recv[0] == :call and not b_recv[3] and b_recv[2] == 'map' and b_args and
b_args[0] == :dasgn_curr
ary = get_new_tmp_var('ary')
recv = ast_to_c(b_recv[1], scope, ary)
scope.statements << C::CExpression[ary, :'=', recv] if ary != recv
scope.statements << C::If.new(rb_test_class_ary(ary), nil, rb_raise('only Array#map { |e| } handled'))
if want_value
scope.statements << C::CExpression[@iter_break, :'=', fcall('rb_ary_new')]
end
cntr = get_new_tmp_var('cntr')
cntr.type = C::BaseType.new(:int, :unsigned)
body = C::Block.new(scope)
if b_args and b_args[0] == :dasgn_curr
body.statements << C::CExpression[dvar(b_args[1]), :'=', [rb_ary_ptr(ary), :'[]', [cntr]]]
end
# same as #each up to this point (except default retval), now add a '@iter_break << body_value'
# XXX 'next' unhandled
val = ast_to_c(b_body, body)
body.statements << fcall('rb_ary_push', @iter_break, val)
scope.statements << C::For.new(C::CExpression[cntr, :'=', [[0], cntr.type]], C::CExpression[cntr, :<, rb_ary_len(ary)], C::CExpression[:'++', cntr], body)
else
@iter_break = old_ib
return
end
ret = @iter_break
@iter_break = old_ib
ret || nil.object_id
end
end
# a ruby2c C generator for use in the any ruby interpreter (generates C suitable for use as a standard Ruby extension)
class RubyStaticCompiler < RubyLiveCompiler
# add a new ruby function to the current @cp
def self.compile(klass, *methlist)
@rcp ||= new
methlist.each { |meth|
ast = RubyHack.read_method_ast(klass, meth)
@rcp.compile(ast, klass, meth)
}
self
end
def self.compile_singleton(klass, *methlist)
@rcp ||= new
methlist.each { |meth|
ast = RubyHack.read_singleton_method_ast(klass, meth)
@rcp.compile(ast, klass, meth, true)
}
self
end
def self.dump
<<EOS + @rcp.cp.dump_definition('Init_compiledruby')
#ifdef __ELF__
asm .pt_gnu_stack rw;
#endif
EOS
end
def dump(m="Init_compiledruby")
m ? @cp.dump_definition(m, 'do_init_once') : @cp.to_s
end
def initialize(cp=nil)
super(cp)
@cp.parse <<EOS
// static VALUE method(VALUE self, VALUE arg0, VALUE arg1) { return (VALUE)0; }
// static VALUE const_Lol;
static void do_init_once(void) {
// const_Lol = rb_const_get(*rb_cObject, rb_intern("Lol"));
// rb_define_method(const_Lol, "method", method, 2);
}
int Init_compiledruby(void) __attribute__((export)) {
// use a separate func to avoid having to append statements before the 'return'
do_init_once();
return 0;
}
EOS
end
# returns the 'do_init_once' function body
def init
@cp.toplevel.symbol['do_init_once'].initializer
end
def compile(ast, klass, method, singleton=false)
@compiled_func_cache ||= {}
mname = super(ast, klass, method, singleton)
return if not mname
@compiled_func_cache[[klass, method.to_s, singleton]] = @cur_cfunc
cls = rb_const(nil, klass)
init.statements << fcall("rb_define#{'_singleton' if singleton}_method", cls, method.to_s, @cur_cfunc, method_arity)
mname
end
def declare_newtopvar(name, initializer, type=value)
v = C::Variable.new(name, type)
v.storage = :static
@cp.toplevel.symbol[v.name] = v
pos = @cp.toplevel.statements.index @cp.toplevel.statements.find { |st|
st.kind_of? C::Declaration and st.var.type.kind_of? C::Function and st.var.initializer
} || -1
@cp.toplevel.statements.insert pos, C::Declaration.new(v)
if initializer
pos = -1
if name =~ /^intern_/
pos = 0
init.statements.each { |st|
break unless st.kind_of? C::CExpression and st.op == :'=' and st.lexpr.kind_of? C::Variable and st.lexpr.name < name
pos += 1
}
end
init.statements.insert(pos, C::CExpression[v, :'=', initializer])
end
v
end
def rb_intern(sym)
n = escape_varname("intern_#{sym}")
@cp.toplevel.symbol[n] || declare_newtopvar(n, fcall('rb_intern', sym.to_s), C::BaseType.new(:int, :unsigned))
end
# rb_const 'FOO', Bar::Baz ==>
# const_Bar = rb_const_get(rb_cObject, rb_intern("Bar"));
# const_Bar_Baz = rb_const_get(const_Bar, rb_intern("Baz"));
# const_Bar_Baz_FOO = rb_const_get(const_Bar_Baz, rb_intern("FOO"));
# use rb_const(nil, class) to get a pointer to a class/module
def rb_const(constname, owner = resolve_const_owner(constname))
raise Fail, "no dynamic constant resolution #{constname}" if not owner
@const_value ||= { [::Object, 'Object'] => rb_global('rb_cObject') }
k = ::Object
v = nil
cname = owner.name
cname += '::' + constname if constname
cname.split('::').each { |n|
kk = k.const_get(n)
if not v = @const_value[[k, n]]
# class A ; end ; B = A => B.name => 'A'
vn = "const_#{escape_varname((k.name + '::' + n).sub(/^Object::/, '').gsub('::', '_'))}"
vi = fcall('rb_const_get', rb_const(nil, k), fcall('rb_intern', n))
v = declare_newtopvar(vn, vi)
# n wont be reused, so do not alloc a global intern_#{n} for this
@const_value[[k, n]] = v
end
k = kk
}
v
end
# TODO remove this when the C compiler is fixed
def rb_global(cname)
C::CExpression[:*, @cp.toplevel.symbol[cname]]
end
def get_cfuncptr(klass, method, singleton=false)
# is it a func we have in the current cparser ?
if ptr = @compiled_func_cache[[klass, method.to_s, singleton]]
return ptr
end
# check if it's a C or ruby func in the current interpreter
cls = singleton ? (class << klass ; self ; end) : klass
ptr = RubyHack.get_method_node_ptr(cls, method)
return if ptr == 0
ftype = RubyHack::NODETYPE[(RubyHack.memory_read_int(ptr) >> 11) & 0xff]
return if ftype != :cfunc
# ok, so assume it will be the same next time
n = escape_varname "fptr_#{klass.name}#{singleton ? '.' : '#'}#{method}".gsub('::', '_')
if not v = @cp.toplevel.symbol[n]
v = get_cfuncptr_dyn(klass, method, singleton, n)
end
v
end
def get_cfuncptr_dyn(klass, method, singleton, n)
arity = singleton ? klass.method(method).arity : klass.instance_method(method).arity
fproto = C::Function.new(value, [])
case arity
when -1; fproto.args << C::Variable.new(nil, C::BaseType.new(:int)) << C::Variable.new(nil, C::Pointer.new(value)) << C::Variable.new(nil, value)
when -2; fproto.args << C::Variable.new(nil, value) << C::Variable.new(nil, value)
else (arity+1).times { fproto.args << C::Variable.new(nil, value) }
end
if not ptr = init.symbol['ptr']
ptr = C::Variable.new('ptr', C::Pointer.new(C::BaseType.new(:int)))
init.symbol[ptr.name] = ptr
init.statements << C::Declaration.new(ptr)
end
cls = rb_const(nil, klass)
cls = fcall('rb_singleton_class', cls) if singleton
init.statements << C::CExpression[ptr, :'=', fcall('rb_method_node', cls, rb_intern(method))]
# dynamically recheck that klass#method is a :cfunc
cnd = C::CExpression[[:'!', ptr], :'||', [[[[ptr, :'[]', [0]], :>>, [11]], :&, [0xff]], :'!=', [RubyHack::NODETYPE.index(:cfunc)]]]
init.statements << C::If.new(cnd, rb_raise("CFunc expected at #{klass}#{singleton ? '.' : '#'}#{method}"), nil)
vi = C::CExpression[[ptr, :'[]', [1]], C::Pointer.new(fproto)]
declare_newtopvar(n, vi, C::Pointer.new(fproto))
end
if defined? $trace_rbfuncall and $trace_rbfuncall
# dynamic trace of all rb_funcall made from our module
def rb_funcall(recv, meth, *args)
if not defined? @rb_fcid
@cp.parse <<EOS
int atexit(void(*)(void));
int printf(char*, ...);
static unsigned rb_fcid_max = 1;
static unsigned rb_fcntr[1];
static void rb_fcstat(void)
{
unsigned i;
for (i=0 ; i<rb_fcid_max ; ++i)
if (rb_fcntr[i])
printf("%u %u\\n", i, rb_fcntr[i]);
}
EOS
@rb_fcid = -1
@rb_fcntr = @cp.toplevel.symbol['rb_fcntr']
@rb_fcid_max = @cp.toplevel.symbol['rb_fcid_max']
init.statements << fcall('atexit', @cp.toplevel.symbol['rb_fcstat'])
end
@rb_fcid += 1
@rb_fcid_max.initializer = C::CExpression[[@rb_fcid+1], @rb_fcid_max.type]
@rb_fcntr.type.length = @rb_fcid+1
ctr = C::CExpression[:'++', [@rb_fcntr, :'[]', [@rb_fcid]]]
C::CExpression[ctr, :',', super(recv, meth, *args)]
end
end
end
end
if __FILE__ == $0 or ARGV.delete('ignore_argv0')
demo = case ARGV.first
when nil; :test_jit
when 'asm'; :inlineasm
when 'generate'; :generate_persistent
else :compile_ruby
end
case demo
when :inlineasm
# cnt.times { sys_write str }
src_asm = <<EOS
mov ecx, [ebp+8]
again:
push ecx
mov eax, 4
mov ebx, 1
mov ecx, [ebp+12]
mov edx, [ebp+16]
int 80h
pop ecx
loop again
EOS
src = <<EOS
#{Metasm::RubyLiveCompiler::RUBY_H}
void doit(int, char*, int);
VALUE foo(VALUE self, VALUE count, VALUE str) {
doit(VAL2INT(count), STR_PTR(str), STR_LEN(str));
return count;
}
void doit(int count, char *str, int strlen) { asm(#{src_asm.inspect}); }
EOS
class Foo
end
m = Metasm::RubyHack.compile_c(src).encoded
Metasm::RubyHack.set_method_binary(Foo, 'bar', m, 2)
Foo.new.bar(4, "blabla\n")
Foo.new.bar(2, "foo\n")
when :compile_ruby
abort 'need <class#method>' if ARGV.empty?
require 'pp'
puts '#if 0'
ARGV.each { |av|
next if not av =~ /^(.*)([.#])(.*)$/
cls, sg, meth = $1, $2, $3.to_sym
sg = { '.' => true, '#' => false }[sg]
cls = cls.split('::').inject(::Object) { |o, cst| o.const_get(cst) }
if sg
ast = Metasm::RubyHack.read_singleton_method_ast(cls, meth)
cls.method(meth) if not ast # raise NoMethodError
puts ' --- ast ---'
pp ast
Metasm::RubyStaticCompiler.compile_singleton(cls, meth)
else
ast = Metasm::RubyHack.read_method_ast(cls, meth)
cls.instance_method(meth) if not ast
puts ' --- ast ---'
pp ast
Metasm::RubyStaticCompiler.compile(cls, meth)
end
}
puts '', ' --- C ---', '#endif'
puts Metasm::RubyStaticCompiler.dump
when :test_jit
class Foo
def bla(x=500)
i = 0
x.times { i += 16 }
i
end
end
t0 = Time.now
Metasm::RubyLiveCompiler.compile(Foo, :bla)
t1 = Time.now
ret = Foo.new.bla(0x401_0000)
puts ret.to_s(16), ret.class
t2 = Time.now
puts "compile %.3fs run %.3fs" % [t1-t0, t2-t1]
when :generate_persistent
Metasm::RubyStaticCompiler.compile(Metasm::Preprocessor, :getchar, :ungetchar, :unreadtok, :readtok_nopp_str, :readtok_nopp, :readtok)
Metasm::RubyStaticCompiler.compile(Metasm::Expression, :reduce_rec, :initialize)
Metasm::RubyStaticCompiler.compile_singleton(Metasm::Expression, :[])
c_src = Metasm::RubyStaticCompiler.dump
File.open('compiledruby.c', 'w') { |fd| fd.puts c_src } if $VERBOSE
puts 'compiling..'
begin ; require 'compiledruby' ; rescue LoadError ; end
# To encode to a different file, you must also rename the Init_compliedruby() function to match the lib name
Metasm::ELF.compile_c(Metasm::Ia32.new, c_src).encode_file('compiledruby.so')
puts 'ruby -r metasm -r compiledruby ftw'
end
end
Reference in New Issue View Git Blame Copy Permalink