consistent 32bit CI error

[Keno]

This seems to have started recently

Error During Test at /tmp/julia/share/julia/test/numbers.jl:2329
  Got exception outside of a @test
  return type Int128 does not match inferred return type Any
  Stacktrace:
   [1] error(::String) at ./error.jl:33
   [2] top-level scope at /tmp/julia/share/julia/test/numbers.jl:2372
   [3] top-level scope at /home/travis/build/JuliaLang/julia/usr/share/julia/stdlib/v1.1/Test/src/Test.jl:1083
   [4] top-level scope at /tmp/julia/share/julia/test/numbers.jl:2330
   [5] include at ./boot.jl:317 [inlined]
   [6] include_relative(::Module, ::String) at ./loading.jl:1038
   [7] include at ./sysimg.jl:29 [inlined]
   [8] include(::String) at /tmp/julia/share/julia/test/testdefs.jl:13
   [9] top-level scope at /tmp/julia/share/julia/test/testdefs.jl:22
   [10] top-level scope at /home/travis/build/JuliaLang/julia/usr/share/julia/stdlib/v1.1/Test/src/Test.jl:1083
   [11] top-level scope at /tmp/julia/share/julia/test/testdefs.jl:21
   [12] top-level scope at util.jl:289
   [13] top-level scope at /tmp/julia/share/julia/test/testdefs.jl:19
   [14] eval at ./boot.jl:319 [inlined]
   [15] #runtests#3(::UInt128, ::Function, ::String, ::String, ::Bool) at /tmp/julia/share/julia/test/testdefs.jl:25
   [16] #runtests at ./none:0 [inlined] (repeats 2 times)
   [17] (::getfield(Distributed, Symbol("##112#114")){Distributed.CallMsg{:call_fetch}})() at /home/travis/build/JuliaLang/julia/usr/share/julia/stdlib/v1.1/Distributed/src/process_messages.jl:269
   [18] run_work_thunk(::getfield(Distributed, Symbol("##112#114")){Distributed.CallMsg{:call_fetch}}, ::Bool) at /home/travis/build/JuliaLang/julia/usr/share/julia/stdlib/v1.1/Distributed/src/process_messages.jl:56
   [19] macro expansion at /home/travis/build/JuliaLang/julia/usr/share/julia/stdlib/v1.1/Distributed/src/process_messages.jl:269 [inlined]
   [20] (::getfield(Distributed, Symbol("##111#113"))

e.g. https://travis-ci.org/JuliaLang/julia/jobs/450035986

[JeffBezanson]

Also https://travis-ci.org/JuliaLang/julia/jobs/450350239

[c42f]

I just got another of these.

[c42f]

This is reproducible for me on an i686 build from a 64 bit ubuntu 18.04 host. The bug reduces to:

julia> Base.return_types(%, (Int8, UInt128))
1-element Array{Any,1}:
 Any

[c42f]

Well, it makes absolutely no sense, but reverting e2f7b2f fixes this for me locally.

[c42f]

More precisely, reverting only the following line seems to fix the problem, but I don't understand why.

diff --git a/base/array.jl b/base/array.jl
index 9e8da6c384..74823710ab 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -272,7 +272,6 @@ function copyto!(dest::Array{T}, doffs::Integer, src::Array{T}, soffs::Integer,
         throw(BoundsError())
     end
     unsafe_copyto!(dest, doffs, src, soffs, n)
-    return dest
 end
 
 # Outlining this because otherwise a catastrophic inference slowdown

Edit: having woken my machine up from sleep state, this one line change no longer "fixes" the problem. Which makes sense if there's something nasty and intermittent going on here. Uninitialized memory read or some such thing, perhaps.

[c42f]

It looks like my machine has fallen out of whatever state it was in which allowed me to reproduce this.

What I did when reproducing was to build 0999799 with ARCH=i686 (on ubuntu 18.04), which gave the return_types failure as stated. Then to revert various recent commits and measure the bug with Revise until I found a change which "fixed" the problem.

This was yesterday, but the build of 0999799 no longer exhibits the problem today. I'll chalk that up to it being intermittent (I don't think it's just me loosing my mind :-) ).

[c42f]

Got another window of reproducibility; it looks like the cached inferred code for rem(::UInt128, ::UInt128) has a return type of Any, which may possibly be the underlying cause though I'm not sure.

Applying the following patch:

diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 01fb88b024..e1912b71da 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -594,6 +594,11 @@ function typeinf_type(method::Method, @nospecialize(atypes), sparams::SimpleVect
             inf = code.inferred
             if !isa(inf, CodeInfo) || (inf::CodeInfo).inferred
                 i == 2 && ccall(:jl_typeinf_end, Cvoid, ())
+                println("typeinf_type code = ", code)
+                println("typeinf_type ", method, " code.rettype = ", code.rettype)
+                println("typeinf_type ", code.inferred)
+                println("typeinf_type ", ccall(:jl_uncompress_ast, Any, (Any, Any), method,
+                                               code.inferred::Vector{UInt8}))
                 return code.rettype
             end
         end

I get the following output:

julia> using Revise; Revise.track(Base.Core.Compiler);

julia> Base.return_types(rem, (UInt128, UInt128))
typeinf_type code = rem(UInt128, UInt128)
typeinf_type Base.rem(...) code.rettype = Any
typeinf_type Array{UInt8, (105,)}[0x08, 0x03, 0x00, 0x00, 0x00, 0x23, 0x73, 0x65, 0x6c, 0x66, 0x23, 0x00, 0x78, 0x00, 0x79, 0x00, 0x16, 0x84, 0xb0, 0xea, 0x09, 0x03, 0x3c, 0x11, 0x02, 0x1d, 0x11, 0x00, 0x05, 0x02, 0x00, 0x09, 0x03, 0x3c, 0x11, 0x02, 0x1d, 0x11, 0x00, 0x05, 0x03, 0x00, 0x2d, 0x1d, 0x85, 0x03, 0x01, 0x03, 0x02, 0x2c, 0x1d, 0x1c, 0xf4, 0x03, 0x03, 0x09, 0x01, 0x3e, 0x03, 0x04, 0x39, 0x16, 0x84, 0xb0, 0xea, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x16, 0x84, 0xac, 0x26, 0x00, 0x2e, 0x2e, 0x20, 0x85, 0x4d, 0x2b, 0x0a, 0x03, 0xab, 0x16, 0x01, 0xb0, 0xf6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x01, 0xae, 0xf6, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01]
typeinf_type Core.CodeInfo(code=Array{Any, (5,)}[
  Expr(:invoke, (::Type{Base.GMP.BigInt})(UInt128), Base.BigInt, Core.SlotNumber(id=2)),
  Expr(:invoke, (::Type{Base.GMP.BigInt})(UInt128), Base.BigInt, Core.SlotNumber(id=3)),
  Expr(:call, Base.rem, SSAValue(1), SSAValue(2)),
  Expr(:call, Base.UInt128, SSAValue(3)),
  Expr(:return, SSAValue(4))], codelocs=Array{Int32, (5,)}[1, 1, 1, 1, 1], method_for_inference_limit_heuristics=nothing, ssavaluetypes=Array{Any, (5,)}[
  Any,
  Any,
  Any,
  Any,
  Any], linetable=Array{Core.LineInfoNode, (1,)}[Core.LineInfoNode(mod=Base, method=:rem, file=Symbol("int.jl"), line=778, inlined_at=0)], ssaflags=Array{UInt8, (5,)}[0x00, 0x00, 0x00, 0x00, 0x00], slotflags=Array{UInt8, (3,)}[0x00, 0x00, 0x00], slotnames=Array{Any, (3,)}[
  Symbol("#self#"),
  :x,
  :y], inferred=true, inlineable=false, propagate_inbounds=false, pure=false)
1-element Array{Any,1}:
 Any

Given these BigInt in here, perhaps this comes down to a weird interaction with the patch in 6fa3e45

[c42f]

Given these BigInt in here, perhaps this comes down to a weird interaction with the patch in 6fa3e45

This would also explain why it's not seen on 64 bit linux, as we don't use GMP for supporting UInt128 in that case.

[c42f]

Here's another oddity - @code_typed and Base.return_types disagree about rem with UInt128:

julia> @code_typed rem(UInt128(1), UInt128(1))
CodeInfo(
778 1 ─ %1 = invoke Base.BigInt(_2::UInt128)::BigInt                  │ 
    │   %2 = invoke Base.BigInt(_3::UInt128)::BigInt                  │ 
    │   %3 = Base.GMP.MPZ.tdiv_r::typeof(tdiv_r)                      │╻ rem
    │   %4 = invoke %3(%1::BigInt, %2::BigInt)::BigInt                ││
    │   %5 = invoke Base.UInt128(%4::BigInt)::UInt128                 │ 
    └──      return %5                                                │ 
) => UInt128

julia> Base.return_types(rem, (UInt128, UInt128))
1-element Array{Any,1}:
 Any