1 //===- DIBuilderBindings.cpp - Bindings for DIBuilder ---------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines C bindings for the DIBuilder class.
12 //===----------------------------------------------------------------------===//
14 #include "DIBuilderBindings.h"
15 #include "IRBindings.h"
16 #include "llvm/IR/DIBuilder.h"
17 #include "llvm/IR/IRBuilder.h"
18 #include "llvm/IR/Module.h"
22 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DIBuilder, LLVMDIBuilderRef)
24 LLVMDIBuilderRef LLVMNewDIBuilder(LLVMModuleRef mref) {
25 Module *m = unwrap(mref);
26 return wrap(new DIBuilder(*m));
29 void LLVMDIBuilderDestroy(LLVMDIBuilderRef dref) {
30 DIBuilder *d = unwrap(dref);
34 void LLVMDIBuilderFinalize(LLVMDIBuilderRef dref) { unwrap(dref)->finalize(); }
36 LLVMMetadataRef LLVMDIBuilderCreateCompileUnit(LLVMDIBuilderRef Dref,
37 unsigned Lang, const char *File,
40 int Optimized, const char *Flags,
41 unsigned RuntimeVersion) {
42 DIBuilder *D = unwrap(Dref);
43 return wrap(D->createCompileUnit(Lang, File, Dir, Producer, Optimized, Flags,
47 LLVMMetadataRef LLVMDIBuilderCreateFile(LLVMDIBuilderRef Dref, const char *File,
49 DIBuilder *D = unwrap(Dref);
50 return wrap(D->createFile(File, Dir));
53 LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef Dref,
54 LLVMMetadataRef Scope,
58 DIBuilder *D = unwrap(Dref);
59 auto *LB = D->createLexicalBlock(unwrap<DILocalScope>(Scope),
60 unwrap<DIFile>(File), Line, Column);
64 LLVMMetadataRef LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Dref,
65 LLVMMetadataRef Scope,
67 unsigned Discriminator) {
68 DIBuilder *D = unwrap(Dref);
69 return wrap(D->createLexicalBlockFile(unwrap<DILocalScope>(Scope),
70 unwrap<DIFile>(File), Discriminator));
73 LLVMMetadataRef LLVMDIBuilderCreateFunction(
74 LLVMDIBuilderRef Dref, LLVMMetadataRef Scope, const char *Name,
75 const char *LinkageName, LLVMMetadataRef File, unsigned Line,
76 LLVMMetadataRef CompositeType, int IsLocalToUnit, int IsDefinition,
77 unsigned ScopeLine, unsigned Flags, int IsOptimized, LLVMValueRef Func) {
78 DIBuilder *D = unwrap(Dref);
79 return wrap(D->createFunction(unwrap<DIScope>(Scope), Name, LinkageName,
80 File ? unwrap<DIFile>(File) : nullptr, Line,
81 unwrap<DISubroutineType>(CompositeType),
82 IsLocalToUnit, IsDefinition, ScopeLine, Flags,
83 IsOptimized, unwrap<Function>(Func)));
87 LLVMDIBuilderCreateAutoVariable(LLVMDIBuilderRef Dref, LLVMMetadataRef Scope,
88 const char *Name, LLVMMetadataRef File,
89 unsigned Line, LLVMMetadataRef Ty,
90 int AlwaysPreserve, unsigned Flags) {
91 DIBuilder *D = unwrap(Dref);
92 return wrap(D->createAutoVariable(unwrap<DIScope>(Scope), Name,
93 unwrap<DIFile>(File), Line,
94 unwrap<DIType>(Ty), AlwaysPreserve, Flags));
97 LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(
98 LLVMDIBuilderRef Dref, LLVMMetadataRef Scope, const char *Name,
99 unsigned ArgNo, LLVMMetadataRef File, unsigned Line, LLVMMetadataRef Ty,
100 int AlwaysPreserve, unsigned Flags) {
101 DIBuilder *D = unwrap(Dref);
102 return wrap(D->createParameterVariable(
103 unwrap<DIScope>(Scope), Name, ArgNo, unwrap<DIFile>(File), Line,
104 unwrap<DIType>(Ty), AlwaysPreserve, Flags));
107 LLVMMetadataRef LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Dref,
110 uint64_t AlignInBits,
112 DIBuilder *D = unwrap(Dref);
113 return wrap(D->createBasicType(Name, SizeInBits, AlignInBits, Encoding));
116 LLVMMetadataRef LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef Dref,
117 LLVMMetadataRef PointeeType,
119 uint64_t AlignInBits,
121 DIBuilder *D = unwrap(Dref);
122 return wrap(D->createPointerType(unwrap<DIType>(PointeeType), SizeInBits,
127 LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Dref, LLVMMetadataRef File,
128 LLVMMetadataRef ParameterTypes) {
129 DIBuilder *D = unwrap(Dref);
131 D->createSubroutineType(File ? unwrap<DIFile>(File) : nullptr,
132 DITypeRefArray(unwrap<MDTuple>(ParameterTypes))));
135 LLVMMetadataRef LLVMDIBuilderCreateStructType(
136 LLVMDIBuilderRef Dref, LLVMMetadataRef Scope, const char *Name,
137 LLVMMetadataRef File, unsigned Line, uint64_t SizeInBits,
138 uint64_t AlignInBits, unsigned Flags, LLVMMetadataRef DerivedFrom,
139 LLVMMetadataRef ElementTypes) {
140 DIBuilder *D = unwrap(Dref);
141 return wrap(D->createStructType(
142 unwrap<DIScope>(Scope), Name, File ? unwrap<DIFile>(File) : nullptr, Line,
143 SizeInBits, AlignInBits, Flags,
144 DerivedFrom ? unwrap<DIType>(DerivedFrom) : nullptr,
145 ElementTypes ? DINodeArray(unwrap<MDTuple>(ElementTypes)) : nullptr));
148 LLVMMetadataRef LLVMDIBuilderCreateReplaceableCompositeType(
149 LLVMDIBuilderRef Dref, unsigned Tag, const char *Name,
150 LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
151 unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
153 DIBuilder *D = unwrap(Dref);
154 return wrap(D->createReplaceableCompositeType(
155 Tag, Name, unwrap<DIScope>(Scope), File ? unwrap<DIFile>(File) : nullptr,
156 Line, RuntimeLang, SizeInBits, AlignInBits, Flags));
160 LLVMDIBuilderCreateMemberType(LLVMDIBuilderRef Dref, LLVMMetadataRef Scope,
161 const char *Name, LLVMMetadataRef File,
162 unsigned Line, uint64_t SizeInBits,
163 uint64_t AlignInBits, uint64_t OffsetInBits,
164 unsigned Flags, LLVMMetadataRef Ty) {
165 DIBuilder *D = unwrap(Dref);
166 return wrap(D->createMemberType(
167 unwrap<DIScope>(Scope), Name, File ? unwrap<DIFile>(File) : nullptr, Line,
168 SizeInBits, AlignInBits, OffsetInBits, Flags, unwrap<DIType>(Ty)));
171 LLVMMetadataRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Dref,
173 uint64_t AlignInBits,
174 LLVMMetadataRef ElementType,
175 LLVMMetadataRef Subscripts) {
176 DIBuilder *D = unwrap(Dref);
177 return wrap(D->createArrayType(SizeInBits, AlignInBits,
178 unwrap<DIType>(ElementType),
179 DINodeArray(unwrap<MDTuple>(Subscripts))));
182 LLVMMetadataRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Dref,
183 LLVMMetadataRef Ty, const char *Name,
184 LLVMMetadataRef File, unsigned Line,
185 LLVMMetadataRef Context) {
186 DIBuilder *D = unwrap(Dref);
187 return wrap(D->createTypedef(unwrap<DIType>(Ty), Name,
188 File ? unwrap<DIFile>(File) : nullptr, Line,
189 Context ? unwrap<DIScope>(Context) : nullptr));
192 LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Dref,
193 int64_t Lo, int64_t Count) {
194 DIBuilder *D = unwrap(Dref);
195 return wrap(D->getOrCreateSubrange(Lo, Count));
198 LLVMMetadataRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Dref,
199 LLVMMetadataRef *Data,
201 DIBuilder *D = unwrap(Dref);
202 Metadata **DataValue = unwrap(Data);
203 ArrayRef<Metadata *> Elements(DataValue, Length);
204 DINodeArray A = D->getOrCreateArray(Elements);
205 return wrap(A.get());
208 LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Dref,
209 LLVMMetadataRef *Data,
211 DIBuilder *D = unwrap(Dref);
212 Metadata **DataValue = unwrap(Data);
213 ArrayRef<Metadata *> Elements(DataValue, Length);
214 DITypeRefArray A = D->getOrCreateTypeArray(Elements);
215 return wrap(A.get());
218 LLVMMetadataRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Dref,
219 int64_t *Addr, size_t Length) {
220 DIBuilder *D = unwrap(Dref);
221 return wrap(D->createExpression(ArrayRef<int64_t>(Addr, Length)));
224 LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef Dref,
225 LLVMValueRef Storage,
226 LLVMMetadataRef VarInfo,
227 LLVMMetadataRef Expr,
228 LLVMBasicBlockRef Block) {
229 // Fail immediately here until the llgo folks update their bindings. The
230 // called function is going to assert out anyway.
231 llvm_unreachable("DIBuilder API change requires a DebugLoc");
233 DIBuilder *D = unwrap(Dref);
234 Instruction *Instr = D->insertDeclare(
235 unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
236 unwrap<DIExpression>(Expr), /* DebugLoc */ nullptr, unwrap(Block));
240 LLVMValueRef LLVMDIBuilderInsertValueAtEnd(LLVMDIBuilderRef Dref,
241 LLVMValueRef Val, uint64_t Offset,
242 LLVMMetadataRef VarInfo,
243 LLVMMetadataRef Expr,
244 LLVMBasicBlockRef Block) {
245 // Fail immediately here until the llgo folks update their bindings. The
246 // called function is going to assert out anyway.
247 llvm_unreachable("DIBuilder API change requires a DebugLoc");
249 DIBuilder *D = unwrap(Dref);
250 Instruction *Instr = D->insertDbgValueIntrinsic(
251 unwrap(Val), Offset, unwrap<DILocalVariable>(VarInfo),
252 unwrap<DIExpression>(Expr), /* DebugLoc */ nullptr, unwrap(Block));