Add wrappers for LLVM's cloning utilities.

Author: maleadt

deps/LLVMExtra/include/LLVMExtra.h

@@ -115,5 +115,21 @@ LLVMTypeRef LLVMGetTypeAttributeValue(LLVMAttributeRef A);
 LLVMBool LLVMIsTypeAttribute(LLVMAttributeRef A);
 #endif
 
+typedef enum {
+  LLVMCloneFunctionChangeTypeLocalChangesOnly = 0,
+  LLVMCloneFunctionChangeTypeGlobalChanges = 1,
+  LLVMCloneFunctionChangeTypeDifferentModule = 2,
+  LLVMCloneFunctionChangeTypeClonedModule = 3
+} LLVMCloneFunctionChangeType;
+
+void LLVMCloneFunctionInto(LLVMValueRef NewFunc, LLVMValueRef OldFunc,
+                           LLVMValueRef *ValueMap, unsigned ValueMapElements,
+                           LLVMCloneFunctionChangeType Changes,
+                           const char *NameSuffix,
+                           LLVMTypeRef (*TypeMapper)(LLVMTypeRef, void *),
+                           void *TypeMapperData,
+                           LLVMValueRef (*Materializer)(LLVMValueRef, void *),
+                           void *MaterializerData);
+
 LLVM_C_EXTERN_C_END
 #endif

deps/LLVMExtra/lib/llvm-api.cpp

@@ -8,6 +8,7 @@
 #include <llvm/IR/Function.h>
 #include <llvm/IR/GlobalValue.h>
 #include <llvm/IR/Instruction.h>
+#include <llvm/IR/Instructions.h>
 #include <llvm/IR/LegacyPassManager.h>
 #include <llvm/IR/Module.h>
 #include <llvm/Support/TargetSelect.h>
@@ -17,6 +18,7 @@
 #if LLVM_VERSION_MAJOR < 12
 #include <llvm/Transforms/Scalar/InstSimplifyPass.h>
 #endif
+#include <llvm/Transforms/Utils/Cloning.h>
 #include <llvm/Transforms/Utils/ModuleUtils.h>
 
 using namespace llvm;
@@ -363,3 +365,52 @@ LLVMBool LLVMIsTypeAttribute(LLVMAttributeRef A) {
   return unwrap(A).isTypeAttribute();
 }
 #endif
+
+class ExternalTypeRemapper : public ValueMapTypeRemapper {
+public:
+  ExternalTypeRemapper(LLVMTypeRef (*fptr)(LLVMTypeRef, void *), void *data)
+      : fptr(fptr), data(data) {}
+
+private:
+  Type *remapType(Type *SrcTy) override {
+    return unwrap(fptr(wrap(SrcTy), data));
+  }
+
+  LLVMTypeRef (*fptr)(LLVMTypeRef, void *);
+  void *data;
+};
+
+class ExternalValueMaterializer : public ValueMaterializer {
+public:
+  ExternalValueMaterializer(LLVMValueRef (*fptr)(LLVMValueRef, void *),
+                            void *data)
+      : fptr(fptr), data(data) {}
+
+private:
+  Value *materialize(Value *V) override { return unwrap(fptr(wrap(V), data)); }
+
+  LLVMValueRef (*fptr)(LLVMValueRef, void *);
+  void *data;
+};
+
+void LLVMCloneFunctionInto(LLVMValueRef NewFunc, LLVMValueRef OldFunc,
+                           LLVMValueRef *ValueMap, unsigned ValueMapElements,
+                           LLVMCloneFunctionChangeType Changes,
+                           const char *NameSuffix,
+                           LLVMTypeRef (*TypeMapper)(LLVMTypeRef, void *),
+                           void *TypeMapperData,
+                           LLVMValueRef (*Materializer)(LLVMValueRef, void *),
+                           void *MaterializerData) {
+  // NOTE: we ignore returns cloned, and don't return the code info
+  SmallVector<ReturnInst *, 8> Returns;
+
+  ValueToValueMapTy VMap;
+  for (unsigned i = 0; i < ValueMapElements; ++i)
+    VMap[unwrap(ValueMap[2 * i])] = unwrap(ValueMap[2 * i + 1]);
+  ExternalTypeRemapper TheTypeRemapper(TypeMapper, TypeMapperData);
+  ExternalValueMaterializer TheMaterializer(Materializer, MaterializerData);
+  CloneFunctionInto(unwrap<Function>(NewFunc), unwrap<Function>(OldFunc), VMap,
+                    Changes, Returns, NameSuffix, nullptr,
+                    TypeMapper ? &TheTypeRemapper : nullptr,
+                    Materializer ? &TheMaterializer : nullptr);
+}

lib/libLLVM_extra.jl

@@ -323,3 +323,14 @@ function LLVMOrcLLJITApplyDataLayout(J, Mod)
 end
 
 end # version
+
+@cenum LLVMCloneFunctionChangeType::UInt32 begin
+    LLVMCloneFunctionChangeTypeLocalChangesOnly = 0
+    LLVMCloneFunctionChangeTypeGlobalChanges = 1
+    LLVMCloneFunctionChangeTypeDifferentModule = 2
+    LLVMCloneFunctionChangeTypeClonedModule = 3
+end
+
+function LLVMCloneFunctionInto(NewFunc, OldFunc, ValueMap, ValueMapElements, Changes, NameSuffix, TypeMapper, TypeMapperData, Materializer, MaterializerData)
+    ccall((:LLVMCloneFunctionInto, libLLVMExtra), Cvoid, (LLVMValueRef, LLVMValueRef, Ptr{LLVMValueRef}, Cuint, LLVMCloneFunctionChangeType, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), NewFunc, OldFunc, ValueMap, ValueMapElements, Changes, NameSuffix, TypeMapper, TypeMapperData, Materializer, MaterializerData)
+end

src/LLVM.jl

@@ -7,8 +7,8 @@ using Libdl
 
 ## source code includes
 
-include("util.jl")
 include("base.jl")
+include("version.jl")
 
 const libllvm = Ref{String}()
 
@@ -60,6 +60,7 @@ include("transform.jl")
 include("debuginfo.jl")
 include("dibuilder.jl")
 include("jitevents.jl")
+include("utils.jl")
 
 has_orc_v1() = v"8" <= LLVM.version() < v"12"
 if has_orc_v1()

src/base.jl

@@ -1,20 +1,67 @@
-# Basic library functionality
-
-export version
-
-version() = Base.libllvm_version
-
-function runtime_version()
-    # FIXME: add a proper C API to LLVM
-    version_print = unsafe_string(
-        ccall((:_ZN4llvm16LTOCodeGenerator16getVersionStringEv, libllvm[]), Cstring, ()))
-    m = match(r"LLVM version (?<version>.+)", version_print)
-    m === nothing && error("Unrecognized version string: '$version_print'")
-    if endswith(m[:version], "jl")
-        # strip the "jl" SONAME suffix (JuliaLang/julia#33058)
-        # (LLVM does never report a prerelease version anyway)
-        VersionNumber(m[:version][1:end-2])
+# helpers for wrapping the library
+
+function unsafe_message(ptr, args...)
+    str = unsafe_string(ptr, args...)
+    API.LLVMDisposeMessage(ptr)
+    str
+end
+
+
+## defining types in the LLVM type hierarchy
+
+# llvm.org/docs/doxygen/html/group__LLVMCSupportTypes.html
+
+# macro that adds an inner constructor to a type definition,
+# calling `refcheck` on the ref field argument
+macro checked(typedef)
+    # decode structure definition
+    if Meta.isexpr(typedef, :macrocall)
+        # handle `@compat` prefixing 0.6-style type declarations
+        typedef = macroexpand(typedef)
+    end
+    if Meta.isexpr(typedef, :struct)
+        structure = typedef.args[2]
+        body = typedef.args[3]
     else
-        VersionNumber(m[:version])
+        error("argument is not a structure definition")
     end
+    if isa(structure, Symbol)
+        # basic type definition
+        typename = structure
+    elseif Meta.isexpr(structure, :<:)
+        # typename <: parentname
+        all(e->isa(e,Symbol), structure.args) ||
+            error("typedef should consist of plain types, ie. not parametric ones")
+        typename = structure.args[1]
+    else
+        error("malformed type definition: cannot decode type name")
+    end
+
+    # decode fields
+    field_names = Symbol[]
+    field_defs = Union{Symbol,Expr}[]
+    for arg in body.args
+        if isa(arg, LineNumberNode)
+            continue
+        elseif isa(arg, Symbol)
+            push!(field_names, arg)
+            push!(field_defs, arg)
+        elseif Meta.isexpr(arg, :(::))
+            push!(field_names, arg.args[1])
+            push!(field_defs, arg)
+        end
+    end
+    :ref in field_names || error("structure definition should contain 'ref' field")
+
+    # insert checked constructor
+    push!(body.args, :(
+        $typename($(field_defs...)) = (refcheck($typename, ref); new($(field_names...)))
+    ))
+
+    return esc(typedef)
+end
+
+# the most basic check is asserting that we don't use a null pointer
+@inline function refcheck(::Type, ref::Ptr)
+    ref==C_NULL && throw(UndefRefError())
 end

src/util.jl

@@ -0,0 +1,70 @@
+# Utilities for working with LLVM source code
+
+## cloning
+
+export clone_into!, clone
+
+type_mapper_callback(typ, type_mapper) =
+    Base.unsafe_convert(API.LLVMTypeRef, type_mapper[](LLVMType(typ)))
+materializer_callback(val, materializer) =
+    Base.unsafe_convert(API.LLVMValueRef, materializer[](Value(val)))
+
+function clone_into!(new::Function, old::Function;
+                     value_map::Dict{Value,Value}=Dict{Value,Value}(),
+                     changes=API.LLVMCloneFunctionChangeTypeLocalChangesOnly,
+                     suffix::String="", type_mapper=nothing, materializer=nothing)
+    value_map_array = Value[]
+    for (src, dest) in value_map
+        push!(value_map_array, src)
+        push!(value_map_array, dest)
+    end
+    if type_mapper === nothing
+        type_mapper_ptr = C_NULL
+        type_mapper_data = C_NULL
+    else
+        type_mapper_ptr = @cfunction(type_mapper_callback, API.LLVMTypeRef, (API.LLVMTypeRef,Any))
+        type_mapper_data = Ref(type_mapper)
+    end
+    if materializer === nothing
+        materializer_ptr = C_NULL
+        materializer_data = C_NULL
+    else
+        materializer_ptr = @cfunction(materializer_callback, API.LLVMValueRef, (API.LLVMValueRef,Any))
+        materializer_data = Ref(materializer)
+    end
+    API.LLVMCloneFunctionInto(new, old, value_map_array, length(value_map), changes, suffix,
+                              type_mapper_ptr, type_mapper_data,
+                              materializer_ptr, materializer_data)
+end
+
+function clone(f::Function; value_map::Dict{Value,Value}=Dict{Value,Value}())
+    argtypes = LLVMType[]
+
+    # The user might be deleting arguments to the function by specifying them in
+    # the VMap.  If so, we need to not add the arguments to the arg ty vector
+    for arg in parameters(f)
+        if !in(arg, keys(value_map))    # Haven't mapped the argument to anything yet?
+            push!(argtypes, llvmtype(arg))
+        end
+    end
+
+    # Create a new function type...
+    fty = FunctionType(return_type(eltype(llvmtype(f))), argtypes)   # TODO: isVarArg
+
+    # Create the new function...
+    new_f = Function(parent(f), name(f), fty)
+    # TODO: address space, linkage
+
+    # Loop over the arguments, copying the names of the mapped arguments over...
+    for (arg, new_arg) in zip(parameters(f), parameters(new_f))
+        if !in(arg, keys(value_map))    # Is this argument preserved?
+            name!(new_arg, name(arg))   # Copy the name over...
+            value_map[arg] = new_arg    # Add mapping to VMap
+        end
+    end
+
+    clone_into!(new_f, f;
+                value_map, changes=API.LLVMCloneFunctionChangeTypeLocalChangesOnly)
+
+   return new_f
+end

src/utils.jl

@@ -0,0 +1,20 @@
+# Version management
+
+export version
+
+version() = Base.libllvm_version
+
+function runtime_version()
+    # FIXME: add a proper C API to LLVM
+    version_print = unsafe_string(
+        ccall((:_ZN4llvm16LTOCodeGenerator16getVersionStringEv, libllvm[]), Cstring, ()))
+    m = match(r"LLVM version (?<version>.+)", version_print)
+    m === nothing && error("Unrecognized version string: '$version_print'")
+    if endswith(m[:version], "jl")
+        # strip the "jl" SONAME suffix (JuliaLang/julia#33058)
+        # (LLVM does never report a prerelease version anyway)
+        VersionNumber(m[:version][1:end-2])
+    else
+        VersionNumber(m[:version])
+    end
+end

src/version.jl

@@ -18,7 +18,7 @@ using Test
 #       because the context has been disposed already. avoid that by disabling `dispose`
 LLVM.dispose(::Context) = return
 
-include("util.jl")
+include("helpers.jl")
 
 @testset "types" begin
     @test convert(Bool, LLVM.True) == true
@@ -71,6 +71,7 @@ include("target.jl")
 include("targetmachine.jl")
 include("datalayout.jl")
 include("debuginfo.jl")
+include("utils.jl")
 if LLVM.has_orc_v1()
     include("orc.jl")
 end