Merge pull request #27898 from JuliaLang/jn/codegen-fixes

some fixes for compilation

Author: vtjnash

base/generator.jl

@@ -41,9 +41,10 @@ Generator(::Type{T}, I1, I2, Is...) where {T} = Generator(a->T(a...), zip(I1, I2
 
 function iterate(g::Generator, s...)
     @_inline_meta
-    y = iterate(g.iter, s...)::Union{Tuple{Any, Any}, Nothing}
+    y = iterate(g.iter, s...)
     y === nothing && return nothing
-    g.f(y[1]), y[2]
+    y = y::Tuple{Any, Any} # try to give inference some idea of what to expect about the behavior of the next line
+    return (g.f(y[1]), y[2])
 end
 
 length(g::Generator) = length(g.iter)

src/codegen.cpp

@@ -4209,8 +4209,7 @@ static void emit_cfunc_invalidate(
         break;
     }
     case jl_returninfo_t::SRet: {
-        unsigned sret_nbytes = jl_datatype_size(astrt);
-        emit_memcpy(ctx, &*gf_thunk->arg_begin(), nullptr, gf_ret, nullptr, sret_nbytes, jl_alignment(sret_nbytes));
+        emit_memcpy(ctx, &*gf_thunk->arg_begin(), nullptr, gf_ret, nullptr, jl_datatype_size(astrt), julia_alignment(astrt, 0));
         ctx.builder.CreateRetVoid();
         break;
     }

src/dump.c

@@ -710,8 +710,9 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v, int as_li
             jl_serialize_value(s, jl_nothing);
         else
             jl_serialize_value(s, (jl_value_t*)m->ambig);
-        write_int8(s->s, m->called);
+        write_int32(s->s, m->called);
         write_int32(s->s, m->nargs);
+        write_int32(s->s, m->nospecialize);
         write_int8(s->s, m->isva);
         write_int8(s->s, m->pure);
         jl_serialize_value(s, (jl_value_t*)m->module);
@@ -1563,7 +1564,7 @@ static jl_value_t *jl_deserialize_value_method(jl_serializer_state *s, jl_value_
     jl_method_t *m =
         (jl_method_t*)jl_gc_alloc(s->ptls, sizeof(jl_method_t),
                                   jl_method_type);
-    memset(m, 0, sizeof(jl_method_type));
+    memset(m, 0, sizeof(jl_method_t));
     uintptr_t pos = backref_list.len;
     if (usetable)
         arraylist_push(&backref_list, m);
@@ -1585,8 +1586,9 @@ static jl_value_t *jl_deserialize_value_method(jl_serializer_state *s, jl_value_
     m->min_world = jl_world_counter;
     m->ambig = jl_deserialize_value(s, (jl_value_t**)&m->ambig);
     jl_gc_wb(m, m->ambig);
-    m->called = read_int8(s->s);
+    m->called = read_int32(s->s);
     m->nargs = read_int32(s->s);
+    m->nospecialize = read_int32(s->s);
     m->isva = read_int8(s->s);
     m->pure = read_int8(s->s);
     m->module = (jl_module_t*)jl_deserialize_value(s, (jl_value_t**)&m->module);

src/gf.c

@@ -601,7 +601,7 @@ static void jl_compilation_sig(
     for (i = 0; i < np; i++) {
         jl_value_t *elt = jl_tparam(tt, i);
         jl_value_t *decl_i = jl_nth_slot_type(decl, i);
-        size_t i_arg = (i <= nargs ? i : nargs);
+        size_t i_arg = (i < nargs - 1 ? i : nargs - 1);
 
         if (jl_is_kind(decl_i)) {
             // if we can prove the match was against the kind (not a Type)
@@ -792,35 +792,35 @@ JL_DLLEXPORT int jl_isa_compileable_sig(
     if (!jl_is_datatype(type) || jl_has_free_typevars((jl_value_t*)type))
         return 0;
 
+    size_t i, np = jl_nparams(type);
+    size_t nargs = definition->nargs; // == jl_field_count(jl_unwrap_unionall(decl));
+    if (np == 0)
+        return nargs == 0;
+    if (jl_is_vararg_type(jl_tparam(type, np - 1))) {
+        if (!definition->isva || np <= nargs)
+            return 0;
+    }
+    else if (definition->isva ? np != nargs : np < nargs) {
+        return 0;
+    }
+
     if (definition->generator) {
         // staged functions aren't optimized
         // so assume the caller was intelligent about calling us
         return type->isdispatchtuple;
     }
 
-    size_t i, np = jl_nparams(type);
-    size_t nargs = definition->nargs; // == jl_field_count(jl_unwrap_unionall(decl));
-    if (definition->isva ? np <= nargs : np != nargs)
-        return 0;
     for (i = 0; i < np; i++) {
         jl_value_t *elt = jl_tparam(type, i);
         jl_value_t *decl_i = jl_nth_slot_type((jl_value_t*)decl, i);
-        size_t i_arg = (i <= nargs ? i : nargs);
+        size_t i_arg = (i < nargs - 1 ? i : nargs - 1);
 
         if (jl_is_vararg_type(elt)) { // varargs are always considered compilable
             if (!jl_has_free_typevars(elt))
                 continue;
             return 0;
         }
 
-        if (jl_is_kind(elt)) {
-            // kind slots always get guard entries (checking for subtypes of Type)
-            if (decl_i == elt || jl_subtype((jl_value_t*)jl_type_type, decl_i))
-                continue;
-            // TODO: other code paths that could reach here
-            return 0;
-        }
-
         if (i_arg > 0 && i_arg <= sizeof(definition->nospecialize) * 8 &&
                 (definition->nospecialize & (1 << (i_arg - 1)))) {
             if (decl_i == (jl_value_t*)jl_any_type) {
@@ -836,6 +836,14 @@ JL_DLLEXPORT int jl_isa_compileable_sig(
             // TODO: handle @nospecialize with other declared types
         }
 
+        if (jl_is_kind(elt)) {
+            // kind slots always get guard entries (checking for subtypes of Type)
+            if (decl_i == elt || jl_subtype((jl_value_t*)jl_type_type, decl_i))
+                continue;
+            // TODO: other code paths that could reach here
+            return 0;
+        }
+
         if (jl_is_type_type(elt)) {
             // if the declared type was not Any or Union{Type, ...},
             // then the match must been with kind, such as UnionAll or DataType,