static jl_typemap_entry_t *jl_typemap_node_assoc_exact(jl_typemap_entry_t *ml, jl_value_t **args, size_t n)
{
while (ml != (void*)jl_nothing) {
size_t lensig = jl_datatype_nfields(ml->sig);
if (lensig == n || (ml->va && lensig <= n+1)) {
int ismatch;
if (ml->simplesig != (void*)jl_nothing &&
!sig_match_simple(args, n, jl_svec_data(ml->simplesig->parameters), 0,
jl_datatype_nfields(ml->simplesig)))
ismatch = 0;
else if (ml->isleafsig)
ismatch = sig_match_leaf(args, jl_svec_data(ml->sig->parameters), n);
else if (ml->issimplesig)
ismatch = sig_match_simple(args, n, jl_svec_data(ml->sig->parameters), ml->va, lensig);
else
ismatch = jl_tuple_subtype(args, n, ml->sig, 1);
if (ismatch) {
size_t i, l;
for (i = 0, l = jl_svec_len(ml->guardsigs); i < l; i++) {
// checking guard entries require a more
// expensive subtype check, since guard entries added for ANY might be
// abstract. this fixed issue #12967.
if (jl_tuple_subtype(args, n, (jl_tupletype_t*)jl_svecref(ml->guardsigs, i), 1)) {
break;
}
}
if (i == l)
return ml;
}
}
ml = ml->next;
}
return NULL;
}
static jl_function_t *jl_mt_assoc_by_type(jl_methtable_t *mt, jl_tuple_t *tt, int cache)
{
jl_methlist_t *m = mt->defs;
size_t nargs = tt->length;
size_t i;
jl_value_t *env = jl_false;
while (m != NULL) {
if (m->tvars!=jl_null) {
env = jl_type_match((jl_value_t*)tt, (jl_value_t*)m->sig);
if (env != (jl_value_t*)jl_false) break;
}
else if (jl_tuple_subtype(&jl_tupleref(tt,0), nargs,
&jl_tupleref(m->sig,0),
((jl_tuple_t*)m->sig)->length, 0, 0)) {
break;
}
m = m->next;
}
if (env == (jl_value_t*)jl_false) {
if (m != NULL) {
if (!cache) {
return m->func;
}
return cache_method(mt, tt, m->func, (jl_tuple_t*)m->sig, jl_null);
}
return NULL;
}
jl_tuple_t *newsig=NULL;
JL_GC_PUSH(&env, &newsig);
assert(jl_is_tuple(env));
jl_tuple_t *tpenv = (jl_tuple_t*)env;
// don't bother computing this if no arguments are tuples
for(i=0; i < tt->length; i++) {
if (jl_is_tuple(jl_tupleref(tt,i)))
break;
}
if (i < tt->length) {
newsig = (jl_tuple_t*)jl_instantiate_type_with((jl_type_t*)m->sig,
&jl_tupleref(tpenv,0),
tpenv->length/2);
}
else {
newsig = (jl_tuple_t*)m->sig;
}
assert(jl_is_tuple(newsig));
jl_function_t *nf;
if (!cache)
nf = m->func;
else
nf = cache_method(mt, tt, m->func, newsig, tpenv);
JL_GC_POP();
return nf;
}
jl_typemap_entry_t *jl_typemap_entry_assoc_exact(jl_typemap_entry_t *ml, jl_value_t **args, size_t n)
{
// some manually-unrolled common special cases
while (ml->simplesig == (void*)jl_nothing && ml->guardsigs == jl_emptysvec && ml->isleafsig) {
// use a tight loop for a long as possible
if (n == jl_field_count(ml->sig) && jl_typeof(args[0]) == jl_tparam(ml->sig, 0)) {
if (n == 1)
return ml;
if (n == 2) {
if (jl_typeof(args[1]) == jl_tparam(ml->sig, 1))
return ml;
}
else if (n == 3) {
if (jl_typeof(args[1]) == jl_tparam(ml->sig, 1) &&
jl_typeof(args[2]) == jl_tparam(ml->sig, 2))
return ml;
}
else {
if (sig_match_leaf(args, jl_svec_data(ml->sig->parameters), n))
return ml;
}
}
ml = ml->next;
if (ml == (void*)jl_nothing)
return NULL;
}
while (ml != (void*)jl_nothing) {
size_t lensig = jl_field_count(ml->sig);
if (lensig == n || (ml->va && lensig <= n+1)) {
if (ml->simplesig != (void*)jl_nothing) {
size_t lensimplesig = jl_field_count(ml->simplesig);
int isva = lensimplesig > 0 && jl_is_vararg_type(jl_tparam(ml->simplesig, lensimplesig - 1));
if (lensig == n || (isva && lensimplesig <= n + 1)) {
if (!sig_match_simple(args, n, jl_svec_data(ml->simplesig->parameters), isva, lensimplesig))
goto nomatch;
}
else {
goto nomatch;
}
}
if (ml->isleafsig) {
if (!sig_match_leaf(args, jl_svec_data(ml->sig->parameters), n))
goto nomatch;
}
else if (ml->issimplesig) {
if (!sig_match_simple(args, n, jl_svec_data(ml->sig->parameters), ml->va, lensig))
goto nomatch;
}
else {
if (!jl_tuple_subtype(args, n, ml->sig, 1))
goto nomatch;
}
size_t i, l;
if (ml->guardsigs != jl_emptysvec) {
for (i = 0, l = jl_svec_len(ml->guardsigs); i < l; i++) {
// checking guard entries require a more
// expensive subtype check, since guard entries added for ANY might be
// abstract. this fixed issue #12967.
if (jl_tuple_subtype(args, n, (jl_tupletype_t*)jl_svecref(ml->guardsigs, i), 1)) {
goto nomatch;
}
}
}
return ml;
}
nomatch:
ml = ml->next;
}
return NULL;
}
/*
Method caches are divided into three parts: one for signatures where
the first argument is a singleton kind (Type{Foo}), one indexed by the
UID of the first argument's type in normal cases, and a fallback
table of everything else.
Note that the "primary key" is the type of the first *argument*, since
there tends to be lots of variation there. The type of the 0th argument
(the function) is always the same for most functions.
*/
static jl_typemap_entry_t *jl_typemap_assoc_by_type_(jl_typemap_entry_t *ml, jl_tupletype_t *types, int8_t inexact, jl_svec_t **penv)
{
size_t n = jl_field_count(types);
while (ml != (void*)jl_nothing) {
size_t lensig = jl_field_count(ml->sig);
if (lensig == n || (ml->va && lensig <= n+1)) {
int resetenv = 0, ismatch = 1;
if (ml->simplesig != (void*)jl_nothing) {
size_t lensimplesig = jl_field_count(ml->simplesig);
int isva = lensimplesig > 0 && jl_is_vararg_type(jl_tparam(ml->simplesig, lensimplesig - 1));
if (lensig == n || (isva && lensimplesig <= n + 1))
ismatch = sig_match_by_type_simple(jl_svec_data(types->parameters), n,
ml->simplesig, lensimplesig, isva);
else
ismatch = 0;
}
if (ismatch == 0)
; // nothing
else if (ml->isleafsig)
ismatch = sig_match_by_type_leaf(jl_svec_data(types->parameters),
ml->sig, lensig);
else if (ml->issimplesig)
ismatch = sig_match_by_type_simple(jl_svec_data(types->parameters), n,
ml->sig, lensig, ml->va);
else if (ml->tvars == jl_emptysvec)
ismatch = jl_tuple_subtype(jl_svec_data(types->parameters), n, ml->sig, 0);
else if (penv == NULL) {
ismatch = jl_type_match((jl_value_t*)types, (jl_value_t*)ml->sig) != (jl_value_t*)jl_false;
}
else {
// TODO: this is missing the actual subtype test,
// which works currently because types is typically a leaf tt,
// or inexact is set (which then does a sort of subtype test via jl_types_equal)
// but this isn't entirely general
jl_value_t *ti = jl_lookup_match((jl_value_t*)types, (jl_value_t*)ml->sig, penv, ml->tvars);
resetenv = 1;
ismatch = (ti != (jl_value_t*)jl_bottom_type);
if (ismatch) {
// parametric methods only match if all typevars are matched by
// non-typevars.
size_t i, l;
for (i = 0, l = jl_svec_len(*penv); i < l; i++) {
if (jl_is_typevar(jl_svecref(*penv, i))) {
if (inexact) {
// "inexact" means the given type is compile-time,
// where a failure to determine the value of a
// static parameter is inconclusive.
// this is issue #3182, see test/core.jl
return INEXACT_ENTRY;
}
ismatch = 0;
break;
}
}
if (inexact) {
// the compiler might attempt jl_get_specialization on e.g.
// convert(::Type{Type{Int}}, ::DataType), which is concrete but might not
// equal the run time type. in this case ti would be {Type{Type{Int}}, Type{Int}}
// but tt would be {Type{Type{Int}}, DataType}.
JL_GC_PUSH1(&ti);
ismatch = jl_types_equal(ti, (jl_value_t*)types);
JL_GC_POP();
if (!ismatch)
return INEXACT_ENTRY;
}
}
}
if (ismatch) {
size_t i, l;
for (i = 0, l = jl_svec_len(ml->guardsigs); i < l; i++) {
// see corresponding code in jl_typemap_assoc_exact
if (jl_subtype((jl_value_t*)types, jl_svecref(ml->guardsigs, i), 0)) {
ismatch = 0;
break;
}
}
if (ismatch)
return ml;
}
if (resetenv)
*penv = jl_emptysvec;
}
ml = ml->next;
}
return NULL;
}
jl_typemap_entry_t *jl_typemap_assoc_exact(union jl_typemap_t ml_or_cache, jl_value_t **args, size_t n, int8_t offs)
{
// NOTE: This function is a huge performance hot spot!!
jl_typemap_entry_t *ml;
if (jl_typeof(ml_or_cache.unknown) == (jl_value_t*)jl_typemap_level_type) {
jl_typemap_level_t *cache = ml_or_cache.node;
if (n > offs) {
jl_value_t *a1 = args[offs];
jl_value_t *ty = (jl_value_t*)jl_typeof(a1);
assert(jl_is_datatype(ty));
if (ty == (jl_value_t*)jl_datatype_type && cache->targ != (void*)jl_nothing) {
ml_or_cache = mtcache_hash_lookup(cache->targ, a1, 1, offs);
ml = jl_typemap_assoc_exact(ml_or_cache, args, n, offs+1);
if (ml)
return ml;
}
if (cache->arg1 != (void*)jl_nothing) {
ml_or_cache = mtcache_hash_lookup(cache->arg1, ty, 0, offs);
if (jl_typeof(ml_or_cache.unknown) == (jl_value_t*)jl_typemap_entry_type &&
ml_or_cache.leaf->simplesig == (void*)jl_nothing && offs < 2 && n > 1) {
jl_value_t *a0 = args[1-offs];
jl_value_t *t0 = (jl_value_t*)jl_typeof(a0);
if (ml_or_cache.leaf->next==(void*)jl_nothing && n==2 && jl_datatype_nfields(ml_or_cache.leaf->sig)==2 &&
jl_tparam(ml_or_cache.leaf->sig, 1 - offs) == t0)
return ml_or_cache.leaf;
if (n==3) {
// some manually-unrolled common special cases
jl_value_t *a2 = args[2];
if (!jl_is_tuple(a2)) { // issue #6426
jl_typemap_entry_t *mn = ml_or_cache.leaf;
if (jl_datatype_nfields(mn->sig)==3 &&
jl_tparam(mn->sig,1-offs)==t0 &&
jl_tparam(mn->sig,2)==(jl_value_t*)jl_typeof(a2))
return mn;
mn = mn->next;
if (mn!=(void*)jl_nothing && jl_datatype_nfields(mn->sig)==3 &&
jl_tparam(mn->sig,1-offs)==t0 &&
jl_tparam(mn->sig,2)==(jl_value_t*)jl_typeof(a2))
return mn;
}
}
}
ml = jl_typemap_assoc_exact(ml_or_cache, args, n, offs+1);
if (ml)
return ml;
}
}
ml = cache->linear;
}
else {
ml = ml_or_cache.leaf;
}
while (ml != (void*)jl_nothing) {
size_t lensig = jl_datatype_nfields(ml->sig);
if (lensig == n || (ml->va && lensig <= n+1)) {
int ismatch;
if (ml->simplesig != (void*)jl_nothing &&
!sig_match_simple(args, n, jl_svec_data(ml->simplesig->parameters), 0,
jl_datatype_nfields(ml->simplesig)))
ismatch = 0;
else if (ml->isleafsig)
ismatch = sig_match_leaf(args, jl_svec_data(ml->sig->parameters), n);
else if (ml->issimplesig)
ismatch = sig_match_simple(args, n, jl_svec_data(ml->sig->parameters), ml->va, lensig);
else
ismatch = jl_tuple_subtype(args, n, ml->sig, 1);
if (ismatch) {
size_t i, l;
for (i = 0, l = jl_svec_len(ml->guardsigs); i < l; i++) {
// checking guard entries require a more
// expensive subtype check, since guard entries added for ANY might be
// abstract. this fixed issue #12967.
if (jl_tuple_subtype(args, n, (jl_tupletype_t*)jl_svecref(ml->guardsigs, i), 1)) {
break;
}
}
if (i == l)
return ml;
}
}
ml = ml->next;
}
return NULL;
}
