Update LLVM bindings after r239940. Apparently these aren't included in
[oota-llvm.git] / bindings / go / llvm / ir.go
1 //===- ir.go - Bindings for ir --------------------------------------------===//
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 ir component.
11 //
12 //===----------------------------------------------------------------------===//
13
14 package llvm
15
16 /*
17 #include "llvm-c/Core.h"
18 #include "IRBindings.h"
19 #include <stdlib.h>
20 */
21 import "C"
22 import "unsafe"
23 import "errors"
24
25 type (
26         // We use these weird structs here because *Ref types are pointers and
27         // Go's spec says that a pointer cannot be used as a receiver base type.
28         Context struct {
29                 C C.LLVMContextRef
30         }
31         Module struct {
32                 C C.LLVMModuleRef
33         }
34         Type struct {
35                 C C.LLVMTypeRef
36         }
37         Value struct {
38                 C C.LLVMValueRef
39         }
40         BasicBlock struct {
41                 C C.LLVMBasicBlockRef
42         }
43         Builder struct {
44                 C C.LLVMBuilderRef
45         }
46         ModuleProvider struct {
47                 C C.LLVMModuleProviderRef
48         }
49         MemoryBuffer struct {
50                 C C.LLVMMemoryBufferRef
51         }
52         PassManager struct {
53                 C C.LLVMPassManagerRef
54         }
55         Use struct {
56                 C C.LLVMUseRef
57         }
58         Metadata struct {
59                 C C.LLVMMetadataRef
60         }
61         Attribute        uint64
62         Opcode           C.LLVMOpcode
63         TypeKind         C.LLVMTypeKind
64         Linkage          C.LLVMLinkage
65         Visibility       C.LLVMVisibility
66         CallConv         C.LLVMCallConv
67         IntPredicate     C.LLVMIntPredicate
68         FloatPredicate   C.LLVMRealPredicate
69         LandingPadClause C.LLVMLandingPadClauseTy
70 )
71
72 func (c Context) IsNil() bool        { return c.C == nil }
73 func (c Module) IsNil() bool         { return c.C == nil }
74 func (c Type) IsNil() bool           { return c.C == nil }
75 func (c Value) IsNil() bool          { return c.C == nil }
76 func (c BasicBlock) IsNil() bool     { return c.C == nil }
77 func (c Builder) IsNil() bool        { return c.C == nil }
78 func (c ModuleProvider) IsNil() bool { return c.C == nil }
79 func (c MemoryBuffer) IsNil() bool   { return c.C == nil }
80 func (c PassManager) IsNil() bool    { return c.C == nil }
81 func (c Use) IsNil() bool            { return c.C == nil }
82
83 // helpers
84 func llvmTypeRefPtr(t *Type) *C.LLVMTypeRef    { return (*C.LLVMTypeRef)(unsafe.Pointer(t)) }
85 func llvmValueRefPtr(t *Value) *C.LLVMValueRef { return (*C.LLVMValueRef)(unsafe.Pointer(t)) }
86 func llvmMetadataRefPtr(t *Metadata) *C.LLVMMetadataRef {
87         return (*C.LLVMMetadataRef)(unsafe.Pointer(t))
88 }
89 func llvmBasicBlockRefPtr(t *BasicBlock) *C.LLVMBasicBlockRef {
90         return (*C.LLVMBasicBlockRef)(unsafe.Pointer(t))
91 }
92 func boolToLLVMBool(b bool) C.LLVMBool {
93         if b {
94                 return C.LLVMBool(1)
95         }
96         return C.LLVMBool(0)
97 }
98
99 func llvmValueRefs(values []Value) (*C.LLVMValueRef, C.unsigned) {
100         var pt *C.LLVMValueRef
101         ptlen := C.unsigned(len(values))
102         if ptlen > 0 {
103                 pt = llvmValueRefPtr(&values[0])
104         }
105         return pt, ptlen
106 }
107
108 func llvmMetadataRefs(mds []Metadata) (*C.LLVMMetadataRef, C.unsigned) {
109         var pt *C.LLVMMetadataRef
110         ptlen := C.unsigned(len(mds))
111         if ptlen > 0 {
112                 pt = llvmMetadataRefPtr(&mds[0])
113         }
114         return pt, ptlen
115 }
116
117 //-------------------------------------------------------------------------
118 // llvm.Attribute
119 //-------------------------------------------------------------------------
120
121 const (
122         NoneAttribute               Attribute = 0
123         ZExtAttribute               Attribute = C.LLVMZExtAttribute
124         SExtAttribute               Attribute = C.LLVMSExtAttribute
125         NoReturnAttribute           Attribute = C.LLVMNoReturnAttribute
126         InRegAttribute              Attribute = C.LLVMInRegAttribute
127         StructRetAttribute          Attribute = C.LLVMStructRetAttribute
128         NoUnwindAttribute           Attribute = C.LLVMNoUnwindAttribute
129         NoAliasAttribute            Attribute = C.LLVMNoAliasAttribute
130         ByValAttribute              Attribute = C.LLVMByValAttribute
131         NestAttribute               Attribute = C.LLVMNestAttribute
132         ReadNoneAttribute           Attribute = C.LLVMReadNoneAttribute
133         ReadOnlyAttribute           Attribute = C.LLVMReadOnlyAttribute
134         NoInlineAttribute           Attribute = C.LLVMNoInlineAttribute
135         AlwaysInlineAttribute       Attribute = C.LLVMAlwaysInlineAttribute
136         OptimizeForSizeAttribute    Attribute = C.LLVMOptimizeForSizeAttribute
137         StackProtectAttribute       Attribute = C.LLVMStackProtectAttribute
138         StackProtectReqAttribute    Attribute = C.LLVMStackProtectReqAttribute
139         Alignment                   Attribute = C.LLVMAlignment
140         NoCaptureAttribute          Attribute = C.LLVMNoCaptureAttribute
141         NoRedZoneAttribute          Attribute = C.LLVMNoRedZoneAttribute
142         NoImplicitFloatAttribute    Attribute = C.LLVMNoImplicitFloatAttribute
143         NakedAttribute              Attribute = C.LLVMNakedAttribute
144         InlineHintAttribute         Attribute = C.LLVMInlineHintAttribute
145         StackAlignment              Attribute = C.LLVMStackAlignment
146         ReturnsTwiceAttribute       Attribute = C.LLVMReturnsTwice
147         UWTableAttribute            Attribute = C.LLVMUWTable
148         NonLazyBindAttribute        Attribute = 1 << 31
149         SanitizeAddressAttribute    Attribute = 1 << 32
150         MinSizeAttribute            Attribute = 1 << 33
151         NoDuplicateAttribute        Attribute = 1 << 34
152         StackProtectStrongAttribute Attribute = 1 << 35
153         SanitizeThreadAttribute     Attribute = 1 << 36
154         SanitizeMemoryAttribute     Attribute = 1 << 37
155         NoBuiltinAttribute          Attribute = 1 << 38
156         ReturnedAttribute           Attribute = 1 << 39
157         ColdAttribute               Attribute = 1 << 40
158         BuiltinAttribute            Attribute = 1 << 41
159         OptimizeNoneAttribute       Attribute = 1 << 42
160         InAllocaAttribute           Attribute = 1 << 43
161         NonNullAttribute            Attribute = 1 << 44
162         JumpTableAttribute          Attribute = 1 << 45
163         ConvergentAttribute         Attribute = 1 << 46
164         SafeStackAttribute          Attribute = 1 << 47
165 )
166
167 //-------------------------------------------------------------------------
168 // llvm.Opcode
169 //-------------------------------------------------------------------------
170
171 const (
172         Ret         Opcode = C.LLVMRet
173         Br          Opcode = C.LLVMBr
174         Switch      Opcode = C.LLVMSwitch
175         IndirectBr  Opcode = C.LLVMIndirectBr
176         Invoke      Opcode = C.LLVMInvoke
177         Unreachable Opcode = C.LLVMUnreachable
178
179         // Standard Binary Operators
180         Add  Opcode = C.LLVMAdd
181         FAdd Opcode = C.LLVMFAdd
182         Sub  Opcode = C.LLVMSub
183         FSub Opcode = C.LLVMFSub
184         Mul  Opcode = C.LLVMMul
185         FMul Opcode = C.LLVMFMul
186         UDiv Opcode = C.LLVMUDiv
187         SDiv Opcode = C.LLVMSDiv
188         FDiv Opcode = C.LLVMFDiv
189         URem Opcode = C.LLVMURem
190         SRem Opcode = C.LLVMSRem
191         FRem Opcode = C.LLVMFRem
192
193         // Logical Operators
194         Shl  Opcode = C.LLVMShl
195         LShr Opcode = C.LLVMLShr
196         AShr Opcode = C.LLVMAShr
197         And  Opcode = C.LLVMAnd
198         Or   Opcode = C.LLVMOr
199         Xor  Opcode = C.LLVMXor
200
201         // Memory Operators
202         Alloca        Opcode = C.LLVMAlloca
203         Load          Opcode = C.LLVMLoad
204         Store         Opcode = C.LLVMStore
205         GetElementPtr Opcode = C.LLVMGetElementPtr
206
207         // Cast Operators
208         Trunc    Opcode = C.LLVMTrunc
209         ZExt     Opcode = C.LLVMZExt
210         SExt     Opcode = C.LLVMSExt
211         FPToUI   Opcode = C.LLVMFPToUI
212         FPToSI   Opcode = C.LLVMFPToSI
213         UIToFP   Opcode = C.LLVMUIToFP
214         SIToFP   Opcode = C.LLVMSIToFP
215         FPTrunc  Opcode = C.LLVMFPTrunc
216         FPExt    Opcode = C.LLVMFPExt
217         PtrToInt Opcode = C.LLVMPtrToInt
218         IntToPtr Opcode = C.LLVMIntToPtr
219         BitCast  Opcode = C.LLVMBitCast
220
221         // Other Operators
222         ICmp   Opcode = C.LLVMICmp
223         FCmp   Opcode = C.LLVMFCmp
224         PHI    Opcode = C.LLVMPHI
225         Call   Opcode = C.LLVMCall
226         Select Opcode = C.LLVMSelect
227         // UserOp1
228         // UserOp2
229         VAArg          Opcode = C.LLVMVAArg
230         ExtractElement Opcode = C.LLVMExtractElement
231         InsertElement  Opcode = C.LLVMInsertElement
232         ShuffleVector  Opcode = C.LLVMShuffleVector
233         ExtractValue   Opcode = C.LLVMExtractValue
234         InsertValue    Opcode = C.LLVMInsertValue
235 )
236
237 //-------------------------------------------------------------------------
238 // llvm.TypeKind
239 //-------------------------------------------------------------------------
240
241 const (
242         VoidTypeKind      TypeKind = C.LLVMVoidTypeKind
243         FloatTypeKind     TypeKind = C.LLVMFloatTypeKind
244         DoubleTypeKind    TypeKind = C.LLVMDoubleTypeKind
245         X86_FP80TypeKind  TypeKind = C.LLVMX86_FP80TypeKind
246         FP128TypeKind     TypeKind = C.LLVMFP128TypeKind
247         PPC_FP128TypeKind TypeKind = C.LLVMPPC_FP128TypeKind
248         LabelTypeKind     TypeKind = C.LLVMLabelTypeKind
249         IntegerTypeKind   TypeKind = C.LLVMIntegerTypeKind
250         FunctionTypeKind  TypeKind = C.LLVMFunctionTypeKind
251         StructTypeKind    TypeKind = C.LLVMStructTypeKind
252         ArrayTypeKind     TypeKind = C.LLVMArrayTypeKind
253         PointerTypeKind   TypeKind = C.LLVMPointerTypeKind
254         VectorTypeKind    TypeKind = C.LLVMVectorTypeKind
255         MetadataTypeKind  TypeKind = C.LLVMMetadataTypeKind
256 )
257
258 //-------------------------------------------------------------------------
259 // llvm.Linkage
260 //-------------------------------------------------------------------------
261
262 const (
263         ExternalLinkage            Linkage = C.LLVMExternalLinkage
264         AvailableExternallyLinkage Linkage = C.LLVMAvailableExternallyLinkage
265         LinkOnceAnyLinkage         Linkage = C.LLVMLinkOnceAnyLinkage
266         LinkOnceODRLinkage         Linkage = C.LLVMLinkOnceODRLinkage
267         WeakAnyLinkage             Linkage = C.LLVMWeakAnyLinkage
268         WeakODRLinkage             Linkage = C.LLVMWeakODRLinkage
269         AppendingLinkage           Linkage = C.LLVMAppendingLinkage
270         InternalLinkage            Linkage = C.LLVMInternalLinkage
271         PrivateLinkage             Linkage = C.LLVMPrivateLinkage
272         ExternalWeakLinkage        Linkage = C.LLVMExternalWeakLinkage
273         CommonLinkage              Linkage = C.LLVMCommonLinkage
274 )
275
276 //-------------------------------------------------------------------------
277 // llvm.Visibility
278 //-------------------------------------------------------------------------
279
280 const (
281         DefaultVisibility   Visibility = C.LLVMDefaultVisibility
282         HiddenVisibility    Visibility = C.LLVMHiddenVisibility
283         ProtectedVisibility Visibility = C.LLVMProtectedVisibility
284 )
285
286 //-------------------------------------------------------------------------
287 // llvm.CallConv
288 //-------------------------------------------------------------------------
289
290 const (
291         CCallConv           CallConv = C.LLVMCCallConv
292         FastCallConv        CallConv = C.LLVMFastCallConv
293         ColdCallConv        CallConv = C.LLVMColdCallConv
294         X86StdcallCallConv  CallConv = C.LLVMX86StdcallCallConv
295         X86FastcallCallConv CallConv = C.LLVMX86FastcallCallConv
296 )
297
298 //-------------------------------------------------------------------------
299 // llvm.IntPredicate
300 //-------------------------------------------------------------------------
301
302 const (
303         IntEQ  IntPredicate = C.LLVMIntEQ
304         IntNE  IntPredicate = C.LLVMIntNE
305         IntUGT IntPredicate = C.LLVMIntUGT
306         IntUGE IntPredicate = C.LLVMIntUGE
307         IntULT IntPredicate = C.LLVMIntULT
308         IntULE IntPredicate = C.LLVMIntULE
309         IntSGT IntPredicate = C.LLVMIntSGT
310         IntSGE IntPredicate = C.LLVMIntSGE
311         IntSLT IntPredicate = C.LLVMIntSLT
312         IntSLE IntPredicate = C.LLVMIntSLE
313 )
314
315 //-------------------------------------------------------------------------
316 // llvm.FloatPredicate
317 //-------------------------------------------------------------------------
318
319 const (
320         FloatPredicateFalse FloatPredicate = C.LLVMRealPredicateFalse
321         FloatOEQ            FloatPredicate = C.LLVMRealOEQ
322         FloatOGT            FloatPredicate = C.LLVMRealOGT
323         FloatOGE            FloatPredicate = C.LLVMRealOGE
324         FloatOLT            FloatPredicate = C.LLVMRealOLT
325         FloatOLE            FloatPredicate = C.LLVMRealOLE
326         FloatONE            FloatPredicate = C.LLVMRealONE
327         FloatORD            FloatPredicate = C.LLVMRealORD
328         FloatUNO            FloatPredicate = C.LLVMRealUNO
329         FloatUEQ            FloatPredicate = C.LLVMRealUEQ
330         FloatUGT            FloatPredicate = C.LLVMRealUGT
331         FloatUGE            FloatPredicate = C.LLVMRealUGE
332         FloatULT            FloatPredicate = C.LLVMRealULT
333         FloatULE            FloatPredicate = C.LLVMRealULE
334         FloatUNE            FloatPredicate = C.LLVMRealUNE
335         FloatPredicateTrue  FloatPredicate = C.LLVMRealPredicateTrue
336 )
337
338 //-------------------------------------------------------------------------
339 // llvm.LandingPadClause
340 //-------------------------------------------------------------------------
341
342 const (
343         LandingPadCatch  LandingPadClause = C.LLVMLandingPadCatch
344         LandingPadFilter LandingPadClause = C.LLVMLandingPadFilter
345 )
346
347 //-------------------------------------------------------------------------
348 // llvm.Context
349 //-------------------------------------------------------------------------
350
351 func NewContext() Context    { return Context{C.LLVMContextCreate()} }
352 func GlobalContext() Context { return Context{C.LLVMGetGlobalContext()} }
353 func (c Context) Dispose()   { C.LLVMContextDispose(c.C) }
354
355 func (c Context) MDKindID(name string) (id int) {
356         cname := C.CString(name)
357         defer C.free(unsafe.Pointer(cname))
358         id = int(C.LLVMGetMDKindIDInContext(c.C, cname, C.unsigned(len(name))))
359         return
360 }
361
362 func MDKindID(name string) (id int) {
363         cname := C.CString(name)
364         defer C.free(unsafe.Pointer(cname))
365         id = int(C.LLVMGetMDKindID(cname, C.unsigned(len(name))))
366         return
367 }
368
369 //-------------------------------------------------------------------------
370 // llvm.Module
371 //-------------------------------------------------------------------------
372
373 // Create and destroy modules.
374 // See llvm::Module::Module.
375 func NewModule(name string) (m Module) {
376         cname := C.CString(name)
377         defer C.free(unsafe.Pointer(cname))
378         m.C = C.LLVMModuleCreateWithName(cname)
379         return
380 }
381
382 func (c Context) NewModule(name string) (m Module) {
383         cname := C.CString(name)
384         defer C.free(unsafe.Pointer(cname))
385         m.C = C.LLVMModuleCreateWithNameInContext(cname, c.C)
386         return
387 }
388
389 // See llvm::Module::~Module
390 func (m Module) Dispose() { C.LLVMDisposeModule(m.C) }
391
392 // Data layout. See Module::getDataLayout.
393 func (m Module) DataLayout() string {
394         clayout := C.LLVMGetDataLayout(m.C)
395         return C.GoString(clayout)
396 }
397
398 func (m Module) SetDataLayout(layout string) {
399         clayout := C.CString(layout)
400         defer C.free(unsafe.Pointer(clayout))
401         C.LLVMSetDataLayout(m.C, clayout)
402 }
403
404 // Target triple. See Module::getTargetTriple.
405 func (m Module) Target() string {
406         ctarget := C.LLVMGetTarget(m.C)
407         return C.GoString(ctarget)
408 }
409 func (m Module) SetTarget(target string) {
410         ctarget := C.CString(target)
411         defer C.free(unsafe.Pointer(ctarget))
412         C.LLVMSetTarget(m.C, ctarget)
413 }
414
415 func (m Module) GetTypeByName(name string) (t Type) {
416         cname := C.CString(name)
417         defer C.free(unsafe.Pointer(cname))
418         t.C = C.LLVMGetTypeByName(m.C, cname)
419         return
420 }
421
422 // See Module::dump.
423 func (m Module) Dump() {
424         C.LLVMDumpModule(m.C)
425 }
426
427 func (m Module) String() string {
428         cir := C.LLVMPrintModuleToString(m.C)
429         defer C.free(unsafe.Pointer(cir))
430         ir := C.GoString(cir)
431         return ir
432 }
433
434 // See Module::setModuleInlineAsm.
435 func (m Module) SetInlineAsm(asm string) {
436         casm := C.CString(asm)
437         defer C.free(unsafe.Pointer(casm))
438         C.LLVMSetModuleInlineAsm(m.C, casm)
439 }
440
441 func (m Module) AddNamedMetadataOperand(name string, operand Metadata) {
442         cname := C.CString(name)
443         defer C.free(unsafe.Pointer(cname))
444         C.LLVMAddNamedMetadataOperand2(m.C, cname, operand.C)
445 }
446
447 func (m Module) Context() (c Context) {
448         c.C = C.LLVMGetModuleContext(m.C)
449         return
450 }
451
452 //-------------------------------------------------------------------------
453 // llvm.Type
454 //-------------------------------------------------------------------------
455
456 // LLVM types conform to the following hierarchy:
457 //
458 //   types:
459 //     integer type
460 //     real type
461 //     function type
462 //     sequence types:
463 //       array type
464 //       pointer type
465 //       vector type
466 //     void type
467 //     label type
468 //     opaque type
469
470 // See llvm::LLVMTypeKind::getTypeID.
471 func (t Type) TypeKind() TypeKind { return TypeKind(C.LLVMGetTypeKind(t.C)) }
472
473 // See llvm::LLVMType::getContext.
474 func (t Type) Context() (c Context) {
475         c.C = C.LLVMGetTypeContext(t.C)
476         return
477 }
478
479 // Operations on integer types
480 func (c Context) Int1Type() (t Type)  { t.C = C.LLVMInt1TypeInContext(c.C); return }
481 func (c Context) Int8Type() (t Type)  { t.C = C.LLVMInt8TypeInContext(c.C); return }
482 func (c Context) Int16Type() (t Type) { t.C = C.LLVMInt16TypeInContext(c.C); return }
483 func (c Context) Int32Type() (t Type) { t.C = C.LLVMInt32TypeInContext(c.C); return }
484 func (c Context) Int64Type() (t Type) { t.C = C.LLVMInt64TypeInContext(c.C); return }
485 func (c Context) IntType(numbits int) (t Type) {
486         t.C = C.LLVMIntTypeInContext(c.C, C.unsigned(numbits))
487         return
488 }
489
490 func Int1Type() (t Type)  { t.C = C.LLVMInt1Type(); return }
491 func Int8Type() (t Type)  { t.C = C.LLVMInt8Type(); return }
492 func Int16Type() (t Type) { t.C = C.LLVMInt16Type(); return }
493 func Int32Type() (t Type) { t.C = C.LLVMInt32Type(); return }
494 func Int64Type() (t Type) { t.C = C.LLVMInt64Type(); return }
495
496 func IntType(numbits int) (t Type) {
497         t.C = C.LLVMIntType(C.unsigned(numbits))
498         return
499 }
500
501 func (t Type) IntTypeWidth() int {
502         return int(C.LLVMGetIntTypeWidth(t.C))
503 }
504
505 // Operations on real types
506 func (c Context) FloatType() (t Type)    { t.C = C.LLVMFloatTypeInContext(c.C); return }
507 func (c Context) DoubleType() (t Type)   { t.C = C.LLVMDoubleTypeInContext(c.C); return }
508 func (c Context) X86FP80Type() (t Type)  { t.C = C.LLVMX86FP80TypeInContext(c.C); return }
509 func (c Context) FP128Type() (t Type)    { t.C = C.LLVMFP128TypeInContext(c.C); return }
510 func (c Context) PPCFP128Type() (t Type) { t.C = C.LLVMPPCFP128TypeInContext(c.C); return }
511
512 func FloatType() (t Type)    { t.C = C.LLVMFloatType(); return }
513 func DoubleType() (t Type)   { t.C = C.LLVMDoubleType(); return }
514 func X86FP80Type() (t Type)  { t.C = C.LLVMX86FP80Type(); return }
515 func FP128Type() (t Type)    { t.C = C.LLVMFP128Type(); return }
516 func PPCFP128Type() (t Type) { t.C = C.LLVMPPCFP128Type(); return }
517
518 // Operations on function types
519 func FunctionType(returnType Type, paramTypes []Type, isVarArg bool) (t Type) {
520         var pt *C.LLVMTypeRef
521         var ptlen C.unsigned
522         if len(paramTypes) > 0 {
523                 pt = llvmTypeRefPtr(&paramTypes[0])
524                 ptlen = C.unsigned(len(paramTypes))
525         }
526         t.C = C.LLVMFunctionType(returnType.C,
527                 pt,
528                 ptlen,
529                 boolToLLVMBool(isVarArg))
530         return
531 }
532
533 func (t Type) IsFunctionVarArg() bool { return C.LLVMIsFunctionVarArg(t.C) != 0 }
534 func (t Type) ReturnType() (rt Type)  { rt.C = C.LLVMGetReturnType(t.C); return }
535 func (t Type) ParamTypesCount() int   { return int(C.LLVMCountParamTypes(t.C)) }
536 func (t Type) ParamTypes() []Type {
537         count := t.ParamTypesCount()
538         if count > 0 {
539                 out := make([]Type, count)
540                 C.LLVMGetParamTypes(t.C, llvmTypeRefPtr(&out[0]))
541                 return out
542         }
543         return nil
544 }
545
546 // Operations on struct types
547 func (c Context) StructType(elementTypes []Type, packed bool) (t Type) {
548         var pt *C.LLVMTypeRef
549         var ptlen C.unsigned
550         if len(elementTypes) > 0 {
551                 pt = llvmTypeRefPtr(&elementTypes[0])
552                 ptlen = C.unsigned(len(elementTypes))
553         }
554         t.C = C.LLVMStructTypeInContext(c.C,
555                 pt,
556                 ptlen,
557                 boolToLLVMBool(packed))
558         return
559 }
560
561 func StructType(elementTypes []Type, packed bool) (t Type) {
562         var pt *C.LLVMTypeRef
563         var ptlen C.unsigned
564         if len(elementTypes) > 0 {
565                 pt = llvmTypeRefPtr(&elementTypes[0])
566                 ptlen = C.unsigned(len(elementTypes))
567         }
568         t.C = C.LLVMStructType(pt, ptlen, boolToLLVMBool(packed))
569         return
570 }
571
572 func (c Context) StructCreateNamed(name string) (t Type) {
573         cname := C.CString(name)
574         defer C.free(unsafe.Pointer(cname))
575         t.C = C.LLVMStructCreateNamed(c.C, cname)
576         return
577 }
578
579 func (t Type) StructName() string {
580         return C.GoString(C.LLVMGetStructName(t.C))
581 }
582
583 func (t Type) StructSetBody(elementTypes []Type, packed bool) {
584         var pt *C.LLVMTypeRef
585         var ptlen C.unsigned
586         if len(elementTypes) > 0 {
587                 pt = llvmTypeRefPtr(&elementTypes[0])
588                 ptlen = C.unsigned(len(elementTypes))
589         }
590         C.LLVMStructSetBody(t.C, pt, ptlen, boolToLLVMBool(packed))
591 }
592
593 func (t Type) IsStructPacked() bool         { return C.LLVMIsPackedStruct(t.C) != 0 }
594 func (t Type) StructElementTypesCount() int { return int(C.LLVMCountStructElementTypes(t.C)) }
595 func (t Type) StructElementTypes() []Type {
596         out := make([]Type, t.StructElementTypesCount())
597         if len(out) > 0 {
598                 C.LLVMGetStructElementTypes(t.C, llvmTypeRefPtr(&out[0]))
599         }
600         return out
601 }
602
603 // Operations on array, pointer, and vector types (sequence types)
604 func ArrayType(elementType Type, elementCount int) (t Type) {
605         t.C = C.LLVMArrayType(elementType.C, C.unsigned(elementCount))
606         return
607 }
608 func PointerType(elementType Type, addressSpace int) (t Type) {
609         t.C = C.LLVMPointerType(elementType.C, C.unsigned(addressSpace))
610         return
611 }
612 func VectorType(elementType Type, elementCount int) (t Type) {
613         t.C = C.LLVMVectorType(elementType.C, C.unsigned(elementCount))
614         return
615 }
616
617 func (t Type) ElementType() (rt Type)   { rt.C = C.LLVMGetElementType(t.C); return }
618 func (t Type) ArrayLength() int         { return int(C.LLVMGetArrayLength(t.C)) }
619 func (t Type) PointerAddressSpace() int { return int(C.LLVMGetPointerAddressSpace(t.C)) }
620 func (t Type) VectorSize() int          { return int(C.LLVMGetVectorSize(t.C)) }
621
622 // Operations on other types
623 func (c Context) VoidType() (t Type)  { t.C = C.LLVMVoidTypeInContext(c.C); return }
624 func (c Context) LabelType() (t Type) { t.C = C.LLVMLabelTypeInContext(c.C); return }
625
626 func VoidType() (t Type)  { t.C = C.LLVMVoidType(); return }
627 func LabelType() (t Type) { t.C = C.LLVMLabelType(); return }
628
629 //-------------------------------------------------------------------------
630 // llvm.Value
631 //-------------------------------------------------------------------------
632
633 // Operations on all values
634 func (v Value) Type() (t Type) { t.C = C.LLVMTypeOf(v.C); return }
635 func (v Value) Name() string   { return C.GoString(C.LLVMGetValueName(v.C)) }
636 func (v Value) SetName(name string) {
637         cname := C.CString(name)
638         defer C.free(unsafe.Pointer(cname))
639         C.LLVMSetValueName(v.C, cname)
640 }
641 func (v Value) Dump()                       { C.LLVMDumpValue(v.C) }
642 func (v Value) ReplaceAllUsesWith(nv Value) { C.LLVMReplaceAllUsesWith(v.C, nv.C) }
643 func (v Value) HasMetadata() bool           { return C.LLVMHasMetadata(v.C) != 0 }
644 func (v Value) Metadata(kind int) (rv Value) {
645         rv.C = C.LLVMGetMetadata(v.C, C.unsigned(kind))
646         return
647 }
648 func (v Value) SetMetadata(kind int, node Metadata) {
649         C.LLVMSetMetadata2(v.C, C.unsigned(kind), node.C)
650 }
651
652 // Conversion functions.
653 // Return the input value if it is an instance of the specified class, otherwise NULL.
654 // See llvm::dyn_cast_or_null<>.
655 func (v Value) IsAArgument() (rv Value)   { rv.C = C.LLVMIsAArgument(v.C); return }
656 func (v Value) IsABasicBlock() (rv Value) { rv.C = C.LLVMIsABasicBlock(v.C); return }
657 func (v Value) IsAInlineAsm() (rv Value)  { rv.C = C.LLVMIsAInlineAsm(v.C); return }
658 func (v Value) IsAUser() (rv Value)       { rv.C = C.LLVMIsAUser(v.C); return }
659 func (v Value) IsAConstant() (rv Value)   { rv.C = C.LLVMIsAConstant(v.C); return }
660 func (v Value) IsAConstantAggregateZero() (rv Value) {
661         rv.C = C.LLVMIsAConstantAggregateZero(v.C)
662         return
663 }
664 func (v Value) IsAConstantArray() (rv Value)       { rv.C = C.LLVMIsAConstantArray(v.C); return }
665 func (v Value) IsAConstantExpr() (rv Value)        { rv.C = C.LLVMIsAConstantExpr(v.C); return }
666 func (v Value) IsAConstantFP() (rv Value)          { rv.C = C.LLVMIsAConstantFP(v.C); return }
667 func (v Value) IsAConstantInt() (rv Value)         { rv.C = C.LLVMIsAConstantInt(v.C); return }
668 func (v Value) IsAConstantPointerNull() (rv Value) { rv.C = C.LLVMIsAConstantPointerNull(v.C); return }
669 func (v Value) IsAConstantStruct() (rv Value)      { rv.C = C.LLVMIsAConstantStruct(v.C); return }
670 func (v Value) IsAConstantVector() (rv Value)      { rv.C = C.LLVMIsAConstantVector(v.C); return }
671 func (v Value) IsAGlobalValue() (rv Value)         { rv.C = C.LLVMIsAGlobalValue(v.C); return }
672 func (v Value) IsAFunction() (rv Value)            { rv.C = C.LLVMIsAFunction(v.C); return }
673 func (v Value) IsAGlobalAlias() (rv Value)         { rv.C = C.LLVMIsAGlobalAlias(v.C); return }
674 func (v Value) IsAGlobalVariable() (rv Value)      { rv.C = C.LLVMIsAGlobalVariable(v.C); return }
675 func (v Value) IsAUndefValue() (rv Value)          { rv.C = C.LLVMIsAUndefValue(v.C); return }
676 func (v Value) IsAInstruction() (rv Value)         { rv.C = C.LLVMIsAInstruction(v.C); return }
677 func (v Value) IsABinaryOperator() (rv Value)      { rv.C = C.LLVMIsABinaryOperator(v.C); return }
678 func (v Value) IsACallInst() (rv Value)            { rv.C = C.LLVMIsACallInst(v.C); return }
679 func (v Value) IsAIntrinsicInst() (rv Value)       { rv.C = C.LLVMIsAIntrinsicInst(v.C); return }
680 func (v Value) IsADbgInfoIntrinsic() (rv Value)    { rv.C = C.LLVMIsADbgInfoIntrinsic(v.C); return }
681 func (v Value) IsADbgDeclareInst() (rv Value)      { rv.C = C.LLVMIsADbgDeclareInst(v.C); return }
682 func (v Value) IsAMemIntrinsic() (rv Value)        { rv.C = C.LLVMIsAMemIntrinsic(v.C); return }
683 func (v Value) IsAMemCpyInst() (rv Value)          { rv.C = C.LLVMIsAMemCpyInst(v.C); return }
684 func (v Value) IsAMemMoveInst() (rv Value)         { rv.C = C.LLVMIsAMemMoveInst(v.C); return }
685 func (v Value) IsAMemSetInst() (rv Value)          { rv.C = C.LLVMIsAMemSetInst(v.C); return }
686 func (v Value) IsACmpInst() (rv Value)             { rv.C = C.LLVMIsACmpInst(v.C); return }
687 func (v Value) IsAFCmpInst() (rv Value)            { rv.C = C.LLVMIsAFCmpInst(v.C); return }
688 func (v Value) IsAICmpInst() (rv Value)            { rv.C = C.LLVMIsAICmpInst(v.C); return }
689 func (v Value) IsAExtractElementInst() (rv Value)  { rv.C = C.LLVMIsAExtractElementInst(v.C); return }
690 func (v Value) IsAGetElementPtrInst() (rv Value)   { rv.C = C.LLVMIsAGetElementPtrInst(v.C); return }
691 func (v Value) IsAInsertElementInst() (rv Value)   { rv.C = C.LLVMIsAInsertElementInst(v.C); return }
692 func (v Value) IsAInsertValueInst() (rv Value)     { rv.C = C.LLVMIsAInsertValueInst(v.C); return }
693 func (v Value) IsAPHINode() (rv Value)             { rv.C = C.LLVMIsAPHINode(v.C); return }
694 func (v Value) IsASelectInst() (rv Value)          { rv.C = C.LLVMIsASelectInst(v.C); return }
695 func (v Value) IsAShuffleVectorInst() (rv Value)   { rv.C = C.LLVMIsAShuffleVectorInst(v.C); return }
696 func (v Value) IsAStoreInst() (rv Value)           { rv.C = C.LLVMIsAStoreInst(v.C); return }
697 func (v Value) IsATerminatorInst() (rv Value)      { rv.C = C.LLVMIsATerminatorInst(v.C); return }
698 func (v Value) IsABranchInst() (rv Value)          { rv.C = C.LLVMIsABranchInst(v.C); return }
699 func (v Value) IsAInvokeInst() (rv Value)          { rv.C = C.LLVMIsAInvokeInst(v.C); return }
700 func (v Value) IsAReturnInst() (rv Value)          { rv.C = C.LLVMIsAReturnInst(v.C); return }
701 func (v Value) IsASwitchInst() (rv Value)          { rv.C = C.LLVMIsASwitchInst(v.C); return }
702 func (v Value) IsAUnreachableInst() (rv Value)     { rv.C = C.LLVMIsAUnreachableInst(v.C); return }
703 func (v Value) IsAUnaryInstruction() (rv Value)    { rv.C = C.LLVMIsAUnaryInstruction(v.C); return }
704 func (v Value) IsAAllocaInst() (rv Value)          { rv.C = C.LLVMIsAAllocaInst(v.C); return }
705 func (v Value) IsACastInst() (rv Value)            { rv.C = C.LLVMIsACastInst(v.C); return }
706 func (v Value) IsABitCastInst() (rv Value)         { rv.C = C.LLVMIsABitCastInst(v.C); return }
707 func (v Value) IsAFPExtInst() (rv Value)           { rv.C = C.LLVMIsAFPExtInst(v.C); return }
708 func (v Value) IsAFPToSIInst() (rv Value)          { rv.C = C.LLVMIsAFPToSIInst(v.C); return }
709 func (v Value) IsAFPToUIInst() (rv Value)          { rv.C = C.LLVMIsAFPToUIInst(v.C); return }
710 func (v Value) IsAFPTruncInst() (rv Value)         { rv.C = C.LLVMIsAFPTruncInst(v.C); return }
711 func (v Value) IsAIntToPtrInst() (rv Value)        { rv.C = C.LLVMIsAIntToPtrInst(v.C); return }
712 func (v Value) IsAPtrToIntInst() (rv Value)        { rv.C = C.LLVMIsAPtrToIntInst(v.C); return }
713 func (v Value) IsASExtInst() (rv Value)            { rv.C = C.LLVMIsASExtInst(v.C); return }
714 func (v Value) IsASIToFPInst() (rv Value)          { rv.C = C.LLVMIsASIToFPInst(v.C); return }
715 func (v Value) IsATruncInst() (rv Value)           { rv.C = C.LLVMIsATruncInst(v.C); return }
716 func (v Value) IsAUIToFPInst() (rv Value)          { rv.C = C.LLVMIsAUIToFPInst(v.C); return }
717 func (v Value) IsAZExtInst() (rv Value)            { rv.C = C.LLVMIsAZExtInst(v.C); return }
718 func (v Value) IsAExtractValueInst() (rv Value)    { rv.C = C.LLVMIsAExtractValueInst(v.C); return }
719 func (v Value) IsALoadInst() (rv Value)            { rv.C = C.LLVMIsALoadInst(v.C); return }
720 func (v Value) IsAVAArgInst() (rv Value)           { rv.C = C.LLVMIsAVAArgInst(v.C); return }
721
722 // Operations on Uses
723 func (v Value) FirstUse() (u Use)  { u.C = C.LLVMGetFirstUse(v.C); return }
724 func (u Use) NextUse() (ru Use)    { ru.C = C.LLVMGetNextUse(u.C); return }
725 func (u Use) User() (v Value)      { v.C = C.LLVMGetUser(u.C); return }
726 func (u Use) UsedValue() (v Value) { v.C = C.LLVMGetUsedValue(u.C); return }
727
728 // Operations on Users
729 func (v Value) Operand(i int) (rv Value)   { rv.C = C.LLVMGetOperand(v.C, C.unsigned(i)); return }
730 func (v Value) SetOperand(i int, op Value) { C.LLVMSetOperand(v.C, C.unsigned(i), op.C) }
731 func (v Value) OperandsCount() int         { return int(C.LLVMGetNumOperands(v.C)) }
732
733 // Operations on constants of any type
734 func ConstNull(t Type) (v Value)        { v.C = C.LLVMConstNull(t.C); return }
735 func ConstAllOnes(t Type) (v Value)     { v.C = C.LLVMConstAllOnes(t.C); return }
736 func Undef(t Type) (v Value)            { v.C = C.LLVMGetUndef(t.C); return }
737 func (v Value) IsConstant() bool        { return C.LLVMIsConstant(v.C) != 0 }
738 func (v Value) IsNull() bool            { return C.LLVMIsNull(v.C) != 0 }
739 func (v Value) IsUndef() bool           { return C.LLVMIsUndef(v.C) != 0 }
740 func ConstPointerNull(t Type) (v Value) { v.C = C.LLVMConstPointerNull(t.C); return }
741
742 // Operations on metadata
743 func (c Context) MDString(str string) (md Metadata) {
744         cstr := C.CString(str)
745         defer C.free(unsafe.Pointer(cstr))
746         md.C = C.LLVMMDString2(c.C, cstr, C.unsigned(len(str)))
747         return
748 }
749 func (c Context) MDNode(mds []Metadata) (md Metadata) {
750         ptr, nvals := llvmMetadataRefs(mds)
751         md.C = C.LLVMMDNode2(c.C, ptr, nvals)
752         return
753 }
754 func (c Context) TemporaryMDNode(mds []Metadata) (md Metadata) {
755         ptr, nvals := llvmMetadataRefs(mds)
756         md.C = C.LLVMTemporaryMDNode(c.C, ptr, nvals)
757         return
758 }
759 func (v Value) ConstantAsMetadata() (md Metadata) {
760         md.C = C.LLVMConstantAsMetadata(v.C)
761         return
762 }
763
764 // Operations on scalar constants
765 func ConstInt(t Type, n uint64, signExtend bool) (v Value) {
766         v.C = C.LLVMConstInt(t.C,
767                 C.ulonglong(n),
768                 boolToLLVMBool(signExtend))
769         return
770 }
771 func ConstIntFromString(t Type, str string, radix int) (v Value) {
772         cstr := C.CString(str)
773         defer C.free(unsafe.Pointer(cstr))
774         v.C = C.LLVMConstIntOfString(t.C, cstr, C.uint8_t(radix))
775         return
776 }
777 func ConstFloat(t Type, n float64) (v Value) {
778         v.C = C.LLVMConstReal(t.C, C.double(n))
779         return
780 }
781 func ConstFloatFromString(t Type, str string) (v Value) {
782         cstr := C.CString(str)
783         defer C.free(unsafe.Pointer(cstr))
784         v.C = C.LLVMConstRealOfString(t.C, cstr)
785         return
786 }
787
788 func (v Value) ZExtValue() uint64 { return uint64(C.LLVMConstIntGetZExtValue(v.C)) }
789 func (v Value) SExtValue() int64  { return int64(C.LLVMConstIntGetSExtValue(v.C)) }
790
791 // Operations on composite constants
792 func (c Context) ConstString(str string, addnull bool) (v Value) {
793         cstr := C.CString(str)
794         defer C.free(unsafe.Pointer(cstr))
795         v.C = C.LLVMConstStringInContext(c.C, cstr,
796                 C.unsigned(len(str)), boolToLLVMBool(!addnull))
797         return
798 }
799 func (c Context) ConstStruct(constVals []Value, packed bool) (v Value) {
800         ptr, nvals := llvmValueRefs(constVals)
801         v.C = C.LLVMConstStructInContext(c.C, ptr, nvals,
802                 boolToLLVMBool(packed))
803         return
804 }
805 func ConstNamedStruct(t Type, constVals []Value) (v Value) {
806         ptr, nvals := llvmValueRefs(constVals)
807         v.C = C.LLVMConstNamedStruct(t.C, ptr, nvals)
808         return
809 }
810 func ConstString(str string, addnull bool) (v Value) {
811         cstr := C.CString(str)
812         defer C.free(unsafe.Pointer(cstr))
813         v.C = C.LLVMConstString(cstr,
814                 C.unsigned(len(str)), boolToLLVMBool(!addnull))
815         return
816 }
817 func ConstArray(t Type, constVals []Value) (v Value) {
818         ptr, nvals := llvmValueRefs(constVals)
819         v.C = C.LLVMConstArray(t.C, ptr, nvals)
820         return
821 }
822 func ConstStruct(constVals []Value, packed bool) (v Value) {
823         ptr, nvals := llvmValueRefs(constVals)
824         v.C = C.LLVMConstStruct(ptr, nvals, boolToLLVMBool(packed))
825         return
826 }
827 func ConstVector(scalarConstVals []Value, packed bool) (v Value) {
828         ptr, nvals := llvmValueRefs(scalarConstVals)
829         v.C = C.LLVMConstVector(ptr, nvals)
830         return
831 }
832
833 // Constant expressions
834 func (v Value) Opcode() Opcode                { return Opcode(C.LLVMGetConstOpcode(v.C)) }
835 func (v Value) InstructionOpcode() Opcode     { return Opcode(C.LLVMGetInstructionOpcode(v.C)) }
836 func AlignOf(t Type) (v Value)                { v.C = C.LLVMAlignOf(t.C); return }
837 func SizeOf(t Type) (v Value)                 { v.C = C.LLVMSizeOf(t.C); return }
838 func ConstNeg(v Value) (rv Value)             { rv.C = C.LLVMConstNeg(v.C); return }
839 func ConstNSWNeg(v Value) (rv Value)          { rv.C = C.LLVMConstNSWNeg(v.C); return }
840 func ConstNUWNeg(v Value) (rv Value)          { rv.C = C.LLVMConstNUWNeg(v.C); return }
841 func ConstFNeg(v Value) (rv Value)            { rv.C = C.LLVMConstFNeg(v.C); return }
842 func ConstNot(v Value) (rv Value)             { rv.C = C.LLVMConstNot(v.C); return }
843 func ConstAdd(lhs, rhs Value) (v Value)       { v.C = C.LLVMConstAdd(lhs.C, rhs.C); return }
844 func ConstNSWAdd(lhs, rhs Value) (v Value)    { v.C = C.LLVMConstNSWAdd(lhs.C, rhs.C); return }
845 func ConstNUWAdd(lhs, rhs Value) (v Value)    { v.C = C.LLVMConstNUWAdd(lhs.C, rhs.C); return }
846 func ConstFAdd(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstFAdd(lhs.C, rhs.C); return }
847 func ConstSub(lhs, rhs Value) (v Value)       { v.C = C.LLVMConstSub(lhs.C, rhs.C); return }
848 func ConstNSWSub(lhs, rhs Value) (v Value)    { v.C = C.LLVMConstNSWSub(lhs.C, rhs.C); return }
849 func ConstNUWSub(lhs, rhs Value) (v Value)    { v.C = C.LLVMConstNUWSub(lhs.C, rhs.C); return }
850 func ConstFSub(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstFSub(lhs.C, rhs.C); return }
851 func ConstMul(lhs, rhs Value) (v Value)       { v.C = C.LLVMConstMul(lhs.C, rhs.C); return }
852 func ConstNSWMul(lhs, rhs Value) (v Value)    { v.C = C.LLVMConstNSWMul(lhs.C, rhs.C); return }
853 func ConstNUWMul(lhs, rhs Value) (v Value)    { v.C = C.LLVMConstNUWMul(lhs.C, rhs.C); return }
854 func ConstFMul(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstFMul(lhs.C, rhs.C); return }
855 func ConstUDiv(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstUDiv(lhs.C, rhs.C); return }
856 func ConstSDiv(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstSDiv(lhs.C, rhs.C); return }
857 func ConstExactSDiv(lhs, rhs Value) (v Value) { v.C = C.LLVMConstExactSDiv(lhs.C, rhs.C); return }
858 func ConstFDiv(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstFDiv(lhs.C, rhs.C); return }
859 func ConstURem(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstURem(lhs.C, rhs.C); return }
860 func ConstSRem(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstSRem(lhs.C, rhs.C); return }
861 func ConstFRem(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstFRem(lhs.C, rhs.C); return }
862 func ConstAnd(lhs, rhs Value) (v Value)       { v.C = C.LLVMConstAnd(lhs.C, rhs.C); return }
863 func ConstOr(lhs, rhs Value) (v Value)        { v.C = C.LLVMConstOr(lhs.C, rhs.C); return }
864 func ConstXor(lhs, rhs Value) (v Value)       { v.C = C.LLVMConstXor(lhs.C, rhs.C); return }
865
866 func ConstICmp(pred IntPredicate, lhs, rhs Value) (v Value) {
867         v.C = C.LLVMConstICmp(C.LLVMIntPredicate(pred), lhs.C, rhs.C)
868         return
869 }
870 func ConstFCmp(pred FloatPredicate, lhs, rhs Value) (v Value) {
871         v.C = C.LLVMConstFCmp(C.LLVMRealPredicate(pred), lhs.C, rhs.C)
872         return
873 }
874
875 func ConstShl(lhs, rhs Value) (v Value)  { v.C = C.LLVMConstShl(lhs.C, rhs.C); return }
876 func ConstLShr(lhs, rhs Value) (v Value) { v.C = C.LLVMConstLShr(lhs.C, rhs.C); return }
877 func ConstAShr(lhs, rhs Value) (v Value) { v.C = C.LLVMConstAShr(lhs.C, rhs.C); return }
878
879 func ConstGEP(v Value, indices []Value) (rv Value) {
880         ptr, nvals := llvmValueRefs(indices)
881         rv.C = C.LLVMConstGEP(v.C, ptr, nvals)
882         return
883 }
884 func ConstInBoundsGEP(v Value, indices []Value) (rv Value) {
885         ptr, nvals := llvmValueRefs(indices)
886         rv.C = C.LLVMConstInBoundsGEP(v.C, ptr, nvals)
887         return
888 }
889 func ConstTrunc(v Value, t Type) (rv Value)         { rv.C = C.LLVMConstTrunc(v.C, t.C); return }
890 func ConstSExt(v Value, t Type) (rv Value)          { rv.C = C.LLVMConstSExt(v.C, t.C); return }
891 func ConstZExt(v Value, t Type) (rv Value)          { rv.C = C.LLVMConstZExt(v.C, t.C); return }
892 func ConstFPTrunc(v Value, t Type) (rv Value)       { rv.C = C.LLVMConstFPTrunc(v.C, t.C); return }
893 func ConstFPExt(v Value, t Type) (rv Value)         { rv.C = C.LLVMConstFPExt(v.C, t.C); return }
894 func ConstUIToFP(v Value, t Type) (rv Value)        { rv.C = C.LLVMConstUIToFP(v.C, t.C); return }
895 func ConstSIToFP(v Value, t Type) (rv Value)        { rv.C = C.LLVMConstSIToFP(v.C, t.C); return }
896 func ConstFPToUI(v Value, t Type) (rv Value)        { rv.C = C.LLVMConstFPToUI(v.C, t.C); return }
897 func ConstFPToSI(v Value, t Type) (rv Value)        { rv.C = C.LLVMConstFPToSI(v.C, t.C); return }
898 func ConstPtrToInt(v Value, t Type) (rv Value)      { rv.C = C.LLVMConstPtrToInt(v.C, t.C); return }
899 func ConstIntToPtr(v Value, t Type) (rv Value)      { rv.C = C.LLVMConstIntToPtr(v.C, t.C); return }
900 func ConstBitCast(v Value, t Type) (rv Value)       { rv.C = C.LLVMConstBitCast(v.C, t.C); return }
901 func ConstZExtOrBitCast(v Value, t Type) (rv Value) { rv.C = C.LLVMConstZExtOrBitCast(v.C, t.C); return }
902 func ConstSExtOrBitCast(v Value, t Type) (rv Value) { rv.C = C.LLVMConstSExtOrBitCast(v.C, t.C); return }
903 func ConstTruncOrBitCast(v Value, t Type) (rv Value) {
904         rv.C = C.LLVMConstTruncOrBitCast(v.C, t.C)
905         return
906 }
907 func ConstPointerCast(v Value, t Type) (rv Value) { rv.C = C.LLVMConstPointerCast(v.C, t.C); return }
908 func ConstIntCast(v Value, t Type, signed bool) (rv Value) {
909         rv.C = C.LLVMConstIntCast(v.C, t.C, boolToLLVMBool(signed))
910         return
911 }
912 func ConstFPCast(v Value, t Type) (rv Value) { rv.C = C.LLVMConstFPCast(v.C, t.C); return }
913 func ConstSelect(cond, iftrue, iffalse Value) (rv Value) {
914         rv.C = C.LLVMConstSelect(cond.C, iftrue.C, iffalse.C)
915         return
916 }
917 func ConstExtractElement(vec, i Value) (rv Value) {
918         rv.C = C.LLVMConstExtractElement(vec.C, i.C)
919         return
920 }
921 func ConstInsertElement(vec, elem, i Value) (rv Value) {
922         rv.C = C.LLVMConstInsertElement(vec.C, elem.C, i.C)
923         return
924 }
925 func ConstShuffleVector(veca, vecb, mask Value) (rv Value) {
926         rv.C = C.LLVMConstShuffleVector(veca.C, vecb.C, mask.C)
927         return
928 }
929
930 //TODO
931 //LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
932 //                                   unsigned NumIdx);
933
934 func ConstExtractValue(agg Value, indices []uint32) (rv Value) {
935         n := len(indices)
936         if n == 0 {
937                 panic("one or more indices are required")
938         }
939         ptr := (*C.unsigned)(&indices[0])
940         rv.C = C.LLVMConstExtractValue(agg.C, ptr, C.unsigned(n))
941         return
942 }
943
944 func ConstInsertValue(agg, val Value, indices []uint32) (rv Value) {
945         n := len(indices)
946         if n == 0 {
947                 panic("one or more indices are required")
948         }
949         ptr := (*C.unsigned)(&indices[0])
950         rv.C = C.LLVMConstInsertValue(agg.C, val.C, ptr, C.unsigned(n))
951         return
952 }
953
954 func BlockAddress(f Value, bb BasicBlock) (v Value) {
955         v.C = C.LLVMBlockAddress(f.C, bb.C)
956         return
957 }
958
959 // Operations on global variables, functions, and aliases (globals)
960 func (v Value) GlobalParent() (m Module) { m.C = C.LLVMGetGlobalParent(v.C); return }
961 func (v Value) IsDeclaration() bool      { return C.LLVMIsDeclaration(v.C) != 0 }
962 func (v Value) Linkage() Linkage         { return Linkage(C.LLVMGetLinkage(v.C)) }
963 func (v Value) SetLinkage(l Linkage)     { C.LLVMSetLinkage(v.C, C.LLVMLinkage(l)) }
964 func (v Value) Section() string          { return C.GoString(C.LLVMGetSection(v.C)) }
965 func (v Value) SetSection(str string) {
966         cstr := C.CString(str)
967         defer C.free(unsafe.Pointer(cstr))
968         C.LLVMSetSection(v.C, cstr)
969 }
970 func (v Value) Visibility() Visibility      { return Visibility(C.LLVMGetVisibility(v.C)) }
971 func (v Value) SetVisibility(vi Visibility) { C.LLVMSetVisibility(v.C, C.LLVMVisibility(vi)) }
972 func (v Value) Alignment() int              { return int(C.LLVMGetAlignment(v.C)) }
973 func (v Value) SetAlignment(a int)          { C.LLVMSetAlignment(v.C, C.unsigned(a)) }
974 func (v Value) SetUnnamedAddr(ua bool)      { C.LLVMSetUnnamedAddr(v.C, boolToLLVMBool(ua)) }
975
976 // Operations on global variables
977 func AddGlobal(m Module, t Type, name string) (v Value) {
978         cname := C.CString(name)
979         defer C.free(unsafe.Pointer(cname))
980         v.C = C.LLVMAddGlobal(m.C, t.C, cname)
981         return
982 }
983 func AddGlobalInAddressSpace(m Module, t Type, name string, addressSpace int) (v Value) {
984         cname := C.CString(name)
985         defer C.free(unsafe.Pointer(cname))
986         v.C = C.LLVMAddGlobalInAddressSpace(m.C, t.C, cname, C.unsigned(addressSpace))
987         return
988 }
989 func (m Module) NamedGlobal(name string) (v Value) {
990         cname := C.CString(name)
991         defer C.free(unsafe.Pointer(cname))
992         v.C = C.LLVMGetNamedGlobal(m.C, cname)
993         return
994 }
995
996 func (m Module) FirstGlobal() (v Value)   { v.C = C.LLVMGetFirstGlobal(m.C); return }
997 func (m Module) LastGlobal() (v Value)    { v.C = C.LLVMGetLastGlobal(m.C); return }
998 func NextGlobal(v Value) (rv Value)       { rv.C = C.LLVMGetNextGlobal(v.C); return }
999 func PrevGlobal(v Value) (rv Value)       { rv.C = C.LLVMGetPreviousGlobal(v.C); return }
1000 func (v Value) EraseFromParentAsGlobal()  { C.LLVMDeleteGlobal(v.C) }
1001 func (v Value) Initializer() (rv Value)   { rv.C = C.LLVMGetInitializer(v.C); return }
1002 func (v Value) SetInitializer(cv Value)   { C.LLVMSetInitializer(v.C, cv.C) }
1003 func (v Value) IsThreadLocal() bool       { return C.LLVMIsThreadLocal(v.C) != 0 }
1004 func (v Value) SetThreadLocal(tl bool)    { C.LLVMSetThreadLocal(v.C, boolToLLVMBool(tl)) }
1005 func (v Value) IsGlobalConstant() bool    { return C.LLVMIsGlobalConstant(v.C) != 0 }
1006 func (v Value) SetGlobalConstant(gc bool) { C.LLVMSetGlobalConstant(v.C, boolToLLVMBool(gc)) }
1007
1008 // Operations on aliases
1009 func AddAlias(m Module, t Type, aliasee Value, name string) (v Value) {
1010         cname := C.CString(name)
1011         defer C.free(unsafe.Pointer(cname))
1012         v.C = C.LLVMAddAlias(m.C, t.C, aliasee.C, cname)
1013         return
1014 }
1015
1016 // Operations on functions
1017 func AddFunction(m Module, name string, ft Type) (v Value) {
1018         cname := C.CString(name)
1019         defer C.free(unsafe.Pointer(cname))
1020         v.C = C.LLVMAddFunction(m.C, cname, ft.C)
1021         return
1022 }
1023
1024 func (m Module) NamedFunction(name string) (v Value) {
1025         cname := C.CString(name)
1026         defer C.free(unsafe.Pointer(cname))
1027         v.C = C.LLVMGetNamedFunction(m.C, cname)
1028         return
1029 }
1030
1031 func (m Module) FirstFunction() (v Value)  { v.C = C.LLVMGetFirstFunction(m.C); return }
1032 func (m Module) LastFunction() (v Value)   { v.C = C.LLVMGetLastFunction(m.C); return }
1033 func NextFunction(v Value) (rv Value)      { rv.C = C.LLVMGetNextFunction(v.C); return }
1034 func PrevFunction(v Value) (rv Value)      { rv.C = C.LLVMGetPreviousFunction(v.C); return }
1035 func (v Value) EraseFromParentAsFunction() { C.LLVMDeleteFunction(v.C) }
1036 func (v Value) IntrinsicID() int           { return int(C.LLVMGetIntrinsicID(v.C)) }
1037 func (v Value) FunctionCallConv() CallConv {
1038         return CallConv(C.LLVMCallConv(C.LLVMGetFunctionCallConv(v.C)))
1039 }
1040 func (v Value) SetFunctionCallConv(cc CallConv) { C.LLVMSetFunctionCallConv(v.C, C.unsigned(cc)) }
1041 func (v Value) GC() string                      { return C.GoString(C.LLVMGetGC(v.C)) }
1042 func (v Value) SetGC(name string) {
1043         cname := C.CString(name)
1044         defer C.free(unsafe.Pointer(cname))
1045         C.LLVMSetGC(v.C, cname)
1046 }
1047 func (v Value) AddFunctionAttr(a Attribute)    { C.LLVMAddFunctionAttr2(v.C, C.uint64_t(a)) }
1048 func (v Value) FunctionAttr() Attribute        { return Attribute(C.LLVMGetFunctionAttr2(v.C)) }
1049 func (v Value) RemoveFunctionAttr(a Attribute) { C.LLVMRemoveFunctionAttr2(v.C, C.uint64_t(a)) }
1050 func (v Value) AddTargetDependentFunctionAttr(attr, value string) {
1051         cattr := C.CString(attr)
1052         defer C.free(unsafe.Pointer(cattr))
1053         cvalue := C.CString(value)
1054         defer C.free(unsafe.Pointer(cvalue))
1055         C.LLVMAddTargetDependentFunctionAttr(v.C, cattr, cvalue)
1056 }
1057
1058 // Operations on parameters
1059 func (v Value) ParamsCount() int { return int(C.LLVMCountParams(v.C)) }
1060 func (v Value) Params() []Value {
1061         out := make([]Value, v.ParamsCount())
1062         if len(out) > 0 {
1063                 C.LLVMGetParams(v.C, llvmValueRefPtr(&out[0]))
1064         }
1065         return out
1066 }
1067 func (v Value) Param(i int) (rv Value)  { rv.C = C.LLVMGetParam(v.C, C.unsigned(i)); return }
1068 func (v Value) ParamParent() (rv Value) { rv.C = C.LLVMGetParamParent(v.C); return }
1069 func (v Value) FirstParam() (rv Value)  { rv.C = C.LLVMGetFirstParam(v.C); return }
1070 func (v Value) LastParam() (rv Value)   { rv.C = C.LLVMGetLastParam(v.C); return }
1071 func NextParam(v Value) (rv Value)      { rv.C = C.LLVMGetNextParam(v.C); return }
1072 func PrevParam(v Value) (rv Value)      { rv.C = C.LLVMGetPreviousParam(v.C); return }
1073 func (v Value) AddAttribute(a Attribute) {
1074         if a >= 1<<32 {
1075                 panic("attribute value currently unsupported")
1076         }
1077         C.LLVMAddAttribute(v.C, C.LLVMAttribute(a))
1078 }
1079 func (v Value) RemoveAttribute(a Attribute) {
1080         if a >= 1<<32 {
1081                 panic("attribute value currently unsupported")
1082         }
1083         C.LLVMRemoveAttribute(v.C, C.LLVMAttribute(a))
1084 }
1085 func (v Value) Attribute() Attribute        { return Attribute(C.LLVMGetAttribute(v.C)) }
1086 func (v Value) SetParamAlignment(align int) { C.LLVMSetParamAlignment(v.C, C.unsigned(align)) }
1087
1088 // Operations on basic blocks
1089 func (bb BasicBlock) AsValue() (v Value)      { v.C = C.LLVMBasicBlockAsValue(bb.C); return }
1090 func (v Value) IsBasicBlock() bool            { return C.LLVMValueIsBasicBlock(v.C) != 0 }
1091 func (v Value) AsBasicBlock() (bb BasicBlock) { bb.C = C.LLVMValueAsBasicBlock(v.C); return }
1092 func (bb BasicBlock) Parent() (v Value)       { v.C = C.LLVMGetBasicBlockParent(bb.C); return }
1093 func (v Value) BasicBlocksCount() int         { return int(C.LLVMCountBasicBlocks(v.C)) }
1094 func (v Value) BasicBlocks() []BasicBlock {
1095         out := make([]BasicBlock, v.BasicBlocksCount())
1096         C.LLVMGetBasicBlocks(v.C, llvmBasicBlockRefPtr(&out[0]))
1097         return out
1098 }
1099 func (v Value) FirstBasicBlock() (bb BasicBlock)    { bb.C = C.LLVMGetFirstBasicBlock(v.C); return }
1100 func (v Value) LastBasicBlock() (bb BasicBlock)     { bb.C = C.LLVMGetLastBasicBlock(v.C); return }
1101 func NextBasicBlock(bb BasicBlock) (rbb BasicBlock) { rbb.C = C.LLVMGetNextBasicBlock(bb.C); return }
1102 func PrevBasicBlock(bb BasicBlock) (rbb BasicBlock) { rbb.C = C.LLVMGetPreviousBasicBlock(bb.C); return }
1103 func (v Value) EntryBasicBlock() (bb BasicBlock)    { bb.C = C.LLVMGetEntryBasicBlock(v.C); return }
1104 func (c Context) AddBasicBlock(f Value, name string) (bb BasicBlock) {
1105         cname := C.CString(name)
1106         defer C.free(unsafe.Pointer(cname))
1107         bb.C = C.LLVMAppendBasicBlockInContext(c.C, f.C, cname)
1108         return
1109 }
1110 func (c Context) InsertBasicBlock(ref BasicBlock, name string) (bb BasicBlock) {
1111         cname := C.CString(name)
1112         defer C.free(unsafe.Pointer(cname))
1113         bb.C = C.LLVMInsertBasicBlockInContext(c.C, ref.C, cname)
1114         return
1115 }
1116 func AddBasicBlock(f Value, name string) (bb BasicBlock) {
1117         cname := C.CString(name)
1118         defer C.free(unsafe.Pointer(cname))
1119         bb.C = C.LLVMAppendBasicBlock(f.C, cname)
1120         return
1121 }
1122 func InsertBasicBlock(ref BasicBlock, name string) (bb BasicBlock) {
1123         cname := C.CString(name)
1124         defer C.free(unsafe.Pointer(cname))
1125         bb.C = C.LLVMInsertBasicBlock(ref.C, cname)
1126         return
1127 }
1128 func (bb BasicBlock) EraseFromParent()          { C.LLVMDeleteBasicBlock(bb.C) }
1129 func (bb BasicBlock) MoveBefore(pos BasicBlock) { C.LLVMMoveBasicBlockBefore(bb.C, pos.C) }
1130 func (bb BasicBlock) MoveAfter(pos BasicBlock)  { C.LLVMMoveBasicBlockAfter(bb.C, pos.C) }
1131
1132 // Operations on instructions
1133 func (v Value) InstructionParent() (bb BasicBlock) { bb.C = C.LLVMGetInstructionParent(v.C); return }
1134 func (bb BasicBlock) FirstInstruction() (v Value)  { v.C = C.LLVMGetFirstInstruction(bb.C); return }
1135 func (bb BasicBlock) LastInstruction() (v Value)   { v.C = C.LLVMGetLastInstruction(bb.C); return }
1136 func NextInstruction(v Value) (rv Value)           { rv.C = C.LLVMGetNextInstruction(v.C); return }
1137 func PrevInstruction(v Value) (rv Value)           { rv.C = C.LLVMGetPreviousInstruction(v.C); return }
1138
1139 // Operations on call sites
1140 func (v Value) SetInstructionCallConv(cc CallConv) {
1141         C.LLVMSetInstructionCallConv(v.C, C.unsigned(cc))
1142 }
1143 func (v Value) InstructionCallConv() CallConv {
1144         return CallConv(C.LLVMCallConv(C.LLVMGetInstructionCallConv(v.C)))
1145 }
1146 func (v Value) AddInstrAttribute(i int, a Attribute) {
1147         if a >= 1<<32 {
1148                 panic("attribute value currently unsupported")
1149         }
1150         C.LLVMAddInstrAttribute(v.C, C.unsigned(i), C.LLVMAttribute(a))
1151 }
1152 func (v Value) RemoveInstrAttribute(i int, a Attribute) {
1153         if a >= 1<<32 {
1154                 panic("attribute value currently unsupported")
1155         }
1156         C.LLVMRemoveInstrAttribute(v.C, C.unsigned(i), C.LLVMAttribute(a))
1157 }
1158 func (v Value) SetInstrParamAlignment(i int, align int) {
1159         C.LLVMSetInstrParamAlignment(v.C, C.unsigned(i), C.unsigned(align))
1160 }
1161
1162 // Operations on call instructions (only)
1163 func (v Value) IsTailCall() bool    { return C.LLVMIsTailCall(v.C) != 0 }
1164 func (v Value) SetTailCall(is bool) { C.LLVMSetTailCall(v.C, boolToLLVMBool(is)) }
1165
1166 // Operations on phi nodes
1167 func (v Value) AddIncoming(vals []Value, blocks []BasicBlock) {
1168         ptr, nvals := llvmValueRefs(vals)
1169         C.LLVMAddIncoming(v.C, ptr, llvmBasicBlockRefPtr(&blocks[0]), nvals)
1170 }
1171 func (v Value) IncomingCount() int { return int(C.LLVMCountIncoming(v.C)) }
1172 func (v Value) IncomingValue(i int) (rv Value) {
1173         rv.C = C.LLVMGetIncomingValue(v.C, C.unsigned(i))
1174         return
1175 }
1176 func (v Value) IncomingBlock(i int) (bb BasicBlock) {
1177         bb.C = C.LLVMGetIncomingBlock(v.C, C.unsigned(i))
1178         return
1179 }
1180
1181 //-------------------------------------------------------------------------
1182 // llvm.Builder
1183 //-------------------------------------------------------------------------
1184
1185 // An instruction builder represents a point within a basic block, and is the
1186 // exclusive means of building instructions using the C interface.
1187
1188 func (c Context) NewBuilder() (b Builder) { b.C = C.LLVMCreateBuilderInContext(c.C); return }
1189 func NewBuilder() (b Builder)             { b.C = C.LLVMCreateBuilder(); return }
1190 func (b Builder) SetInsertPoint(block BasicBlock, instr Value) {
1191         C.LLVMPositionBuilder(b.C, block.C, instr.C)
1192 }
1193 func (b Builder) SetInsertPointBefore(instr Value)     { C.LLVMPositionBuilderBefore(b.C, instr.C) }
1194 func (b Builder) SetInsertPointAtEnd(block BasicBlock) { C.LLVMPositionBuilderAtEnd(b.C, block.C) }
1195 func (b Builder) GetInsertBlock() (bb BasicBlock)      { bb.C = C.LLVMGetInsertBlock(b.C); return }
1196 func (b Builder) ClearInsertionPoint()                 { C.LLVMClearInsertionPosition(b.C) }
1197 func (b Builder) Insert(instr Value)                   { C.LLVMInsertIntoBuilder(b.C, instr.C) }
1198 func (b Builder) InsertWithName(instr Value, name string) {
1199         cname := C.CString(name)
1200         defer C.free(unsafe.Pointer(cname))
1201         C.LLVMInsertIntoBuilderWithName(b.C, instr.C, cname)
1202 }
1203 func (b Builder) Dispose() { C.LLVMDisposeBuilder(b.C) }
1204
1205 // Metadata
1206 func (b Builder) SetCurrentDebugLocation(line, col uint, scope, inlinedAt Metadata) {
1207         C.LLVMSetCurrentDebugLocation2(b.C, C.unsigned(line), C.unsigned(col), scope.C, inlinedAt.C)
1208 }
1209 func (b Builder) SetInstDebugLocation(v Value)    { C.LLVMSetInstDebugLocation(b.C, v.C) }
1210 func (b Builder) InsertDeclare(module Module, storage Value, md Value) Value {
1211         f := module.NamedFunction("llvm.dbg.declare")
1212         if f.IsNil() {
1213                 ftyp := FunctionType(VoidType(), []Type{storage.Type(), md.Type()}, false)
1214                 f = AddFunction(module, "llvm.dbg.declare", ftyp)
1215         }
1216         return b.CreateCall(f, []Value{storage, md}, "")
1217 }
1218
1219 // Terminators
1220 func (b Builder) CreateRetVoid() (rv Value)    { rv.C = C.LLVMBuildRetVoid(b.C); return }
1221 func (b Builder) CreateRet(v Value) (rv Value) { rv.C = C.LLVMBuildRet(b.C, v.C); return }
1222 func (b Builder) CreateAggregateRet(vs []Value) (rv Value) {
1223         ptr, nvals := llvmValueRefs(vs)
1224         rv.C = C.LLVMBuildAggregateRet(b.C, ptr, nvals)
1225         return
1226 }
1227 func (b Builder) CreateBr(bb BasicBlock) (rv Value) { rv.C = C.LLVMBuildBr(b.C, bb.C); return }
1228 func (b Builder) CreateCondBr(ifv Value, thenb, elseb BasicBlock) (rv Value) {
1229         rv.C = C.LLVMBuildCondBr(b.C, ifv.C, thenb.C, elseb.C)
1230         return
1231 }
1232 func (b Builder) CreateSwitch(v Value, elseb BasicBlock, numCases int) (rv Value) {
1233         rv.C = C.LLVMBuildSwitch(b.C, v.C, elseb.C, C.unsigned(numCases))
1234         return
1235 }
1236 func (b Builder) CreateIndirectBr(addr Value, numDests int) (rv Value) {
1237         rv.C = C.LLVMBuildIndirectBr(b.C, addr.C, C.unsigned(numDests))
1238         return
1239 }
1240 func (b Builder) CreateInvoke(fn Value, args []Value, then, catch BasicBlock, name string) (rv Value) {
1241         cname := C.CString(name)
1242         defer C.free(unsafe.Pointer(cname))
1243         ptr, nvals := llvmValueRefs(args)
1244         rv.C = C.LLVMBuildInvoke(b.C, fn.C, ptr, nvals, then.C, catch.C, cname)
1245         return
1246 }
1247 func (b Builder) CreateUnreachable() (rv Value) { rv.C = C.LLVMBuildUnreachable(b.C); return }
1248
1249 // Add a case to the switch instruction
1250 func (v Value) AddCase(on Value, dest BasicBlock) { C.LLVMAddCase(v.C, on.C, dest.C) }
1251
1252 // Add a destination to the indirectbr instruction
1253 func (v Value) AddDest(dest BasicBlock) { C.LLVMAddDestination(v.C, dest.C) }
1254
1255 // Arithmetic
1256 func (b Builder) CreateAdd(lhs, rhs Value, name string) (v Value) {
1257         cname := C.CString(name)
1258         defer C.free(unsafe.Pointer(cname))
1259         v.C = C.LLVMBuildAdd(b.C, lhs.C, rhs.C, cname)
1260         return
1261 }
1262 func (b Builder) CreateNSWAdd(lhs, rhs Value, name string) (v Value) {
1263         cname := C.CString(name)
1264         defer C.free(unsafe.Pointer(cname))
1265         v.C = C.LLVMBuildNSWAdd(b.C, lhs.C, rhs.C, cname)
1266         return
1267 }
1268 func (b Builder) CreateNUWAdd(lhs, rhs Value, name string) (v Value) {
1269         cname := C.CString(name)
1270         defer C.free(unsafe.Pointer(cname))
1271         v.C = C.LLVMBuildNUWAdd(b.C, lhs.C, rhs.C, cname)
1272         return
1273 }
1274 func (b Builder) CreateFAdd(lhs, rhs Value, name string) (v Value) {
1275         cname := C.CString(name)
1276         defer C.free(unsafe.Pointer(cname))
1277         v.C = C.LLVMBuildFAdd(b.C, lhs.C, rhs.C, cname)
1278         return
1279 }
1280 func (b Builder) CreateSub(lhs, rhs Value, name string) (v Value) {
1281         cname := C.CString(name)
1282         defer C.free(unsafe.Pointer(cname))
1283         v.C = C.LLVMBuildSub(b.C, lhs.C, rhs.C, cname)
1284         return
1285 }
1286 func (b Builder) CreateNSWSub(lhs, rhs Value, name string) (v Value) {
1287         cname := C.CString(name)
1288         defer C.free(unsafe.Pointer(cname))
1289         v.C = C.LLVMBuildNSWSub(b.C, lhs.C, rhs.C, cname)
1290         return
1291 }
1292 func (b Builder) CreateNUWSub(lhs, rhs Value, name string) (v Value) {
1293         cname := C.CString(name)
1294         defer C.free(unsafe.Pointer(cname))
1295         v.C = C.LLVMBuildNUWSub(b.C, lhs.C, rhs.C, cname)
1296         return
1297 }
1298 func (b Builder) CreateFSub(lhs, rhs Value, name string) (v Value) {
1299         cname := C.CString(name)
1300         v.C = C.LLVMBuildFSub(b.C, lhs.C, rhs.C, cname)
1301         C.free(unsafe.Pointer(cname))
1302         return
1303 }
1304 func (b Builder) CreateMul(lhs, rhs Value, name string) (v Value) {
1305         cname := C.CString(name)
1306         defer C.free(unsafe.Pointer(cname))
1307         v.C = C.LLVMBuildMul(b.C, lhs.C, rhs.C, cname)
1308         return
1309 }
1310 func (b Builder) CreateNSWMul(lhs, rhs Value, name string) (v Value) {
1311         cname := C.CString(name)
1312         defer C.free(unsafe.Pointer(cname))
1313         v.C = C.LLVMBuildNSWMul(b.C, lhs.C, rhs.C, cname)
1314         return
1315 }
1316 func (b Builder) CreateNUWMul(lhs, rhs Value, name string) (v Value) {
1317         cname := C.CString(name)
1318         defer C.free(unsafe.Pointer(cname))
1319         v.C = C.LLVMBuildNUWMul(b.C, lhs.C, rhs.C, cname)
1320         return
1321 }
1322 func (b Builder) CreateFMul(lhs, rhs Value, name string) (v Value) {
1323         cname := C.CString(name)
1324         defer C.free(unsafe.Pointer(cname))
1325         v.C = C.LLVMBuildFMul(b.C, lhs.C, rhs.C, cname)
1326         return
1327 }
1328 func (b Builder) CreateUDiv(lhs, rhs Value, name string) (v Value) {
1329         cname := C.CString(name)
1330         defer C.free(unsafe.Pointer(cname))
1331         v.C = C.LLVMBuildUDiv(b.C, lhs.C, rhs.C, cname)
1332         return
1333 }
1334 func (b Builder) CreateSDiv(lhs, rhs Value, name string) (v Value) {
1335         cname := C.CString(name)
1336         defer C.free(unsafe.Pointer(cname))
1337         v.C = C.LLVMBuildSDiv(b.C, lhs.C, rhs.C, cname)
1338         return
1339 }
1340 func (b Builder) CreateExactSDiv(lhs, rhs Value, name string) (v Value) {
1341         cname := C.CString(name)
1342         defer C.free(unsafe.Pointer(cname))
1343         v.C = C.LLVMBuildExactSDiv(b.C, lhs.C, rhs.C, cname)
1344         return
1345 }
1346 func (b Builder) CreateFDiv(lhs, rhs Value, name string) (v Value) {
1347         cname := C.CString(name)
1348         defer C.free(unsafe.Pointer(cname))
1349         v.C = C.LLVMBuildFDiv(b.C, lhs.C, rhs.C, cname)
1350         return
1351 }
1352 func (b Builder) CreateURem(lhs, rhs Value, name string) (v Value) {
1353         cname := C.CString(name)
1354         defer C.free(unsafe.Pointer(cname))
1355         v.C = C.LLVMBuildURem(b.C, lhs.C, rhs.C, cname)
1356         return
1357 }
1358 func (b Builder) CreateSRem(lhs, rhs Value, name string) (v Value) {
1359         cname := C.CString(name)
1360         defer C.free(unsafe.Pointer(cname))
1361         v.C = C.LLVMBuildSRem(b.C, lhs.C, rhs.C, cname)
1362         return
1363 }
1364 func (b Builder) CreateFRem(lhs, rhs Value, name string) (v Value) {
1365         cname := C.CString(name)
1366         defer C.free(unsafe.Pointer(cname))
1367         v.C = C.LLVMBuildFRem(b.C, lhs.C, rhs.C, cname)
1368         return
1369 }
1370 func (b Builder) CreateShl(lhs, rhs Value, name string) (v Value) {
1371         cname := C.CString(name)
1372         defer C.free(unsafe.Pointer(cname))
1373         v.C = C.LLVMBuildShl(b.C, lhs.C, rhs.C, cname)
1374         return
1375 }
1376 func (b Builder) CreateLShr(lhs, rhs Value, name string) (v Value) {
1377         cname := C.CString(name)
1378         defer C.free(unsafe.Pointer(cname))
1379         v.C = C.LLVMBuildLShr(b.C, lhs.C, rhs.C, cname)
1380         return
1381 }
1382 func (b Builder) CreateAShr(lhs, rhs Value, name string) (v Value) {
1383         cname := C.CString(name)
1384         defer C.free(unsafe.Pointer(cname))
1385         v.C = C.LLVMBuildAShr(b.C, lhs.C, rhs.C, cname)
1386         return
1387 }
1388 func (b Builder) CreateAnd(lhs, rhs Value, name string) (v Value) {
1389         cname := C.CString(name)
1390         defer C.free(unsafe.Pointer(cname))
1391         v.C = C.LLVMBuildAnd(b.C, lhs.C, rhs.C, cname)
1392         return
1393 }
1394 func (b Builder) CreateOr(lhs, rhs Value, name string) (v Value) {
1395         cname := C.CString(name)
1396         defer C.free(unsafe.Pointer(cname))
1397         v.C = C.LLVMBuildOr(b.C, lhs.C, rhs.C, cname)
1398         return
1399 }
1400 func (b Builder) CreateXor(lhs, rhs Value, name string) (v Value) {
1401         cname := C.CString(name)
1402         defer C.free(unsafe.Pointer(cname))
1403         v.C = C.LLVMBuildXor(b.C, lhs.C, rhs.C, cname)
1404         return
1405 }
1406 func (b Builder) CreateBinOp(op Opcode, lhs, rhs Value, name string) (v Value) {
1407         cname := C.CString(name)
1408         defer C.free(unsafe.Pointer(cname))
1409         v.C = C.LLVMBuildBinOp(b.C, C.LLVMOpcode(op), lhs.C, rhs.C, cname)
1410         return
1411 }
1412 func (b Builder) CreateNeg(v Value, name string) (rv Value) {
1413         cname := C.CString(name)
1414         defer C.free(unsafe.Pointer(cname))
1415         rv.C = C.LLVMBuildNeg(b.C, v.C, cname)
1416         return
1417 }
1418 func (b Builder) CreateNSWNeg(v Value, name string) (rv Value) {
1419         cname := C.CString(name)
1420         defer C.free(unsafe.Pointer(cname))
1421         rv.C = C.LLVMBuildNSWNeg(b.C, v.C, cname)
1422         return
1423 }
1424 func (b Builder) CreateNUWNeg(v Value, name string) (rv Value) {
1425         cname := C.CString(name)
1426         defer C.free(unsafe.Pointer(cname))
1427         rv.C = C.LLVMBuildNUWNeg(b.C, v.C, cname)
1428         return
1429 }
1430 func (b Builder) CreateFNeg(v Value, name string) (rv Value) {
1431         cname := C.CString(name)
1432         defer C.free(unsafe.Pointer(cname))
1433         rv.C = C.LLVMBuildFNeg(b.C, v.C, cname)
1434         return
1435 }
1436 func (b Builder) CreateNot(v Value, name string) (rv Value) {
1437         cname := C.CString(name)
1438         defer C.free(unsafe.Pointer(cname))
1439         rv.C = C.LLVMBuildNot(b.C, v.C, cname)
1440         return
1441 }
1442
1443 // Memory
1444
1445 func (b Builder) CreateMalloc(t Type, name string) (v Value) {
1446         cname := C.CString(name)
1447         defer C.free(unsafe.Pointer(cname))
1448         v.C = C.LLVMBuildMalloc(b.C, t.C, cname)
1449         return
1450 }
1451 func (b Builder) CreateArrayMalloc(t Type, val Value, name string) (v Value) {
1452         cname := C.CString(name)
1453         defer C.free(unsafe.Pointer(cname))
1454         v.C = C.LLVMBuildArrayMalloc(b.C, t.C, val.C, cname)
1455         return
1456 }
1457 func (b Builder) CreateAlloca(t Type, name string) (v Value) {
1458         cname := C.CString(name)
1459         defer C.free(unsafe.Pointer(cname))
1460         v.C = C.LLVMBuildAlloca(b.C, t.C, cname)
1461         return
1462 }
1463 func (b Builder) CreateArrayAlloca(t Type, val Value, name string) (v Value) {
1464         cname := C.CString(name)
1465         defer C.free(unsafe.Pointer(cname))
1466         v.C = C.LLVMBuildArrayAlloca(b.C, t.C, val.C, cname)
1467         return
1468 }
1469 func (b Builder) CreateFree(p Value) (v Value) {
1470         v.C = C.LLVMBuildFree(b.C, p.C)
1471         return
1472 }
1473 func (b Builder) CreateLoad(p Value, name string) (v Value) {
1474         cname := C.CString(name)
1475         defer C.free(unsafe.Pointer(cname))
1476         v.C = C.LLVMBuildLoad(b.C, p.C, cname)
1477         return
1478 }
1479 func (b Builder) CreateStore(val Value, p Value) (v Value) {
1480         v.C = C.LLVMBuildStore(b.C, val.C, p.C)
1481         return
1482 }
1483 func (b Builder) CreateGEP(p Value, indices []Value, name string) (v Value) {
1484         cname := C.CString(name)
1485         defer C.free(unsafe.Pointer(cname))
1486         ptr, nvals := llvmValueRefs(indices)
1487         v.C = C.LLVMBuildGEP(b.C, p.C, ptr, nvals, cname)
1488         return
1489 }
1490 func (b Builder) CreateInBoundsGEP(p Value, indices []Value, name string) (v Value) {
1491         cname := C.CString(name)
1492         defer C.free(unsafe.Pointer(cname))
1493         ptr, nvals := llvmValueRefs(indices)
1494         v.C = C.LLVMBuildInBoundsGEP(b.C, p.C, ptr, nvals, cname)
1495         return
1496 }
1497 func (b Builder) CreateStructGEP(p Value, i int, name string) (v Value) {
1498         cname := C.CString(name)
1499         defer C.free(unsafe.Pointer(cname))
1500         v.C = C.LLVMBuildStructGEP(b.C, p.C, C.unsigned(i), cname)
1501         return
1502 }
1503 func (b Builder) CreateGlobalString(str, name string) (v Value) {
1504         cstr := C.CString(str)
1505         defer C.free(unsafe.Pointer(cstr))
1506         cname := C.CString(name)
1507         defer C.free(unsafe.Pointer(cname))
1508         v.C = C.LLVMBuildGlobalString(b.C, cstr, cname)
1509         return
1510 }
1511 func (b Builder) CreateGlobalStringPtr(str, name string) (v Value) {
1512         cstr := C.CString(str)
1513         defer C.free(unsafe.Pointer(cstr))
1514         cname := C.CString(name)
1515         defer C.free(unsafe.Pointer(cname))
1516         v.C = C.LLVMBuildGlobalStringPtr(b.C, cstr, cname)
1517         return
1518 }
1519
1520 // Casts
1521 func (b Builder) CreateTrunc(val Value, t Type, name string) (v Value) {
1522         cname := C.CString(name)
1523         defer C.free(unsafe.Pointer(cname))
1524         v.C = C.LLVMBuildTrunc(b.C, val.C, t.C, cname)
1525         return
1526 }
1527 func (b Builder) CreateZExt(val Value, t Type, name string) (v Value) {
1528         cname := C.CString(name)
1529         defer C.free(unsafe.Pointer(cname))
1530         v.C = C.LLVMBuildZExt(b.C, val.C, t.C, cname)
1531         return
1532 }
1533 func (b Builder) CreateSExt(val Value, t Type, name string) (v Value) {
1534         cname := C.CString(name)
1535         defer C.free(unsafe.Pointer(cname))
1536         v.C = C.LLVMBuildSExt(b.C, val.C, t.C, cname)
1537         return
1538 }
1539 func (b Builder) CreateFPToUI(val Value, t Type, name string) (v Value) {
1540         cname := C.CString(name)
1541         defer C.free(unsafe.Pointer(cname))
1542         v.C = C.LLVMBuildFPToUI(b.C, val.C, t.C, cname)
1543         return
1544 }
1545 func (b Builder) CreateFPToSI(val Value, t Type, name string) (v Value) {
1546         cname := C.CString(name)
1547         defer C.free(unsafe.Pointer(cname))
1548         v.C = C.LLVMBuildFPToSI(b.C, val.C, t.C, cname)
1549         return
1550 }
1551 func (b Builder) CreateUIToFP(val Value, t Type, name string) (v Value) {
1552         cname := C.CString(name)
1553         defer C.free(unsafe.Pointer(cname))
1554         v.C = C.LLVMBuildUIToFP(b.C, val.C, t.C, cname)
1555         return
1556 }
1557 func (b Builder) CreateSIToFP(val Value, t Type, name string) (v Value) {
1558         cname := C.CString(name)
1559         defer C.free(unsafe.Pointer(cname))
1560         v.C = C.LLVMBuildSIToFP(b.C, val.C, t.C, cname)
1561         return
1562 }
1563 func (b Builder) CreateFPTrunc(val Value, t Type, name string) (v Value) {
1564         cname := C.CString(name)
1565         defer C.free(unsafe.Pointer(cname))
1566         v.C = C.LLVMBuildFPTrunc(b.C, val.C, t.C, cname)
1567         return
1568 }
1569 func (b Builder) CreateFPExt(val Value, t Type, name string) (v Value) {
1570         cname := C.CString(name)
1571         defer C.free(unsafe.Pointer(cname))
1572         v.C = C.LLVMBuildFPExt(b.C, val.C, t.C, cname)
1573         return
1574 }
1575 func (b Builder) CreatePtrToInt(val Value, t Type, name string) (v Value) {
1576         cname := C.CString(name)
1577         defer C.free(unsafe.Pointer(cname))
1578         v.C = C.LLVMBuildPtrToInt(b.C, val.C, t.C, cname)
1579         return
1580 }
1581 func (b Builder) CreateIntToPtr(val Value, t Type, name string) (v Value) {
1582         cname := C.CString(name)
1583         defer C.free(unsafe.Pointer(cname))
1584         v.C = C.LLVMBuildIntToPtr(b.C, val.C, t.C, cname)
1585         return
1586 }
1587 func (b Builder) CreateBitCast(val Value, t Type, name string) (v Value) {
1588         cname := C.CString(name)
1589         defer C.free(unsafe.Pointer(cname))
1590         v.C = C.LLVMBuildBitCast(b.C, val.C, t.C, cname)
1591         return
1592 }
1593 func (b Builder) CreateZExtOrBitCast(val Value, t Type, name string) (v Value) {
1594         cname := C.CString(name)
1595         defer C.free(unsafe.Pointer(cname))
1596         v.C = C.LLVMBuildZExtOrBitCast(b.C, val.C, t.C, cname)
1597         return
1598 }
1599 func (b Builder) CreateSExtOrBitCast(val Value, t Type, name string) (v Value) {
1600         cname := C.CString(name)
1601         defer C.free(unsafe.Pointer(cname))
1602         v.C = C.LLVMBuildSExtOrBitCast(b.C, val.C, t.C, cname)
1603         return
1604 }
1605 func (b Builder) CreateTruncOrBitCast(val Value, t Type, name string) (v Value) {
1606         cname := C.CString(name)
1607         defer C.free(unsafe.Pointer(cname))
1608         v.C = C.LLVMBuildTruncOrBitCast(b.C, val.C, t.C, cname)
1609         return
1610 }
1611 func (b Builder) CreateCast(val Value, op Opcode, t Type, name string) (v Value) {
1612         cname := C.CString(name)
1613         defer C.free(unsafe.Pointer(cname))
1614         v.C = C.LLVMBuildCast(b.C, C.LLVMOpcode(op), val.C, t.C, cname)
1615         return
1616 } //
1617 func (b Builder) CreatePointerCast(val Value, t Type, name string) (v Value) {
1618         cname := C.CString(name)
1619         defer C.free(unsafe.Pointer(cname))
1620         v.C = C.LLVMBuildPointerCast(b.C, val.C, t.C, cname)
1621         return
1622 }
1623 func (b Builder) CreateIntCast(val Value, t Type, name string) (v Value) {
1624         cname := C.CString(name)
1625         defer C.free(unsafe.Pointer(cname))
1626         v.C = C.LLVMBuildIntCast(b.C, val.C, t.C, cname)
1627         return
1628 }
1629 func (b Builder) CreateFPCast(val Value, t Type, name string) (v Value) {
1630         cname := C.CString(name)
1631         defer C.free(unsafe.Pointer(cname))
1632         v.C = C.LLVMBuildFPCast(b.C, val.C, t.C, cname)
1633         return
1634 }
1635
1636 // Comparisons
1637 func (b Builder) CreateICmp(pred IntPredicate, lhs, rhs Value, name string) (v Value) {
1638         cname := C.CString(name)
1639         defer C.free(unsafe.Pointer(cname))
1640         v.C = C.LLVMBuildICmp(b.C, C.LLVMIntPredicate(pred), lhs.C, rhs.C, cname)
1641         return
1642 }
1643 func (b Builder) CreateFCmp(pred FloatPredicate, lhs, rhs Value, name string) (v Value) {
1644         cname := C.CString(name)
1645         defer C.free(unsafe.Pointer(cname))
1646         v.C = C.LLVMBuildFCmp(b.C, C.LLVMRealPredicate(pred), lhs.C, rhs.C, cname)
1647         return
1648 }
1649
1650 // Miscellaneous instructions
1651 func (b Builder) CreatePHI(t Type, name string) (v Value) {
1652         cname := C.CString(name)
1653         defer C.free(unsafe.Pointer(cname))
1654         v.C = C.LLVMBuildPhi(b.C, t.C, cname)
1655         return
1656 }
1657 func (b Builder) CreateCall(fn Value, args []Value, name string) (v Value) {
1658         cname := C.CString(name)
1659         defer C.free(unsafe.Pointer(cname))
1660         ptr, nvals := llvmValueRefs(args)
1661         v.C = C.LLVMBuildCall(b.C, fn.C, ptr, nvals, cname)
1662         return
1663 }
1664
1665 func (b Builder) CreateSelect(ifv, thenv, elsev Value, name string) (v Value) {
1666         cname := C.CString(name)
1667         defer C.free(unsafe.Pointer(cname))
1668         v.C = C.LLVMBuildSelect(b.C, ifv.C, thenv.C, elsev.C, cname)
1669         return
1670 }
1671
1672 func (b Builder) CreateVAArg(list Value, t Type, name string) (v Value) {
1673         cname := C.CString(name)
1674         defer C.free(unsafe.Pointer(cname))
1675         v.C = C.LLVMBuildVAArg(b.C, list.C, t.C, cname)
1676         return
1677 }
1678 func (b Builder) CreateExtractElement(vec, i Value, name string) (v Value) {
1679         cname := C.CString(name)
1680         defer C.free(unsafe.Pointer(cname))
1681         v.C = C.LLVMBuildExtractElement(b.C, vec.C, i.C, cname)
1682         return
1683 }
1684 func (b Builder) CreateInsertElement(vec, elt, i Value, name string) (v Value) {
1685         cname := C.CString(name)
1686         defer C.free(unsafe.Pointer(cname))
1687         v.C = C.LLVMBuildInsertElement(b.C, vec.C, elt.C, i.C, cname)
1688         return
1689 }
1690 func (b Builder) CreateShuffleVector(v1, v2, mask Value, name string) (v Value) {
1691         cname := C.CString(name)
1692         defer C.free(unsafe.Pointer(cname))
1693         v.C = C.LLVMBuildShuffleVector(b.C, v1.C, v2.C, mask.C, cname)
1694         return
1695 }
1696 func (b Builder) CreateExtractValue(agg Value, i int, name string) (v Value) {
1697         cname := C.CString(name)
1698         defer C.free(unsafe.Pointer(cname))
1699         v.C = C.LLVMBuildExtractValue(b.C, agg.C, C.unsigned(i), cname)
1700         return
1701 }
1702 func (b Builder) CreateInsertValue(agg, elt Value, i int, name string) (v Value) {
1703         cname := C.CString(name)
1704         defer C.free(unsafe.Pointer(cname))
1705         v.C = C.LLVMBuildInsertValue(b.C, agg.C, elt.C, C.unsigned(i), cname)
1706         return
1707 }
1708
1709 func (b Builder) CreateIsNull(val Value, name string) (v Value) {
1710         cname := C.CString(name)
1711         defer C.free(unsafe.Pointer(cname))
1712         v.C = C.LLVMBuildIsNull(b.C, val.C, cname)
1713         return
1714 }
1715 func (b Builder) CreateIsNotNull(val Value, name string) (v Value) {
1716         cname := C.CString(name)
1717         defer C.free(unsafe.Pointer(cname))
1718         v.C = C.LLVMBuildIsNotNull(b.C, val.C, cname)
1719         return
1720 }
1721 func (b Builder) CreatePtrDiff(lhs, rhs Value, name string) (v Value) {
1722         cname := C.CString(name)
1723         defer C.free(unsafe.Pointer(cname))
1724         v.C = C.LLVMBuildPtrDiff(b.C, lhs.C, rhs.C, cname)
1725         return
1726 }
1727
1728 func (b Builder) CreateLandingPad(t Type, personality Value, nclauses int, name string) (l Value) {
1729         cname := C.CString(name)
1730         defer C.free(unsafe.Pointer(cname))
1731         l.C = C.LLVMBuildLandingPad(b.C, t.C, C.unsigned(nclauses), cname)
1732         return l
1733 }
1734
1735 func (l Value) AddClause(v Value) {
1736         C.LLVMAddClause(l.C, v.C)
1737 }
1738
1739 func (l Value) SetCleanup(cleanup bool) {
1740         C.LLVMSetCleanup(l.C, boolToLLVMBool(cleanup))
1741 }
1742
1743 func (b Builder) CreateResume(ex Value) (v Value) {
1744         v.C = C.LLVMBuildResume(b.C, ex.C)
1745         return
1746 }
1747
1748 //-------------------------------------------------------------------------
1749 // llvm.ModuleProvider
1750 //-------------------------------------------------------------------------
1751
1752 // Changes the type of M so it can be passed to FunctionPassManagers and the
1753 // JIT. They take ModuleProviders for historical reasons.
1754 func NewModuleProviderForModule(m Module) (mp ModuleProvider) {
1755         mp.C = C.LLVMCreateModuleProviderForExistingModule(m.C)
1756         return
1757 }
1758
1759 // Destroys the module M.
1760 func (mp ModuleProvider) Dispose() { C.LLVMDisposeModuleProvider(mp.C) }
1761
1762 //-------------------------------------------------------------------------
1763 // llvm.MemoryBuffer
1764 //-------------------------------------------------------------------------
1765
1766 func NewMemoryBufferFromFile(path string) (b MemoryBuffer, err error) {
1767         var cmsg *C.char
1768         cpath := C.CString(path)
1769         defer C.free(unsafe.Pointer(cpath))
1770         fail := C.LLVMCreateMemoryBufferWithContentsOfFile(cpath, &b.C, &cmsg)
1771         if fail != 0 {
1772                 b.C = nil
1773                 err = errors.New(C.GoString(cmsg))
1774                 C.LLVMDisposeMessage(cmsg)
1775         }
1776         return
1777 }
1778
1779 func NewMemoryBufferFromStdin() (b MemoryBuffer, err error) {
1780         var cmsg *C.char
1781         fail := C.LLVMCreateMemoryBufferWithSTDIN(&b.C, &cmsg)
1782         if fail != 0 {
1783                 b.C = nil
1784                 err = errors.New(C.GoString(cmsg))
1785                 C.LLVMDisposeMessage(cmsg)
1786         }
1787         return
1788 }
1789
1790 func (b MemoryBuffer) Bytes() []byte {
1791         cstart := C.LLVMGetBufferStart(b.C)
1792         csize := C.LLVMGetBufferSize(b.C)
1793         return C.GoBytes(unsafe.Pointer(cstart), C.int(csize))
1794 }
1795
1796 func (b MemoryBuffer) Dispose() { C.LLVMDisposeMemoryBuffer(b.C) }
1797
1798 //-------------------------------------------------------------------------
1799 // llvm.PassManager
1800 //-------------------------------------------------------------------------
1801
1802 // Constructs a new whole-module pass pipeline. This type of pipeline is
1803 // suitable for link-time optimization and whole-module transformations.
1804 // See llvm::PassManager::PassManager.
1805 func NewPassManager() (pm PassManager) { pm.C = C.LLVMCreatePassManager(); return }
1806
1807 // Constructs a new function-by-function pass pipeline over the module
1808 // provider. It does not take ownership of the module provider. This type of
1809 // pipeline is suitable for code generation and JIT compilation tasks.
1810 // See llvm::FunctionPassManager::FunctionPassManager.
1811 func NewFunctionPassManagerForModule(m Module) (pm PassManager) {
1812         pm.C = C.LLVMCreateFunctionPassManagerForModule(m.C)
1813         return
1814 }
1815
1816 // Initializes, executes on the provided module, and finalizes all of the
1817 // passes scheduled in the pass manager. Returns 1 if any of the passes
1818 // modified the module, 0 otherwise. See llvm::PassManager::run(Module&).
1819 func (pm PassManager) Run(m Module) bool { return C.LLVMRunPassManager(pm.C, m.C) != 0 }
1820
1821 // Initializes all of the function passes scheduled in the function pass
1822 // manager. Returns 1 if any of the passes modified the module, 0 otherwise.
1823 // See llvm::FunctionPassManager::doInitialization.
1824 func (pm PassManager) InitializeFunc() bool { return C.LLVMInitializeFunctionPassManager(pm.C) != 0 }
1825
1826 // Executes all of the function passes scheduled in the function pass manager
1827 // on the provided function. Returns 1 if any of the passes modified the
1828 // function, false otherwise.
1829 // See llvm::FunctionPassManager::run(Function&).
1830 func (pm PassManager) RunFunc(f Value) bool { return C.LLVMRunFunctionPassManager(pm.C, f.C) != 0 }
1831
1832 // Finalizes all of the function passes scheduled in in the function pass
1833 // manager. Returns 1 if any of the passes modified the module, 0 otherwise.
1834 // See llvm::FunctionPassManager::doFinalization.
1835 func (pm PassManager) FinalizeFunc() bool { return C.LLVMFinalizeFunctionPassManager(pm.C) != 0 }
1836
1837 // Frees the memory of a pass pipeline. For function pipelines, does not free
1838 // the module provider.
1839 // See llvm::PassManagerBase::~PassManagerBase.
1840 func (pm PassManager) Dispose() { C.LLVMDisposePassManager(pm.C) }
1841
1842 //-------------------------------------------------------------------------
1843 // llvm.Metadata
1844 //-------------------------------------------------------------------------
1845
1846 func (md Metadata) ReplaceAllUsesWith(new Metadata) {
1847         C.LLVMMetadataReplaceAllUsesWith(md.C, new.C)
1848 }