Merge pull request #269 from maleadt/tb/operand_bundles

Add support for inspecting and creating operand bundles.

Author: maleadt

Manifest.toml

@@ -34,9 +34,9 @@ version = "1.3.0"
 
 [[LLVMExtra_jll]]
 deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
-git-tree-sha1 = "9c360e5ce980b88bb31a7b086dbb19469008154b"
+git-tree-sha1 = "6a2af408fe809c4f1a54d2b3f188fdd3698549d6"
 uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab"
-version = "0.0.10+0"
+version = "0.0.11+0"
 
 [[LibCURL]]
 deps = ["LibCURL_jll", "MozillaCACerts_jll"]

Project.toml

@@ -11,5 +11,5 @@ Unicode = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
 
 [compat]
 CEnum = "0.2, 0.3, 0.4"
-LLVMExtra_jll = "~0.0.10"
+LLVMExtra_jll = "~0.0.11"
 julia = "1.6"

deps/LLVMExtra/include/LLVMExtra.h

@@ -135,5 +135,27 @@ void LLVMFunctionDeleteBody(LLVMValueRef Func);
 
 void LLVMDestroyConstant(LLVMValueRef Const);
 
+// operand bundles
+typedef struct LLVMOpaqueOperandBundleUse *LLVMOperandBundleUseRef;
+unsigned LLVMGetNumOperandBundles(LLVMValueRef Instr);
+LLVMOperandBundleUseRef LLVMGetOperandBundle(LLVMValueRef Val, unsigned Index);
+void LLVMDisposeOperandBundleUse(LLVMOperandBundleUseRef Bundle);
+uint32_t LLVMGetOperandBundleUseTagID(LLVMOperandBundleUseRef Bundle);
+const char *LLVMGetOperandBundleUseTagName(LLVMOperandBundleUseRef Bundle, unsigned *Length);
+unsigned LLVMGetOperandBundleUseNumInputs(LLVMOperandBundleUseRef Bundle);
+void LLVMGetOperandBundleUseInputs(LLVMOperandBundleUseRef Bundle, LLVMValueRef *Dest);
+typedef struct LLVMOpaqueOperandBundleDef *LLVMOperandBundleDefRef;
+LLVMOperandBundleDefRef LLVMOperandBundleDefFromUse(LLVMOperandBundleUseRef Bundle);
+LLVMOperandBundleDefRef LLVMCreateOperandBundleDef(const char *Tag, LLVMValueRef *Inputs,
+                                                   unsigned NumInputs);
+void LLVMDisposeOperandBundleDef(LLVMOperandBundleDefRef Bundle);
+const char *LLVMGetOperandBundleDefTag(LLVMOperandBundleDefRef Bundle, unsigned *Length);
+unsigned LLVMGetOperandBundleDefNumInputs(LLVMOperandBundleDefRef Bundle);
+void LLVMGetOperandBundleDefInputs(LLVMOperandBundleDefRef Bundle, LLVMValueRef *Dest);
+LLVMValueRef LLVMBuildCallWithOpBundle(LLVMBuilderRef B, LLVMValueRef Fn,
+                                       LLVMValueRef *Args, unsigned NumArgs,
+                                       LLVMOperandBundleDefRef *Bundles, unsigned NumBundles,
+                                       const char *Name);
+
 LLVM_C_EXTERN_C_END
 #endif

deps/LLVMExtra/lib/llvm-api.cpp

@@ -9,6 +9,7 @@
 #include <llvm/IR/GlobalValue.h>
 #include <llvm/IR/Instruction.h>
 #include <llvm/IR/Instructions.h>
+#include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/LegacyPassManager.h>
 #include <llvm/IR/Module.h>
 #include <llvm/Support/TargetSelect.h>
@@ -422,3 +423,93 @@ void LLVMFunctionDeleteBody(LLVMValueRef Func) {
 void LLVMDestroyConstant(LLVMValueRef Const) {
     unwrap<Constant>(Const)->destroyConstant();
 }
+
+// operand bundles
+
+DEFINE_STDCXX_CONVERSION_FUNCTIONS(OperandBundleUse, LLVMOperandBundleUseRef)
+
+unsigned LLVMGetNumOperandBundles(LLVMValueRef Instr) {
+    return unwrap<CallBase>(Instr)->getNumOperandBundles();
+}
+
+LLVMOperandBundleUseRef LLVMGetOperandBundle(LLVMValueRef Val, unsigned Index) {
+    CallBase *CB = unwrap<CallBase>(Val);
+    return wrap(new OperandBundleUse(CB->getOperandBundleAt(Index)));
+}
+
+void LLVMDisposeOperandBundleUse(LLVMOperandBundleUseRef Bundle) {
+    delete unwrap<OperandBundleUse>(Bundle);
+    return;
+}
+
+uint32_t LLVMGetOperandBundleUseTagID(LLVMOperandBundleUseRef Bundle) {
+    const OperandBundleUse *S = unwrap<OperandBundleUse>(Bundle);
+    return S->getTagID();
+}
+
+const char *LLVMGetOperandBundleUseTagName(LLVMOperandBundleUseRef Bundle, unsigned *Length) {
+    const OperandBundleUse *S = unwrap<OperandBundleUse>(Bundle);
+    *Length = S->getTagName().size();
+    return S->getTagName().data();
+}
+
+unsigned LLVMGetOperandBundleUseNumInputs(LLVMOperandBundleUseRef Bundle) {
+  return unwrap<OperandBundleUse>(Bundle)->Inputs.size();
+}
+
+void LLVMGetOperandBundleUseInputs(LLVMOperandBundleUseRef Bundle, LLVMValueRef *Dest) {
+  size_t i = 0;
+  for (auto &input: unwrap<OperandBundleUse>(Bundle)->Inputs)
+      Dest[i++] = wrap(input);
+}
+
+DEFINE_STDCXX_CONVERSION_FUNCTIONS(OperandBundleDef, LLVMOperandBundleDefRef)
+
+LLVMOperandBundleDefRef LLVMCreateOperandBundleDef(const char *Tag, LLVMValueRef *Inputs,
+                                                   unsigned NumInputs) {
+    SmallVector<Value*, 1> InputArray;
+    for (auto *Input : makeArrayRef(Inputs, NumInputs))
+        InputArray.push_back(unwrap(Input));
+  return wrap(new OperandBundleDef(std::string(Tag), InputArray));
+}
+
+LLVMOperandBundleDefRef LLVMOperandBundleDefFromUse(LLVMOperandBundleUseRef Bundle) {
+    return wrap(new OperandBundleDef(*unwrap<OperandBundleUse>(Bundle)));
+}
+
+void LLVMDisposeOperandBundleDef(LLVMOperandBundleDefRef Bundle) {
+    delete unwrap<OperandBundleDef>(Bundle);
+    return;
+}
+
+const char *LLVMGetOperandBundleDefTag(LLVMOperandBundleDefRef Bundle, unsigned *Length) {
+    const OperandBundleDef *S = unwrap<OperandBundleDef>(Bundle);
+    *Length = S->getTag().size();
+    return S->getTag().data();
+}
+
+unsigned LLVMGetOperandBundleDefNumInputs(LLVMOperandBundleDefRef Bundle) {
+  return unwrap<OperandBundleDef>(Bundle)->input_size();
+}
+
+void LLVMGetOperandBundleDefInputs(LLVMOperandBundleDefRef Bundle, LLVMValueRef *Dest) {
+  size_t i = 0;
+  for (auto input: unwrap<OperandBundleDef>(Bundle)->inputs())
+      Dest[i++] = wrap(input);
+}
+
+LLVMValueRef LLVMBuildCallWithOpBundle(LLVMBuilderRef B, LLVMValueRef Fn,
+                                       LLVMValueRef *Args, unsigned NumArgs,
+                                       LLVMOperandBundleDefRef *Bundles, unsigned NumBundles,
+                                       const char *Name) {
+    Value *V = unwrap(Fn);
+    FunctionType *FnT =
+        cast<FunctionType>(cast<PointerType>(V->getType())->getElementType());
+
+    SmallVector<OperandBundleDef, 1> BundleArray;
+    for (auto *Bundle : makeArrayRef(Bundles, NumBundles))
+        BundleArray.push_back(*unwrap<OperandBundleDef>(Bundle));
+
+    return wrap(unwrap(B)->CreateCall(FnT, unwrap(Fn), makeArrayRef(unwrap(Args), NumArgs),
+                                      BundleArray, Name));
+}

lib/libLLVM_extra.jl

@@ -342,3 +342,68 @@ end
 function LLVMDestroyConstant(Const)
     ccall((:LLVMDestroyConstant, libLLVMExtra), Cvoid, (LLVMValueRef,), Const)
 end
+
+mutable struct LLVMOpaqueOperandBundleUse end
+
+const LLVMOperandBundleUseRef = Ptr{LLVMOpaqueOperandBundleUse}
+
+function LLVMGetNumOperandBundles(Instr)
+    ccall((:LLVMGetNumOperandBundles, libLLVMExtra), Cuint, (LLVMValueRef,), Instr)
+end
+
+function LLVMGetOperandBundle(Val, Index)
+    ccall((:LLVMGetOperandBundle, libLLVMExtra), LLVMOperandBundleUseRef, (LLVMValueRef, Cuint), Val, Index)
+end
+
+function LLVMDisposeOperandBundleUse(Bundle)
+    ccall((:LLVMDisposeOperandBundleUse, libLLVMExtra), Cvoid, (LLVMOperandBundleUseRef,), Bundle)
+end
+
+function LLVMGetOperandBundleUseTagID(Bundle)
+    ccall((:LLVMGetOperandBundleUseTagID, libLLVMExtra), UInt32, (LLVMOperandBundleUseRef,), Bundle)
+end
+
+function LLVMGetOperandBundleUseTagName(Bundle, Length)
+    ccall((:LLVMGetOperandBundleUseTagName, libLLVMExtra), Cstring, (LLVMOperandBundleUseRef, Ptr{Cuint}), Bundle, Length)
+end
+
+function LLVMGetOperandBundleUseNumInputs(Bundle)
+    ccall((:LLVMGetOperandBundleUseNumInputs, libLLVMExtra), Cuint, (LLVMOperandBundleUseRef,), Bundle)
+end
+
+function LLVMGetOperandBundleUseInputs(Bundle, Dest)
+    ccall((:LLVMGetOperandBundleUseInputs, libLLVMExtra), Cvoid, (LLVMOperandBundleUseRef, Ptr{LLVMValueRef}), Bundle, Dest)
+end
+
+mutable struct LLVMOpaqueOperandBundleDef end
+
+const LLVMOperandBundleDefRef = Ptr{LLVMOpaqueOperandBundleDef}
+
+function LLVMOperandBundleDefFromUse(Bundle)
+    ccall((:LLVMOperandBundleDefFromUse, libLLVMExtra), LLVMOperandBundleDefRef, (LLVMOperandBundleUseRef,), Bundle)
+end
+
+function LLVMCreateOperandBundleDef(Tag, Inputs, NumInputs)
+    ccall((:LLVMCreateOperandBundleDef, libLLVMExtra), LLVMOperandBundleDefRef, (Cstring, Ptr{LLVMValueRef}, Cuint), Tag, Inputs, NumInputs)
+end
+
+function LLVMDisposeOperandBundleDef(Bundle)
+    ccall((:LLVMDisposeOperandBundleDef, libLLVMExtra), Cvoid, (LLVMOperandBundleDefRef,), Bundle)
+end
+
+function LLVMGetOperandBundleDefTag(Bundle, Length)
+    ccall((:LLVMGetOperandBundleDefTag, libLLVMExtra), Cstring, (LLVMOperandBundleDefRef, Ptr{Cuint}), Bundle, Length)
+end
+
+function LLVMGetOperandBundleDefNumInputs(Bundle)
+    ccall((:LLVMGetOperandBundleDefNumInputs, libLLVMExtra), Cuint, (LLVMOperandBundleDefRef,), Bundle)
+end
+
+function LLVMGetOperandBundleDefInputs(Bundle, Dest)
+    ccall((:LLVMGetOperandBundleDefInputs, libLLVMExtra), Cvoid, (LLVMOperandBundleDefRef, Ptr{LLVMValueRef}), Bundle, Dest)
+end
+
+function LLVMBuildCallWithOpBundle(B, Fn, Args, NumArgs, Bundles, NumBundles, Name)
+    ccall((:LLVMBuildCallWithOpBundle, libLLVMExtra), LLVMValueRef, (LLVMBuilderRef, LLVMValueRef, Ptr{LLVMValueRef}, Cuint, Ptr{LLVMOperandBundleDefRef}, Cuint, Cstring), B, Fn, Args, NumArgs, Bundles, NumBundles, Name)
+end
+

src/core/instructions.jl

@@ -131,18 +131,112 @@ end
 
 ## call sites and invocations
 
+# TODO: add this to the actual type hierarchy
+const CallBase = Union{CallBrInst, CallInst, InvokeInst}
+
 export callconv, callconv!,
        istailcall, tailcall!,
-       called_value
+       called_value, arguments,
+       OperandBundleUse, OperandBundleDef, operand_bundles
 
-callconv(inst::Instruction) = API.LLVMGetInstructionCallConv(inst)
-callconv!(inst::Instruction, cc) =
+callconv(inst::CallBase) = API.LLVMGetInstructionCallConv(inst)
+callconv!(inst::CallBase, cc) =
     API.LLVMSetInstructionCallConv(inst, cc)
 
-istailcall(inst::Instruction) = convert(Core.Bool, API.LLVMIsTailCall(inst))
-tailcall!(inst::Instruction, bool) = API.LLVMSetTailCall(inst, convert(Bool, bool))
+istailcall(inst::CallBase) = convert(Core.Bool, API.LLVMIsTailCall(inst))
+tailcall!(inst::CallBase, bool) = API.LLVMSetTailCall(inst, convert(Bool, bool))
+
+called_value(inst::CallBase) = Value(API.LLVMGetCalledValue(inst))
+
+function arguments(inst::CallBase)
+    nargs = API.LLVMGetNumArgOperands(inst)
+    operands(inst)[1:nargs]
+end
+
+# operand bundles
+
+# XXX: these objects are just C structures, whose lifetime isn't tied to LLVM IR structures.
+#      that means we need to create a copy when passing them to Julia, necessitating disposal.
+
+@checked mutable struct OperandBundleUse
+    ref::API.LLVMOperandBundleUseRef
+end
+Base.unsafe_convert(::Type{API.LLVMOperandBundleUseRef}, bundle::OperandBundleUse) =
+    bundle.ref
+
+struct OperandBundleIterator <: AbstractVector{OperandBundleUse}
+    inst::Instruction
+end
+
+operand_bundles(inst::Instruction) = OperandBundleIterator(inst)
+
+Base.size(iter::OperandBundleIterator) = (API.LLVMGetNumOperandBundles(iter.inst),)
+
+Base.IndexStyle(::OperandBundleIterator) = IndexLinear()
+
+function Base.getindex(iter::OperandBundleIterator, i::Int)
+    @boundscheck 1 <= i <= length(iter) || throw(BoundsError(iter, i))
+    bundle = OperandBundleUse(API.LLVMGetOperandBundle(iter.inst, i-1))
+    finalizer(bundle) do obj
+        API.LLVMDisposeOperandBundleUse(obj)
+    end
+end
+
+tag_id(bundle::OperandBundleUse) = API.LLVMGetOperandBundleTagID(bundle)
+
+function tag_name(bundle::OperandBundleUse)
+    len = Ref{Cuint}()
+    data = API.LLVMGetOperandBundleUseTagName(bundle, len)
+    unsafe_string(convert(Ptr{Int8}, data), len[])
+end
+
+function inputs(bundle::OperandBundleUse)
+    nvals = API.LLVMGetOperandBundleUseNumInputs(bundle)
+    vals = Vector{API.LLVMValueRef}(undef, nvals)
+    API.LLVMGetOperandBundleUseInputs(bundle, vals)
+    return [Value(val) for val in vals]
+end
+
+@checked mutable struct OperandBundleDef
+    ref::API.LLVMOperandBundleDefRef
+end
+Base.unsafe_convert(::Type{API.LLVMOperandBundleDefRef}, bundle::OperandBundleDef) =
+    bundle.ref
+
+function tag_name(bundle::OperandBundleDef)
+    len = Ref{Cuint}()
+    data = API.LLVMGetOperandBundleDefTag(bundle, len)
+    unsafe_string(convert(Ptr{Int8}, data), len[])
+end
+
+function OperandBundleDef(bundle_use::OperandBundleUse)
+    bundle_def = OperandBundleDef(API.LLVMOperandBundleDefFromUse(bundle_use))
+    finalizer(bundle_def) do obj
+        API.LLVMDisposeOperandBundleDef(obj)
+    end
+end
+
+function OperandBundleDef(tag::String, inputs::Vector{<:Value}=Value[])
+    bundle = OperandBundleDef(API.LLVMCreateOperandBundleDef(tag, inputs, length(inputs)))
+    finalizer(bundle) do obj
+        API.LLVMDisposeOperandBundleDef(obj)
+    end
+end
+
+function inputs(bundle::OperandBundleDef)
+    nvals = API.LLVMGetOperandBundleDefNumInputs(bundle)
+    vals = Vector{API.LLVMValueRef}(undef, nvals)
+    API.LLVMGetOperandBundleDefInputs(bundle, vals)
+    return [Value(val) for val in vals]
+end
+
+function Base.show(io::IO, bundle::Union{OperandBundleUse,OperandBundleDef})
+    # mimic how bundles are rendered in LLVM IR
+    print(io, "\"", tag_name(bundle), "\"(")
+    join(io, inputs(bundle), ", ")
+    print(io, ")")
+end
 
-called_value(inst::Instruction) = Value(API.LLVMGetCalledValue(inst))
 
 
 ## terminators

src/irbuilder.jl

@@ -342,6 +342,18 @@ select!(builder::Builder, If::Value, Then::Value, Else::Value, Name::String="")
 call!(builder::Builder, Fn::Value, Args::Vector{<:Value}=Value[], Name::String="") =
     Instruction(API.LLVMBuildCall(builder, Fn, Args, length(Args), Name))
 
+call!(builder::Builder, Fn::Value, Args::Vector{<:Value},
+      Bundles::Vector{OperandBundleDef}, Name::String="") =
+    Instruction(API.LLVMBuildCallWithOpBundle(builder, Fn, Args, length(Args), Bundles,
+                                              length(Bundles), Name))
+
+# convenience function that performs the OperandBundle(Iterator|Use)->Def conversion
+call!(builder::Builder, Fn::Value, Args::Vector{<:Value},
+      Bundles, Name::String="") =
+    Instruction(API.LLVMBuildCallWithOpBundle(builder, Fn, Args, length(Args),
+                                              OperandBundleDef.(Bundles),
+                                              length(Bundles), Name))
+
 va_arg!(builder::Builder, List::Value, Ty::LLVMType, Name::String="") =
     Instruction(API.LLVMBuildVAArg(builder, List, Ty, Name))