[X86] Cleanup ADCX/ADOX instruction definitions.
[lldb.git] / llvm / bindings / go / llvm / dibuilder.go
1 //===- dibuilder.go - Bindings for DIBuilder ------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines bindings for the DIBuilder class.
11 //
12 //===----------------------------------------------------------------------===//
13
14 package llvm
15
16 /*
17 #include "DIBuilderBindings.h"
18 #include <stdlib.h>
19 */
20 import "C"
21
22 import (
23         "debug/dwarf"
24         "unsafe"
25 )
26
27 type DwarfTag uint32
28
29 const (
30         DW_TAG_lexical_block   DwarfTag = 0x0b
31         DW_TAG_compile_unit    DwarfTag = 0x11
32         DW_TAG_variable        DwarfTag = 0x34
33         DW_TAG_base_type       DwarfTag = 0x24
34         DW_TAG_pointer_type    DwarfTag = 0x0F
35         DW_TAG_structure_type  DwarfTag = 0x13
36         DW_TAG_subroutine_type DwarfTag = 0x15
37         DW_TAG_file_type       DwarfTag = 0x29
38         DW_TAG_subprogram      DwarfTag = 0x2E
39         DW_TAG_auto_variable   DwarfTag = 0x100
40         DW_TAG_arg_variable    DwarfTag = 0x101
41 )
42
43 const (
44         FlagPrivate = 1 << iota
45         FlagProtected
46         FlagFwdDecl
47         FlagAppleBlock
48         FlagBlockByrefStruct
49         FlagVirtual
50         FlagArtificial
51         FlagExplicit
52         FlagPrototyped
53         FlagObjcClassComplete
54         FlagObjectPointer
55         FlagVector
56         FlagStaticMember
57         FlagIndirectVariable
58 )
59
60 type DwarfLang uint32
61
62 const (
63         // http://dwarfstd.org/ShowIssue.php?issue=101014.1&type=open
64         DW_LANG_Go DwarfLang = 0x0016
65 )
66
67 type DwarfTypeEncoding uint32
68
69 const (
70         DW_ATE_address         DwarfTypeEncoding = 0x01
71         DW_ATE_boolean         DwarfTypeEncoding = 0x02
72         DW_ATE_complex_float   DwarfTypeEncoding = 0x03
73         DW_ATE_float           DwarfTypeEncoding = 0x04
74         DW_ATE_signed          DwarfTypeEncoding = 0x05
75         DW_ATE_signed_char     DwarfTypeEncoding = 0x06
76         DW_ATE_unsigned        DwarfTypeEncoding = 0x07
77         DW_ATE_unsigned_char   DwarfTypeEncoding = 0x08
78         DW_ATE_imaginary_float DwarfTypeEncoding = 0x09
79         DW_ATE_packed_decimal  DwarfTypeEncoding = 0x0a
80         DW_ATE_numeric_string  DwarfTypeEncoding = 0x0b
81         DW_ATE_edited          DwarfTypeEncoding = 0x0c
82         DW_ATE_signed_fixed    DwarfTypeEncoding = 0x0d
83         DW_ATE_unsigned_fixed  DwarfTypeEncoding = 0x0e
84         DW_ATE_decimal_float   DwarfTypeEncoding = 0x0f
85         DW_ATE_UTF             DwarfTypeEncoding = 0x10
86         DW_ATE_lo_user         DwarfTypeEncoding = 0x80
87         DW_ATE_hi_user         DwarfTypeEncoding = 0xff
88 )
89
90 // DIBuilder is a wrapper for the LLVM DIBuilder class.
91 type DIBuilder struct {
92         ref C.LLVMDIBuilderRef
93         m   Module
94 }
95
96 // NewDIBuilder creates a new DIBuilder, associated with the given module.
97 func NewDIBuilder(m Module) *DIBuilder {
98         d := C.LLVMNewDIBuilder(m.C)
99         return &DIBuilder{ref: d, m: m}
100 }
101
102 // Destroy destroys the DIBuilder.
103 func (d *DIBuilder) Destroy() {
104         C.LLVMDIBuilderDestroy(d.ref)
105 }
106
107 // FInalize finalizes the debug information generated by the DIBuilder.
108 func (d *DIBuilder) Finalize() {
109         C.LLVMDIBuilderFinalize(d.ref)
110 }
111
112 // DICompileUnit holds the values for creating compile unit debug metadata.
113 type DICompileUnit struct {
114         Language       DwarfLang
115         File           string
116         Dir            string
117         Producer       string
118         Optimized      bool
119         Flags          string
120         RuntimeVersion int
121 }
122
123 // CreateCompileUnit creates compile unit debug metadata.
124 func (d *DIBuilder) CreateCompileUnit(cu DICompileUnit) Metadata {
125         file := C.CString(cu.File)
126         defer C.free(unsafe.Pointer(file))
127         dir := C.CString(cu.Dir)
128         defer C.free(unsafe.Pointer(dir))
129         producer := C.CString(cu.Producer)
130         defer C.free(unsafe.Pointer(producer))
131         flags := C.CString(cu.Flags)
132         defer C.free(unsafe.Pointer(flags))
133         result := C.LLVMDIBuilderCreateCompileUnit(
134                 d.ref,
135                 C.LLVMDWARFSourceLanguage(cu.Language),
136                 C.LLVMDIBuilderCreateFile(d.ref, file, C.size_t(len(cu.File)), dir, C.size_t(len(cu.Dir))),
137                 producer, C.size_t(len(cu.Producer)),
138                 C.LLVMBool(boolToCInt(cu.Optimized)),
139                 flags, C.size_t(len(cu.Flags)),
140                 C.unsigned(cu.RuntimeVersion),
141                 /*SplitName=*/ nil, 0,
142                 C.LLVMDWARFEmissionFull,
143                 /*DWOId=*/ 0,
144                 /*SplitDebugInlining*/ C.LLVMBool(boolToCInt(true)),
145                 /*DebugInfoForProfiling*/ C.LLVMBool(boolToCInt(false)),
146         )
147         return Metadata{C: result}
148 }
149
150 // CreateCompileUnit creates file debug metadata.
151 func (d *DIBuilder) CreateFile(filename, dir string) Metadata {
152         cfilename := C.CString(filename)
153         defer C.free(unsafe.Pointer(cfilename))
154         cdir := C.CString(dir)
155         defer C.free(unsafe.Pointer(cdir))
156         result := C.LLVMDIBuilderCreateFile(d.ref,
157                 cfilename, C.size_t(len(filename)),
158                 cdir, C.size_t(len(dir)))
159         return Metadata{C: result}
160 }
161
162 // DILexicalBlock holds the values for creating lexical block debug metadata.
163 type DILexicalBlock struct {
164         File   Metadata
165         Line   int
166         Column int
167 }
168
169 // CreateCompileUnit creates lexical block debug metadata.
170 func (d *DIBuilder) CreateLexicalBlock(diScope Metadata, b DILexicalBlock) Metadata {
171         result := C.LLVMDIBuilderCreateLexicalBlock(
172                 d.ref,
173                 diScope.C,
174                 b.File.C,
175                 C.unsigned(b.Line),
176                 C.unsigned(b.Column),
177         )
178         return Metadata{C: result}
179 }
180
181 func (d *DIBuilder) CreateLexicalBlockFile(diScope Metadata, diFile Metadata, discriminator int) Metadata {
182         result := C.LLVMDIBuilderCreateLexicalBlockFile(d.ref, diScope.C, diFile.C,
183                 C.unsigned(discriminator))
184         return Metadata{C: result}
185 }
186
187 // DIFunction holds the values for creating function debug metadata.
188 type DIFunction struct {
189         Name         string
190         LinkageName  string
191         File         Metadata
192         Line         int
193         Type         Metadata
194         LocalToUnit  bool
195         IsDefinition bool
196         ScopeLine    int
197         Flags        int
198         Optimized    bool
199 }
200
201 // CreateCompileUnit creates function debug metadata.
202 func (d *DIBuilder) CreateFunction(diScope Metadata, f DIFunction) Metadata {
203         name := C.CString(f.Name)
204         defer C.free(unsafe.Pointer(name))
205         linkageName := C.CString(f.LinkageName)
206         defer C.free(unsafe.Pointer(linkageName))
207         result := C.LLVMDIBuilderCreateFunction(
208                 d.ref,
209                 diScope.C,
210                 name,
211                 linkageName,
212                 f.File.C,
213                 C.unsigned(f.Line),
214                 f.Type.C,
215                 boolToCInt(f.LocalToUnit),
216                 boolToCInt(f.IsDefinition),
217                 C.unsigned(f.ScopeLine),
218                 C.unsigned(f.Flags),
219                 boolToCInt(f.Optimized),
220         )
221         return Metadata{C: result}
222 }
223
224 // DIAutoVariable holds the values for creating auto variable debug metadata.
225 type DIAutoVariable struct {
226         Name           string
227         File           Metadata
228         Line           int
229         Type           Metadata
230         AlwaysPreserve bool
231         Flags          int
232         AlignInBits    uint32
233 }
234
235 // CreateAutoVariable creates local variable debug metadata.
236 func (d *DIBuilder) CreateAutoVariable(scope Metadata, v DIAutoVariable) Metadata {
237         name := C.CString(v.Name)
238         defer C.free(unsafe.Pointer(name))
239         result := C.LLVMDIBuilderCreateAutoVariable(
240                 d.ref,
241                 scope.C,
242                 name,
243                 v.File.C,
244                 C.unsigned(v.Line),
245                 v.Type.C,
246                 boolToCInt(v.AlwaysPreserve),
247                 C.unsigned(v.Flags),
248                 C.uint32_t(v.AlignInBits),
249         )
250         return Metadata{C: result}
251 }
252
253 // DIParameterVariable holds the values for creating parameter variable debug metadata.
254 type DIParameterVariable struct {
255         Name           string
256         File           Metadata
257         Line           int
258         Type           Metadata
259         AlwaysPreserve bool
260         Flags          int
261
262         // ArgNo is the 1-based index of the argument in the function's
263         // parameter list.
264         ArgNo int
265 }
266
267 // CreateParameterVariable creates parameter variable debug metadata.
268 func (d *DIBuilder) CreateParameterVariable(scope Metadata, v DIParameterVariable) Metadata {
269         name := C.CString(v.Name)
270         defer C.free(unsafe.Pointer(name))
271         result := C.LLVMDIBuilderCreateParameterVariable(
272                 d.ref,
273                 scope.C,
274                 name,
275                 C.unsigned(v.ArgNo),
276                 v.File.C,
277                 C.unsigned(v.Line),
278                 v.Type.C,
279                 boolToCInt(v.AlwaysPreserve),
280                 C.unsigned(v.Flags),
281         )
282         return Metadata{C: result}
283 }
284
285 // DIBasicType holds the values for creating basic type debug metadata.
286 type DIBasicType struct {
287         Name       string
288         SizeInBits uint64
289         Encoding   DwarfTypeEncoding
290 }
291
292 // CreateBasicType creates basic type debug metadata.
293 func (d *DIBuilder) CreateBasicType(t DIBasicType) Metadata {
294         name := C.CString(t.Name)
295         defer C.free(unsafe.Pointer(name))
296         result := C.LLVMDIBuilderCreateBasicType(
297                 d.ref,
298                 name,
299                 C.uint64_t(t.SizeInBits),
300                 C.unsigned(t.Encoding),
301         )
302         return Metadata{C: result}
303 }
304
305 // DIPointerType holds the values for creating pointer type debug metadata.
306 type DIPointerType struct {
307         Pointee     Metadata
308         SizeInBits  uint64
309         AlignInBits uint32 // optional
310         Name        string // optional
311 }
312
313 // CreateBasicType creates basic type debug metadata.
314 func (d *DIBuilder) CreatePointerType(t DIPointerType) Metadata {
315         name := C.CString(t.Name)
316         defer C.free(unsafe.Pointer(name))
317         result := C.LLVMDIBuilderCreatePointerType(
318                 d.ref,
319                 t.Pointee.C,
320                 C.uint64_t(t.SizeInBits),
321                 C.uint32_t(t.AlignInBits),
322                 name,
323         )
324         return Metadata{C: result}
325 }
326
327 // DISubroutineType holds the values for creating subroutine type debug metadata.
328 type DISubroutineType struct {
329         // File is the file in which the subroutine type is defined.
330         File Metadata
331
332         // Parameters contains the subroutine parameter types,
333         // including the return type at the 0th index.
334         Parameters []Metadata
335 }
336
337 // CreateSubroutineType creates subroutine type debug metadata.
338 func (d *DIBuilder) CreateSubroutineType(t DISubroutineType) Metadata {
339         params := d.getOrCreateTypeArray(t.Parameters)
340         result := C.LLVMDIBuilderCreateSubroutineType(d.ref, t.File.C, params.C)
341         return Metadata{C: result}
342 }
343
344 // DIStructType holds the values for creating struct type debug metadata.
345 type DIStructType struct {
346         Name        string
347         File        Metadata
348         Line        int
349         SizeInBits  uint64
350         AlignInBits uint32
351         Flags       int
352         DerivedFrom Metadata
353         Elements    []Metadata
354 }
355
356 // CreateStructType creates struct type debug metadata.
357 func (d *DIBuilder) CreateStructType(scope Metadata, t DIStructType) Metadata {
358         elements := d.getOrCreateArray(t.Elements)
359         name := C.CString(t.Name)
360         defer C.free(unsafe.Pointer(name))
361         result := C.LLVMDIBuilderCreateStructType(
362                 d.ref,
363                 scope.C,
364                 name,
365                 t.File.C,
366                 C.unsigned(t.Line),
367                 C.uint64_t(t.SizeInBits),
368                 C.uint32_t(t.AlignInBits),
369                 C.unsigned(t.Flags),
370                 t.DerivedFrom.C,
371                 elements.C,
372         )
373         return Metadata{C: result}
374 }
375
376 // DIReplaceableCompositeType holds the values for creating replaceable
377 // composite type debug metadata.
378 type DIReplaceableCompositeType struct {
379         Tag         dwarf.Tag
380         Name        string
381         File        Metadata
382         Line        int
383         RuntimeLang int
384         SizeInBits  uint64
385         AlignInBits uint32
386         Flags       int
387 }
388
389 // CreateReplaceableCompositeType creates replaceable composite type debug metadata.
390 func (d *DIBuilder) CreateReplaceableCompositeType(scope Metadata, t DIReplaceableCompositeType) Metadata {
391         name := C.CString(t.Name)
392         defer C.free(unsafe.Pointer(name))
393         result := C.LLVMDIBuilderCreateReplaceableCompositeType(
394                 d.ref,
395                 C.unsigned(t.Tag),
396                 name,
397                 scope.C,
398                 t.File.C,
399                 C.unsigned(t.Line),
400                 C.unsigned(t.RuntimeLang),
401                 C.uint64_t(t.SizeInBits),
402                 C.uint32_t(t.AlignInBits),
403                 C.unsigned(t.Flags),
404         )
405         return Metadata{C: result}
406 }
407
408 // DIMemberType holds the values for creating member type debug metadata.
409 type DIMemberType struct {
410         Name         string
411         File         Metadata
412         Line         int
413         SizeInBits   uint64
414         AlignInBits  uint32
415         OffsetInBits uint64
416         Flags        int
417         Type         Metadata
418 }
419
420 // CreateMemberType creates struct type debug metadata.
421 func (d *DIBuilder) CreateMemberType(scope Metadata, t DIMemberType) Metadata {
422         name := C.CString(t.Name)
423         defer C.free(unsafe.Pointer(name))
424         result := C.LLVMDIBuilderCreateMemberType(
425                 d.ref,
426                 scope.C,
427                 name,
428                 t.File.C,
429                 C.unsigned(t.Line),
430                 C.uint64_t(t.SizeInBits),
431                 C.uint32_t(t.AlignInBits),
432                 C.uint64_t(t.OffsetInBits),
433                 C.unsigned(t.Flags),
434                 t.Type.C,
435         )
436         return Metadata{C: result}
437 }
438
439 // DISubrange describes an integer value range.
440 type DISubrange struct {
441         Lo    int64
442         Count int64
443 }
444
445 // DIArrayType holds the values for creating array type debug metadata.
446 type DIArrayType struct {
447         SizeInBits  uint64
448         AlignInBits uint32
449         ElementType Metadata
450         Subscripts  []DISubrange
451 }
452
453 // CreateArrayType creates struct type debug metadata.
454 func (d *DIBuilder) CreateArrayType(t DIArrayType) Metadata {
455         subscriptsSlice := make([]Metadata, len(t.Subscripts))
456         for i, s := range t.Subscripts {
457                 subscriptsSlice[i] = d.getOrCreateSubrange(s.Lo, s.Count)
458         }
459         subscripts := d.getOrCreateArray(subscriptsSlice)
460         result := C.LLVMDIBuilderCreateArrayType(
461                 d.ref,
462                 C.uint64_t(t.SizeInBits),
463                 C.uint32_t(t.AlignInBits),
464                 t.ElementType.C,
465                 subscripts.C,
466         )
467         return Metadata{C: result}
468 }
469
470 // DITypedef holds the values for creating typedef type debug metadata.
471 type DITypedef struct {
472         Type    Metadata
473         Name    string
474         File    Metadata
475         Line    int
476         Context Metadata
477 }
478
479 // CreateTypedef creates typedef type debug metadata.
480 func (d *DIBuilder) CreateTypedef(t DITypedef) Metadata {
481         name := C.CString(t.Name)
482         defer C.free(unsafe.Pointer(name))
483         result := C.LLVMDIBuilderCreateTypedef(
484                 d.ref,
485                 t.Type.C,
486                 name,
487                 t.File.C,
488                 C.unsigned(t.Line),
489                 t.Context.C,
490         )
491         return Metadata{C: result}
492 }
493
494 // getOrCreateSubrange gets a metadata node for the specified subrange,
495 // creating if required.
496 func (d *DIBuilder) getOrCreateSubrange(lo, count int64) Metadata {
497         result := C.LLVMDIBuilderGetOrCreateSubrange(d.ref, C.int64_t(lo), C.int64_t(count))
498         return Metadata{C: result}
499 }
500
501 // getOrCreateArray gets a metadata node containing the specified values,
502 // creating if required.
503 func (d *DIBuilder) getOrCreateArray(values []Metadata) Metadata {
504         if len(values) == 0 {
505                 return Metadata{}
506         }
507         data, length := llvmMetadataRefs(values)
508         result := C.LLVMDIBuilderGetOrCreateArray(d.ref, data, C.size_t(length))
509         return Metadata{C: result}
510 }
511
512 // getOrCreateTypeArray gets a metadata node for a type array containing the
513 // specified values, creating if required.
514 func (d *DIBuilder) getOrCreateTypeArray(values []Metadata) Metadata {
515         if len(values) == 0 {
516                 return Metadata{}
517         }
518         data, length := llvmMetadataRefs(values)
519         result := C.LLVMDIBuilderGetOrCreateTypeArray(d.ref, data, C.size_t(length))
520         return Metadata{C: result}
521 }
522
523 // CreateExpression creates a new descriptor for the specified
524 // variable which has a complex address expression for its address.
525 func (d *DIBuilder) CreateExpression(addr []int64) Metadata {
526         var data *C.int64_t
527         if len(addr) > 0 {
528                 data = (*C.int64_t)(unsafe.Pointer(&addr[0]))
529         }
530         result := C.LLVMDIBuilderCreateExpression(d.ref, data, C.size_t(len(addr)))
531         return Metadata{C: result}
532 }
533
534 // InsertDeclareAtEnd inserts a call to llvm.dbg.declare at the end of the
535 // specified basic block for the given value and associated debug metadata.
536 func (d *DIBuilder) InsertDeclareAtEnd(v Value, diVarInfo, expr Metadata, bb BasicBlock) Value {
537         result := C.LLVMDIBuilderInsertDeclareAtEnd(d.ref, v.C, diVarInfo.C, expr.C, bb.C)
538         return Value{C: result}
539 }
540
541 // InsertValueAtEnd inserts a call to llvm.dbg.value at the end of the
542 // specified basic block for the given value and associated debug metadata.
543 func (d *DIBuilder) InsertValueAtEnd(v Value, diVarInfo, expr Metadata, bb BasicBlock) Value {
544         result := C.LLVMDIBuilderInsertValueAtEnd(d.ref, v.C, diVarInfo.C, expr.C, bb.C)
545         return Value{C: result}
546 }
547
548 func boolToCInt(v bool) C.int {
549         if v {
550                 return 1
551         }
552         return 0
553 }