[llvm] Propagate nonnull attribute through LLVM IR #13697

alexanderkyte · 2019-03-27T18:28:30Z

Summary

This change allows LLVM to identify unnecessary null checks. We mark GOT accesses (including those made by LDSTR) and new object calls as nonnull.

Since LLVM won't propagate this, we propagate from definition to usage, across casts, and from usage to definition (conditionally).

This enables it to remove a significant portion of some benchmarks.

In real-world code, we can expect to see this remove the unnecessary null checks made by private methods.

Example

C#:

Note that the constant strings are trivially non-null. This PR spots and propagates that.


   static void ThrowIfNull(string s)
    {
        if (s == null)
            ThrowArgumentNullException();
    }

    static void ThrowArgumentNullException()
    {
        throw new ArgumentNullException();
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    static int Bench(string a, string b, string c, string d)
    {
        ThrowIfNull(a);
        ThrowIfNull(b);
        ThrowIfNull(c);
        ThrowIfNull(d);

        return a.Length + b.Length + c.Length + d.Length;
    }

    [Benchmark(Description = nameof(NoThrowInline))]
    public int Test() => Bench("a", "bc", "def", "ghij");

Before:


define hidden monocc i32 @NoThrowInline_MainClass_Bench_string_string_string_string(i64*  %arg_a, i64* %arg_b, i64* %arg_c, i64*  %arg_d) #6 gc "mono" {
BB0:
  br label %INIT_BB1

INIT_BB1:                                         ; preds = %BB0
  br label %INITED_BB2

INITED_BB2:                                       ; preds = %INIT_BB1
  br label %BB3

BB3:                                              ; preds = %INITED_BB2
  br label %BB2

BB2:                                              ; preds = %BB3
  notail call monocc void @NoThrowInline_MainClass_ThrowIfNull_string(i64* %arg_a)
  notail call monocc void @NoThrowInline_MainClass_ThrowIfNull_string(i64* %arg_b)
  notail call monocc void @NoThrowInline_MainClass_ThrowIfNull_string(i64* %arg_c)
  notail call monocc void @NoThrowInline_MainClass_ThrowIfNull_string(i64* %arg_d)
  %0 = bitcast i64* %arg_a to i32*
  %1 = getelementptr i32, i32* %0, i32 4
  %t50 = load volatile i32, i32* %1
  %2 = bitcast i64* %arg_b to i32*
  %3 = getelementptr i32, i32* %2, i32 4
  %t52 = load volatile i32, i32* %3
  %t53 = add i32 %t50, %t52
  %4 = bitcast i64* %arg_c to i32*
  %5 = getelementptr i32, i32* %4, i32 4
  %t55 = load volatile i32, i32* %5
  %t56 = add i32 %t53, %t55
  %6 = bitcast i64* %arg_d to i32*
  %7 = getelementptr i32, i32* %6, i32 4
  %t58 = load volatile i32, i32* %7
  %t60 = add i32 %t56, %t58
  br label %BB1

BB1:                                              ; preds = %BB2
  ret i32 %t60
}

After:

Note: safepoint in below code is added by backend, not part of this change


define hidden monocc i32 @NoThrowInline_MainClass_Bench_string_string_string_string(i64* nonnull %arg_a, i64* nonnull %arg_b, i64* nonnull %arg_c, i64* nonnull %arg_d) #6 gc "mono" {
BB0:
  %0 = getelementptr i64, i64* %arg_a, i64 2
  %1 = bitcast i64* %0 to i32*
  %t50 = load volatile i32, i32* %1, align 4
  %2 = getelementptr i64, i64* %arg_b, i64 2
  %3 = bitcast i64* %2 to i32*
  %t52 = load volatile i32, i32* %3, align 4
  %t53 = add i32 %t52, %t50
  %4 = getelementptr i64, i64* %arg_c, i64 2
  %5 = bitcast i64* %4 to i32*
  %t55 = load volatile i32, i32* %5, align 4
  %t56 = add i32 %t53, %t55
  %6 = getelementptr i64, i64* %arg_d, i64 2
  %7 = bitcast i64* %6 to i32*
  %t58 = load volatile i32, i32* %7, align 4
  %t60 = add i32 %t56, %t58
  %8 = load i64*, i64** getelementptr inbounds ([37 x i64*], [37 x i64*]* @mono_aot_NoThrowInline_llvm_got, i64 0, i64 7), align 8
  %9 = load i64, i64* %8, align 4
  %10 = icmp eq i64 %9, 0
  br i1 %10, label %gc.safepoint_poll.exit, label %gc.safepoint_poll.poll.i

gc.safepoint_poll.poll.i:                         ; preds = %BB0
  %11 = load void ()*, void ()** bitcast (i64** getelementptr inbounds ([37 x i64*], [37 x i64*]* @mono_aot_NoThrowInline_llvm_got, i64 0, i64 25) to void ()**), align 8
  call void %11() #8
  br label %gc.safepoint_poll.exit

gc.safepoint_poll.exit:                           ; preds = %BB0, %gc.safepoint_poll.poll.i
  ret i32 %t60
}

Dependencies

This depends on dotnet/linker#528.

TODO:

Add usage to Wasm so tested
Add unit tests
Benchmark change with [dotnet/performance] Benchmarking Results and Reproduction Steps #13104

mono/mini/mini-llvm.c

mcs/class/corlib/Mono/Codegen.cs

lambdageek · 2019-03-27T20:32:31Z

mono/mini/aot-compiler.c

Maybe check the namespace, too. "Reflected" might be a pretty common name for attributes.

Why not to use existing System.Runtime.CompilerServices.MethodImpl attribute with NoOptimization flag instead which this logic should honour anyway?

Interesting. We don't seem to actually use that attribute at all right now outside of monodis.

https://gist.github.com/alexanderkyte/357ac0e85b37b078b17c511da154c473

I guess my concern was that by adding this attribute to a method, we would disable other optimizations.

I can definitely re-use it if that's the case though.

alexanderkyte · 2019-03-28T17:30:24Z

Wow Github really mis-orders commits

mono/mini/mini-llvm.c

alexanderkyte · 2019-04-03T19:38:31Z

Added support to the linker to remove the attribute, so we don't bloat binary sizes.

https://gist.github.com/alexanderkyte/84be1514a9c86c5223cd3ff3a2be265f

alexanderkyte · 2019-04-05T19:25:50Z

Waiting on dotnet/linker#506 to bump this

Due to issues discussed here, this pass needs to be disabled for the change to be incorporated in the bump. dotnet/linker#541

akoeplinger · 2019-04-24T14:49:08Z

@monojenkins commit csproj

alexanderkyte added do-not-merge epic: LLVM CodeGen Quality labels Mar 27, 2019

alexanderkyte requested review from BrzVlad, lewurm and vargaz March 27, 2019 18:28

alexanderkyte requested review from akoeplinger, lambdageek, marek-safar and thaystg as code owners March 27, 2019 18:28

alexanderkyte changed the title ~~[do-not-merge][NeedsReview][llvm] Propagate nonnull attribute through LLVM IR~~ [do-not-merge/multi-repo][needs-review][llvm] Propagate nonnull attribute through LLVM IR Mar 27, 2019

alexanderkyte mentioned this pull request Mar 27, 2019

Annotate private methods kept because of reflection dotnet/linker#506

Closed