octave-nkf: src/pt-jit.cc comparison

comparison src/pt-jit.cc @ 14925:8697e3e9d77a

Properly cleanup the low level IR

author	Max Brister <max@2bass.com>
date	Tue, 29 May 2012 12:07:26 -0500
parents	d4d9a64db6aa
children	39d52aa37a08

comparison

equal deleted inserted replaced

-:d4d9a64db6aa
+:8697e3e9d77a
 {
 return muser->parent ();
 }
 // -------------------- jit_value --------------------
+jit_value::~jit_value (void)
+{
+while (use_head)
+{
+jit_instruction *user = use_head->user ();
+size_t idx = use_head->index ();
+user->stash_argument (idx, 0);
+}
+}
 #define JIT_METH(clname)                                \
 void                                                  \
 jit_ ## clname::accept (jit_ir_walker& walker)        \
 {                                                     \
 walker.visit (*this);                               \
 jit_terminator *term = terminator ();
 return term ? term->sucessor_count () : 0;
 }
 jit_phi *
-jit_block::search_phi (const std::string& tag_name, jit_value *adefault)
+jit_block::search_phi (const std::string& tag_name)
 {
-jit_phi *ret;
+jit_phi *ret = 0;
 for (iterator iter = begin (); iter != end ()
 && (ret = dynamic_cast<jit_phi *> (*iter)); ++iter)
 if (ret->tag () == tag_name)
 return ret;
-ret = new jit_phi (pred_count (), adefault);
+return 0;
-ret->stash_tag (tag_name);
-prepend (ret);
-return ret;
 }
 llvm::BasicBlock *
 jit_block::to_llvm (void) const
 {
 // -------------------- jit_convert --------------------
 jit_convert::jit_convert (llvm::Module *module, tree &tee)
 {
 jit_instruction::reset_ids ();
-jit_block *entry_block = new jit_block ("body");
+jit_block *entry_block = create<jit_block> ("body");
 block = entry_block;
 blocks.push_back (block);
-toplevel_map tlevel (block);
+toplevel_map tlevel (*this, block);
 variables = &tlevel;
-final_block = new jit_block ("final");
+final_block = create<jit_block> ("final");
 visit (tee);
 blocks.push_back (final_block);
-block->append (new jit_break (final_block));
+block->append (create<jit_break> (final_block));
 for (variable_map::iterator iter = variables->begin ();
 iter != variables->end (); ++iter)
-final_block->append (new jit_store_argument (iter->first, iter->second));
+final_block->append (create<jit_store_argument> (iter->first, iter->second));
 // FIXME: Maybe we should remove dead code here?
 // initialize the worklist to instructions derived from constants
 for (std::list<jit_value *>::iterator iter = constants.begin ();
 std::cout << std::endl;
 llvm::verifyFunction (*function);
 }
 }
+jit_convert::~jit_convert (void)
+{
+for (std::list<jit_value *>::iterator iter = all_values.begin ();
+iter != all_values.end (); ++iter)
+delete *iter;
+}
 void
 jit_convert::visit_anon_fcn_handle (tree_anon_fcn_handle&)
 {
 fail ();
 }
 tree_expression *rhs = be.rhs ();
 jit_value *rhsv = visit (rhs);
 const jit_function& fn = jit_typeinfo::binary_op (be.op_type ());
-result = block->append (new jit_call (fn, lhsv, rhsv));
+result = block->append (create<jit_call> (fn, lhsv, rhsv));
 }
 void
 jit_convert::visit_break_command (tree_break_command&)
 {
 tree_identifier *lhs = dynamic_cast<tree_identifier *>(cmd.left_hand_side ());
 if (! lhs)
 fail ();
 std::string lhs_name = lhs->name ();
-jit_block *body = new jit_block ("for_body");
+jit_block *body = create<jit_block> ("for_body");
 blocks.push_back (body);
-jit_block *tail = new jit_block ("for_tail");
+jit_block *tail = create<jit_block> ("for_tail");
-unwind_protect prot_tail;
-prot_tail.add_delete (tail); // incase we fail before adding tail to blocks
 // do control expression, iter init, and condition check in prev_block (block)
 jit_value *control = visit (cmd.control_expr ());
-jit_call *init_iter = new jit_call (jit_typeinfo::for_init, control);
+jit_call *init_iter = create<jit_call> (jit_typeinfo::for_init, control);
 init_iter->stash_tag ("#iter");
 block->append (init_iter);
-jit_value *check = block->append (new jit_call (jit_typeinfo::for_check,
+jit_value *check = block->append (create<jit_call> (jit_typeinfo::for_check,
 control, init_iter));
-block->append (new jit_cond_break (check, body, tail));
+block->append (create<jit_cond_break> (check, body, tail));
 // we need to do iter phi manually, for_map handles the rest
-jit_phi *iter_phi = new jit_phi (2);
+jit_phi *iter_phi = create<jit_phi> (2);
 iter_phi->stash_tag ("#iter");
 iter_phi->stash_argument (0, init_iter);
 body->append (iter_phi);
 variable_map *merge_vars = variables;
 for_map body_vars (variables, body);
 variables = &body_vars;
 block = body;
 // first thing we do in the for loop is bind our index from our itertor
-jit_call *idx_rhs = new jit_call (jit_typeinfo::for_index, control, iter_phi);
+jit_call *idx_rhs = create<jit_call> (jit_typeinfo::for_index, control, iter_phi);
 block->append (idx_rhs);
 idx_rhs->stash_tag (lhs_name);
 do_assign (lhs_name, idx_rhs, false);
 tree_statement_list *pt_body = cmd.body ();
 pt_body->accept (*this);
 // increment iterator, check conditional, and repeat
 const jit_function& add_fn = jit_typeinfo::binary_op (octave_value::op_add);
-jit_call *iter_inc = new jit_call (add_fn, iter_phi,
+jit_call *iter_inc = create<jit_call> (add_fn, iter_phi,
-get_const<jit_const_index> (1));
+create<jit_const_index> (1));
 iter_inc->stash_tag ("#iter");
 block->append (iter_inc);
-check = block->append (new jit_call (jit_typeinfo::for_check, control,
+check = block->append (create<jit_call> (jit_typeinfo::for_check, control,
 iter_inc));
-block->append (new jit_cond_break (check, body, tail));
+block->append (create<jit_cond_break> (check, body, tail));
 iter_phi->stash_argument (1, iter_inc);
 body_vars.finish_phi (*variables);
 merge (tail, *merge_vars, block, body_vars);
 blocks.push_back (tail);
-prot_tail.discard ();
 block = tail;
 variables = merge_vars;
-iter_phi = new jit_phi (2);
+iter_phi = create<jit_phi> (2);
 iter_phi->stash_tag ("#iter");
 iter_phi->stash_argument (0, init_iter);
 iter_phi->stash_argument (1, iter_inc);
 block->append (iter_phi);
-block->append (new jit_call (jit_typeinfo::release, iter_phi));
+block->append (create<jit_call> (jit_typeinfo::release, iter_phi));
 }
 void
 jit_convert::visit_complex_for_command (tree_complex_for_command&)
 {
 void
 jit_convert::visit_identifier (tree_identifier& ti)
 {
 const jit_function& fn = jit_typeinfo::grab ();
 jit_value *var = variables->get (ti.name ());
-result = block->append (new jit_call (fn, var));
+result = block->append (create<jit_call> (fn, var));
 }
 void
 jit_convert::visit_if_clause (tree_if_clause&)
 {
 ++iter;
 for (size_t i = 1; iter != lst.end (); ++iter, ++i)
 {
 tree_if_clause *tic = *iter;
 if (tic->is_else_clause ())
-entry_blocks[i] = new jit_block ("else");
+entry_blocks[i] = create<jit_block> ("else");
 else
-entry_blocks[i] = new jit_block ("ifelse_cond");
+entry_blocks[i] = create<jit_block> ("ifelse_cond");
-cleanup_blocks.push_back (entry_blocks[i]);
+}
-}
+jit_block *tail = create<jit_block> ("if_tail");
-jit_block *tail = new jit_block ("if_tail");
 if (! last_else)
 entry_blocks[entry_blocks.size () - 1] = tail;
 // actually fill out the contents of our blocks. We store the variable maps
 // at the end of each branch, this allows us to merge them in the tail
 if (! tic->is_else_clause ())
 {
 tree_expression *expr = tic->condition ();
 jit_value *cond = visit (expr);
-jit_block *body = new jit_block (i == 0 ? "if_body" : "ifelse_body");
+jit_block *body = create<jit_block> (i == 0 ? "if_body" : "ifelse_body");
 blocks.push_back (body);
-jit_instruction *br = new jit_cond_break (cond, body,
+jit_instruction *br = create<jit_cond_break> (cond, body,
 entry_blocks[i + 1]);
 block->append (br);
 block = body;
 variables = new compound_map (variables);
 branch_variables[i] = variables;
 assert (stmt_lst); // jwe: Can this be null?
 stmt_lst->accept (*this);
 branch_variables[i] = variables;
 branch_blocks[i] = block;
-block->append (new jit_break (tail));
+block->append (create<jit_break> (tail));
 }
 blocks.push_back (tail);
 // We create phi nodes in the tail to merge blocks
 {
 octave_value v = tc.rvalue1 ();
 if (v.is_real_scalar () && v.is_double_type ())
 {
 double dv = v.double_value ();
-result = get_const<jit_const_scalar> (dv);
+result = create<jit_const_scalar> (dv);
 }
 else if (v.is_range ())
 {
 Range rv = v.range_value ();
-result = get_const<jit_const_range> (rv);
+result = create<jit_const_range> (rv);
 }
 else
 fail ();
 }
 else if (expr->is_identifier () && expr->print_result ())
 {
 // FIXME: ugly hack, we need to come up with a way to pass
 // nargout to visit_identifier
 const jit_function& fn = jit_typeinfo::print_value ();
-jit_const_string *name = get_const<jit_const_string> (expr->name ());
+jit_const_string *name = create<jit_const_string> (expr->name ());
-block->append (new jit_call (fn, name, expr_result));
+block->append (create<jit_call> (fn, name, expr_result));
 }
 }
 }
 void
 void
 jit_convert::do_assign (const std::string& lhs, jit_value *rhs, bool print)
 {
 const jit_function& release = jit_typeinfo::release ();
 jit_value *current = variables->get (lhs);
-block->append (new jit_call (release, current));
+block->append (create<jit_call> (release, current));
 variables->set (lhs, rhs);
 if (print)
 {
 const jit_function& print_fn = jit_typeinfo::print_value ();
-jit_const_string *name = get_const<jit_const_string> (lhs);
+jit_const_string *name = create<jit_const_string> (lhs);
-block->append (new jit_call (print_fn, name, rhs));
+block->append (create<jit_call> (print_fn, name, rhs));
 }
 }
 jit_value *
 jit_convert::visit (tree& tee)
 void
 jit_convert::merge (jit_block *merge_block, variable_map& merge_vars,
 jit_block *incomming_block,
 const variable_map& incomming_vars)
 {
+size_t pred_count = merge_block->pred_count ();
 size_t merge_idx = merge_block->pred_index (incomming_block);
 for (variable_map::const_iterator iter = incomming_vars.begin ();
 iter != incomming_vars.end (); ++iter)
 {
 const std::string& vname = iter->first;
 if (merge_val != inc_val)
 {
 jit_phi *phi = dynamic_cast<jit_phi *> (merge_val);
 if (! (phi && phi->parent () == merge_block))
 {
-phi = merge_block->search_phi (vname, merge_val);
+phi = merge_block->search_phi (vname);
+if (! phi)
+{
+phi = create<jit_phi> (pred_count, merge_val);
+merge_block->prepend (phi);
+}
 merge_vars.set (vname, phi);
 }
 phi->stash_argument (merge_idx, inc_val);
 }
 assert (pval == 0); // we have no parent
 jit_block *entry = block ();
 octave_value val = symbol_table::find (name);
 jit_type *type = jit_typeinfo::type_of (val);
-jit_instruction *ret = new jit_extract_argument (type, name);
+jit_instruction *ret = convert.create<jit_extract_argument> (type, name);
 return vars[name] = entry->prepend (ret);
 }
 // -------------------- jit_convert::convert_llvm --------------------
 llvm::Function *

Mercurial > octave-nkf

comparison src/pt-jit.cc @ 14925:8697e3e9d77a