__copysplat added as an ugly (and hopefully temporary) hack.

Idea is to prevent unnecessary Array creation in the case of the
frequent pattern of using the splat operator in arguments only to then
forward the splatted arguments in a call to another method. To do it
properly we need to check that it's not referenced elsewhere. Instead
we use the special name __copysplat to trigger non-Ruby functionality
until we have a proper verification step in place.

Author: vidarh

compile_calls.rb

@@ -71,20 +71,28 @@ def copy_splat_loop(splatcnt, indir)
   # less efficient than it could be.
   #
   def compile_args_copysplat(scope, a, indir)
-    @e.comment("SPLAT")
     @e.with_register do |splatcnt|
-      param = compile_eval_arg(scope, a[1])
-      @e.addl(4,param)
-      @e.load_indirect(param, splatcnt)
-      @e.addl(4,param)
-      @e.load_indirect(param, :eax)
-      @e.testl(:eax,:eax)
-      l = @e.get_local
-
-      # If Array class ptr has not been allocated yet:
-      @e.je(l)
-      copy_splat_loop(splatcnt, indir)
-      @e.local(l)
+      if a[1] == :__copysplat
+        @e.comment("SPLAT COPY")
+        param = @e.save_to_reg(compile_eval_arg(scope, [:sub, :numargs, 2]))
+        @e.movl(param, splatcnt)
+        param = compile_eval_arg(scope, a[1])
+        copy_splat_loop(splatcnt, indir)
+      else
+        @e.comment("SPLAT ARRAY")
+        param = compile_eval_arg(scope, a[1])
+        @e.addl(4,param)
+        @e.load_indirect(param, splatcnt)
+        @e.addl(4,param)
+        @e.load_indirect(param, :eax)
+        @e.testl(:eax,:eax)
+        l = @e.get_local
+
+        # If Array class ptr has not been allocated yet:
+        @e.je(l)
+        copy_splat_loop(splatcnt, indir)
+        @e.local(l)
+      end
     end
 
   end
@@ -129,11 +137,15 @@ def compile_args_splat(scope, ob, args)
     exprlist = []
     args.each_with_index do |a, i|
       if a.is_a?(Array) && a[0] == :splat
-        # We do this, rather than Array#length, because the class may not
-        # have been created yet. This *requires* Array's @len ivar to be
-        # in the first ivar;
-        # FIXME: should enforce this.
-        exprlist << [:index, a[1], 1]
+        if a[1] == :__copysplat
+          exprlist << [:sub, :numargs, 2]
+        else
+          # We do this, rather than Array#length, because the class may not
+          # have been created yet. This *requires* Array's @len ivar to be
+          # in the first ivar;
+          # FIXME: should enforce this.
+          exprlist << [:index, a[1], 1]
+        end
       else
         num_fixed += 1
       end

lib/core/array.rb

@@ -9,7 +9,7 @@ class Array
   # FIXME: initialize should take two optional arguments,
   # but we don't yet handle initializers, so not supporting that
   # for now.
-  def initialize *elements
+  def initialize *__copysplat
     # FIXME: See notes in lib/core/core.rb regarding bootstrapping
     # of splat handling, which causes the annoyance below:
     #
@@ -21,9 +21,11 @@ def initialize *elements
     # We'd still be limited in what to do here, but not as strictly.
     #
     __initialize
-    if elements.length > 0
-      __grow(elements[0].__get_raw)
-    end
+    %s(if (gt numargs 2) (callm self __copy_init ((index __copysplat 0))))
+  end
+
+  def __copy_init other
+    __grow(other.__get_raw)
   end
 
   def capacity

lib/core/array_base.rb

@@ -69,12 +69,14 @@ def to_a
     (assign splat (callm Array __new))
     (assign pos 0)
     (assign max (sub na 2))
-    (callm splat __grow (max))
-    (while (lt pos max)
-       (do
-          (callm splat __set (pos (index r pos)))
-          (assign pos (add pos 1))
-          )
-        )
-  splat
+    (if (gt max 0) (do
+      (callm splat __grow (max))
+      (while (lt pos max)
+         (do
+           (callm splat __set (pos (index r pos)))
+           (assign pos (add pos 1))
+         )
+       )
+    ))
+    splat
   ))

lib/core/class.rb

@@ -124,9 +124,10 @@ def __new
     ob
   end
 
-  def new *rest
+  # FIXME: Optimizing this will shave massively off __splat_to_Array calls.
+  def new *__copysplat
     ob = allocate
-    ob.initialize(*rest)
+    ob.initialize(*__copysplat)
     ob
   end
 

lib/core/proc.rb

@@ -23,8 +23,8 @@ def arity
     @arity
   end
 
-  def call *arg
-    %s(call @addr (@s 0 @env (splat arg)))
+  def call *__copysplat
+    %s(call @addr (@s 0 @env (splat __copysplat)))
 
     # WARNING: Do not do extra stuff here. If this is a 'proc'/bare block
     # code after the %s(call ...) above will not get executed.

lib/core/string.rb

@@ -1,4 +1,5 @@
 
+%s(defun __stralloc (len) (do (__alloc_leaf len)))
 # See Symbol for a discussion of type tagging.
 #
 # FIXME: For (right) now String objects are sort-of immutable.
@@ -15,7 +16,8 @@ class String
   # will be prone to order of bootstrapping the core
   # classes.
   #
-  def initialize *str
+
+  def initialize *__copysplat
     # @buffer contains the pointer to raw memory
     # used to contain the string.
     # 
@@ -24,14 +26,22 @@ def initialize *str
     # be an FixNum instance instead of the actual
     # value 0.
 
+    %s(assign @buffer 0)
+    @flags  = 0
+    @length = 0
+    %s(assign @capacity 0)
     %s(if (lt numargs 3)
-         (assign @buffer "")
-         (do 
-            (assign first (callm str [] (__I0)))
-            (assign len (callm first length))
-            (callm self __copy_raw ((callm first __get_raw) len))
-          )
-          )
+      (assign @buffer "")
+      (callm self __copy_initialize ((splat __copysplat)))
+    )
+  end
+
+  def __copy_initialize *str
+    %s(do
+        (assign first (callm str [] ((__int 0))))
+        (assign len (callm first length))
+        (callm self __copy_raw ((callm first __get_raw) len))
+      )
   end
 
   def inspect
@@ -152,7 +162,8 @@ def eql? other
 
   def __copy_raw(str,len)
     %s(assign len (add (callm len __get_raw) 1))
-    %s(assign @buffer (__alloc_leaf len))
+    %s(assign @capacity (add len 8))
+    %s(assign @buffer (__stralloc @capacity))
     %s(memmove @buffer str len)
     %s(assign (bindex @buffer (sub len 1)) 0)
     nil