Add new C++ API for variant parts

This patch adds new wrapper functions of DIBuilder methods to let gnat-llvm create variant parts.

Author: tromey

llvm-interface/check_for_llvm_apis.sh

@@ -42,6 +42,9 @@ api_test HAVE_TYPE_FN_SCOPE "void call(DebugInfoFinder *f, DILocalVariable *v) {
 # Test that checks if sizes and offsets can be dynamic.
 api_test HAVE_DYNAMIC_OFFSETS "void call(DIBuilder *b) { b->createMemberType(nullptr, StringRef(), nullptr, 0, nullptr, 0, nullptr, DINode::FlagZero, nullptr); }"
 
+# Test whether multiple members can be included in a variant.
+api_test HAVE_MULTI_MEMBER_VARIANT "void call(DIBuilder *b) { b->createVariantMemberType(nullptr, DINodeArray(), (Constant*)nullptr, (DIType*)nullptr); }"
+
 for def in $haves; do
  echo "#define GNAT_LLVM_$def"
 done > obj/tmp-gnat-llvm-config.h

llvm-interface/gnatllvm-wrapper.adb

@@ -927,6 +927,19 @@ package body GNATLLVM.Wrapper is
  return Types_Can_Have_Dynamic_Offsets_C /= 0;
  end Types_Can_Have_Dynamic_Offsets;
 
+ ---------------------------------------------
+ -- Types_Can_Have_Multiple_Variant_Members --
+ ---------------------------------------------
+
+ function Types_Can_Have_Multiple_Variant_Members return Boolean
+ is
+ function Types_Can_Have_Multiple_Variant_Members_C return LLVM_Bool
+ with Import => True, Convention => C,
+ External_Name => "Types_Can_Have_Multiple_Variant_Members";
+ begin
+ return Types_Can_Have_Multiple_Variant_Members_C /= 0;
+ end Types_Can_Have_Multiple_Variant_Members;
+
  function Create_Global_Variable_Declaration
  (Builder : DI_Builder_T;
  Scope : Metadata_T;
@@ -984,4 +997,54 @@ package body GNATLLVM.Wrapper is
  unsigned (Elements'Length));
  end Replace_Composite_Elements;
 
+ -------------------------
+ -- Create_Variant_Part --
+ -------------------------
+
+ function Create_Variant_Part
+ (Builder : DI_Builder_T;
+ Discriminator : Metadata_T;
+ Elements : Metadata_Array) return Metadata_T
+ is
+ function Create_Variant_Part_C
+ (Builder : DI_Builder_T;
+ Discriminator : Metadata_T;
+ Elements : System.Address;
+ Num_Elements : unsigned) return Metadata_T
+ with Import => True, Convention => C,
+ External_Name => "Create_Variant_Part";
+ begin
+ return Create_Variant_Part_C (Builder, Discriminator,
+ Elements'Address,
+ unsigned (Elements'Length));
+ end Create_Variant_Part;
+
+ ---------------------------
+ -- Create_Variant_Member --
+ ---------------------------
+
+ function Create_Variant_Member
+ (Builder : DI_Builder_T;
+ Elements : Metadata_Array;
+ Discriminants : Word_Array) return Metadata_T
+ is
+ function Create_Variant_Member_C
+ (Ctx : Context_T;
+ Builder : DI_Builder_T;
+ Elements : System.Address;
+ Num_Elements : unsigned;
+ Discriminants : System.Address;
+ Num_Discriminants : unsigned) return Metadata_T
+ with Import => True, Convention => C,
+ External_Name => "Create_Variant_Member";
+ begin
+ return Create_Variant_Member_C
+ (Get_Global_Context,
+ Builder,
+ Elements'Address,
+ unsigned (Elements'Length),
+ Discriminants'Address,
+ unsigned (Discriminants'Length));
+ end Create_Variant_Member;
+
 end GNATLLVM.Wrapper;

llvm-interface/gnatllvm-wrapper.ads

@@ -565,6 +565,10 @@ package GNATLLVM.Wrapper is
  -- Return true if the LLVM contains the patch that allows types to
  -- have dynamic offsets and sizes.
 
+ function Types_Can_Have_Multiple_Variant_Members return Boolean;
+ -- Return true if the LLVM contains the patch that allows types to
+ -- have multiple members in a variant part.
+
  function Create_Global_Variable_Declaration
  (Builder : DI_Builder_T;
  Scope : Metadata_T;
@@ -585,4 +589,18 @@ package GNATLLVM.Wrapper is
  -- Wrapper for DIBuilder::replaceArrays that only allows updating
  -- the elements of a composite type.
 
+ function Create_Variant_Part
+ (Builder : DI_Builder_T;
+ Discriminator : Metadata_T;
+ Elements : Metadata_Array) return Metadata_T;
+ -- A wrapper for an LLVM DIBuilder method that creates a variant
+ -- part.
+
+ function Create_Variant_Member
+ (Builder : DI_Builder_T;
+ Elements : Metadata_Array;
+ Discriminants : Word_Array) return Metadata_T;
+ -- A wrapper for an LLVM DIBuilder method that creates a variant
+ -- member.
+
 end GNATLLVM.Wrapper;

llvm-interface/llvm_wrapper.cc

@@ -1549,6 +1549,17 @@ Types_Can_Have_Dynamic_Offsets ()
 #endif
 }
 
+extern "C"
+bool
+Types_Can_Have_Multiple_Variant_Members ()
+{
+#ifdef GNAT_LLVM_HAVE_MULTI_MEMBER_VARIANT
+ return true;
+#else
+ return false;
+#endif
+}
+
 extern "C"
 LLVMMetadataRef Create_Global_Variable_Declaration(
  LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
@@ -1576,3 +1587,44 @@ LLVMMetadataRef Replace_Composite_Elements(
  // T might have been modified by replaceArrays.
  return wrap(T);
 }
+
+extern "C"
+LLVMMetadataRef Create_Variant_Part(
+ LLVMDIBuilderRef Builder, LLVMMetadataRef Discriminator,
+ LLVMMetadataRef *Elements, unsigned NumElements) {
+ DIDerivedType *Disc = Discriminator ? unwrap<DIDerivedType>(Discriminator) : nullptr;
+ auto Elems = unwrap(Builder)->getOrCreateArray({unwrap(Elements), NumElements});
+
+ return wrap(unwrap(Builder)->createVariantPart(
+ nullptr, {}, nullptr, 0, 0, 0, DINode::FlagZero,
+ Disc, Elems));
+}
+
+extern "C"
+LLVMMetadataRef Create_Variant_Member(
+ LLVMContext *Context, LLVMDIBuilderRef Builder,
+ LLVMMetadataRef *Elements, unsigned NumElements,
+ uint64_t *Discriminants, unsigned NumDiscriminants) {
+#ifdef GNAT_LLVM_HAVE_MULTI_MEMBER_VARIANT
+ auto Elems = unwrap(Builder)->getOrCreateArray({unwrap(Elements), NumElements});
+ Constant *D = nullptr;
+ // Note that this small optimization is actually required: when
+ // adding support for discriminant lists to LLVM, I did not realize
+ // that ConstantDataArray::get will return a ConstantAggregateZero
+ // when possible; and so the DWARF generation code does not handle
+ // this case. If a variant uses "when 0", this will result in a
+ // discriminant array of {0, 0}, which would then be ignored by the
+ // DWARF writer. This optimization works around this oddity to
+ // provide correct DWARF output.
+ if (NumDiscriminants == 2 && Discriminants[0] == Discriminants[1]) {
+ D = ConstantInt::get (Type::getInt64Ty (*Context), Discriminants[0]);
+ } else if (NumDiscriminants > 0) {
+ ArrayRef<uint64_t> Vals(Discriminants, NumDiscriminants);
+ D = ConstantDataArray::get(*Context, Vals);
+ }
+ return wrap(unwrap(Builder)->createVariantMemberType(nullptr, Elems, D, nullptr));
+#else
+ // This should never be called in this situation.
+ assert(0);
+#endif
+}