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(¶mTypes[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 func (v Value) SetPersonality(p Value) { 1058 C.LLVMSetPersonalityFn(v.C, p.C) 1059 } 1060 func (v Value) SetSubprogram(sp Metadata) { 1061 C.LLVMSetSubprogram(v.C, sp.C) 1062 } 1063 1064 // Operations on parameters 1065 func (v Value) ParamsCount() int { return int(C.LLVMCountParams(v.C)) } 1066 func (v Value) Params() []Value { 1067 out := make([]Value, v.ParamsCount()) 1068 if len(out) > 0 { 1069 C.LLVMGetParams(v.C, llvmValueRefPtr(&out[0])) 1070 } 1071 return out 1072 } 1073 func (v Value) Param(i int) (rv Value) { rv.C = C.LLVMGetParam(v.C, C.unsigned(i)); return } 1074 func (v Value) ParamParent() (rv Value) { rv.C = C.LLVMGetParamParent(v.C); return } 1075 func (v Value) FirstParam() (rv Value) { rv.C = C.LLVMGetFirstParam(v.C); return } 1076 func (v Value) LastParam() (rv Value) { rv.C = C.LLVMGetLastParam(v.C); return } 1077 func NextParam(v Value) (rv Value) { rv.C = C.LLVMGetNextParam(v.C); return } 1078 func PrevParam(v Value) (rv Value) { rv.C = C.LLVMGetPreviousParam(v.C); return } 1079 func (v Value) AddAttribute(a Attribute) { 1080 if a >= 1<<32 { 1081 panic("attribute value currently unsupported") 1082 } 1083 C.LLVMAddAttribute(v.C, C.LLVMAttribute(a)) 1084 } 1085 func (v Value) RemoveAttribute(a Attribute) { 1086 if a >= 1<<32 { 1087 panic("attribute value currently unsupported") 1088 } 1089 C.LLVMRemoveAttribute(v.C, C.LLVMAttribute(a)) 1090 } 1091 func (v Value) Attribute() Attribute { return Attribute(C.LLVMGetAttribute(v.C)) } 1092 func (v Value) SetParamAlignment(align int) { C.LLVMSetParamAlignment(v.C, C.unsigned(align)) } 1093 1094 // Operations on basic blocks 1095 func (bb BasicBlock) AsValue() (v Value) { v.C = C.LLVMBasicBlockAsValue(bb.C); return } 1096 func (v Value) IsBasicBlock() bool { return C.LLVMValueIsBasicBlock(v.C) != 0 } 1097 func (v Value) AsBasicBlock() (bb BasicBlock) { bb.C = C.LLVMValueAsBasicBlock(v.C); return } 1098 func (bb BasicBlock) Parent() (v Value) { v.C = C.LLVMGetBasicBlockParent(bb.C); return } 1099 func (v Value) BasicBlocksCount() int { return int(C.LLVMCountBasicBlocks(v.C)) } 1100 func (v Value) BasicBlocks() []BasicBlock { 1101 out := make([]BasicBlock, v.BasicBlocksCount()) 1102 C.LLVMGetBasicBlocks(v.C, llvmBasicBlockRefPtr(&out[0])) 1103 return out 1104 } 1105 func (v Value) FirstBasicBlock() (bb BasicBlock) { bb.C = C.LLVMGetFirstBasicBlock(v.C); return } 1106 func (v Value) LastBasicBlock() (bb BasicBlock) { bb.C = C.LLVMGetLastBasicBlock(v.C); return } 1107 func NextBasicBlock(bb BasicBlock) (rbb BasicBlock) { rbb.C = C.LLVMGetNextBasicBlock(bb.C); return } 1108 func PrevBasicBlock(bb BasicBlock) (rbb BasicBlock) { rbb.C = C.LLVMGetPreviousBasicBlock(bb.C); return } 1109 func (v Value) EntryBasicBlock() (bb BasicBlock) { bb.C = C.LLVMGetEntryBasicBlock(v.C); return } 1110 func (c Context) AddBasicBlock(f Value, name string) (bb BasicBlock) { 1111 cname := C.CString(name) 1112 defer C.free(unsafe.Pointer(cname)) 1113 bb.C = C.LLVMAppendBasicBlockInContext(c.C, f.C, cname) 1114 return 1115 } 1116 func (c Context) InsertBasicBlock(ref BasicBlock, name string) (bb BasicBlock) { 1117 cname := C.CString(name) 1118 defer C.free(unsafe.Pointer(cname)) 1119 bb.C = C.LLVMInsertBasicBlockInContext(c.C, ref.C, cname) 1120 return 1121 } 1122 func AddBasicBlock(f Value, name string) (bb BasicBlock) { 1123 cname := C.CString(name) 1124 defer C.free(unsafe.Pointer(cname)) 1125 bb.C = C.LLVMAppendBasicBlock(f.C, cname) 1126 return 1127 } 1128 func InsertBasicBlock(ref BasicBlock, name string) (bb BasicBlock) { 1129 cname := C.CString(name) 1130 defer C.free(unsafe.Pointer(cname)) 1131 bb.C = C.LLVMInsertBasicBlock(ref.C, cname) 1132 return 1133 } 1134 func (bb BasicBlock) EraseFromParent() { C.LLVMDeleteBasicBlock(bb.C) } 1135 func (bb BasicBlock) MoveBefore(pos BasicBlock) { C.LLVMMoveBasicBlockBefore(bb.C, pos.C) } 1136 func (bb BasicBlock) MoveAfter(pos BasicBlock) { C.LLVMMoveBasicBlockAfter(bb.C, pos.C) } 1137 1138 // Operations on instructions 1139 func (v Value) InstructionParent() (bb BasicBlock) { bb.C = C.LLVMGetInstructionParent(v.C); return } 1140 func (bb BasicBlock) FirstInstruction() (v Value) { v.C = C.LLVMGetFirstInstruction(bb.C); return } 1141 func (bb BasicBlock) LastInstruction() (v Value) { v.C = C.LLVMGetLastInstruction(bb.C); return } 1142 func NextInstruction(v Value) (rv Value) { rv.C = C.LLVMGetNextInstruction(v.C); return } 1143 func PrevInstruction(v Value) (rv Value) { rv.C = C.LLVMGetPreviousInstruction(v.C); return } 1144 1145 // Operations on call sites 1146 func (v Value) SetInstructionCallConv(cc CallConv) { 1147 C.LLVMSetInstructionCallConv(v.C, C.unsigned(cc)) 1148 } 1149 func (v Value) InstructionCallConv() CallConv { 1150 return CallConv(C.LLVMCallConv(C.LLVMGetInstructionCallConv(v.C))) 1151 } 1152 func (v Value) AddInstrAttribute(i int, a Attribute) { 1153 if a >= 1<<32 { 1154 panic("attribute value currently unsupported") 1155 } 1156 C.LLVMAddInstrAttribute(v.C, C.unsigned(i), C.LLVMAttribute(a)) 1157 } 1158 func (v Value) RemoveInstrAttribute(i int, a Attribute) { 1159 if a >= 1<<32 { 1160 panic("attribute value currently unsupported") 1161 } 1162 C.LLVMRemoveInstrAttribute(v.C, C.unsigned(i), C.LLVMAttribute(a)) 1163 } 1164 func (v Value) SetInstrParamAlignment(i int, align int) { 1165 C.LLVMSetInstrParamAlignment(v.C, C.unsigned(i), C.unsigned(align)) 1166 } 1167 1168 // Operations on call instructions (only) 1169 func (v Value) IsTailCall() bool { return C.LLVMIsTailCall(v.C) != 0 } 1170 func (v Value) SetTailCall(is bool) { C.LLVMSetTailCall(v.C, boolToLLVMBool(is)) } 1171 1172 // Operations on phi nodes 1173 func (v Value) AddIncoming(vals []Value, blocks []BasicBlock) { 1174 ptr, nvals := llvmValueRefs(vals) 1175 C.LLVMAddIncoming(v.C, ptr, llvmBasicBlockRefPtr(&blocks[0]), nvals) 1176 } 1177 func (v Value) IncomingCount() int { return int(C.LLVMCountIncoming(v.C)) } 1178 func (v Value) IncomingValue(i int) (rv Value) { 1179 rv.C = C.LLVMGetIncomingValue(v.C, C.unsigned(i)) 1180 return 1181 } 1182 func (v Value) IncomingBlock(i int) (bb BasicBlock) { 1183 bb.C = C.LLVMGetIncomingBlock(v.C, C.unsigned(i)) 1184 return 1185 } 1186 1187 //------------------------------------------------------------------------- 1188 // llvm.Builder 1189 //------------------------------------------------------------------------- 1190 1191 // An instruction builder represents a point within a basic block, and is the 1192 // exclusive means of building instructions using the C interface. 1193 1194 func (c Context) NewBuilder() (b Builder) { b.C = C.LLVMCreateBuilderInContext(c.C); return } 1195 func NewBuilder() (b Builder) { b.C = C.LLVMCreateBuilder(); return } 1196 func (b Builder) SetInsertPoint(block BasicBlock, instr Value) { 1197 C.LLVMPositionBuilder(b.C, block.C, instr.C) 1198 } 1199 func (b Builder) SetInsertPointBefore(instr Value) { C.LLVMPositionBuilderBefore(b.C, instr.C) } 1200 func (b Builder) SetInsertPointAtEnd(block BasicBlock) { C.LLVMPositionBuilderAtEnd(b.C, block.C) } 1201 func (b Builder) GetInsertBlock() (bb BasicBlock) { bb.C = C.LLVMGetInsertBlock(b.C); return } 1202 func (b Builder) ClearInsertionPoint() { C.LLVMClearInsertionPosition(b.C) } 1203 func (b Builder) Insert(instr Value) { C.LLVMInsertIntoBuilder(b.C, instr.C) } 1204 func (b Builder) InsertWithName(instr Value, name string) { 1205 cname := C.CString(name) 1206 defer C.free(unsafe.Pointer(cname)) 1207 C.LLVMInsertIntoBuilderWithName(b.C, instr.C, cname) 1208 } 1209 func (b Builder) Dispose() { C.LLVMDisposeBuilder(b.C) } 1210 1211 // Metadata 1212 func (b Builder) SetCurrentDebugLocation(line, col uint, scope, inlinedAt Metadata) { 1213 C.LLVMSetCurrentDebugLocation2(b.C, C.unsigned(line), C.unsigned(col), scope.C, inlinedAt.C) 1214 } 1215 func (b Builder) SetInstDebugLocation(v Value) { C.LLVMSetInstDebugLocation(b.C, v.C) } 1216 func (b Builder) InsertDeclare(module Module, storage Value, md Value) Value { 1217 f := module.NamedFunction("llvm.dbg.declare") 1218 if f.IsNil() { 1219 ftyp := FunctionType(VoidType(), []Type{storage.Type(), md.Type()}, false) 1220 f = AddFunction(module, "llvm.dbg.declare", ftyp) 1221 } 1222 return b.CreateCall(f, []Value{storage, md}, "") 1223 } 1224 1225 // Terminators 1226 func (b Builder) CreateRetVoid() (rv Value) { rv.C = C.LLVMBuildRetVoid(b.C); return } 1227 func (b Builder) CreateRet(v Value) (rv Value) { rv.C = C.LLVMBuildRet(b.C, v.C); return } 1228 func (b Builder) CreateAggregateRet(vs []Value) (rv Value) { 1229 ptr, nvals := llvmValueRefs(vs) 1230 rv.C = C.LLVMBuildAggregateRet(b.C, ptr, nvals) 1231 return 1232 } 1233 func (b Builder) CreateBr(bb BasicBlock) (rv Value) { rv.C = C.LLVMBuildBr(b.C, bb.C); return } 1234 func (b Builder) CreateCondBr(ifv Value, thenb, elseb BasicBlock) (rv Value) { 1235 rv.C = C.LLVMBuildCondBr(b.C, ifv.C, thenb.C, elseb.C) 1236 return 1237 } 1238 func (b Builder) CreateSwitch(v Value, elseb BasicBlock, numCases int) (rv Value) { 1239 rv.C = C.LLVMBuildSwitch(b.C, v.C, elseb.C, C.unsigned(numCases)) 1240 return 1241 } 1242 func (b Builder) CreateIndirectBr(addr Value, numDests int) (rv Value) { 1243 rv.C = C.LLVMBuildIndirectBr(b.C, addr.C, C.unsigned(numDests)) 1244 return 1245 } 1246 func (b Builder) CreateInvoke(fn Value, args []Value, then, catch BasicBlock, name string) (rv Value) { 1247 cname := C.CString(name) 1248 defer C.free(unsafe.Pointer(cname)) 1249 ptr, nvals := llvmValueRefs(args) 1250 rv.C = C.LLVMBuildInvoke(b.C, fn.C, ptr, nvals, then.C, catch.C, cname) 1251 return 1252 } 1253 func (b Builder) CreateUnreachable() (rv Value) { rv.C = C.LLVMBuildUnreachable(b.C); return } 1254 1255 // Add a case to the switch instruction 1256 func (v Value) AddCase(on Value, dest BasicBlock) { C.LLVMAddCase(v.C, on.C, dest.C) } 1257 1258 // Add a destination to the indirectbr instruction 1259 func (v Value) AddDest(dest BasicBlock) { C.LLVMAddDestination(v.C, dest.C) } 1260 1261 // Arithmetic 1262 func (b Builder) CreateAdd(lhs, rhs Value, name string) (v Value) { 1263 cname := C.CString(name) 1264 defer C.free(unsafe.Pointer(cname)) 1265 v.C = C.LLVMBuildAdd(b.C, lhs.C, rhs.C, cname) 1266 return 1267 } 1268 func (b Builder) CreateNSWAdd(lhs, rhs Value, name string) (v Value) { 1269 cname := C.CString(name) 1270 defer C.free(unsafe.Pointer(cname)) 1271 v.C = C.LLVMBuildNSWAdd(b.C, lhs.C, rhs.C, cname) 1272 return 1273 } 1274 func (b Builder) CreateNUWAdd(lhs, rhs Value, name string) (v Value) { 1275 cname := C.CString(name) 1276 defer C.free(unsafe.Pointer(cname)) 1277 v.C = C.LLVMBuildNUWAdd(b.C, lhs.C, rhs.C, cname) 1278 return 1279 } 1280 func (b Builder) CreateFAdd(lhs, rhs Value, name string) (v Value) { 1281 cname := C.CString(name) 1282 defer C.free(unsafe.Pointer(cname)) 1283 v.C = C.LLVMBuildFAdd(b.C, lhs.C, rhs.C, cname) 1284 return 1285 } 1286 func (b Builder) CreateSub(lhs, rhs Value, name string) (v Value) { 1287 cname := C.CString(name) 1288 defer C.free(unsafe.Pointer(cname)) 1289 v.C = C.LLVMBuildSub(b.C, lhs.C, rhs.C, cname) 1290 return 1291 } 1292 func (b Builder) CreateNSWSub(lhs, rhs Value, name string) (v Value) { 1293 cname := C.CString(name) 1294 defer C.free(unsafe.Pointer(cname)) 1295 v.C = C.LLVMBuildNSWSub(b.C, lhs.C, rhs.C, cname) 1296 return 1297 } 1298 func (b Builder) CreateNUWSub(lhs, rhs Value, name string) (v Value) { 1299 cname := C.CString(name) 1300 defer C.free(unsafe.Pointer(cname)) 1301 v.C = C.LLVMBuildNUWSub(b.C, lhs.C, rhs.C, cname) 1302 return 1303 } 1304 func (b Builder) CreateFSub(lhs, rhs Value, name string) (v Value) { 1305 cname := C.CString(name) 1306 v.C = C.LLVMBuildFSub(b.C, lhs.C, rhs.C, cname) 1307 C.free(unsafe.Pointer(cname)) 1308 return 1309 } 1310 func (b Builder) CreateMul(lhs, rhs Value, name string) (v Value) { 1311 cname := C.CString(name) 1312 defer C.free(unsafe.Pointer(cname)) 1313 v.C = C.LLVMBuildMul(b.C, lhs.C, rhs.C, cname) 1314 return 1315 } 1316 func (b Builder) CreateNSWMul(lhs, rhs Value, name string) (v Value) { 1317 cname := C.CString(name) 1318 defer C.free(unsafe.Pointer(cname)) 1319 v.C = C.LLVMBuildNSWMul(b.C, lhs.C, rhs.C, cname) 1320 return 1321 } 1322 func (b Builder) CreateNUWMul(lhs, rhs Value, name string) (v Value) { 1323 cname := C.CString(name) 1324 defer C.free(unsafe.Pointer(cname)) 1325 v.C = C.LLVMBuildNUWMul(b.C, lhs.C, rhs.C, cname) 1326 return 1327 } 1328 func (b Builder) CreateFMul(lhs, rhs Value, name string) (v Value) { 1329 cname := C.CString(name) 1330 defer C.free(unsafe.Pointer(cname)) 1331 v.C = C.LLVMBuildFMul(b.C, lhs.C, rhs.C, cname) 1332 return 1333 } 1334 func (b Builder) CreateUDiv(lhs, rhs Value, name string) (v Value) { 1335 cname := C.CString(name) 1336 defer C.free(unsafe.Pointer(cname)) 1337 v.C = C.LLVMBuildUDiv(b.C, lhs.C, rhs.C, cname) 1338 return 1339 } 1340 func (b Builder) CreateSDiv(lhs, rhs Value, name string) (v Value) { 1341 cname := C.CString(name) 1342 defer C.free(unsafe.Pointer(cname)) 1343 v.C = C.LLVMBuildSDiv(b.C, lhs.C, rhs.C, cname) 1344 return 1345 } 1346 func (b Builder) CreateExactSDiv(lhs, rhs Value, name string) (v Value) { 1347 cname := C.CString(name) 1348 defer C.free(unsafe.Pointer(cname)) 1349 v.C = C.LLVMBuildExactSDiv(b.C, lhs.C, rhs.C, cname) 1350 return 1351 } 1352 func (b Builder) CreateFDiv(lhs, rhs Value, name string) (v Value) { 1353 cname := C.CString(name) 1354 defer C.free(unsafe.Pointer(cname)) 1355 v.C = C.LLVMBuildFDiv(b.C, lhs.C, rhs.C, cname) 1356 return 1357 } 1358 func (b Builder) CreateURem(lhs, rhs Value, name string) (v Value) { 1359 cname := C.CString(name) 1360 defer C.free(unsafe.Pointer(cname)) 1361 v.C = C.LLVMBuildURem(b.C, lhs.C, rhs.C, cname) 1362 return 1363 } 1364 func (b Builder) CreateSRem(lhs, rhs Value, name string) (v Value) { 1365 cname := C.CString(name) 1366 defer C.free(unsafe.Pointer(cname)) 1367 v.C = C.LLVMBuildSRem(b.C, lhs.C, rhs.C, cname) 1368 return 1369 } 1370 func (b Builder) CreateFRem(lhs, rhs Value, name string) (v Value) { 1371 cname := C.CString(name) 1372 defer C.free(unsafe.Pointer(cname)) 1373 v.C = C.LLVMBuildFRem(b.C, lhs.C, rhs.C, cname) 1374 return 1375 } 1376 func (b Builder) CreateShl(lhs, rhs Value, name string) (v Value) { 1377 cname := C.CString(name) 1378 defer C.free(unsafe.Pointer(cname)) 1379 v.C = C.LLVMBuildShl(b.C, lhs.C, rhs.C, cname) 1380 return 1381 } 1382 func (b Builder) CreateLShr(lhs, rhs Value, name string) (v Value) { 1383 cname := C.CString(name) 1384 defer C.free(unsafe.Pointer(cname)) 1385 v.C = C.LLVMBuildLShr(b.C, lhs.C, rhs.C, cname) 1386 return 1387 } 1388 func (b Builder) CreateAShr(lhs, rhs Value, name string) (v Value) { 1389 cname := C.CString(name) 1390 defer C.free(unsafe.Pointer(cname)) 1391 v.C = C.LLVMBuildAShr(b.C, lhs.C, rhs.C, cname) 1392 return 1393 } 1394 func (b Builder) CreateAnd(lhs, rhs Value, name string) (v Value) { 1395 cname := C.CString(name) 1396 defer C.free(unsafe.Pointer(cname)) 1397 v.C = C.LLVMBuildAnd(b.C, lhs.C, rhs.C, cname) 1398 return 1399 } 1400 func (b Builder) CreateOr(lhs, rhs Value, name string) (v Value) { 1401 cname := C.CString(name) 1402 defer C.free(unsafe.Pointer(cname)) 1403 v.C = C.LLVMBuildOr(b.C, lhs.C, rhs.C, cname) 1404 return 1405 } 1406 func (b Builder) CreateXor(lhs, rhs Value, name string) (v Value) { 1407 cname := C.CString(name) 1408 defer C.free(unsafe.Pointer(cname)) 1409 v.C = C.LLVMBuildXor(b.C, lhs.C, rhs.C, cname) 1410 return 1411 } 1412 func (b Builder) CreateBinOp(op Opcode, lhs, rhs Value, name string) (v Value) { 1413 cname := C.CString(name) 1414 defer C.free(unsafe.Pointer(cname)) 1415 v.C = C.LLVMBuildBinOp(b.C, C.LLVMOpcode(op), lhs.C, rhs.C, cname) 1416 return 1417 } 1418 func (b Builder) CreateNeg(v Value, name string) (rv Value) { 1419 cname := C.CString(name) 1420 defer C.free(unsafe.Pointer(cname)) 1421 rv.C = C.LLVMBuildNeg(b.C, v.C, cname) 1422 return 1423 } 1424 func (b Builder) CreateNSWNeg(v Value, name string) (rv Value) { 1425 cname := C.CString(name) 1426 defer C.free(unsafe.Pointer(cname)) 1427 rv.C = C.LLVMBuildNSWNeg(b.C, v.C, cname) 1428 return 1429 } 1430 func (b Builder) CreateNUWNeg(v Value, name string) (rv Value) { 1431 cname := C.CString(name) 1432 defer C.free(unsafe.Pointer(cname)) 1433 rv.C = C.LLVMBuildNUWNeg(b.C, v.C, cname) 1434 return 1435 } 1436 func (b Builder) CreateFNeg(v Value, name string) (rv Value) { 1437 cname := C.CString(name) 1438 defer C.free(unsafe.Pointer(cname)) 1439 rv.C = C.LLVMBuildFNeg(b.C, v.C, cname) 1440 return 1441 } 1442 func (b Builder) CreateNot(v Value, name string) (rv Value) { 1443 cname := C.CString(name) 1444 defer C.free(unsafe.Pointer(cname)) 1445 rv.C = C.LLVMBuildNot(b.C, v.C, cname) 1446 return 1447 } 1448 1449 // Memory 1450 1451 func (b Builder) CreateMalloc(t Type, name string) (v Value) { 1452 cname := C.CString(name) 1453 defer C.free(unsafe.Pointer(cname)) 1454 v.C = C.LLVMBuildMalloc(b.C, t.C, cname) 1455 return 1456 } 1457 func (b Builder) CreateArrayMalloc(t Type, val Value, name string) (v Value) { 1458 cname := C.CString(name) 1459 defer C.free(unsafe.Pointer(cname)) 1460 v.C = C.LLVMBuildArrayMalloc(b.C, t.C, val.C, cname) 1461 return 1462 } 1463 func (b Builder) CreateAlloca(t Type, name string) (v Value) { 1464 cname := C.CString(name) 1465 defer C.free(unsafe.Pointer(cname)) 1466 v.C = C.LLVMBuildAlloca(b.C, t.C, cname) 1467 return 1468 } 1469 func (b Builder) CreateArrayAlloca(t Type, val Value, name string) (v Value) { 1470 cname := C.CString(name) 1471 defer C.free(unsafe.Pointer(cname)) 1472 v.C = C.LLVMBuildArrayAlloca(b.C, t.C, val.C, cname) 1473 return 1474 } 1475 func (b Builder) CreateFree(p Value) (v Value) { 1476 v.C = C.LLVMBuildFree(b.C, p.C) 1477 return 1478 } 1479 func (b Builder) CreateLoad(p Value, name string) (v Value) { 1480 cname := C.CString(name) 1481 defer C.free(unsafe.Pointer(cname)) 1482 v.C = C.LLVMBuildLoad(b.C, p.C, cname) 1483 return 1484 } 1485 func (b Builder) CreateStore(val Value, p Value) (v Value) { 1486 v.C = C.LLVMBuildStore(b.C, val.C, p.C) 1487 return 1488 } 1489 func (b Builder) CreateGEP(p Value, indices []Value, name string) (v Value) { 1490 cname := C.CString(name) 1491 defer C.free(unsafe.Pointer(cname)) 1492 ptr, nvals := llvmValueRefs(indices) 1493 v.C = C.LLVMBuildGEP(b.C, p.C, ptr, nvals, cname) 1494 return 1495 } 1496 func (b Builder) CreateInBoundsGEP(p Value, indices []Value, name string) (v Value) { 1497 cname := C.CString(name) 1498 defer C.free(unsafe.Pointer(cname)) 1499 ptr, nvals := llvmValueRefs(indices) 1500 v.C = C.LLVMBuildInBoundsGEP(b.C, p.C, ptr, nvals, cname) 1501 return 1502 } 1503 func (b Builder) CreateStructGEP(p Value, i int, name string) (v Value) { 1504 cname := C.CString(name) 1505 defer C.free(unsafe.Pointer(cname)) 1506 v.C = C.LLVMBuildStructGEP(b.C, p.C, C.unsigned(i), cname) 1507 return 1508 } 1509 func (b Builder) CreateGlobalString(str, name string) (v Value) { 1510 cstr := C.CString(str) 1511 defer C.free(unsafe.Pointer(cstr)) 1512 cname := C.CString(name) 1513 defer C.free(unsafe.Pointer(cname)) 1514 v.C = C.LLVMBuildGlobalString(b.C, cstr, cname) 1515 return 1516 } 1517 func (b Builder) CreateGlobalStringPtr(str, name string) (v Value) { 1518 cstr := C.CString(str) 1519 defer C.free(unsafe.Pointer(cstr)) 1520 cname := C.CString(name) 1521 defer C.free(unsafe.Pointer(cname)) 1522 v.C = C.LLVMBuildGlobalStringPtr(b.C, cstr, cname) 1523 return 1524 } 1525 1526 // Casts 1527 func (b Builder) CreateTrunc(val Value, t Type, name string) (v Value) { 1528 cname := C.CString(name) 1529 defer C.free(unsafe.Pointer(cname)) 1530 v.C = C.LLVMBuildTrunc(b.C, val.C, t.C, cname) 1531 return 1532 } 1533 func (b Builder) CreateZExt(val Value, t Type, name string) (v Value) { 1534 cname := C.CString(name) 1535 defer C.free(unsafe.Pointer(cname)) 1536 v.C = C.LLVMBuildZExt(b.C, val.C, t.C, cname) 1537 return 1538 } 1539 func (b Builder) CreateSExt(val Value, t Type, name string) (v Value) { 1540 cname := C.CString(name) 1541 defer C.free(unsafe.Pointer(cname)) 1542 v.C = C.LLVMBuildSExt(b.C, val.C, t.C, cname) 1543 return 1544 } 1545 func (b Builder) CreateFPToUI(val Value, t Type, name string) (v Value) { 1546 cname := C.CString(name) 1547 defer C.free(unsafe.Pointer(cname)) 1548 v.C = C.LLVMBuildFPToUI(b.C, val.C, t.C, cname) 1549 return 1550 } 1551 func (b Builder) CreateFPToSI(val Value, t Type, name string) (v Value) { 1552 cname := C.CString(name) 1553 defer C.free(unsafe.Pointer(cname)) 1554 v.C = C.LLVMBuildFPToSI(b.C, val.C, t.C, cname) 1555 return 1556 } 1557 func (b Builder) CreateUIToFP(val Value, t Type, name string) (v Value) { 1558 cname := C.CString(name) 1559 defer C.free(unsafe.Pointer(cname)) 1560 v.C = C.LLVMBuildUIToFP(b.C, val.C, t.C, cname) 1561 return 1562 } 1563 func (b Builder) CreateSIToFP(val Value, t Type, name string) (v Value) { 1564 cname := C.CString(name) 1565 defer C.free(unsafe.Pointer(cname)) 1566 v.C = C.LLVMBuildSIToFP(b.C, val.C, t.C, cname) 1567 return 1568 } 1569 func (b Builder) CreateFPTrunc(val Value, t Type, name string) (v Value) { 1570 cname := C.CString(name) 1571 defer C.free(unsafe.Pointer(cname)) 1572 v.C = C.LLVMBuildFPTrunc(b.C, val.C, t.C, cname) 1573 return 1574 } 1575 func (b Builder) CreateFPExt(val Value, t Type, name string) (v Value) { 1576 cname := C.CString(name) 1577 defer C.free(unsafe.Pointer(cname)) 1578 v.C = C.LLVMBuildFPExt(b.C, val.C, t.C, cname) 1579 return 1580 } 1581 func (b Builder) CreatePtrToInt(val Value, t Type, name string) (v Value) { 1582 cname := C.CString(name) 1583 defer C.free(unsafe.Pointer(cname)) 1584 v.C = C.LLVMBuildPtrToInt(b.C, val.C, t.C, cname) 1585 return 1586 } 1587 func (b Builder) CreateIntToPtr(val Value, t Type, name string) (v Value) { 1588 cname := C.CString(name) 1589 defer C.free(unsafe.Pointer(cname)) 1590 v.C = C.LLVMBuildIntToPtr(b.C, val.C, t.C, cname) 1591 return 1592 } 1593 func (b Builder) CreateBitCast(val Value, t Type, name string) (v Value) { 1594 cname := C.CString(name) 1595 defer C.free(unsafe.Pointer(cname)) 1596 v.C = C.LLVMBuildBitCast(b.C, val.C, t.C, cname) 1597 return 1598 } 1599 func (b Builder) CreateZExtOrBitCast(val Value, t Type, name string) (v Value) { 1600 cname := C.CString(name) 1601 defer C.free(unsafe.Pointer(cname)) 1602 v.C = C.LLVMBuildZExtOrBitCast(b.C, val.C, t.C, cname) 1603 return 1604 } 1605 func (b Builder) CreateSExtOrBitCast(val Value, t Type, name string) (v Value) { 1606 cname := C.CString(name) 1607 defer C.free(unsafe.Pointer(cname)) 1608 v.C = C.LLVMBuildSExtOrBitCast(b.C, val.C, t.C, cname) 1609 return 1610 } 1611 func (b Builder) CreateTruncOrBitCast(val Value, t Type, name string) (v Value) { 1612 cname := C.CString(name) 1613 defer C.free(unsafe.Pointer(cname)) 1614 v.C = C.LLVMBuildTruncOrBitCast(b.C, val.C, t.C, cname) 1615 return 1616 } 1617 func (b Builder) CreateCast(val Value, op Opcode, t Type, name string) (v Value) { 1618 cname := C.CString(name) 1619 defer C.free(unsafe.Pointer(cname)) 1620 v.C = C.LLVMBuildCast(b.C, C.LLVMOpcode(op), val.C, t.C, cname) 1621 return 1622 } // 1623 func (b Builder) CreatePointerCast(val Value, t Type, name string) (v Value) { 1624 cname := C.CString(name) 1625 defer C.free(unsafe.Pointer(cname)) 1626 v.C = C.LLVMBuildPointerCast(b.C, val.C, t.C, cname) 1627 return 1628 } 1629 func (b Builder) CreateIntCast(val Value, t Type, name string) (v Value) { 1630 cname := C.CString(name) 1631 defer C.free(unsafe.Pointer(cname)) 1632 v.C = C.LLVMBuildIntCast(b.C, val.C, t.C, cname) 1633 return 1634 } 1635 func (b Builder) CreateFPCast(val Value, t Type, name string) (v Value) { 1636 cname := C.CString(name) 1637 defer C.free(unsafe.Pointer(cname)) 1638 v.C = C.LLVMBuildFPCast(b.C, val.C, t.C, cname) 1639 return 1640 } 1641 1642 // Comparisons 1643 func (b Builder) CreateICmp(pred IntPredicate, lhs, rhs Value, name string) (v Value) { 1644 cname := C.CString(name) 1645 defer C.free(unsafe.Pointer(cname)) 1646 v.C = C.LLVMBuildICmp(b.C, C.LLVMIntPredicate(pred), lhs.C, rhs.C, cname) 1647 return 1648 } 1649 func (b Builder) CreateFCmp(pred FloatPredicate, lhs, rhs Value, name string) (v Value) { 1650 cname := C.CString(name) 1651 defer C.free(unsafe.Pointer(cname)) 1652 v.C = C.LLVMBuildFCmp(b.C, C.LLVMRealPredicate(pred), lhs.C, rhs.C, cname) 1653 return 1654 } 1655 1656 // Miscellaneous instructions 1657 func (b Builder) CreatePHI(t Type, name string) (v Value) { 1658 cname := C.CString(name) 1659 defer C.free(unsafe.Pointer(cname)) 1660 v.C = C.LLVMBuildPhi(b.C, t.C, cname) 1661 return 1662 } 1663 func (b Builder) CreateCall(fn Value, args []Value, name string) (v Value) { 1664 cname := C.CString(name) 1665 defer C.free(unsafe.Pointer(cname)) 1666 ptr, nvals := llvmValueRefs(args) 1667 v.C = C.LLVMBuildCall(b.C, fn.C, ptr, nvals, cname) 1668 return 1669 } 1670 1671 func (b Builder) CreateSelect(ifv, thenv, elsev Value, name string) (v Value) { 1672 cname := C.CString(name) 1673 defer C.free(unsafe.Pointer(cname)) 1674 v.C = C.LLVMBuildSelect(b.C, ifv.C, thenv.C, elsev.C, cname) 1675 return 1676 } 1677 1678 func (b Builder) CreateVAArg(list Value, t Type, name string) (v Value) { 1679 cname := C.CString(name) 1680 defer C.free(unsafe.Pointer(cname)) 1681 v.C = C.LLVMBuildVAArg(b.C, list.C, t.C, cname) 1682 return 1683 } 1684 func (b Builder) CreateExtractElement(vec, i Value, name string) (v Value) { 1685 cname := C.CString(name) 1686 defer C.free(unsafe.Pointer(cname)) 1687 v.C = C.LLVMBuildExtractElement(b.C, vec.C, i.C, cname) 1688 return 1689 } 1690 func (b Builder) CreateInsertElement(vec, elt, i Value, name string) (v Value) { 1691 cname := C.CString(name) 1692 defer C.free(unsafe.Pointer(cname)) 1693 v.C = C.LLVMBuildInsertElement(b.C, vec.C, elt.C, i.C, cname) 1694 return 1695 } 1696 func (b Builder) CreateShuffleVector(v1, v2, mask Value, name string) (v Value) { 1697 cname := C.CString(name) 1698 defer C.free(unsafe.Pointer(cname)) 1699 v.C = C.LLVMBuildShuffleVector(b.C, v1.C, v2.C, mask.C, cname) 1700 return 1701 } 1702 func (b Builder) CreateExtractValue(agg Value, i int, name string) (v Value) { 1703 cname := C.CString(name) 1704 defer C.free(unsafe.Pointer(cname)) 1705 v.C = C.LLVMBuildExtractValue(b.C, agg.C, C.unsigned(i), cname) 1706 return 1707 } 1708 func (b Builder) CreateInsertValue(agg, elt Value, i int, name string) (v Value) { 1709 cname := C.CString(name) 1710 defer C.free(unsafe.Pointer(cname)) 1711 v.C = C.LLVMBuildInsertValue(b.C, agg.C, elt.C, C.unsigned(i), cname) 1712 return 1713 } 1714 1715 func (b Builder) CreateIsNull(val Value, name string) (v Value) { 1716 cname := C.CString(name) 1717 defer C.free(unsafe.Pointer(cname)) 1718 v.C = C.LLVMBuildIsNull(b.C, val.C, cname) 1719 return 1720 } 1721 func (b Builder) CreateIsNotNull(val Value, name string) (v Value) { 1722 cname := C.CString(name) 1723 defer C.free(unsafe.Pointer(cname)) 1724 v.C = C.LLVMBuildIsNotNull(b.C, val.C, cname) 1725 return 1726 } 1727 func (b Builder) CreatePtrDiff(lhs, rhs Value, name string) (v Value) { 1728 cname := C.CString(name) 1729 defer C.free(unsafe.Pointer(cname)) 1730 v.C = C.LLVMBuildPtrDiff(b.C, lhs.C, rhs.C, cname) 1731 return 1732 } 1733 1734 func (b Builder) CreateLandingPad(t Type, nclauses int, name string) (l Value) { 1735 cname := C.CString(name) 1736 defer C.free(unsafe.Pointer(cname)) 1737 l.C = C.LLVMBuildLandingPad(b.C, t.C, nil, C.unsigned(nclauses), cname) 1738 return l 1739 } 1740 1741 func (l Value) AddClause(v Value) { 1742 C.LLVMAddClause(l.C, v.C) 1743 } 1744 1745 func (l Value) SetCleanup(cleanup bool) { 1746 C.LLVMSetCleanup(l.C, boolToLLVMBool(cleanup)) 1747 } 1748 1749 func (b Builder) CreateResume(ex Value) (v Value) { 1750 v.C = C.LLVMBuildResume(b.C, ex.C) 1751 return 1752 } 1753 1754 //------------------------------------------------------------------------- 1755 // llvm.ModuleProvider 1756 //------------------------------------------------------------------------- 1757 1758 // Changes the type of M so it can be passed to FunctionPassManagers and the 1759 // JIT. They take ModuleProviders for historical reasons. 1760 func NewModuleProviderForModule(m Module) (mp ModuleProvider) { 1761 mp.C = C.LLVMCreateModuleProviderForExistingModule(m.C) 1762 return 1763 } 1764 1765 // Destroys the module M. 1766 func (mp ModuleProvider) Dispose() { C.LLVMDisposeModuleProvider(mp.C) } 1767 1768 //------------------------------------------------------------------------- 1769 // llvm.MemoryBuffer 1770 //------------------------------------------------------------------------- 1771 1772 func NewMemoryBufferFromFile(path string) (b MemoryBuffer, err error) { 1773 var cmsg *C.char 1774 cpath := C.CString(path) 1775 defer C.free(unsafe.Pointer(cpath)) 1776 fail := C.LLVMCreateMemoryBufferWithContentsOfFile(cpath, &b.C, &cmsg) 1777 if fail != 0 { 1778 b.C = nil 1779 err = errors.New(C.GoString(cmsg)) 1780 C.LLVMDisposeMessage(cmsg) 1781 } 1782 return 1783 } 1784 1785 func NewMemoryBufferFromStdin() (b MemoryBuffer, err error) { 1786 var cmsg *C.char 1787 fail := C.LLVMCreateMemoryBufferWithSTDIN(&b.C, &cmsg) 1788 if fail != 0 { 1789 b.C = nil 1790 err = errors.New(C.GoString(cmsg)) 1791 C.LLVMDisposeMessage(cmsg) 1792 } 1793 return 1794 } 1795 1796 func (b MemoryBuffer) Bytes() []byte { 1797 cstart := C.LLVMGetBufferStart(b.C) 1798 csize := C.LLVMGetBufferSize(b.C) 1799 return C.GoBytes(unsafe.Pointer(cstart), C.int(csize)) 1800 } 1801 1802 func (b MemoryBuffer) Dispose() { C.LLVMDisposeMemoryBuffer(b.C) } 1803 1804 //------------------------------------------------------------------------- 1805 // llvm.PassManager 1806 //------------------------------------------------------------------------- 1807 1808 // Constructs a new whole-module pass pipeline. This type of pipeline is 1809 // suitable for link-time optimization and whole-module transformations. 1810 // See llvm::PassManager::PassManager. 1811 func NewPassManager() (pm PassManager) { pm.C = C.LLVMCreatePassManager(); return } 1812 1813 // Constructs a new function-by-function pass pipeline over the module 1814 // provider. It does not take ownership of the module provider. This type of 1815 // pipeline is suitable for code generation and JIT compilation tasks. 1816 // See llvm::FunctionPassManager::FunctionPassManager. 1817 func NewFunctionPassManagerForModule(m Module) (pm PassManager) { 1818 pm.C = C.LLVMCreateFunctionPassManagerForModule(m.C) 1819 return 1820 } 1821 1822 // Initializes, executes on the provided module, and finalizes all of the 1823 // passes scheduled in the pass manager. Returns 1 if any of the passes 1824 // modified the module, 0 otherwise. See llvm::PassManager::run(Module&). 1825 func (pm PassManager) Run(m Module) bool { return C.LLVMRunPassManager(pm.C, m.C) != 0 } 1826 1827 // Initializes all of the function passes scheduled in the function pass 1828 // manager. Returns 1 if any of the passes modified the module, 0 otherwise. 1829 // See llvm::FunctionPassManager::doInitialization. 1830 func (pm PassManager) InitializeFunc() bool { return C.LLVMInitializeFunctionPassManager(pm.C) != 0 } 1831 1832 // Executes all of the function passes scheduled in the function pass manager 1833 // on the provided function. Returns 1 if any of the passes modified the 1834 // function, false otherwise. 1835 // See llvm::FunctionPassManager::run(Function&). 1836 func (pm PassManager) RunFunc(f Value) bool { return C.LLVMRunFunctionPassManager(pm.C, f.C) != 0 } 1837 1838 // Finalizes all of the function passes scheduled in in the function pass 1839 // manager. Returns 1 if any of the passes modified the module, 0 otherwise. 1840 // See llvm::FunctionPassManager::doFinalization. 1841 func (pm PassManager) FinalizeFunc() bool { return C.LLVMFinalizeFunctionPassManager(pm.C) != 0 } 1842 1843 // Frees the memory of a pass pipeline. For function pipelines, does not free 1844 // the module provider. 1845 // See llvm::PassManagerBase::~PassManagerBase. 1846 func (pm PassManager) Dispose() { C.LLVMDisposePassManager(pm.C) } 1847 1848 //------------------------------------------------------------------------- 1849 // llvm.Metadata 1850 //------------------------------------------------------------------------- 1851 1852 func (md Metadata) ReplaceAllUsesWith(new Metadata) { 1853 C.LLVMMetadataReplaceAllUsesWith(md.C, new.C) 1854 } 1855