DebugInfo: Delete old subclasses of DIType

[oota-llvm.git] / bindings / go / llvm / DIBuilderBindings.cpp

diff --git a/bindings/go/llvm/DIBuilderBindings.cpp b/bindings/go/llvm/DIBuilderBindings.cpp
index f39198df42d4911943927901ddfbf565fb596a03..cd538e363a504c7180699025355d8efc767d684d 100644 (file)
--- a/bindings/go/llvm/DIBuilderBindings.cpp
+++ b/bindings/go/llvm/DIBuilderBindings.cpp
@@ -21,12 +21,6 @@ using namespace llvm;
 
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DIBuilder, LLVMDIBuilderRef)
 
-namespace {
-template <typename T> T unwrapDI(LLVMMetadataRef v) {
-  return v ? T(unwrap<MDNode>(v)) : T();
-}
-}
-
 LLVMDIBuilderRef LLVMNewDIBuilder(LLVMModuleRef mref) {
   Module *m = unwrap(mref);
   return wrap(new DIBuilder(*m));
@@ -64,8 +58,8 @@ LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef Dref,
                                                 unsigned Line,
                                                 unsigned Column) {
   DIBuilder *D = unwrap(Dref);
-  DILexicalBlock LB = D->createLexicalBlock(
-      unwrapDI<DIDescriptor>(Scope), unwrapDI<DIFile>(File), Line, Column);
+  auto *LB = D->createLexicalBlock(unwrap<MDLocalScope>(Scope),
+                                   unwrap<MDFile>(File), Line, Column);
   return wrap(LB);
 }
 
@@ -75,7 +69,7 @@ LLVMMetadataRef LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Dref,
                                                     unsigned Discriminator) {
   DIBuilder *D = unwrap(Dref);
   DILexicalBlockFile LBF = D->createLexicalBlockFile(
-      unwrapDI<DIDescriptor>(Scope), unwrapDI<DIFile>(File), Discriminator);
+      unwrap<MDLocalScope>(Scope), unwrap<MDFile>(File), Discriminator);
   return wrap(LBF);
 }
 
@@ -86,9 +80,10 @@ LLVMMetadataRef LLVMDIBuilderCreateFunction(
     unsigned ScopeLine, unsigned Flags, int IsOptimized, LLVMValueRef Func) {
   DIBuilder *D = unwrap(Dref);
   DISubprogram SP = D->createFunction(
-      unwrapDI<DIDescriptor>(Scope), Name, LinkageName, unwrapDI<DIFile>(File),
-      Line, unwrapDI<DICompositeType>(CompositeType), IsLocalToUnit,
-      IsDefinition, ScopeLine, Flags, IsOptimized, unwrap<Function>(Func));
+      unwrap<MDScope>(Scope), Name, LinkageName,
+      File ? unwrap<MDFile>(File) : nullptr, Line,
+      unwrap<MDSubroutineType>(CompositeType), IsLocalToUnit, IsDefinition,
+      ScopeLine, Flags, IsOptimized, unwrap<Function>(Func));
   return wrap(SP);
 }
 
@@ -98,8 +93,8 @@ LLVMMetadataRef LLVMDIBuilderCreateLocalVariable(
     int AlwaysPreserve, unsigned Flags, unsigned ArgNo) {
   DIBuilder *D = unwrap(Dref);
   DIVariable V = D->createLocalVariable(
-      Tag, unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), Line,
-      unwrapDI<DIType>(Ty), AlwaysPreserve, Flags, ArgNo);
+      Tag, unwrap<MDScope>(Scope), Name, unwrap<MDFile>(File), Line,
+      unwrap<MDType>(Ty), AlwaysPreserve, Flags, ArgNo);
   return wrap(V);
 }
 
@@ -109,8 +104,7 @@ LLVMMetadataRef LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Dref,
                                              uint64_t AlignInBits,
                                              unsigned Encoding) {
   DIBuilder *D = unwrap(Dref);
-  DIBasicType T = D->createBasicType(Name, SizeInBits, AlignInBits, Encoding);
-  return wrap(T);
+  return wrap(D->createBasicType(Name, SizeInBits, AlignInBits, Encoding));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef Dref,
@@ -119,18 +113,17 @@ LLVMMetadataRef LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef Dref,
                                                uint64_t AlignInBits,
                                                const char *Name) {
   DIBuilder *D = unwrap(Dref);
-  DIDerivedType T = D->createPointerType(unwrapDI<DIType>(PointeeType),
-                                         SizeInBits, AlignInBits, Name);
-  return wrap(T);
+  return wrap(D->createPointerType(unwrap<MDType>(PointeeType), SizeInBits,
+                                   AlignInBits, Name));
 }
 
 LLVMMetadataRef
 LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Dref, LLVMMetadataRef File,
                                   LLVMMetadataRef ParameterTypes) {
   DIBuilder *D = unwrap(Dref);
-  DICompositeType CT = D->createSubroutineType(
-      unwrapDI<DIFile>(File), unwrapDI<DITypeArray>(ParameterTypes));
-  return wrap(CT);
+  return wrap(
+      D->createSubroutineType(File ? unwrap<MDFile>(File) : nullptr,
+                              DITypeArray(unwrap<MDTuple>(ParameterTypes))));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateStructType(
@@ -139,11 +132,11 @@ LLVMMetadataRef LLVMDIBuilderCreateStructType(
     uint64_t AlignInBits, unsigned Flags, LLVMMetadataRef DerivedFrom,
     LLVMMetadataRef ElementTypes) {
   DIBuilder *D = unwrap(Dref);
-  DICompositeType CT = D->createStructType(
-      unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), Line,
-      SizeInBits, AlignInBits, Flags, unwrapDI<DIType>(DerivedFrom),
-      unwrapDI<DIArray>(ElementTypes));
-  return wrap(CT);
+  return wrap(D->createStructType(
+      unwrap<MDScope>(Scope), Name, File ? unwrap<MDFile>(File) : nullptr, Line,
+      SizeInBits, AlignInBits, Flags,
+      DerivedFrom ? unwrap<MDType>(DerivedFrom) : nullptr,
+      ElementTypes ? DIArray(unwrap<MDTuple>(ElementTypes)) : nullptr));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateReplaceableCompositeType(
@@ -152,10 +145,9 @@ LLVMMetadataRef LLVMDIBuilderCreateReplaceableCompositeType(
     unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
     unsigned Flags) {
   DIBuilder *D = unwrap(Dref);
-  DICompositeType CT = D->createReplaceableCompositeType(
-      Tag, Name, unwrapDI<DIDescriptor>(Scope), unwrapDI<DIFile>(File), Line,
-      RuntimeLang, SizeInBits, AlignInBits, Flags);
-  return wrap(CT);
+  return wrap(D->createReplaceableCompositeType(
+      Tag, Name, unwrap<MDScope>(Scope), File ? unwrap<MDFile>(File) : nullptr,
+      Line, RuntimeLang, SizeInBits, AlignInBits, Flags));
 }
 
 LLVMMetadataRef
@@ -165,10 +157,9 @@ LLVMDIBuilderCreateMemberType(LLVMDIBuilderRef Dref, LLVMMetadataRef Scope,
                               uint64_t AlignInBits, uint64_t OffsetInBits,
                               unsigned Flags, LLVMMetadataRef Ty) {
   DIBuilder *D = unwrap(Dref);
-  DIDerivedType DT = D->createMemberType(
-      unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), Line,
-      SizeInBits, AlignInBits, OffsetInBits, Flags, unwrapDI<DIType>(Ty));
-  return wrap(DT);
+  return wrap(D->createMemberType(
+      unwrap<MDScope>(Scope), Name, File ? unwrap<MDFile>(File) : nullptr, Line,
+      SizeInBits, AlignInBits, OffsetInBits, Flags, unwrap<MDType>(Ty)));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Dref,
@@ -177,10 +168,9 @@ LLVMMetadataRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Dref,
                                              LLVMMetadataRef ElementType,
                                              LLVMMetadataRef Subscripts) {
   DIBuilder *D = unwrap(Dref);
-  DICompositeType CT =
-      D->createArrayType(SizeInBits, AlignInBits, unwrapDI<DIType>(ElementType),
-                         unwrapDI<DIArray>(Subscripts));
-  return wrap(CT);
+  return wrap(D->createArrayType(SizeInBits, AlignInBits,
+                                 unwrap<MDType>(ElementType),
+                                 DIArray(unwrap<MDTuple>(Subscripts))));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Dref,
@@ -188,10 +178,9 @@ LLVMMetadataRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Dref,
                                            LLVMMetadataRef File, unsigned Line,
                                            LLVMMetadataRef Context) {
   DIBuilder *D = unwrap(Dref);
-  DIDerivedType DT =
-      D->createTypedef(unwrapDI<DIType>(Ty), Name, unwrapDI<DIFile>(File), Line,
-                       unwrapDI<DIDescriptor>(Context));
-  return wrap(DT);
+  return wrap(D->createTypedef(unwrap<MDType>(Ty), Name,
+                               File ? unwrap<MDFile>(File) : nullptr, Line,
+                               Context ? unwrap<MDScope>(Context) : nullptr));
 }
 
 LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Dref,
@@ -208,7 +197,7 @@ LLVMMetadataRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Dref,
   Metadata **DataValue = unwrap(Data);
   ArrayRef<Metadata *> Elements(DataValue, Length);
   DIArray A = D->getOrCreateArray(Elements);
-  return wrap(A);
+  return wrap(A.get());
 }
 
 LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Dref,
@@ -218,7 +207,7 @@ LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Dref,
   Metadata **DataValue = unwrap(Data);
   ArrayRef<Metadata *> Elements(DataValue, Length);
   DITypeArray A = D->getOrCreateTypeArray(Elements);
-  return wrap(A);
+  return wrap(A.get());
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Dref,
@@ -233,10 +222,14 @@ LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef Dref,
                                              LLVMMetadataRef VarInfo,
                                              LLVMMetadataRef Expr,
                                              LLVMBasicBlockRef Block) {
+  // Fail immediately here until the llgo folks update their bindings.  The
+  // called function is going to assert out anyway.
+  llvm_unreachable("DIBuilder API change requires a DebugLoc");
+
   DIBuilder *D = unwrap(Dref);
-  Instruction *Instr =
-      D->insertDeclare(unwrap(Storage), unwrapDI<DIVariable>(VarInfo),
-                       unwrapDI<DIExpression>(Expr), unwrap(Block));
+  Instruction *Instr = D->insertDeclare(
+      unwrap(Storage), unwrap<MDLocalVariable>(VarInfo),
+      unwrap<MDExpression>(Expr), /* DebugLoc */ nullptr, unwrap(Block));
   return wrap(Instr);
 }
 
@@ -245,9 +238,13 @@ LLVMValueRef LLVMDIBuilderInsertValueAtEnd(LLVMDIBuilderRef Dref,
                                            LLVMMetadataRef VarInfo,
                                            LLVMMetadataRef Expr,
                                            LLVMBasicBlockRef Block) {
+  // Fail immediately here until the llgo folks update their bindings.  The
+  // called function is going to assert out anyway.
+  llvm_unreachable("DIBuilder API change requires a DebugLoc");
+
   DIBuilder *D = unwrap(Dref);
   Instruction *Instr = D->insertDbgValueIntrinsic(
-      unwrap(Val), Offset, unwrapDI<DIVariable>(VarInfo),
-      unwrapDI<DIExpression>(Expr), unwrap(Block));
+      unwrap(Val), Offset, unwrap<MDLocalVariable>(VarInfo),
+      unwrap<MDExpression>(Expr), /* DebugLoc */ nullptr, unwrap(Block));
   return wrap(Instr);
 }