--- a/libinterp/octave-value/ov-builtin.cc	Sat Oct 07 09:59:16 2017 +0200
+++ b/libinterp/octave-value/ov-builtin.cc	Sun Oct 15 21:08:02 2017 +0200
@@ -93,14 +93,14 @@
   return retval;
 }
 
-jit_type *
+octave::jit_type *
 octave_builtin::to_jit (void) const
 {
   return jtype;
 }
 
 void
-octave_builtin::stash_jit (jit_type& type)
+octave_builtin::stash_jit (octave::jit_type& type)
 {
   jtype = &type;
 }

--- a/libinterp/octave-value/ov-builtin.h	Sat Oct 07 09:59:16 2017 +0200
+++ b/libinterp/octave-value/ov-builtin.h	Sun Oct 15 21:08:02 2017 +0200
@@ -34,12 +34,12 @@
 
 class octave_value;
 class octave_value_list;
-class jit_type;
 
 namespace octave
 {
   class tree_evaluator;
   class interpreter;
+  class jit_type;
 }
 
 // Builtin functions.
@@ -91,9 +91,9 @@
   call (octave::tree_evaluator& tw, int nargout = 0,
         const octave_value_list& args = octave_value_list ());
 
-  jit_type * to_jit (void) const;
+  octave::jit_type * to_jit (void) const;
 
-  void stash_jit (jit_type& type);
+  void stash_jit (octave::jit_type& type);
 
   fcn function (void) const;
 
@@ -116,7 +116,7 @@
   std::set<std::string> dispatch_classes;
 
   // A pointer to the jit type that represents the function.
-  jit_type *jtype;
+  octave::jit_type *jtype;
 
 private:
 

--- a/libinterp/octave-value/ov-usr-fcn.h	Sat Oct 07 09:59:16 2017 +0200
+++ b/libinterp/octave-value/ov-usr-fcn.h	Sun Oct 15 21:08:02 2017 +0200
@@ -49,11 +49,11 @@
   class tree_evaluator;
   class tree_expression;
   class tree_walker;
-}
+#if defined (HAVE_LLVM)
+  class jit_function_info;
+#endif
 
-#if defined (HAVE_LLVM)
-class jit_function_info;
-#endif
+}
 
 class
 octave_user_code : public octave_function
@@ -401,9 +401,9 @@
   void accept (octave::tree_walker& tw);
 
 #if defined (HAVE_LLVM)
-  jit_function_info * get_info (void) { return jit_info; }
+  octave::jit_function_info * get_info (void) { return jit_info; }
 
-  void stash_info (jit_function_info *info) { jit_info = info; }
+  void stash_info (octave::jit_function_info *info) { jit_info = info; }
 #endif
 
   octave_value dump (void) const;
@@ -491,7 +491,7 @@
   octave::symbol_table::scope *parent_scope;
 
 #if defined (HAVE_LLVM)
-  jit_function_info *jit_info;
+  octave::jit_function_info *jit_info;
 #endif
 
   void maybe_relocate_end_internal (void);

--- a/libinterp/parse-tree/jit-ir.cc	Sat Oct 07 09:59:16 2017 +0200
+++ b/libinterp/parse-tree/jit-ir.cc	Sun Oct 15 21:08:02 2017 +0200
@@ -44,136 +44,139 @@
 
 #include "error.h"
 
-// -------------------- jit_factory --------------------
-jit_factory::~jit_factory (void)
-{
-  for (value_list::iterator iter = all_values.begin ();
-       iter != all_values.end (); ++iter)
-    delete *iter;
-}
-
-void
-jit_factory::track_value (jit_value *value)
-{
-  if (value->type ())
-    mconstants.push_back (value);
-  all_values.push_back (value);
-}
-
-// -------------------- jit_block_list --------------------
-void
-jit_block_list::insert_after (iterator iter, jit_block *ablock)
-{
-  ++iter;
-  insert_before (iter, ablock);
-}
-
-void
-jit_block_list::insert_after (jit_block *loc, jit_block *ablock)
-{
-  insert_after (loc->location (), ablock);
-}
-
-void
-jit_block_list::insert_before (iterator iter, jit_block *ablock)
-{
-  iter = mlist.insert (iter, ablock);
-  ablock->stash_location (iter);
-}
-
-void
-jit_block_list::insert_before (jit_block *loc, jit_block *ablock)
-{
-  insert_before (loc->location (), ablock);
-}
-
-void
-jit_block_list::label (void)
-{
-  if (mlist.size ())
-    {
-      jit_block *block = mlist.back ();
-      block->label ();
-    }
-}
-
-std::ostream&
-jit_block_list::print (std::ostream& os, const std::string& header) const
-{
-  os << "-------------------- " << header << " --------------------\n";
-  return os << *this;
-}
-
-std::ostream&
-jit_block_list::print_dom (std::ostream& os) const
+namespace octave
 {
-  os << "-------------------- dom info --------------------\n";
-  for (const_iterator iter = begin (); iter != end (); ++iter)
-    {
-      assert (*iter);
-      (*iter)->print_dom (os);
-    }
-  os << std::endl;
+
+  // -------------------- jit_factory --------------------
+  jit_factory::~jit_factory (void)
+  {
+    for (value_list::iterator iter = all_values.begin ();
+         iter != all_values.end (); ++iter)
+      delete *iter;
+  }
 
-  return os;
-}
+  void
+  jit_factory::track_value (jit_value *value)
+  {
+    if (value->type ())
+      mconstants.push_back (value);
+    all_values.push_back (value);
+  }
+
+  // -------------------- jit_block_list --------------------
+  void
+  jit_block_list::insert_after (iterator iter, jit_block *ablock)
+  {
+    ++iter;
+    insert_before (iter, ablock);
+  }
 
-void
-jit_block_list::push_back (jit_block *b)
-{
-  mlist.push_back (b);
-  iterator iter = mlist.end ();
-  b->stash_location (--iter);
-}
+  void
+  jit_block_list::insert_after (jit_block *loc, jit_block *ablock)
+  {
+    insert_after (loc->location (), ablock);
+  }
+
+  void
+  jit_block_list::insert_before (iterator iter, jit_block *ablock)
+  {
+    iter = mlist.insert (iter, ablock);
+    ablock->stash_location (iter);
+  }
 
-std::ostream&
-operator<<(std::ostream& os, const jit_block_list& blocks)
-{
-  for (jit_block_list::const_iterator iter = blocks.begin ();
-       iter != blocks.end (); ++iter)
-    {
-      assert (*iter);
-      (*iter)->print (os, 0);
-    }
-  return os << std::endl;
-}
+  void
+  jit_block_list::insert_before (jit_block *loc, jit_block *ablock)
+  {
+    insert_before (loc->location (), ablock);
+  }
+
+  void
+  jit_block_list::label (void)
+  {
+    if (mlist.size ())
+      {
+        jit_block *block = mlist.back ();
+        block->label ();
+      }
+  }
+
+  std::ostream&
+  jit_block_list::print (std::ostream& os, const std::string& header) const
+  {
+    os << "-------------------- " << header << " --------------------\n";
+    return os << *this;
+  }
 
-// -------------------- jit_use --------------------
-jit_block *
-jit_use::user_parent (void) const
-{
-  return muser->parent ();
-}
+  std::ostream&
+  jit_block_list::print_dom (std::ostream& os) const
+  {
+    os << "-------------------- dom info --------------------\n";
+    for (const_iterator iter = begin (); iter != end (); ++iter)
+      {
+        assert (*iter);
+        (*iter)->print_dom (os);
+      }
+    os << std::endl;
+
+    return os;
+  }
 
-// -------------------- jit_value --------------------
-jit_value::~jit_value (void)
-{ }
+  void
+  jit_block_list::push_back (jit_block *b)
+  {
+    mlist.push_back (b);
+    iterator iter = mlist.end ();
+    b->stash_location (--iter);
+  }
+
+  std::ostream&
+  operator<<(std::ostream& os, const jit_block_list& blocks)
+  {
+    for (jit_block_list::const_iterator iter = blocks.begin ();
+         iter != blocks.end (); ++iter)
+      {
+        assert (*iter);
+        (*iter)->print (os, 0);
+      }
+    return os << std::endl;
+  }
 
-jit_block *
-jit_value::first_use_block (void)
-{
-  jit_use *use = first_use ();
-  while (use)
-    {
-      if (! isa<jit_error_check> (use->user ()))
-        return use->user_parent ();
+  // -------------------- jit_use --------------------
+  jit_block *
+  jit_use::user_parent (void) const
+  {
+    return muser->parent ();
+  }
 
-      use = use->next ();
-    }
+  // -------------------- jit_value --------------------
+  jit_value::~jit_value (void)
+  { }
 
-  return 0;
-}
+  jit_block *
+  jit_value::first_use_block (void)
+  {
+    jit_use *use = first_use ();
+    while (use)
+      {
+        if (! isa<jit_error_check> (use->user ()))
+          return use->user_parent ();
+
+        use = use->next ();
+      }
 
-void
-jit_value::replace_with (jit_value *value)
-{
-  while (first_use ())
-    {
-      jit_instruction *user = first_use ()->user ();
-      size_t idx = first_use ()->index ();
-      user->stash_argument (idx, value);
-    }
-}
+    return 0;
+  }
+
+  void
+  jit_value::replace_with (jit_value *value)
+  {
+    while (first_use ())
+      {
+        jit_instruction *user = first_use ()->user ();
+        size_t idx = first_use ()->index ();
+        user->stash_argument (idx, value);
+      }
+  }
 
 #define JIT_METH(clname)                                \
   void                                                  \
@@ -182,664 +185,666 @@
     walker.visit (*this);                               \
   }
 
-JIT_VISIT_IR_NOTEMPLATE
+  JIT_VISIT_IR_NOTEMPLATE
 #undef JIT_METH
 
-std::ostream&
-operator<< (std::ostream& os, const jit_value& value)
-{
-  return value.short_print (os);
-}
+  std::ostream&
+  operator<< (std::ostream& os, const jit_value& value)
+  {
+    return value.short_print (os);
+  }
+
+  std::ostream&
+  jit_print (std::ostream& os, jit_value *avalue)
+  {
+    if (avalue)
+      return avalue->print (os);
+    return os << "NULL";
+  }
 
-std::ostream&
-jit_print (std::ostream& os, jit_value *avalue)
-{
-  if (avalue)
-    return avalue->print (os);
-  return os << "NULL";
-}
+  // -------------------- jit_instruction --------------------
+  void
+  jit_instruction::remove (void)
+  {
+    if (mparent)
+      mparent->remove (mlocation);
+    resize_arguments (0);
+  }
+
+  llvm::BasicBlock *
+  jit_instruction::parent_llvm (void) const
+  {
+    return mparent->to_llvm ();
+  }
 
-// -------------------- jit_instruction --------------------
-void
-jit_instruction::remove (void)
-{
-  if (mparent)
-    mparent->remove (mlocation);
-  resize_arguments (0);
-}
+  std::ostream&
+  jit_instruction::short_print (std::ostream& os) const
+  {
+    if (type ())
+      jit_print (os, type ()) << ": ";
+    return os << '#' << mid;
+  }
 
-llvm::BasicBlock *
-jit_instruction::parent_llvm (void) const
-{
-  return mparent->to_llvm ();
-}
+  void
+  jit_instruction::do_construct_ssa (size_t start, size_t end)
+  {
+    for (size_t i = start; i < end; ++i)
+      {
+        jit_value *arg = argument (i);
+        jit_variable *var = dynamic_cast<jit_variable *> (arg);
+        if (var && var->has_top ())
+          stash_argument (i, var->top ());
+      }
+  }
 
-std::ostream&
-jit_instruction::short_print (std::ostream& os) const
-{
-  if (type ())
-    jit_print (os, type ()) << ": ";
-  return os << '#' << mid;
-}
+  // -------------------- jit_block --------------------
+  void
+  jit_block::replace_with (jit_value *value)
+  {
+    assert (isa<jit_block> (value));
+    jit_block *block = static_cast<jit_block *> (value);
+
+    jit_value::replace_with (block);
 
-void
-jit_instruction::do_construct_ssa (size_t start, size_t end)
-{
-  for (size_t i = start; i < end; ++i)
-    {
-      jit_value *arg = argument (i);
-      jit_variable *var = dynamic_cast<jit_variable *> (arg);
-      if (var && var->has_top ())
-        stash_argument (i, var->top ());
-    }
-}
+    while (ILIST_T::first_use ())
+      {
+        jit_phi_incomming *incomming = ILIST_T::first_use ();
+        incomming->stash_value (block);
+      }
+  }
+
+  void
+  jit_block::replace_in_phi (jit_block *ablock, jit_block *with)
+  {
+    jit_phi_incomming *node = ILIST_T::first_use ();
+    while (node)
+      {
+        jit_phi_incomming *prev = node;
+        node = node->next ();
 
-// -------------------- jit_block --------------------
-void
-jit_block::replace_with (jit_value *value)
-{
-  assert (isa<jit_block> (value));
-  jit_block *block = static_cast<jit_block *> (value);
+        if (prev->user_parent () == ablock)
+          prev->stash_value (with);
+      }
+  }
 
-  jit_value::replace_with (block);
+  jit_block *
+  jit_block::maybe_merge ()
+  {
+    if (successor_count () == 1 && successor (0) != this
+        && (successor (0)->use_count () == 1 || instructions.size () == 1))
+      {
+        jit_block *to_merge = successor (0);
+        merge (*to_merge);
+        return to_merge;
+      }
 
-  while (ILIST_T::first_use ())
-    {
-      jit_phi_incomming *incomming = ILIST_T::first_use ();
-      incomming->stash_value (block);
-    }
-}
+    return 0;
+  }
 
-void
-jit_block::replace_in_phi (jit_block *ablock, jit_block *with)
-{
-  jit_phi_incomming *node = ILIST_T::first_use ();
-  while (node)
-    {
-      jit_phi_incomming *prev = node;
-      node = node->next ();
+  void
+  jit_block::merge (jit_block& block)
+  {
+    // the merge block will contain a new terminator
+    jit_terminator *old_term = terminator ();
+    if (old_term)
+      old_term->remove ();
+
+    bool was_empty = end () == begin ();
+    iterator merge_begin = end ();
+    if (! was_empty)
+      --merge_begin;
 
-      if (prev->user_parent () == ablock)
-        prev->stash_value (with);
-    }
-}
+    instructions.splice (end (), block.instructions);
+    if (was_empty)
+      merge_begin = begin ();
+    else
+      ++merge_begin;
 
-jit_block *
-jit_block::maybe_merge ()
-{
-  if (successor_count () == 1 && successor (0) != this
-      && (successor (0)->use_count () == 1 || instructions.size () == 1))
-    {
-      jit_block *to_merge = successor (0);
-      merge (*to_merge);
-      return to_merge;
-    }
+    // now merge_begin points to the start of the new instructions, we must
+    // update their parent information
+    for (iterator iter = merge_begin; iter != end (); ++iter)
+      {
+        jit_instruction *instr = *iter;
+        instr->stash_parent (this, iter);
+      }
+
+    block.replace_with (this);
+  }
 
-  return 0;
-}
+  jit_instruction *
+  jit_block::prepend (jit_instruction *instr)
+  {
+    instructions.push_front (instr);
+    instr->stash_parent (this, instructions.begin ());
+    return instr;
+  }
 
-void
-jit_block::merge (jit_block& block)
-{
-  // the merge block will contain a new terminator
-  jit_terminator *old_term = terminator ();
-  if (old_term)
-    old_term->remove ();
+  jit_instruction *
+  jit_block::prepend_after_phi (jit_instruction *instr)
+  {
+    // FIXME: Make this O(1)
+    for (iterator iter = begin (); iter != end (); ++iter)
+      {
+        jit_instruction *temp = *iter;
+        if (! isa<jit_phi> (temp))
+          {
+            insert_before (iter, instr);
+            return instr;
+          }
+      }
 
-  bool was_empty = end () == begin ();
-  iterator merge_begin = end ();
-  if (! was_empty)
-    --merge_begin;
+    return append (instr);
+  }
 
-  instructions.splice (end (), block.instructions);
-  if (was_empty)
-    merge_begin = begin ();
-  else
-    ++merge_begin;
+  void
+  jit_block::internal_append (jit_instruction *instr)
+  {
+    instructions.push_back (instr);
+    instr->stash_parent (this, --instructions.end ());
+  }
+
+  jit_instruction *
+  jit_block::insert_before (iterator loc, jit_instruction *instr)
+  {
+    iterator iloc = instructions.insert (loc, instr);
+    instr->stash_parent (this, iloc);
+    return instr;
+  }
 
-  // now merge_begin points to the start of the new instructions, we must
-  // update their parent information
-  for (iterator iter = merge_begin; iter != end (); ++iter)
-    {
-      jit_instruction *instr = *iter;
-      instr->stash_parent (this, iter);
-    }
+  jit_instruction *
+  jit_block::insert_after (iterator loc, jit_instruction *instr)
+  {
+    ++loc;
+    iterator iloc = instructions.insert (loc, instr);
+    instr->stash_parent (this, iloc);
+    return instr;
+  }
 
-  block.replace_with (this);
-}
+  jit_terminator *
+  jit_block::terminator (void) const
+  {
+    assert (this);
+    if (instructions.empty ())
+      return 0;
 
-jit_instruction *
-jit_block::prepend (jit_instruction *instr)
-{
-  instructions.push_front (instr);
-  instr->stash_parent (this, instructions.begin ());
-  return instr;
-}
+    jit_instruction *last = instructions.back ();
+    return dynamic_cast<jit_terminator *> (last);
+  }
 
-jit_instruction *
-jit_block::prepend_after_phi (jit_instruction *instr)
-{
-  // FIXME: Make this O(1)
-  for (iterator iter = begin (); iter != end (); ++iter)
-    {
-      jit_instruction *temp = *iter;
-      if (! isa<jit_phi> (temp))
-        {
-          insert_before (iter, instr);
-          return instr;
-        }
-    }
+  bool
+  jit_block::branch_alive (jit_block *asucc) const
+  {
+    return terminator ()->alive (asucc);
+  }
+
+  jit_block *
+  jit_block::successor (size_t i) const
+  {
+    jit_terminator *term = terminator ();
+    return term->successor (i);
+  }
 
-  return append (instr);
-}
+  size_t
+  jit_block::successor_count (void) const
+  {
+    jit_terminator *term = terminator ();
+    return term ? term->successor_count () : 0;
+  }
 
-void
-jit_block::internal_append (jit_instruction *instr)
-{
-  instructions.push_back (instr);
-  instr->stash_parent (this, --instructions.end ());
-}
+  llvm::BasicBlock *
+  jit_block::to_llvm (void) const
+  {
+    return llvm::cast<llvm::BasicBlock> (llvm_value);
+  }
 
-jit_instruction *
-jit_block::insert_before (iterator loc, jit_instruction *instr)
-{
-  iterator iloc = instructions.insert (loc, instr);
-  instr->stash_parent (this, iloc);
-  return instr;
-}
+  std::ostream&
+  jit_block::print_dom (std::ostream& os) const
+  {
+    short_print (os);
+    os << ":\n";
+    os << "  mid: " << mid << std::endl;
+    os << "  predecessors: ";
+    for (jit_use *use = first_use (); use; use = use->next ())
+      os << *use->user_parent () << ' ';
+    os << std::endl;
+
+    os << "  successors: ";
+    for (size_t i = 0; i < successor_count (); ++i)
+      os << *successor (i) << ' ';
+    os << std::endl;
 
-jit_instruction *
-jit_block::insert_after (iterator loc, jit_instruction *instr)
-{
-  ++loc;
-  iterator iloc = instructions.insert (loc, instr);
-  instr->stash_parent (this, iloc);
-  return instr;
-}
+    os << "  idom: ";
+    if (idom)
+      os << *idom;
+    else
+      os << "NULL";
+    os << std::endl;
+    os << "  df: ";
+    for (df_iterator iter = df_begin (); iter != df_end (); ++iter)
+      os << **iter << ' ';
+    os << std::endl;
 
-jit_terminator *
-jit_block::terminator (void) const
-{
-  assert (this);
-  if (instructions.empty ())
-    return 0;
+    os << "  dom_succ: ";
+    for (size_t i = 0; i < dom_succ.size (); ++i)
+      os << *dom_succ[i] << ' ';
 
-  jit_instruction *last = instructions.back ();
-  return dynamic_cast<jit_terminator *> (last);
-}
+    return os << std::endl;
+  }
+
+  void
+  jit_block::compute_df (size_t avisit_count)
+  {
+    if (visited (avisit_count))
+      return;
 
-bool
-jit_block::branch_alive (jit_block *asucc) const
-{
-  return terminator ()->alive (asucc);
-}
+    if (use_count () >= 2)
+      {
+        for (jit_use *use = first_use (); use; use = use->next ())
+          {
+            jit_block *runner = use->user_parent ();
+            while (runner != idom)
+              {
+                runner->mdf.insert (this);
+                runner = runner->idom;
+              }
+          }
+      }
 
-jit_block *
-jit_block::successor (size_t i) const
-{
-  jit_terminator *term = terminator ();
-  return term->successor (i);
-}
+    for (size_t i = 0; i < successor_count (); ++i)
+      successor (i)->compute_df (avisit_count);
+  }
 
-size_t
-jit_block::successor_count (void) const
-{
-  jit_terminator *term = terminator ();
-  return term ? term->successor_count () : 0;
-}
+  bool
+  jit_block::update_idom (size_t avisit_count)
+  {
+    if (visited (avisit_count) || ! use_count ())
+      return false;
+
+    bool changed = false;
+    for (jit_use *use = first_use (); use; use = use->next ())
+      {
+        jit_block *pred = use->user_parent ();
+        changed = pred->update_idom (avisit_count) || changed;
+      }
 
-llvm::BasicBlock *
-jit_block::to_llvm (void) const
-{
-  return llvm::cast<llvm::BasicBlock> (llvm_value);
-}
+    jit_use *use = first_use ();
+    jit_block *new_idom = use->user_parent ();
+    use = use->next ();
+
+    for (; use; use = use->next ())
+      {
+        jit_block *pred = use->user_parent ();
+        jit_block *pidom = pred->idom;
+        if (pidom)
+          new_idom = idom_intersect (pidom, new_idom);
+      }
 
-std::ostream&
-jit_block::print_dom (std::ostream& os) const
-{
-  short_print (os);
-  os << ":\n";
-  os << "  mid: " << mid << std::endl;
-  os << "  predecessors: ";
-  for (jit_use *use = first_use (); use; use = use->next ())
-    os << *use->user_parent () << ' ';
-  os << std::endl;
+    if (idom != new_idom)
+      {
+        idom = new_idom;
+        return true;
+      }
+
+    return changed;
+  }
 
-  os << "  successors: ";
-  for (size_t i = 0; i < successor_count (); ++i)
-    os << *successor (i) << ' ';
-  os << std::endl;
+  void
+  jit_block::label (size_t avisit_count, size_t& number)
+  {
+    if (visited (avisit_count))
+      return;
+
+    for (jit_use *use = first_use (); use; use = use->next ())
+      {
+        jit_block *pred = use->user_parent ();
+        pred->label (avisit_count, number);
+      }
 
-  os << "  idom: ";
-  if (idom)
-    os << *idom;
-  else
-    os << "NULL";
-  os << std::endl;
-  os << "  df: ";
-  for (df_iterator iter = df_begin (); iter != df_end (); ++iter)
-    os << **iter << ' ';
-  os << std::endl;
+    mid = number++;
+  }
+
+  void
+  jit_block::pop_all (void)
+  {
+    for (iterator iter = begin (); iter != end (); ++iter)
+      {
+        jit_instruction *instr = *iter;
+        instr->pop_variable ();
+      }
+  }
 
-  os << "  dom_succ: ";
-  for (size_t i = 0; i < dom_succ.size (); ++i)
-    os << *dom_succ[i] << ' ';
-
-  return os << std::endl;
-}
+  std::ostream&
+  jit_block::print (std::ostream& os, size_t indent) const
+  {
+    print_indent (os, indent);
+    short_print (os) << ":        %pred = ";
+    for (jit_use *use = first_use (); use; use = use->next ())
+      {
+        jit_block *pred = use->user_parent ();
+        os << *pred;
+        if (use->next ())
+          os << ", ";
+      }
+    os << std::endl;
 
-void
-jit_block::compute_df (size_t avisit_count)
-{
-  if (visited (avisit_count))
-    return;
+    for (const_iterator iter = begin (); iter != end (); ++iter)
+      {
+        jit_instruction *instr = *iter;
+        instr->print (os, indent + 1) << std::endl;
+      }
+    return os;
+  }
+
+  jit_block *
+  jit_block::maybe_split (jit_factory& factory, jit_block_list& blocks,
+                          jit_block *asuccessor)
+  {
+    if (successor_count () > 1)
+      {
+        jit_terminator *term = terminator ();
+        size_t idx = term->successor_index (asuccessor);
+        jit_block *split = factory.create<jit_block> ("phi_split", mvisit_count);
 
-  if (use_count () >= 2)
-    {
-      for (jit_use *use = first_use (); use; use = use->next ())
-        {
-          jit_block *runner = use->user_parent ();
-          while (runner != idom)
-            {
-              runner->mdf.insert (this);
-              runner = runner->idom;
-            }
-        }
-    }
+        // place after this to ensure define before use in the blocks list
+        blocks.insert_after (this, split);
+
+        term->stash_argument (idx, split);
+        jit_branch *br = split->append (factory.create<jit_branch> (asuccessor));
+        replace_in_phi (asuccessor, split);
 
-  for (size_t i = 0; i < successor_count (); ++i)
-    successor (i)->compute_df (avisit_count);
-}
+        if (alive ())
+          {
+            split->mark_alive ();
+            br->infer ();
+          }
 
-bool
-jit_block::update_idom (size_t avisit_count)
-{
-  if (visited (avisit_count) || ! use_count ())
-    return false;
+        return split;
+      }
+
+    return this;
+  }
 
-  bool changed = false;
-  for (jit_use *use = first_use (); use; use = use->next ())
-    {
-      jit_block *pred = use->user_parent ();
-      changed = pred->update_idom (avisit_count) || changed;
-    }
+  void
+  jit_block::create_dom_tree (size_t avisit_count)
+  {
+    if (visited (avisit_count))
+      return;
+
+    if (idom != this)
+      idom->dom_succ.push_back (this);
+
+    for (size_t i = 0; i < successor_count (); ++i)
+      successor (i)->create_dom_tree (avisit_count);
+  }
 
-  jit_use *use = first_use ();
-  jit_block *new_idom = use->user_parent ();
-  use = use->next ();
+  jit_block *
+  jit_block::idom_intersect (jit_block *i, jit_block *j)
+  {
+    while (i && j && i != j)
+      {
+        while (i && i->id () > j->id ())
+          i = i->idom;
 
-  for (; use; use = use->next ())
-    {
-      jit_block *pred = use->user_parent ();
-      jit_block *pidom = pred->idom;
-      if (pidom)
-        new_idom = idom_intersect (pidom, new_idom);
-    }
+        while (i && j && j->id () > i->id ())
+          j = j->idom;
+      }
+
+    return i ? i : j;
+  }
+
+  // -------------------- jit_phi_incomming --------------------
 
-  if (idom != new_idom)
-    {
-      idom = new_idom;
-      return true;
-    }
+  jit_block *
+  jit_phi_incomming::user_parent (void) const
+  { return muser->parent (); }
 
-  return changed;
-}
+  // -------------------- jit_phi --------------------
+  bool
+  jit_phi::prune (void)
+  {
+    jit_block *p = parent ();
+    size_t new_idx = 0;
+    jit_value *unique = argument (1);
 
-void
-jit_block::label (size_t avisit_count, size_t& number)
-{
-  if (visited (avisit_count))
-    return;
+    for (size_t i = 0; i < argument_count (); ++i)
+      {
+        jit_block *inc = incomming (i);
+        if (inc->branch_alive (p))
+          {
+            if (unique != argument (i))
+              unique = 0;
 
-  for (jit_use *use = first_use (); use; use = use->next ())
-    {
-      jit_block *pred = use->user_parent ();
-      pred->label (avisit_count, number);
-    }
+            if (new_idx != i)
+              {
+                stash_argument (new_idx, argument (i));
+                mincomming[new_idx].stash_value (inc);
+              }
 
-  mid = number++;
-}
+            ++new_idx;
+          }
+      }
+
+    if (new_idx != argument_count ())
+      {
+        resize_arguments (new_idx);
+        mincomming.resize (new_idx);
+      }
 
-void
-jit_block::pop_all (void)
-{
-  for (iterator iter = begin (); iter != end (); ++iter)
-    {
-      jit_instruction *instr = *iter;
-      instr->pop_variable ();
-    }
-}
+    assert (argument_count () > 0);
+    if (unique)
+      {
+        replace_with (unique);
+        return true;
+      }
+
+    return false;
+  }
 
-std::ostream&
-jit_block::print (std::ostream& os, size_t indent) const
-{
-  print_indent (os, indent);
-  short_print (os) << ":        %pred = ";
-  for (jit_use *use = first_use (); use; use = use->next ())
-    {
-      jit_block *pred = use->user_parent ();
-      os << *pred;
-      if (use->next ())
-        os << ", ";
-    }
-  os << std::endl;
+  bool
+  jit_phi::infer (void)
+  {
+    jit_block *p = parent ();
+    if (! p->alive ())
+      return false;
+
+    jit_type *infered = nullptr;
+    for (size_t i = 0; i < argument_count (); ++i)
+      {
+        jit_block *inc = incomming (i);
+        if (inc->branch_alive (p))
+          infered = jit_typeinfo::join (infered, argument_type (i));
+      }
+
+    if (infered != type ())
+      {
+        stash_type (infered);
+        return true;
+      }
 
-  for (const_iterator iter = begin (); iter != end (); ++iter)
-    {
-      jit_instruction *instr = *iter;
-      instr->print (os, indent + 1) << std::endl;
-    }
-  return os;
-}
+    return false;
+  }
+
+  llvm::PHINode *
+  jit_phi::to_llvm (void) const
+  {
+    return llvm::cast<llvm::PHINode> (jit_value::to_llvm ());
+  }
 
-jit_block *
-jit_block::maybe_split (jit_factory& factory, jit_block_list& blocks,
-                        jit_block *asuccessor)
-{
-  if (successor_count () > 1)
-    {
-      jit_terminator *term = terminator ();
-      size_t idx = term->successor_index (asuccessor);
-      jit_block *split = factory.create<jit_block> ("phi_split", mvisit_count);
+  // -------------------- jit_terminator --------------------
+  size_t
+  jit_terminator::successor_index (const jit_block *asuccessor) const
+  {
+    size_t scount = successor_count ();
+    for (size_t i = 0; i < scount; ++i)
+      if (successor (i) == asuccessor)
+        return i;
+
+    panic_impossible ();
+  }
 
-      // place after this to ensure define before use in the blocks list
-      blocks.insert_after (this, split);
+  bool
+  jit_terminator::infer (void)
+  {
+    if (! parent ()->alive ())
+      return false;
 
-      term->stash_argument (idx, split);
-      jit_branch *br = split->append (factory.create<jit_branch> (asuccessor));
-      replace_in_phi (asuccessor, split);
-
-      if (alive ())
+    bool changed = false;
+    for (size_t i = 0; i < malive.size (); ++i)
+      if (! malive[i] && check_alive (i))
         {
-          split->mark_alive ();
-          br->infer ();
+          changed = true;
+          malive[i] = true;
+          successor (i)->mark_alive ();
         }
 
-      return split;
-    }
-
-  return this;
-}
-
-void
-jit_block::create_dom_tree (size_t avisit_count)
-{
-  if (visited (avisit_count))
-    return;
-
-  if (idom != this)
-    idom->dom_succ.push_back (this);
+    return changed;
+  }
 
-  for (size_t i = 0; i < successor_count (); ++i)
-    successor (i)->create_dom_tree (avisit_count);
-}
-
-jit_block *
-jit_block::idom_intersect (jit_block *i, jit_block *j)
-{
-  while (i && j && i != j)
-    {
-      while (i && i->id () > j->id ())
-        i = i->idom;
-
-      while (i && j && j->id () > i->id ())
-        j = j->idom;
-    }
+  llvm::TerminatorInst *
+  jit_terminator::to_llvm (void) const
+  {
+    return llvm::cast<llvm::TerminatorInst> (jit_value::to_llvm ());
+  }
 
-  return i ? i : j;
-}
-
-// -------------------- jit_phi_incomming --------------------
-
-jit_block *
-jit_phi_incomming::user_parent (void) const
-{ return muser->parent (); }
-
-// -------------------- jit_phi --------------------
-bool
-jit_phi::prune (void)
-{
-  jit_block *p = parent ();
-  size_t new_idx = 0;
-  jit_value *unique = argument (1);
-
-  for (size_t i = 0; i < argument_count (); ++i)
-    {
-      jit_block *inc = incomming (i);
-      if (inc->branch_alive (p))
-        {
-          if (unique != argument (i))
-            unique = 0;
-
-          if (new_idx != i)
-            {
-              stash_argument (new_idx, argument (i));
-              mincomming[new_idx].stash_value (inc);
-            }
-
-          ++new_idx;
-        }
-    }
+  // -------------------- jit_call --------------------
+  bool
+  jit_call::needs_release (void) const
+  {
+    if (type () && jit_typeinfo::get_release (type ()).valid ())
+      {
+        for (jit_use *use = first_use (); use; use = use->next ())
+          {
+            jit_assign *assign = dynamic_cast<jit_assign *> (use->user ());
+            if (assign && assign->artificial ())
+              return false;
+          }
 
-  if (new_idx != argument_count ())
-    {
-      resize_arguments (new_idx);
-      mincomming.resize (new_idx);
-    }
-
-  assert (argument_count () > 0);
-  if (unique)
-    {
-      replace_with (unique);
-      return true;
-    }
-
-  return false;
-}
-
-bool
-jit_phi::infer (void)
-{
-  jit_block *p = parent ();
-  if (! p->alive ())
+        return true;
+      }
     return false;
-
-  jit_type *infered = nullptr;
-  for (size_t i = 0; i < argument_count (); ++i)
-    {
-      jit_block *inc = incomming (i);
-      if (inc->branch_alive (p))
-        infered = jit_typeinfo::join (infered, argument_type (i));
-    }
+  }
 
-  if (infered != type ())
-    {
-      stash_type (infered);
-      return true;
-    }
-
-  return false;
-}
-
-llvm::PHINode *
-jit_phi::to_llvm (void) const
-{
-  return llvm::cast<llvm::PHINode> (jit_value::to_llvm ());
-}
+  bool
+  jit_call::infer (void)
+  {
+    // FIXME: explain algorithm
+    for (size_t i = 0; i < argument_count (); ++i)
+      {
+        already_infered[i] = argument_type (i);
+        if (! already_infered[i])
+          return false;
+      }
 
-// -------------------- jit_terminator --------------------
-size_t
-jit_terminator::successor_index (const jit_block *asuccessor) const
-{
-  size_t scount = successor_count ();
-  for (size_t i = 0; i < scount; ++i)
-    if (successor (i) == asuccessor)
-      return i;
-
-  panic_impossible ();
-}
+    jit_type *infered = moperation.result (already_infered);
+    if (! infered && use_count ())
+      {
+        std::stringstream ss;
+        ss << "Missing overload in type inference for ";
+        print (ss, 0);
+        throw jit_fail_exception (ss.str ());
+      }
 
-bool
-jit_terminator::infer (void)
-{
-  if (! parent ()->alive ())
-    return false;
-
-  bool changed = false;
-  for (size_t i = 0; i < malive.size (); ++i)
-    if (! malive[i] && check_alive (i))
+    if (infered != type ())
       {
-        changed = true;
-        malive[i] = true;
-        successor (i)->mark_alive ();
+        stash_type (infered);
+        return true;
       }
 
-  return changed;
-}
-
-llvm::TerminatorInst *
-jit_terminator::to_llvm (void) const
-{
-  return llvm::cast<llvm::TerminatorInst> (jit_value::to_llvm ());
-}
+    return false;
+  }
 
-// -------------------- jit_call --------------------
-bool
-jit_call::needs_release (void) const
-{
-  if (type () && jit_typeinfo::get_release (type ()).valid ())
-    {
-      for (jit_use *use = first_use (); use; use = use->next ())
-        {
-          jit_assign *assign = dynamic_cast<jit_assign *> (use->user ());
-          if (assign && assign->artificial ())
-            return false;
-        }
+  // -------------------- jit_error_check --------------------
+  std::string
+  jit_error_check::variable_to_string (variable v)
+  {
+    switch (v)
+      {
+      case var_error_state:
+        return "error_state";
+      case var_interrupt:
+        return "interrupt";
+      default:
+        panic_impossible ();
+      }
+  }
 
-      return true;
-    }
-  return false;
-}
+  std::ostream&
+  jit_error_check::print (std::ostream& os, size_t indent) const
+  {
+    print_indent (os, indent) << "error_check " << variable_to_string (mvariable)
+                              << ", ";
 
-bool
-jit_call::infer (void)
-{
-  // FIXME: explain algorithm
-  for (size_t i = 0; i < argument_count (); ++i)
-    {
-      already_infered[i] = argument_type (i);
-      if (! already_infered[i])
-        return false;
-    }
-
-  jit_type *infered = moperation.result (already_infered);
-  if (! infered && use_count ())
-    {
-      std::stringstream ss;
-      ss << "Missing overload in type inference for ";
-      print (ss, 0);
-      throw jit_fail_exception (ss.str ());
-    }
+    if (has_check_for ())
+      os << "<for> " << *check_for () << ", ";
+    print_successor (os << "<normal> ", 1) << ", ";
+    return print_successor (os << "<error> ", 0);
+  }
 
-  if (infered != type ())
-    {
-      stash_type (infered);
-      return true;
-    }
-
-  return false;
-}
+  // -------------------- jit_magic_end --------------------
+  jit_magic_end::context::context (jit_factory& factory, jit_value *avalue,
+                                   size_t aindex, size_t acount)
+    : value (avalue), index (factory.create<jit_const_index> (aindex)),
+      count (factory.create<jit_const_index> (acount))
+  { }
 
-// -------------------- jit_error_check --------------------
-std::string
-jit_error_check::variable_to_string (variable v)
-{
-  switch (v)
-    {
-    case var_error_state:
-      return "error_state";
-    case var_interrupt:
-      return "interrupt";
-    default:
-      panic_impossible ();
-    }
-}
+  jit_magic_end::jit_magic_end (const std::vector<context>& full_context)
+    : contexts (full_context)
+  {
+    resize_arguments (contexts.size ());
+
+    size_t i;
+    std::vector<context>::const_iterator iter;
+    for (iter = contexts.begin (), i = 0; iter != contexts.end (); ++iter, ++i)
+      stash_argument (i, iter->value);
+  }
 
-std::ostream&
-jit_error_check::print (std::ostream& os, size_t indent) const
-{
-  print_indent (os, indent) << "error_check " << variable_to_string (mvariable)
-                            << ", ";
-
-  if (has_check_for ())
-    os << "<for> " << *check_for () << ", ";
-  print_successor (os << "<normal> ", 1) << ", ";
-  return print_successor (os << "<error> ", 0);
-}
+  jit_magic_end::context
+  jit_magic_end::resolve_context (void) const
+  {
+    size_t idx;
+    for (idx = 0; idx < contexts.size (); ++idx)
+      {
+        jit_type *ctx_type = contexts[idx].value->type ();
+        if (! ctx_type || ctx_type->skip_paren ())
+          break;
+      }
 
-// -------------------- jit_magic_end --------------------
-jit_magic_end::context::context (jit_factory& factory, jit_value *avalue,
-                                 size_t aindex, size_t acount)
-  : value (avalue), index (factory.create<jit_const_index> (aindex)),
-    count (factory.create<jit_const_index> (acount))
-{ }
+    if (idx >= contexts.size ())
+      idx = 0;
 
-jit_magic_end::jit_magic_end (const std::vector<context>& full_context)
-  : contexts (full_context)
-{
-  resize_arguments (contexts.size ());
-
-  size_t i;
-  std::vector<context>::const_iterator iter;
-  for (iter = contexts.begin (), i = 0; iter != contexts.end (); ++iter, ++i)
-    stash_argument (i, iter->value);
-}
+    context ret = contexts[idx];
+    ret.value = argument (idx);
+    return ret;
+  }
 
-jit_magic_end::context
-jit_magic_end::resolve_context (void) const
-{
-  size_t idx;
-  for (idx = 0; idx < contexts.size (); ++idx)
-    {
-      jit_type *ctx_type = contexts[idx].value->type ();
-      if (! ctx_type || ctx_type->skip_paren ())
-        break;
-    }
+  bool
+  jit_magic_end::infer (void)
+  {
+    jit_type *new_type = overload ().result ();
+    if (new_type != type ())
+      {
+        stash_type (new_type);
+        return true;
+      }
 
-  if (idx >= contexts.size ())
-    idx = 0;
-
-  context ret = contexts[idx];
-  ret.value = argument (idx);
-  return ret;
-}
+    return false;
+  }
 
-bool
-jit_magic_end::infer (void)
-{
-  jit_type *new_type = overload ().result ();
-  if (new_type != type ())
-    {
-      stash_type (new_type);
-      return true;
-    }
-
-  return false;
-}
+  std::ostream&
+  jit_magic_end::print (std::ostream& os, size_t indent) const
+  {
+    context ctx = resolve_context ();
+    short_print (print_indent (os, indent)) << " (" << *ctx.value << ", ";
+    return os << *ctx.index << ", " << *ctx.count << ')';
+  }
 
-std::ostream&
-jit_magic_end::print (std::ostream& os, size_t indent) const
-{
-  context ctx = resolve_context ();
-  short_print (print_indent (os, indent)) << " (" << *ctx.value << ", ";
-  return os << *ctx.index << ", " << *ctx.count << ')';
-}
+  const jit_function&
+  jit_magic_end::overload () const
+  {
+    const context& ctx = resolve_context ();
+    return jit_typeinfo::end (ctx.value, ctx.index, ctx.count);
+  }
 
-const jit_function&
-jit_magic_end::overload () const
-{
-  const context& ctx = resolve_context ();
-  return jit_typeinfo::end (ctx.value, ctx.index, ctx.count);
 }
 
 #endif

--- a/libinterp/parse-tree/jit-ir.h	Sat Oct 07 09:59:16 2017 +0200
+++ b/libinterp/parse-tree/jit-ir.h	Sun Oct 15 21:08:02 2017 +0200
@@ -35,9 +35,12 @@
 
 #include "jit-typeinfo.h"
 
-// The low level octave jit ir
-// this ir is close to llvm, but contains information for doing type inference.
-// We convert the octave parse tree to this IR directly.
+namespace octave
+{
+
+  // The low level octave jit ir
+  // this ir is close to llvm, but contains information for doing type inference.
+  // We convert the octave parse tree to this IR directly.
 
 #define JIT_VISIT_IR_NOTEMPLATE                 \
   JIT_METH(block);                              \
@@ -66,1347 +69,1349 @@
   JIT_VISIT_IR_NOTEMPLATE                       \
   JIT_VISIT_IR_CONST
 
-// forward declare all ir classes
+  // forward declare all ir classes
 #define JIT_METH(cname)                         \
   class jit_ ## cname;
 
-JIT_VISIT_IR_NOTEMPLATE
+  JIT_VISIT_IR_NOTEMPLATE
 
 #undef JIT_METH
 
-// ABCs which aren't included in JIT_VISIT_IR_ALL
-class jit_instruction;
-class jit_terminator;
+  // ABCs which aren't included in JIT_VISIT_IR_ALL
+  class jit_instruction;
+  class jit_terminator;
 
-template <typename T, jit_type *(*EXTRACT_T)(void), typename PASS_T = T,
-          bool QUOTE=false>
-class jit_const;
+  template <typename T, jit_type *(*EXTRACT_T)(void), typename PASS_T = T,
+            bool QUOTE=false>
+  class jit_const;
 
-typedef jit_const<bool, jit_typeinfo::get_bool> jit_const_bool;
-typedef jit_const<double, jit_typeinfo::get_scalar> jit_const_scalar;
-typedef jit_const<Complex, jit_typeinfo::get_complex> jit_const_complex;
-typedef jit_const<octave_idx_type, jit_typeinfo::get_index> jit_const_index;
+  typedef jit_const<bool, jit_typeinfo::get_bool> jit_const_bool;
+  typedef jit_const<double, jit_typeinfo::get_scalar> jit_const_scalar;
+  typedef jit_const<Complex, jit_typeinfo::get_complex> jit_const_complex;
+  typedef jit_const<octave_idx_type, jit_typeinfo::get_index> jit_const_index;
 
-typedef jit_const<std::string, jit_typeinfo::get_string, const std::string&,
-                  true> jit_const_string;
-typedef jit_const<jit_range, jit_typeinfo::get_range, const jit_range&>
-jit_const_range;
+  typedef jit_const<std::string, jit_typeinfo::get_string, const std::string&,
+                    true> jit_const_string;
+  typedef jit_const<jit_range, jit_typeinfo::get_range, const jit_range&>
+  jit_const_range;
 
-class jit_ir_walker;
-class jit_use;
+  class jit_ir_walker;
+  class jit_use;
 
-// Creates and tracks memory for jit_value and subclasses.
-// Memory managment is simple, all values that are created live as long as the
-// factory.
-class
-jit_factory
-{
-  typedef std::list<jit_value *> value_list;
+  // Creates and tracks memory for jit_value and subclasses.
+  // Memory managment is simple, all values that are created live as long as the
+  // factory.
+  class
+  jit_factory
+  {
+    typedef std::list<jit_value *> value_list;
 
-public:
+  public:
 
-  ~jit_factory (void);
+    ~jit_factory (void);
 
-  const value_list& constants (void) const { return mconstants; }
+    const value_list& constants (void) const { return mconstants; }
 
-  template <typename T, typename ...Args>
-  T * create (const Args&... args)
-  {
-    T *ret = new T (args...);
-    track_value (ret);
-    return ret;
-  }
+    template <typename T, typename ...Args>
+    T * create (const Args&... args)
+    {
+      T *ret = new T (args...);
+      track_value (ret);
+      return ret;
+    }
 
-private:
+  private:
 
-  void track_value (jit_value *v);
+    void track_value (jit_value *v);
 
-  value_list all_values;
+    value_list all_values;
 
-  value_list mconstants;
-};
+    value_list mconstants;
+  };
 
-// A list of basic blocks (jit_block) which form some body of code.
-//
-// We do not directly inherit from std::list because we need to update the
-// blocks stashed location in push_back and insert.
-class
-jit_block_list
-{
-public:
-  typedef std::list<jit_block *>::iterator iterator;
-  typedef std::list<jit_block *>::const_iterator const_iterator;
+  // A list of basic blocks (jit_block) which form some body of code.
+  //
+  // We do not directly inherit from std::list because we need to update the
+  // blocks stashed location in push_back and insert.
+  class
+  jit_block_list
+  {
+  public:
+    typedef std::list<jit_block *>::iterator iterator;
+    typedef std::list<jit_block *>::const_iterator const_iterator;
 
-  jit_block * back (void) const { return mlist.back (); }
+    jit_block * back (void) const { return mlist.back (); }
 
-  iterator begin (void) { return mlist.begin (); }
+    iterator begin (void) { return mlist.begin (); }
 
-  const_iterator begin (void) const { return mlist.begin (); }
+    const_iterator begin (void) const { return mlist.begin (); }
 
-  iterator end (void)  { return mlist.end (); }
+    iterator end (void)  { return mlist.end (); }
 
-  const_iterator end (void) const  { return mlist.end (); }
+    const_iterator end (void) const  { return mlist.end (); }
 
-  iterator erase (iterator iter) { return mlist.erase (iter); }
+    iterator erase (iterator iter) { return mlist.erase (iter); }
 
-  jit_block * front (void) const { return mlist.front (); }
+    jit_block * front (void) const { return mlist.front (); }
 
-  void insert_after (iterator iter, jit_block *ablock);
+    void insert_after (iterator iter, jit_block *ablock);
 
-  void insert_after (jit_block *loc, jit_block *ablock);
+    void insert_after (jit_block *loc, jit_block *ablock);
 
-  void insert_before (iterator iter, jit_block *ablock);
+    void insert_before (iterator iter, jit_block *ablock);
 
-  void insert_before (jit_block *loc, jit_block *ablock);
+    void insert_before (jit_block *loc, jit_block *ablock);
 
-  void label (void);
+    void label (void);
 
-  std::ostream& print (std::ostream& os, const std::string& header) const;
+    std::ostream& print (std::ostream& os, const std::string& header) const;
 
-  std::ostream& print_dom (std::ostream& os) const;
+    std::ostream& print_dom (std::ostream& os) const;
 
-  void push_back (jit_block *b);
-private:
-  std::list<jit_block *> mlist;
-};
+    void push_back (jit_block *b);
+  private:
+    std::list<jit_block *> mlist;
+  };
 
-std::ostream& operator<<(std::ostream& os, const jit_block_list& blocks);
+  std::ostream& operator<<(std::ostream& os, const jit_block_list& blocks);
 
-class
-jit_value : public jit_internal_list<jit_value, jit_use>
-{
-public:
-  jit_value (void) : llvm_value (0), ty (0), mlast_use (0),
-                     min_worklist (false) { }
+  class
+  jit_value : public jit_internal_list<jit_value, jit_use>
+  {
+  public:
+    jit_value (void) : llvm_value (0), ty (0), mlast_use (0),
+                       min_worklist (false) { }
 
-  virtual ~jit_value (void);
+    virtual ~jit_value (void);
 
-  bool in_worklist (void) const
-  {
-    return min_worklist;
-  }
+    bool in_worklist (void) const
+    {
+      return min_worklist;
+    }
 
-  void stash_in_worklist (bool ain_worklist)
-  {
-    min_worklist = ain_worklist;
-  }
+    void stash_in_worklist (bool ain_worklist)
+    {
+      min_worklist = ain_worklist;
+    }
 
-  // The block of the first use which is not a jit_error_check
-  // So this is not necessarily first_use ()->parent ().
-  jit_block * first_use_block (void);
+    // The block of the first use which is not a jit_error_check
+    // So this is not necessarily first_use ()->parent ().
+    jit_block * first_use_block (void);
 
-  // replace all uses with
-  virtual void replace_with (jit_value *value);
+    // replace all uses with
+    virtual void replace_with (jit_value *value);
 
-  jit_type * type (void) const { return ty; }
+    jit_type * type (void) const { return ty; }
 
-  llvm::Type * type_llvm (void) const
-  {
-    return ty ? ty->to_llvm () : nullptr;
-  }
+    llvm::Type * type_llvm (void) const
+    {
+      return ty ? ty->to_llvm () : nullptr;
+    }
 
-  const std::string& type_name (void) const
-  {
-    return ty->name ();
-  }
+    const std::string& type_name (void) const
+    {
+      return ty->name ();
+    }
 
-  void stash_type (jit_type *new_ty) { ty = new_ty; }
+    void stash_type (jit_type *new_ty) { ty = new_ty; }
 
-  std::string print_string (void)
-  {
-    std::stringstream ss;
-    print (ss);
-    return ss.str ();
-  }
+    std::string print_string (void)
+    {
+      std::stringstream ss;
+      print (ss);
+      return ss.str ();
+    }
 
-  jit_instruction * last_use (void) const { return mlast_use; }
+    jit_instruction * last_use (void) const { return mlast_use; }
 
-  void stash_last_use (jit_instruction *alast_use)
-  {
-    mlast_use = alast_use;
-  }
+    void stash_last_use (jit_instruction *alast_use)
+    {
+      mlast_use = alast_use;
+    }
 
-  virtual bool needs_release (void) const { return false; }
+    virtual bool needs_release (void) const { return false; }
 
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const = 0;
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const = 0;
 
-  virtual std::ostream& short_print (std::ostream& os) const
-  { return print (os); }
+    virtual std::ostream& short_print (std::ostream& os) const
+    { return print (os); }
 
-  virtual void accept (jit_ir_walker& walker) = 0;
+    virtual void accept (jit_ir_walker& walker) = 0;
 
-  bool has_llvm (void) const
-  {
-    return llvm_value;
-  }
+    bool has_llvm (void) const
+    {
+      return llvm_value;
+    }
 
-  llvm::Value * to_llvm (void) const
-  {
-    assert (llvm_value);
-    return llvm_value;
-  }
+    llvm::Value * to_llvm (void) const
+    {
+      assert (llvm_value);
+      return llvm_value;
+    }
 
-  void stash_llvm (llvm::Value *compiled)
-  {
-    llvm_value = compiled;
-  }
+    void stash_llvm (llvm::Value *compiled)
+    {
+      llvm_value = compiled;
+    }
 
-protected:
-  std::ostream& print_indent (std::ostream& os, size_t indent = 0) const
-  {
-    for (size_t i = 0; i < indent * 8; ++i)
-      os << ' ';
-    return os;
-  }
+  protected:
+    std::ostream& print_indent (std::ostream& os, size_t indent = 0) const
+    {
+      for (size_t i = 0; i < indent * 8; ++i)
+        os << ' ';
+      return os;
+    }
 
-  llvm::Value *llvm_value;
-private:
-  jit_type *ty;
-  jit_instruction *mlast_use;
-  bool min_worklist;
-};
+    llvm::Value *llvm_value;
+  private:
+    jit_type *ty;
+    jit_instruction *mlast_use;
+    bool min_worklist;
+  };
 
-std::ostream& operator<< (std::ostream& os, const jit_value& value);
-std::ostream& jit_print (std::ostream& os, jit_value *avalue);
+  std::ostream& operator<< (std::ostream& os, const jit_value& value);
+  std::ostream& jit_print (std::ostream& os, jit_value *avalue);
 
-class
-jit_use : public jit_internal_node<jit_value, jit_use>
-{
-public:
-  // some compilers don't allow us to use jit_internal_node without template
-  // paremeters
-  typedef jit_internal_node<jit_value, jit_use> PARENT_T;
-
-  jit_use (void) : muser (0), mindex (0) { }
+  class
+  jit_use : public jit_internal_node<jit_value, jit_use>
+  {
+  public:
+    // some compilers don't allow us to use jit_internal_node without template
+    // paremeters
+    typedef jit_internal_node<jit_value, jit_use> PARENT_T;
 
-  // we should really have a move operator, but not until c++11 :(
-  jit_use (const jit_use& use) : muser (0), mindex (0)
-  {
-    *this = use;
-  }
-
-  jit_use& operator= (const jit_use& use)
-  {
-    stash_value (use.value (), use.user (), use.index ());
-    return *this;
-  }
-
-  size_t index (void) const { return mindex; }
+    jit_use (void) : muser (0), mindex (0) { }
 
-  jit_instruction * user (void) const { return muser; }
-
-  jit_block * user_parent (void) const;
-
-  std::list<jit_block *> user_parent_location (void) const;
+    // we should really have a move operator, but not until c++11 :(
+    jit_use (const jit_use& use) : muser (0), mindex (0)
+    {
+      *this = use;
+    }
 
-  void stash_value (jit_value *avalue, jit_instruction *auser = nullptr,
-                    size_t aindex = -1)
-  {
-    PARENT_T::stash_value (avalue);
-    mindex = aindex;
-    muser = auser;
-  }
-private:
-  jit_instruction *muser;
-  size_t mindex;
-};
-
-class
-jit_instruction : public jit_value
-{
-public:
-  // FIXME: this code could be so much pretier with varadic templates...
-  jit_instruction (void) : mid (next_id ()), mparent (0)
-  { }
+    jit_use& operator= (const jit_use& use)
+    {
+      stash_value (use.value (), use.user (), use.index ());
+      return *this;
+    }
 
-  jit_instruction (size_t nargs) : mid (next_id ()), mparent (0)
-  {
-    already_infered.reserve (nargs);
-    marguments.reserve (nargs);
-  }
+    size_t index (void) const { return mindex; }
+
+    jit_instruction * user (void) const { return muser; }
 
-  template <typename ...Args>
-  jit_instruction (jit_value * arg1, Args... other_args)
-    : already_infered (1 + sizeof... (other_args)),
-      marguments (1 + sizeof... (other_args)),
-      mid (next_id ()), mparent (nullptr)
-  {
-    stash_argument (0, arg1, other_args...);
-  }
+    jit_block * user_parent (void) const;
 
-  jit_instruction (const std::vector<jit_value *>& aarguments)
-    : already_infered (aarguments.size ()), marguments (aarguments.size ()),
-      mid (next_id ()), mparent (0)
-  {
-    for (size_t i = 0; i < aarguments.size (); ++i)
-      stash_argument (i, aarguments[i]);
-  }
+    std::list<jit_block *> user_parent_location (void) const;
 
-  static void reset_ids (void)
-  {
-    next_id (true);
-  }
-
-  jit_value * argument (size_t i) const
-  {
-    return marguments[i].value ();
-  }
+    void stash_value (jit_value *avalue, jit_instruction *auser = nullptr,
+                      size_t aindex = -1)
+    {
+      PARENT_T::stash_value (avalue);
+      mindex = aindex;
+      muser = auser;
+    }
+  private:
+    jit_instruction *muser;
+    size_t mindex;
+  };
 
-  llvm::Value * argument_llvm (size_t i) const
-  {
-    assert (argument (i));
-    return argument (i)->to_llvm ();
-  }
-
-  jit_type * argument_type (size_t i) const
-  {
-    return argument (i)->type ();
-  }
-
-  llvm::Type * argument_type_llvm (size_t i) const
-  {
-    assert (argument (i));
-    return argument_type (i)->to_llvm ();
-  }
-
-  std::ostream& print_argument (std::ostream& os, size_t i) const
+  class
+  jit_instruction : public jit_value
   {
-    if (argument (i))
-      return argument (i)->short_print (os);
-    else
-      return os << "NULL";
-  }
+  public:
+    // FIXME: this code could be so much pretier with varadic templates...
+    jit_instruction (void) : mid (next_id ()), mparent (0)
+    { }
 
-  void stash_argument (size_t i, jit_value * arg)
-  {
-    marguments[i].stash_value (arg, this, i);
-  }
+    jit_instruction (size_t nargs) : mid (next_id ()), mparent (0)
+    {
+      already_infered.reserve (nargs);
+      marguments.reserve (nargs);
+    }
 
-  template <typename ...Args>
-  void stash_argument (size_t i, jit_value * arg1, Args... aargs)
-  {
-    marguments[i].stash_value (arg1, this, i);
-    stash_argument (++i, aargs...);
-  }
+    template <typename ...Args>
+    jit_instruction (jit_value * arg1, Args... other_args)
+      : already_infered (1 + sizeof... (other_args)),
+        marguments (1 + sizeof... (other_args)),
+        mid (next_id ()), mparent (nullptr)
+    {
+      stash_argument (0, arg1, other_args...);
+    }
 
-  void push_argument (jit_value *arg)
-  {
-    marguments.push_back (jit_use ());
-    stash_argument (marguments.size () - 1, arg);
-    already_infered.push_back (0);
-  }
+    jit_instruction (const std::vector<jit_value *>& aarguments)
+      : already_infered (aarguments.size ()), marguments (aarguments.size ()),
+        mid (next_id ()), mparent (0)
+    {
+      for (size_t i = 0; i < aarguments.size (); ++i)
+        stash_argument (i, aarguments[i]);
+    }
+
+    static void reset_ids (void)
+    {
+      next_id (true);
+    }
 
-  size_t argument_count (void) const
-  {
-    return marguments.size ();
-  }
+    jit_value * argument (size_t i) const
+    {
+      return marguments[i].value ();
+    }
 
-  void resize_arguments (size_t acount, jit_value *adefault = nullptr)
-  {
-    size_t old = marguments.size ();
-    marguments.resize (acount);
-    already_infered.resize (acount);
+    llvm::Value * argument_llvm (size_t i) const
+    {
+      assert (argument (i));
+      return argument (i)->to_llvm ();
+    }
+
+    jit_type * argument_type (size_t i) const
+    {
+      return argument (i)->type ();
+    }
 
-    if (adefault)
-      for (size_t i = old; i < acount; ++i)
-        stash_argument (i, adefault);
-  }
-
-  const std::vector<jit_use>& arguments (void) const { return marguments; }
+    llvm::Type * argument_type_llvm (size_t i) const
+    {
+      assert (argument (i));
+      return argument_type (i)->to_llvm ();
+    }
 
-  // argument types which have been infered already
-  const std::vector<jit_type *>& argument_types (void) const
-  { return already_infered; }
+    std::ostream& print_argument (std::ostream& os, size_t i) const
+    {
+      if (argument (i))
+        return argument (i)->short_print (os);
+      else
+        return os << "NULL";
+    }
 
-  virtual void push_variable (void) { }
+    void stash_argument (size_t i, jit_value * arg)
+    {
+      marguments[i].stash_value (arg, this, i);
+    }
 
-  virtual void pop_variable (void) { }
+    template <typename ...Args>
+    void stash_argument (size_t i, jit_value * arg1, Args... aargs)
+    {
+      marguments[i].stash_value (arg1, this, i);
+      stash_argument (++i, aargs...);
+    }
 
-  virtual void construct_ssa (void)
-  {
-    do_construct_ssa (0, argument_count ());
-  }
+    void push_argument (jit_value *arg)
+    {
+      marguments.push_back (jit_use ());
+      stash_argument (marguments.size () - 1, arg);
+      already_infered.push_back (0);
+    }
 
-  virtual bool infer (void) { return false; }
+    size_t argument_count (void) const
+    {
+      return marguments.size ();
+    }
 
-  void remove (void);
+    void resize_arguments (size_t acount, jit_value *adefault = nullptr)
+    {
+      size_t old = marguments.size ();
+      marguments.resize (acount);
+      already_infered.resize (acount);
 
-  virtual std::ostream& short_print (std::ostream& os) const;
+      if (adefault)
+        for (size_t i = old; i < acount; ++i)
+          stash_argument (i, adefault);
+    }
 
-  jit_block * parent (void) const { return mparent; }
+    const std::vector<jit_use>& arguments (void) const { return marguments; }
+
+    // argument types which have been infered already
+    const std::vector<jit_type *>& argument_types (void) const
+    { return already_infered; }
 
-  std::list<jit_instruction *>::iterator location (void) const
-  {
-    return mlocation;
-  }
+    virtual void push_variable (void) { }
+
+    virtual void pop_variable (void) { }
 
-  llvm::BasicBlock * parent_llvm (void) const;
+    virtual void construct_ssa (void)
+    {
+      do_construct_ssa (0, argument_count ());
+    }
+
+    virtual bool infer (void) { return false; }
+
+    void remove (void);
 
-  void stash_parent (jit_block *aparent,
-                     std::list<jit_instruction *>::iterator alocation)
-  {
-    mparent = aparent;
-    mlocation = alocation;
-  }
+    virtual std::ostream& short_print (std::ostream& os) const;
+
+    jit_block * parent (void) const { return mparent; }
+
+    std::list<jit_instruction *>::iterator location (void) const
+    {
+      return mlocation;
+    }
 
-  size_t id (void) const { return mid; }
-protected:
+    llvm::BasicBlock * parent_llvm (void) const;
 
-  // Do SSA replacement on arguments in [start, end)
-  void do_construct_ssa (size_t start, size_t end);
+    void stash_parent (jit_block *aparent,
+                       std::list<jit_instruction *>::iterator alocation)
+    {
+      mparent = aparent;
+      mlocation = alocation;
+    }
+
+    size_t id (void) const { return mid; }
+  protected:
 
-  std::vector<jit_type *> already_infered;
-private:
-  static size_t next_id (bool reset = false)
-  {
-    static size_t ret = 0;
-    if (reset)
-      return ret = 0;
+    // Do SSA replacement on arguments in [start, end)
+    void do_construct_ssa (size_t start, size_t end);
+
+    std::vector<jit_type *> already_infered;
+  private:
+    static size_t next_id (bool reset = false)
+    {
+      static size_t ret = 0;
+      if (reset)
+        return ret = 0;
 
-    return ret++;
-  }
+      return ret++;
+    }
 
-  std::vector<jit_use> marguments;
+    std::vector<jit_use> marguments;
 
-  size_t mid;
-  jit_block *mparent;
-  std::list<jit_instruction *>::iterator mlocation;
-};
+    size_t mid;
+    jit_block *mparent;
+    std::list<jit_instruction *>::iterator mlocation;
+  };
 
-// defnie accept methods for subclasses
+  // defnie accept methods for subclasses
 #define JIT_VALUE_ACCEPT                        \
   virtual void accept (jit_ir_walker& walker);
 
-// for use as a dummy argument during conversion to LLVM
-class
-jit_argument : public jit_value
-{
-public:
-  jit_argument (jit_type *atype, llvm::Value *avalue)
+  // for use as a dummy argument during conversion to LLVM
+  class
+  jit_argument : public jit_value
+  {
+  public:
+    jit_argument (jit_type *atype, llvm::Value *avalue)
+    {
+      stash_type (atype);
+      stash_llvm (avalue);
+    }
+
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
+    {
+      print_indent (os, indent);
+      return jit_print (os, type ()) << ": DUMMY";
+    }
+
+    JIT_VALUE_ACCEPT;
+  };
+
+  template <typename T, jit_type *(*EXTRACT_T)(void), typename PASS_T, bool QUOTE>
+  class
+  jit_const : public jit_value
+  {
+  public:
+    typedef PASS_T pass_t;
+
+    jit_const (PASS_T avalue) : mvalue (avalue)
+    {
+      stash_type (EXTRACT_T ());
+    }
+
+    PASS_T value (void) const { return mvalue; }
+
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
+    {
+      print_indent (os, indent);
+      jit_print (os, type ()) << ": ";
+      if (QUOTE)
+        os << '"';
+      os << mvalue;
+      if (QUOTE)
+        os << '"';
+      return os;
+    }
+
+    JIT_VALUE_ACCEPT;
+  private:
+    T mvalue;
+  };
+
+  class jit_phi_incomming;
+
+  class
+  jit_block : public jit_value, public jit_internal_list<jit_block,
+                                                         jit_phi_incomming>
   {
-    stash_type (atype);
-    stash_llvm (avalue);
-  }
+    typedef jit_internal_list<jit_block, jit_phi_incomming> ILIST_T;
+  public:
+    typedef std::list<jit_instruction *> instruction_list;
+    typedef instruction_list::iterator iterator;
+    typedef instruction_list::const_iterator const_iterator;
+
+    typedef std::set<jit_block *> df_set;
+    typedef df_set::const_iterator df_iterator;
+
+    static const size_t NO_ID = static_cast<size_t> (-1);
+
+    jit_block (const std::string& aname, size_t avisit_count = 0)
+      : mvisit_count (avisit_count), mid (NO_ID), idom (0), mname (aname),
+        malive (false)
+    { }
+
+    virtual void replace_with (jit_value *value);
+
+    void replace_in_phi (jit_block *ablock, jit_block *with);
+
+    // we have a new internal list, but we want to stay compatible with jit_value
+    jit_use * first_use (void) const { return jit_value::first_use (); }
+
+    size_t use_count (void) const { return jit_value::use_count (); }
+
+    // if a block is alive, then it might be visited during execution
+    bool alive (void) const { return malive; }
+
+    void mark_alive (void) { malive = true; }
+
+    // If we can merge with a successor, do so and return the now empty block
+    jit_block * maybe_merge ();
+
+    // merge another block into this block, leaving the merge block empty
+    void merge (jit_block& merge);
+
+    const std::string& name (void) const { return mname; }
+
+    jit_instruction * prepend (jit_instruction *instr);
+
+    jit_instruction * prepend_after_phi (jit_instruction *instr);
 
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
-  {
-    print_indent (os, indent);
-    return jit_print (os, type ()) << ": DUMMY";
-  }
+    template <typename T>
+    T * append (T *instr)
+    {
+      internal_append (instr);
+      return instr;
+    }
+
+    jit_instruction * insert_before (iterator loc, jit_instruction *instr);
+
+    jit_instruction * insert_before (jit_instruction *loc, jit_instruction *instr)
+    {
+      return insert_before (loc->location (), instr);
+    }
+
+    jit_instruction * insert_after (iterator loc, jit_instruction *instr);
+
+    jit_instruction * insert_after (jit_instruction *loc, jit_instruction *instr)
+    {
+      return insert_after (loc->location (), instr);
+    }
+
+    iterator remove (iterator iter)
+    {
+      jit_instruction *instr = *iter;
+      iter = instructions.erase (iter);
+      instr->stash_parent (0, instructions.end ());
+      return iter;
+    }
+
+    jit_terminator * terminator (void) const;
+
+    // is the jump from pred alive?
+    bool branch_alive (jit_block *asucc) const;
+
+    jit_block * successor (size_t i) const;
+
+    size_t successor_count (void) const;
+
+    iterator begin (void) { return instructions.begin (); }
+
+    const_iterator begin (void) const { return instructions.begin (); }
+
+    iterator end (void) { return instructions.end (); }
+
+    const_iterator end (void) const { return instructions.end (); }
+
+    iterator phi_begin (void);
+
+    iterator phi_end (void);
+
+    iterator nonphi_begin (void);
+
+    // must label before id is valid
+    size_t id (void) const { return mid; }
 
-  JIT_VALUE_ACCEPT;
-};
+    // dominance frontier
+    const df_set& df (void) const { return mdf; }
+
+    df_iterator df_begin (void) const { return mdf.begin (); }
+
+    df_iterator df_end (void) const { return mdf.end (); }
+
+    // label with a RPO walk
+    void label (void)
+    {
+      size_t number = 0;
+      label (mvisit_count, number);
+    }
+
+    void label (size_t avisit_count, size_t& number);
+
+    // See for idom computation algorithm
+    // Cooper, Keith D.; Harvey, Timothy J; and Kennedy, Ken (2001).
+    // "A Simple, Fast Dominance Algorithm"
+    void compute_idom (jit_block& entry_block)
+    {
+      bool changed;
+      entry_block.idom = &entry_block;
+      do
+        changed = update_idom (mvisit_count);
+      while (changed);
+    }
+
+    // compute dominance frontier
+    void compute_df (void)
+    {
+      compute_df (mvisit_count);
+    }
+
+    void create_dom_tree (void)
+    {
+      create_dom_tree (mvisit_count);
+    }
+
+    jit_block * dom_successor (size_t idx) const
+    {
+      return dom_succ[idx];
+    }
+
+    size_t dom_successor_count (void) const
+    {
+      return dom_succ.size ();
+    }
+
+    // call pop_varaible on all instructions
+    void pop_all (void);
+
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const;
+
+    jit_block * maybe_split (jit_factory& factory, jit_block_list& blocks,
+                             jit_block *asuccessor);
+
+    jit_block * maybe_split (jit_factory& factory, jit_block_list& blocks,
+                             jit_block& asuccessor)
+    {
+      return maybe_split (factory, blocks, &asuccessor);
+    }
+
+    // print dominator infomration
+    std::ostream& print_dom (std::ostream& os) const;
+
+    virtual std::ostream& short_print (std::ostream& os) const
+    {
+      os << mname;
+      if (mid != NO_ID)
+        os << mid;
+      else
+        os << '!';
+      return os;
+    }
+
+    llvm::BasicBlock * to_llvm (void) const;
 
-template <typename T, jit_type *(*EXTRACT_T)(void), typename PASS_T, bool QUOTE>
-class
-jit_const : public jit_value
-{
-public:
-  typedef PASS_T pass_t;
+    std::list<jit_block *>::iterator location (void) const
+    { return mlocation; }
+
+    void stash_location (std::list<jit_block *>::iterator alocation)
+    { mlocation = alocation; }
+
+    // used to prevent visiting the same node twice in the graph
+    size_t visit_count (void) const { return mvisit_count; }
+
+    // check if this node has been visited yet at the given visit count.
+    // If we have not been visited yet, mark us as visited.
+    bool visited (size_t avisit_count)
+    {
+      if (mvisit_count <= avisit_count)
+        {
+          mvisit_count = avisit_count + 1;
+          return false;
+        }
+
+      return true;
+    }
+
+    jit_instruction * front (void) { return instructions.front (); }
+
+    jit_instruction * back (void) { return instructions.back (); }
+
+    JIT_VALUE_ACCEPT;
+  private:
+    void internal_append (jit_instruction *instr);
+
+    void compute_df (size_t avisit_count);
+
+    bool update_idom (size_t avisit_count);
+
+    void create_dom_tree (size_t avisit_count);
+
+    static jit_block * idom_intersect (jit_block *i, jit_block *j);
 
-  jit_const (PASS_T avalue) : mvalue (avalue)
+    size_t mvisit_count;
+    size_t mid;
+    jit_block *idom;
+    df_set mdf;
+    std::vector<jit_block *> dom_succ;
+    std::string mname;
+    instruction_list instructions;
+    bool malive;
+    std::list<jit_block *>::iterator mlocation;
+  };
+
+  // keeps track of phi functions that use a block on incomming edges
+  class
+  jit_phi_incomming : public jit_internal_node<jit_block, jit_phi_incomming>
   {
-    stash_type (EXTRACT_T ());
-  }
+  public:
+    jit_phi_incomming (void) : muser (0) { }
+
+    jit_phi_incomming (jit_phi *auser) : muser (auser) { }
+
+    jit_phi_incomming (const jit_phi_incomming& use)
+    {
+      *this = use;
+    }
 
-  PASS_T value (void) const { return mvalue; }
+    jit_phi_incomming& operator= (const jit_phi_incomming& use)
+    {
+      stash_value (use.value ());
+      muser = use.muser;
+      return *this;
+    }
+
+    jit_phi * user (void) const { return muser; }
 
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
+    jit_block * user_parent (void) const;
+  private:
+    jit_phi *muser;
+  };
+
+  // A non-ssa variable
+  class
+  jit_variable : public jit_value
   {
-    print_indent (os, indent);
-    jit_print (os, type ()) << ": ";
-    if (QUOTE)
-      os << '"';
-    os << mvalue;
-    if (QUOTE)
-      os << '"';
-    return os;
-  }
+  public:
+    jit_variable (const std::string& aname) : mname (aname), mlast_use (0) { }
+
+    const std::string& name (void) const { return mname; }
+
+    // manipulate the value_stack, for use during SSA construction.  The top of
+    // the value stack represents the current value for this variable
+    bool has_top (void) const
+    {
+      return ! value_stack.empty ();
+    }
+
+    jit_value * top (void) const
+    {
+      return value_stack.top ();
+    }
+
+    void push (jit_instruction *v)
+    {
+      value_stack.push (v);
+      mlast_use = v;
+    }
+
+    void pop (void)
+    {
+      value_stack.pop ();
+    }
+
+    jit_instruction * last_use (void) const
+    {
+      return mlast_use;
+    }
+
+    void stash_last_use (jit_instruction *instr)
+    {
+      mlast_use = instr;
+    }
+
+    // blocks in which we are used
+    void use_blocks (jit_block::df_set& result)
+    {
+      jit_use *use = first_use ();
+      while (use)
+        {
+          result.insert (use->user_parent ());
+          use = use->next ();
+        }
+    }
+
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
+    {
+      return print_indent (os, indent) << mname;
+    }
+
+    JIT_VALUE_ACCEPT;
+  private:
+    std::string mname;
+    std::stack<jit_value *> value_stack;
+    jit_instruction *mlast_use;
+  };
+
+  class
+  jit_assign_base : public jit_instruction
+  {
+  public:
+    jit_assign_base (jit_variable *adest) : jit_instruction (), mdest (adest) { }
+
+    jit_assign_base (jit_variable *adest, size_t npred) : jit_instruction (npred),
+                                                          mdest (adest) { }
+
+    jit_assign_base (jit_variable *adest, jit_value *arg0, jit_value *arg1)
+      : jit_instruction (arg0, arg1), mdest (adest) { }
+
+    jit_variable * dest (void) const { return mdest; }
+
+    virtual void push_variable (void)
+    {
+      mdest->push (this);
+    }
 
-  JIT_VALUE_ACCEPT;
-private:
-  T mvalue;
-};
+    virtual void pop_variable (void)
+    {
+      mdest->pop ();
+    }
+
+    virtual std::ostream& short_print (std::ostream& os) const
+    {
+      if (type ())
+        jit_print (os, type ()) << ": ";
+
+      dest ()->short_print (os);
+      return os << '#' << id ();
+    }
+  private:
+    jit_variable *mdest;
+  };
+
+  class
+  jit_assign : public jit_assign_base
+  {
+  public:
+    jit_assign (jit_variable *adest, jit_value *asrc)
+      : jit_assign_base (adest, adest, asrc), martificial (false) { }
+
+    jit_value * overwrite (void) const
+    {
+      return argument (0);
+    }
+
+    jit_value * src (void) const
+    {
+      return argument (1);
+    }
+
+    // variables don't get modified in an SSA, but COW requires we modify
+    // variables.  An artificial assign is for when a variable gets modified.  We
+    // need an assign in the SSA, but the reference counts shouldn't be updated.
+    bool artificial (void) const { return martificial; }
+
+    void mark_artificial (void) { martificial = true; }
 
-class jit_phi_incomming;
+    virtual bool infer (void)
+    {
+      jit_type *stype = src ()->type ();
+      if (stype != type())
+        {
+          stash_type (stype);
+          return true;
+        }
+
+      return false;
+    }
+
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
+    {
+      print_indent (os, indent) << *this << " = " << *src ();
+
+      if (artificial ())
+        os << " [artificial]";
+
+      return os;
+    }
+
+    JIT_VALUE_ACCEPT;
+  private:
+    bool martificial;
+  };
+
+  class
+  jit_phi : public jit_assign_base
+  {
+  public:
+    jit_phi (jit_variable *adest, size_t npred)
+      : jit_assign_base (adest, npred)
+    {
+      mincomming.reserve (npred);
+    }
+
+    // removes arguments form dead incomming jumps
+    bool prune (void);
+
+    void add_incomming (jit_block *from, jit_value *value)
+    {
+      push_argument (value);
+      mincomming.push_back (jit_phi_incomming (this));
+      mincomming[mincomming.size () - 1].stash_value (from);
+    }
 
-class
-jit_block : public jit_value, public jit_internal_list<jit_block,
-                                                       jit_phi_incomming>
-{
-  typedef jit_internal_list<jit_block, jit_phi_incomming> ILIST_T;
-public:
-  typedef std::list<jit_instruction *> instruction_list;
-  typedef instruction_list::iterator iterator;
-  typedef instruction_list::const_iterator const_iterator;
+    jit_block * incomming (size_t i) const
+    {
+      return mincomming[i].value ();
+    }
+
+    llvm::BasicBlock * incomming_llvm (size_t i) const
+    {
+      return incomming (i)->to_llvm ();
+    }
+
+    virtual void construct_ssa (void) { }
+
+    virtual bool infer (void);
+
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
+    {
+      std::stringstream ss;
+      print_indent (ss, indent);
+      short_print (ss) << " phi ";
+      std::string ss_str = ss.str ();
+      std::string indent_str (ss_str.size (), ' ');
+      os << ss_str;
+
+      for (size_t i = 0; i < argument_count (); ++i)
+        {
+          if (i > 0)
+            os << indent_str;
+          os << "| ";
+
+          os << *incomming (i) << " -> ";
+          os << *argument (i);
+
+          if (i + 1 < argument_count ())
+            os << std::endl;
+        }
+
+      return os;
+    }
+
+    llvm::PHINode * to_llvm (void) const;
+
+    JIT_VALUE_ACCEPT;
+  private:
+    std::vector<jit_phi_incomming> mincomming;
+  };
+
+  class
+  jit_terminator : public jit_instruction
+  {
+  public:
+
+    template <typename ...Args>
+    jit_terminator (size_t asuccessor_count, Args... args)
+      : jit_instruction (args...),
+        malive (asuccessor_count, false) { }
+
+    jit_block * successor (size_t idx = 0) const
+    {
+      return static_cast<jit_block *> (argument (idx));
+    }
+
+    llvm::BasicBlock * successor_llvm (size_t idx = 0) const
+    {
+      return successor (idx)->to_llvm ();
+    }
+
+    size_t successor_index (const jit_block *asuccessor) const;
+
+    std::ostream& print_successor (std::ostream& os, size_t idx = 0) const
+    {
+      if (alive (idx))
+        os << "[live] ";
+      else
+        os << "[dead] ";
+
+      return successor (idx)->short_print (os);
+    }
+
+    // Check if the jump to successor is live
+    bool alive (const jit_block *asuccessor) const
+    {
+      return alive (successor_index (asuccessor));
+    }
+
+    bool alive (size_t idx) const { return malive[idx]; }
 
-  typedef std::set<jit_block *> df_set;
-  typedef df_set::const_iterator df_iterator;
+    bool alive (int idx) const { return malive[idx]; }
+
+    size_t successor_count (void) const { return malive.size (); }
+
+    virtual bool infer (void);
+
+    llvm::TerminatorInst * to_llvm (void) const;
+  protected:
+    virtual bool check_alive (size_t) const { return true; }
+  private:
+    std::vector<bool> malive;
+  };
+
+  class
+  jit_branch : public jit_terminator
+  {
+  public:
+    jit_branch (jit_block *succ) : jit_terminator (1, succ) { }
+
+    virtual size_t successor_count (void) const { return 1; }
+
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
+    {
+      print_indent (os, indent) << "branch: ";
+      return print_successor (os);
+    }
+
+    JIT_VALUE_ACCEPT;
+  };
+
+  class
+  jit_cond_branch : public jit_terminator
+  {
+  public:
+    jit_cond_branch (jit_value *c, jit_block *ctrue, jit_block *cfalse)
+      : jit_terminator (2, ctrue, cfalse, c) { }
+
+    jit_value * cond (void) const { return argument (2); }
 
-  static const size_t NO_ID = static_cast<size_t> (-1);
+    std::ostream& print_cond (std::ostream& os) const
+    {
+      return cond ()->short_print (os);
+    }
+
+    llvm::Value * cond_llvm (void) const
+    {
+      return cond ()->to_llvm ();
+    }
+
+    virtual size_t successor_count (void) const { return 2; }
+
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
+    {
+      print_indent (os, indent) << "cond_branch: ";
+      print_cond (os) << ", ";
+      print_successor (os, 0) << ", ";
+      return print_successor (os, 1);
+    }
+
+    JIT_VALUE_ACCEPT;
+  };
 
-  jit_block (const std::string& aname, size_t avisit_count = 0)
-    : mvisit_count (avisit_count), mid (NO_ID), idom (0), mname (aname),
-      malive (false)
+  class
+  jit_call : public jit_instruction
+  {
+  public:
+    jit_call (const jit_operation& (*aoperation) (void))
+      : moperation (aoperation ())
+    {
+      const jit_function& ol = overload ();
+      if (ol.valid ())
+        stash_type (ol.result ());
+    }
+
+    jit_call (const jit_operation& aoperation) : moperation (aoperation)
+    {
+      const jit_function& ol = overload ();
+      if (ol.valid ())
+        stash_type (ol.result ());
+    }
+
+    template <typename ...Args>
+    jit_call (const jit_operation& aoperation,
+              jit_value * arg1, Args... other_args)
+      : jit_instruction (arg1, other_args...), moperation (aoperation)
   { }
 
-  virtual void replace_with (jit_value *value);
-
-  void replace_in_phi (jit_block *ablock, jit_block *with);
-
-  // we have a new internal list, but we want to stay compatible with jit_value
-  jit_use * first_use (void) const { return jit_value::first_use (); }
-
-  size_t use_count (void) const { return jit_value::use_count (); }
-
-  // if a block is alive, then it might be visited during execution
-  bool alive (void) const { return malive; }
-
-  void mark_alive (void) { malive = true; }
-
-  // If we can merge with a successor, do so and return the now empty block
-  jit_block * maybe_merge ();
-
-  // merge another block into this block, leaving the merge block empty
-  void merge (jit_block& merge);
-
-  const std::string& name (void) const { return mname; }
-
-  jit_instruction * prepend (jit_instruction *instr);
-
-  jit_instruction * prepend_after_phi (jit_instruction *instr);
-
-  template <typename T>
-  T * append (T *instr)
-  {
-    internal_append (instr);
-    return instr;
-  }
-
-  jit_instruction * insert_before (iterator loc, jit_instruction *instr);
+    template <typename ...Args>
+    jit_call (const jit_operation& (*aoperation) (void),
+              jit_value * arg1, Args... other_args)
+      : jit_instruction (arg1, other_args...), moperation (aoperation ())
+    { }
 
-  jit_instruction * insert_before (jit_instruction *loc, jit_instruction *instr)
-  {
-    return insert_before (loc->location (), instr);
-  }
-
-  jit_instruction * insert_after (iterator loc, jit_instruction *instr);
-
-  jit_instruction * insert_after (jit_instruction *loc, jit_instruction *instr)
-  {
-    return insert_after (loc->location (), instr);
-  }
-
-  iterator remove (iterator iter)
-  {
-    jit_instruction *instr = *iter;
-    iter = instructions.erase (iter);
-    instr->stash_parent (0, instructions.end ());
-    return iter;
-  }
-
-  jit_terminator * terminator (void) const;
-
-  // is the jump from pred alive?
-  bool branch_alive (jit_block *asucc) const;
-
-  jit_block * successor (size_t i) const;
-
-  size_t successor_count (void) const;
-
-  iterator begin (void) { return instructions.begin (); }
-
-  const_iterator begin (void) const { return instructions.begin (); }
-
-  iterator end (void) { return instructions.end (); }
-
-  const_iterator end (void) const { return instructions.end (); }
-
-  iterator phi_begin (void);
-
-  iterator phi_end (void);
-
-  iterator nonphi_begin (void);
+    jit_call (const jit_operation& aoperation,
+              const std::vector<jit_value *>& args)
+      : jit_instruction (args), moperation (aoperation)
+    { }
 
-  // must label before id is valid
-  size_t id (void) const { return mid; }
-
-  // dominance frontier
-  const df_set& df (void) const { return mdf; }
-
-  df_iterator df_begin (void) const { return mdf.begin (); }
-
-  df_iterator df_end (void) const { return mdf.end (); }
-
-  // label with a RPO walk
-  void label (void)
-  {
-    size_t number = 0;
-    label (mvisit_count, number);
-  }
-
-  void label (size_t avisit_count, size_t& number);
-
-  // See for idom computation algorithm
-  // Cooper, Keith D.; Harvey, Timothy J; and Kennedy, Ken (2001).
-  // "A Simple, Fast Dominance Algorithm"
-  void compute_idom (jit_block& entry_block)
-  {
-    bool changed;
-    entry_block.idom = &entry_block;
-    do
-      changed = update_idom (mvisit_count);
-    while (changed);
-  }
-
-  // compute dominance frontier
-  void compute_df (void)
-  {
-    compute_df (mvisit_count);
-  }
+    const jit_operation& operation (void) const { return moperation; }
 
-  void create_dom_tree (void)
-  {
-    create_dom_tree (mvisit_count);
-  }
-
-  jit_block * dom_successor (size_t idx) const
-  {
-    return dom_succ[idx];
-  }
-
-  size_t dom_successor_count (void) const
-  {
-    return dom_succ.size ();
-  }
-
-  // call pop_varaible on all instructions
-  void pop_all (void);
-
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const;
+    bool can_error (void) const
+    {
+      return overload ().can_error ();
+    }
 
-  jit_block * maybe_split (jit_factory& factory, jit_block_list& blocks,
-                           jit_block *asuccessor);
-
-  jit_block * maybe_split (jit_factory& factory, jit_block_list& blocks,
-                           jit_block& asuccessor)
-  {
-    return maybe_split (factory, blocks, &asuccessor);
-  }
-
-  // print dominator infomration
-  std::ostream& print_dom (std::ostream& os) const;
-
-  virtual std::ostream& short_print (std::ostream& os) const
-  {
-    os << mname;
-    if (mid != NO_ID)
-      os << mid;
-    else
-      os << '!';
-    return os;
-  }
-
-  llvm::BasicBlock * to_llvm (void) const;
+    const jit_function& overload (void) const
+    {
+      return moperation.overload (argument_types ());
+    }
 
-  std::list<jit_block *>::iterator location (void) const
-  { return mlocation; }
-
-  void stash_location (std::list<jit_block *>::iterator alocation)
-  { mlocation = alocation; }
-
-  // used to prevent visiting the same node twice in the graph
-  size_t visit_count (void) const { return mvisit_count; }
-
-  // check if this node has been visited yet at the given visit count.
-  // If we have not been visited yet, mark us as visited.
-  bool visited (size_t avisit_count)
-  {
-    if (mvisit_count <= avisit_count)
-      {
-        mvisit_count = avisit_count + 1;
-        return false;
-      }
-
-    return true;
-  }
-
-  jit_instruction * front (void) { return instructions.front (); }
-
-  jit_instruction * back (void) { return instructions.back (); }
-
-  JIT_VALUE_ACCEPT;
-private:
-  void internal_append (jit_instruction *instr);
-
-  void compute_df (size_t avisit_count);
-
-  bool update_idom (size_t avisit_count);
-
-  void create_dom_tree (size_t avisit_count);
-
-  static jit_block * idom_intersect (jit_block *i, jit_block *j);
+    virtual bool needs_release (void) const;
 
-  size_t mvisit_count;
-  size_t mid;
-  jit_block *idom;
-  df_set mdf;
-  std::vector<jit_block *> dom_succ;
-  std::string mname;
-  instruction_list instructions;
-  bool malive;
-  std::list<jit_block *>::iterator mlocation;
-};
-
-// keeps track of phi functions that use a block on incomming edges
-class
-jit_phi_incomming : public jit_internal_node<jit_block, jit_phi_incomming>
-{
-public:
-  jit_phi_incomming (void) : muser (0) { }
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
+    {
+      print_indent (os, indent);
 
-  jit_phi_incomming (jit_phi *auser) : muser (auser) { }
-
-  jit_phi_incomming (const jit_phi_incomming& use)
-  {
-    *this = use;
-  }
-
-  jit_phi_incomming& operator= (const jit_phi_incomming& use)
-  {
-    stash_value (use.value ());
-    muser = use.muser;
-    return *this;
-  }
-
-  jit_phi * user (void) const { return muser; }
-
-  jit_block * user_parent (void) const;
-private:
-  jit_phi *muser;
-};
+      if (use_count ())
+        short_print (os) << " = ";
+      os << "call " << moperation.name () << " (";
 
-// A non-ssa variable
-class
-jit_variable : public jit_value
-{
-public:
-  jit_variable (const std::string& aname) : mname (aname), mlast_use (0) { }
-
-  const std::string& name (void) const { return mname; }
-
-  // manipulate the value_stack, for use during SSA construction.  The top of
-  // the value stack represents the current value for this variable
-  bool has_top (void) const
-  {
-    return ! value_stack.empty ();
-  }
-
-  jit_value * top (void) const
-  {
-    return value_stack.top ();
-  }
-
-  void push (jit_instruction *v)
-  {
-    value_stack.push (v);
-    mlast_use = v;
-  }
-
-  void pop (void)
-  {
-    value_stack.pop ();
-  }
-
-  jit_instruction * last_use (void) const
-  {
-    return mlast_use;
-  }
-
-  void stash_last_use (jit_instruction *instr)
-  {
-    mlast_use = instr;
-  }
+      for (size_t i = 0; i < argument_count (); ++i)
+        {
+          print_argument (os, i);
+          if (i + 1 < argument_count ())
+            os << ", ";
+        }
+      return os << ')';
+    }
 
-  // blocks in which we are used
-  void use_blocks (jit_block::df_set& result)
-  {
-    jit_use *use = first_use ();
-    while (use)
-      {
-        result.insert (use->user_parent ());
-        use = use->next ();
-      }
-  }
-
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
-  {
-    return print_indent (os, indent) << mname;
-  }
+    virtual bool infer (void);
 
-  JIT_VALUE_ACCEPT;
-private:
-  std::string mname;
-  std::stack<jit_value *> value_stack;
-  jit_instruction *mlast_use;
-};
-
-class
-jit_assign_base : public jit_instruction
-{
-public:
-  jit_assign_base (jit_variable *adest) : jit_instruction (), mdest (adest) { }
-
-  jit_assign_base (jit_variable *adest, size_t npred) : jit_instruction (npred),
-                                                        mdest (adest) { }
-
-  jit_assign_base (jit_variable *adest, jit_value *arg0, jit_value *arg1)
-    : jit_instruction (arg0, arg1), mdest (adest) { }
-
-  jit_variable * dest (void) const { return mdest; }
-
-  virtual void push_variable (void)
-  {
-    mdest->push (this);
-  }
+    JIT_VALUE_ACCEPT;
+  private:
+    const jit_operation& moperation;
+  };
 
-  virtual void pop_variable (void)
-  {
-    mdest->pop ();
-  }
-
-  virtual std::ostream& short_print (std::ostream& os) const
-  {
-    if (type ())
-      jit_print (os, type ()) << ": ";
-
-    dest ()->short_print (os);
-    return os << '#' << id ();
-  }
-private:
-  jit_variable *mdest;
-};
-
-class
-jit_assign : public jit_assign_base
-{
-public:
-  jit_assign (jit_variable *adest, jit_value *asrc)
-    : jit_assign_base (adest, adest, asrc), martificial (false) { }
-
-  jit_value * overwrite (void) const
-  {
-    return argument (0);
-  }
-
-  jit_value * src (void) const
-  {
-    return argument (1);
-  }
-
-  // variables don't get modified in an SSA, but COW requires we modify
-  // variables.  An artificial assign is for when a variable gets modified.  We
-  // need an assign in the SSA, but the reference counts shouldn't be updated.
-  bool artificial (void) const { return martificial; }
-
-  void mark_artificial (void) { martificial = true; }
-
-  virtual bool infer (void)
-  {
-    jit_type *stype = src ()->type ();
-    if (stype != type())
-      {
-        stash_type (stype);
-        return true;
-      }
-
-    return false;
-  }
-
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
-  {
-    print_indent (os, indent) << *this << " = " << *src ();
-
-    if (artificial ())
-      os << " [artificial]";
-
-    return os;
-  }
-
-  JIT_VALUE_ACCEPT;
-private:
-  bool martificial;
-};
-
-class
-jit_phi : public jit_assign_base
-{
-public:
-  jit_phi (jit_variable *adest, size_t npred)
-    : jit_assign_base (adest, npred)
-  {
-    mincomming.reserve (npred);
-  }
-
-  // removes arguments form dead incomming jumps
-  bool prune (void);
-
-  void add_incomming (jit_block *from, jit_value *value)
-  {
-    push_argument (value);
-    mincomming.push_back (jit_phi_incomming (this));
-    mincomming[mincomming.size () - 1].stash_value (from);
-  }
-
-  jit_block * incomming (size_t i) const
-  {
-    return mincomming[i].value ();
-  }
-
-  llvm::BasicBlock * incomming_llvm (size_t i) const
-  {
-    return incomming (i)->to_llvm ();
-  }
-
-  virtual void construct_ssa (void) { }
-
-  virtual bool infer (void);
-
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
-  {
-    std::stringstream ss;
-    print_indent (ss, indent);
-    short_print (ss) << " phi ";
-    std::string ss_str = ss.str ();
-    std::string indent_str (ss_str.size (), ' ');
-    os << ss_str;
-
-    for (size_t i = 0; i < argument_count (); ++i)
-      {
-        if (i > 0)
-          os << indent_str;
-        os << "| ";
-
-        os << *incomming (i) << " -> ";
-        os << *argument (i);
-
-        if (i + 1 < argument_count ())
-          os << std::endl;
-      }
-
-    return os;
-  }
-
-  llvm::PHINode * to_llvm (void) const;
-
-  JIT_VALUE_ACCEPT;
-private:
-  std::vector<jit_phi_incomming> mincomming;
-};
-
-class
-jit_terminator : public jit_instruction
-{
-public:
-
-  template <typename ...Args>
-  jit_terminator (size_t asuccessor_count, Args... args)
-    : jit_instruction (args...),
-      malive (asuccessor_count, false) { }
-
-  jit_block * successor (size_t idx = 0) const
-  {
-    return static_cast<jit_block *> (argument (idx));
-  }
-
-  llvm::BasicBlock * successor_llvm (size_t idx = 0) const
-  {
-    return successor (idx)->to_llvm ();
-  }
-
-  size_t successor_index (const jit_block *asuccessor) const;
-
-  std::ostream& print_successor (std::ostream& os, size_t idx = 0) const
+  // FIXME: This is just ugly...
+  // checks error_state, if error_state is false then goto the normal branch,
+  // otherwise goto the error branch
+  class
+  jit_error_check : public jit_terminator
   {
-    if (alive (idx))
-      os << "[live] ";
-    else
-      os << "[dead] ";
-
-    return successor (idx)->short_print (os);
-  }
-
-  // Check if the jump to successor is live
-  bool alive (const jit_block *asuccessor) const
-  {
-    return alive (successor_index (asuccessor));
-  }
-
-  bool alive (size_t idx) const { return malive[idx]; }
-
-  bool alive (int idx) const { return malive[idx]; }
-
-  size_t successor_count (void) const { return malive.size (); }
-
-  virtual bool infer (void);
-
-  llvm::TerminatorInst * to_llvm (void) const;
-protected:
-  virtual bool check_alive (size_t) const { return true; }
-private:
-  std::vector<bool> malive;
-};
-
-class
-jit_branch : public jit_terminator
-{
-public:
-  jit_branch (jit_block *succ) : jit_terminator (1, succ) { }
-
-  virtual size_t successor_count (void) const { return 1; }
+  public:
+    // Which variable is the error check for?
+    enum variable
+      {
+        var_error_state,
+        var_interrupt
+      };
 
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
-  {
-    print_indent (os, indent) << "branch: ";
-    return print_successor (os);
-  }
-
-  JIT_VALUE_ACCEPT;
-};
-
-class
-jit_cond_branch : public jit_terminator
-{
-public:
-  jit_cond_branch (jit_value *c, jit_block *ctrue, jit_block *cfalse)
-    : jit_terminator (2, ctrue, cfalse, c) { }
-
-  jit_value * cond (void) const { return argument (2); }
+    static std::string variable_to_string (variable v);
 
-  std::ostream& print_cond (std::ostream& os) const
-  {
-    return cond ()->short_print (os);
-  }
-
-  llvm::Value * cond_llvm (void) const
-  {
-    return cond ()->to_llvm ();
-  }
+    jit_error_check (variable var, jit_call *acheck_for, jit_block *normal,
+                     jit_block *error)
+      : jit_terminator (2, error, normal, acheck_for), mvariable (var) { }
 
-  virtual size_t successor_count (void) const { return 2; }
+    jit_error_check (variable var, jit_block *normal, jit_block *error)
+      : jit_terminator (2, error, normal), mvariable (var) { }
 
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
-  {
-    print_indent (os, indent) << "cond_branch: ";
-    print_cond (os) << ", ";
-    print_successor (os, 0) << ", ";
-    return print_successor (os, 1);
-  }
-
-  JIT_VALUE_ACCEPT;
-};
+    variable check_variable (void) const { return mvariable; }
 
-class
-jit_call : public jit_instruction
-{
-public:
-  jit_call (const jit_operation& (*aoperation) (void))
-    : moperation (aoperation ())
-  {
-    const jit_function& ol = overload ();
-    if (ol.valid ())
-      stash_type (ol.result ());
-  }
-
-  jit_call (const jit_operation& aoperation) : moperation (aoperation)
-  {
-    const jit_function& ol = overload ();
-    if (ol.valid ())
-      stash_type (ol.result ());
-  }
+    bool has_check_for (void) const
+    {
+      return argument_count () == 3;
+    }
 
-  template <typename ...Args>
-  jit_call (const jit_operation& aoperation,
-            jit_value * arg1, Args... other_args)
-    : jit_instruction (arg1, other_args...), moperation (aoperation)
-  { }
-
-  template <typename ...Args>
-  jit_call (const jit_operation& (*aoperation) (void),
-            jit_value * arg1, Args... other_args)
-    : jit_instruction (arg1, other_args...), moperation (aoperation ())
-  { }
-
-  jit_call (const jit_operation& aoperation,
-            const std::vector<jit_value *>& args)
-    : jit_instruction (args), moperation (aoperation)
-  { }
-
-  const jit_operation& operation (void) const { return moperation; }
-
-  bool can_error (void) const
-  {
-    return overload ().can_error ();
-  }
+    jit_call * check_for (void) const
+    {
+      assert (has_check_for ());
+      return static_cast<jit_call *> (argument (2));
+    }
 
-  const jit_function& overload (void) const
-  {
-    return moperation.overload (argument_types ());
-  }
-
-  virtual bool needs_release (void) const;
-
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
-  {
-    print_indent (os, indent);
-
-    if (use_count ())
-      short_print (os) << " = ";
-    os << "call " << moperation.name () << " (";
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const;
 
-    for (size_t i = 0; i < argument_count (); ++i)
-      {
-        print_argument (os, i);
-        if (i + 1 < argument_count ())
-          os << ", ";
-      }
-    return os << ')';
-  }
-
-  virtual bool infer (void);
-
-  JIT_VALUE_ACCEPT;
-private:
-  const jit_operation& moperation;
-};
-
-// FIXME: This is just ugly...
-// checks error_state, if error_state is false then goto the normal branch,
-// otherwise goto the error branch
-class
-jit_error_check : public jit_terminator
-{
-public:
-  // Which variable is the error check for?
-  enum variable
-  {
-    var_error_state,
-    var_interrupt
+    JIT_VALUE_ACCEPT;
+  protected:
+    virtual bool check_alive (size_t idx) const
+    {
+      if (! has_check_for ())
+        return true;
+      return idx == 1 ? true : check_for ()->can_error ();
+    }
+  private:
+    variable mvariable;
   };
 
-  static std::string variable_to_string (variable v);
-
-  jit_error_check (variable var, jit_call *acheck_for, jit_block *normal,
-                   jit_block *error)
-    : jit_terminator (2, error, normal, acheck_for), mvariable (var) { }
-
-  jit_error_check (variable var, jit_block *normal, jit_block *error)
-    : jit_terminator (2, error, normal), mvariable (var) { }
-
-  variable check_variable (void) const { return mvariable; }
-
-  bool has_check_for (void) const
-  {
-    return argument_count () == 3;
-  }
-
-  jit_call * check_for (void) const
-  {
-    assert (has_check_for ());
-    return static_cast<jit_call *> (argument (2));
-  }
-
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const;
-
-  JIT_VALUE_ACCEPT;
-protected:
-  virtual bool check_alive (size_t idx) const
-  {
-    if (! has_check_for ())
-      return true;
-    return idx == 1 ? true : check_for ()->can_error ();
-  }
-private:
-  variable mvariable;
-};
-
-// for now only handles the 1D case
-class
-jit_magic_end : public jit_instruction
-{
-public:
+  // for now only handles the 1D case
   class
-  context
+  jit_magic_end : public jit_instruction
   {
   public:
-    context (void) : value (0), index (0), count (0)
-    { }
+    class
+    context
+    {
+    public:
+      context (void) : value (0), index (0), count (0)
+      { }
+
+      context (jit_factory& factory, jit_value *avalue, size_t aindex,
+               size_t acount);
+
+      jit_value *value;
+      jit_const_index *index;
+      jit_const_index *count;
+    };
+
+    jit_magic_end (const std::vector<context>& full_context);
+
+    virtual bool infer (void);
+
+    const jit_function& overload () const;
+
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const;
+
+    context resolve_context (void) const;
+
+    virtual std::ostream& short_print (std::ostream& os) const
+    {
+      return os << "magic_end" << '#' << id ();
+    }
 
-    context (jit_factory& factory, jit_value *avalue, size_t aindex,
-             size_t acount);
+    JIT_VALUE_ACCEPT;
+  private:
+    std::vector<context> contexts;
+  };
+
+  class
+  jit_extract_argument : public jit_assign_base
+  {
+  public:
+    jit_extract_argument (jit_type *atype, jit_variable *adest)
+      : jit_assign_base (adest)
+    {
+      stash_type (atype);
+    }
 
-    jit_value *value;
-    jit_const_index *index;
-    jit_const_index *count;
+    const std::string& name (void) const
+    {
+      return dest ()->name ();
+    }
+
+    const jit_function& overload (void) const
+    {
+      return jit_typeinfo::cast (type (), jit_typeinfo::get_any ());
+    }
+
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
+    {
+      print_indent (os, indent);
+
+      return short_print (os) << " = extract " << name ();
+    }
+
+    JIT_VALUE_ACCEPT;
   };
 
-  jit_magic_end (const std::vector<context>& full_context);
-
-  virtual bool infer (void);
-
-  const jit_function& overload () const;
-
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const;
-
-  context resolve_context (void) const;
-
-  virtual std::ostream& short_print (std::ostream& os) const
-  {
-    return os << "magic_end" << '#' << id ();
-  }
-
-  JIT_VALUE_ACCEPT;
-private:
-  std::vector<context> contexts;
-};
-
-class
-jit_extract_argument : public jit_assign_base
-{
-public:
-  jit_extract_argument (jit_type *atype, jit_variable *adest)
-    : jit_assign_base (adest)
-  {
-    stash_type (atype);
-  }
-
-  const std::string& name (void) const
-  {
-    return dest ()->name ();
-  }
-
-  const jit_function& overload (void) const
-  {
-    return jit_typeinfo::cast (type (), jit_typeinfo::get_any ());
-  }
-
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
-  {
-    print_indent (os, indent);
-
-    return short_print (os) << " = extract " << name ();
-  }
-
-  JIT_VALUE_ACCEPT;
-};
-
-class
-jit_store_argument : public jit_instruction
-{
-public:
-  jit_store_argument (jit_variable *var)
-    : jit_instruction (var), dest (var)
-  { }
-
-  const std::string& name (void) const
-  {
-    return dest->name ();
-  }
-
-  const jit_function& overload (void) const
-  {
-    return jit_typeinfo::cast (jit_typeinfo::get_any (), result_type ());
-  }
-
-  jit_value * result (void) const
+  class
+  jit_store_argument : public jit_instruction
   {
-    return argument (0);
-  }
+  public:
+    jit_store_argument (jit_variable *var)
+      : jit_instruction (var), dest (var)
+    { }
+
+    const std::string& name (void) const
+    {
+      return dest->name ();
+    }
 
-  jit_type * result_type (void) const
-  {
-    return result ()->type ();
-  }
+    const jit_function& overload (void) const
+    {
+      return jit_typeinfo::cast (jit_typeinfo::get_any (), result_type ());
+    }
 
-  llvm::Value * result_llvm (void) const
-  {
-    return result ()->to_llvm ();
-  }
+    jit_value * result (void) const
+    {
+      return argument (0);
+    }
 
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
-  {
-    jit_value *res = result ();
-    print_indent (os, indent) << "store ";
-    dest->short_print (os);
+    jit_type * result_type (void) const
+    {
+      return result ()->type ();
+    }
+
+    llvm::Value * result_llvm (void) const
+    {
+      return result ()->to_llvm ();
+    }
 
-    if (! isa<jit_variable> (res))
-      {
-        os << " = ";
-        res->short_print (os);
-      }
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
+    {
+      jit_value *res = result ();
+      print_indent (os, indent) << "store ";
+      dest->short_print (os);
 
-    return os;
-  }
-
-  JIT_VALUE_ACCEPT;
-private:
-  jit_variable *dest;
-};
+      if (! isa<jit_variable> (res))
+        {
+          os << " = ";
+          res->short_print (os);
+        }
 
-class
-jit_return : public jit_instruction
-{
-public:
-  jit_return (void) { }
+      return os;
+    }
 
-  jit_return (jit_value *retval) : jit_instruction (retval) { }
+    JIT_VALUE_ACCEPT;
+  private:
+    jit_variable *dest;
+  };
 
-  jit_value * result (void) const
+  class
+  jit_return : public jit_instruction
   {
-    return argument_count () ? argument (0) : nullptr;
-  }
+  public:
+    jit_return (void) { }
 
-  jit_type * result_type (void) const
-  {
-    jit_value *res = result ();
-    return res ? res->type () : nullptr;
-  }
+    jit_return (jit_value *retval) : jit_instruction (retval) { }
+
+    jit_value * result (void) const
+    {
+      return argument_count () ? argument (0) : nullptr;
+    }
 
-  virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
-  {
-    print_indent (os, indent) << "return";
+    jit_type * result_type (void) const
+    {
+      jit_value *res = result ();
+      return res ? res->type () : nullptr;
+    }
 
-    if (result ())
-      os << ' ' << *result ();
+    virtual std::ostream& print (std::ostream& os, size_t indent = 0) const
+    {
+      print_indent (os, indent) << "return";
 
-    return os;
-  }
+      if (result ())
+        os << ' ' << *result ();
 
-  JIT_VALUE_ACCEPT;
-};
+      return os;
+    }
 
-class
-jit_ir_walker
-{
-public:
-  virtual ~jit_ir_walker () { }
+    JIT_VALUE_ACCEPT;
+  };
+
+  class
+  jit_ir_walker
+  {
+  public:
+    virtual ~jit_ir_walker () { }
 
 #define JIT_METH(clname)                        \
-  virtual void visit (jit_ ## clname&) = 0;
+    virtual void visit (jit_ ## clname&) = 0;
 
-  JIT_VISIT_IR_CLASSES;
+    JIT_VISIT_IR_CLASSES;
 
 #undef JIT_METH
-};
+  };
 
-template <typename T, jit_type *(*EXTRACT_T)(void), typename PASS_T, bool QUOTE>
-void
-jit_const<T, EXTRACT_T, PASS_T, QUOTE>::accept (jit_ir_walker& walker)
-{
-  walker.visit (*this);
-}
+  template <typename T, jit_type *(*EXTRACT_T)(void), typename PASS_T, bool QUOTE>
+  void
+  jit_const<T, EXTRACT_T, PASS_T, QUOTE>::accept (jit_ir_walker& walker)
+  {
+    walker.visit (*this);
+  }
 
 #undef JIT_VALUE_ACCEPT
 
+}
+
 #endif
 #endif