Codegen introspection misleading for`atomic_max!`

[jakobnissen]

On 1.12-rc2

julia> @code_llvm debuginfo=:none Threads.atomic_max!(Threads.Atomic{Int}(0), 1)
; Function Signature: atomic_max!(Base.Threads.Atomic{Int64}, Int64)
define i64 @"julia_atomic_max!_3804"(ptr noundef nonnull align 8 dereferenceable(8) %"x::Atomic", i64 signext %"v::Int64") #0 {
top:
  %rv.i = atomicrmw max ptr %"x::Atomic", i64 %"v::Int64" acq_rel, align 8
  ret i64 %rv.i
}

On master:

julia> @code_llvm debuginfo=:none Threads.atomic_max!(Threads.Atomic{Int}(0), 1)
; Function Signature: atomic_max!(Base.Threads.Atomic{Int64}, Int64)
define i64 @"julia_atomic_max!_1385"(ptr noundef nonnull align 8 dereferenceable(8) %"x::Atomic", i64 signext %"v::Int64") local_unnamed_addr #0 {
top:
  %0 = load atomic i64, ptr %"x::Atomic" unordered, align 8
  br label %atomicrmw.start

atomicrmw.start:                                  ; preds = %atomicrmw.start, %top
  %loaded = phi i64 [ %0, %top ], [ %newloaded, %atomicrmw.start ]
  %1 = call fastcc i64 @j_max_1387(i64 signext %loaded, i64 signext %"v::Int64")
  %2 = cmpxchg ptr %"x::Atomic", i64 %loaded, i64 %1 acq_rel monotonic, align 8
  %success = extractvalue { i64, i1 } %2, 1
  %newloaded = extractvalue { i64, i1 } %2, 0
  br i1 %success, label %atomicrmw.end, label %atomicrmw.start

atomicrmw.end:                                    ; preds = %atomicrmw.start
  ret i64 %newloaded
}

The generated native (x86-64) code is also worse.
Possibly caused by #57010

[vtjnash]

hmm, something is going wrong with the code_llvm emulation. the native code being used looks fine:

julia> @code_native dump_module=false debuginfo=:none Threads.atomic_max!(Threads.Atomic{Int}(0), 1)
	stp	x29, x30, [sp, #-16]!
	mov	x29, sp
	ldr	x8, [x20, #16]
	ldr	x8, [x8, #16]
	ldr	xzr, [x8]
	ldsmaxal	x1, x0, [x0]
	ldp	x29, x30, [sp], #16
	ret

[gbaraldi]

code_llvm raw=true gets it right

[jakobnissen]

Ah you're right, the native code "regression" I saw was for the @atomic case, which is not as efficient as atomic_max! even after #57010:

julia> mutable struct Foo
           @atomic x::Int
       end
       f(x, i) = (@atomic :monotonic max(x.x, i); nothing);

julia> x = Foo(1);

julia> @code_native f(x, 2)

I'm not sure if this is expected, or an oversight in #57010

[vtjnash]

code_native emulates what it predicts the JIT will do, just like code_llvm. dump_module=false shows what actually runs:

julia> @code_native dump_module=false f(x, 2)
...
	ldsmax	x1, x8, [x0]
...