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