opaque ptr err

Author: wsmoses

src/Enzyme.jl

@@ -135,6 +135,19 @@ function guess_activity end
 mutable struct EnzymeContext
 end
 
+struct OpaquePointerError
+    msg::String
+end
+
+function Base.showerror(io::IO, ece::OpaquePointerError)
+    if isdefined(Base.Experimental, :show_error_hints)
+        Base.Experimental.show_error_hints(io, ece)
+    end
+    print(io, "OpaquePointerError: Enzyme execution failed to handle opaque pointers, with the following information:\n")
+    print(io, ece.msg, '\n')
+end
+
+
 include("logic.jl")
 include("analyses/type.jl")
 include("typetree.jl")

src/compiler.jl

@@ -32,6 +32,8 @@ import Enzyme:
     add_edge!
 using Enzyme
 
+import Enzyme: OpaquePointerError
+
 import EnzymeCore
 import EnzymeCore: EnzymeRules, ABI, FFIABI, DefaultABI
 
@@ -3779,7 +3781,13 @@ function lower_convention(
                 push!(wrapper_types, typ)
                 push!(wrapper_attrs, LLVM.Attribute[EnumAttribute("noalias")])
             else
-                push!(wrapper_types, eltype(typ))
+
+                elty = convert(LLVMType, arg.typ)
+                if !LLVM.is_opaque(typ)
+                    @assert elty == eltype(typ)
+                end
+
+                push!(wrapper_types, elty)
                 push!(wrapper_attrs, LLVM.Attribute[])
                 push!(loweredArgs, arg.arg_i)
             end
@@ -3941,7 +3949,13 @@ function lower_convention(
                         ),
                     )
                 end
-                ptr = alloca!(builder, eltype(ty), LLVM.name(parm) * ".innerparm")
+
+                elty = convert(LLVMType, arg.typ)
+                if !LLVM.is_opaque(ty)
+                    @assert elty == eltype(ty)
+                end
+
+                ptr = alloca!(builder, elty, LLVM.name(parm) * ".innerparm")
                 if TT !== nothing && TT.parameters[arg.arg_i] <: Const
                     metadata(ptr)["enzyme_inactive"] = MDNode(LLVM.Metadata[])
                 end

src/errors.jl

@@ -82,18 +82,6 @@ function code_typed_helper(mi::Core.MethodInstance, world::UInt, mode::Enzyme.AP
     end
 end
 
-struct OpaquePointerError <: EnzymeError
-    msg::String
-end
-
-function Base.showerror(io::IO, ece::OpaquePointerError)
-    if isdefined(Base.Experimental, :show_error_hints)
-        Base.Experimental.show_error_hints(io, ece)
-    end
-    print(io, "OpaquePointerError: Enzyme execution failed to handle opaque pointers, with the following information:\n")
-    print(io, ece.msg, '\n')
-end
-
 struct EnzymeRuntimeException <: EnzymeError
     msg::Cstring
 end

src/utils.jl

@@ -500,7 +500,33 @@ export typed_fieldoffset
 
 # returns the inner type of an sret/enzyme_sret/enzyme_sret_v
 function sret_ty(fn::LLVM.Function, idx::Int)::LLVM.LLVMType
-    return eltype(LLVM.value_type(LLVM.parameters(fn)[idx]))
+
+    vt = LLVM.value_type(LLVM.parameters(fn)[idx])
+
+
+    for attr in collect(parameter_attributes(fn, idx))
+        ekind = LLVM.kind(attr)
+        
+        if ekind == "sret"
+            return value(attr)
+        end
+
+        if ekind == "enzyme_sret" || ekind == "enzyme_sret_v"
+            if LLVM.is_opaque(vt)
+                msg = sprint() do io
+                    println(io, "Failed to get sret type of function\n")
+                    println(io, "idx = ", string(idx))
+                    println(io, "vt = ", string(vt))
+                    println(io, "fn = ", string(fn))
+                end
+                throw(OpaquePointerError(msg))
+            end
+        
+            return eltype(vt)
+        end
+    end
+
+    throw(AssertionError("Function requesting sret type was not an sret"))
 end
 
 export sret_ty