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

comparison src/pt-jit.cc @ 14944:c0a5ab3b9278

jit_const no longer inherits from jit_instruction

author	Max Brister <max@2bass.com>
date	Fri, 08 Jun 2012 15:30:07 -0500
parents	8efcaf5aa233
children	591aeec5c520

comparison

equal deleted inserted replaced

-:8efcaf5aa233
+:c0a5ab3b9278
 iter != entry_block->end (); ++iter)
 if (jit_extract_argument *extract = dynamic_cast<jit_extract_argument *> (*iter))
 arguments.push_back (std::make_pair (extract->name (), true));
 convert_llvm to_llvm;
-function = to_llvm.convert (module, arguments, blocks);
+function = to_llvm.convert (module, arguments, blocks, constants);
 #ifdef OCTAVE_JIT_DEBUG
 std::cout << "-------------------- llvm ir --------------------";
 llvm::raw_os_ostream llvm_cout (std::cout);
 function->print (llvm_cout);
 void
 jit_convert::visit_colon_expression (tree_colon_expression& expr)
 {
 // in the futher we need to add support for classes and deal with rvalues
-jit_instruction *base = visit (expr.base ());
+jit_value *base = visit (expr.base ());
-jit_instruction *limit = visit (expr.limit ());
+jit_value *limit = visit (expr.limit ());
-jit_instruction *increment;
+jit_value *increment;
 tree_expression *tinc = expr.increment ();
 if (tinc)
 increment = visit (tinc);
 else
-{
+increment = create<jit_const_scalar> (1);
-increment = create<jit_const_scalar> (1);
-block->append (increment);
-}
 result = block->append (create<jit_call> (jit_typeinfo::make_range, base,
 limit, increment));
 }
 block->append (create<jit_break> (check_block));
 finish_breaks (check_block, continues);
 block = check_block;
 const jit_function& add_fn = jit_typeinfo::binary_op (octave_value::op_add);
-jit_instruction *one = create<jit_const_index> (1);
+jit_value *one = create<jit_const_index> (1);
-block->append (one);
 jit_call *iter_inc = create<jit_call> (add_fn, iterator, one);
 block->append (iter_inc);
 block->append (create<jit_assign> (iterator, iter_inc));
 check = block->append (create<jit_call> (jit_typeinfo::for_check, control,
 iterator));
 blocks.push_back (entry_blocks[i]);
 if (! tic->is_else_clause ())
 {
 tree_expression *expr = tic->condition ();
-jit_instruction *cond = visit (expr);
+jit_value *cond = visit (expr);
-cond = create<jit_call> (&jit_typeinfo::logically_true, cond);
+jit_instruction *check = create<jit_call> (&jit_typeinfo::logically_true, cond);
-block->append (cond);
+block->append (check);
 jit_block *next = create<jit_block> (block->name () + "a");
 blocks.push_back (next);
 block->append (create<jit_check_error> (next, final_block));
 block = next;
 jit_block *body = create<jit_block> (i == 0 ? "if_body" : "ifelse_body");
 blocks.push_back (body);
-jit_instruction *br = create<jit_cond_break> (cond, body,
+jit_instruction *br = create<jit_cond_break> (check, body,
 entry_blocks[i + 1]);
 block->append (br);
 block = body;
 }
 Range rv = v.range_value ();
 result = create<jit_const_range> (rv);
 }
 else
 fail ("Unknown constant");
-block->append (result);
 }
 void
 jit_convert::visit_fcn_handle (tree_fcn_handle&)
 {
 void
 jit_convert::visit_simple_assignment (tree_simple_assignment& tsa)
 {
 // resolve rhs
 tree_expression *rhs = tsa.right_hand_side ();
-jit_instruction *rhsv = visit (rhs);
+jit_value *rhsv = visit (rhs);
 // resolve lhs
 tree_expression *lhs = tsa.left_hand_side ();
 if (! lhs->is_identifier ())
 fail ();
 do_bind_ans = (! id->is_variable ());
 }
 else
 do_bind_ans = (! expr->is_assignment_expression ());
-jit_instruction *expr_result = visit (expr);
+jit_value *expr_result = visit (expr);
 if (do_bind_ans)
 do_assign ("ans", expr_result, expr->print_result ());
 else if (expr->is_identifier () && expr->print_result ())
 {
 entry_block->prepend (extract);
 return vmap[vname] = var;
 }
-jit_instruction *
+jit_value *
-jit_convert::do_assign (const std::string& lhs, jit_instruction *rhs,
+jit_convert::do_assign (const std::string& lhs, jit_value *rhs,
 bool print)
 {
 jit_variable *var = get_variable (lhs);
 block->append (create<jit_assign> (var, rhs));
 const jit_function& print_fn = jit_typeinfo::print_value ();
 jit_const_string *name = create<jit_const_string> (lhs);
 block->append (create<jit_call> (print_fn, name, var));
 }
-return rhs;
+return var;
 }
-jit_instruction *
+jit_value *
 jit_convert::visit (tree& tee)
 {
 result = 0;
 tee.accept (*this);
-jit_instruction *ret = result;
+jit_value *ret = result;
 result = 0;
 return ret;
 }
 void
 // -------------------- jit_convert::convert_llvm --------------------
 llvm::Function *
 jit_convert::convert_llvm::convert (llvm::Module *module,
 const std::vector<std::pair< std::string, bool> >& args,
-const std::list<jit_block *>& blocks)
+const std::list<jit_block *>& blocks,
+const std::list<jit_value *>& constants)
 {
 jit_type *any = jit_typeinfo::get_any ();
 // argument is an array of octave_base_value*, or octave_base_value**
 llvm::Type *arg_type = any->to_llvm (); // this is octave_base_value*
 jblock->stash_llvm (block);
 }
 jit_block *first = *blocks.begin ();
 builder.CreateBr (first->to_llvm ());
+// constants aren't in the IR, we visit those first
+for (std::list<jit_value *>::const_iterator iter = constants.begin ();
+iter != constants.end (); ++iter)
+if (! isa<jit_instruction> (*iter))
+visit (*iter);
 // convert all instructions
 for (biter = blocks.begin (); biter != blocks.end (); ++biter)
 visit (*biter);

Mercurial > hg > octave-lyh

comparison src/pt-jit.cc @ 14944:c0a5ab3b9278