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