Mercurial > octave
diff libinterp/parse-tree/jit-typeinfo.cc @ 24847:fa4e852dae1e
use m_ prefix consistently in jit compiler classes in the parser
* jit-ir.cc, jit-ir.h, jit-typeinfo.cc, jit-typeinfo.h, jit-util.cc,
jit-util.h, pt-jit.cc: Use m_ prefix consistently in jit compiler
classes in the parser. Style fixes.
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Wed, 07 Mar 2018 16:42:08 -0500 |
| parents | 194eb4bd202b |
| children | 6652d3823428 |
line wrap: on
line diff
--- a/libinterp/parse-tree/jit-typeinfo.cc Wed Mar 07 14:56:03 2018 -0500 +++ b/libinterp/parse-tree/jit-typeinfo.cc Wed Mar 07 16:42:08 2018 -0500 @@ -128,7 +128,7 @@ extern "C" void octave_jit_release_matrix (jit_matrix *m) { - delete m->array; + delete m->m_array; } extern "C" octave_base_value * @@ -141,16 +141,16 @@ extern "C" jit_matrix octave_jit_grab_matrix (jit_matrix *m) { - return *m->array; + return *m->m_array; } extern "C" octave_base_value * octave_jit_cast_any_matrix (jit_matrix *m) { - octave_value ret (*m->array); + octave_value ret (*m->m_array); octave_base_value *rep = ret.internal_rep (); rep->grab (); - delete m->array; + delete m->m_array; return rep; } @@ -222,8 +222,9 @@ extern "C" void octave_jit_ginvalid_index (void) { - // FIXME: 0-argument form of octave::err_invalid_index removed in cset dd6345fd8a97 - // Report -1 as the bad index for all occurrences. + // FIXME: 0-argument form of octave::err_invalid_index removed in + // cset dd6345fd8a97. Report -1 as the bad index for all + // occurrences. octave::err_invalid_index (static_cast<octave_idx_type> (-1)); } @@ -238,7 +239,7 @@ octave_jit_paren_subsasgn_impl (jit_matrix *mat, octave_idx_type index, double value) { - NDArray *array = mat->array; + NDArray *array = mat->m_array; if (array->numel () < index) array->resize1 (index); @@ -266,7 +267,7 @@ Array<idx_vector> idx; make_indices (indicies, idx_count, idx); - Array<double> ret = mat->array->index (idx); + Array<double> ret = mat->m_array->index (idx); return ret.xelem (0); } @@ -283,8 +284,8 @@ Matrix temp (1, 1); temp.xelem(0) = value; - mat->array->assign (idx, temp); - ret.update (mat->array); + mat->m_array->assign (idx, temp); + ret.update (mat->m_array); return ret; } @@ -293,7 +294,7 @@ octave_jit_paren_subsasgn_matrix_range (jit_matrix *mat, jit_range *index, double value) { - NDArray *array = mat->array; + NDArray *array = mat->m_array; bool done = false; // optimize for the simple case (no resizing and no errors) @@ -302,9 +303,9 @@ { // this code is similar to idx_vector::fill, but we avoid allocating an // idx_vector and its associated rep - octave_idx_type start = static_cast<octave_idx_type> (index->base) - 1; - octave_idx_type step = static_cast<octave_idx_type> (index->inc); - octave_idx_type nelem = index->nelem; + octave_idx_type start = static_cast<octave_idx_type> (index->m_base) - 1; + octave_idx_type step = static_cast<octave_idx_type> (index->m_inc); + octave_idx_type nelem = index->m_nelem; octave_idx_type final = start + nelem * step; if (step < 0) { @@ -312,7 +313,7 @@ std::swap (final, start); } - if (start >= 0 && final < mat->slice_len) + if (start >= 0 && final < mat->m_slice_len) { done = true; @@ -344,23 +345,23 @@ octave_jit_end_matrix (jit_matrix *mat, octave_idx_type idx, octave_idx_type count) { - octave_idx_type ndim = mat->dimensions[-1]; + octave_idx_type ndim = mat->m_dimensions[-1]; if (ndim == count) - return mat->dimensions[idx]; + return mat->m_dimensions[idx]; else if (ndim > count) { if (idx == count - 1) { - double ret = mat->dimensions[idx]; + double ret = mat->m_dimensions[idx]; for (octave_idx_type i = idx + 1; i < ndim; ++i) - ret *= mat->dimensions[idx]; + ret *= mat->m_dimensions[idx]; return ret; } - return mat->dimensions[idx]; + return mat->m_dimensions[idx]; } else // ndim < count - return idx < ndim ? mat->dimensions[idx] : 1; + return idx < ndim ? mat->m_dimensions[idx] : 1; } extern "C" octave_base_value * @@ -489,8 +490,8 @@ std::ostream& operator<< (std::ostream& os, const jit_range& rng) { - return os << "Range[" << rng.base << ", " << rng.limit << ", " << rng.inc - << ", " << rng.nelem << ']'; + return os << "Range[" << rng.m_base << ", " << rng.m_limit + << ", " << rng.m_inc << ", " << rng.m_nelem << ']'; } @@ -499,9 +500,9 @@ std::ostream& operator<< (std::ostream& os, const jit_matrix& mat) { - return os << "Matrix[" << mat.ref_count << ", " << mat.slice_data << ", " - << mat.slice_len << ", " << mat.dimensions << ", " - << mat.array << ']'; + return os << "Matrix[" << mat.m_ref_count << ", " << mat.m_slice_data << ", " + << mat.m_slice_len << ", " << mat.m_dimensions << ", " + << mat.m_array << ']'; } @@ -509,22 +510,22 @@ jit_type::jit_type (const std::string& aname, jit_type *aparent, llvm::Type *allvm_type, bool askip_paren, int aid) : - mname (aname), mparent (aparent), llvm_type (allvm_type), mid (aid), - mdepth (aparent ? aparent->mdepth + 1 : 0), mskip_paren (askip_paren) + m_name (aname), m_parent (aparent), m_llvm_type (allvm_type), m_id (aid), + m_depth (aparent ? aparent->m_depth + 1 : 0), m_skip_paren (askip_paren) { - std::memset (msret, 0, sizeof (msret)); - std::memset (mpointer_arg, 0, sizeof (mpointer_arg)); - std::memset (mpack, 0, sizeof (mpack)); - std::memset (munpack, 0, sizeof (munpack)); + std::memset (m_sret, 0, sizeof (m_sret)); + std::memset (m_pointer_arg, 0, sizeof (m_pointer_arg)); + std::memset (m_pack, 0, sizeof (m_pack)); + std::memset (m_unpack, 0, sizeof (m_unpack)); for (size_t i = 0; i < jit_convention::length; ++i) - mpacked_type[i] = llvm_type; + m_packed_type[i] = m_llvm_type; } llvm::Type * jit_type::to_llvm_arg (void) const { - return llvm_type ? llvm_type->getPointerTo () : nullptr; + return m_llvm_type ? m_llvm_type->getPointerTo () : nullptr; } jit_type* @@ -561,23 +562,23 @@ // -------------------- jit_function -------------------- jit_function::jit_function () - : module (nullptr), llvm_function (nullptr), mresult (nullptr), - call_conv (jit_convention::length), mcan_error (false) + : m_module (nullptr), m_llvm_function (nullptr), m_result (nullptr), + m_call_conv (jit_convention::length), m_can_error (false) { } jit_function::jit_function (const jit_module *amodule, jit_convention::type acall_conv, const llvm::Twine& aname, jit_type *aresult, const std::vector<jit_type *>& aargs) - : module (amodule), mresult (aresult), args (aargs), call_conv (acall_conv), - mcan_error (false) + : m_module (amodule), m_result (aresult), m_args (aargs), m_call_conv (acall_conv), + m_can_error (false) { llvm::SmallVector<llvm::Type *, 15> llvm_args; llvm::Type *rtype = llvm::Type::getVoidTy (context); - if (mresult) + if (m_result) { - rtype = mresult->packed_type (call_conv); + rtype = m_result->packed_type (m_call_conv); if (sret ()) { llvm_args.push_back (rtype->getPointerTo ()); @@ -585,20 +586,20 @@ } } - for (std::vector<jit_type *>::const_iterator iter = args.begin (); - iter != args.end (); ++iter) + for (std::vector<jit_type *>::const_iterator iter = m_args.begin (); + iter != m_args.end (); ++iter) { jit_type *ty = *iter; assert (ty); - llvm::Type *argty = ty->packed_type (call_conv); - if (ty->pointer_arg (call_conv)) + llvm::Type *argty = ty->packed_type (m_call_conv); + if (ty->pointer_arg (m_call_conv)) argty = argty->getPointerTo (); llvm_args.push_back (argty); } llvm::FunctionType *ft = llvm::FunctionType::get (rtype, llvm_args, false); - llvm_function = module->create_llvm_function (ft, aname); + m_llvm_function = m_module->create_llvm_function (ft, aname); if (sret ()) { @@ -606,52 +607,52 @@ llvm::AttrBuilder attr_builder; attr_builder.addAttribute (llvm::Attributes::StructRet); llvm::Attributes attrs = llvm::Attributes::get(context, attr_builder); - llvm_function->addAttribute (1, attrs); + m_llvm_function->addAttribute (1, attrs); #else - llvm_function->addAttribute (1, llvm::Attribute::StructRet); + m_llvm_function->addAttribute (1, llvm::Attribute::StructRet); #endif } - if (call_conv == jit_convention::internal) + if (m_call_conv == jit_convention::internal) #if defined (FUNCTION_ADDFNATTR_ARG_IS_ATTRIBUTES) - llvm_function->addFnAttr (llvm::Attributes::AlwaysInline); + m_llvm_function->addFnAttr (llvm::Attributes::AlwaysInline); #else - llvm_function->addFnAttr (llvm::Attribute::AlwaysInline); + m_llvm_function->addFnAttr (llvm::Attribute::AlwaysInline); #endif } jit_function::jit_function (const jit_function& fn, jit_type *aresult, const std::vector<jit_type *>& aargs) - : module (fn.module), llvm_function (fn.llvm_function), mresult (aresult), - args (aargs), call_conv (fn.call_conv), mcan_error (fn.mcan_error) + : m_module (fn.m_module), m_llvm_function (fn.m_llvm_function), m_result (aresult), + m_args (aargs), m_call_conv (fn.m_call_conv), m_can_error (fn.m_can_error) { } jit_function::jit_function (const jit_function& fn) - : module (fn.module), llvm_function (fn.llvm_function), mresult (fn.mresult), - args (fn.args), call_conv (fn.call_conv), mcan_error (fn.mcan_error) + : m_module (fn.m_module), m_llvm_function (fn.m_llvm_function), m_result (fn.m_result), + m_args (fn.m_args), m_call_conv (fn.m_call_conv), m_can_error (fn.m_can_error) { } void jit_function::erase (void) { - if (! llvm_function) + if (! m_llvm_function) return; - llvm_function->eraseFromParent (); - llvm_function = 0; + m_llvm_function->eraseFromParent (); + m_llvm_function = 0; } std::string jit_function::name (void) const { - return llvm_function->getName (); + return m_llvm_function->getName (); } llvm::BasicBlock * jit_function::new_block (const std::string& aname, llvm::BasicBlock *insert_before) { - return llvm::BasicBlock::Create (context, aname, llvm_function, + return llvm::BasicBlock::Create (context, aname, m_llvm_function, insert_before); } @@ -662,8 +663,8 @@ if (! valid ()) throw jit_fail_exception ("Call not implemented"); - assert (in_args.size () == args.size ()); - std::vector<llvm::Value *> llvm_args (args.size ()); + assert (in_args.size () == m_args.size ()); + std::vector<llvm::Value *> llvm_args (m_args.size ()); for (size_t i = 0; i < in_args.size (); ++i) llvm_args[i] = in_args[i]->to_llvm (); @@ -677,7 +678,7 @@ if (! valid ()) throw jit_fail_exception ("Call not implemented"); - assert (in_args.size () == args.size ()); + assert (in_args.size () == m_args.size ()); llvm::SmallVector<llvm::Value *, 10> llvm_args; llvm_args.reserve (in_args.size () + sret ()); @@ -692,20 +693,20 @@ llvm::AllocaInst *sret_mem = nullptr; if (sret ()) { - sret_mem = pre_builder.CreateAlloca (mresult->packed_type (call_conv)); + sret_mem = pre_builder.CreateAlloca (m_result->packed_type (m_call_conv)); llvm_args.push_back (sret_mem); } for (size_t i = 0; i < in_args.size (); ++i) { llvm::Value *arg = in_args[i]; - jit_type::convert_fn convert = args[i]->pack (call_conv); + jit_type::convert_fn convert = m_args[i]->pack (m_call_conv); if (convert) arg = convert (builder, arg); - if (args[i]->pointer_arg (call_conv)) + if (m_args[i]->pointer_arg (m_call_conv)) { - llvm::Type *ty = args[i]->packed_type (call_conv); + llvm::Type *ty = m_args[i]->packed_type (m_call_conv); llvm::Value *alloca = pre_builder.CreateAlloca (ty); builder.CreateStore (arg, alloca); arg = alloca; @@ -714,7 +715,7 @@ llvm_args.push_back (arg); } - llvm::CallInst *callinst = builder.CreateCall (llvm_function, llvm_args); + llvm::CallInst *callinst = builder.CreateCall (m_llvm_function, llvm_args); llvm::Value *ret = callinst; if (sret ()) @@ -730,9 +731,9 @@ ret = builder.CreateLoad (sret_mem); } - if (mresult) + if (m_result) { - jit_type::convert_fn unpack = mresult->unpack (call_conv); + jit_type::convert_fn unpack = m_result->unpack (m_call_conv); if (unpack) ret = unpack (builder, ret); } @@ -743,18 +744,18 @@ llvm::Value * jit_function::argument (llvm::IRBuilderD& builder, size_t idx) const { - assert (idx < args.size ()); + assert (idx < m_args.size ()); // FIXME: We should be treating arguments like a list, not a vector. // Shouldn't matter much for now, as the number of arguments shouldn't // be much bigger than 4 - llvm::Function::arg_iterator iter = llvm_function->arg_begin (); + llvm::Function::arg_iterator iter = m_llvm_function->arg_begin (); if (sret ()) ++iter; for (size_t i = 0; i < idx; ++i, ++iter); - if (args[idx]->pointer_arg (call_conv)) + if (m_args[idx]->pointer_arg (m_call_conv)) return builder.CreateLoad (&*iter); return &*iter; @@ -764,17 +765,17 @@ jit_function::do_return (llvm::IRBuilderD& builder, llvm::Value *rval, bool verify) { - assert (! rval == ! mresult); + assert (! rval == ! m_result); if (rval) { - jit_type::convert_fn convert = mresult->pack (call_conv); + jit_type::convert_fn convert = m_result->pack (m_call_conv); if (convert) rval = convert (builder, rval); if (sret ()) { - builder.CreateStore (rval, &*(llvm_function->arg_begin ())); + builder.CreateStore (rval, &*(m_llvm_function->arg_begin ())); builder.CreateRetVoid (); } else @@ -784,14 +785,14 @@ builder.CreateRetVoid (); if (verify) - llvm::verifyFunction (*llvm_function); + llvm::verifyFunction (*m_llvm_function); } std::ostream& operator<< (std::ostream& os, const jit_function& fn) { llvm::Function *lfn = fn.to_llvm (); - os << "jit_function: cc=" << fn.call_conv; + os << "jit_function: cc=" << fn.m_call_conv; llvm::raw_os_ostream llvm_out (os); lfn->print (llvm_out); llvm_out.flush (); @@ -801,8 +802,8 @@ // -------------------- jit_operation -------------------- jit_operation::~jit_operation (void) { - for (generated_map::iterator iter = generated.begin (); - iter != generated.end (); ++iter) + for (generated_map::iterator iter = m_generated.begin (); + iter != m_generated.end (); ++iter) { delete iter->first; delete iter->second; @@ -816,10 +817,10 @@ // Number of input arguments of the overload that is being registered size_t nargs = args.size (); - if (nargs >= overloads.size ()) - overloads.resize (nargs + 1); + if (nargs >= m_overloads.size ()) + m_overloads.resize (nargs + 1); - Array<jit_function>& over = overloads[nargs]; + Array<jit_function>& over = m_overloads[nargs]; dim_vector dv (over.dims ()); Array<octave_idx_type> idx = to_idx (args); bool must_resize = false; @@ -854,10 +855,10 @@ if (! types[i]) return null_overload; - if (nargs >= overloads.size ()) + if (nargs >= m_overloads.size ()) return do_generate (types); - const Array<jit_function>& over = overloads[nargs]; + const Array<jit_function>& over = m_overloads[nargs]; dim_vector dv (over.dims ()); Array<octave_idx_type> idx = to_idx (types); for (octave_idx_type i = 0; i < dv.length (); ++i) @@ -897,8 +898,8 @@ jit_operation::do_generate (const signature_vec& types) const { static jit_function null_overload; - generated_map::const_iterator find = generated.find (&types); - if (find != generated.end ()) + generated_map::const_iterator find = m_generated.find (&types); + if (find != m_generated.end ()) { if (find->second) return *find->second; @@ -907,7 +908,7 @@ } jit_function *ret = generate (types); - generated[new signature_vec (types)] = ret; + m_generated[new signature_vec (types)] = ret; return ret ? *ret : null_overload; } @@ -982,19 +983,19 @@ jit_paren_subsref::jit_paren_subsref (const jit_typeinfo& ti) : jit_index_operation (ti, "()subsref"), - paren_scalar (nullptr) + m_paren_scalar (nullptr) { } - jit_paren_subsref::~jit_paren_subsref () + jit_paren_subsref::~jit_paren_subsref (void) { - delete paren_scalar; + delete m_paren_scalar; } jit_function * jit_paren_subsref::generate_matrix (const signature_vec& types) const { - if (paren_scalar == nullptr) + if (m_paren_scalar == nullptr) panic_impossible (); std::stringstream ss; @@ -1002,17 +1003,17 @@ // FIXME: Where will this be deleted? jit_function *fn = new jit_function - (typeinfo.create_internal (ss.str (), typeinfo.scalar, types)); + (m_typeinfo.create_internal (ss.str (), m_typeinfo.m_scalar, types)); fn->mark_can_error (); llvm::BasicBlock *body = fn->new_block (); llvm::IRBuilder<> builder (body); llvm::Value *array = create_arg_array (builder, *fn, 1, types.size ()); - llvm::Value *nelem = llvm::ConstantInt::get (typeinfo.index_t, + llvm::Value *nelem = llvm::ConstantInt::get (m_typeinfo.m_index_t, types.size () - 1); llvm::Value *mat = fn->argument (builder, 0); - llvm::Value *ret = paren_scalar->call (builder, mat, array, nelem); + llvm::Value *ret = m_paren_scalar->call (builder, mat, array, nelem); fn->do_return (builder, ret); return fn; } @@ -1021,35 +1022,34 @@ jit_paren_subsref::init_paren_scalar () { std::vector<jit_type *> types (3); - types[0] = typeinfo.matrix; - types[1] = typeinfo.scalar_ptr; - types[2] = typeinfo.index; + types[0] = m_typeinfo.m_matrix; + types[1] = m_typeinfo.m_scalar_ptr; + types[2] = m_typeinfo.m_index; - paren_scalar = new jit_function - (typeinfo.create_external (&octave_jit_paren_scalar, - "octave_jit_paren_scalar", - typeinfo.scalar, types)); + m_paren_scalar = new jit_function + (m_typeinfo.create_external (&octave_jit_paren_scalar, + "octave_jit_paren_scalar", + m_typeinfo.m_scalar, types)); - paren_scalar->mark_can_error (); + m_paren_scalar->mark_can_error (); } // -------------------- jit_paren_subsasgn -------------------- jit_paren_subsasgn::jit_paren_subsasgn (const jit_typeinfo& ti) : jit_index_operation (ti, "()subsasgn"), - paren_scalar (nullptr) - { - } + m_paren_scalar (nullptr) + { } - jit_paren_subsasgn::~jit_paren_subsasgn () + jit_paren_subsasgn::~jit_paren_subsasgn (void) { - delete paren_scalar; + delete m_paren_scalar; } jit_function * jit_paren_subsasgn::generate_matrix (const signature_vec& types) const { - if (paren_scalar == nullptr) + if (m_paren_scalar == nullptr) panic_impossible (); std::stringstream ss; @@ -1057,19 +1057,19 @@ // FIXME: Where will this be deleted? jit_function *fn = new jit_function - (typeinfo.create_internal (ss.str (), typeinfo.matrix, types)); + (m_typeinfo.create_internal (ss.str (), m_typeinfo.m_matrix, types)); fn->mark_can_error (); llvm::BasicBlock *body = fn->new_block (); llvm::IRBuilder<> builder (body); llvm::Value *array = create_arg_array (builder, *fn, 1, types.size () - 1); - llvm::Value *nelem = llvm::ConstantInt::get (typeinfo.index_t, + llvm::Value *nelem = llvm::ConstantInt::get (m_typeinfo.m_index_t, types.size () - 2); llvm::Value *mat = fn->argument (builder, 0); llvm::Value *value = fn->argument (builder, types.size () - 1); - llvm::Value *ret = paren_scalar->call (builder, mat, array, nelem, value); + llvm::Value *ret = m_paren_scalar->call (builder, mat, array, nelem, value); fn->do_return (builder, ret); return fn; @@ -1079,29 +1079,29 @@ jit_paren_subsasgn::init_paren_scalar () { std::vector<jit_type *> types (4); - types[0] = typeinfo.matrix; - types[1] = typeinfo.scalar_ptr; - types[2] = typeinfo.index; - types[3] = typeinfo.scalar; + types[0] = m_typeinfo.m_matrix; + types[1] = m_typeinfo.m_scalar_ptr; + types[2] = m_typeinfo.m_index; + types[3] = m_typeinfo.m_scalar; - paren_scalar = new jit_function - (typeinfo.create_external (&octave_jit_paren_scalar_subsasgn, - "octave_jit_paren_scalar", - typeinfo.matrix, types)); + m_paren_scalar = new jit_function + (m_typeinfo.create_external (&octave_jit_paren_scalar_subsasgn, + "octave_jit_paren_scalar", + m_typeinfo.m_matrix, types)); - paren_scalar->mark_can_error (); + m_paren_scalar->mark_can_error (); } // -------------------- jit_typeinfo -------------------- - bool jit_typeinfo::in_construction = false; + bool jit_typeinfo::s_in_construction = false; // Static method that holds the singleton instance jit_typeinfo& jit_typeinfo::instance (void) { - if (in_construction) + if (s_in_construction) // This state is typically reached when the constructor calls one // of the static methods of the singleton class... panic_impossible (); @@ -1110,42 +1110,42 @@ return typeinfo; } - jit_typeinfo::~jit_typeinfo () + jit_typeinfo::~jit_typeinfo (void) { - while (! id_to_type.empty ()) + while (! m_id_to_type.empty ()) { - delete id_to_type.back (); - id_to_type.pop_back (); + delete m_id_to_type.back (); + m_id_to_type.pop_back (); } - delete builder_ptr; - delete base_jit_module; + delete m_builder_ptr; + delete m_base_jit_module; } // wrap function names to simplify jit_typeinfo::create_external #define JIT_FN(fn) &fn, #fn - jit_typeinfo::jit_typeinfo () + jit_typeinfo::jit_typeinfo (void) : paren_subsref_fn (*this), paren_subsasgn_fn (*this), - next_id (0), - grab_fn ("grab"), - release_fn ("release"), - destroy_fn ("destroy"), - print_fn ("print"), - for_init_fn ("for_init"), - for_check_fn ("for_check"), - for_index_fn ("for_index"), - logically_true_fn ("logically_true"), - make_range_fn ("make_range"), - end1_fn ("end1"), - end_fn ("end"), - create_undef_fn ("create_undef"), - base_jit_module (new jit_module ("octaveJITBaseModule")), - builder_ptr (new llvm::IRBuilderD (context)), - builder (*builder_ptr) // FIXME: Use a pointer directly in the constructor, and get rid of this + m_next_id (0), + m_grab_fn ("grab"), + m_release_fn ("release"), + m_destroy_fn ("destroy"), + m_print_fn ("print"), + m_for_init_fn ("for_init"), + m_for_check_fn ("for_check"), + m_for_index_fn ("for_index"), + m_logically_true_fn ("logically_true"), + m_make_range_fn ("make_range"), + m_end1_fn ("end1"), + m_end_fn ("end"), + m_create_undef_fn ("create_undef"), + m_base_jit_module (new jit_module ("octaveJITBaseModule")), + m_builder_ptr (new llvm::IRBuilderD (context)), + m_builder (*m_builder_ptr) // FIXME: Use a pointer directly in the constructor, and get rid of this { - in_construction = true; + s_in_construction = true; // ----- Register basic JIT types ----- @@ -1154,113 +1154,113 @@ // jit_types: "any" < (nullptr) // "any_ptr" < (nullptr) - any_t = llvm::StructType::create (context, "octave_base_value"); - any_t = any_t->getPointerTo (); - any = do_register_new_type ("any", nullptr, any_t); - any_ptr = do_register_new_type ("any_ptr", nullptr, any_t->getPointerTo ()); + m_any_t = llvm::StructType::create (context, "octave_base_value"); + m_any_t = m_any_t->getPointerTo (); + m_any = do_register_new_type ("any", nullptr, m_any_t); + m_any_ptr = do_register_new_type ("any_ptr", nullptr, m_any_t->getPointerTo ()); // jit_types: "scalar" < "complex" < "any" // and: "scalar_ptr" < (nullptr) // FIXME: what about sing-precision floats ??? // FIXME: shouldn't we make scalar_ptr a sub_type of any_ptr ? - scalar_t = llvm::Type::getDoubleTy (context); - complex_t = llvm::ArrayType::get (scalar_t, 2); - complex = do_register_new_type ("complex", any, complex_t); - scalar = do_register_new_type ("scalar", complex, scalar_t); - scalar_ptr = do_register_new_type ("scalar_ptr", nullptr, scalar_t->getPointerTo ()); + m_scalar_t = llvm::Type::getDoubleTy (context); + m_complex_t = llvm::ArrayType::get (m_scalar_t, 2); + m_complex = do_register_new_type ("complex", m_any, m_complex_t); + m_scalar = do_register_new_type ("scalar", m_complex, m_scalar_t); + m_scalar_ptr = do_register_new_type ("scalar_ptr", nullptr, m_scalar_t->getPointerTo ()); // jit_type: "bool" < "any" - bool_t = llvm::Type::getInt1Ty (context); - boolean = do_register_new_type ("bool", any, bool_t); + m_bool_t = llvm::Type::getInt1Ty (context); + m_boolean = do_register_new_type ("bool", m_any, m_bool_t); // jit_types: "int8", "int16", "int32", "int64" < "any" - ints[ 8] = do_register_new_type ("int8", any, llvm::Type::getIntNTy (context, 8)); - ints[16] = do_register_new_type ("int16", any, llvm::Type::getIntNTy (context, 16)); - ints[32] = do_register_new_type ("int32", any, llvm::Type::getIntNTy (context, 32)); - ints[64] = do_register_new_type ("int64", any, llvm::Type::getIntNTy (context, 64)); + m_ints[ 8] = do_register_new_type ("int8", m_any, llvm::Type::getIntNTy (context, 8)); + m_ints[16] = do_register_new_type ("int16", m_any, llvm::Type::getIntNTy (context, 16)); + m_ints[32] = do_register_new_type ("int32", m_any, llvm::Type::getIntNTy (context, 32)); + m_ints[64] = do_register_new_type ("int64", m_any, llvm::Type::getIntNTy (context, 64)); // jit_type: "string" < "any" - string_t = llvm::Type::getInt8Ty (context); - string_t = string_t->getPointerTo (); - string = do_register_new_type ("string", any, string_t); + m_string_t = llvm::Type::getInt8Ty (context); + m_string_t = m_string_t->getPointerTo (); + m_string = do_register_new_type ("string", m_any, m_string_t); // jit_type: "index" < "any" - index_t = llvm::Type::getIntNTy (context, sizeof (octave_idx_type) * 8); - index = do_register_new_type ("index", any, index_t); + m_index_t = llvm::Type::getIntNTy (context, sizeof (octave_idx_type) * 8); + m_index = do_register_new_type ("index", m_any, m_index_t); // jit_type: "range" < "any" - range_t = llvm::StructType::create (context, "range"); + m_range_t = llvm::StructType::create (context, "range"); { - std::vector<llvm::Type *> range_contents (4, scalar_t); - range_contents[3] = index_t; - range_t->setBody (range_contents); + std::vector<llvm::Type *> range_contents (4, m_scalar_t); + range_contents[3] = m_index_t; + m_range_t->setBody (range_contents); } - range = do_register_new_type ("range", any, range_t); + m_range = do_register_new_type ("range", m_any, m_range_t); // jit_type: "matrix" < "any" - matrix_t = llvm::StructType::create (context, "matrix"); + m_matrix_t = llvm::StructType::create (context, "matrix"); { llvm::Type *refcount_t = llvm::Type::getIntNTy (context, sizeof(int) * 8); llvm::Type *matrix_contents[5]; matrix_contents[0] = refcount_t->getPointerTo (); - matrix_contents[1] = scalar_t->getPointerTo (); - matrix_contents[2] = index_t; - matrix_contents[3] = index_t->getPointerTo (); - matrix_contents[4] = string_t; - matrix_t->setBody (llvm::makeArrayRef (matrix_contents, 5)); + matrix_contents[1] = m_scalar_t->getPointerTo (); + matrix_contents[2] = m_index_t; + matrix_contents[3] = m_index_t->getPointerTo (); + matrix_contents[4] = m_string_t; + m_matrix_t->setBody (llvm::makeArrayRef (matrix_contents, 5)); } - matrix = do_register_new_type ("matrix", any, matrix_t); + m_matrix = do_register_new_type ("matrix", m_any, m_matrix_t); // ----- Specify calling conventions ----- // complex_ret is what is passed to C functions // in order to get calling convention right - complex_ret = llvm::StructType::create (context, "complex_ret"); + m_complex_ret = llvm::StructType::create (context, "complex_ret"); { - llvm::Type *cmplx_inner_cont[] = {scalar_t, scalar_t}; + llvm::Type *cmplx_inner_cont[] = {m_scalar_t, m_scalar_t}; llvm::StructType *cmplx_inner = llvm::StructType::create (cmplx_inner_cont); llvm::Type *contents[] = {cmplx_inner}; - complex_ret->setBody (contents); + m_complex_ret->setBody (contents); } // FIXME: We should detect architecture and do something sane // based on that here we assume x86 or x86_64 - matrix->mark_sret (jit_convention::external); - matrix->mark_pointer_arg (jit_convention::external); + m_matrix->mark_sret (jit_convention::external); + m_matrix->mark_pointer_arg (jit_convention::external); - range->mark_sret (jit_convention::external); - range->mark_pointer_arg (jit_convention::external); + m_range->mark_sret (jit_convention::external); + m_range->mark_pointer_arg (jit_convention::external); - complex->set_pack (jit_convention::external, &jit_typeinfo::pack_complex); - complex->set_unpack (jit_convention::external, &jit_typeinfo::unpack_complex); - complex->set_packed_type (jit_convention::external, complex_ret); + m_complex->set_pack (jit_convention::external, &jit_typeinfo::pack_complex); + m_complex->set_unpack (jit_convention::external, &jit_typeinfo::unpack_complex); + m_complex->set_packed_type (jit_convention::external, m_complex_ret); if (sizeof (void *) == 4) - complex->mark_sret (jit_convention::external); + m_complex->mark_sret (jit_convention::external); paren_subsref_fn.init_paren_scalar (); paren_subsasgn_fn.init_paren_scalar (); // bind global variables - lerror_state = base_jit_module->create_global_variable (bool_t, false, - "error_state"); + m_lerror_state = m_base_jit_module->create_global_variable (m_bool_t, false, + "error_state"); - base_jit_module->add_global_mapping (lerror_state, &error_state); + m_base_jit_module->add_global_mapping (m_lerror_state, &error_state); // sig_atomic_type is going to be some sort of integer - sig_atomic_type = llvm::Type::getIntNTy (context, sizeof(sig_atomic_t) * 8); + m_sig_atomic_type = llvm::Type::getIntNTy (context, sizeof(sig_atomic_t) * 8); - loctave_interrupt_state = base_jit_module->create_global_variable - (sig_atomic_type, false, "octave_interrupt_state"); + m_loctave_interrupt_state = m_base_jit_module->create_global_variable + (m_sig_atomic_type, false, "octave_interrupt_state"); - base_jit_module->add_global_mapping (loctave_interrupt_state, - &octave_interrupt_state); + m_base_jit_module->add_global_mapping (m_loctave_interrupt_state, + &octave_interrupt_state); // generic call function { jit_type *int_t = do_get_intN (sizeof (octave_builtin::fcn) * 8); - any_call = create_external (JIT_FN (octave_jit_call), any, int_t, int_t, - any_ptr, int_t); + m_any_call = create_external (JIT_FN (octave_jit_call), m_any, int_t, int_t, + m_any_ptr, int_t); } // any with anything is an any op @@ -1268,21 +1268,21 @@ jit_type *binary_op_type = do_get_intN (sizeof (octave_value::binary_op) * 8); llvm::Type *llvm_bo_type = binary_op_type->to_llvm (); jit_function any_binary = create_external (JIT_FN (octave_jit_binary_any_any), - any, binary_op_type, any, any); + m_any, binary_op_type, m_any, m_any); any_binary.mark_can_error (); for (size_t i = 0; i < octave_value::num_binary_ops; ++i) { octave_value::binary_op op = static_cast<octave_value::binary_op> (i); std::string op_name = octave_value::binary_op_as_string (op); - binary_ops.push_back (jit_operation ("binary" + op_name)); + m_binary_ops.push_back (jit_operation ("binary" + op_name)); } for (size_t i = 0; i < octave_value::num_unary_ops; ++i) { octave_value::unary_op op = static_cast<octave_value::unary_op> (i); std::string op_name = octave_value::unary_op_as_string (op); - unary_ops.push_back (jit_operation ("unary" + op_name)); + m_unary_ops.push_back (jit_operation ("unary" + op_name)); } for (int op = 0; op < octave_value::num_binary_ops; ++op) @@ -1290,378 +1290,378 @@ const llvm::Twine &fn_name = "octave_jit_binary_any_any_" + llvm::Twine (op); - fn = create_internal (fn_name, any, any, any); + fn = create_internal (fn_name, m_any, m_any, m_any); fn.mark_can_error (); llvm::BasicBlock *block = fn.new_block (); - builder.SetInsertPoint (block); + m_builder.SetInsertPoint (block); llvm::APInt op_int(sizeof (octave_value::binary_op) * 8, op, std::numeric_limits<octave_value::binary_op>::is_signed); llvm::Value *op_as_llvm = llvm::ConstantInt::get (llvm_bo_type, op_int); - llvm::Value *ret = any_binary.call (builder, op_as_llvm, - fn.argument (builder, 0), - fn.argument (builder, 1)); - fn.do_return (builder, ret); - binary_ops[op].add_overload (fn); + llvm::Value *ret = any_binary.call (m_builder, op_as_llvm, + fn.argument (m_builder, 0), + fn.argument (m_builder, 1)); + fn.do_return (m_builder, ret); + m_binary_ops[op].add_overload (fn); } // grab matrix - fn = create_external (JIT_FN (octave_jit_grab_matrix), matrix, matrix); - grab_fn.add_overload (fn); - grab_fn.add_overload (create_identity (scalar)); - grab_fn.add_overload (create_identity (scalar_ptr)); - grab_fn.add_overload (create_identity (any_ptr)); - grab_fn.add_overload (create_identity (boolean)); - grab_fn.add_overload (create_identity (complex)); - grab_fn.add_overload (create_identity (index)); + fn = create_external (JIT_FN (octave_jit_grab_matrix), m_matrix, m_matrix); + m_grab_fn.add_overload (fn); + m_grab_fn.add_overload (create_identity (m_scalar)); + m_grab_fn.add_overload (create_identity (m_scalar_ptr)); + m_grab_fn.add_overload (create_identity (m_any_ptr)); + m_grab_fn.add_overload (create_identity (m_boolean)); + m_grab_fn.add_overload (create_identity (m_complex)); + m_grab_fn.add_overload (create_identity (m_index)); // release any - fn = create_external (JIT_FN (octave_jit_release_any), nullptr, any); - release_fn.add_overload (fn); + fn = create_external (JIT_FN (octave_jit_release_any), nullptr, m_any); + m_release_fn.add_overload (fn); // release matrix - fn = create_external (JIT_FN (octave_jit_release_matrix), nullptr, matrix); - release_fn.add_overload (fn); + fn = create_external (JIT_FN (octave_jit_release_matrix), nullptr, m_matrix); + m_release_fn.add_overload (fn); // destroy - destroy_fn = release_fn; - destroy_fn.add_overload (create_identity(scalar)); - destroy_fn.add_overload (create_identity(boolean)); - destroy_fn.add_overload (create_identity(index)); - destroy_fn.add_overload (create_identity(complex)); + m_destroy_fn = m_release_fn; + m_destroy_fn.add_overload (create_identity(m_scalar)); + m_destroy_fn.add_overload (create_identity(m_boolean)); + m_destroy_fn.add_overload (create_identity(m_index)); + m_destroy_fn.add_overload (create_identity(m_complex)); // -------------------- scalar related operations -------------------- // now for binary scalar operations - add_binary_op (scalar, octave_value::op_add, llvm::Instruction::FAdd); - add_binary_op (scalar, octave_value::op_sub, llvm::Instruction::FSub); - add_binary_op (scalar, octave_value::op_mul, llvm::Instruction::FMul); - add_binary_op (scalar, octave_value::op_el_mul, llvm::Instruction::FMul); + add_binary_op (m_scalar, octave_value::op_add, llvm::Instruction::FAdd); + add_binary_op (m_scalar, octave_value::op_sub, llvm::Instruction::FSub); + add_binary_op (m_scalar, octave_value::op_mul, llvm::Instruction::FMul); + add_binary_op (m_scalar, octave_value::op_el_mul, llvm::Instruction::FMul); - add_binary_fcmp (scalar, octave_value::op_lt, llvm::CmpInst::FCMP_ULT); - add_binary_fcmp (scalar, octave_value::op_le, llvm::CmpInst::FCMP_ULE); - add_binary_fcmp (scalar, octave_value::op_eq, llvm::CmpInst::FCMP_UEQ); - add_binary_fcmp (scalar, octave_value::op_ge, llvm::CmpInst::FCMP_UGE); - add_binary_fcmp (scalar, octave_value::op_gt, llvm::CmpInst::FCMP_UGT); - add_binary_fcmp (scalar, octave_value::op_ne, llvm::CmpInst::FCMP_UNE); + add_binary_fcmp (m_scalar, octave_value::op_lt, llvm::CmpInst::FCMP_ULT); + add_binary_fcmp (m_scalar, octave_value::op_le, llvm::CmpInst::FCMP_ULE); + add_binary_fcmp (m_scalar, octave_value::op_eq, llvm::CmpInst::FCMP_UEQ); + add_binary_fcmp (m_scalar, octave_value::op_ge, llvm::CmpInst::FCMP_UGE); + add_binary_fcmp (m_scalar, octave_value::op_gt, llvm::CmpInst::FCMP_UGT); + add_binary_fcmp (m_scalar, octave_value::op_ne, llvm::CmpInst::FCMP_UNE); jit_function gripe_div0 = create_external (JIT_FN (warn_divide_by_zero), nullptr); gripe_div0.mark_can_error (); // divide is annoying because it might error - fn = create_internal ("octave_jit_div_scalar_scalar", scalar, scalar, scalar); + fn = create_internal ("octave_jit_div_scalar_scalar", m_scalar, m_scalar, m_scalar); fn.mark_can_error (); llvm::BasicBlock *body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { llvm::BasicBlock *warn_block = fn.new_block ("warn"); llvm::BasicBlock *normal_block = fn.new_block ("normal"); - llvm::Value *zero = llvm::ConstantFP::get (scalar_t, 0); - llvm::Value *check = builder.CreateFCmpUEQ (zero, fn.argument (builder, 1)); - builder.CreateCondBr (check, warn_block, normal_block); + llvm::Value *zero = llvm::ConstantFP::get (m_scalar_t, 0); + llvm::Value *check = m_builder.CreateFCmpUEQ (zero, fn.argument (m_builder, 1)); + m_builder.CreateCondBr (check, warn_block, normal_block); - builder.SetInsertPoint (warn_block); - gripe_div0.call (builder); - builder.CreateBr (normal_block); + m_builder.SetInsertPoint (warn_block); + gripe_div0.call (m_builder); + m_builder.CreateBr (normal_block); - builder.SetInsertPoint (normal_block); - llvm::Value *ret = builder.CreateFDiv (fn.argument (builder, 0), - fn.argument (builder, 1)); - fn.do_return (builder, ret); + m_builder.SetInsertPoint (normal_block); + llvm::Value *ret = m_builder.CreateFDiv (fn.argument (m_builder, 0), + fn.argument (m_builder, 1)); + fn.do_return (m_builder, ret); } - binary_ops[octave_value::op_div].add_overload (fn); - binary_ops[octave_value::op_el_div].add_overload (fn); + m_binary_ops[octave_value::op_div].add_overload (fn); + m_binary_ops[octave_value::op_el_div].add_overload (fn); // ldiv is the same as div with the operators reversed fn = mirror_binary (fn); - binary_ops[octave_value::op_ldiv].add_overload (fn); - binary_ops[octave_value::op_el_ldiv].add_overload (fn); + m_binary_ops[octave_value::op_ldiv].add_overload (fn); + m_binary_ops[octave_value::op_el_ldiv].add_overload (fn); // In general, the result of scalar ^ scalar is a complex number. We might // be able to improve on this if we keep track of the range of values // variables can take on. - fn = create_external (JIT_FN (octave_jit_pow_scalar_scalar), complex, scalar, - scalar); - binary_ops[octave_value::op_pow].add_overload (fn); - binary_ops[octave_value::op_el_pow].add_overload (fn); + fn = create_external (JIT_FN (octave_jit_pow_scalar_scalar), m_complex, m_scalar, + m_scalar); + m_binary_ops[octave_value::op_pow].add_overload (fn); + m_binary_ops[octave_value::op_el_pow].add_overload (fn); // now for unary scalar operations // FIXME: Impelment not - fn = create_internal ("octave_jit_++", scalar, scalar); + fn = create_internal ("octave_jit_++", m_scalar, m_scalar); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *one = llvm::ConstantFP::get (scalar_t, 1); - llvm::Value *val = fn.argument (builder, 0); - val = builder.CreateFAdd (val, one); - fn.do_return (builder, val); + llvm::Value *one = llvm::ConstantFP::get (m_scalar_t, 1); + llvm::Value *val = fn.argument (m_builder, 0); + val = m_builder.CreateFAdd (val, one); + fn.do_return (m_builder, val); } - unary_ops[octave_value::op_incr].add_overload (fn); + m_unary_ops[octave_value::op_incr].add_overload (fn); - fn = create_internal ("octave_jit_--", scalar, scalar); + fn = create_internal ("octave_jit_--", m_scalar, m_scalar); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *one = llvm::ConstantFP::get (scalar_t, 1); - llvm::Value *val = fn.argument (builder, 0); - val = builder.CreateFSub (val, one); - fn.do_return (builder, val); + llvm::Value *one = llvm::ConstantFP::get (m_scalar_t, 1); + llvm::Value *val = fn.argument (m_builder, 0); + val = m_builder.CreateFSub (val, one); + fn.do_return (m_builder, val); } - unary_ops[octave_value::op_decr].add_overload (fn); + m_unary_ops[octave_value::op_decr].add_overload (fn); - fn = create_internal ("octave_jit_uminus", scalar, scalar); + fn = create_internal ("octave_jit_uminus", m_scalar, m_scalar); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *mone = llvm::ConstantFP::get (scalar_t, -1); - llvm::Value *val = fn.argument (builder, 0); - val = builder.CreateFMul (val, mone); - fn.do_return (builder, val); + llvm::Value *mone = llvm::ConstantFP::get (m_scalar_t, -1); + llvm::Value *val = fn.argument (m_builder, 0); + val = m_builder.CreateFMul (val, mone); + fn.do_return (m_builder, val); } - unary_ops[octave_value::op_uminus].add_overload (fn); + m_unary_ops[octave_value::op_uminus].add_overload (fn); - fn = create_identity (scalar); - unary_ops[octave_value::op_uplus].add_overload (fn); - unary_ops[octave_value::op_transpose].add_overload (fn); - unary_ops[octave_value::op_hermitian].add_overload (fn); + fn = create_identity (m_scalar); + m_unary_ops[octave_value::op_uplus].add_overload (fn); + m_unary_ops[octave_value::op_transpose].add_overload (fn); + m_unary_ops[octave_value::op_hermitian].add_overload (fn); // now for binary complex operations - fn = create_internal ("octave_jit_+_complex_complex", complex, complex, - complex); + fn = create_internal ("octave_jit_+_complex_complex", m_complex, m_complex, + m_complex); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *lhs = fn.argument (builder, 0); - llvm::Value *rhs = fn.argument (builder, 1); - llvm::Value *real = builder.CreateFAdd (complex_real (lhs), - complex_real (rhs)); - llvm::Value *imag = builder.CreateFAdd (complex_imag (lhs), - complex_imag (rhs)); - fn.do_return (builder, complex_new (real, imag)); + llvm::Value *lhs = fn.argument (m_builder, 0); + llvm::Value *rhs = fn.argument (m_builder, 1); + llvm::Value *real = m_builder.CreateFAdd (complex_real (lhs), + complex_real (rhs)); + llvm::Value *imag = m_builder.CreateFAdd (complex_imag (lhs), + complex_imag (rhs)); + fn.do_return (m_builder, complex_new (real, imag)); } - binary_ops[octave_value::op_add].add_overload (fn); + m_binary_ops[octave_value::op_add].add_overload (fn); - fn = create_internal ("octave_jit_-_complex_complex", complex, complex, - complex); + fn = create_internal ("octave_jit_-_complex_complex", m_complex, m_complex, + m_complex); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *lhs = fn.argument (builder, 0); - llvm::Value *rhs = fn.argument (builder, 1); - llvm::Value *real = builder.CreateFSub (complex_real (lhs), - complex_real (rhs)); - llvm::Value *imag = builder.CreateFSub (complex_imag (lhs), - complex_imag (rhs)); - fn.do_return (builder, complex_new (real, imag)); + llvm::Value *lhs = fn.argument (m_builder, 0); + llvm::Value *rhs = fn.argument (m_builder, 1); + llvm::Value *real = m_builder.CreateFSub (complex_real (lhs), + complex_real (rhs)); + llvm::Value *imag = m_builder.CreateFSub (complex_imag (lhs), + complex_imag (rhs)); + fn.do_return (m_builder, complex_new (real, imag)); } - binary_ops[octave_value::op_sub].add_overload (fn); + m_binary_ops[octave_value::op_sub].add_overload (fn); fn = create_external (JIT_FN (octave_jit_complex_mul), - complex, complex, complex); - binary_ops[octave_value::op_mul].add_overload (fn); - binary_ops[octave_value::op_el_mul].add_overload (fn); + m_complex, m_complex, m_complex); + m_binary_ops[octave_value::op_mul].add_overload (fn); + m_binary_ops[octave_value::op_el_mul].add_overload (fn); jit_function complex_div = create_external (JIT_FN (octave_jit_complex_div), - complex, complex, complex); + m_complex, m_complex, m_complex); complex_div.mark_can_error (); - binary_ops[octave_value::op_div].add_overload (fn); - binary_ops[octave_value::op_ldiv].add_overload (fn); + m_binary_ops[octave_value::op_div].add_overload (fn); + m_binary_ops[octave_value::op_ldiv].add_overload (fn); - fn = create_external (JIT_FN (octave_jit_pow_complex_complex), complex, - complex, complex); - binary_ops[octave_value::op_pow].add_overload (fn); - binary_ops[octave_value::op_el_pow].add_overload (fn); + fn = create_external (JIT_FN (octave_jit_pow_complex_complex), m_complex, + m_complex, m_complex); + m_binary_ops[octave_value::op_pow].add_overload (fn); + m_binary_ops[octave_value::op_el_pow].add_overload (fn); - fn = create_internal ("octave_jit_*_scalar_complex", complex, scalar, - complex); + fn = create_internal ("octave_jit_*_scalar_complex", m_complex, m_scalar, + m_complex); jit_function mul_scalar_complex = fn; body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { llvm::BasicBlock *complex_mul = fn.new_block ("complex_mul"); llvm::BasicBlock *scalar_mul = fn.new_block ("scalar_mul"); - llvm::Value *fzero = llvm::ConstantFP::get (scalar_t, 0); - llvm::Value *lhs = fn.argument (builder, 0); - llvm::Value *rhs = fn.argument (builder, 1); + llvm::Value *fzero = llvm::ConstantFP::get (m_scalar_t, 0); + llvm::Value *lhs = fn.argument (m_builder, 0); + llvm::Value *rhs = fn.argument (m_builder, 1); - llvm::Value *cmp = builder.CreateFCmpUEQ (complex_imag (rhs), fzero); - builder.CreateCondBr (cmp, scalar_mul, complex_mul); + llvm::Value *cmp = m_builder.CreateFCmpUEQ (complex_imag (rhs), fzero); + m_builder.CreateCondBr (cmp, scalar_mul, complex_mul); - builder.SetInsertPoint (scalar_mul); + m_builder.SetInsertPoint (scalar_mul); llvm::Value *temp = complex_real (rhs); - temp = builder.CreateFMul (lhs, temp); - fn.do_return (builder, complex_new (temp, fzero), false); + temp = m_builder.CreateFMul (lhs, temp); + fn.do_return (m_builder, complex_new (temp, fzero), false); - builder.SetInsertPoint (complex_mul); - temp = complex_new (builder.CreateFMul (lhs, complex_real (rhs)), - builder.CreateFMul (lhs, complex_imag (rhs))); - fn.do_return (builder, temp); + m_builder.SetInsertPoint (complex_mul); + temp = complex_new (m_builder.CreateFMul (lhs, complex_real (rhs)), + m_builder.CreateFMul (lhs, complex_imag (rhs))); + fn.do_return (m_builder, temp); } - binary_ops[octave_value::op_mul].add_overload (fn); - binary_ops[octave_value::op_el_mul].add_overload (fn); + m_binary_ops[octave_value::op_mul].add_overload (fn); + m_binary_ops[octave_value::op_el_mul].add_overload (fn); fn = mirror_binary (mul_scalar_complex); - binary_ops[octave_value::op_mul].add_overload (fn); - binary_ops[octave_value::op_el_mul].add_overload (fn); + m_binary_ops[octave_value::op_mul].add_overload (fn); + m_binary_ops[octave_value::op_el_mul].add_overload (fn); - fn = create_internal ("octave_jit_+_scalar_complex", complex, scalar, - complex); + fn = create_internal ("octave_jit_+_scalar_complex", m_complex, m_scalar, + m_complex); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *lhs = fn.argument (builder, 0); - llvm::Value *rhs = fn.argument (builder, 1); - llvm::Value *real = builder.CreateFAdd (lhs, complex_real (rhs)); - fn.do_return (builder, complex_real (rhs, real)); + llvm::Value *lhs = fn.argument (m_builder, 0); + llvm::Value *rhs = fn.argument (m_builder, 1); + llvm::Value *real = m_builder.CreateFAdd (lhs, complex_real (rhs)); + fn.do_return (m_builder, complex_real (rhs, real)); } - binary_ops[octave_value::op_add].add_overload (fn); + m_binary_ops[octave_value::op_add].add_overload (fn); fn = mirror_binary (fn); - binary_ops[octave_value::op_add].add_overload (fn); + m_binary_ops[octave_value::op_add].add_overload (fn); - fn = create_internal ("octave_jit_-_complex_scalar", complex, complex, - scalar); + fn = create_internal ("octave_jit_-_complex_scalar", m_complex, m_complex, + m_scalar); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *lhs = fn.argument (builder, 0); - llvm::Value *rhs = fn.argument (builder, 1); - llvm::Value *real = builder.CreateFSub (complex_real (lhs), rhs); - fn.do_return (builder, complex_real (lhs, real)); + llvm::Value *lhs = fn.argument (m_builder, 0); + llvm::Value *rhs = fn.argument (m_builder, 1); + llvm::Value *real = m_builder.CreateFSub (complex_real (lhs), rhs); + fn.do_return (m_builder, complex_real (lhs, real)); } - binary_ops[octave_value::op_sub].add_overload (fn); + m_binary_ops[octave_value::op_sub].add_overload (fn); - fn = create_internal ("octave_jit_-_scalar_complex", complex, scalar, - complex); + fn = create_internal ("octave_jit_-_scalar_complex", m_complex, m_scalar, + m_complex); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *lhs = fn.argument (builder, 0); - llvm::Value *rhs = fn.argument (builder, 1); - llvm::Value *real = builder.CreateFSub (lhs, complex_real (rhs)); - fn.do_return (builder, complex_real (rhs, real)); + llvm::Value *lhs = fn.argument (m_builder, 0); + llvm::Value *rhs = fn.argument (m_builder, 1); + llvm::Value *real = m_builder.CreateFSub (lhs, complex_real (rhs)); + fn.do_return (m_builder, complex_real (rhs, real)); } - binary_ops[octave_value::op_sub].add_overload (fn); + m_binary_ops[octave_value::op_sub].add_overload (fn); - fn = create_external (JIT_FN (octave_jit_pow_scalar_complex), complex, scalar, - complex); - binary_ops[octave_value::op_pow].add_overload (fn); - binary_ops[octave_value::op_el_pow].add_overload (fn); + fn = create_external (JIT_FN (octave_jit_pow_scalar_complex), m_complex, m_scalar, + m_complex); + m_binary_ops[octave_value::op_pow].add_overload (fn); + m_binary_ops[octave_value::op_el_pow].add_overload (fn); - fn = create_external (JIT_FN (octave_jit_pow_complex_scalar), complex, - complex, scalar); - binary_ops[octave_value::op_pow].add_overload (fn); - binary_ops[octave_value::op_el_pow].add_overload (fn); + fn = create_external (JIT_FN (octave_jit_pow_complex_scalar), m_complex, + m_complex, m_scalar); + m_binary_ops[octave_value::op_pow].add_overload (fn); + m_binary_ops[octave_value::op_el_pow].add_overload (fn); // now for binary index operators - add_binary_op (index, octave_value::op_add, llvm::Instruction::Add); + add_binary_op (m_index, octave_value::op_add, llvm::Instruction::Add); // and binary bool operators - add_binary_op (boolean, octave_value::op_el_or, llvm::Instruction::Or); - add_binary_op (boolean, octave_value::op_el_and, llvm::Instruction::And); + add_binary_op (m_boolean, octave_value::op_el_or, llvm::Instruction::Or); + add_binary_op (m_boolean, octave_value::op_el_and, llvm::Instruction::And); // now for printing functions - add_print (any, reinterpret_cast<void *> (&octave_jit_print_any)); - add_print (scalar, reinterpret_cast<void *> (&octave_jit_print_scalar)); + add_print (m_any, reinterpret_cast<void *> (&octave_jit_print_any)); + add_print (m_scalar, reinterpret_cast<void *> (&octave_jit_print_scalar)); // initialize for loop - fn = create_internal ("octave_jit_for_range_init", index, range); + fn = create_internal ("octave_jit_for_range_init", m_index, m_range); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *zero = llvm::ConstantInt::get (index_t, 0); - fn.do_return (builder, zero); + llvm::Value *zero = llvm::ConstantInt::get (m_index_t, 0); + fn.do_return (m_builder, zero); } - for_init_fn.add_overload (fn); + m_for_init_fn.add_overload (fn); // bounds check for for loop - fn = create_internal ("octave_jit_for_range_check", boolean, range, index); + fn = create_internal ("octave_jit_for_range_check", m_boolean, m_range, m_index); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { llvm::Value *nelem - = builder.CreateExtractValue (fn.argument (builder, 0), 3); - llvm::Value *idx = fn.argument (builder, 1); - llvm::Value *ret = builder.CreateICmpULT (idx, nelem); - fn.do_return (builder, ret); + = m_builder.CreateExtractValue (fn.argument (m_builder, 0), 3); + llvm::Value *idx = fn.argument (m_builder, 1); + llvm::Value *ret = m_builder.CreateICmpULT (idx, nelem); + fn.do_return (m_builder, ret); } - for_check_fn.add_overload (fn); + m_for_check_fn.add_overload (fn); // index variabe for for loop - fn = create_internal ("octave_jit_for_range_idx", scalar, range, index); + fn = create_internal ("octave_jit_for_range_idx", m_scalar, m_range, m_index); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *idx = fn.argument (builder, 1); - llvm::Value *didx = builder.CreateSIToFP (idx, scalar_t); - llvm::Value *rng = fn.argument (builder, 0); - llvm::Value *base = builder.CreateExtractValue (rng, 0); - llvm::Value *inc = builder.CreateExtractValue (rng, 2); + llvm::Value *idx = fn.argument (m_builder, 1); + llvm::Value *didx = m_builder.CreateSIToFP (idx, m_scalar_t); + llvm::Value *rng = fn.argument (m_builder, 0); + llvm::Value *base = m_builder.CreateExtractValue (rng, 0); + llvm::Value *inc = m_builder.CreateExtractValue (rng, 2); - llvm::Value *ret = builder.CreateFMul (didx, inc); - ret = builder.CreateFAdd (base, ret); - fn.do_return (builder, ret); + llvm::Value *ret = m_builder.CreateFMul (didx, inc); + ret = m_builder.CreateFAdd (base, ret); + fn.do_return (m_builder, ret); } - for_index_fn.add_overload (fn); + m_for_index_fn.add_overload (fn); // logically true jit_function gripe_nantl = create_external (JIT_FN (octave_jit_err_nan_to_logical_conversion), nullptr); gripe_nantl.mark_can_error (); - fn = create_internal ("octave_jit_logically_true_scalar", boolean, scalar); + fn = create_internal ("octave_jit_logically_true_scalar", m_boolean, m_scalar); fn.mark_can_error (); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { llvm::BasicBlock *error_block = fn.new_block ("error"); llvm::BasicBlock *normal_block = fn.new_block ("normal"); - llvm::Value *check = builder.CreateFCmpUNE (fn.argument (builder, 0), - fn.argument (builder, 0)); - builder.CreateCondBr (check, error_block, normal_block); + llvm::Value *check = m_builder.CreateFCmpUNE (fn.argument (m_builder, 0), + fn.argument (m_builder, 0)); + m_builder.CreateCondBr (check, error_block, normal_block); - builder.SetInsertPoint (error_block); - gripe_nantl.call (builder); - builder.CreateBr (normal_block); - builder.SetInsertPoint (normal_block); + m_builder.SetInsertPoint (error_block); + gripe_nantl.call (m_builder); + m_builder.CreateBr (normal_block); + m_builder.SetInsertPoint (normal_block); - llvm::Value *zero = llvm::ConstantFP::get (scalar_t, 0); - llvm::Value *ret = builder.CreateFCmpONE (fn.argument (builder, 0), zero); - fn.do_return (builder, ret); + llvm::Value *zero = llvm::ConstantFP::get (m_scalar_t, 0); + llvm::Value *ret = m_builder.CreateFCmpONE (fn.argument (m_builder, 0), zero); + fn.do_return (m_builder, ret); } - logically_true_fn.add_overload (fn); + m_logically_true_fn.add_overload (fn); // logically_true boolean - fn = create_identity (boolean); - logically_true_fn.add_overload (fn); + fn = create_identity (m_boolean); + m_logically_true_fn.add_overload (fn); // make_range // FIXME: May be benificial to implement all in LLVM jit_function compute_nelem = create_external (JIT_FN (octave_jit_compute_nelem), - index, scalar, scalar, scalar); - fn = create_internal ("octave_jit_make_range", range, scalar, scalar, scalar); + m_index, m_scalar, m_scalar, m_scalar); + fn = create_internal ("octave_jit_make_range", m_range, m_scalar, m_scalar, m_scalar); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *base = fn.argument (builder, 0); - llvm::Value *limit = fn.argument (builder, 1); - llvm::Value *inc = fn.argument (builder, 2); - llvm::Value *nelem = compute_nelem.call (builder, base, limit, inc); + llvm::Value *base = fn.argument (m_builder, 0); + llvm::Value *limit = fn.argument (m_builder, 1); + llvm::Value *inc = fn.argument (m_builder, 2); + llvm::Value *nelem = compute_nelem.call (m_builder, base, limit, inc); - llvm::Value *dzero = llvm::ConstantFP::get (scalar_t, 0); - llvm::Value *izero = llvm::ConstantInt::get (index_t, 0); - llvm::Value *rng = llvm::ConstantStruct::get (range_t, dzero, dzero, dzero, + llvm::Value *dzero = llvm::ConstantFP::get (m_scalar_t, 0); + llvm::Value *izero = llvm::ConstantInt::get (m_index_t, 0); + llvm::Value *rng = llvm::ConstantStruct::get (m_range_t, dzero, dzero, dzero, izero, NULL); - rng = builder.CreateInsertValue (rng, base, 0); - rng = builder.CreateInsertValue (rng, limit, 1); - rng = builder.CreateInsertValue (rng, inc, 2); - rng = builder.CreateInsertValue (rng, nelem, 3); - fn.do_return (builder, rng); + rng = m_builder.CreateInsertValue (rng, base, 0); + rng = m_builder.CreateInsertValue (rng, limit, 1); + rng = m_builder.CreateInsertValue (rng, inc, 2); + rng = m_builder.CreateInsertValue (rng, nelem, 3); + fn.do_return (m_builder, rng); } - make_range_fn.add_overload (fn); + m_make_range_fn.add_overload (fn); // paren_subsref jit_type *jit_int = do_get_intN (sizeof (int) * 8); @@ -1669,299 +1669,299 @@ jit_function ginvalid_index = create_external (JIT_FN (octave_jit_ginvalid_index), nullptr); jit_function gindex_range = create_external (JIT_FN (octave_jit_gindex_range), - nullptr, jit_int, jit_int, index, - index); + nullptr, jit_int, jit_int, m_index, + m_index); - fn = create_internal ("()subsref", scalar, matrix, scalar); + fn = create_internal ("()subsref", m_scalar, m_matrix, m_scalar); fn.mark_can_error (); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *one_idx = llvm::ConstantInt::get (index_t, 1); + llvm::Value *one_idx = llvm::ConstantInt::get (m_index_t, 1); llvm::Value *one_int = llvm::ConstantInt::get (int_t, 1); - llvm::Value *undef = llvm::UndefValue::get (scalar_t); - llvm::Value *mat = fn.argument (builder, 0); - llvm::Value *idx = fn.argument (builder, 1); + llvm::Value *undef = llvm::UndefValue::get (m_scalar_t); + llvm::Value *mat = fn.argument (m_builder, 0); + llvm::Value *idx = fn.argument (m_builder, 1); // convert index to scalar to integer, and check index >= 1 - llvm::Value *int_idx = builder.CreateFPToSI (idx, index_t); - llvm::Value *check_idx = builder.CreateSIToFP (int_idx, scalar_t); - llvm::Value *cond0 = builder.CreateFCmpUNE (idx, check_idx); - llvm::Value *cond1 = builder.CreateICmpSLT (int_idx, one_idx); - llvm::Value *cond = builder.CreateOr (cond0, cond1); + llvm::Value *int_idx = m_builder.CreateFPToSI (idx, m_index_t); + llvm::Value *check_idx = m_builder.CreateSIToFP (int_idx, m_scalar_t); + llvm::Value *cond0 = m_builder.CreateFCmpUNE (idx, check_idx); + llvm::Value *cond1 = m_builder.CreateICmpSLT (int_idx, one_idx); + llvm::Value *cond = m_builder.CreateOr (cond0, cond1); llvm::BasicBlock *done = fn.new_block ("done"); llvm::BasicBlock *conv_error = fn.new_block ("conv_error", done); llvm::BasicBlock *normal = fn.new_block ("normal", done); - builder.CreateCondBr (cond, conv_error, normal); + m_builder.CreateCondBr (cond, conv_error, normal); - builder.SetInsertPoint (conv_error); - ginvalid_index.call (builder); - builder.CreateBr (done); + m_builder.SetInsertPoint (conv_error); + ginvalid_index.call (m_builder); + m_builder.CreateBr (done); - builder.SetInsertPoint (normal); + m_builder.SetInsertPoint (normal); llvm::Value *len - = builder.CreateExtractValue (mat, llvm::ArrayRef<unsigned> (2)); - cond = builder.CreateICmpSGT (int_idx, len); + = m_builder.CreateExtractValue (mat, llvm::ArrayRef<unsigned> (2)); + cond = m_builder.CreateICmpSGT (int_idx, len); llvm::BasicBlock *bounds_error = fn.new_block ("bounds_error", done); llvm::BasicBlock *success = fn.new_block ("success", done); - builder.CreateCondBr (cond, bounds_error, success); + m_builder.CreateCondBr (cond, bounds_error, success); - builder.SetInsertPoint (bounds_error); - gindex_range.call (builder, one_int, one_int, int_idx, len); - builder.CreateBr (done); + m_builder.SetInsertPoint (bounds_error); + gindex_range.call (m_builder, one_int, one_int, int_idx, len); + m_builder.CreateBr (done); - builder.SetInsertPoint (success); - llvm::Value *data = builder.CreateExtractValue (mat, - llvm::ArrayRef<unsigned> (1)); - llvm::Value *gep = builder.CreateInBoundsGEP (data, int_idx); - llvm::Value *ret = builder.CreateLoad (gep); - builder.CreateBr (done); + m_builder.SetInsertPoint (success); + llvm::Value *data = m_builder.CreateExtractValue (mat, + llvm::ArrayRef<unsigned> (1)); + llvm::Value *gep = m_builder.CreateInBoundsGEP (data, int_idx); + llvm::Value *ret = m_builder.CreateLoad (gep); + m_builder.CreateBr (done); - builder.SetInsertPoint (done); + m_builder.SetInsertPoint (done); - llvm::PHINode *merge = llvm::PHINode::Create (scalar_t, 3); - builder.Insert (merge); + llvm::PHINode *merge = llvm::PHINode::Create (m_scalar_t, 3); + m_builder.Insert (merge); merge->addIncoming (undef, conv_error); merge->addIncoming (undef, bounds_error); merge->addIncoming (ret, success); - fn.do_return (builder, merge); + fn.do_return (m_builder, merge); } paren_subsref_fn.add_overload (fn); // paren subsasgn jit_function resize_paren_subsasgn - = create_external (JIT_FN (octave_jit_paren_subsasgn_impl), matrix, matrix, - index, scalar); - fn = create_internal ("octave_jit_paren_subsasgn", matrix, matrix, scalar, - scalar); + = create_external (JIT_FN (octave_jit_paren_subsasgn_impl), m_matrix, m_matrix, + m_index, m_scalar); + fn = create_internal ("octave_jit_paren_subsasgn", m_matrix, m_matrix, m_scalar, + m_scalar); fn.mark_can_error (); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *one_idx = llvm::ConstantInt::get (index_t, 1); + llvm::Value *one_idx = llvm::ConstantInt::get (m_index_t, 1); llvm::Value *one_int = llvm::ConstantInt::get (int_t, 1); - llvm::Value *mat = fn.argument (builder, 0); - llvm::Value *idx = fn.argument (builder, 1); - llvm::Value *value = fn.argument (builder, 2); + llvm::Value *mat = fn.argument (m_builder, 0); + llvm::Value *idx = fn.argument (m_builder, 1); + llvm::Value *value = fn.argument (m_builder, 2); - llvm::Value *int_idx = builder.CreateFPToSI (idx, index_t); - llvm::Value *check_idx = builder.CreateSIToFP (int_idx, scalar_t); - llvm::Value *cond0 = builder.CreateFCmpUNE (idx, check_idx); - llvm::Value *cond1 = builder.CreateICmpSLT (int_idx, one_idx); - llvm::Value *cond = builder.CreateOr (cond0, cond1); + llvm::Value *int_idx = m_builder.CreateFPToSI (idx, m_index_t); + llvm::Value *check_idx = m_builder.CreateSIToFP (int_idx, m_scalar_t); + llvm::Value *cond0 = m_builder.CreateFCmpUNE (idx, check_idx); + llvm::Value *cond1 = m_builder.CreateICmpSLT (int_idx, one_idx); + llvm::Value *cond = m_builder.CreateOr (cond0, cond1); llvm::BasicBlock *done = fn.new_block ("done"); llvm::BasicBlock *conv_error = fn.new_block ("conv_error", done); llvm::BasicBlock *normal = fn.new_block ("normal", done); - builder.CreateCondBr (cond, conv_error, normal); - builder.SetInsertPoint (conv_error); - ginvalid_index.call (builder); - builder.CreateBr (done); + m_builder.CreateCondBr (cond, conv_error, normal); + m_builder.SetInsertPoint (conv_error); + ginvalid_index.call (m_builder); + m_builder.CreateBr (done); - builder.SetInsertPoint (normal); - llvm::Value *len = builder.CreateExtractValue (mat, 2); - cond0 = builder.CreateICmpSGT (int_idx, len); + m_builder.SetInsertPoint (normal); + llvm::Value *len = m_builder.CreateExtractValue (mat, 2); + cond0 = m_builder.CreateICmpSGT (int_idx, len); - llvm::Value *rcount = builder.CreateExtractValue (mat, 0); - rcount = builder.CreateLoad (rcount); - cond1 = builder.CreateICmpSGT (rcount, one_int); - cond = builder.CreateOr (cond0, cond1); + llvm::Value *rcount = m_builder.CreateExtractValue (mat, 0); + rcount = m_builder.CreateLoad (rcount); + cond1 = m_builder.CreateICmpSGT (rcount, one_int); + cond = m_builder.CreateOr (cond0, cond1); llvm::BasicBlock *bounds_error = fn.new_block ("bounds_error", done); llvm::BasicBlock *success = fn.new_block ("success", done); - builder.CreateCondBr (cond, bounds_error, success); + m_builder.CreateCondBr (cond, bounds_error, success); // resize on out of bounds access - builder.SetInsertPoint (bounds_error); - llvm::Value *resize_result = resize_paren_subsasgn.call (builder, mat, + m_builder.SetInsertPoint (bounds_error); + llvm::Value *resize_result = resize_paren_subsasgn.call (m_builder, mat, int_idx, value); - builder.CreateBr (done); + m_builder.CreateBr (done); - builder.SetInsertPoint (success); + m_builder.SetInsertPoint (success); llvm::Value *data - = builder.CreateExtractValue (mat, llvm::ArrayRef<unsigned> (1)); - llvm::Value *gep = builder.CreateInBoundsGEP (data, int_idx); - builder.CreateStore (value, gep); - builder.CreateBr (done); + = m_builder.CreateExtractValue (mat, llvm::ArrayRef<unsigned> (1)); + llvm::Value *gep = m_builder.CreateInBoundsGEP (data, int_idx); + m_builder.CreateStore (value, gep); + m_builder.CreateBr (done); - builder.SetInsertPoint (done); + m_builder.SetInsertPoint (done); - llvm::PHINode *merge = llvm::PHINode::Create (matrix_t, 3); - builder.Insert (merge); + llvm::PHINode *merge = llvm::PHINode::Create (m_matrix_t, 3); + m_builder.Insert (merge); merge->addIncoming (mat, conv_error); merge->addIncoming (resize_result, bounds_error); merge->addIncoming (mat, success); - fn.do_return (builder, merge); + fn.do_return (m_builder, merge); } paren_subsasgn_fn.add_overload (fn); - fn = create_external (JIT_FN (octave_jit_paren_subsasgn_matrix_range), matrix, - matrix, range, scalar); + fn = create_external (JIT_FN (octave_jit_paren_subsasgn_matrix_range), m_matrix, + m_matrix, m_range, m_scalar); fn.mark_can_error (); paren_subsasgn_fn.add_overload (fn); - fn = create_internal ("octave_jit_end1_matrix", scalar, matrix, index, index); + fn = create_internal ("octave_jit_end1_matrix", m_scalar, m_matrix, m_index, m_index); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *mat = fn.argument (builder, 0); - llvm::Value *ret = builder.CreateExtractValue (mat, 2); - fn.do_return (builder, builder.CreateSIToFP (ret, scalar_t)); + llvm::Value *mat = fn.argument (m_builder, 0); + llvm::Value *ret = m_builder.CreateExtractValue (mat, 2); + fn.do_return (m_builder, m_builder.CreateSIToFP (ret, m_scalar_t)); } - end1_fn.add_overload (fn); + m_end1_fn.add_overload (fn); - fn = create_external (JIT_FN (octave_jit_end_matrix),scalar, matrix, index, - index); - end_fn.add_overload (fn); + fn = create_external (JIT_FN (octave_jit_end_matrix),m_scalar, m_matrix, m_index, + m_index); + m_end_fn.add_overload (fn); // -------------------- create_undef -------------------- - fn = create_external (JIT_FN (octave_jit_create_undef), any); - create_undef_fn.add_overload (fn); + fn = create_external (JIT_FN (octave_jit_create_undef), m_any); + m_create_undef_fn.add_overload (fn); - casts[any->type_id ()].stash_name ("(any)"); - casts[scalar->type_id ()].stash_name ("(scalar)"); - casts[complex->type_id ()].stash_name ("(complex)"); - casts[matrix->type_id ()].stash_name ("(matrix)"); - casts[range->type_id ()].stash_name ("(range)"); + m_casts[m_any->type_id ()].stash_name ("(any)"); + m_casts[m_scalar->type_id ()].stash_name ("(scalar)"); + m_casts[m_complex->type_id ()].stash_name ("(complex)"); + m_casts[m_matrix->type_id ()].stash_name ("(matrix)"); + m_casts[m_range->type_id ()].stash_name ("(range)"); - // cast any <- matrix - fn = create_external (JIT_FN (octave_jit_cast_any_matrix), any, matrix); - casts[any->type_id ()].add_overload (fn); + // cast m_any <- matrix + fn = create_external (JIT_FN (octave_jit_cast_any_matrix), m_any, m_matrix); + m_casts[m_any->type_id ()].add_overload (fn); // cast matrix <- any - fn = create_external (JIT_FN (octave_jit_cast_matrix_any), matrix, any); - casts[matrix->type_id ()].add_overload (fn); + fn = create_external (JIT_FN (octave_jit_cast_matrix_any), m_matrix, m_any); + m_casts[m_matrix->type_id ()].add_overload (fn); // cast any <- range - fn = create_external (JIT_FN (octave_jit_cast_any_range), any, range); - casts[any->type_id ()].add_overload (fn); + fn = create_external (JIT_FN (octave_jit_cast_any_range), m_any, m_range); + m_casts[m_any->type_id ()].add_overload (fn); // cast range <- any - fn = create_external (JIT_FN (octave_jit_cast_range_any), range, any); - casts[range->type_id ()].add_overload (fn); + fn = create_external (JIT_FN (octave_jit_cast_range_any), m_range, m_any); + m_casts[m_range->type_id ()].add_overload (fn); // cast any <- scalar - fn = create_external (JIT_FN (octave_jit_cast_any_scalar), any, scalar); - casts[any->type_id ()].add_overload (fn); + fn = create_external (JIT_FN (octave_jit_cast_any_scalar), m_any, m_scalar); + m_casts[m_any->type_id ()].add_overload (fn); // cast scalar <- any - fn = create_external (JIT_FN (octave_jit_cast_scalar_any), scalar, any); - casts[scalar->type_id ()].add_overload (fn); + fn = create_external (JIT_FN (octave_jit_cast_scalar_any), m_scalar, m_any); + m_casts[m_scalar->type_id ()].add_overload (fn); // cast any <- complex - fn = create_external (JIT_FN (octave_jit_cast_any_complex), any, complex); - casts[any->type_id ()].add_overload (fn); + fn = create_external (JIT_FN (octave_jit_cast_any_complex), m_any, m_complex); + m_casts[m_any->type_id ()].add_overload (fn); // cast complex <- any - fn = create_external (JIT_FN (octave_jit_cast_complex_any), complex, any); - casts[complex->type_id ()].add_overload (fn); + fn = create_external (JIT_FN (octave_jit_cast_complex_any), m_complex, m_any); + m_casts[m_complex->type_id ()].add_overload (fn); // cast complex <- scalar - fn = create_internal ("octave_jit_cast_complex_scalar", complex, scalar); + fn = create_internal ("octave_jit_cast_complex_scalar", m_complex, m_scalar); body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); { - llvm::Value *zero = llvm::ConstantFP::get (scalar_t, 0); - fn.do_return (builder, complex_new (fn.argument (builder, 0), zero)); + llvm::Value *zero = llvm::ConstantFP::get (m_scalar_t, 0); + fn.do_return (m_builder, complex_new (fn.argument (m_builder, 0), zero)); } - casts[complex->type_id ()].add_overload (fn); + m_casts[m_complex->type_id ()].add_overload (fn); // cast scalar <- complex - fn = create_internal ("octave_jit_cast_scalar_complex", scalar, complex); + fn = create_internal ("octave_jit_cast_scalar_complex", m_scalar, m_complex); body = fn.new_block (); - builder.SetInsertPoint (body); - fn.do_return (builder, complex_real (fn.argument (builder, 0))); - casts[scalar->type_id ()].add_overload (fn); + m_builder.SetInsertPoint (body); + fn.do_return (m_builder, complex_real (fn.argument (m_builder, 0))); + m_casts[m_scalar->type_id ()].add_overload (fn); // cast any <- any - fn = create_identity (any); - casts[any->type_id ()].add_overload (fn); + fn = create_identity (m_any); + m_casts[m_any->type_id ()].add_overload (fn); // cast scalar <- scalar - fn = create_identity (scalar); - casts[scalar->type_id ()].add_overload (fn); + fn = create_identity (m_scalar); + m_casts[m_scalar->type_id ()].add_overload (fn); // cast complex <- complex - fn = create_identity (complex); - casts[complex->type_id ()].add_overload (fn); + fn = create_identity (m_complex); + m_casts[m_complex->type_id ()].add_overload (fn); // -------------------- builtin functions -------------------- add_builtin ("#unknown_function"); - unknown_function = builtins["#unknown_function"]; + m_unknown_function = m_builtins["#unknown_function"]; add_builtin ("sin"); - register_intrinsic ("sin", llvm::Intrinsic::sin, scalar, scalar); - register_generic ("sin", matrix, matrix); + register_intrinsic ("sin", llvm::Intrinsic::sin, m_scalar, m_scalar); + register_generic ("sin", m_matrix, m_matrix); add_builtin ("cos"); - register_intrinsic ("cos", llvm::Intrinsic::cos, scalar, scalar); - register_generic ("cos", matrix, matrix); + register_intrinsic ("cos", llvm::Intrinsic::cos, m_scalar, m_scalar); + register_generic ("cos", m_matrix, m_matrix); add_builtin ("exp"); - register_intrinsic ("exp", llvm::Intrinsic::exp, scalar, scalar); - register_generic ("exp", matrix, matrix); + register_intrinsic ("exp", llvm::Intrinsic::exp, m_scalar, m_scalar); + register_generic ("exp", m_matrix, m_matrix); add_builtin ("balance"); - register_generic ("balance", matrix, matrix); + register_generic ("balance", m_matrix, m_matrix); add_builtin ("cond"); - register_generic ("cond", scalar, matrix); + register_generic ("cond", m_scalar, m_matrix); add_builtin ("det"); - register_generic ("det", scalar, matrix); + register_generic ("det", m_scalar, m_matrix); add_builtin ("norm"); - register_generic ("norm", scalar, matrix); + register_generic ("norm", m_scalar, m_matrix); add_builtin ("rand"); - register_generic ("rand", matrix, scalar); - register_generic ("rand", matrix, std::vector<jit_type *> (2, scalar)); + register_generic ("rand", m_matrix, m_scalar); + register_generic ("rand", m_matrix, std::vector<jit_type *> (2, m_scalar)); add_builtin ("magic"); - register_generic ("magic", matrix, scalar); - register_generic ("magic", matrix, std::vector<jit_type *> (2, scalar)); + register_generic ("magic", m_matrix, m_scalar); + register_generic ("magic", m_matrix, std::vector<jit_type *> (2, m_scalar)); add_builtin ("eye"); - register_generic ("eye", matrix, scalar); - register_generic ("eye", matrix, std::vector<jit_type *> (2, scalar)); + register_generic ("eye", m_matrix, m_scalar); + register_generic ("eye", m_matrix, std::vector<jit_type *> (2, m_scalar)); add_builtin ("mod"); - register_generic ("mod", scalar, std::vector<jit_type *> (2, scalar)); + register_generic ("mod", m_scalar, std::vector<jit_type *> (2, m_scalar)); - // casts.resize (next_id + 1); - jit_function any_id = create_identity (any); + // m_casts.resize (m_next_id + 1); + jit_function any_id = create_identity (m_any); jit_function grab_any = create_external (JIT_FN (octave_jit_grab_any), - any, any); + m_any, m_any); - jit_function release_any = release_fn.overload (any); + jit_function release_any = m_release_fn.overload (m_any); std::vector<jit_type *> args; args.resize (1); - for (std::map<std::string, jit_type *>::iterator iter = builtins.begin (); - iter != builtins.end (); ++iter) + for (std::map<std::string, jit_type *>::iterator iter = m_builtins.begin (); + iter != m_builtins.end (); ++iter) { jit_type *btype = iter->second; args[0] = btype; - grab_fn.add_overload (jit_function (grab_any, btype, args)); - release_fn.add_overload (jit_function (release_any, 0, args)); - casts[any->type_id ()].add_overload (jit_function (any_id, any, args)); + m_grab_fn.add_overload (jit_function (grab_any, btype, args)); + m_release_fn.add_overload (jit_function (release_any, 0, args)); + m_casts[m_any->type_id ()].add_overload (jit_function (any_id, m_any, args)); - args[0] = any; - casts[btype->type_id ()].add_overload (jit_function (any_id, btype, - args)); + args[0] = m_any; + m_casts[btype->type_id ()].add_overload (jit_function (any_id, btype, + args)); } - base_jit_module->finalizeObject (); + m_base_jit_module->finalizeObject (); - in_construction = false; + s_in_construction = false; } // create a function with an external calling convention @@ -1972,10 +1972,10 @@ jit_type *ret, const std::vector<jit_type *>& args) const { - jit_function retval (base_jit_module, jit_convention::external, + jit_function retval (m_base_jit_module, jit_convention::external, name, ret, args); - base_jit_module->add_global_mapping (retval.to_llvm (), fn); + m_base_jit_module->add_global_mapping (retval.to_llvm (), fn); return retval; } @@ -1990,11 +1990,11 @@ assert ((name == "any") || (name == "any_ptr") || (name == "scalar_ptr") || (parent != nullptr)); - jit_type *ret = new jit_type (name, parent, llvm_type, skip_paren, next_id++); - id_to_type.push_back (ret); + jit_type *ret = new jit_type (name, parent, llvm_type, skip_paren, m_next_id++); + m_id_to_type.push_back (ret); - casts.push_back (jit_operation ("(" + name + ")")); - identities.push_back (jit_function ()); + m_casts.push_back (jit_operation ("(" + name + ")")); + m_identities.push_back (jit_function ()); return ret; } @@ -2002,8 +2002,8 @@ jit_type* jit_typeinfo::do_get_intN (size_t nbits) const { - std::map<size_t, jit_type *>::const_iterator iter = ints.find (nbits); - if (iter != ints.end ()) + std::map<size_t, jit_type *>::const_iterator iter = m_ints.find (nbits); + if (iter != m_ints.end ()) return iter->second; throw jit_fail_exception ("No such integer type"); @@ -2014,9 +2014,9 @@ { jit_const_index *ccount = dynamic_cast<jit_const_index *> (count); if (ccount && ccount->value () == 1) - return end1_fn.overload (value->type (), idx->type (), count->type ()); + return m_end1_fn.overload (value->type (), idx->type (), count->type ()); - return end_fn.overload (value->type (), idx->type (), count->type ()); + return m_end_fn.overload (value->type (), idx->type (), count->type ()); } void @@ -2028,7 +2028,7 @@ jit_function fn = create_external (fptr, name.str (), nullptr, do_get_intN (8), ty); - print_fn.add_overload (fn); + m_print_fn.add_overload (fn); } // FIXME: cp between add_binary_op, add_binary_icmp, and add_binary_fcmp @@ -2042,14 +2042,14 @@ jit_function fn = create_internal (fname.str (), ty, ty, ty); llvm::BasicBlock *block = fn.new_block (); - builder.SetInsertPoint (block); + m_builder.SetInsertPoint (block); llvm::Instruction::BinaryOps temp = static_cast<llvm::Instruction::BinaryOps>(llvm_op); - llvm::Value *ret = builder.CreateBinOp (temp, fn.argument (builder, 0), - fn.argument (builder, 1)); - fn.do_return (builder, ret); - binary_ops[op].add_overload (fn); + llvm::Value *ret = m_builder.CreateBinOp (temp, fn.argument (m_builder, 0), + fn.argument (m_builder, 1)); + fn.do_return (m_builder, ret); + m_binary_ops[op].add_overload (fn); } void @@ -2060,15 +2060,15 @@ fname << "octave_jit" << octave_value::binary_op_as_string (ov_op) << '_' << ty->name (); - jit_function fn = create_internal (fname.str (), boolean, ty, ty); + jit_function fn = create_internal (fname.str (), m_boolean, ty, ty); llvm::BasicBlock *block = fn.new_block (); - builder.SetInsertPoint (block); + m_builder.SetInsertPoint (block); llvm::CmpInst::Predicate temp = static_cast<llvm::CmpInst::Predicate>(llvm_op); - llvm::Value *ret = builder.CreateICmp (temp, fn.argument (builder, 0), - fn.argument (builder, 1)); - fn.do_return (builder, ret); - binary_ops[op].add_overload (fn); + llvm::Value *ret = m_builder.CreateICmp (temp, fn.argument (m_builder, 0), + fn.argument (m_builder, 1)); + fn.do_return (m_builder, ret); + m_binary_ops[op].add_overload (fn); } void @@ -2079,49 +2079,49 @@ fname << "octave_jit" << octave_value::binary_op_as_string (ov_op) << '_' << ty->name (); - jit_function fn = create_internal (fname.str (), boolean, ty, ty); + jit_function fn = create_internal (fname.str (), m_boolean, ty, ty); llvm::BasicBlock *block = fn.new_block (); - builder.SetInsertPoint (block); + m_builder.SetInsertPoint (block); llvm::CmpInst::Predicate temp = static_cast<llvm::CmpInst::Predicate>(llvm_op); - llvm::Value *ret = builder.CreateFCmp (temp, fn.argument (builder, 0), - fn.argument (builder, 1)); - fn.do_return (builder, ret); - binary_ops[op].add_overload (fn); + llvm::Value *ret = m_builder.CreateFCmp (temp, fn.argument (m_builder, 0), + fn.argument (m_builder, 1)); + fn.do_return (m_builder, ret); + m_binary_ops[op].add_overload (fn); } jit_function jit_typeinfo::create_identity (jit_type *type) { size_t id = type->type_id (); - if (id >= identities.size ()) - identities.resize (id + 1); + if (id >= m_identities.size ()) + m_identities.resize (id + 1); - if (! identities[id].valid ()) + if (! m_identities[id].valid ()) { std::stringstream name; name << "id_" << type->name (); jit_function fn = create_internal (name.str (), type, type); llvm::BasicBlock *body = fn.new_block (); - builder.SetInsertPoint (body); - fn.do_return (builder, fn.argument (builder, 0)); - return identities[id] = fn; + m_builder.SetInsertPoint (body); + fn.do_return (m_builder, fn.argument (m_builder, 0)); + return m_identities[id] = fn; } - return identities[id]; + return m_identities[id]; } llvm::Value * jit_typeinfo::do_insert_error_check (llvm::IRBuilderD& abuilder) { - return abuilder.CreateLoad (lerror_state); + return abuilder.CreateLoad (m_lerror_state); } llvm::Value * jit_typeinfo::do_insert_interrupt_check (llvm::IRBuilderD& abuilder) { - llvm::LoadInst *val = abuilder.CreateLoad (loctave_interrupt_state); + llvm::LoadInst *val = abuilder.CreateLoad (m_loctave_interrupt_state); val->setVolatile (true); return abuilder.CreateICmpSGT (val, abuilder.getInt32 (0)); } @@ -2129,8 +2129,8 @@ void jit_typeinfo::add_builtin (const std::string& name) { - jit_type *btype = do_register_new_type (name, any, any_t, true); - builtins[name] = btype; + jit_type *btype = do_register_new_type (name, m_any, m_any_t, true); + m_builtins[name] = btype; octave_builtin *ov_builtin = find_builtin (name); if (ov_builtin) @@ -2142,13 +2142,13 @@ jit_type *result, const std::vector<jit_type *>& args) { - jit_type *builtin_type = builtins[name]; + jit_type *builtin_type = m_builtins[name]; size_t nargs = args.size (); std::vector<llvm::Type*> llvm_args (nargs); for (size_t i = 0; i < nargs; ++i) llvm_args[i] = args[i]->to_llvm (); - llvm::Function *ifun = base_jit_module-> + llvm::Function *ifun = m_base_jit_module-> get_intrinsic_declaration (iid, llvm_args); std::stringstream fn_name; @@ -2163,14 +2163,14 @@ // call the intrinsic with the remaining arguments. jit_function fn = create_internal (fn_name.str (), result, args1); llvm::BasicBlock *body = fn.new_block (); - builder.SetInsertPoint (body); + m_builder.SetInsertPoint (body); llvm::SmallVector<llvm::Value *, 5> fargs (nargs); for (size_t i = 0; i < nargs; ++i) - fargs[i] = fn.argument (builder, i + 1); + fargs[i] = fn.argument (m_builder, i + 1); - llvm::Value *ret = builder.CreateCall (ifun, fargs); - fn.do_return (builder, ret); + llvm::Value *ret = m_builder.CreateCall (ifun, fargs); + fn.do_return (m_builder, ret); paren_subsref_fn.add_overload (fn); } @@ -2194,27 +2194,27 @@ return; std::vector<jit_type *> fn_args (args.size () + 1); - fn_args[0] = builtins[name]; + fn_args[0] = m_builtins[name]; std::copy (args.begin (), args.end (), fn_args.begin () + 1); jit_function fn = create_internal (name, result, fn_args); fn.mark_can_error (); llvm::BasicBlock *block = fn.new_block (); - builder.SetInsertPoint (block); - llvm::ArrayType *array_t = llvm::ArrayType::get (any_t, args.size ()); + m_builder.SetInsertPoint (block); + llvm::ArrayType *array_t = llvm::ArrayType::get (m_any_t, args.size ()); llvm::Value *array = llvm::UndefValue::get (array_t); for (size_t i = 0; i < args.size (); ++i) { - llvm::Value *arg = fn.argument (builder, i + 1); - jit_function agrab = grab_fn.overload (args[i]); + llvm::Value *arg = fn.argument (m_builder, i + 1); + jit_function agrab = m_grab_fn.overload (args[i]); if (agrab.valid ()) - arg = agrab.call (builder, arg); - jit_function acast = do_cast (any, args[i]); - array = builder.CreateInsertValue (array, acast.call (builder, arg), i); + arg = agrab.call (m_builder, arg); + jit_function acast = do_cast (m_any, args[i]); + array = m_builder.CreateInsertValue (array, acast.call (m_builder, arg), i); } - llvm::Value *array_mem = builder.CreateAlloca (array_t); - builder.CreateStore (array, array_mem); - array = builder.CreateBitCast (array_mem, any_t->getPointerTo ()); + llvm::Value *array_mem = m_builder.CreateAlloca (array_t); + m_builder.CreateStore (array, array_mem); + array = m_builder.CreateBitCast (array_mem, m_any_t->getPointerTo ()); jit_type *jintTy = do_get_intN (sizeof (octave_builtin::fcn) * 8); llvm::Type *intTy = jintTy->to_llvm (); @@ -2223,10 +2223,10 @@ llvm::Value *nargin = llvm::ConstantInt::get (intTy, args.size ()); size_t result_int = reinterpret_cast<size_t> (result); llvm::Value *res_llvm = llvm::ConstantInt::get (intTy, result_int); - llvm::Value *ret = any_call.call (builder, fcn, nargin, array, res_llvm); + llvm::Value *ret = m_any_call.call (m_builder, fcn, nargin, array, res_llvm); - jit_function cast_result = do_cast (result, any); - fn.do_return (builder, cast_result.call (builder, ret)); + jit_function cast_result = do_cast (result, m_any); + fn.do_return (m_builder, cast_result.call (m_builder, ret)); paren_subsref_fn.add_overload (fn); } @@ -2240,13 +2240,13 @@ ret.mark_can_error (); llvm::BasicBlock *body = ret.new_block (); - builder.SetInsertPoint (body); - llvm::Value *result = fn.call (builder, ret.argument (builder, 1), - ret.argument (builder, 0)); + m_builder.SetInsertPoint (body); + llvm::Value *result = fn.call (m_builder, ret.argument (m_builder, 1), + ret.argument (m_builder, 0)); if (ret.result ()) - ret.do_return (builder, result); + ret.do_return (m_builder, result); else - ret.do_return (builder); + ret.do_return (m_builder); return ret; } @@ -2256,7 +2256,7 @@ { llvm::Value *real = bld.CreateExtractValue (cplx, 0); llvm::Value *imag = bld.CreateExtractValue (cplx, 1); - llvm::Value *ret = llvm::UndefValue::get (complex_ret); + llvm::Value *ret = llvm::UndefValue::get (m_complex_ret); unsigned int re_idx[] = {0, 0}; unsigned int im_idx[] = {0, 1}; @@ -2270,10 +2270,10 @@ unsigned int re_idx[] = {0, 0}; unsigned int im_idx[] = {0, 1}; - llvm::Type *complex_t = get_complex ()->to_llvm (); + llvm::Type *m_complex_t = get_complex ()->to_llvm (); llvm::Value *real = bld.CreateExtractValue (result, re_idx); llvm::Value *imag = bld.CreateExtractValue (result, im_idx); - llvm::Value *ret = llvm::UndefValue::get (complex_t); + llvm::Value *ret = llvm::UndefValue::get (m_complex_t); ret = bld.CreateInsertValue (ret, real, 0); return bld.CreateInsertValue (ret, imag, 1); @@ -2282,31 +2282,31 @@ llvm::Value * jit_typeinfo::complex_real (llvm::Value *cx) { - return builder.CreateExtractValue (cx, 0); + return m_builder.CreateExtractValue (cx, 0); } llvm::Value * jit_typeinfo::complex_real (llvm::Value *cx, llvm::Value *real) { - return builder.CreateInsertValue (cx, real, 0); + return m_builder.CreateInsertValue (cx, real, 0); } llvm::Value * jit_typeinfo::complex_imag (llvm::Value *cx) { - return builder.CreateExtractValue (cx, 1); + return m_builder.CreateExtractValue (cx, 1); } llvm::Value * jit_typeinfo::complex_imag (llvm::Value *cx, llvm::Value *imag) { - return builder.CreateInsertValue (cx, imag, 1); + return m_builder.CreateInsertValue (cx, imag, 1); } llvm::Value * jit_typeinfo::complex_new (llvm::Value *real, llvm::Value *imag) { - llvm::Value *ret = llvm::UndefValue::get (complex->to_llvm ()); + llvm::Value *ret = llvm::UndefValue::get (m_complex->to_llvm ()); ret = complex_real (ret, real); return complex_imag (ret, imag); } @@ -2321,19 +2321,19 @@ octave_builtin *builtin = dynamic_cast<octave_builtin *> (ov.internal_rep ()); return builtin && builtin->to_jit () ? builtin->to_jit () - : unknown_function; + : m_unknown_function; } if (ov.is_range ()) - return range; + return m_range; if (ov.is_double_type () && ! ov.iscomplex ()) { if (ov.is_real_scalar ()) - return scalar; + return m_scalar; if (ov.is_matrix_type ()) - return matrix; + return m_matrix; } if (ov.is_complex_scalar ()) @@ -2343,12 +2343,11 @@ // We don't really represent complex values, instead we represent // complex_or_scalar. If the imag value is zero, we assume a scalar. if (cv.imag () != 0) - return complex; + return m_complex; } - return any; + return m_any; } - } #endif