Name LLVM variables from codegen (JuliaLang#50094)

fingolfin · Jun 20, 2023 · 0da46e2 · 0da46e2
1 parent 427b123
commit 0da46e2
Show file tree

Hide file tree

Showing 9 changed files with 506 additions and 112 deletions.
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
@@ -305,6 +305,7 @@ void *jl_create_native_impl(jl_array_t *methods, LLVMOrcThreadSafeModuleRef llvm
     jl_codegen_params_t params(ctxt, std::move(target_info.first), std::move(target_info.second));
     params.params = cgparams;
     params.imaging = imaging;
+    params.debug_level = jl_options.debug_level;
     params.external_linkage = _external_linkage;
     size_t compile_for[] = { jl_typeinf_world, _world };
     for (int worlds = 0; worlds < 2; worlds++) {
@@ -2082,6 +2083,16 @@ void jl_get_llvmf_defn_impl(jl_llvmf_dump_t* dump, jl_method_instance_t *mi, siz
         jl_codegen_params_t output(*ctx, std::move(target_info.first), std::move(target_info.second));
         output.world = world;
         output.params = &params;
+        output.imaging = imaging_default();
+        // This would be nice, but currently it causes some assembly regressions that make printed output
+        // differ very significantly from the actual non-imaging mode code.
+        // // Force imaging mode for names of pointers
+        // output.imaging = true;
+        // This would also be nice, but it seems to cause OOMs on the windows32 builder
+        // // Force at least medium debug info for introspection
+        // No debug info = no variable names,
+        // max debug info = llvm.dbg.declare/value intrinsics which clutter IR output
+        output.debug_level = jl_options.debug_level;
         auto decls = jl_emit_code(m, mi, src, jlrettype, output);
         JL_UNLOCK(&jl_codegen_lock); // Might GC
 

diff --git a/src/ccall.cpp b/src/ccall.cpp
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
diff --git a/src/codegen.cpp b/src/codegen.cpp
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
@@ -195,6 +195,8 @@ static jl_callptr_t _jl_compile_codeinst(
     jl_codegen_params_t params(std::move(context), jl_ExecutionEngine->getDataLayout(), jl_ExecutionEngine->getTargetTriple()); // Locks the context
     params.cache = true;
     params.world = world;
+    params.imaging = imaging_default();
+    params.debug_level = jl_options.debug_level;
     jl_workqueue_t emitted;
     {
         orc::ThreadSafeModule result_m =
@@ -358,6 +360,8 @@ int jl_compile_extern_c_impl(LLVMOrcThreadSafeModuleRef llvmmod, void *p, void *
         return std::make_pair(M.getDataLayout(), Triple(M.getTargetTriple()));
     });
     jl_codegen_params_t params(into->getContext(), std::move(target_info.first), std::move(target_info.second));
+    params.imaging = imaging_default();
+    params.debug_level = jl_options.debug_level;
     if (pparams == NULL)
         pparams = &params;
     assert(pparams->tsctx.getContext() == into->getContext().getContext());

diff --git a/src/jitlayers.h b/src/jitlayers.h
@@ -237,6 +237,7 @@ typedef struct _jl_codegen_params_t {
     bool cache = false;
     bool external_linkage = false;
     bool imaging;
+    int debug_level;
     _jl_codegen_params_t(orc::ThreadSafeContext ctx, DataLayout DL, Triple triple)
         : tsctx(std::move(ctx)), tsctx_lock(tsctx.getLock()),
             DL(std::move(DL)), TargetTriple(std::move(triple)), imaging(imaging_default()) {}

diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
@@ -519,29 +519,34 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
 
     # -g
     @test readchomp(`$exename -E "Base.JLOptions().debug_level" -g`) == "2"
-    let code = writereadpipeline("code_llvm(stdout, +, (Int64, Int64), raw=true, dump_module=true)", `$exename -g0`)
-        @test code[2]
-        code = code[1]
-        @test occursin("llvm.module.flags", code)
-        @test !occursin("llvm.dbg.cu", code)
-        @test !occursin("int.jl", code)
-        @test !occursin("Int64", code)
-    end
-    let code = writereadpipeline("code_llvm(stdout, +, (Int64, Int64), raw=true, dump_module=true)", `$exename -g1`)
-        @test code[2]
-        code = code[1]
-        @test occursin("llvm.module.flags", code)
-        @test occursin("llvm.dbg.cu", code)
-        @test occursin("int.jl", code)
-        @test !occursin("Int64", code)
-    end
-    let code = writereadpipeline("code_llvm(stdout, +, (Int64, Int64), raw=true, dump_module=true)", `$exename -g2`)
-        @test code[2]
-        code = code[1]
-        @test occursin("llvm.module.flags", code)
-        @test occursin("llvm.dbg.cu", code)
-        @test occursin("int.jl", code)
-        @test occursin("\"Int64\"", code)
+    # --print-before/--print-after with pass names is broken on Windows due to no-gnu-unique issues
+    if !Sys.iswindows()
+        withenv("JULIA_LLVM_ARGS" => "--print-before=FinalLowerGC") do
+            let code = readchomperrors(`$exename -g0 -E "@eval Int64(1)+Int64(1)"`)
+                @test code[1]
+                code = code[3]
+                @test occursin("llvm.module.flags", code)
+                @test !occursin("llvm.dbg.cu", code)
+                @test !occursin("int.jl", code)
+                @test !occursin("\"Int64\"", code)
+            end
+            let code = readchomperrors(`$exename -g1 -E "@eval Int64(1)+Int64(1)"`)
+                @test code[1]
+                code = code[3]
+                @test occursin("llvm.module.flags", code)
+                @test occursin("llvm.dbg.cu", code)
+                @test occursin("int.jl", code)
+                @test !occursin("\"Int64\"", code)
+            end
+            let code = readchomperrors(`$exename -g2 -E "@eval Int64(1)+Int64(1)"`)
+                @test code[1]
+                code = code[3]
+                @test occursin("llvm.module.flags", code)
+                @test occursin("llvm.dbg.cu", code)
+                @test occursin("int.jl", code)
+                @test occursin("\"Int64\"", code)
+            end
+        end
     end
 
     # --check-bounds

diff --git a/test/llvmpasses/llvmcall.jl b/test/llvmpasses/llvmcall.jl
@@ -13,20 +13,109 @@ end
 @generated foo(x)=:(ccall("extern foo", llvmcall, $x, ($x,), x))
 bar(x) = ntuple(i -> VecElement{Float16}(x[i]), 2)
 
-# CHECK: call half @foo(half %{{[0-9]+}})
+# CHECK: define
+# CHECK-SAME: half @julia_foo
+# CHECK-SAME: {
+# CHECK-NOT: define
+# CHECK: [[FOO_RET:%.*]] = call half @foo(half [[FOO_ARG:%.*]])
+# CHECK-NOT: define
+# CHECK: ret half
+# CHECK-NOT: define
+# CHECK: }
 emit(foo, Float16)
 
-# CHECK: call [2 x half] @foo([2 x half] %{{[0-9]+}})
+# COM: Make sure that we don't miss a function by accident (helps localize errors)
+# CHECK-NOT: {
+# CHECK-NOT: }
+# CHECK: define
+# CHECK-SAME: nonnull {} addrspace(10)* @jfptr
+# CHECK-SAME: {
+
+# CHECK: define
+# CHECK-SAME: [2 x half] @julia_foo
+# CHECK-SAME: {
+# CHECK-NOT: define
+# CHECK: [[FOO_RET:%.*]] = call [2 x half] @foo([2 x half] [[FOO_ARG:%.*]])
+# CHECK-NOT: define
+# CHECK: ret [2 x half]
+# CHECK-NOT: define
+# CHECK: }
 emit(foo, NTuple{2, Float16})
 
-# CHECK: call <2 x half> @foo(<2 x half> %{{[0-9]+}})
+# COM: Make sure that we don't miss a function by accident (helps localize errors)
+# CHECK-NOT: {
+# CHECK-NOT: }
+# CHECK: define
+# CHECK-SAME: nonnull {} addrspace(10)* @jfptr
+# CHECK-SAME: {
+
+# CHECK: define
+# CHECK-SAME: <2 x half> @julia_foo
+# CHECK-SAME: {
+# CHECK-NOT: define
+# CHECK: [[FOO_RET:%.*]] call <2 x half> @foo(<2 x half> [[FOO_ARG:%.*]])
+# CHECK-NOT: define
+# CHECK: ret <2 x half>
+# CHECK-NOT: define
+# CHECK: }
 emit(foo, NTuple{2, VecElement{Float16}})
 
-# CHECK: call i8 addrspace(3)* @foo(i8 addrspace(3)* %{{[0-9]+}})
+# COM: Make sure that we don't miss a function by accident (helps localize errors)
+# CHECK-NOT: {
+# CHECK-NOT: }
+# CHECK: define
+# CHECK-SAME: nonnull {} addrspace(10)* @jfptr
+# CHECK-SAME: {
+
+# CHECK: define
+# CHECK-SAME: i8 addrspace(3)* @julia_foo
+# CHECK-SAME: {
+# CHECK-NOT: define
+# CHECK: [[FOO_RET:%.*]] call i8 addrspace(3)* @foo(i8 addrspace(3)* [[FOO_ARG:%.*]])
+# CHECK-NOT: define
+# CHECK: ret i8 addrspace(3)*
+# CHECK-NOT: define
+# CHECK: }
 emit(foo, Core.LLVMPtr{Float32, 3})
 
-# CHECK: call { i32, i32 } @foo({ i32, i32 } %{{[0-9]+}})
+# COM: Make sure that we don't miss a function by accident (helps localize errors)
+# CHECK-NOT: {
+# CHECK-NOT: }
+# CHECK: define
+# CHECK-SAME: nonnull {} addrspace(10)* @jfptr
+# CHECK-SAME: {
+
+# CHECK: define
+# CHECK-SAME: [2 x i32] @julia_foo
+# CHECK-SAME: {
+# CHECK-NOT: define
+# CHECK: [[FOO_RET:%.*]] call { i32, i32 } @foo({ i32, i32 } [[FOO_ARG:%.*]])
+# CHECK-NOT: define
+# CHECK: ret [2 x i32]
+# CHECK-NOT: define
+# CHECK: }
 emit(foo, Foo)
 
-# CHECK: define {{(swiftcc )?}}<2 x half> @julia_bar_{{[0-9]+}}(
+# COM: Make sure that we don't miss a function by accident (helps localize errors)
+# CHECK-NOT: {
+# CHECK-NOT: }
+# CHECK: define
+# CHECK-SAME: nonnull {} addrspace(10)* @jfptr
+# CHECK-SAME: {
+
+# CHECK: define
+# CHECK-SAME: <2 x half> @julia_bar
+# CHECK-SAME: [2 x half]
+# CHECK-SAME: {
+# CHECK-NOT: define
+# CHECK: ret <2 x half>
+# CHECK-NOT: define
+# CHECK: }
 emit(bar, NTuple{2, Float16})
+
+# COM: Make sure that we don't miss a function by accident (helps localize errors)
+# CHECK-NOT: {
+# CHECK-NOT: }
+# CHECK: define
+# CHECK-SAME: nonnull {} addrspace(10)* @jfptr
+# CHECK-SAME: {