Type-tagging for Fixnum/Integer

Adds the overhead of checking if bit 0 is set for all attempts to get the
class for an object, but as a consequence significantly reduces object
creation.

Author: vidarh

compile_calls.rb

@@ -239,13 +239,36 @@ def compile_call(scope, func, args, block = nil)
   end
 
 
-  # If adding type-tagging, this is the place to do it.
-  # In the case of type tagging, the value in %esi
-  # would be matched against the suitable type tags
-  # to determine the class, instead of loading the class
-  # from the first long of the object.
+  # Load class for the object whose pointer is in %esi.
+  #
+  # For now, this is done by testing bit 0, and if it
+  # is set we know this isn't a valid pointer to a Class
+  # object. Instead we assume it is a Fixnum.
+  #
+  # This is similar to MRI, but MRI uses type tags for
+  # more types of objects. We probably will here too
+  # in the future (e.g. Float when it's added, at least)
+  #
+  # Upside: Far less need for garbage collection.
+  # Downside: The cost of *this* every time we need the
+  # class pointer. This can be mitigated somewhat by
+  # better code generation (e.g. keeping class pointers
+  # for objects that are accessed multiple times;
+  # figuring out inlining and the like, but requires more
+  # effort to optimize. As a first stage, however, this
+  # will do as it makes self-compilation viable for this
+  # compiler for the first time.
+  #
   def load_class(scope)
+    @e.testl(1, :esi)
+    l1 = @e.get_local
+    l2 = @e.get_local
+    @e.jz(l1)
+    @e.load(:global, :Fixnum)
+    @e.jmp(l2)
+    @e.label(l1)
     @e.load_indirect(:esi, :eax)
+    @e.label(l2)
   end
 
   # Load the super-class pointer

lib/core/fixnum.rb

@@ -1,32 +1,19 @@
 class Fixnum < Integer
 
-  def initialize
-    # Can't use any Ruby expressions that use integers here,
-    # directly or indirectly, so best not use *any*, because
-    # it would cause recursion until running out of memory.
-    %s(assign @value 0)
-  end
-
-  def self.allocate
-    %s(assign ob (__array_leaf 2))
-    %s(assign (index ob 0) self)
-    ob
+  def class
+    Fixnum
   end
 
   def % other
     %s(assign r (callm other __get_raw))
-    %s(assign m (mod @value r))
+    %s(assign m (mod (sar self) r))
     %s(if (eq (ge m 0) (lt r 0))
          (assign m (add m r)))
     %s(__int m)
   end
 
-  def __set_raw(value)
-    @value = value
-  end
-
   def __get_raw
-    @value
+    %s(sar self)
   end
 
   def to_i
@@ -75,31 +62,32 @@ def inspect
   end
 
   def chr
-   %s(let (buf)
-       (assign buf (__alloc_leaf 2))
-       (snprintf buf 2 "%c" @value)
+    %s(let (buf)
+         (assign buf (__alloc_leaf 2))
+         (snprintf buf 2 "%c" (sar self))
        (__get_string buf)
-       )
+     )
   end
 
   def + other
-    %s(call __int ((add @value (callm other __get_raw))))
+    %s(__int (add (sar self) (callm other __get_raw)))
   end
 
   def - other
-    %s(call __int ((sub @value (callm other __get_raw))))
+    %s(__int (sub (sar self) (callm other __get_raw)))
   end
 
+  
   def <= other
-    %s(if (le @value (callm other __get_raw)) true false)
+    %s(if (le (sar self) (callm other __get_raw)) true false)
   end
 
   def == other
     if other.nil?
       return false 
     end
     return false if !other.is_a?(Numeric)
-    %s(if (eq @value (callm other __get_raw)) true false)
+    %s(if (eq (sar self) (callm other __get_raw)) true false)
   end
 
   # FIXME: I don't know why '!' seems to get an argument...
@@ -110,19 +98,19 @@ def ! *args
   def != other
     return true if !other.is_a?(Numeric)
     other = other.to_i
-    %s(if (ne @value (callm other __get_raw)) true false)
+    %s(if (ne (sar self) (callm other __get_raw)) true false)
   end
 
   def < other
-    %s(if (lt @value (callm other __get_raw)) true false)
+    %s(if (lt (sar self) (callm other __get_raw)) true false)
   end
 
   def > other
-    %s(if (gt @value (callm other __get_raw)) true false)
+    %s(if (gt (sar self) (callm other __get_raw)) true false)
   end
 
   def >= other
-    %s(if (ge @value (callm other __get_raw)) true false)
+    %s(if (ge (sar self) (callm other __get_raw)) true false)
   end
 
   def <=> other
@@ -137,22 +125,22 @@ def <=> other
   end
 
   def div other
-    %s(call __int ((div @value (callm other __get_raw))))
+    %s(__int (div (sar self) (sar other)))
   end
 
   def mul other
-    %s(call __int ((mul @value (callm other __get_raw))))
+    %s(__int (mul (sar self) (sar other)))
   end
 
   # These two definitions are only acceptable temporarily,
   # because we will for now only deal with integers
 
   def * other
-    mul(other)
+    %s(__int (mul (sar self) (sar other)))
   end
 
   def / other
-    div(other)
+    %s(__int (div (sar self) (sar other)))
   end
 
   def ord
@@ -168,27 +156,7 @@ def times
   end
 end
 
-%s(assign FixNum_cache_size 1000)
-%s(assign FixNum_cache (__array_leaf (mul FixNum_cache_size 2)))
-
 %s(defun __int (val)
-    (let (num)
-      (if (and (ge val 0) (lt val FixNum_cache_size))
-        (do
-          # 32 bit class-ptr + 32 bit int; Naughty assumptions again. FIXME
-          (assign num (add FixNum_cache (mul val 8)))
-          (if (eq (index num 0) 0) (do
-            (assign (index num 0) Fixnum)  # class-ptr
-            (callm num __set_raw (val))
-            (return num)
-          ))
-          (return num)
-        )
-      )
-      (assign num (callm Fixnum allocate))
-      (callm num __set_raw (val))
-      (return num)
-    )
-  )
-
-%s(__compiler_internal integer_list)
+  (add (shl val) 1)
+)
+