kernel/compiler/blocks.rb kernel/compiler/blocks_graph.rb kernel/compiler/bytecode.rb kernel/compiler/compile.rb kernel/compiler/compiled_file.rb kernel/compiler/compiler.rb kernel/compiler/execute.rb kernel/compiler/generator.rb kernel/compiler/graph.rb kernel/compiler/iseq.rb kernel/compiler/local.rb kernel/compiler/node.rb kernel/compiler/nodes.rb kernel/compiler/plugins.rb kernel/compiler/sexp.rb kernel/compiler/stack.rb kernel/compiler/sydney_rewriter.rb kernel/compiler/text.rb @@ -612,6 +612,138 @@ module Kernel "#<#{self.__class__}:0x#{self.__id__.to_s(16)}>" end + def compile(path, out=nil, flags=nil) + out = "#{path}c" unless out + cm = Compiler::Utils.compile_file(path, flags) + raise LoadError, "Unable to compile '#{path}'" unless cm + Rubinius::CompiledFile.dump cm, out + return out + end + module_function :compile + + ## + # Loads the given file as executable code and returns true. If + # the file cannot be found, cannot be compiled or some other + # error occurs, LoadError is raised with an explanation. + # + # Unlike #require, the file extension if any must be present but + # is not restricted to .rb, .rbc or .<platform shared lib ext>. + # Any other extensions (or no extension) are assumed to be plain + # Ruby files. The only exceptions to this rule are: + # + # 1. if given a .rb or no/any-extensioned file and there is a + # compiled version of the same file that is not older than + # the source file (based on File.mtime), the compiled one + # is loaded directly to avoid the compilation overhead. + # 2. if a .rb file is given but it does not exist, the system + # will try to load the corresponding .rbc instead (to allow + # distributing just .rbc files.) + # + # If the path given starts with ./, ../, ~/ or /, it is treated + # as a "qualified" file and will be loaded directly (after path + # expansion) instead of matching against $LOAD_PATH. The relative + # paths use Dir.pwd. + # + # If the filename is plain (unqualified) then it is sequentially + # prefixed with each path in $LOAD_PATH ($:) to locate the file, + # using the first one that exists. If none of the resulting paths + # exist, LoadError is raised. Unqualified names may contain path + # elements so directories are valid targets and can be used with + # $LOAD_PATH. + # + # A few extra options are supported. If the second parameter is + # true, then the module is wrapped inside an anonymous module for + # loading to avoid polluting the namespace. This is actually a + # shorthand for passing in :wrap => true-ish in the second arg + # which may be an option Hash. + # + # If :recompile in option Hash is true-ish then the file in + # question is recompiled each time. If the source file is not + # present when recompiling is requested, a LoadError is raised. + # + # TODO: Support non-UNIX paths. + # + # TODO: The anonymous module wrapping is not implemented at all. + # + def load(path, opts = {:wrap => false, :recompile => false}) + path = StringValue(path) + # Remap all library extensions behind the scenes, just like MRI + path.gsub!(/\.(so|bundle|dll|dylib)$/, "#{Rubinius::LIBSUFFIX}") + + opts = {:wrap => !!opts, :recompile => false} unless Hash === opts + + if path.suffix? '.rbc' + rb, rbc, ext = nil, path, nil + elsif path.suffix? '.rb' + rb, rbc, ext = path, "#{path}c", nil + elsif path.suffix? "#{Rubinius::LIBSUFFIX}" + rb, rbc, ext = nil, nil, path + else + dir, name = File.split(path) + rb = path + ext = nil + + if name[0] == ?. + rbc = nil + else + rbc = "#{dir}/#{name}.compiled.rbc" + end + end + + Compiler::Utils.unified_load path, rb, rbc, ext, nil, opts + end + module_function :load + + # Attempt to load the given file, returning true if successful. + # If the file has already been successfully loaded and exists + # in $LOADED_FEATURES, it will not be re-evaluated and false + # is returned instead. If the filename cannot be resolved, + # a LoadError is raised. + # + # The file can have one of the following extensions: + # + # [.rb] Plain Ruby source file. + # [.rbc] Compiled Ruby source file. + # [.o, .so, .dylib, .dll] Shared library (platform-specific.) + # [<none>] Filename without extension. + # + # (.rba files should be loaded using CodeArchive.load_everything.) + # + # If the file does not have an extension, #require attempts to + # match it using .rb, .rbc and .<shared extension> as extensions, + # in that order, instead. If foo.rb does not exist but foo.rbc + # does, the latter will be loaded even if called with foo.rb. + # + # If the path given starts with ./, ../, ~/ or /, it is treated + # as a "qualified" file and will be loaded directly (after path + # expansion) instead of matching against $LOAD_PATH. The relative + # paths use Dir.pwd. + # + # If the filename is plain (unqualified) then it is sequentially + # prefixed with each path in $LOAD_PATH ($:) to locate the file, + # using the first one that exists. If none of the resulting paths + # exist, LoadError is raised. Unqualified names may contain path + # elements so directories are valid targets and can be used with + # $LOAD_PATH. + # + # TODO: Support non-UNIX paths. + # + # TODO: See if we can safely use 1.9 rules with $LOADED_FEATURES, + # i.e. expand paths into it. This should be possible if it + # is completely transparent to the user in all normal cases. + # + # Each successfully loaded file is added to $LOADED_FEATURES + # ($"), using the original unexpanded filename (with the + # exception that the file extension is added.) + # + def require(path) + path = StringValue(path) + rb, rbc, ext = Compiler::Utils.split_path path + Autoload.remove(rb) + Compiler::Utils.unified_load path, rb, rbc, ext, true + end + module_function :require + def autoload(name, file) Object.autoload(name, file) end kernel/common/kernel.rb @@ -1,5 +1,3 @@ -# depends on: iseq.rb - ## # Breakpoint objects represent debugging breakpoints in the bytecode of # CompiledMethod objects. @@ -18,11 +16,9 @@ class Breakpoint self.private_class_method :new # Define a single encoder instance to be used for all breakpoints - @encoder = InstructionSequence::Encoder.new - # Returns the shared class InstructionSequence::Encoder instance. def Breakpoint.encoder - @encoder + @encoder ||= InstructionSequence::Encoder.new end # Initializes the breakpoint kernel/delta/breakpoint.rb @@ -97,9 +97,6 @@ script = nil begin - # TODO: Temporary until compiler is refactored - Compiler::Utils.load_compiler - script_debug_requested = false until ARGV.empty? arg = ARGV.shift kernel/loader.rb @@ -3,8 +3,6 @@ require 'rubygems' $:.push "lib" require 'ruby_parser' -require 'compiler/text' -require 'compiler/stack' $:.pop class Executable @@ -12,9 +10,24 @@ class Executable attr_accessor :primitive end -require File.dirname(__FILE__) + '/../../kernel/delta/compiled_file' -require File.dirname(__FILE__) + '/../../kernel/delta/iseq' -require File.dirname(__FILE__) + '/../../kernel/common/compiled_method' +$: << File.expand_path(File.dirname(__FILE__) + '/../../kernel') +require 'compiler/blocks' +require 'compiler/blocks_graph' +require 'compiler/compiler' +require 'compiler/node' +require 'compiler/nodes' +require 'compiler/iseq' +require 'compiler/generator' +require 'compiler/bytecode' +require 'compiler/compiled_file' +require 'compiler/execute' +require 'compiler/text' +require 'compiler/graph' +require 'compiler/local' +require 'compiler/plugins' +require 'compiler/stack' +require 'common/compiled_method' +$:.pop class SendSite def initialize(name) lib/compiler/mri_shim.rb @@ -89,108 +89,106 @@ def compile_ruby(src, rbc, check_mtime = false, kernel = false) end # drake does not allow invoke to be called inside tasks - def kernel_clean - rm_rf %w[runtime/bootstrap runtime/platform runtime/common runtime/delta], - :verbose => $verbose - - files_to_delete = [] - files_to_delete += Dir["*.rbc"] + Dir["**/*.rbc"] + Dir["**/.*.rbc"] - files_to_delete += Dir["**/load_order.txt"] - files_to_delete += ["runtime/platform.conf"] - - rm_f files_to_delete, :verbose => $verbose + rm_f Dir["**/*.rbc", + "**/.*.rbc", + "runtime/**/load_order.txt", + "runtime/platform.conf"], + :verbose => $verbose end -loose = [] -modules = Hash.new { |h,k| h[k] = [] } - -Dir["kernel/**/*.rb"].each do |path| - _, mod, file = path.split("/") +# The default rule for compiling all kernel files use the +# rbx-kernel compiler flag. Other files are exception cases. +rule ".rbc" do |t| + rbc = t.name + src = t.prerequisites.first - if file - modules[mod] << path - else - loose << mod - end + compile_ruby src, rbc, false, true end -all_kernel = [] -all_kernel << 'kernel/bootstrap/rubinius_config.rb' -all_kernel << 'kernel/bootstrap/ruby_config.rb' +# Create file dependencies for all kernel files +unless File.exists? "runtime/index" + raise "unable to build kernel, runtime/index is missing" +else + subdirs = IO.readlines("runtime/index").map { |line| line.chomp } +end -modules['bootstrap'] << 'kernel/bootstrap/rubinius_config.rb' -modules['bootstrap'] << 'kernel/bootstrap/ruby_config.rb' -modules.each do |name, files| - files.each do |rb| - rbc = "runtime/#{name}/#{File.basename(rb)}c" - all_kernel << rbc +kernel = ["runtime/platform.conf"] - file rbc => rb do - compile_ruby rb, rbc, false, true - end +subdirs.each do |subdir| + Dir["kernel/#{subdir}/*.rb"].each do |rb| + rbc = "runtime/#{subdir}/#{File.basename(rb)}c" + kernel << rbc + file rbc => rb end end -all_kernel << 'runtime/alpha.rbc' -all_kernel << 'runtime/loader.rbc' +rb = "kernel/bootstrap/rubinius_config.rb" +rbc = "runtime/bootstrap/rubinius_config.rbc" +file rbc => rb +kernel << rb << rbc -file 'runtime/alpha.rbc' => 'kernel/alpha.rb' do |t| - rbc = t.name - src = t.prerequisites.first - - compile_ruby src, rbc, false, true -end +rb = "kernel/bootstrap/ruby_config.rb" +rbc = "runtime/bootstrap/ruby_config.rbc" +file rbc => rb +kernel << rb << rbc -file 'runtime/loader.rbc' => 'kernel/loader.rb' +file "runtime/alpha.rbc" => "kernel/alpha.rb" +kernel << "runtime/alpha.rbc" -rule ".rbc" do |t| +file "runtime/loader.rbc" => "kernel/loader.rb" do |t| rbc = t.name src = t.prerequisites.first - compile_ruby src, rbc + compile_ruby src, rbc, false, true end - -COMPILER_SOURCES = Dir["lib/compiler/*.rb"] + - %w(strscan stringio racc/parser ruby_lexer ruby_parser - ruby_parser_extras sexp sexp_processor).map { |f| "lib/#{f}.rb" } -COMPILER_SOURCES << "kernel/delta/compiled_file.rb" -COMPILER_MTIME = COMPILER_SOURCES.map { |f| File::Stat.new(f).mtime }.max -compiler = [] - -COMPILER_SOURCES.each do |rb| - compiler << "#{rb}c" - file "#{rb}c" => rb do - compile_ruby rb, "#{rb}c", false, true +kernel << "runtime/loader.rbc" + +# TODO: extra_compiler is temporary until sexp processing is removed +# from the compiler. +extra_compiler = ["lib/strscan.rb", + "lib/stringio.rb", + "lib/racc/parser.rb", + "lib/ruby_lexer.rb", + "lib/ruby_parser.rb", + "lib/ruby_parser_extras.rb", + "lib/sexp_processor.rb"] +extra_compiler.each do |rb| + rbc = "#{rb}c" + kernel << rbc + + file rbc => rb do |t| + src = t.prerequisites.first + dst = t.name + + compile_ruby src, dst end end +desc "Build all kernel files" task :kernel => 'kernel:build' namespace :kernel do task :check_compiler do - kernel_mtime = all_kernel.select do |f| - f =~ /rbc$/ and File.exist? f - end.map do |f| - File::Stat.new(f).mtime - end.min + unless ENV['NOCLEAN'] + existing = kernel.select { |name| name =~ /rbc$/ and File.exists? name } + kernel_mtime = existing.map { |name| File.stat(name).mtime }.min - kernel_clean if !kernel_mtime or COMPILER_MTIME > kernel_mtime unless ENV['NOCLEAN'] - end + compiler = (Dir["kernel/compiler/*.rb"] + extra_compiler) + compiler_mtime = compiler.map { |name| File.stat(name).mtime }.max - task :show do - p modules - p loose + kernel_clean if !kernel_mtime or compiler_mtime > kernel_mtime + end end - task :build => ['kernel:check_compiler', all_kernel, compiler, - 'runtime/platform.conf'].flatten do - modules.each do |name, files| - create_load_order files, "runtime/#{name}/load_order.txt" + task :build => ['kernel:check_compiler'] + kernel + extra_compiler do + subdirs.each do |subdir| + files = Dir["kernel/#{subdir}/*.rb"] + create_load_order files, "runtime/#{subdir}/load_order.txt" end end - desc "clean up rbc files" + desc "Delete all .rbc files" task :clean do kernel_clean end @@ -228,4 +226,3 @@ namespace :kernel do end end - rakelib/kernel.rake @@ -410,7 +410,7 @@ end file 'vm/primitives.o' => 'vm/codegen/field_extract.rb' file 'vm/primitives.o' => TYPE_GEN -file 'vm/codegen/instructions_gen.rb' => 'kernel/delta/iseq.rb' +file 'vm/codegen/instructions_gen.rb' => 'kernel/compiler/iseq.rb' file 'vm/instructions.rb' => 'vm/gen' file 'vm/instructions.rb' => 'vm/codegen/instructions_gen.rb' file 'vm/test/test_instructions.hpp' => 'vm/codegen/instructions_gen.rb' rakelib/vm.rake @@ -2,3 +2,4 @@ bootstrap platform common delta +compiler runtime/index @@ -12,7 +12,7 @@ class Object # for vm debugging end require 'yaml' -require "#{File.dirname(__FILE__)}/../../kernel/delta/iseq" +require "#{File.dirname(__FILE__)}/../../kernel/compiler/iseq" require 'rubygems' require 'parse_tree' vm/codegen/instructions_gen.rb kernel/common/compile.rb kernel/delta/compiled_file.rb kernel/delta/iseq.rb lib/compiler/blocks.rb lib/compiler/blocks_graph.rb lib/compiler/bytecode.rb lib/compiler/compiler.rb lib/compiler/execute.rb lib/compiler/generator.rb lib/compiler/graph.rb lib/compiler/local.rb lib/compiler/node.rb lib/compiler/nodes.rb lib/compiler/plugins.rb lib/compiler/stack.rb lib/compiler/sydney_rewriter.rb lib/compiler/text.rb 3ed339238a238db64d53b30e7ffbf558be38731f Brian Ford bford@engineyard.com http://github.com/evanphx/rubinius/commit/4dc34cab851a6d2b307baf7454637a047e14988d 4dc34cab851a6d2b307baf7454637a047e14988d 2009-02-22T23:49:34-08:00 2009-02-22T15:08:04-08:00 Move the patient to the operating room. 6a4690a3b38ebe2e84ba2c964d1dabb900465c00 Brian Ford bford@engineyard.com