1 //===-- Core.cpp ----------------------------------------------------------===// 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 implements the common infrastructure (including the C bindings) 11 // for libLLVMCore.a, which implements the LLVM intermediate representation. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm-c/Core.h" 16 #include "llvm/Attributes.h" 17 #include "llvm/Bitcode/ReaderWriter.h" 18 #include "llvm/Constants.h" 19 #include "llvm/DerivedTypes.h" 20 #include "llvm/GlobalVariable.h" 21 #include "llvm/GlobalAlias.h" 22 #include "llvm/LLVMContext.h" 23 #include "llvm/InlineAsm.h" 24 #include "llvm/IntrinsicInst.h" 25 #include "llvm/PassManager.h" 26 #include "llvm/Support/CallSite.h" 27 #include "llvm/Support/Debug.h" 28 #include "llvm/Support/ErrorHandling.h" 29 #include "llvm/Support/MemoryBuffer.h" 30 #include "llvm/Support/raw_ostream.h" 31 #include "llvm/Support/system_error.h" 32 #include <cassert> 33 #include <cstdlib> 34 #include <cstring> 35 36 using namespace llvm; 37 38 void llvm::initializeCore(PassRegistry &Registry) { 39 initializeDominatorTreePass(Registry); 40 initializePrintModulePassPass(Registry); 41 initializePrintFunctionPassPass(Registry); 42 initializeVerifierPass(Registry); 43 initializePreVerifierPass(Registry); 44 } 45 46 void LLVMInitializeCore(LLVMPassRegistryRef R) { 47 initializeCore(*unwrap(R)); 48 } 49 50 /*===-- Error handling ----------------------------------------------------===*/ 51 52 void LLVMDisposeMessage(char *Message) { 53 free(Message); 54 } 55 56 57 /*===-- Operations on contexts --------------------------------------------===*/ 58 59 LLVMContextRef LLVMContextCreate() { 60 return wrap(new LLVMContext()); 61 } 62 63 LLVMContextRef LLVMGetGlobalContext() { 64 return wrap(&getGlobalContext()); 65 } 66 67 void LLVMContextDispose(LLVMContextRef C) { 68 delete unwrap(C); 69 } 70 71 unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char* Name, 72 unsigned SLen) { 73 return unwrap(C)->getMDKindID(StringRef(Name, SLen)); 74 } 75 76 unsigned LLVMGetMDKindID(const char* Name, unsigned SLen) { 77 return LLVMGetMDKindIDInContext(LLVMGetGlobalContext(), Name, SLen); 78 } 79 80 81 /*===-- Operations on modules ---------------------------------------------===*/ 82 83 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID) { 84 return wrap(new Module(ModuleID, getGlobalContext())); 85 } 86 87 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID, 88 LLVMContextRef C) { 89 return wrap(new Module(ModuleID, *unwrap(C))); 90 } 91 92 void LLVMDisposeModule(LLVMModuleRef M) { 93 delete unwrap(M); 94 } 95 96 /*--.. Data layout .........................................................--*/ 97 const char * LLVMGetDataLayout(LLVMModuleRef M) { 98 return unwrap(M)->getDataLayout().c_str(); 99 } 100 101 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple) { 102 unwrap(M)->setDataLayout(Triple); 103 } 104 105 /*--.. Target triple .......................................................--*/ 106 const char * LLVMGetTarget(LLVMModuleRef M) { 107 return unwrap(M)->getTargetTriple().c_str(); 108 } 109 110 void LLVMSetTarget(LLVMModuleRef M, const char *Triple) { 111 unwrap(M)->setTargetTriple(Triple); 112 } 113 114 void LLVMDumpModule(LLVMModuleRef M) { 115 unwrap(M)->dump(); 116 } 117 118 LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename, 119 char **ErrorMessage) { 120 std::string error; 121 raw_fd_ostream dest(Filename, error); 122 if (!error.empty()) { 123 *ErrorMessage = strdup(error.c_str()); 124 return true; 125 } 126 127 unwrap(M)->print(dest, NULL); 128 129 if (!error.empty()) { 130 *ErrorMessage = strdup(error.c_str()); 131 return true; 132 } 133 dest.flush(); 134 return false; 135 } 136 137 /*--.. Operations on inline assembler ......................................--*/ 138 void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm) { 139 unwrap(M)->setModuleInlineAsm(StringRef(Asm)); 140 } 141 142 143 /*--.. Operations on module contexts ......................................--*/ 144 LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M) { 145 return wrap(&unwrap(M)->getContext()); 146 } 147 148 149 /*===-- Operations on types -----------------------------------------------===*/ 150 151 /*--.. Operations on all types (mostly) ....................................--*/ 152 153 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) { 154 switch (unwrap(Ty)->getTypeID()) { 155 default: llvm_unreachable("Unhandled TypeID."); 156 case Type::VoidTyID: 157 return LLVMVoidTypeKind; 158 case Type::HalfTyID: 159 return LLVMHalfTypeKind; 160 case Type::FloatTyID: 161 return LLVMFloatTypeKind; 162 case Type::DoubleTyID: 163 return LLVMDoubleTypeKind; 164 case Type::X86_FP80TyID: 165 return LLVMX86_FP80TypeKind; 166 case Type::FP128TyID: 167 return LLVMFP128TypeKind; 168 case Type::PPC_FP128TyID: 169 return LLVMPPC_FP128TypeKind; 170 case Type::LabelTyID: 171 return LLVMLabelTypeKind; 172 case Type::MetadataTyID: 173 return LLVMMetadataTypeKind; 174 case Type::IntegerTyID: 175 return LLVMIntegerTypeKind; 176 case Type::FunctionTyID: 177 return LLVMFunctionTypeKind; 178 case Type::StructTyID: 179 return LLVMStructTypeKind; 180 case Type::ArrayTyID: 181 return LLVMArrayTypeKind; 182 case Type::PointerTyID: 183 return LLVMPointerTypeKind; 184 case Type::VectorTyID: 185 return LLVMVectorTypeKind; 186 case Type::X86_MMXTyID: 187 return LLVMX86_MMXTypeKind; 188 } 189 } 190 191 LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty) 192 { 193 return unwrap(Ty)->isSized(); 194 } 195 196 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty) { 197 return wrap(&unwrap(Ty)->getContext()); 198 } 199 200 /*--.. Operations on integer types .........................................--*/ 201 202 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C) { 203 return (LLVMTypeRef) Type::getInt1Ty(*unwrap(C)); 204 } 205 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C) { 206 return (LLVMTypeRef) Type::getInt8Ty(*unwrap(C)); 207 } 208 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C) { 209 return (LLVMTypeRef) Type::getInt16Ty(*unwrap(C)); 210 } 211 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C) { 212 return (LLVMTypeRef) Type::getInt32Ty(*unwrap(C)); 213 } 214 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C) { 215 return (LLVMTypeRef) Type::getInt64Ty(*unwrap(C)); 216 } 217 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits) { 218 return wrap(IntegerType::get(*unwrap(C), NumBits)); 219 } 220 221 LLVMTypeRef LLVMInt1Type(void) { 222 return LLVMInt1TypeInContext(LLVMGetGlobalContext()); 223 } 224 LLVMTypeRef LLVMInt8Type(void) { 225 return LLVMInt8TypeInContext(LLVMGetGlobalContext()); 226 } 227 LLVMTypeRef LLVMInt16Type(void) { 228 return LLVMInt16TypeInContext(LLVMGetGlobalContext()); 229 } 230 LLVMTypeRef LLVMInt32Type(void) { 231 return LLVMInt32TypeInContext(LLVMGetGlobalContext()); 232 } 233 LLVMTypeRef LLVMInt64Type(void) { 234 return LLVMInt64TypeInContext(LLVMGetGlobalContext()); 235 } 236 LLVMTypeRef LLVMIntType(unsigned NumBits) { 237 return LLVMIntTypeInContext(LLVMGetGlobalContext(), NumBits); 238 } 239 240 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy) { 241 return unwrap<IntegerType>(IntegerTy)->getBitWidth(); 242 } 243 244 /*--.. Operations on real types ............................................--*/ 245 246 LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C) { 247 return (LLVMTypeRef) Type::getHalfTy(*unwrap(C)); 248 } 249 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C) { 250 return (LLVMTypeRef) Type::getFloatTy(*unwrap(C)); 251 } 252 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C) { 253 return (LLVMTypeRef) Type::getDoubleTy(*unwrap(C)); 254 } 255 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C) { 256 return (LLVMTypeRef) Type::getX86_FP80Ty(*unwrap(C)); 257 } 258 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C) { 259 return (LLVMTypeRef) Type::getFP128Ty(*unwrap(C)); 260 } 261 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C) { 262 return (LLVMTypeRef) Type::getPPC_FP128Ty(*unwrap(C)); 263 } 264 LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C) { 265 return (LLVMTypeRef) Type::getX86_MMXTy(*unwrap(C)); 266 } 267 268 LLVMTypeRef LLVMHalfType(void) { 269 return LLVMHalfTypeInContext(LLVMGetGlobalContext()); 270 } 271 LLVMTypeRef LLVMFloatType(void) { 272 return LLVMFloatTypeInContext(LLVMGetGlobalContext()); 273 } 274 LLVMTypeRef LLVMDoubleType(void) { 275 return LLVMDoubleTypeInContext(LLVMGetGlobalContext()); 276 } 277 LLVMTypeRef LLVMX86FP80Type(void) { 278 return LLVMX86FP80TypeInContext(LLVMGetGlobalContext()); 279 } 280 LLVMTypeRef LLVMFP128Type(void) { 281 return LLVMFP128TypeInContext(LLVMGetGlobalContext()); 282 } 283 LLVMTypeRef LLVMPPCFP128Type(void) { 284 return LLVMPPCFP128TypeInContext(LLVMGetGlobalContext()); 285 } 286 LLVMTypeRef LLVMX86MMXType(void) { 287 return LLVMX86MMXTypeInContext(LLVMGetGlobalContext()); 288 } 289 290 /*--.. Operations on function types ........................................--*/ 291 292 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, 293 LLVMTypeRef *ParamTypes, unsigned ParamCount, 294 LLVMBool IsVarArg) { 295 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount); 296 return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0)); 297 } 298 299 LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) { 300 return unwrap<FunctionType>(FunctionTy)->isVarArg(); 301 } 302 303 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy) { 304 return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType()); 305 } 306 307 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy) { 308 return unwrap<FunctionType>(FunctionTy)->getNumParams(); 309 } 310 311 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest) { 312 FunctionType *Ty = unwrap<FunctionType>(FunctionTy); 313 for (FunctionType::param_iterator I = Ty->param_begin(), 314 E = Ty->param_end(); I != E; ++I) 315 *Dest++ = wrap(*I); 316 } 317 318 /*--.. Operations on struct types ..........................................--*/ 319 320 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, 321 unsigned ElementCount, LLVMBool Packed) { 322 ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount); 323 return wrap(StructType::get(*unwrap(C), Tys, Packed != 0)); 324 } 325 326 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, 327 unsigned ElementCount, LLVMBool Packed) { 328 return LLVMStructTypeInContext(LLVMGetGlobalContext(), ElementTypes, 329 ElementCount, Packed); 330 } 331 332 LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name) 333 { 334 return wrap(StructType::create(*unwrap(C), Name)); 335 } 336 337 const char *LLVMGetStructName(LLVMTypeRef Ty) 338 { 339 StructType *Type = unwrap<StructType>(Ty); 340 if (!Type->hasName()) 341 return 0; 342 return Type->getName().data(); 343 } 344 345 void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes, 346 unsigned ElementCount, LLVMBool Packed) { 347 ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount); 348 unwrap<StructType>(StructTy)->setBody(Tys, Packed != 0); 349 } 350 351 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy) { 352 return unwrap<StructType>(StructTy)->getNumElements(); 353 } 354 355 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest) { 356 StructType *Ty = unwrap<StructType>(StructTy); 357 for (StructType::element_iterator I = Ty->element_begin(), 358 E = Ty->element_end(); I != E; ++I) 359 *Dest++ = wrap(*I); 360 } 361 362 LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy) { 363 return unwrap<StructType>(StructTy)->isPacked(); 364 } 365 366 LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy) { 367 return unwrap<StructType>(StructTy)->isOpaque(); 368 } 369 370 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name) { 371 return wrap(unwrap(M)->getTypeByName(Name)); 372 } 373 374 /*--.. Operations on array, pointer, and vector types (sequence types) .....--*/ 375 376 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount) { 377 return wrap(ArrayType::get(unwrap(ElementType), ElementCount)); 378 } 379 380 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace) { 381 return wrap(PointerType::get(unwrap(ElementType), AddressSpace)); 382 } 383 384 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) { 385 return wrap(VectorType::get(unwrap(ElementType), ElementCount)); 386 } 387 388 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty) { 389 return wrap(unwrap<SequentialType>(Ty)->getElementType()); 390 } 391 392 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) { 393 return unwrap<ArrayType>(ArrayTy)->getNumElements(); 394 } 395 396 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy) { 397 return unwrap<PointerType>(PointerTy)->getAddressSpace(); 398 } 399 400 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) { 401 return unwrap<VectorType>(VectorTy)->getNumElements(); 402 } 403 404 /*--.. Operations on other types ...........................................--*/ 405 406 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C) { 407 return wrap(Type::getVoidTy(*unwrap(C))); 408 } 409 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C) { 410 return wrap(Type::getLabelTy(*unwrap(C))); 411 } 412 413 LLVMTypeRef LLVMVoidType(void) { 414 return LLVMVoidTypeInContext(LLVMGetGlobalContext()); 415 } 416 LLVMTypeRef LLVMLabelType(void) { 417 return LLVMLabelTypeInContext(LLVMGetGlobalContext()); 418 } 419 420 /*===-- Operations on values ----------------------------------------------===*/ 421 422 /*--.. Operations on all values ............................................--*/ 423 424 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val) { 425 return wrap(unwrap(Val)->getType()); 426 } 427 428 const char *LLVMGetValueName(LLVMValueRef Val) { 429 return unwrap(Val)->getName().data(); 430 } 431 432 void LLVMSetValueName(LLVMValueRef Val, const char *Name) { 433 unwrap(Val)->setName(Name); 434 } 435 436 void LLVMDumpValue(LLVMValueRef Val) { 437 unwrap(Val)->dump(); 438 } 439 440 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal) { 441 unwrap(OldVal)->replaceAllUsesWith(unwrap(NewVal)); 442 } 443 444 int LLVMHasMetadata(LLVMValueRef Inst) { 445 return unwrap<Instruction>(Inst)->hasMetadata(); 446 } 447 448 LLVMValueRef LLVMGetMetadata(LLVMValueRef Inst, unsigned KindID) { 449 return wrap(unwrap<Instruction>(Inst)->getMetadata(KindID)); 450 } 451 452 void LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef MD) { 453 unwrap<Instruction>(Inst)->setMetadata(KindID, MD? unwrap<MDNode>(MD) : NULL); 454 } 455 456 /*--.. Conversion functions ................................................--*/ 457 458 #define LLVM_DEFINE_VALUE_CAST(name) \ 459 LLVMValueRef LLVMIsA##name(LLVMValueRef Val) { \ 460 return wrap(static_cast<Value*>(dyn_cast_or_null<name>(unwrap(Val)))); \ 461 } 462 463 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DEFINE_VALUE_CAST) 464 465 /*--.. Operations on Uses ..................................................--*/ 466 LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val) { 467 Value *V = unwrap(Val); 468 Value::use_iterator I = V->use_begin(); 469 if (I == V->use_end()) 470 return 0; 471 return wrap(&(I.getUse())); 472 } 473 474 LLVMUseRef LLVMGetNextUse(LLVMUseRef U) { 475 Use *Next = unwrap(U)->getNext(); 476 if (Next) 477 return wrap(Next); 478 return 0; 479 } 480 481 LLVMValueRef LLVMGetUser(LLVMUseRef U) { 482 return wrap(unwrap(U)->getUser()); 483 } 484 485 LLVMValueRef LLVMGetUsedValue(LLVMUseRef U) { 486 return wrap(unwrap(U)->get()); 487 } 488 489 /*--.. Operations on Users .................................................--*/ 490 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index) { 491 Value *V = unwrap(Val); 492 if (MDNode *MD = dyn_cast<MDNode>(V)) 493 return wrap(MD->getOperand(Index)); 494 return wrap(cast<User>(V)->getOperand(Index)); 495 } 496 497 void LLVMSetOperand(LLVMValueRef Val, unsigned Index, LLVMValueRef Op) { 498 unwrap<User>(Val)->setOperand(Index, unwrap(Op)); 499 } 500 501 int LLVMGetNumOperands(LLVMValueRef Val) { 502 Value *V = unwrap(Val); 503 if (MDNode *MD = dyn_cast<MDNode>(V)) 504 return MD->getNumOperands(); 505 return cast<User>(V)->getNumOperands(); 506 } 507 508 /*--.. Operations on constants of any type .................................--*/ 509 510 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty) { 511 return wrap(Constant::getNullValue(unwrap(Ty))); 512 } 513 514 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty) { 515 return wrap(Constant::getAllOnesValue(unwrap(Ty))); 516 } 517 518 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) { 519 return wrap(UndefValue::get(unwrap(Ty))); 520 } 521 522 LLVMBool LLVMIsConstant(LLVMValueRef Ty) { 523 return isa<Constant>(unwrap(Ty)); 524 } 525 526 LLVMBool LLVMIsNull(LLVMValueRef Val) { 527 if (Constant *C = dyn_cast<Constant>(unwrap(Val))) 528 return C->isNullValue(); 529 return false; 530 } 531 532 LLVMBool LLVMIsUndef(LLVMValueRef Val) { 533 return isa<UndefValue>(unwrap(Val)); 534 } 535 536 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) { 537 return 538 wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty))); 539 } 540 541 /*--.. Operations on metadata nodes ........................................--*/ 542 543 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str, 544 unsigned SLen) { 545 return wrap(MDString::get(*unwrap(C), StringRef(Str, SLen))); 546 } 547 548 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen) { 549 return LLVMMDStringInContext(LLVMGetGlobalContext(), Str, SLen); 550 } 551 552 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals, 553 unsigned Count) { 554 return wrap(MDNode::get(*unwrap(C), 555 makeArrayRef(unwrap<Value>(Vals, Count), Count))); 556 } 557 558 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count) { 559 return LLVMMDNodeInContext(LLVMGetGlobalContext(), Vals, Count); 560 } 561 562 const char *LLVMGetMDString(LLVMValueRef V, unsigned* Len) { 563 if (const MDString *S = dyn_cast<MDString>(unwrap(V))) { 564 *Len = S->getString().size(); 565 return S->getString().data(); 566 } 567 *Len = 0; 568 return 0; 569 } 570 571 unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char* name) 572 { 573 if (NamedMDNode *N = unwrap(M)->getNamedMetadata(name)) { 574 return N->getNumOperands(); 575 } 576 return 0; 577 } 578 579 void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char* name, LLVMValueRef *Dest) 580 { 581 NamedMDNode *N = unwrap(M)->getNamedMetadata(name); 582 if (!N) 583 return; 584 for (unsigned i=0;i<N->getNumOperands();i++) 585 Dest[i] = wrap(N->getOperand(i)); 586 } 587 588 void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char* name, 589 LLVMValueRef Val) 590 { 591 NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(name); 592 if (!N) 593 return; 594 MDNode *Op = Val ? unwrap<MDNode>(Val) : NULL; 595 if (Op) 596 N->addOperand(Op); 597 } 598 599 /*--.. Operations on scalar constants ......................................--*/ 600 601 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, 602 LLVMBool SignExtend) { 603 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0)); 604 } 605 606 LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy, 607 unsigned NumWords, 608 const uint64_t Words[]) { 609 IntegerType *Ty = unwrap<IntegerType>(IntTy); 610 return wrap(ConstantInt::get(Ty->getContext(), 611 APInt(Ty->getBitWidth(), 612 makeArrayRef(Words, NumWords)))); 613 } 614 615 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char Str[], 616 uint8_t Radix) { 617 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str), 618 Radix)); 619 } 620 621 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char Str[], 622 unsigned SLen, uint8_t Radix) { 623 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str, SLen), 624 Radix)); 625 } 626 627 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N) { 628 return wrap(ConstantFP::get(unwrap(RealTy), N)); 629 } 630 631 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text) { 632 return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Text))); 633 } 634 635 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char Str[], 636 unsigned SLen) { 637 return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Str, SLen))); 638 } 639 640 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal) { 641 return unwrap<ConstantInt>(ConstantVal)->getZExtValue(); 642 } 643 644 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal) { 645 return unwrap<ConstantInt>(ConstantVal)->getSExtValue(); 646 } 647 648 /*--.. Operations on composite constants ...................................--*/ 649 650 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str, 651 unsigned Length, 652 LLVMBool DontNullTerminate) { 653 /* Inverted the sense of AddNull because ', 0)' is a 654 better mnemonic for null termination than ', 1)'. */ 655 return wrap(ConstantDataArray::getString(*unwrap(C), StringRef(Str, Length), 656 DontNullTerminate == 0)); 657 } 658 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C, 659 LLVMValueRef *ConstantVals, 660 unsigned Count, LLVMBool Packed) { 661 Constant **Elements = unwrap<Constant>(ConstantVals, Count); 662 return wrap(ConstantStruct::getAnon(*unwrap(C), makeArrayRef(Elements, Count), 663 Packed != 0)); 664 } 665 666 LLVMValueRef LLVMConstString(const char *Str, unsigned Length, 667 LLVMBool DontNullTerminate) { 668 return LLVMConstStringInContext(LLVMGetGlobalContext(), Str, Length, 669 DontNullTerminate); 670 } 671 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, 672 LLVMValueRef *ConstantVals, unsigned Length) { 673 ArrayRef<Constant*> V(unwrap<Constant>(ConstantVals, Length), Length); 674 return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V)); 675 } 676 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, 677 LLVMBool Packed) { 678 return LLVMConstStructInContext(LLVMGetGlobalContext(), ConstantVals, Count, 679 Packed); 680 } 681 682 LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy, 683 LLVMValueRef *ConstantVals, 684 unsigned Count) { 685 Constant **Elements = unwrap<Constant>(ConstantVals, Count); 686 StructType *Ty = cast<StructType>(unwrap(StructTy)); 687 688 return wrap(ConstantStruct::get(Ty, makeArrayRef(Elements, Count))); 689 } 690 691 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) { 692 return wrap(ConstantVector::get(makeArrayRef( 693 unwrap<Constant>(ScalarConstantVals, Size), Size))); 694 } 695 696 /*-- Opcode mapping */ 697 698 static LLVMOpcode map_to_llvmopcode(int opcode) 699 { 700 switch (opcode) { 701 default: llvm_unreachable("Unhandled Opcode."); 702 #define HANDLE_INST(num, opc, clas) case num: return LLVM##opc; 703 #include "llvm/Instruction.def" 704 #undef HANDLE_INST 705 } 706 } 707 708 static int map_from_llvmopcode(LLVMOpcode code) 709 { 710 switch (code) { 711 #define HANDLE_INST(num, opc, clas) case LLVM##opc: return num; 712 #include "llvm/Instruction.def" 713 #undef HANDLE_INST 714 } 715 llvm_unreachable("Unhandled Opcode."); 716 } 717 718 /*--.. Constant expressions ................................................--*/ 719 720 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal) { 721 return map_to_llvmopcode(unwrap<ConstantExpr>(ConstantVal)->getOpcode()); 722 } 723 724 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty) { 725 return wrap(ConstantExpr::getAlignOf(unwrap(Ty))); 726 } 727 728 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty) { 729 return wrap(ConstantExpr::getSizeOf(unwrap(Ty))); 730 } 731 732 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal) { 733 return wrap(ConstantExpr::getNeg(unwrap<Constant>(ConstantVal))); 734 } 735 736 LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal) { 737 return wrap(ConstantExpr::getNSWNeg(unwrap<Constant>(ConstantVal))); 738 } 739 740 LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal) { 741 return wrap(ConstantExpr::getNUWNeg(unwrap<Constant>(ConstantVal))); 742 } 743 744 745 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal) { 746 return wrap(ConstantExpr::getFNeg(unwrap<Constant>(ConstantVal))); 747 } 748 749 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal) { 750 return wrap(ConstantExpr::getNot(unwrap<Constant>(ConstantVal))); 751 } 752 753 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 754 return wrap(ConstantExpr::getAdd(unwrap<Constant>(LHSConstant), 755 unwrap<Constant>(RHSConstant))); 756 } 757 758 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, 759 LLVMValueRef RHSConstant) { 760 return wrap(ConstantExpr::getNSWAdd(unwrap<Constant>(LHSConstant), 761 unwrap<Constant>(RHSConstant))); 762 } 763 764 LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, 765 LLVMValueRef RHSConstant) { 766 return wrap(ConstantExpr::getNUWAdd(unwrap<Constant>(LHSConstant), 767 unwrap<Constant>(RHSConstant))); 768 } 769 770 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 771 return wrap(ConstantExpr::getFAdd(unwrap<Constant>(LHSConstant), 772 unwrap<Constant>(RHSConstant))); 773 } 774 775 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 776 return wrap(ConstantExpr::getSub(unwrap<Constant>(LHSConstant), 777 unwrap<Constant>(RHSConstant))); 778 } 779 780 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, 781 LLVMValueRef RHSConstant) { 782 return wrap(ConstantExpr::getNSWSub(unwrap<Constant>(LHSConstant), 783 unwrap<Constant>(RHSConstant))); 784 } 785 786 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, 787 LLVMValueRef RHSConstant) { 788 return wrap(ConstantExpr::getNUWSub(unwrap<Constant>(LHSConstant), 789 unwrap<Constant>(RHSConstant))); 790 } 791 792 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 793 return wrap(ConstantExpr::getFSub(unwrap<Constant>(LHSConstant), 794 unwrap<Constant>(RHSConstant))); 795 } 796 797 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 798 return wrap(ConstantExpr::getMul(unwrap<Constant>(LHSConstant), 799 unwrap<Constant>(RHSConstant))); 800 } 801 802 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, 803 LLVMValueRef RHSConstant) { 804 return wrap(ConstantExpr::getNSWMul(unwrap<Constant>(LHSConstant), 805 unwrap<Constant>(RHSConstant))); 806 } 807 808 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, 809 LLVMValueRef RHSConstant) { 810 return wrap(ConstantExpr::getNUWMul(unwrap<Constant>(LHSConstant), 811 unwrap<Constant>(RHSConstant))); 812 } 813 814 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 815 return wrap(ConstantExpr::getFMul(unwrap<Constant>(LHSConstant), 816 unwrap<Constant>(RHSConstant))); 817 } 818 819 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 820 return wrap(ConstantExpr::getUDiv(unwrap<Constant>(LHSConstant), 821 unwrap<Constant>(RHSConstant))); 822 } 823 824 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 825 return wrap(ConstantExpr::getSDiv(unwrap<Constant>(LHSConstant), 826 unwrap<Constant>(RHSConstant))); 827 } 828 829 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, 830 LLVMValueRef RHSConstant) { 831 return wrap(ConstantExpr::getExactSDiv(unwrap<Constant>(LHSConstant), 832 unwrap<Constant>(RHSConstant))); 833 } 834 835 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 836 return wrap(ConstantExpr::getFDiv(unwrap<Constant>(LHSConstant), 837 unwrap<Constant>(RHSConstant))); 838 } 839 840 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 841 return wrap(ConstantExpr::getURem(unwrap<Constant>(LHSConstant), 842 unwrap<Constant>(RHSConstant))); 843 } 844 845 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 846 return wrap(ConstantExpr::getSRem(unwrap<Constant>(LHSConstant), 847 unwrap<Constant>(RHSConstant))); 848 } 849 850 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 851 return wrap(ConstantExpr::getFRem(unwrap<Constant>(LHSConstant), 852 unwrap<Constant>(RHSConstant))); 853 } 854 855 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 856 return wrap(ConstantExpr::getAnd(unwrap<Constant>(LHSConstant), 857 unwrap<Constant>(RHSConstant))); 858 } 859 860 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 861 return wrap(ConstantExpr::getOr(unwrap<Constant>(LHSConstant), 862 unwrap<Constant>(RHSConstant))); 863 } 864 865 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 866 return wrap(ConstantExpr::getXor(unwrap<Constant>(LHSConstant), 867 unwrap<Constant>(RHSConstant))); 868 } 869 870 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, 871 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 872 return wrap(ConstantExpr::getICmp(Predicate, 873 unwrap<Constant>(LHSConstant), 874 unwrap<Constant>(RHSConstant))); 875 } 876 877 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, 878 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 879 return wrap(ConstantExpr::getFCmp(Predicate, 880 unwrap<Constant>(LHSConstant), 881 unwrap<Constant>(RHSConstant))); 882 } 883 884 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 885 return wrap(ConstantExpr::getShl(unwrap<Constant>(LHSConstant), 886 unwrap<Constant>(RHSConstant))); 887 } 888 889 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 890 return wrap(ConstantExpr::getLShr(unwrap<Constant>(LHSConstant), 891 unwrap<Constant>(RHSConstant))); 892 } 893 894 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 895 return wrap(ConstantExpr::getAShr(unwrap<Constant>(LHSConstant), 896 unwrap<Constant>(RHSConstant))); 897 } 898 899 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, 900 LLVMValueRef *ConstantIndices, unsigned NumIndices) { 901 ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices), 902 NumIndices); 903 return wrap(ConstantExpr::getGetElementPtr(unwrap<Constant>(ConstantVal), 904 IdxList)); 905 } 906 907 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, 908 LLVMValueRef *ConstantIndices, 909 unsigned NumIndices) { 910 Constant* Val = unwrap<Constant>(ConstantVal); 911 ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices), 912 NumIndices); 913 return wrap(ConstantExpr::getInBoundsGetElementPtr(Val, IdxList)); 914 } 915 916 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 917 return wrap(ConstantExpr::getTrunc(unwrap<Constant>(ConstantVal), 918 unwrap(ToType))); 919 } 920 921 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 922 return wrap(ConstantExpr::getSExt(unwrap<Constant>(ConstantVal), 923 unwrap(ToType))); 924 } 925 926 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 927 return wrap(ConstantExpr::getZExt(unwrap<Constant>(ConstantVal), 928 unwrap(ToType))); 929 } 930 931 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 932 return wrap(ConstantExpr::getFPTrunc(unwrap<Constant>(ConstantVal), 933 unwrap(ToType))); 934 } 935 936 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 937 return wrap(ConstantExpr::getFPExtend(unwrap<Constant>(ConstantVal), 938 unwrap(ToType))); 939 } 940 941 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 942 return wrap(ConstantExpr::getUIToFP(unwrap<Constant>(ConstantVal), 943 unwrap(ToType))); 944 } 945 946 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 947 return wrap(ConstantExpr::getSIToFP(unwrap<Constant>(ConstantVal), 948 unwrap(ToType))); 949 } 950 951 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 952 return wrap(ConstantExpr::getFPToUI(unwrap<Constant>(ConstantVal), 953 unwrap(ToType))); 954 } 955 956 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 957 return wrap(ConstantExpr::getFPToSI(unwrap<Constant>(ConstantVal), 958 unwrap(ToType))); 959 } 960 961 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 962 return wrap(ConstantExpr::getPtrToInt(unwrap<Constant>(ConstantVal), 963 unwrap(ToType))); 964 } 965 966 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 967 return wrap(ConstantExpr::getIntToPtr(unwrap<Constant>(ConstantVal), 968 unwrap(ToType))); 969 } 970 971 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 972 return wrap(ConstantExpr::getBitCast(unwrap<Constant>(ConstantVal), 973 unwrap(ToType))); 974 } 975 976 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, 977 LLVMTypeRef ToType) { 978 return wrap(ConstantExpr::getZExtOrBitCast(unwrap<Constant>(ConstantVal), 979 unwrap(ToType))); 980 } 981 982 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, 983 LLVMTypeRef ToType) { 984 return wrap(ConstantExpr::getSExtOrBitCast(unwrap<Constant>(ConstantVal), 985 unwrap(ToType))); 986 } 987 988 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, 989 LLVMTypeRef ToType) { 990 return wrap(ConstantExpr::getTruncOrBitCast(unwrap<Constant>(ConstantVal), 991 unwrap(ToType))); 992 } 993 994 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, 995 LLVMTypeRef ToType) { 996 return wrap(ConstantExpr::getPointerCast(unwrap<Constant>(ConstantVal), 997 unwrap(ToType))); 998 } 999 1000 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, 1001 LLVMBool isSigned) { 1002 return wrap(ConstantExpr::getIntegerCast(unwrap<Constant>(ConstantVal), 1003 unwrap(ToType), isSigned)); 1004 } 1005 1006 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1007 return wrap(ConstantExpr::getFPCast(unwrap<Constant>(ConstantVal), 1008 unwrap(ToType))); 1009 } 1010 1011 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, 1012 LLVMValueRef ConstantIfTrue, 1013 LLVMValueRef ConstantIfFalse) { 1014 return wrap(ConstantExpr::getSelect(unwrap<Constant>(ConstantCondition), 1015 unwrap<Constant>(ConstantIfTrue), 1016 unwrap<Constant>(ConstantIfFalse))); 1017 } 1018 1019 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, 1020 LLVMValueRef IndexConstant) { 1021 return wrap(ConstantExpr::getExtractElement(unwrap<Constant>(VectorConstant), 1022 unwrap<Constant>(IndexConstant))); 1023 } 1024 1025 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, 1026 LLVMValueRef ElementValueConstant, 1027 LLVMValueRef IndexConstant) { 1028 return wrap(ConstantExpr::getInsertElement(unwrap<Constant>(VectorConstant), 1029 unwrap<Constant>(ElementValueConstant), 1030 unwrap<Constant>(IndexConstant))); 1031 } 1032 1033 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, 1034 LLVMValueRef VectorBConstant, 1035 LLVMValueRef MaskConstant) { 1036 return wrap(ConstantExpr::getShuffleVector(unwrap<Constant>(VectorAConstant), 1037 unwrap<Constant>(VectorBConstant), 1038 unwrap<Constant>(MaskConstant))); 1039 } 1040 1041 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, 1042 unsigned NumIdx) { 1043 return wrap(ConstantExpr::getExtractValue(unwrap<Constant>(AggConstant), 1044 makeArrayRef(IdxList, NumIdx))); 1045 } 1046 1047 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, 1048 LLVMValueRef ElementValueConstant, 1049 unsigned *IdxList, unsigned NumIdx) { 1050 return wrap(ConstantExpr::getInsertValue(unwrap<Constant>(AggConstant), 1051 unwrap<Constant>(ElementValueConstant), 1052 makeArrayRef(IdxList, NumIdx))); 1053 } 1054 1055 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, const char *AsmString, 1056 const char *Constraints, 1057 LLVMBool HasSideEffects, 1058 LLVMBool IsAlignStack) { 1059 return wrap(InlineAsm::get(dyn_cast<FunctionType>(unwrap(Ty)), AsmString, 1060 Constraints, HasSideEffects, IsAlignStack)); 1061 } 1062 1063 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB) { 1064 return wrap(BlockAddress::get(unwrap<Function>(F), unwrap(BB))); 1065 } 1066 1067 /*--.. Operations on global variables, functions, and aliases (globals) ....--*/ 1068 1069 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global) { 1070 return wrap(unwrap<GlobalValue>(Global)->getParent()); 1071 } 1072 1073 LLVMBool LLVMIsDeclaration(LLVMValueRef Global) { 1074 return unwrap<GlobalValue>(Global)->isDeclaration(); 1075 } 1076 1077 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global) { 1078 switch (unwrap<GlobalValue>(Global)->getLinkage()) { 1079 case GlobalValue::ExternalLinkage: 1080 return LLVMExternalLinkage; 1081 case GlobalValue::AvailableExternallyLinkage: 1082 return LLVMAvailableExternallyLinkage; 1083 case GlobalValue::LinkOnceAnyLinkage: 1084 return LLVMLinkOnceAnyLinkage; 1085 case GlobalValue::LinkOnceODRLinkage: 1086 return LLVMLinkOnceODRLinkage; 1087 case GlobalValue::LinkOnceODRAutoHideLinkage: 1088 return LLVMLinkOnceODRAutoHideLinkage; 1089 case GlobalValue::WeakAnyLinkage: 1090 return LLVMWeakAnyLinkage; 1091 case GlobalValue::WeakODRLinkage: 1092 return LLVMWeakODRLinkage; 1093 case GlobalValue::AppendingLinkage: 1094 return LLVMAppendingLinkage; 1095 case GlobalValue::InternalLinkage: 1096 return LLVMInternalLinkage; 1097 case GlobalValue::PrivateLinkage: 1098 return LLVMPrivateLinkage; 1099 case GlobalValue::LinkerPrivateLinkage: 1100 return LLVMLinkerPrivateLinkage; 1101 case GlobalValue::LinkerPrivateWeakLinkage: 1102 return LLVMLinkerPrivateWeakLinkage; 1103 case GlobalValue::DLLImportLinkage: 1104 return LLVMDLLImportLinkage; 1105 case GlobalValue::DLLExportLinkage: 1106 return LLVMDLLExportLinkage; 1107 case GlobalValue::ExternalWeakLinkage: 1108 return LLVMExternalWeakLinkage; 1109 case GlobalValue::CommonLinkage: 1110 return LLVMCommonLinkage; 1111 } 1112 1113 llvm_unreachable("Invalid GlobalValue linkage!"); 1114 } 1115 1116 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage) { 1117 GlobalValue *GV = unwrap<GlobalValue>(Global); 1118 1119 switch (Linkage) { 1120 case LLVMExternalLinkage: 1121 GV->setLinkage(GlobalValue::ExternalLinkage); 1122 break; 1123 case LLVMAvailableExternallyLinkage: 1124 GV->setLinkage(GlobalValue::AvailableExternallyLinkage); 1125 break; 1126 case LLVMLinkOnceAnyLinkage: 1127 GV->setLinkage(GlobalValue::LinkOnceAnyLinkage); 1128 break; 1129 case LLVMLinkOnceODRLinkage: 1130 GV->setLinkage(GlobalValue::LinkOnceODRLinkage); 1131 break; 1132 case LLVMLinkOnceODRAutoHideLinkage: 1133 GV->setLinkage(GlobalValue::LinkOnceODRAutoHideLinkage); 1134 break; 1135 case LLVMWeakAnyLinkage: 1136 GV->setLinkage(GlobalValue::WeakAnyLinkage); 1137 break; 1138 case LLVMWeakODRLinkage: 1139 GV->setLinkage(GlobalValue::WeakODRLinkage); 1140 break; 1141 case LLVMAppendingLinkage: 1142 GV->setLinkage(GlobalValue::AppendingLinkage); 1143 break; 1144 case LLVMInternalLinkage: 1145 GV->setLinkage(GlobalValue::InternalLinkage); 1146 break; 1147 case LLVMPrivateLinkage: 1148 GV->setLinkage(GlobalValue::PrivateLinkage); 1149 break; 1150 case LLVMLinkerPrivateLinkage: 1151 GV->setLinkage(GlobalValue::LinkerPrivateLinkage); 1152 break; 1153 case LLVMLinkerPrivateWeakLinkage: 1154 GV->setLinkage(GlobalValue::LinkerPrivateWeakLinkage); 1155 break; 1156 case LLVMDLLImportLinkage: 1157 GV->setLinkage(GlobalValue::DLLImportLinkage); 1158 break; 1159 case LLVMDLLExportLinkage: 1160 GV->setLinkage(GlobalValue::DLLExportLinkage); 1161 break; 1162 case LLVMExternalWeakLinkage: 1163 GV->setLinkage(GlobalValue::ExternalWeakLinkage); 1164 break; 1165 case LLVMGhostLinkage: 1166 DEBUG(errs() 1167 << "LLVMSetLinkage(): LLVMGhostLinkage is no longer supported."); 1168 break; 1169 case LLVMCommonLinkage: 1170 GV->setLinkage(GlobalValue::CommonLinkage); 1171 break; 1172 } 1173 } 1174 1175 const char *LLVMGetSection(LLVMValueRef Global) { 1176 return unwrap<GlobalValue>(Global)->getSection().c_str(); 1177 } 1178 1179 void LLVMSetSection(LLVMValueRef Global, const char *Section) { 1180 unwrap<GlobalValue>(Global)->setSection(Section); 1181 } 1182 1183 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global) { 1184 return static_cast<LLVMVisibility>( 1185 unwrap<GlobalValue>(Global)->getVisibility()); 1186 } 1187 1188 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz) { 1189 unwrap<GlobalValue>(Global) 1190 ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz)); 1191 } 1192 1193 unsigned LLVMGetAlignment(LLVMValueRef Global) { 1194 return unwrap<GlobalValue>(Global)->getAlignment(); 1195 } 1196 1197 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes) { 1198 unwrap<GlobalValue>(Global)->setAlignment(Bytes); 1199 } 1200 1201 /*--.. Operations on global variables ......................................--*/ 1202 1203 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name) { 1204 return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false, 1205 GlobalValue::ExternalLinkage, 0, Name)); 1206 } 1207 1208 LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty, 1209 const char *Name, 1210 unsigned AddressSpace) { 1211 return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false, 1212 GlobalValue::ExternalLinkage, 0, Name, 0, 1213 GlobalVariable::NotThreadLocal, AddressSpace)); 1214 } 1215 1216 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name) { 1217 return wrap(unwrap(M)->getNamedGlobal(Name)); 1218 } 1219 1220 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M) { 1221 Module *Mod = unwrap(M); 1222 Module::global_iterator I = Mod->global_begin(); 1223 if (I == Mod->global_end()) 1224 return 0; 1225 return wrap(I); 1226 } 1227 1228 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M) { 1229 Module *Mod = unwrap(M); 1230 Module::global_iterator I = Mod->global_end(); 1231 if (I == Mod->global_begin()) 1232 return 0; 1233 return wrap(--I); 1234 } 1235 1236 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar) { 1237 GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar); 1238 Module::global_iterator I = GV; 1239 if (++I == GV->getParent()->global_end()) 1240 return 0; 1241 return wrap(I); 1242 } 1243 1244 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar) { 1245 GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar); 1246 Module::global_iterator I = GV; 1247 if (I == GV->getParent()->global_begin()) 1248 return 0; 1249 return wrap(--I); 1250 } 1251 1252 void LLVMDeleteGlobal(LLVMValueRef GlobalVar) { 1253 unwrap<GlobalVariable>(GlobalVar)->eraseFromParent(); 1254 } 1255 1256 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar) { 1257 GlobalVariable* GV = unwrap<GlobalVariable>(GlobalVar); 1258 if ( !GV->hasInitializer() ) 1259 return 0; 1260 return wrap(GV->getInitializer()); 1261 } 1262 1263 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) { 1264 unwrap<GlobalVariable>(GlobalVar) 1265 ->setInitializer(unwrap<Constant>(ConstantVal)); 1266 } 1267 1268 LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar) { 1269 return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal(); 1270 } 1271 1272 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal) { 1273 unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0); 1274 } 1275 1276 LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar) { 1277 return unwrap<GlobalVariable>(GlobalVar)->isConstant(); 1278 } 1279 1280 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant) { 1281 unwrap<GlobalVariable>(GlobalVar)->setConstant(IsConstant != 0); 1282 } 1283 1284 /*--.. Operations on aliases ......................................--*/ 1285 1286 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, 1287 const char *Name) { 1288 return wrap(new GlobalAlias(unwrap(Ty), GlobalValue::ExternalLinkage, Name, 1289 unwrap<Constant>(Aliasee), unwrap (M))); 1290 } 1291 1292 /*--.. Operations on functions .............................................--*/ 1293 1294 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, 1295 LLVMTypeRef FunctionTy) { 1296 return wrap(Function::Create(unwrap<FunctionType>(FunctionTy), 1297 GlobalValue::ExternalLinkage, Name, unwrap(M))); 1298 } 1299 1300 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name) { 1301 return wrap(unwrap(M)->getFunction(Name)); 1302 } 1303 1304 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M) { 1305 Module *Mod = unwrap(M); 1306 Module::iterator I = Mod->begin(); 1307 if (I == Mod->end()) 1308 return 0; 1309 return wrap(I); 1310 } 1311 1312 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M) { 1313 Module *Mod = unwrap(M); 1314 Module::iterator I = Mod->end(); 1315 if (I == Mod->begin()) 1316 return 0; 1317 return wrap(--I); 1318 } 1319 1320 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn) { 1321 Function *Func = unwrap<Function>(Fn); 1322 Module::iterator I = Func; 1323 if (++I == Func->getParent()->end()) 1324 return 0; 1325 return wrap(I); 1326 } 1327 1328 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn) { 1329 Function *Func = unwrap<Function>(Fn); 1330 Module::iterator I = Func; 1331 if (I == Func->getParent()->begin()) 1332 return 0; 1333 return wrap(--I); 1334 } 1335 1336 void LLVMDeleteFunction(LLVMValueRef Fn) { 1337 unwrap<Function>(Fn)->eraseFromParent(); 1338 } 1339 1340 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn) { 1341 if (Function *F = dyn_cast<Function>(unwrap(Fn))) 1342 return F->getIntrinsicID(); 1343 return 0; 1344 } 1345 1346 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn) { 1347 return unwrap<Function>(Fn)->getCallingConv(); 1348 } 1349 1350 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC) { 1351 return unwrap<Function>(Fn)->setCallingConv( 1352 static_cast<CallingConv::ID>(CC)); 1353 } 1354 1355 const char *LLVMGetGC(LLVMValueRef Fn) { 1356 Function *F = unwrap<Function>(Fn); 1357 return F->hasGC()? F->getGC() : 0; 1358 } 1359 1360 void LLVMSetGC(LLVMValueRef Fn, const char *GC) { 1361 Function *F = unwrap<Function>(Fn); 1362 if (GC) 1363 F->setGC(GC); 1364 else 1365 F->clearGC(); 1366 } 1367 1368 void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA) { 1369 Function *Func = unwrap<Function>(Fn); 1370 const AttrListPtr PAL = Func->getAttributes(); 1371 const AttrListPtr PALnew = PAL.addAttr(~0U, Attributes(PA)); 1372 Func->setAttributes(PALnew); 1373 } 1374 1375 void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA) { 1376 Function *Func = unwrap<Function>(Fn); 1377 const AttrListPtr PAL = Func->getAttributes(); 1378 const AttrListPtr PALnew = PAL.removeAttr(~0U, Attributes(PA)); 1379 Func->setAttributes(PALnew); 1380 } 1381 1382 LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn) { 1383 Function *Func = unwrap<Function>(Fn); 1384 const AttrListPtr PAL = Func->getAttributes(); 1385 Attributes attr = PAL.getFnAttributes(); 1386 return (LLVMAttribute)attr.Raw(); 1387 } 1388 1389 /*--.. Operations on parameters ............................................--*/ 1390 1391 unsigned LLVMCountParams(LLVMValueRef FnRef) { 1392 // This function is strictly redundant to 1393 // LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(FnRef))) 1394 return unwrap<Function>(FnRef)->arg_size(); 1395 } 1396 1397 void LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs) { 1398 Function *Fn = unwrap<Function>(FnRef); 1399 for (Function::arg_iterator I = Fn->arg_begin(), 1400 E = Fn->arg_end(); I != E; I++) 1401 *ParamRefs++ = wrap(I); 1402 } 1403 1404 LLVMValueRef LLVMGetParam(LLVMValueRef FnRef, unsigned index) { 1405 Function::arg_iterator AI = unwrap<Function>(FnRef)->arg_begin(); 1406 while (index --> 0) 1407 AI++; 1408 return wrap(AI); 1409 } 1410 1411 LLVMValueRef LLVMGetParamParent(LLVMValueRef V) { 1412 return wrap(unwrap<Argument>(V)->getParent()); 1413 } 1414 1415 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn) { 1416 Function *Func = unwrap<Function>(Fn); 1417 Function::arg_iterator I = Func->arg_begin(); 1418 if (I == Func->arg_end()) 1419 return 0; 1420 return wrap(I); 1421 } 1422 1423 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn) { 1424 Function *Func = unwrap<Function>(Fn); 1425 Function::arg_iterator I = Func->arg_end(); 1426 if (I == Func->arg_begin()) 1427 return 0; 1428 return wrap(--I); 1429 } 1430 1431 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg) { 1432 Argument *A = unwrap<Argument>(Arg); 1433 Function::arg_iterator I = A; 1434 if (++I == A->getParent()->arg_end()) 1435 return 0; 1436 return wrap(I); 1437 } 1438 1439 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg) { 1440 Argument *A = unwrap<Argument>(Arg); 1441 Function::arg_iterator I = A; 1442 if (I == A->getParent()->arg_begin()) 1443 return 0; 1444 return wrap(--I); 1445 } 1446 1447 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA) { 1448 unwrap<Argument>(Arg)->addAttr(Attributes(PA)); 1449 } 1450 1451 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA) { 1452 unwrap<Argument>(Arg)->removeAttr(Attributes(PA)); 1453 } 1454 1455 LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg) { 1456 Argument *A = unwrap<Argument>(Arg); 1457 Attributes attr = A->getParent()->getAttributes().getParamAttributes( 1458 A->getArgNo()+1); 1459 return (LLVMAttribute)attr.Raw(); 1460 } 1461 1462 1463 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align) { 1464 unwrap<Argument>(Arg)->addAttr( 1465 Attribute::constructAlignmentFromInt(align)); 1466 } 1467 1468 /*--.. Operations on basic blocks ..........................................--*/ 1469 1470 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB) { 1471 return wrap(static_cast<Value*>(unwrap(BB))); 1472 } 1473 1474 LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val) { 1475 return isa<BasicBlock>(unwrap(Val)); 1476 } 1477 1478 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val) { 1479 return wrap(unwrap<BasicBlock>(Val)); 1480 } 1481 1482 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB) { 1483 return wrap(unwrap(BB)->getParent()); 1484 } 1485 1486 LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB) { 1487 return wrap(unwrap(BB)->getTerminator()); 1488 } 1489 1490 unsigned LLVMCountBasicBlocks(LLVMValueRef FnRef) { 1491 return unwrap<Function>(FnRef)->size(); 1492 } 1493 1494 void LLVMGetBasicBlocks(LLVMValueRef FnRef, LLVMBasicBlockRef *BasicBlocksRefs){ 1495 Function *Fn = unwrap<Function>(FnRef); 1496 for (Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++) 1497 *BasicBlocksRefs++ = wrap(I); 1498 } 1499 1500 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn) { 1501 return wrap(&unwrap<Function>(Fn)->getEntryBlock()); 1502 } 1503 1504 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn) { 1505 Function *Func = unwrap<Function>(Fn); 1506 Function::iterator I = Func->begin(); 1507 if (I == Func->end()) 1508 return 0; 1509 return wrap(I); 1510 } 1511 1512 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn) { 1513 Function *Func = unwrap<Function>(Fn); 1514 Function::iterator I = Func->end(); 1515 if (I == Func->begin()) 1516 return 0; 1517 return wrap(--I); 1518 } 1519 1520 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB) { 1521 BasicBlock *Block = unwrap(BB); 1522 Function::iterator I = Block; 1523 if (++I == Block->getParent()->end()) 1524 return 0; 1525 return wrap(I); 1526 } 1527 1528 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB) { 1529 BasicBlock *Block = unwrap(BB); 1530 Function::iterator I = Block; 1531 if (I == Block->getParent()->begin()) 1532 return 0; 1533 return wrap(--I); 1534 } 1535 1536 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, 1537 LLVMValueRef FnRef, 1538 const char *Name) { 1539 return wrap(BasicBlock::Create(*unwrap(C), Name, unwrap<Function>(FnRef))); 1540 } 1541 1542 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef FnRef, const char *Name) { 1543 return LLVMAppendBasicBlockInContext(LLVMGetGlobalContext(), FnRef, Name); 1544 } 1545 1546 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, 1547 LLVMBasicBlockRef BBRef, 1548 const char *Name) { 1549 BasicBlock *BB = unwrap(BBRef); 1550 return wrap(BasicBlock::Create(*unwrap(C), Name, BB->getParent(), BB)); 1551 } 1552 1553 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef BBRef, 1554 const char *Name) { 1555 return LLVMInsertBasicBlockInContext(LLVMGetGlobalContext(), BBRef, Name); 1556 } 1557 1558 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BBRef) { 1559 unwrap(BBRef)->eraseFromParent(); 1560 } 1561 1562 void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BBRef) { 1563 unwrap(BBRef)->removeFromParent(); 1564 } 1565 1566 void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos) { 1567 unwrap(BB)->moveBefore(unwrap(MovePos)); 1568 } 1569 1570 void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos) { 1571 unwrap(BB)->moveAfter(unwrap(MovePos)); 1572 } 1573 1574 /*--.. Operations on instructions ..........................................--*/ 1575 1576 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst) { 1577 return wrap(unwrap<Instruction>(Inst)->getParent()); 1578 } 1579 1580 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB) { 1581 BasicBlock *Block = unwrap(BB); 1582 BasicBlock::iterator I = Block->begin(); 1583 if (I == Block->end()) 1584 return 0; 1585 return wrap(I); 1586 } 1587 1588 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB) { 1589 BasicBlock *Block = unwrap(BB); 1590 BasicBlock::iterator I = Block->end(); 1591 if (I == Block->begin()) 1592 return 0; 1593 return wrap(--I); 1594 } 1595 1596 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst) { 1597 Instruction *Instr = unwrap<Instruction>(Inst); 1598 BasicBlock::iterator I = Instr; 1599 if (++I == Instr->getParent()->end()) 1600 return 0; 1601 return wrap(I); 1602 } 1603 1604 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst) { 1605 Instruction *Instr = unwrap<Instruction>(Inst); 1606 BasicBlock::iterator I = Instr; 1607 if (I == Instr->getParent()->begin()) 1608 return 0; 1609 return wrap(--I); 1610 } 1611 1612 void LLVMInstructionEraseFromParent(LLVMValueRef Inst) { 1613 unwrap<Instruction>(Inst)->eraseFromParent(); 1614 } 1615 1616 LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst) { 1617 if (ICmpInst *I = dyn_cast<ICmpInst>(unwrap(Inst))) 1618 return (LLVMIntPredicate)I->getPredicate(); 1619 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst))) 1620 if (CE->getOpcode() == Instruction::ICmp) 1621 return (LLVMIntPredicate)CE->getPredicate(); 1622 return (LLVMIntPredicate)0; 1623 } 1624 1625 LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst) { 1626 if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst))) 1627 return map_to_llvmopcode(C->getOpcode()); 1628 return (LLVMOpcode)0; 1629 } 1630 1631 /*--.. Call and invoke instructions ........................................--*/ 1632 1633 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr) { 1634 Value *V = unwrap(Instr); 1635 if (CallInst *CI = dyn_cast<CallInst>(V)) 1636 return CI->getCallingConv(); 1637 if (InvokeInst *II = dyn_cast<InvokeInst>(V)) 1638 return II->getCallingConv(); 1639 llvm_unreachable("LLVMGetInstructionCallConv applies only to call and invoke!"); 1640 } 1641 1642 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC) { 1643 Value *V = unwrap(Instr); 1644 if (CallInst *CI = dyn_cast<CallInst>(V)) 1645 return CI->setCallingConv(static_cast<CallingConv::ID>(CC)); 1646 else if (InvokeInst *II = dyn_cast<InvokeInst>(V)) 1647 return II->setCallingConv(static_cast<CallingConv::ID>(CC)); 1648 llvm_unreachable("LLVMSetInstructionCallConv applies only to call and invoke!"); 1649 } 1650 1651 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, 1652 LLVMAttribute PA) { 1653 CallSite Call = CallSite(unwrap<Instruction>(Instr)); 1654 Call.setAttributes( 1655 Call.getAttributes().addAttr(index, Attributes(PA))); 1656 } 1657 1658 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index, 1659 LLVMAttribute PA) { 1660 CallSite Call = CallSite(unwrap<Instruction>(Instr)); 1661 Call.setAttributes( 1662 Call.getAttributes().removeAttr(index, Attributes(PA))); 1663 } 1664 1665 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, 1666 unsigned align) { 1667 CallSite Call = CallSite(unwrap<Instruction>(Instr)); 1668 Call.setAttributes( 1669 Call.getAttributes().addAttr(index, 1670 Attribute::constructAlignmentFromInt(align))); 1671 } 1672 1673 /*--.. Operations on call instructions (only) ..............................--*/ 1674 1675 LLVMBool LLVMIsTailCall(LLVMValueRef Call) { 1676 return unwrap<CallInst>(Call)->isTailCall(); 1677 } 1678 1679 void LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall) { 1680 unwrap<CallInst>(Call)->setTailCall(isTailCall); 1681 } 1682 1683 /*--.. Operations on switch instructions (only) ............................--*/ 1684 1685 LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef Switch) { 1686 return wrap(unwrap<SwitchInst>(Switch)->getDefaultDest()); 1687 } 1688 1689 /*--.. Operations on phi nodes .............................................--*/ 1690 1691 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, 1692 LLVMBasicBlockRef *IncomingBlocks, unsigned Count) { 1693 PHINode *PhiVal = unwrap<PHINode>(PhiNode); 1694 for (unsigned I = 0; I != Count; ++I) 1695 PhiVal->addIncoming(unwrap(IncomingValues[I]), unwrap(IncomingBlocks[I])); 1696 } 1697 1698 unsigned LLVMCountIncoming(LLVMValueRef PhiNode) { 1699 return unwrap<PHINode>(PhiNode)->getNumIncomingValues(); 1700 } 1701 1702 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index) { 1703 return wrap(unwrap<PHINode>(PhiNode)->getIncomingValue(Index)); 1704 } 1705 1706 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index) { 1707 return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index)); 1708 } 1709 1710 1711 /*===-- Instruction builders ----------------------------------------------===*/ 1712 1713 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C) { 1714 return wrap(new IRBuilder<>(*unwrap(C))); 1715 } 1716 1717 LLVMBuilderRef LLVMCreateBuilder(void) { 1718 return LLVMCreateBuilderInContext(LLVMGetGlobalContext()); 1719 } 1720 1721 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, 1722 LLVMValueRef Instr) { 1723 BasicBlock *BB = unwrap(Block); 1724 Instruction *I = Instr? unwrap<Instruction>(Instr) : (Instruction*) BB->end(); 1725 unwrap(Builder)->SetInsertPoint(BB, I); 1726 } 1727 1728 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr) { 1729 Instruction *I = unwrap<Instruction>(Instr); 1730 unwrap(Builder)->SetInsertPoint(I->getParent(), I); 1731 } 1732 1733 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block) { 1734 BasicBlock *BB = unwrap(Block); 1735 unwrap(Builder)->SetInsertPoint(BB); 1736 } 1737 1738 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder) { 1739 return wrap(unwrap(Builder)->GetInsertBlock()); 1740 } 1741 1742 void LLVMClearInsertionPosition(LLVMBuilderRef Builder) { 1743 unwrap(Builder)->ClearInsertionPoint(); 1744 } 1745 1746 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr) { 1747 unwrap(Builder)->Insert(unwrap<Instruction>(Instr)); 1748 } 1749 1750 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, 1751 const char *Name) { 1752 unwrap(Builder)->Insert(unwrap<Instruction>(Instr), Name); 1753 } 1754 1755 void LLVMDisposeBuilder(LLVMBuilderRef Builder) { 1756 delete unwrap(Builder); 1757 } 1758 1759 /*--.. Metadata builders ...................................................--*/ 1760 1761 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L) { 1762 MDNode *Loc = L ? unwrap<MDNode>(L) : NULL; 1763 unwrap(Builder)->SetCurrentDebugLocation(DebugLoc::getFromDILocation(Loc)); 1764 } 1765 1766 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder) { 1767 return wrap(unwrap(Builder)->getCurrentDebugLocation() 1768 .getAsMDNode(unwrap(Builder)->getContext())); 1769 } 1770 1771 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst) { 1772 unwrap(Builder)->SetInstDebugLocation(unwrap<Instruction>(Inst)); 1773 } 1774 1775 1776 /*--.. Instruction builders ................................................--*/ 1777 1778 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef B) { 1779 return wrap(unwrap(B)->CreateRetVoid()); 1780 } 1781 1782 LLVMValueRef LLVMBuildRet(LLVMBuilderRef B, LLVMValueRef V) { 1783 return wrap(unwrap(B)->CreateRet(unwrap(V))); 1784 } 1785 1786 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef B, LLVMValueRef *RetVals, 1787 unsigned N) { 1788 return wrap(unwrap(B)->CreateAggregateRet(unwrap(RetVals), N)); 1789 } 1790 1791 LLVMValueRef LLVMBuildBr(LLVMBuilderRef B, LLVMBasicBlockRef Dest) { 1792 return wrap(unwrap(B)->CreateBr(unwrap(Dest))); 1793 } 1794 1795 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef B, LLVMValueRef If, 1796 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else) { 1797 return wrap(unwrap(B)->CreateCondBr(unwrap(If), unwrap(Then), unwrap(Else))); 1798 } 1799 1800 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef B, LLVMValueRef V, 1801 LLVMBasicBlockRef Else, unsigned NumCases) { 1802 return wrap(unwrap(B)->CreateSwitch(unwrap(V), unwrap(Else), NumCases)); 1803 } 1804 1805 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr, 1806 unsigned NumDests) { 1807 return wrap(unwrap(B)->CreateIndirectBr(unwrap(Addr), NumDests)); 1808 } 1809 1810 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn, 1811 LLVMValueRef *Args, unsigned NumArgs, 1812 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, 1813 const char *Name) { 1814 return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch), 1815 makeArrayRef(unwrap(Args), NumArgs), 1816 Name)); 1817 } 1818 1819 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, 1820 LLVMValueRef PersFn, unsigned NumClauses, 1821 const char *Name) { 1822 return wrap(unwrap(B)->CreateLandingPad(unwrap(Ty), 1823 cast<Function>(unwrap(PersFn)), 1824 NumClauses, Name)); 1825 } 1826 1827 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn) { 1828 return wrap(unwrap(B)->CreateResume(unwrap(Exn))); 1829 } 1830 1831 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) { 1832 return wrap(unwrap(B)->CreateUnreachable()); 1833 } 1834 1835 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, 1836 LLVMBasicBlockRef Dest) { 1837 unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest)); 1838 } 1839 1840 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest) { 1841 unwrap<IndirectBrInst>(IndirectBr)->addDestination(unwrap(Dest)); 1842 } 1843 1844 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal) { 1845 unwrap<LandingPadInst>(LandingPad)-> 1846 addClause(cast<Constant>(unwrap(ClauseVal))); 1847 } 1848 1849 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val) { 1850 unwrap<LandingPadInst>(LandingPad)->setCleanup(Val); 1851 } 1852 1853 /*--.. Arithmetic ..........................................................--*/ 1854 1855 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1856 const char *Name) { 1857 return wrap(unwrap(B)->CreateAdd(unwrap(LHS), unwrap(RHS), Name)); 1858 } 1859 1860 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1861 const char *Name) { 1862 return wrap(unwrap(B)->CreateNSWAdd(unwrap(LHS), unwrap(RHS), Name)); 1863 } 1864 1865 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1866 const char *Name) { 1867 return wrap(unwrap(B)->CreateNUWAdd(unwrap(LHS), unwrap(RHS), Name)); 1868 } 1869 1870 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1871 const char *Name) { 1872 return wrap(unwrap(B)->CreateFAdd(unwrap(LHS), unwrap(RHS), Name)); 1873 } 1874 1875 LLVMValueRef LLVMBuildSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1876 const char *Name) { 1877 return wrap(unwrap(B)->CreateSub(unwrap(LHS), unwrap(RHS), Name)); 1878 } 1879 1880 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1881 const char *Name) { 1882 return wrap(unwrap(B)->CreateNSWSub(unwrap(LHS), unwrap(RHS), Name)); 1883 } 1884 1885 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1886 const char *Name) { 1887 return wrap(unwrap(B)->CreateNUWSub(unwrap(LHS), unwrap(RHS), Name)); 1888 } 1889 1890 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1891 const char *Name) { 1892 return wrap(unwrap(B)->CreateFSub(unwrap(LHS), unwrap(RHS), Name)); 1893 } 1894 1895 LLVMValueRef LLVMBuildMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1896 const char *Name) { 1897 return wrap(unwrap(B)->CreateMul(unwrap(LHS), unwrap(RHS), Name)); 1898 } 1899 1900 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1901 const char *Name) { 1902 return wrap(unwrap(B)->CreateNSWMul(unwrap(LHS), unwrap(RHS), Name)); 1903 } 1904 1905 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1906 const char *Name) { 1907 return wrap(unwrap(B)->CreateNUWMul(unwrap(LHS), unwrap(RHS), Name)); 1908 } 1909 1910 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1911 const char *Name) { 1912 return wrap(unwrap(B)->CreateFMul(unwrap(LHS), unwrap(RHS), Name)); 1913 } 1914 1915 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1916 const char *Name) { 1917 return wrap(unwrap(B)->CreateUDiv(unwrap(LHS), unwrap(RHS), Name)); 1918 } 1919 1920 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1921 const char *Name) { 1922 return wrap(unwrap(B)->CreateSDiv(unwrap(LHS), unwrap(RHS), Name)); 1923 } 1924 1925 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef B, LLVMValueRef LHS, 1926 LLVMValueRef RHS, const char *Name) { 1927 return wrap(unwrap(B)->CreateExactSDiv(unwrap(LHS), unwrap(RHS), Name)); 1928 } 1929 1930 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1931 const char *Name) { 1932 return wrap(unwrap(B)->CreateFDiv(unwrap(LHS), unwrap(RHS), Name)); 1933 } 1934 1935 LLVMValueRef LLVMBuildURem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1936 const char *Name) { 1937 return wrap(unwrap(B)->CreateURem(unwrap(LHS), unwrap(RHS), Name)); 1938 } 1939 1940 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1941 const char *Name) { 1942 return wrap(unwrap(B)->CreateSRem(unwrap(LHS), unwrap(RHS), Name)); 1943 } 1944 1945 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1946 const char *Name) { 1947 return wrap(unwrap(B)->CreateFRem(unwrap(LHS), unwrap(RHS), Name)); 1948 } 1949 1950 LLVMValueRef LLVMBuildShl(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1951 const char *Name) { 1952 return wrap(unwrap(B)->CreateShl(unwrap(LHS), unwrap(RHS), Name)); 1953 } 1954 1955 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1956 const char *Name) { 1957 return wrap(unwrap(B)->CreateLShr(unwrap(LHS), unwrap(RHS), Name)); 1958 } 1959 1960 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1961 const char *Name) { 1962 return wrap(unwrap(B)->CreateAShr(unwrap(LHS), unwrap(RHS), Name)); 1963 } 1964 1965 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1966 const char *Name) { 1967 return wrap(unwrap(B)->CreateAnd(unwrap(LHS), unwrap(RHS), Name)); 1968 } 1969 1970 LLVMValueRef LLVMBuildOr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1971 const char *Name) { 1972 return wrap(unwrap(B)->CreateOr(unwrap(LHS), unwrap(RHS), Name)); 1973 } 1974 1975 LLVMValueRef LLVMBuildXor(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 1976 const char *Name) { 1977 return wrap(unwrap(B)->CreateXor(unwrap(LHS), unwrap(RHS), Name)); 1978 } 1979 1980 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op, 1981 LLVMValueRef LHS, LLVMValueRef RHS, 1982 const char *Name) { 1983 return wrap(unwrap(B)->CreateBinOp(Instruction::BinaryOps(map_from_llvmopcode(Op)), unwrap(LHS), 1984 unwrap(RHS), Name)); 1985 } 1986 1987 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) { 1988 return wrap(unwrap(B)->CreateNeg(unwrap(V), Name)); 1989 } 1990 1991 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V, 1992 const char *Name) { 1993 return wrap(unwrap(B)->CreateNSWNeg(unwrap(V), Name)); 1994 } 1995 1996 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V, 1997 const char *Name) { 1998 return wrap(unwrap(B)->CreateNUWNeg(unwrap(V), Name)); 1999 } 2000 2001 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) { 2002 return wrap(unwrap(B)->CreateFNeg(unwrap(V), Name)); 2003 } 2004 2005 LLVMValueRef LLVMBuildNot(LLVMBuilderRef B, LLVMValueRef V, const char *Name) { 2006 return wrap(unwrap(B)->CreateNot(unwrap(V), Name)); 2007 } 2008 2009 /*--.. Memory ..............................................................--*/ 2010 2011 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef B, LLVMTypeRef Ty, 2012 const char *Name) { 2013 Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext()); 2014 Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty)); 2015 AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy); 2016 Instruction* Malloc = CallInst::CreateMalloc(unwrap(B)->GetInsertBlock(), 2017 ITy, unwrap(Ty), AllocSize, 2018 0, 0, ""); 2019 return wrap(unwrap(B)->Insert(Malloc, Twine(Name))); 2020 } 2021 2022 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef B, LLVMTypeRef Ty, 2023 LLVMValueRef Val, const char *Name) { 2024 Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext()); 2025 Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty)); 2026 AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy); 2027 Instruction* Malloc = CallInst::CreateMalloc(unwrap(B)->GetInsertBlock(), 2028 ITy, unwrap(Ty), AllocSize, 2029 unwrap(Val), 0, ""); 2030 return wrap(unwrap(B)->Insert(Malloc, Twine(Name))); 2031 } 2032 2033 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef B, LLVMTypeRef Ty, 2034 const char *Name) { 2035 return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), 0, Name)); 2036 } 2037 2038 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef B, LLVMTypeRef Ty, 2039 LLVMValueRef Val, const char *Name) { 2040 return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), unwrap(Val), Name)); 2041 } 2042 2043 LLVMValueRef LLVMBuildFree(LLVMBuilderRef B, LLVMValueRef PointerVal) { 2044 return wrap(unwrap(B)->Insert( 2045 CallInst::CreateFree(unwrap(PointerVal), unwrap(B)->GetInsertBlock()))); 2046 } 2047 2048 2049 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef B, LLVMValueRef PointerVal, 2050 const char *Name) { 2051 return wrap(unwrap(B)->CreateLoad(unwrap(PointerVal), Name)); 2052 } 2053 2054 LLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val, 2055 LLVMValueRef PointerVal) { 2056 return wrap(unwrap(B)->CreateStore(unwrap(Val), unwrap(PointerVal))); 2057 } 2058 2059 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 2060 LLVMValueRef *Indices, unsigned NumIndices, 2061 const char *Name) { 2062 ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices); 2063 return wrap(unwrap(B)->CreateGEP(unwrap(Pointer), IdxList, Name)); 2064 } 2065 2066 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 2067 LLVMValueRef *Indices, unsigned NumIndices, 2068 const char *Name) { 2069 ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices); 2070 return wrap(unwrap(B)->CreateInBoundsGEP(unwrap(Pointer), IdxList, Name)); 2071 } 2072 2073 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 2074 unsigned Idx, const char *Name) { 2075 return wrap(unwrap(B)->CreateStructGEP(unwrap(Pointer), Idx, Name)); 2076 } 2077 2078 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, 2079 const char *Name) { 2080 return wrap(unwrap(B)->CreateGlobalString(Str, Name)); 2081 } 2082 2083 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, 2084 const char *Name) { 2085 return wrap(unwrap(B)->CreateGlobalStringPtr(Str, Name)); 2086 } 2087 2088 LLVMBool LLVMGetVolatile(LLVMValueRef MemAccessInst) { 2089 Value *P = unwrap<Value>(MemAccessInst); 2090 if (LoadInst *LI = dyn_cast<LoadInst>(P)) 2091 return LI->isVolatile(); 2092 return cast<StoreInst>(P)->isVolatile(); 2093 } 2094 2095 void LLVMSetVolatile(LLVMValueRef MemAccessInst, LLVMBool isVolatile) { 2096 Value *P = unwrap<Value>(MemAccessInst); 2097 if (LoadInst *LI = dyn_cast<LoadInst>(P)) 2098 return LI->setVolatile(isVolatile); 2099 return cast<StoreInst>(P)->setVolatile(isVolatile); 2100 } 2101 2102 /*--.. Casts ...............................................................--*/ 2103 2104 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef B, LLVMValueRef Val, 2105 LLVMTypeRef DestTy, const char *Name) { 2106 return wrap(unwrap(B)->CreateTrunc(unwrap(Val), unwrap(DestTy), Name)); 2107 } 2108 2109 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef B, LLVMValueRef Val, 2110 LLVMTypeRef DestTy, const char *Name) { 2111 return wrap(unwrap(B)->CreateZExt(unwrap(Val), unwrap(DestTy), Name)); 2112 } 2113 2114 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef B, LLVMValueRef Val, 2115 LLVMTypeRef DestTy, const char *Name) { 2116 return wrap(unwrap(B)->CreateSExt(unwrap(Val), unwrap(DestTy), Name)); 2117 } 2118 2119 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef B, LLVMValueRef Val, 2120 LLVMTypeRef DestTy, const char *Name) { 2121 return wrap(unwrap(B)->CreateFPToUI(unwrap(Val), unwrap(DestTy), Name)); 2122 } 2123 2124 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef B, LLVMValueRef Val, 2125 LLVMTypeRef DestTy, const char *Name) { 2126 return wrap(unwrap(B)->CreateFPToSI(unwrap(Val), unwrap(DestTy), Name)); 2127 } 2128 2129 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef B, LLVMValueRef Val, 2130 LLVMTypeRef DestTy, const char *Name) { 2131 return wrap(unwrap(B)->CreateUIToFP(unwrap(Val), unwrap(DestTy), Name)); 2132 } 2133 2134 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef B, LLVMValueRef Val, 2135 LLVMTypeRef DestTy, const char *Name) { 2136 return wrap(unwrap(B)->CreateSIToFP(unwrap(Val), unwrap(DestTy), Name)); 2137 } 2138 2139 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef B, LLVMValueRef Val, 2140 LLVMTypeRef DestTy, const char *Name) { 2141 return wrap(unwrap(B)->CreateFPTrunc(unwrap(Val), unwrap(DestTy), Name)); 2142 } 2143 2144 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef B, LLVMValueRef Val, 2145 LLVMTypeRef DestTy, const char *Name) { 2146 return wrap(unwrap(B)->CreateFPExt(unwrap(Val), unwrap(DestTy), Name)); 2147 } 2148 2149 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef B, LLVMValueRef Val, 2150 LLVMTypeRef DestTy, const char *Name) { 2151 return wrap(unwrap(B)->CreatePtrToInt(unwrap(Val), unwrap(DestTy), Name)); 2152 } 2153 2154 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef B, LLVMValueRef Val, 2155 LLVMTypeRef DestTy, const char *Name) { 2156 return wrap(unwrap(B)->CreateIntToPtr(unwrap(Val), unwrap(DestTy), Name)); 2157 } 2158 2159 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef B, LLVMValueRef Val, 2160 LLVMTypeRef DestTy, const char *Name) { 2161 return wrap(unwrap(B)->CreateBitCast(unwrap(Val), unwrap(DestTy), Name)); 2162 } 2163 2164 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val, 2165 LLVMTypeRef DestTy, const char *Name) { 2166 return wrap(unwrap(B)->CreateZExtOrBitCast(unwrap(Val), unwrap(DestTy), 2167 Name)); 2168 } 2169 2170 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val, 2171 LLVMTypeRef DestTy, const char *Name) { 2172 return wrap(unwrap(B)->CreateSExtOrBitCast(unwrap(Val), unwrap(DestTy), 2173 Name)); 2174 } 2175 2176 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef B, LLVMValueRef Val, 2177 LLVMTypeRef DestTy, const char *Name) { 2178 return wrap(unwrap(B)->CreateTruncOrBitCast(unwrap(Val), unwrap(DestTy), 2179 Name)); 2180 } 2181 2182 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val, 2183 LLVMTypeRef DestTy, const char *Name) { 2184 return wrap(unwrap(B)->CreateCast(Instruction::CastOps(map_from_llvmopcode(Op)), unwrap(Val), 2185 unwrap(DestTy), Name)); 2186 } 2187 2188 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef B, LLVMValueRef Val, 2189 LLVMTypeRef DestTy, const char *Name) { 2190 return wrap(unwrap(B)->CreatePointerCast(unwrap(Val), unwrap(DestTy), Name)); 2191 } 2192 2193 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef B, LLVMValueRef Val, 2194 LLVMTypeRef DestTy, const char *Name) { 2195 return wrap(unwrap(B)->CreateIntCast(unwrap(Val), unwrap(DestTy), 2196 /*isSigned*/true, Name)); 2197 } 2198 2199 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef B, LLVMValueRef Val, 2200 LLVMTypeRef DestTy, const char *Name) { 2201 return wrap(unwrap(B)->CreateFPCast(unwrap(Val), unwrap(DestTy), Name)); 2202 } 2203 2204 /*--.. Comparisons .........................................................--*/ 2205 2206 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef B, LLVMIntPredicate Op, 2207 LLVMValueRef LHS, LLVMValueRef RHS, 2208 const char *Name) { 2209 return wrap(unwrap(B)->CreateICmp(static_cast<ICmpInst::Predicate>(Op), 2210 unwrap(LHS), unwrap(RHS), Name)); 2211 } 2212 2213 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef B, LLVMRealPredicate Op, 2214 LLVMValueRef LHS, LLVMValueRef RHS, 2215 const char *Name) { 2216 return wrap(unwrap(B)->CreateFCmp(static_cast<FCmpInst::Predicate>(Op), 2217 unwrap(LHS), unwrap(RHS), Name)); 2218 } 2219 2220 /*--.. Miscellaneous instructions ..........................................--*/ 2221 2222 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name) { 2223 return wrap(unwrap(B)->CreatePHI(unwrap(Ty), 0, Name)); 2224 } 2225 2226 LLVMValueRef LLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, 2227 LLVMValueRef *Args, unsigned NumArgs, 2228 const char *Name) { 2229 return wrap(unwrap(B)->CreateCall(unwrap(Fn), 2230 makeArrayRef(unwrap(Args), NumArgs), 2231 Name)); 2232 } 2233 2234 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If, 2235 LLVMValueRef Then, LLVMValueRef Else, 2236 const char *Name) { 2237 return wrap(unwrap(B)->CreateSelect(unwrap(If), unwrap(Then), unwrap(Else), 2238 Name)); 2239 } 2240 2241 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef B, LLVMValueRef List, 2242 LLVMTypeRef Ty, const char *Name) { 2243 return wrap(unwrap(B)->CreateVAArg(unwrap(List), unwrap(Ty), Name)); 2244 } 2245 2246 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef B, LLVMValueRef VecVal, 2247 LLVMValueRef Index, const char *Name) { 2248 return wrap(unwrap(B)->CreateExtractElement(unwrap(VecVal), unwrap(Index), 2249 Name)); 2250 } 2251 2252 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef B, LLVMValueRef VecVal, 2253 LLVMValueRef EltVal, LLVMValueRef Index, 2254 const char *Name) { 2255 return wrap(unwrap(B)->CreateInsertElement(unwrap(VecVal), unwrap(EltVal), 2256 unwrap(Index), Name)); 2257 } 2258 2259 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef B, LLVMValueRef V1, 2260 LLVMValueRef V2, LLVMValueRef Mask, 2261 const char *Name) { 2262 return wrap(unwrap(B)->CreateShuffleVector(unwrap(V1), unwrap(V2), 2263 unwrap(Mask), Name)); 2264 } 2265 2266 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef B, LLVMValueRef AggVal, 2267 unsigned Index, const char *Name) { 2268 return wrap(unwrap(B)->CreateExtractValue(unwrap(AggVal), Index, Name)); 2269 } 2270 2271 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef B, LLVMValueRef AggVal, 2272 LLVMValueRef EltVal, unsigned Index, 2273 const char *Name) { 2274 return wrap(unwrap(B)->CreateInsertValue(unwrap(AggVal), unwrap(EltVal), 2275 Index, Name)); 2276 } 2277 2278 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef B, LLVMValueRef Val, 2279 const char *Name) { 2280 return wrap(unwrap(B)->CreateIsNull(unwrap(Val), Name)); 2281 } 2282 2283 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef B, LLVMValueRef Val, 2284 const char *Name) { 2285 return wrap(unwrap(B)->CreateIsNotNull(unwrap(Val), Name)); 2286 } 2287 2288 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef B, LLVMValueRef LHS, 2289 LLVMValueRef RHS, const char *Name) { 2290 return wrap(unwrap(B)->CreatePtrDiff(unwrap(LHS), unwrap(RHS), Name)); 2291 } 2292 2293 2294 /*===-- Module providers --------------------------------------------------===*/ 2295 2296 LLVMModuleProviderRef 2297 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M) { 2298 return reinterpret_cast<LLVMModuleProviderRef>(M); 2299 } 2300 2301 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP) { 2302 delete unwrap(MP); 2303 } 2304 2305 2306 /*===-- Memory buffers ----------------------------------------------------===*/ 2307 2308 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile( 2309 const char *Path, 2310 LLVMMemoryBufferRef *OutMemBuf, 2311 char **OutMessage) { 2312 2313 OwningPtr<MemoryBuffer> MB; 2314 error_code ec; 2315 if (!(ec = MemoryBuffer::getFile(Path, MB))) { 2316 *OutMemBuf = wrap(MB.take()); 2317 return 0; 2318 } 2319 2320 *OutMessage = strdup(ec.message().c_str()); 2321 return 1; 2322 } 2323 2324 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, 2325 char **OutMessage) { 2326 OwningPtr<MemoryBuffer> MB; 2327 error_code ec; 2328 if (!(ec = MemoryBuffer::getSTDIN(MB))) { 2329 *OutMemBuf = wrap(MB.take()); 2330 return 0; 2331 } 2332 2333 *OutMessage = strdup(ec.message().c_str()); 2334 return 1; 2335 } 2336 2337 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf) { 2338 delete unwrap(MemBuf); 2339 } 2340 2341 /*===-- Pass Registry -----------------------------------------------------===*/ 2342 2343 LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void) { 2344 return wrap(PassRegistry::getPassRegistry()); 2345 } 2346 2347 /*===-- Pass Manager ------------------------------------------------------===*/ 2348 2349 LLVMPassManagerRef LLVMCreatePassManager() { 2350 return wrap(new PassManager()); 2351 } 2352 2353 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M) { 2354 return wrap(new FunctionPassManager(unwrap(M))); 2355 } 2356 2357 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef P) { 2358 return LLVMCreateFunctionPassManagerForModule( 2359 reinterpret_cast<LLVMModuleRef>(P)); 2360 } 2361 2362 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M) { 2363 return unwrap<PassManager>(PM)->run(*unwrap(M)); 2364 } 2365 2366 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM) { 2367 return unwrap<FunctionPassManager>(FPM)->doInitialization(); 2368 } 2369 2370 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F) { 2371 return unwrap<FunctionPassManager>(FPM)->run(*unwrap<Function>(F)); 2372 } 2373 2374 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM) { 2375 return unwrap<FunctionPassManager>(FPM)->doFinalization(); 2376 } 2377 2378 void LLVMDisposePassManager(LLVMPassManagerRef PM) { 2379 delete unwrap(PM); 2380 } 2381