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/ADT/StringSwitch.h" 17#include "llvm/Bitcode/ReaderWriter.h" 18#include "llvm/IR/Attributes.h" 19#include "llvm/IR/CallSite.h" 20#include "llvm/IR/Constants.h" 21#include "llvm/IR/DerivedTypes.h" 22#include "llvm/IR/DiagnosticInfo.h" 23#include "llvm/IR/DiagnosticPrinter.h" 24#include "llvm/IR/GlobalAlias.h" 25#include "llvm/IR/GlobalVariable.h" 26#include "llvm/IR/IRBuilder.h" 27#include "llvm/IR/InlineAsm.h" 28#include "llvm/IR/IntrinsicInst.h" 29#include "llvm/IR/LLVMContext.h" 30#include "llvm/IR/LegacyPassManager.h" 31#include "llvm/IR/Module.h" 32#include "llvm/Support/Debug.h" 33#include "llvm/Support/ErrorHandling.h" 34#include "llvm/Support/FileSystem.h" 35#include "llvm/Support/ManagedStatic.h" 36#include "llvm/Support/MemoryBuffer.h" 37#include "llvm/Support/Threading.h" 38#include "llvm/Support/raw_ostream.h" 39#include <cassert> 40#include <cstdlib> 41#include <cstring> 42#include <system_error> 43 44using namespace llvm; 45 46#define DEBUG_TYPE "ir" 47 48void llvm::initializeCore(PassRegistry &Registry) { 49 initializeDominatorTreeWrapperPassPass(Registry); 50 initializePrintModulePassWrapperPass(Registry); 51 initializePrintFunctionPassWrapperPass(Registry); 52 initializePrintBasicBlockPassPass(Registry); 53 initializeVerifierLegacyPassPass(Registry); 54} 55 56void LLVMInitializeCore(LLVMPassRegistryRef R) { 57 initializeCore(*unwrap(R)); 58} 59 60void LLVMShutdown() { 61 llvm_shutdown(); 62} 63 64/*===-- Error handling ----------------------------------------------------===*/ 65 66char *LLVMCreateMessage(const char *Message) { 67 return strdup(Message); 68} 69 70void LLVMDisposeMessage(char *Message) { 71 free(Message); 72} 73 74 75/*===-- Operations on contexts --------------------------------------------===*/ 76 77static ManagedStatic<LLVMContext> GlobalContext; 78 79LLVMContextRef LLVMContextCreate() { 80 return wrap(new LLVMContext()); 81} 82 83LLVMContextRef LLVMGetGlobalContext() { return wrap(&*GlobalContext); } 84 85void LLVMContextSetDiagnosticHandler(LLVMContextRef C, 86 LLVMDiagnosticHandler Handler, 87 void *DiagnosticContext) { 88 unwrap(C)->setDiagnosticHandler( 89 LLVM_EXTENSION reinterpret_cast<LLVMContext::DiagnosticHandlerTy>( 90 Handler), 91 DiagnosticContext); 92} 93 94LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C) { 95 return LLVM_EXTENSION reinterpret_cast<LLVMDiagnosticHandler>( 96 unwrap(C)->getDiagnosticHandler()); 97} 98 99void *LLVMContextGetDiagnosticContext(LLVMContextRef C) { 100 return unwrap(C)->getDiagnosticContext(); 101} 102 103void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback, 104 void *OpaqueHandle) { 105 auto YieldCallback = 106 LLVM_EXTENSION reinterpret_cast<LLVMContext::YieldCallbackTy>(Callback); 107 unwrap(C)->setYieldCallback(YieldCallback, OpaqueHandle); 108} 109 110void LLVMContextDispose(LLVMContextRef C) { 111 delete unwrap(C); 112} 113 114unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char *Name, 115 unsigned SLen) { 116 return unwrap(C)->getMDKindID(StringRef(Name, SLen)); 117} 118 119unsigned LLVMGetMDKindID(const char *Name, unsigned SLen) { 120 return LLVMGetMDKindIDInContext(LLVMGetGlobalContext(), Name, SLen); 121} 122 123#define GET_ATTR_KIND_FROM_NAME 124#include "AttributesCompatFunc.inc" 125 126unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen) { 127 return getAttrKindFromName(StringRef(Name, SLen)); 128} 129 130unsigned LLVMGetLastEnumAttributeKind(void) { 131 return Attribute::AttrKind::EndAttrKinds; 132} 133 134LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID, 135 uint64_t Val) { 136 return wrap(Attribute::get(*unwrap(C), (Attribute::AttrKind)KindID, Val)); 137} 138 139unsigned LLVMGetEnumAttributeKind(LLVMAttributeRef A) { 140 return unwrap(A).getKindAsEnum(); 141} 142 143uint64_t LLVMGetEnumAttributeValue(LLVMAttributeRef A) { 144 auto Attr = unwrap(A); 145 if (Attr.isEnumAttribute()) 146 return 0; 147 return Attr.getValueAsInt(); 148} 149 150LLVMAttributeRef LLVMCreateStringAttribute(LLVMContextRef C, 151 const char *K, unsigned KLength, 152 const char *V, unsigned VLength) { 153 return wrap(Attribute::get(*unwrap(C), StringRef(K, KLength), 154 StringRef(V, VLength))); 155} 156 157const char *LLVMGetStringAttributeKind(LLVMAttributeRef A, 158 unsigned *Length) { 159 auto S = unwrap(A).getKindAsString(); 160 *Length = S.size(); 161 return S.data(); 162} 163 164const char *LLVMGetStringAttributeValue(LLVMAttributeRef A, 165 unsigned *Length) { 166 auto S = unwrap(A).getValueAsString(); 167 *Length = S.size(); 168 return S.data(); 169} 170 171LLVMBool LLVMIsEnumAttribute(LLVMAttributeRef A) { 172 auto Attr = unwrap(A); 173 return Attr.isEnumAttribute() || Attr.isIntAttribute(); 174} 175 176LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A) { 177 return unwrap(A).isStringAttribute(); 178} 179 180char *LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI) { 181 std::string MsgStorage; 182 raw_string_ostream Stream(MsgStorage); 183 DiagnosticPrinterRawOStream DP(Stream); 184 185 unwrap(DI)->print(DP); 186 Stream.flush(); 187 188 return LLVMCreateMessage(MsgStorage.c_str()); 189} 190 191LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI) { 192 LLVMDiagnosticSeverity severity; 193 194 switch(unwrap(DI)->getSeverity()) { 195 default: 196 severity = LLVMDSError; 197 break; 198 case DS_Warning: 199 severity = LLVMDSWarning; 200 break; 201 case DS_Remark: 202 severity = LLVMDSRemark; 203 break; 204 case DS_Note: 205 severity = LLVMDSNote; 206 break; 207 } 208 209 return severity; 210} 211 212/*===-- Operations on modules ---------------------------------------------===*/ 213 214LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID) { 215 return wrap(new Module(ModuleID, *GlobalContext)); 216} 217 218LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID, 219 LLVMContextRef C) { 220 return wrap(new Module(ModuleID, *unwrap(C))); 221} 222 223void LLVMDisposeModule(LLVMModuleRef M) { 224 delete unwrap(M); 225} 226 227const char *LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len) { 228 auto &Str = unwrap(M)->getModuleIdentifier(); 229 *Len = Str.length(); 230 return Str.c_str(); 231} 232 233void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len) { 234 unwrap(M)->setModuleIdentifier(StringRef(Ident, Len)); 235} 236 237 238/*--.. Data layout .........................................................--*/ 239const char *LLVMGetDataLayoutStr(LLVMModuleRef M) { 240 return unwrap(M)->getDataLayoutStr().c_str(); 241} 242 243const char *LLVMGetDataLayout(LLVMModuleRef M) { 244 return LLVMGetDataLayoutStr(M); 245} 246 247void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr) { 248 unwrap(M)->setDataLayout(DataLayoutStr); 249} 250 251/*--.. Target triple .......................................................--*/ 252const char * LLVMGetTarget(LLVMModuleRef M) { 253 return unwrap(M)->getTargetTriple().c_str(); 254} 255 256void LLVMSetTarget(LLVMModuleRef M, const char *Triple) { 257 unwrap(M)->setTargetTriple(Triple); 258} 259 260void LLVMDumpModule(LLVMModuleRef M) { 261 unwrap(M)->dump(); 262} 263 264LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename, 265 char **ErrorMessage) { 266 std::error_code EC; 267 raw_fd_ostream dest(Filename, EC, sys::fs::F_Text); 268 if (EC) { 269 *ErrorMessage = strdup(EC.message().c_str()); 270 return true; 271 } 272 273 unwrap(M)->print(dest, nullptr); 274 275 dest.close(); 276 277 if (dest.has_error()) { 278 *ErrorMessage = strdup("Error printing to file"); 279 return true; 280 } 281 282 return false; 283} 284 285char *LLVMPrintModuleToString(LLVMModuleRef M) { 286 std::string buf; 287 raw_string_ostream os(buf); 288 289 unwrap(M)->print(os, nullptr); 290 os.flush(); 291 292 return strdup(buf.c_str()); 293} 294 295/*--.. Operations on inline assembler ......................................--*/ 296void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm) { 297 unwrap(M)->setModuleInlineAsm(StringRef(Asm)); 298} 299 300 301/*--.. Operations on module contexts ......................................--*/ 302LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M) { 303 return wrap(&unwrap(M)->getContext()); 304} 305 306 307/*===-- Operations on types -----------------------------------------------===*/ 308 309/*--.. Operations on all types (mostly) ....................................--*/ 310 311LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) { 312 switch (unwrap(Ty)->getTypeID()) { 313 case Type::VoidTyID: 314 return LLVMVoidTypeKind; 315 case Type::HalfTyID: 316 return LLVMHalfTypeKind; 317 case Type::FloatTyID: 318 return LLVMFloatTypeKind; 319 case Type::DoubleTyID: 320 return LLVMDoubleTypeKind; 321 case Type::X86_FP80TyID: 322 return LLVMX86_FP80TypeKind; 323 case Type::FP128TyID: 324 return LLVMFP128TypeKind; 325 case Type::PPC_FP128TyID: 326 return LLVMPPC_FP128TypeKind; 327 case Type::LabelTyID: 328 return LLVMLabelTypeKind; 329 case Type::MetadataTyID: 330 return LLVMMetadataTypeKind; 331 case Type::IntegerTyID: 332 return LLVMIntegerTypeKind; 333 case Type::FunctionTyID: 334 return LLVMFunctionTypeKind; 335 case Type::StructTyID: 336 return LLVMStructTypeKind; 337 case Type::ArrayTyID: 338 return LLVMArrayTypeKind; 339 case Type::PointerTyID: 340 return LLVMPointerTypeKind; 341 case Type::VectorTyID: 342 return LLVMVectorTypeKind; 343 case Type::X86_MMXTyID: 344 return LLVMX86_MMXTypeKind; 345 case Type::TokenTyID: 346 return LLVMTokenTypeKind; 347 } 348 llvm_unreachable("Unhandled TypeID."); 349} 350 351LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty) 352{ 353 return unwrap(Ty)->isSized(); 354} 355 356LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty) { 357 return wrap(&unwrap(Ty)->getContext()); 358} 359 360void LLVMDumpType(LLVMTypeRef Ty) { 361 return unwrap(Ty)->dump(); 362} 363 364char *LLVMPrintTypeToString(LLVMTypeRef Ty) { 365 std::string buf; 366 raw_string_ostream os(buf); 367 368 if (unwrap(Ty)) 369 unwrap(Ty)->print(os); 370 else 371 os << "Printing <null> Type"; 372 373 os.flush(); 374 375 return strdup(buf.c_str()); 376} 377 378/*--.. Operations on integer types .........................................--*/ 379 380LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C) { 381 return (LLVMTypeRef) Type::getInt1Ty(*unwrap(C)); 382} 383LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C) { 384 return (LLVMTypeRef) Type::getInt8Ty(*unwrap(C)); 385} 386LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C) { 387 return (LLVMTypeRef) Type::getInt16Ty(*unwrap(C)); 388} 389LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C) { 390 return (LLVMTypeRef) Type::getInt32Ty(*unwrap(C)); 391} 392LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C) { 393 return (LLVMTypeRef) Type::getInt64Ty(*unwrap(C)); 394} 395LLVMTypeRef LLVMInt128TypeInContext(LLVMContextRef C) { 396 return (LLVMTypeRef) Type::getInt128Ty(*unwrap(C)); 397} 398LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits) { 399 return wrap(IntegerType::get(*unwrap(C), NumBits)); 400} 401 402LLVMTypeRef LLVMInt1Type(void) { 403 return LLVMInt1TypeInContext(LLVMGetGlobalContext()); 404} 405LLVMTypeRef LLVMInt8Type(void) { 406 return LLVMInt8TypeInContext(LLVMGetGlobalContext()); 407} 408LLVMTypeRef LLVMInt16Type(void) { 409 return LLVMInt16TypeInContext(LLVMGetGlobalContext()); 410} 411LLVMTypeRef LLVMInt32Type(void) { 412 return LLVMInt32TypeInContext(LLVMGetGlobalContext()); 413} 414LLVMTypeRef LLVMInt64Type(void) { 415 return LLVMInt64TypeInContext(LLVMGetGlobalContext()); 416} 417LLVMTypeRef LLVMInt128Type(void) { 418 return LLVMInt128TypeInContext(LLVMGetGlobalContext()); 419} 420LLVMTypeRef LLVMIntType(unsigned NumBits) { 421 return LLVMIntTypeInContext(LLVMGetGlobalContext(), NumBits); 422} 423 424unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy) { 425 return unwrap<IntegerType>(IntegerTy)->getBitWidth(); 426} 427 428/*--.. Operations on real types ............................................--*/ 429 430LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C) { 431 return (LLVMTypeRef) Type::getHalfTy(*unwrap(C)); 432} 433LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C) { 434 return (LLVMTypeRef) Type::getFloatTy(*unwrap(C)); 435} 436LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C) { 437 return (LLVMTypeRef) Type::getDoubleTy(*unwrap(C)); 438} 439LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C) { 440 return (LLVMTypeRef) Type::getX86_FP80Ty(*unwrap(C)); 441} 442LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C) { 443 return (LLVMTypeRef) Type::getFP128Ty(*unwrap(C)); 444} 445LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C) { 446 return (LLVMTypeRef) Type::getPPC_FP128Ty(*unwrap(C)); 447} 448LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C) { 449 return (LLVMTypeRef) Type::getX86_MMXTy(*unwrap(C)); 450} 451LLVMTypeRef LLVMTokenTypeInContext(LLVMContextRef C) { 452 return (LLVMTypeRef) Type::getTokenTy(*unwrap(C)); 453} 454 455LLVMTypeRef LLVMHalfType(void) { 456 return LLVMHalfTypeInContext(LLVMGetGlobalContext()); 457} 458LLVMTypeRef LLVMFloatType(void) { 459 return LLVMFloatTypeInContext(LLVMGetGlobalContext()); 460} 461LLVMTypeRef LLVMDoubleType(void) { 462 return LLVMDoubleTypeInContext(LLVMGetGlobalContext()); 463} 464LLVMTypeRef LLVMX86FP80Type(void) { 465 return LLVMX86FP80TypeInContext(LLVMGetGlobalContext()); 466} 467LLVMTypeRef LLVMFP128Type(void) { 468 return LLVMFP128TypeInContext(LLVMGetGlobalContext()); 469} 470LLVMTypeRef LLVMPPCFP128Type(void) { 471 return LLVMPPCFP128TypeInContext(LLVMGetGlobalContext()); 472} 473LLVMTypeRef LLVMX86MMXType(void) { 474 return LLVMX86MMXTypeInContext(LLVMGetGlobalContext()); 475} 476 477/*--.. Operations on function types ........................................--*/ 478 479LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, 480 LLVMTypeRef *ParamTypes, unsigned ParamCount, 481 LLVMBool IsVarArg) { 482 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount); 483 return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0)); 484} 485 486LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) { 487 return unwrap<FunctionType>(FunctionTy)->isVarArg(); 488} 489 490LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy) { 491 return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType()); 492} 493 494unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy) { 495 return unwrap<FunctionType>(FunctionTy)->getNumParams(); 496} 497 498void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest) { 499 FunctionType *Ty = unwrap<FunctionType>(FunctionTy); 500 for (FunctionType::param_iterator I = Ty->param_begin(), 501 E = Ty->param_end(); I != E; ++I) 502 *Dest++ = wrap(*I); 503} 504 505/*--.. Operations on struct types ..........................................--*/ 506 507LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, 508 unsigned ElementCount, LLVMBool Packed) { 509 ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount); 510 return wrap(StructType::get(*unwrap(C), Tys, Packed != 0)); 511} 512 513LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, 514 unsigned ElementCount, LLVMBool Packed) { 515 return LLVMStructTypeInContext(LLVMGetGlobalContext(), ElementTypes, 516 ElementCount, Packed); 517} 518 519LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name) 520{ 521 return wrap(StructType::create(*unwrap(C), Name)); 522} 523 524const char *LLVMGetStructName(LLVMTypeRef Ty) 525{ 526 StructType *Type = unwrap<StructType>(Ty); 527 if (!Type->hasName()) 528 return nullptr; 529 return Type->getName().data(); 530} 531 532void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes, 533 unsigned ElementCount, LLVMBool Packed) { 534 ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount); 535 unwrap<StructType>(StructTy)->setBody(Tys, Packed != 0); 536} 537 538unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy) { 539 return unwrap<StructType>(StructTy)->getNumElements(); 540} 541 542void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest) { 543 StructType *Ty = unwrap<StructType>(StructTy); 544 for (StructType::element_iterator I = Ty->element_begin(), 545 E = Ty->element_end(); I != E; ++I) 546 *Dest++ = wrap(*I); 547} 548 549LLVMTypeRef LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy, unsigned i) { 550 StructType *Ty = unwrap<StructType>(StructTy); 551 return wrap(Ty->getTypeAtIndex(i)); 552} 553 554LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy) { 555 return unwrap<StructType>(StructTy)->isPacked(); 556} 557 558LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy) { 559 return unwrap<StructType>(StructTy)->isOpaque(); 560} 561 562LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name) { 563 return wrap(unwrap(M)->getTypeByName(Name)); 564} 565 566/*--.. Operations on array, pointer, and vector types (sequence types) .....--*/ 567 568LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount) { 569 return wrap(ArrayType::get(unwrap(ElementType), ElementCount)); 570} 571 572LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace) { 573 return wrap(PointerType::get(unwrap(ElementType), AddressSpace)); 574} 575 576LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) { 577 return wrap(VectorType::get(unwrap(ElementType), ElementCount)); 578} 579 580LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty) { 581 return wrap(unwrap<SequentialType>(Ty)->getElementType()); 582} 583 584unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) { 585 return unwrap<ArrayType>(ArrayTy)->getNumElements(); 586} 587 588unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy) { 589 return unwrap<PointerType>(PointerTy)->getAddressSpace(); 590} 591 592unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) { 593 return unwrap<VectorType>(VectorTy)->getNumElements(); 594} 595 596/*--.. Operations on other types ...........................................--*/ 597 598LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C) { 599 return wrap(Type::getVoidTy(*unwrap(C))); 600} 601LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C) { 602 return wrap(Type::getLabelTy(*unwrap(C))); 603} 604 605LLVMTypeRef LLVMVoidType(void) { 606 return LLVMVoidTypeInContext(LLVMGetGlobalContext()); 607} 608LLVMTypeRef LLVMLabelType(void) { 609 return LLVMLabelTypeInContext(LLVMGetGlobalContext()); 610} 611 612/*===-- Operations on values ----------------------------------------------===*/ 613 614/*--.. Operations on all values ............................................--*/ 615 616LLVMTypeRef LLVMTypeOf(LLVMValueRef Val) { 617 return wrap(unwrap(Val)->getType()); 618} 619 620LLVMValueKind LLVMGetValueKind(LLVMValueRef Val) { 621 switch(unwrap(Val)->getValueID()) { 622#define HANDLE_VALUE(Name) \ 623 case Value::Name##Val: \ 624 return LLVM##Name##ValueKind; 625#include "llvm/IR/Value.def" 626 default: 627 return LLVMInstructionValueKind; 628 } 629} 630 631const char *LLVMGetValueName(LLVMValueRef Val) { 632 return unwrap(Val)->getName().data(); 633} 634 635void LLVMSetValueName(LLVMValueRef Val, const char *Name) { 636 unwrap(Val)->setName(Name); 637} 638 639void LLVMDumpValue(LLVMValueRef Val) { 640 unwrap(Val)->dump(); 641} 642 643char* LLVMPrintValueToString(LLVMValueRef Val) { 644 std::string buf; 645 raw_string_ostream os(buf); 646 647 if (unwrap(Val)) 648 unwrap(Val)->print(os); 649 else 650 os << "Printing <null> Value"; 651 652 os.flush(); 653 654 return strdup(buf.c_str()); 655} 656 657void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal) { 658 unwrap(OldVal)->replaceAllUsesWith(unwrap(NewVal)); 659} 660 661int LLVMHasMetadata(LLVMValueRef Inst) { 662 return unwrap<Instruction>(Inst)->hasMetadata(); 663} 664 665LLVMValueRef LLVMGetMetadata(LLVMValueRef Inst, unsigned KindID) { 666 auto *I = unwrap<Instruction>(Inst); 667 assert(I && "Expected instruction"); 668 if (auto *MD = I->getMetadata(KindID)) 669 return wrap(MetadataAsValue::get(I->getContext(), MD)); 670 return nullptr; 671} 672 673// MetadataAsValue uses a canonical format which strips the actual MDNode for 674// MDNode with just a single constant value, storing just a ConstantAsMetadata 675// This undoes this canonicalization, reconstructing the MDNode. 676static MDNode *extractMDNode(MetadataAsValue *MAV) { 677 Metadata *MD = MAV->getMetadata(); 678 assert((isa<MDNode>(MD) || isa<ConstantAsMetadata>(MD)) && 679 "Expected a metadata node or a canonicalized constant"); 680 681 if (MDNode *N = dyn_cast<MDNode>(MD)) 682 return N; 683 684 return MDNode::get(MAV->getContext(), MD); 685} 686 687void LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef Val) { 688 MDNode *N = Val ? extractMDNode(unwrap<MetadataAsValue>(Val)) : nullptr; 689 690 unwrap<Instruction>(Inst)->setMetadata(KindID, N); 691} 692 693/*--.. Conversion functions ................................................--*/ 694 695#define LLVM_DEFINE_VALUE_CAST(name) \ 696 LLVMValueRef LLVMIsA##name(LLVMValueRef Val) { \ 697 return wrap(static_cast<Value*>(dyn_cast_or_null<name>(unwrap(Val)))); \ 698 } 699 700LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DEFINE_VALUE_CAST) 701 702LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val) { 703 if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val))) 704 if (isa<MDNode>(MD->getMetadata()) || 705 isa<ValueAsMetadata>(MD->getMetadata())) 706 return Val; 707 return nullptr; 708} 709 710LLVMValueRef LLVMIsAMDString(LLVMValueRef Val) { 711 if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val))) 712 if (isa<MDString>(MD->getMetadata())) 713 return Val; 714 return nullptr; 715} 716 717/*--.. Operations on Uses ..................................................--*/ 718LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val) { 719 Value *V = unwrap(Val); 720 Value::use_iterator I = V->use_begin(); 721 if (I == V->use_end()) 722 return nullptr; 723 return wrap(&*I); 724} 725 726LLVMUseRef LLVMGetNextUse(LLVMUseRef U) { 727 Use *Next = unwrap(U)->getNext(); 728 if (Next) 729 return wrap(Next); 730 return nullptr; 731} 732 733LLVMValueRef LLVMGetUser(LLVMUseRef U) { 734 return wrap(unwrap(U)->getUser()); 735} 736 737LLVMValueRef LLVMGetUsedValue(LLVMUseRef U) { 738 return wrap(unwrap(U)->get()); 739} 740 741/*--.. Operations on Users .................................................--*/ 742 743static LLVMValueRef getMDNodeOperandImpl(LLVMContext &Context, const MDNode *N, 744 unsigned Index) { 745 Metadata *Op = N->getOperand(Index); 746 if (!Op) 747 return nullptr; 748 if (auto *C = dyn_cast<ConstantAsMetadata>(Op)) 749 return wrap(C->getValue()); 750 return wrap(MetadataAsValue::get(Context, Op)); 751} 752 753LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index) { 754 Value *V = unwrap(Val); 755 if (auto *MD = dyn_cast<MetadataAsValue>(V)) { 756 if (auto *L = dyn_cast<ValueAsMetadata>(MD->getMetadata())) { 757 assert(Index == 0 && "Function-local metadata can only have one operand"); 758 return wrap(L->getValue()); 759 } 760 return getMDNodeOperandImpl(V->getContext(), 761 cast<MDNode>(MD->getMetadata()), Index); 762 } 763 764 return wrap(cast<User>(V)->getOperand(Index)); 765} 766 767LLVMUseRef LLVMGetOperandUse(LLVMValueRef Val, unsigned Index) { 768 Value *V = unwrap(Val); 769 return wrap(&cast<User>(V)->getOperandUse(Index)); 770} 771 772void LLVMSetOperand(LLVMValueRef Val, unsigned Index, LLVMValueRef Op) { 773 unwrap<User>(Val)->setOperand(Index, unwrap(Op)); 774} 775 776int LLVMGetNumOperands(LLVMValueRef Val) { 777 Value *V = unwrap(Val); 778 if (isa<MetadataAsValue>(V)) 779 return LLVMGetMDNodeNumOperands(Val); 780 781 return cast<User>(V)->getNumOperands(); 782} 783 784/*--.. Operations on constants of any type .................................--*/ 785 786LLVMValueRef LLVMConstNull(LLVMTypeRef Ty) { 787 return wrap(Constant::getNullValue(unwrap(Ty))); 788} 789 790LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty) { 791 return wrap(Constant::getAllOnesValue(unwrap(Ty))); 792} 793 794LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) { 795 return wrap(UndefValue::get(unwrap(Ty))); 796} 797 798LLVMBool LLVMIsConstant(LLVMValueRef Ty) { 799 return isa<Constant>(unwrap(Ty)); 800} 801 802LLVMBool LLVMIsNull(LLVMValueRef Val) { 803 if (Constant *C = dyn_cast<Constant>(unwrap(Val))) 804 return C->isNullValue(); 805 return false; 806} 807 808LLVMBool LLVMIsUndef(LLVMValueRef Val) { 809 return isa<UndefValue>(unwrap(Val)); 810} 811 812LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) { 813 return wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty))); 814} 815 816/*--.. Operations on metadata nodes ........................................--*/ 817 818LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str, 819 unsigned SLen) { 820 LLVMContext &Context = *unwrap(C); 821 return wrap(MetadataAsValue::get( 822 Context, MDString::get(Context, StringRef(Str, SLen)))); 823} 824 825LLVMValueRef LLVMMDString(const char *Str, unsigned SLen) { 826 return LLVMMDStringInContext(LLVMGetGlobalContext(), Str, SLen); 827} 828 829LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals, 830 unsigned Count) { 831 LLVMContext &Context = *unwrap(C); 832 SmallVector<Metadata *, 8> MDs; 833 for (auto *OV : makeArrayRef(Vals, Count)) { 834 Value *V = unwrap(OV); 835 Metadata *MD; 836 if (!V) 837 MD = nullptr; 838 else if (auto *C = dyn_cast<Constant>(V)) 839 MD = ConstantAsMetadata::get(C); 840 else if (auto *MDV = dyn_cast<MetadataAsValue>(V)) { 841 MD = MDV->getMetadata(); 842 assert(!isa<LocalAsMetadata>(MD) && "Unexpected function-local metadata " 843 "outside of direct argument to call"); 844 } else { 845 // This is function-local metadata. Pretend to make an MDNode. 846 assert(Count == 1 && 847 "Expected only one operand to function-local metadata"); 848 return wrap(MetadataAsValue::get(Context, LocalAsMetadata::get(V))); 849 } 850 851 MDs.push_back(MD); 852 } 853 return wrap(MetadataAsValue::get(Context, MDNode::get(Context, MDs))); 854} 855 856LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count) { 857 return LLVMMDNodeInContext(LLVMGetGlobalContext(), Vals, Count); 858} 859 860const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length) { 861 if (const auto *MD = dyn_cast<MetadataAsValue>(unwrap(V))) 862 if (const MDString *S = dyn_cast<MDString>(MD->getMetadata())) { 863 *Length = S->getString().size(); 864 return S->getString().data(); 865 } 866 *Length = 0; 867 return nullptr; 868} 869 870unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V) { 871 auto *MD = cast<MetadataAsValue>(unwrap(V)); 872 if (isa<ValueAsMetadata>(MD->getMetadata())) 873 return 1; 874 return cast<MDNode>(MD->getMetadata())->getNumOperands(); 875} 876 877void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest) { 878 auto *MD = cast<MetadataAsValue>(unwrap(V)); 879 if (auto *MDV = dyn_cast<ValueAsMetadata>(MD->getMetadata())) { 880 *Dest = wrap(MDV->getValue()); 881 return; 882 } 883 const auto *N = cast<MDNode>(MD->getMetadata()); 884 const unsigned numOperands = N->getNumOperands(); 885 LLVMContext &Context = unwrap(V)->getContext(); 886 for (unsigned i = 0; i < numOperands; i++) 887 Dest[i] = getMDNodeOperandImpl(Context, N, i); 888} 889 890unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char *Name) { 891 if (NamedMDNode *N = unwrap(M)->getNamedMetadata(Name)) { 892 return N->getNumOperands(); 893 } 894 return 0; 895} 896 897void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char *Name, 898 LLVMValueRef *Dest) { 899 NamedMDNode *N = unwrap(M)->getNamedMetadata(Name); 900 if (!N) 901 return; 902 LLVMContext &Context = unwrap(M)->getContext(); 903 for (unsigned i=0;i<N->getNumOperands();i++) 904 Dest[i] = wrap(MetadataAsValue::get(Context, N->getOperand(i))); 905} 906 907void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char *Name, 908 LLVMValueRef Val) { 909 NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(Name); 910 if (!N) 911 return; 912 if (!Val) 913 return; 914 N->addOperand(extractMDNode(unwrap<MetadataAsValue>(Val))); 915} 916 917/*--.. Operations on scalar constants ......................................--*/ 918 919LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, 920 LLVMBool SignExtend) { 921 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0)); 922} 923 924LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy, 925 unsigned NumWords, 926 const uint64_t Words[]) { 927 IntegerType *Ty = unwrap<IntegerType>(IntTy); 928 return wrap(ConstantInt::get(Ty->getContext(), 929 APInt(Ty->getBitWidth(), 930 makeArrayRef(Words, NumWords)))); 931} 932 933LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char Str[], 934 uint8_t Radix) { 935 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str), 936 Radix)); 937} 938 939LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char Str[], 940 unsigned SLen, uint8_t Radix) { 941 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str, SLen), 942 Radix)); 943} 944 945LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N) { 946 return wrap(ConstantFP::get(unwrap(RealTy), N)); 947} 948 949LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text) { 950 return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Text))); 951} 952 953LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char Str[], 954 unsigned SLen) { 955 return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Str, SLen))); 956} 957 958unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal) { 959 return unwrap<ConstantInt>(ConstantVal)->getZExtValue(); 960} 961 962long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal) { 963 return unwrap<ConstantInt>(ConstantVal)->getSExtValue(); 964} 965 966double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *LosesInfo) { 967 ConstantFP *cFP = unwrap<ConstantFP>(ConstantVal) ; 968 Type *Ty = cFP->getType(); 969 970 if (Ty->isFloatTy()) { 971 *LosesInfo = false; 972 return cFP->getValueAPF().convertToFloat(); 973 } 974 975 if (Ty->isDoubleTy()) { 976 *LosesInfo = false; 977 return cFP->getValueAPF().convertToDouble(); 978 } 979 980 bool APFLosesInfo; 981 APFloat APF = cFP->getValueAPF(); 982 APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &APFLosesInfo); 983 *LosesInfo = APFLosesInfo; 984 return APF.convertToDouble(); 985} 986 987/*--.. Operations on composite constants ...................................--*/ 988 989LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str, 990 unsigned Length, 991 LLVMBool DontNullTerminate) { 992 /* Inverted the sense of AddNull because ', 0)' is a 993 better mnemonic for null termination than ', 1)'. */ 994 return wrap(ConstantDataArray::getString(*unwrap(C), StringRef(Str, Length), 995 DontNullTerminate == 0)); 996} 997 998LLVMValueRef LLVMConstString(const char *Str, unsigned Length, 999 LLVMBool DontNullTerminate) { 1000 return LLVMConstStringInContext(LLVMGetGlobalContext(), Str, Length, 1001 DontNullTerminate); 1002} 1003 1004LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef C, unsigned idx) { 1005 return wrap(unwrap<ConstantDataSequential>(C)->getElementAsConstant(idx)); 1006} 1007 1008LLVMBool LLVMIsConstantString(LLVMValueRef C) { 1009 return unwrap<ConstantDataSequential>(C)->isString(); 1010} 1011 1012const char *LLVMGetAsString(LLVMValueRef C, size_t *Length) { 1013 StringRef Str = unwrap<ConstantDataSequential>(C)->getAsString(); 1014 *Length = Str.size(); 1015 return Str.data(); 1016} 1017 1018LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, 1019 LLVMValueRef *ConstantVals, unsigned Length) { 1020 ArrayRef<Constant*> V(unwrap<Constant>(ConstantVals, Length), Length); 1021 return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V)); 1022} 1023 1024LLVMValueRef LLVMConstStructInContext(LLVMContextRef C, 1025 LLVMValueRef *ConstantVals, 1026 unsigned Count, LLVMBool Packed) { 1027 Constant **Elements = unwrap<Constant>(ConstantVals, Count); 1028 return wrap(ConstantStruct::getAnon(*unwrap(C), makeArrayRef(Elements, Count), 1029 Packed != 0)); 1030} 1031 1032LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, 1033 LLVMBool Packed) { 1034 return LLVMConstStructInContext(LLVMGetGlobalContext(), ConstantVals, Count, 1035 Packed); 1036} 1037 1038LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy, 1039 LLVMValueRef *ConstantVals, 1040 unsigned Count) { 1041 Constant **Elements = unwrap<Constant>(ConstantVals, Count); 1042 StructType *Ty = cast<StructType>(unwrap(StructTy)); 1043 1044 return wrap(ConstantStruct::get(Ty, makeArrayRef(Elements, Count))); 1045} 1046 1047LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) { 1048 return wrap(ConstantVector::get(makeArrayRef( 1049 unwrap<Constant>(ScalarConstantVals, Size), Size))); 1050} 1051 1052/*-- Opcode mapping */ 1053 1054static LLVMOpcode map_to_llvmopcode(int opcode) 1055{ 1056 switch (opcode) { 1057 default: llvm_unreachable("Unhandled Opcode."); 1058#define HANDLE_INST(num, opc, clas) case num: return LLVM##opc; 1059#include "llvm/IR/Instruction.def" 1060#undef HANDLE_INST 1061 } 1062} 1063 1064static int map_from_llvmopcode(LLVMOpcode code) 1065{ 1066 switch (code) { 1067#define HANDLE_INST(num, opc, clas) case LLVM##opc: return num; 1068#include "llvm/IR/Instruction.def" 1069#undef HANDLE_INST 1070 } 1071 llvm_unreachable("Unhandled Opcode."); 1072} 1073 1074/*--.. Constant expressions ................................................--*/ 1075 1076LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal) { 1077 return map_to_llvmopcode(unwrap<ConstantExpr>(ConstantVal)->getOpcode()); 1078} 1079 1080LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty) { 1081 return wrap(ConstantExpr::getAlignOf(unwrap(Ty))); 1082} 1083 1084LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty) { 1085 return wrap(ConstantExpr::getSizeOf(unwrap(Ty))); 1086} 1087 1088LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal) { 1089 return wrap(ConstantExpr::getNeg(unwrap<Constant>(ConstantVal))); 1090} 1091 1092LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal) { 1093 return wrap(ConstantExpr::getNSWNeg(unwrap<Constant>(ConstantVal))); 1094} 1095 1096LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal) { 1097 return wrap(ConstantExpr::getNUWNeg(unwrap<Constant>(ConstantVal))); 1098} 1099 1100 1101LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal) { 1102 return wrap(ConstantExpr::getFNeg(unwrap<Constant>(ConstantVal))); 1103} 1104 1105LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal) { 1106 return wrap(ConstantExpr::getNot(unwrap<Constant>(ConstantVal))); 1107} 1108 1109LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1110 return wrap(ConstantExpr::getAdd(unwrap<Constant>(LHSConstant), 1111 unwrap<Constant>(RHSConstant))); 1112} 1113 1114LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, 1115 LLVMValueRef RHSConstant) { 1116 return wrap(ConstantExpr::getNSWAdd(unwrap<Constant>(LHSConstant), 1117 unwrap<Constant>(RHSConstant))); 1118} 1119 1120LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, 1121 LLVMValueRef RHSConstant) { 1122 return wrap(ConstantExpr::getNUWAdd(unwrap<Constant>(LHSConstant), 1123 unwrap<Constant>(RHSConstant))); 1124} 1125 1126LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1127 return wrap(ConstantExpr::getFAdd(unwrap<Constant>(LHSConstant), 1128 unwrap<Constant>(RHSConstant))); 1129} 1130 1131LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1132 return wrap(ConstantExpr::getSub(unwrap<Constant>(LHSConstant), 1133 unwrap<Constant>(RHSConstant))); 1134} 1135 1136LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, 1137 LLVMValueRef RHSConstant) { 1138 return wrap(ConstantExpr::getNSWSub(unwrap<Constant>(LHSConstant), 1139 unwrap<Constant>(RHSConstant))); 1140} 1141 1142LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, 1143 LLVMValueRef RHSConstant) { 1144 return wrap(ConstantExpr::getNUWSub(unwrap<Constant>(LHSConstant), 1145 unwrap<Constant>(RHSConstant))); 1146} 1147 1148LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1149 return wrap(ConstantExpr::getFSub(unwrap<Constant>(LHSConstant), 1150 unwrap<Constant>(RHSConstant))); 1151} 1152 1153LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1154 return wrap(ConstantExpr::getMul(unwrap<Constant>(LHSConstant), 1155 unwrap<Constant>(RHSConstant))); 1156} 1157 1158LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, 1159 LLVMValueRef RHSConstant) { 1160 return wrap(ConstantExpr::getNSWMul(unwrap<Constant>(LHSConstant), 1161 unwrap<Constant>(RHSConstant))); 1162} 1163 1164LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, 1165 LLVMValueRef RHSConstant) { 1166 return wrap(ConstantExpr::getNUWMul(unwrap<Constant>(LHSConstant), 1167 unwrap<Constant>(RHSConstant))); 1168} 1169 1170LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1171 return wrap(ConstantExpr::getFMul(unwrap<Constant>(LHSConstant), 1172 unwrap<Constant>(RHSConstant))); 1173} 1174 1175LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1176 return wrap(ConstantExpr::getUDiv(unwrap<Constant>(LHSConstant), 1177 unwrap<Constant>(RHSConstant))); 1178} 1179 1180LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1181 return wrap(ConstantExpr::getSDiv(unwrap<Constant>(LHSConstant), 1182 unwrap<Constant>(RHSConstant))); 1183} 1184 1185LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, 1186 LLVMValueRef RHSConstant) { 1187 return wrap(ConstantExpr::getExactSDiv(unwrap<Constant>(LHSConstant), 1188 unwrap<Constant>(RHSConstant))); 1189} 1190 1191LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1192 return wrap(ConstantExpr::getFDiv(unwrap<Constant>(LHSConstant), 1193 unwrap<Constant>(RHSConstant))); 1194} 1195 1196LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1197 return wrap(ConstantExpr::getURem(unwrap<Constant>(LHSConstant), 1198 unwrap<Constant>(RHSConstant))); 1199} 1200 1201LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1202 return wrap(ConstantExpr::getSRem(unwrap<Constant>(LHSConstant), 1203 unwrap<Constant>(RHSConstant))); 1204} 1205 1206LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1207 return wrap(ConstantExpr::getFRem(unwrap<Constant>(LHSConstant), 1208 unwrap<Constant>(RHSConstant))); 1209} 1210 1211LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1212 return wrap(ConstantExpr::getAnd(unwrap<Constant>(LHSConstant), 1213 unwrap<Constant>(RHSConstant))); 1214} 1215 1216LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1217 return wrap(ConstantExpr::getOr(unwrap<Constant>(LHSConstant), 1218 unwrap<Constant>(RHSConstant))); 1219} 1220 1221LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1222 return wrap(ConstantExpr::getXor(unwrap<Constant>(LHSConstant), 1223 unwrap<Constant>(RHSConstant))); 1224} 1225 1226LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, 1227 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1228 return wrap(ConstantExpr::getICmp(Predicate, 1229 unwrap<Constant>(LHSConstant), 1230 unwrap<Constant>(RHSConstant))); 1231} 1232 1233LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, 1234 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1235 return wrap(ConstantExpr::getFCmp(Predicate, 1236 unwrap<Constant>(LHSConstant), 1237 unwrap<Constant>(RHSConstant))); 1238} 1239 1240LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1241 return wrap(ConstantExpr::getShl(unwrap<Constant>(LHSConstant), 1242 unwrap<Constant>(RHSConstant))); 1243} 1244 1245LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1246 return wrap(ConstantExpr::getLShr(unwrap<Constant>(LHSConstant), 1247 unwrap<Constant>(RHSConstant))); 1248} 1249 1250LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 1251 return wrap(ConstantExpr::getAShr(unwrap<Constant>(LHSConstant), 1252 unwrap<Constant>(RHSConstant))); 1253} 1254 1255LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, 1256 LLVMValueRef *ConstantIndices, unsigned NumIndices) { 1257 ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices), 1258 NumIndices); 1259 return wrap(ConstantExpr::getGetElementPtr( 1260 nullptr, unwrap<Constant>(ConstantVal), IdxList)); 1261} 1262 1263LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, 1264 LLVMValueRef *ConstantIndices, 1265 unsigned NumIndices) { 1266 Constant* Val = unwrap<Constant>(ConstantVal); 1267 ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices), 1268 NumIndices); 1269 return wrap(ConstantExpr::getInBoundsGetElementPtr(nullptr, Val, IdxList)); 1270} 1271 1272LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1273 return wrap(ConstantExpr::getTrunc(unwrap<Constant>(ConstantVal), 1274 unwrap(ToType))); 1275} 1276 1277LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1278 return wrap(ConstantExpr::getSExt(unwrap<Constant>(ConstantVal), 1279 unwrap(ToType))); 1280} 1281 1282LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1283 return wrap(ConstantExpr::getZExt(unwrap<Constant>(ConstantVal), 1284 unwrap(ToType))); 1285} 1286 1287LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1288 return wrap(ConstantExpr::getFPTrunc(unwrap<Constant>(ConstantVal), 1289 unwrap(ToType))); 1290} 1291 1292LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1293 return wrap(ConstantExpr::getFPExtend(unwrap<Constant>(ConstantVal), 1294 unwrap(ToType))); 1295} 1296 1297LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1298 return wrap(ConstantExpr::getUIToFP(unwrap<Constant>(ConstantVal), 1299 unwrap(ToType))); 1300} 1301 1302LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1303 return wrap(ConstantExpr::getSIToFP(unwrap<Constant>(ConstantVal), 1304 unwrap(ToType))); 1305} 1306 1307LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1308 return wrap(ConstantExpr::getFPToUI(unwrap<Constant>(ConstantVal), 1309 unwrap(ToType))); 1310} 1311 1312LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1313 return wrap(ConstantExpr::getFPToSI(unwrap<Constant>(ConstantVal), 1314 unwrap(ToType))); 1315} 1316 1317LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1318 return wrap(ConstantExpr::getPtrToInt(unwrap<Constant>(ConstantVal), 1319 unwrap(ToType))); 1320} 1321 1322LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1323 return wrap(ConstantExpr::getIntToPtr(unwrap<Constant>(ConstantVal), 1324 unwrap(ToType))); 1325} 1326 1327LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1328 return wrap(ConstantExpr::getBitCast(unwrap<Constant>(ConstantVal), 1329 unwrap(ToType))); 1330} 1331 1332LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal, 1333 LLVMTypeRef ToType) { 1334 return wrap(ConstantExpr::getAddrSpaceCast(unwrap<Constant>(ConstantVal), 1335 unwrap(ToType))); 1336} 1337 1338LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, 1339 LLVMTypeRef ToType) { 1340 return wrap(ConstantExpr::getZExtOrBitCast(unwrap<Constant>(ConstantVal), 1341 unwrap(ToType))); 1342} 1343 1344LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, 1345 LLVMTypeRef ToType) { 1346 return wrap(ConstantExpr::getSExtOrBitCast(unwrap<Constant>(ConstantVal), 1347 unwrap(ToType))); 1348} 1349 1350LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, 1351 LLVMTypeRef ToType) { 1352 return wrap(ConstantExpr::getTruncOrBitCast(unwrap<Constant>(ConstantVal), 1353 unwrap(ToType))); 1354} 1355 1356LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, 1357 LLVMTypeRef ToType) { 1358 return wrap(ConstantExpr::getPointerCast(unwrap<Constant>(ConstantVal), 1359 unwrap(ToType))); 1360} 1361 1362LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, 1363 LLVMBool isSigned) { 1364 return wrap(ConstantExpr::getIntegerCast(unwrap<Constant>(ConstantVal), 1365 unwrap(ToType), isSigned)); 1366} 1367 1368LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1369 return wrap(ConstantExpr::getFPCast(unwrap<Constant>(ConstantVal), 1370 unwrap(ToType))); 1371} 1372 1373LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, 1374 LLVMValueRef ConstantIfTrue, 1375 LLVMValueRef ConstantIfFalse) { 1376 return wrap(ConstantExpr::getSelect(unwrap<Constant>(ConstantCondition), 1377 unwrap<Constant>(ConstantIfTrue), 1378 unwrap<Constant>(ConstantIfFalse))); 1379} 1380 1381LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, 1382 LLVMValueRef IndexConstant) { 1383 return wrap(ConstantExpr::getExtractElement(unwrap<Constant>(VectorConstant), 1384 unwrap<Constant>(IndexConstant))); 1385} 1386 1387LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, 1388 LLVMValueRef ElementValueConstant, 1389 LLVMValueRef IndexConstant) { 1390 return wrap(ConstantExpr::getInsertElement(unwrap<Constant>(VectorConstant), 1391 unwrap<Constant>(ElementValueConstant), 1392 unwrap<Constant>(IndexConstant))); 1393} 1394 1395LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, 1396 LLVMValueRef VectorBConstant, 1397 LLVMValueRef MaskConstant) { 1398 return wrap(ConstantExpr::getShuffleVector(unwrap<Constant>(VectorAConstant), 1399 unwrap<Constant>(VectorBConstant), 1400 unwrap<Constant>(MaskConstant))); 1401} 1402 1403LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, 1404 unsigned NumIdx) { 1405 return wrap(ConstantExpr::getExtractValue(unwrap<Constant>(AggConstant), 1406 makeArrayRef(IdxList, NumIdx))); 1407} 1408 1409LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, 1410 LLVMValueRef ElementValueConstant, 1411 unsigned *IdxList, unsigned NumIdx) { 1412 return wrap(ConstantExpr::getInsertValue(unwrap<Constant>(AggConstant), 1413 unwrap<Constant>(ElementValueConstant), 1414 makeArrayRef(IdxList, NumIdx))); 1415} 1416 1417LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, const char *AsmString, 1418 const char *Constraints, 1419 LLVMBool HasSideEffects, 1420 LLVMBool IsAlignStack) { 1421 return wrap(InlineAsm::get(dyn_cast<FunctionType>(unwrap(Ty)), AsmString, 1422 Constraints, HasSideEffects, IsAlignStack)); 1423} 1424 1425LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB) { 1426 return wrap(BlockAddress::get(unwrap<Function>(F), unwrap(BB))); 1427} 1428 1429/*--.. Operations on global variables, functions, and aliases (globals) ....--*/ 1430 1431LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global) { 1432 return wrap(unwrap<GlobalValue>(Global)->getParent()); 1433} 1434 1435LLVMBool LLVMIsDeclaration(LLVMValueRef Global) { 1436 return unwrap<GlobalValue>(Global)->isDeclaration(); 1437} 1438 1439LLVMLinkage LLVMGetLinkage(LLVMValueRef Global) { 1440 switch (unwrap<GlobalValue>(Global)->getLinkage()) { 1441 case GlobalValue::ExternalLinkage: 1442 return LLVMExternalLinkage; 1443 case GlobalValue::AvailableExternallyLinkage: 1444 return LLVMAvailableExternallyLinkage; 1445 case GlobalValue::LinkOnceAnyLinkage: 1446 return LLVMLinkOnceAnyLinkage; 1447 case GlobalValue::LinkOnceODRLinkage: 1448 return LLVMLinkOnceODRLinkage; 1449 case GlobalValue::WeakAnyLinkage: 1450 return LLVMWeakAnyLinkage; 1451 case GlobalValue::WeakODRLinkage: 1452 return LLVMWeakODRLinkage; 1453 case GlobalValue::AppendingLinkage: 1454 return LLVMAppendingLinkage; 1455 case GlobalValue::InternalLinkage: 1456 return LLVMInternalLinkage; 1457 case GlobalValue::PrivateLinkage: 1458 return LLVMPrivateLinkage; 1459 case GlobalValue::ExternalWeakLinkage: 1460 return LLVMExternalWeakLinkage; 1461 case GlobalValue::CommonLinkage: 1462 return LLVMCommonLinkage; 1463 } 1464 1465 llvm_unreachable("Invalid GlobalValue linkage!"); 1466} 1467 1468void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage) { 1469 GlobalValue *GV = unwrap<GlobalValue>(Global); 1470 1471 switch (Linkage) { 1472 case LLVMExternalLinkage: 1473 GV->setLinkage(GlobalValue::ExternalLinkage); 1474 break; 1475 case LLVMAvailableExternallyLinkage: 1476 GV->setLinkage(GlobalValue::AvailableExternallyLinkage); 1477 break; 1478 case LLVMLinkOnceAnyLinkage: 1479 GV->setLinkage(GlobalValue::LinkOnceAnyLinkage); 1480 break; 1481 case LLVMLinkOnceODRLinkage: 1482 GV->setLinkage(GlobalValue::LinkOnceODRLinkage); 1483 break; 1484 case LLVMLinkOnceODRAutoHideLinkage: 1485 DEBUG(errs() << "LLVMSetLinkage(): LLVMLinkOnceODRAutoHideLinkage is no " 1486 "longer supported."); 1487 break; 1488 case LLVMWeakAnyLinkage: 1489 GV->setLinkage(GlobalValue::WeakAnyLinkage); 1490 break; 1491 case LLVMWeakODRLinkage: 1492 GV->setLinkage(GlobalValue::WeakODRLinkage); 1493 break; 1494 case LLVMAppendingLinkage: 1495 GV->setLinkage(GlobalValue::AppendingLinkage); 1496 break; 1497 case LLVMInternalLinkage: 1498 GV->setLinkage(GlobalValue::InternalLinkage); 1499 break; 1500 case LLVMPrivateLinkage: 1501 GV->setLinkage(GlobalValue::PrivateLinkage); 1502 break; 1503 case LLVMLinkerPrivateLinkage: 1504 GV->setLinkage(GlobalValue::PrivateLinkage); 1505 break; 1506 case LLVMLinkerPrivateWeakLinkage: 1507 GV->setLinkage(GlobalValue::PrivateLinkage); 1508 break; 1509 case LLVMDLLImportLinkage: 1510 DEBUG(errs() 1511 << "LLVMSetLinkage(): LLVMDLLImportLinkage is no longer supported."); 1512 break; 1513 case LLVMDLLExportLinkage: 1514 DEBUG(errs() 1515 << "LLVMSetLinkage(): LLVMDLLExportLinkage is no longer supported."); 1516 break; 1517 case LLVMExternalWeakLinkage: 1518 GV->setLinkage(GlobalValue::ExternalWeakLinkage); 1519 break; 1520 case LLVMGhostLinkage: 1521 DEBUG(errs() 1522 << "LLVMSetLinkage(): LLVMGhostLinkage is no longer supported."); 1523 break; 1524 case LLVMCommonLinkage: 1525 GV->setLinkage(GlobalValue::CommonLinkage); 1526 break; 1527 } 1528} 1529 1530const char *LLVMGetSection(LLVMValueRef Global) { 1531 // Using .data() is safe because of how GlobalObject::setSection is 1532 // implemented. 1533 return unwrap<GlobalValue>(Global)->getSection().data(); 1534} 1535 1536void LLVMSetSection(LLVMValueRef Global, const char *Section) { 1537 unwrap<GlobalObject>(Global)->setSection(Section); 1538} 1539 1540LLVMVisibility LLVMGetVisibility(LLVMValueRef Global) { 1541 return static_cast<LLVMVisibility>( 1542 unwrap<GlobalValue>(Global)->getVisibility()); 1543} 1544 1545void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz) { 1546 unwrap<GlobalValue>(Global) 1547 ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz)); 1548} 1549 1550LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global) { 1551 return static_cast<LLVMDLLStorageClass>( 1552 unwrap<GlobalValue>(Global)->getDLLStorageClass()); 1553} 1554 1555void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class) { 1556 unwrap<GlobalValue>(Global)->setDLLStorageClass( 1557 static_cast<GlobalValue::DLLStorageClassTypes>(Class)); 1558} 1559 1560LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global) { 1561 return unwrap<GlobalValue>(Global)->hasGlobalUnnamedAddr(); 1562} 1563 1564void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr) { 1565 unwrap<GlobalValue>(Global)->setUnnamedAddr( 1566 HasUnnamedAddr ? GlobalValue::UnnamedAddr::Global 1567 : GlobalValue::UnnamedAddr::None); 1568} 1569 1570/*--.. Operations on global variables, load and store instructions .........--*/ 1571 1572unsigned LLVMGetAlignment(LLVMValueRef V) { 1573 Value *P = unwrap<Value>(V); 1574 if (GlobalValue *GV = dyn_cast<GlobalValue>(P)) 1575 return GV->getAlignment(); 1576 if (AllocaInst *AI = dyn_cast<AllocaInst>(P)) 1577 return AI->getAlignment(); 1578 if (LoadInst *LI = dyn_cast<LoadInst>(P)) 1579 return LI->getAlignment(); 1580 if (StoreInst *SI = dyn_cast<StoreInst>(P)) 1581 return SI->getAlignment(); 1582 1583 llvm_unreachable( 1584 "only GlobalValue, AllocaInst, LoadInst and StoreInst have alignment"); 1585} 1586 1587void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes) { 1588 Value *P = unwrap<Value>(V); 1589 if (GlobalObject *GV = dyn_cast<GlobalObject>(P)) 1590 GV->setAlignment(Bytes); 1591 else if (AllocaInst *AI = dyn_cast<AllocaInst>(P)) 1592 AI->setAlignment(Bytes); 1593 else if (LoadInst *LI = dyn_cast<LoadInst>(P)) 1594 LI->setAlignment(Bytes); 1595 else if (StoreInst *SI = dyn_cast<StoreInst>(P)) 1596 SI->setAlignment(Bytes); 1597 else 1598 llvm_unreachable( 1599 "only GlobalValue, AllocaInst, LoadInst and StoreInst have alignment"); 1600} 1601 1602/*--.. Operations on global variables ......................................--*/ 1603 1604LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name) { 1605 return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false, 1606 GlobalValue::ExternalLinkage, nullptr, Name)); 1607} 1608 1609LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty, 1610 const char *Name, 1611 unsigned AddressSpace) { 1612 return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false, 1613 GlobalValue::ExternalLinkage, nullptr, Name, 1614 nullptr, GlobalVariable::NotThreadLocal, 1615 AddressSpace)); 1616} 1617 1618LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name) { 1619 return wrap(unwrap(M)->getNamedGlobal(Name)); 1620} 1621 1622LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M) { 1623 Module *Mod = unwrap(M); 1624 Module::global_iterator I = Mod->global_begin(); 1625 if (I == Mod->global_end()) 1626 return nullptr; 1627 return wrap(&*I); 1628} 1629 1630LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M) { 1631 Module *Mod = unwrap(M); 1632 Module::global_iterator I = Mod->global_end(); 1633 if (I == Mod->global_begin()) 1634 return nullptr; 1635 return wrap(&*--I); 1636} 1637 1638LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar) { 1639 GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar); 1640 Module::global_iterator I(GV); 1641 if (++I == GV->getParent()->global_end()) 1642 return nullptr; 1643 return wrap(&*I); 1644} 1645 1646LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar) { 1647 GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar); 1648 Module::global_iterator I(GV); 1649 if (I == GV->getParent()->global_begin()) 1650 return nullptr; 1651 return wrap(&*--I); 1652} 1653 1654void LLVMDeleteGlobal(LLVMValueRef GlobalVar) { 1655 unwrap<GlobalVariable>(GlobalVar)->eraseFromParent(); 1656} 1657 1658LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar) { 1659 GlobalVariable* GV = unwrap<GlobalVariable>(GlobalVar); 1660 if ( !GV->hasInitializer() ) 1661 return nullptr; 1662 return wrap(GV->getInitializer()); 1663} 1664 1665void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) { 1666 unwrap<GlobalVariable>(GlobalVar) 1667 ->setInitializer(unwrap<Constant>(ConstantVal)); 1668} 1669 1670LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar) { 1671 return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal(); 1672} 1673 1674void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal) { 1675 unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0); 1676} 1677 1678LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar) { 1679 return unwrap<GlobalVariable>(GlobalVar)->isConstant(); 1680} 1681 1682void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant) { 1683 unwrap<GlobalVariable>(GlobalVar)->setConstant(IsConstant != 0); 1684} 1685 1686LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar) { 1687 switch (unwrap<GlobalVariable>(GlobalVar)->getThreadLocalMode()) { 1688 case GlobalVariable::NotThreadLocal: 1689 return LLVMNotThreadLocal; 1690 case GlobalVariable::GeneralDynamicTLSModel: 1691 return LLVMGeneralDynamicTLSModel; 1692 case GlobalVariable::LocalDynamicTLSModel: 1693 return LLVMLocalDynamicTLSModel; 1694 case GlobalVariable::InitialExecTLSModel: 1695 return LLVMInitialExecTLSModel; 1696 case GlobalVariable::LocalExecTLSModel: 1697 return LLVMLocalExecTLSModel; 1698 } 1699 1700 llvm_unreachable("Invalid GlobalVariable thread local mode"); 1701} 1702 1703void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode) { 1704 GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar); 1705 1706 switch (Mode) { 1707 case LLVMNotThreadLocal: 1708 GV->setThreadLocalMode(GlobalVariable::NotThreadLocal); 1709 break; 1710 case LLVMGeneralDynamicTLSModel: 1711 GV->setThreadLocalMode(GlobalVariable::GeneralDynamicTLSModel); 1712 break; 1713 case LLVMLocalDynamicTLSModel: 1714 GV->setThreadLocalMode(GlobalVariable::LocalDynamicTLSModel); 1715 break; 1716 case LLVMInitialExecTLSModel: 1717 GV->setThreadLocalMode(GlobalVariable::InitialExecTLSModel); 1718 break; 1719 case LLVMLocalExecTLSModel: 1720 GV->setThreadLocalMode(GlobalVariable::LocalExecTLSModel); 1721 break; 1722 } 1723} 1724 1725LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar) { 1726 return unwrap<GlobalVariable>(GlobalVar)->isExternallyInitialized(); 1727} 1728 1729void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit) { 1730 unwrap<GlobalVariable>(GlobalVar)->setExternallyInitialized(IsExtInit); 1731} 1732 1733/*--.. Operations on aliases ......................................--*/ 1734 1735LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, 1736 const char *Name) { 1737 auto *PTy = cast<PointerType>(unwrap(Ty)); 1738 return wrap(GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), 1739 GlobalValue::ExternalLinkage, Name, 1740 unwrap<Constant>(Aliasee), unwrap(M))); 1741} 1742 1743/*--.. Operations on functions .............................................--*/ 1744 1745LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, 1746 LLVMTypeRef FunctionTy) { 1747 return wrap(Function::Create(unwrap<FunctionType>(FunctionTy), 1748 GlobalValue::ExternalLinkage, Name, unwrap(M))); 1749} 1750 1751LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name) { 1752 return wrap(unwrap(M)->getFunction(Name)); 1753} 1754 1755LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M) { 1756 Module *Mod = unwrap(M); 1757 Module::iterator I = Mod->begin(); 1758 if (I == Mod->end()) 1759 return nullptr; 1760 return wrap(&*I); 1761} 1762 1763LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M) { 1764 Module *Mod = unwrap(M); 1765 Module::iterator I = Mod->end(); 1766 if (I == Mod->begin()) 1767 return nullptr; 1768 return wrap(&*--I); 1769} 1770 1771LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn) { 1772 Function *Func = unwrap<Function>(Fn); 1773 Module::iterator I(Func); 1774 if (++I == Func->getParent()->end()) 1775 return nullptr; 1776 return wrap(&*I); 1777} 1778 1779LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn) { 1780 Function *Func = unwrap<Function>(Fn); 1781 Module::iterator I(Func); 1782 if (I == Func->getParent()->begin()) 1783 return nullptr; 1784 return wrap(&*--I); 1785} 1786 1787void LLVMDeleteFunction(LLVMValueRef Fn) { 1788 unwrap<Function>(Fn)->eraseFromParent(); 1789} 1790 1791LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn) { 1792 return unwrap<Function>(Fn)->hasPersonalityFn(); 1793} 1794 1795LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn) { 1796 return wrap(unwrap<Function>(Fn)->getPersonalityFn()); 1797} 1798 1799void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn) { 1800 unwrap<Function>(Fn)->setPersonalityFn(unwrap<Constant>(PersonalityFn)); 1801} 1802 1803unsigned LLVMGetIntrinsicID(LLVMValueRef Fn) { 1804 if (Function *F = dyn_cast<Function>(unwrap(Fn))) 1805 return F->getIntrinsicID(); 1806 return 0; 1807} 1808 1809unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn) { 1810 return unwrap<Function>(Fn)->getCallingConv(); 1811} 1812 1813void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC) { 1814 return unwrap<Function>(Fn)->setCallingConv( 1815 static_cast<CallingConv::ID>(CC)); 1816} 1817 1818const char *LLVMGetGC(LLVMValueRef Fn) { 1819 Function *F = unwrap<Function>(Fn); 1820 return F->hasGC()? F->getGC().c_str() : nullptr; 1821} 1822 1823void LLVMSetGC(LLVMValueRef Fn, const char *GC) { 1824 Function *F = unwrap<Function>(Fn); 1825 if (GC) 1826 F->setGC(GC); 1827 else 1828 F->clearGC(); 1829} 1830 1831void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA) { 1832 Function *Func = unwrap<Function>(Fn); 1833 const AttributeSet PAL = Func->getAttributes(); 1834 AttrBuilder B(PA); 1835 const AttributeSet PALnew = 1836 PAL.addAttributes(Func->getContext(), AttributeSet::FunctionIndex, 1837 AttributeSet::get(Func->getContext(), 1838 AttributeSet::FunctionIndex, B)); 1839 Func->setAttributes(PALnew); 1840} 1841 1842void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, 1843 LLVMAttributeRef A) { 1844 unwrap<Function>(F)->addAttribute(Idx, unwrap(A)); 1845} 1846 1847LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F, 1848 LLVMAttributeIndex Idx, 1849 unsigned KindID) { 1850 return wrap(unwrap<Function>(F)->getAttribute(Idx, 1851 (Attribute::AttrKind)KindID)); 1852} 1853 1854LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F, 1855 LLVMAttributeIndex Idx, 1856 const char *K, unsigned KLen) { 1857 return wrap(unwrap<Function>(F)->getAttribute(Idx, StringRef(K, KLen))); 1858} 1859 1860void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, 1861 unsigned KindID) { 1862 unwrap<Function>(F)->removeAttribute(Idx, (Attribute::AttrKind)KindID); 1863} 1864 1865void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, 1866 const char *K, unsigned KLen) { 1867 unwrap<Function>(F)->removeAttribute(Idx, StringRef(K, KLen)); 1868} 1869 1870void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A, 1871 const char *V) { 1872 Function *Func = unwrap<Function>(Fn); 1873 AttributeSet::AttrIndex Idx = 1874 AttributeSet::AttrIndex(AttributeSet::FunctionIndex); 1875 AttrBuilder B; 1876 1877 B.addAttribute(A, V); 1878 AttributeSet Set = AttributeSet::get(Func->getContext(), Idx, B); 1879 Func->addAttributes(Idx, Set); 1880} 1881 1882void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA) { 1883 Function *Func = unwrap<Function>(Fn); 1884 const AttributeSet PAL = Func->getAttributes(); 1885 AttrBuilder B(PA); 1886 const AttributeSet PALnew = 1887 PAL.removeAttributes(Func->getContext(), AttributeSet::FunctionIndex, 1888 AttributeSet::get(Func->getContext(), 1889 AttributeSet::FunctionIndex, B)); 1890 Func->setAttributes(PALnew); 1891} 1892 1893LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn) { 1894 Function *Func = unwrap<Function>(Fn); 1895 const AttributeSet PAL = Func->getAttributes(); 1896 return (LLVMAttribute)PAL.Raw(AttributeSet::FunctionIndex); 1897} 1898 1899/*--.. Operations on parameters ............................................--*/ 1900 1901unsigned LLVMCountParams(LLVMValueRef FnRef) { 1902 // This function is strictly redundant to 1903 // LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(FnRef))) 1904 return unwrap<Function>(FnRef)->arg_size(); 1905} 1906 1907void LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs) { 1908 Function *Fn = unwrap<Function>(FnRef); 1909 for (Function::arg_iterator I = Fn->arg_begin(), 1910 E = Fn->arg_end(); I != E; I++) 1911 *ParamRefs++ = wrap(&*I); 1912} 1913 1914LLVMValueRef LLVMGetParam(LLVMValueRef FnRef, unsigned index) { 1915 Function::arg_iterator AI = unwrap<Function>(FnRef)->arg_begin(); 1916 while (index --> 0) 1917 AI++; 1918 return wrap(&*AI); 1919} 1920 1921LLVMValueRef LLVMGetParamParent(LLVMValueRef V) { 1922 return wrap(unwrap<Argument>(V)->getParent()); 1923} 1924 1925LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn) { 1926 Function *Func = unwrap<Function>(Fn); 1927 Function::arg_iterator I = Func->arg_begin(); 1928 if (I == Func->arg_end()) 1929 return nullptr; 1930 return wrap(&*I); 1931} 1932 1933LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn) { 1934 Function *Func = unwrap<Function>(Fn); 1935 Function::arg_iterator I = Func->arg_end(); 1936 if (I == Func->arg_begin()) 1937 return nullptr; 1938 return wrap(&*--I); 1939} 1940 1941LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg) { 1942 Argument *A = unwrap<Argument>(Arg); 1943 Function::arg_iterator I(A); 1944 if (++I == A->getParent()->arg_end()) 1945 return nullptr; 1946 return wrap(&*I); 1947} 1948 1949LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg) { 1950 Argument *A = unwrap<Argument>(Arg); 1951 Function::arg_iterator I(A); 1952 if (I == A->getParent()->arg_begin()) 1953 return nullptr; 1954 return wrap(&*--I); 1955} 1956 1957void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA) { 1958 Argument *A = unwrap<Argument>(Arg); 1959 AttrBuilder B(PA); 1960 A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B)); 1961} 1962 1963void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA) { 1964 Argument *A = unwrap<Argument>(Arg); 1965 AttrBuilder B(PA); 1966 A->removeAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B)); 1967} 1968 1969LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg) { 1970 Argument *A = unwrap<Argument>(Arg); 1971 return (LLVMAttribute)A->getParent()->getAttributes(). 1972 Raw(A->getArgNo()+1); 1973} 1974 1975void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align) { 1976 Argument *A = unwrap<Argument>(Arg); 1977 AttrBuilder B; 1978 B.addAlignmentAttr(align); 1979 A->addAttr(AttributeSet::get(A->getContext(),A->getArgNo() + 1, B)); 1980} 1981 1982/*--.. Operations on basic blocks ..........................................--*/ 1983 1984LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB) { 1985 return wrap(static_cast<Value*>(unwrap(BB))); 1986} 1987 1988LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val) { 1989 return isa<BasicBlock>(unwrap(Val)); 1990} 1991 1992LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val) { 1993 return wrap(unwrap<BasicBlock>(Val)); 1994} 1995 1996const char *LLVMGetBasicBlockName(LLVMBasicBlockRef BB) { 1997 return unwrap(BB)->getName().data(); 1998} 1999 2000LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB) { 2001 return wrap(unwrap(BB)->getParent()); 2002} 2003 2004LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB) { 2005 return wrap(unwrap(BB)->getTerminator()); 2006} 2007 2008unsigned LLVMCountBasicBlocks(LLVMValueRef FnRef) { 2009 return unwrap<Function>(FnRef)->size(); 2010} 2011 2012void LLVMGetBasicBlocks(LLVMValueRef FnRef, LLVMBasicBlockRef *BasicBlocksRefs){ 2013 Function *Fn = unwrap<Function>(FnRef); 2014 for (BasicBlock &BB : *Fn) 2015 *BasicBlocksRefs++ = wrap(&BB); 2016} 2017 2018LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn) { 2019 return wrap(&unwrap<Function>(Fn)->getEntryBlock()); 2020} 2021 2022LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn) { 2023 Function *Func = unwrap<Function>(Fn); 2024 Function::iterator I = Func->begin(); 2025 if (I == Func->end()) 2026 return nullptr; 2027 return wrap(&*I); 2028} 2029 2030LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn) { 2031 Function *Func = unwrap<Function>(Fn); 2032 Function::iterator I = Func->end(); 2033 if (I == Func->begin()) 2034 return nullptr; 2035 return wrap(&*--I); 2036} 2037 2038LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB) { 2039 BasicBlock *Block = unwrap(BB); 2040 Function::iterator I(Block); 2041 if (++I == Block->getParent()->end()) 2042 return nullptr; 2043 return wrap(&*I); 2044} 2045 2046LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB) { 2047 BasicBlock *Block = unwrap(BB); 2048 Function::iterator I(Block); 2049 if (I == Block->getParent()->begin()) 2050 return nullptr; 2051 return wrap(&*--I); 2052} 2053 2054LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, 2055 LLVMValueRef FnRef, 2056 const char *Name) { 2057 return wrap(BasicBlock::Create(*unwrap(C), Name, unwrap<Function>(FnRef))); 2058} 2059 2060LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef FnRef, const char *Name) { 2061 return LLVMAppendBasicBlockInContext(LLVMGetGlobalContext(), FnRef, Name); 2062} 2063 2064LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, 2065 LLVMBasicBlockRef BBRef, 2066 const char *Name) { 2067 BasicBlock *BB = unwrap(BBRef); 2068 return wrap(BasicBlock::Create(*unwrap(C), Name, BB->getParent(), BB)); 2069} 2070 2071LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef BBRef, 2072 const char *Name) { 2073 return LLVMInsertBasicBlockInContext(LLVMGetGlobalContext(), BBRef, Name); 2074} 2075 2076void LLVMDeleteBasicBlock(LLVMBasicBlockRef BBRef) { 2077 unwrap(BBRef)->eraseFromParent(); 2078} 2079 2080void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BBRef) { 2081 unwrap(BBRef)->removeFromParent(); 2082} 2083 2084void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos) { 2085 unwrap(BB)->moveBefore(unwrap(MovePos)); 2086} 2087 2088void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos) { 2089 unwrap(BB)->moveAfter(unwrap(MovePos)); 2090} 2091 2092/*--.. Operations on instructions ..........................................--*/ 2093 2094LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst) { 2095 return wrap(unwrap<Instruction>(Inst)->getParent()); 2096} 2097 2098LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB) { 2099 BasicBlock *Block = unwrap(BB); 2100 BasicBlock::iterator I = Block->begin(); 2101 if (I == Block->end()) 2102 return nullptr; 2103 return wrap(&*I); 2104} 2105 2106LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB) { 2107 BasicBlock *Block = unwrap(BB); 2108 BasicBlock::iterator I = Block->end(); 2109 if (I == Block->begin()) 2110 return nullptr; 2111 return wrap(&*--I); 2112} 2113 2114LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst) { 2115 Instruction *Instr = unwrap<Instruction>(Inst); 2116 BasicBlock::iterator I(Instr); 2117 if (++I == Instr->getParent()->end()) 2118 return nullptr; 2119 return wrap(&*I); 2120} 2121 2122LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst) { 2123 Instruction *Instr = unwrap<Instruction>(Inst); 2124 BasicBlock::iterator I(Instr); 2125 if (I == Instr->getParent()->begin()) 2126 return nullptr; 2127 return wrap(&*--I); 2128} 2129 2130void LLVMInstructionRemoveFromParent(LLVMValueRef Inst) { 2131 unwrap<Instruction>(Inst)->removeFromParent(); 2132} 2133 2134void LLVMInstructionEraseFromParent(LLVMValueRef Inst) { 2135 unwrap<Instruction>(Inst)->eraseFromParent(); 2136} 2137 2138LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst) { 2139 if (ICmpInst *I = dyn_cast<ICmpInst>(unwrap(Inst))) 2140 return (LLVMIntPredicate)I->getPredicate(); 2141 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst))) 2142 if (CE->getOpcode() == Instruction::ICmp) 2143 return (LLVMIntPredicate)CE->getPredicate(); 2144 return (LLVMIntPredicate)0; 2145} 2146 2147LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst) { 2148 if (FCmpInst *I = dyn_cast<FCmpInst>(unwrap(Inst))) 2149 return (LLVMRealPredicate)I->getPredicate(); 2150 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst))) 2151 if (CE->getOpcode() == Instruction::FCmp) 2152 return (LLVMRealPredicate)CE->getPredicate(); 2153 return (LLVMRealPredicate)0; 2154} 2155 2156LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst) { 2157 if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst))) 2158 return map_to_llvmopcode(C->getOpcode()); 2159 return (LLVMOpcode)0; 2160} 2161 2162LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst) { 2163 if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst))) 2164 return wrap(C->clone()); 2165 return nullptr; 2166} 2167 2168/*--.. Call and invoke instructions ........................................--*/ 2169 2170unsigned LLVMGetNumArgOperands(LLVMValueRef Instr) { 2171 return CallSite(unwrap<Instruction>(Instr)).getNumArgOperands(); 2172} 2173 2174unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr) { 2175 return CallSite(unwrap<Instruction>(Instr)).getCallingConv(); 2176} 2177 2178void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC) { 2179 return CallSite(unwrap<Instruction>(Instr)) 2180 .setCallingConv(static_cast<CallingConv::ID>(CC)); 2181} 2182 2183void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, 2184 LLVMAttribute PA) { 2185 CallSite Call = CallSite(unwrap<Instruction>(Instr)); 2186 AttrBuilder B(PA); 2187 Call.setAttributes( 2188 Call.getAttributes().addAttributes(Call->getContext(), index, 2189 AttributeSet::get(Call->getContext(), 2190 index, B))); 2191} 2192 2193void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index, 2194 LLVMAttribute PA) { 2195 CallSite Call = CallSite(unwrap<Instruction>(Instr)); 2196 AttrBuilder B(PA); 2197 Call.setAttributes(Call.getAttributes() 2198 .removeAttributes(Call->getContext(), index, 2199 AttributeSet::get(Call->getContext(), 2200 index, B))); 2201} 2202 2203void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, 2204 unsigned align) { 2205 CallSite Call = CallSite(unwrap<Instruction>(Instr)); 2206 AttrBuilder B; 2207 B.addAlignmentAttr(align); 2208 Call.setAttributes(Call.getAttributes() 2209 .addAttributes(Call->getContext(), index, 2210 AttributeSet::get(Call->getContext(), 2211 index, B))); 2212} 2213 2214void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, 2215 LLVMAttributeRef A) { 2216 CallSite(unwrap<Instruction>(C)).addAttribute(Idx, unwrap(A)); 2217} 2218 2219LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C, 2220 LLVMAttributeIndex Idx, 2221 unsigned KindID) { 2222 return wrap(CallSite(unwrap<Instruction>(C)) 2223 .getAttribute(Idx, (Attribute::AttrKind)KindID)); 2224} 2225 2226LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C, 2227 LLVMAttributeIndex Idx, 2228 const char *K, unsigned KLen) { 2229 return wrap(CallSite(unwrap<Instruction>(C)) 2230 .getAttribute(Idx, StringRef(K, KLen))); 2231} 2232 2233void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, 2234 unsigned KindID) { 2235 CallSite(unwrap<Instruction>(C)) 2236 .removeAttribute(Idx, (Attribute::AttrKind)KindID); 2237} 2238 2239void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, 2240 const char *K, unsigned KLen) { 2241 CallSite(unwrap<Instruction>(C)).removeAttribute(Idx, StringRef(K, KLen)); 2242} 2243 2244LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr) { 2245 return wrap(CallSite(unwrap<Instruction>(Instr)).getCalledValue()); 2246} 2247 2248/*--.. Operations on call instructions (only) ..............................--*/ 2249 2250LLVMBool LLVMIsTailCall(LLVMValueRef Call) { 2251 return unwrap<CallInst>(Call)->isTailCall(); 2252} 2253 2254void LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall) { 2255 unwrap<CallInst>(Call)->setTailCall(isTailCall); 2256} 2257 2258/*--.. Operations on invoke instructions (only) ............................--*/ 2259 2260LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef Invoke) { 2261 return wrap(unwrap<InvokeInst>(Invoke)->getNormalDest()); 2262} 2263 2264LLVMBasicBlockRef LLVMGetUnwindDest(LLVMValueRef Invoke) { 2265 return wrap(unwrap<InvokeInst>(Invoke)->getUnwindDest()); 2266} 2267 2268void LLVMSetNormalDest(LLVMValueRef Invoke, LLVMBasicBlockRef B) { 2269 unwrap<InvokeInst>(Invoke)->setNormalDest(unwrap(B)); 2270} 2271 2272void LLVMSetUnwindDest(LLVMValueRef Invoke, LLVMBasicBlockRef B) { 2273 unwrap<InvokeInst>(Invoke)->setUnwindDest(unwrap(B)); 2274} 2275 2276/*--.. Operations on terminators ...........................................--*/ 2277 2278unsigned LLVMGetNumSuccessors(LLVMValueRef Term) { 2279 return unwrap<TerminatorInst>(Term)->getNumSuccessors(); 2280} 2281 2282LLVMBasicBlockRef LLVMGetSuccessor(LLVMValueRef Term, unsigned i) { 2283 return wrap(unwrap<TerminatorInst>(Term)->getSuccessor(i)); 2284} 2285 2286void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block) { 2287 return unwrap<TerminatorInst>(Term)->setSuccessor(i,unwrap(block)); 2288} 2289 2290/*--.. Operations on branch instructions (only) ............................--*/ 2291 2292LLVMBool LLVMIsConditional(LLVMValueRef Branch) { 2293 return unwrap<BranchInst>(Branch)->isConditional(); 2294} 2295 2296LLVMValueRef LLVMGetCondition(LLVMValueRef Branch) { 2297 return wrap(unwrap<BranchInst>(Branch)->getCondition()); 2298} 2299 2300void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond) { 2301 return unwrap<BranchInst>(Branch)->setCondition(unwrap(Cond)); 2302} 2303 2304/*--.. Operations on switch instructions (only) ............................--*/ 2305 2306LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef Switch) { 2307 return wrap(unwrap<SwitchInst>(Switch)->getDefaultDest()); 2308} 2309 2310/*--.. Operations on alloca instructions (only) ............................--*/ 2311 2312LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca) { 2313 return wrap(unwrap<AllocaInst>(Alloca)->getAllocatedType()); 2314} 2315 2316/*--.. Operations on gep instructions (only) ...............................--*/ 2317 2318LLVMBool LLVMIsInBounds(LLVMValueRef GEP) { 2319 return unwrap<GetElementPtrInst>(GEP)->isInBounds(); 2320} 2321 2322void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds) { 2323 return unwrap<GetElementPtrInst>(GEP)->setIsInBounds(InBounds); 2324} 2325 2326/*--.. Operations on phi nodes .............................................--*/ 2327 2328void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, 2329 LLVMBasicBlockRef *IncomingBlocks, unsigned Count) { 2330 PHINode *PhiVal = unwrap<PHINode>(PhiNode); 2331 for (unsigned I = 0; I != Count; ++I) 2332 PhiVal->addIncoming(unwrap(IncomingValues[I]), unwrap(IncomingBlocks[I])); 2333} 2334 2335unsigned LLVMCountIncoming(LLVMValueRef PhiNode) { 2336 return unwrap<PHINode>(PhiNode)->getNumIncomingValues(); 2337} 2338 2339LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index) { 2340 return wrap(unwrap<PHINode>(PhiNode)->getIncomingValue(Index)); 2341} 2342 2343LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index) { 2344 return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index)); 2345} 2346 2347/*--.. Operations on extractvalue and insertvalue nodes ....................--*/ 2348 2349unsigned LLVMGetNumIndices(LLVMValueRef Inst) { 2350 auto *I = unwrap(Inst); 2351 if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) 2352 return GEP->getNumIndices(); 2353 if (auto *EV = dyn_cast<ExtractValueInst>(I)) 2354 return EV->getNumIndices(); 2355 if (auto *IV = dyn_cast<InsertValueInst>(I)) 2356 return IV->getNumIndices(); 2357 llvm_unreachable( 2358 "LLVMGetNumIndices applies only to extractvalue and insertvalue!"); 2359} 2360 2361const unsigned *LLVMGetIndices(LLVMValueRef Inst) { 2362 auto *I = unwrap(Inst); 2363 if (auto *EV = dyn_cast<ExtractValueInst>(I)) 2364 return EV->getIndices().data(); 2365 if (auto *IV = dyn_cast<InsertValueInst>(I)) 2366 return IV->getIndices().data(); 2367 llvm_unreachable( 2368 "LLVMGetIndices applies only to extractvalue and insertvalue!"); 2369} 2370 2371 2372/*===-- Instruction builders ----------------------------------------------===*/ 2373 2374LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C) { 2375 return wrap(new IRBuilder<>(*unwrap(C))); 2376} 2377 2378LLVMBuilderRef LLVMCreateBuilder(void) { 2379 return LLVMCreateBuilderInContext(LLVMGetGlobalContext()); 2380} 2381 2382void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, 2383 LLVMValueRef Instr) { 2384 BasicBlock *BB = unwrap(Block); 2385 Instruction *I = Instr? unwrap<Instruction>(Instr) : (Instruction*) BB->end(); 2386 unwrap(Builder)->SetInsertPoint(BB, I->getIterator()); 2387} 2388 2389void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr) { 2390 Instruction *I = unwrap<Instruction>(Instr); 2391 unwrap(Builder)->SetInsertPoint(I->getParent(), I->getIterator()); 2392} 2393 2394void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block) { 2395 BasicBlock *BB = unwrap(Block); 2396 unwrap(Builder)->SetInsertPoint(BB); 2397} 2398 2399LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder) { 2400 return wrap(unwrap(Builder)->GetInsertBlock()); 2401} 2402 2403void LLVMClearInsertionPosition(LLVMBuilderRef Builder) { 2404 unwrap(Builder)->ClearInsertionPoint(); 2405} 2406 2407void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr) { 2408 unwrap(Builder)->Insert(unwrap<Instruction>(Instr)); 2409} 2410 2411void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, 2412 const char *Name) { 2413 unwrap(Builder)->Insert(unwrap<Instruction>(Instr), Name); 2414} 2415 2416void LLVMDisposeBuilder(LLVMBuilderRef Builder) { 2417 delete unwrap(Builder); 2418} 2419 2420/*--.. Metadata builders ...................................................--*/ 2421 2422void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L) { 2423 MDNode *Loc = 2424 L ? cast<MDNode>(unwrap<MetadataAsValue>(L)->getMetadata()) : nullptr; 2425 unwrap(Builder)->SetCurrentDebugLocation(DebugLoc(Loc)); 2426} 2427 2428LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder) { 2429 LLVMContext &Context = unwrap(Builder)->getContext(); 2430 return wrap(MetadataAsValue::get( 2431 Context, unwrap(Builder)->getCurrentDebugLocation().getAsMDNode())); 2432} 2433 2434void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst) { 2435 unwrap(Builder)->SetInstDebugLocation(unwrap<Instruction>(Inst)); 2436} 2437 2438 2439/*--.. Instruction builders ................................................--*/ 2440 2441LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef B) { 2442 return wrap(unwrap(B)->CreateRetVoid()); 2443} 2444 2445LLVMValueRef LLVMBuildRet(LLVMBuilderRef B, LLVMValueRef V) { 2446 return wrap(unwrap(B)->CreateRet(unwrap(V))); 2447} 2448 2449LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef B, LLVMValueRef *RetVals, 2450 unsigned N) { 2451 return wrap(unwrap(B)->CreateAggregateRet(unwrap(RetVals), N)); 2452} 2453 2454LLVMValueRef LLVMBuildBr(LLVMBuilderRef B, LLVMBasicBlockRef Dest) { 2455 return wrap(unwrap(B)->CreateBr(unwrap(Dest))); 2456} 2457 2458LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef B, LLVMValueRef If, 2459 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else) { 2460 return wrap(unwrap(B)->CreateCondBr(unwrap(If), unwrap(Then), unwrap(Else))); 2461} 2462 2463LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef B, LLVMValueRef V, 2464 LLVMBasicBlockRef Else, unsigned NumCases) { 2465 return wrap(unwrap(B)->CreateSwitch(unwrap(V), unwrap(Else), NumCases)); 2466} 2467 2468LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr, 2469 unsigned NumDests) { 2470 return wrap(unwrap(B)->CreateIndirectBr(unwrap(Addr), NumDests)); 2471} 2472 2473LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn, 2474 LLVMValueRef *Args, unsigned NumArgs, 2475 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, 2476 const char *Name) { 2477 return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch), 2478 makeArrayRef(unwrap(Args), NumArgs), 2479 Name)); 2480} 2481 2482LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, 2483 LLVMValueRef PersFn, unsigned NumClauses, 2484 const char *Name) { 2485 // The personality used to live on the landingpad instruction, but now it 2486 // lives on the parent function. For compatibility, take the provided 2487 // personality and put it on the parent function. 2488 if (PersFn) 2489 unwrap(B)->GetInsertBlock()->getParent()->setPersonalityFn( 2490 cast<Function>(unwrap(PersFn))); 2491 return wrap(unwrap(B)->CreateLandingPad(unwrap(Ty), NumClauses, Name)); 2492} 2493 2494LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn) { 2495 return wrap(unwrap(B)->CreateResume(unwrap(Exn))); 2496} 2497 2498LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) { 2499 return wrap(unwrap(B)->CreateUnreachable()); 2500} 2501 2502void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, 2503 LLVMBasicBlockRef Dest) { 2504 unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest)); 2505} 2506 2507void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest) { 2508 unwrap<IndirectBrInst>(IndirectBr)->addDestination(unwrap(Dest)); 2509} 2510 2511unsigned LLVMGetNumClauses(LLVMValueRef LandingPad) { 2512 return unwrap<LandingPadInst>(LandingPad)->getNumClauses(); 2513} 2514 2515LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx) { 2516 return wrap(unwrap<LandingPadInst>(LandingPad)->getClause(Idx)); 2517} 2518 2519void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal) { 2520 unwrap<LandingPadInst>(LandingPad)-> 2521 addClause(cast<Constant>(unwrap(ClauseVal))); 2522} 2523 2524LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad) { 2525 return unwrap<LandingPadInst>(LandingPad)->isCleanup(); 2526} 2527 2528void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val) { 2529 unwrap<LandingPadInst>(LandingPad)->setCleanup(Val); 2530} 2531 2532/*--.. Arithmetic ..........................................................--*/ 2533 2534LLVMValueRef LLVMBuildAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2535 const char *Name) { 2536 return wrap(unwrap(B)->CreateAdd(unwrap(LHS), unwrap(RHS), Name)); 2537} 2538 2539LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2540 const char *Name) { 2541 return wrap(unwrap(B)->CreateNSWAdd(unwrap(LHS), unwrap(RHS), Name)); 2542} 2543 2544LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2545 const char *Name) { 2546 return wrap(unwrap(B)->CreateNUWAdd(unwrap(LHS), unwrap(RHS), Name)); 2547} 2548 2549LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2550 const char *Name) { 2551 return wrap(unwrap(B)->CreateFAdd(unwrap(LHS), unwrap(RHS), Name)); 2552} 2553 2554LLVMValueRef LLVMBuildSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2555 const char *Name) { 2556 return wrap(unwrap(B)->CreateSub(unwrap(LHS), unwrap(RHS), Name)); 2557} 2558 2559LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2560 const char *Name) { 2561 return wrap(unwrap(B)->CreateNSWSub(unwrap(LHS), unwrap(RHS), Name)); 2562} 2563 2564LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2565 const char *Name) { 2566 return wrap(unwrap(B)->CreateNUWSub(unwrap(LHS), unwrap(RHS), Name)); 2567} 2568 2569LLVMValueRef LLVMBuildFSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2570 const char *Name) { 2571 return wrap(unwrap(B)->CreateFSub(unwrap(LHS), unwrap(RHS), Name)); 2572} 2573 2574LLVMValueRef LLVMBuildMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2575 const char *Name) { 2576 return wrap(unwrap(B)->CreateMul(unwrap(LHS), unwrap(RHS), Name)); 2577} 2578 2579LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2580 const char *Name) { 2581 return wrap(unwrap(B)->CreateNSWMul(unwrap(LHS), unwrap(RHS), Name)); 2582} 2583 2584LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2585 const char *Name) { 2586 return wrap(unwrap(B)->CreateNUWMul(unwrap(LHS), unwrap(RHS), Name)); 2587} 2588 2589LLVMValueRef LLVMBuildFMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2590 const char *Name) { 2591 return wrap(unwrap(B)->CreateFMul(unwrap(LHS), unwrap(RHS), Name)); 2592} 2593 2594LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2595 const char *Name) { 2596 return wrap(unwrap(B)->CreateUDiv(unwrap(LHS), unwrap(RHS), Name)); 2597} 2598 2599LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2600 const char *Name) { 2601 return wrap(unwrap(B)->CreateSDiv(unwrap(LHS), unwrap(RHS), Name)); 2602} 2603 2604LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef B, LLVMValueRef LHS, 2605 LLVMValueRef RHS, const char *Name) { 2606 return wrap(unwrap(B)->CreateExactSDiv(unwrap(LHS), unwrap(RHS), Name)); 2607} 2608 2609LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2610 const char *Name) { 2611 return wrap(unwrap(B)->CreateFDiv(unwrap(LHS), unwrap(RHS), Name)); 2612} 2613 2614LLVMValueRef LLVMBuildURem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2615 const char *Name) { 2616 return wrap(unwrap(B)->CreateURem(unwrap(LHS), unwrap(RHS), Name)); 2617} 2618 2619LLVMValueRef LLVMBuildSRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2620 const char *Name) { 2621 return wrap(unwrap(B)->CreateSRem(unwrap(LHS), unwrap(RHS), Name)); 2622} 2623 2624LLVMValueRef LLVMBuildFRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2625 const char *Name) { 2626 return wrap(unwrap(B)->CreateFRem(unwrap(LHS), unwrap(RHS), Name)); 2627} 2628 2629LLVMValueRef LLVMBuildShl(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2630 const char *Name) { 2631 return wrap(unwrap(B)->CreateShl(unwrap(LHS), unwrap(RHS), Name)); 2632} 2633 2634LLVMValueRef LLVMBuildLShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2635 const char *Name) { 2636 return wrap(unwrap(B)->CreateLShr(unwrap(LHS), unwrap(RHS), Name)); 2637} 2638 2639LLVMValueRef LLVMBuildAShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2640 const char *Name) { 2641 return wrap(unwrap(B)->CreateAShr(unwrap(LHS), unwrap(RHS), Name)); 2642} 2643 2644LLVMValueRef LLVMBuildAnd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2645 const char *Name) { 2646 return wrap(unwrap(B)->CreateAnd(unwrap(LHS), unwrap(RHS), Name)); 2647} 2648 2649LLVMValueRef LLVMBuildOr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2650 const char *Name) { 2651 return wrap(unwrap(B)->CreateOr(unwrap(LHS), unwrap(RHS), Name)); 2652} 2653 2654LLVMValueRef LLVMBuildXor(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2655 const char *Name) { 2656 return wrap(unwrap(B)->CreateXor(unwrap(LHS), unwrap(RHS), Name)); 2657} 2658 2659LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op, 2660 LLVMValueRef LHS, LLVMValueRef RHS, 2661 const char *Name) { 2662 return wrap(unwrap(B)->CreateBinOp(Instruction::BinaryOps(map_from_llvmopcode(Op)), unwrap(LHS), 2663 unwrap(RHS), Name)); 2664} 2665 2666LLVMValueRef LLVMBuildNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) { 2667 return wrap(unwrap(B)->CreateNeg(unwrap(V), Name)); 2668} 2669 2670LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V, 2671 const char *Name) { 2672 return wrap(unwrap(B)->CreateNSWNeg(unwrap(V), Name)); 2673} 2674 2675LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V, 2676 const char *Name) { 2677 return wrap(unwrap(B)->CreateNUWNeg(unwrap(V), Name)); 2678} 2679 2680LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) { 2681 return wrap(unwrap(B)->CreateFNeg(unwrap(V), Name)); 2682} 2683 2684LLVMValueRef LLVMBuildNot(LLVMBuilderRef B, LLVMValueRef V, const char *Name) { 2685 return wrap(unwrap(B)->CreateNot(unwrap(V), Name)); 2686} 2687 2688/*--.. Memory ..............................................................--*/ 2689 2690LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef B, LLVMTypeRef Ty, 2691 const char *Name) { 2692 Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext()); 2693 Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty)); 2694 AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy); 2695 Instruction* Malloc = CallInst::CreateMalloc(unwrap(B)->GetInsertBlock(), 2696 ITy, unwrap(Ty), AllocSize, 2697 nullptr, nullptr, ""); 2698 return wrap(unwrap(B)->Insert(Malloc, Twine(Name))); 2699} 2700 2701LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef B, LLVMTypeRef Ty, 2702 LLVMValueRef Val, const char *Name) { 2703 Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext()); 2704 Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty)); 2705 AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy); 2706 Instruction* Malloc = CallInst::CreateMalloc(unwrap(B)->GetInsertBlock(), 2707 ITy, unwrap(Ty), AllocSize, 2708 unwrap(Val), nullptr, ""); 2709 return wrap(unwrap(B)->Insert(Malloc, Twine(Name))); 2710} 2711 2712LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef B, LLVMTypeRef Ty, 2713 const char *Name) { 2714 return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), nullptr, Name)); 2715} 2716 2717LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef B, LLVMTypeRef Ty, 2718 LLVMValueRef Val, const char *Name) { 2719 return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), unwrap(Val), Name)); 2720} 2721 2722LLVMValueRef LLVMBuildFree(LLVMBuilderRef B, LLVMValueRef PointerVal) { 2723 return wrap(unwrap(B)->Insert( 2724 CallInst::CreateFree(unwrap(PointerVal), unwrap(B)->GetInsertBlock()))); 2725} 2726 2727LLVMValueRef LLVMBuildLoad(LLVMBuilderRef B, LLVMValueRef PointerVal, 2728 const char *Name) { 2729 return wrap(unwrap(B)->CreateLoad(unwrap(PointerVal), Name)); 2730} 2731 2732LLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val, 2733 LLVMValueRef PointerVal) { 2734 return wrap(unwrap(B)->CreateStore(unwrap(Val), unwrap(PointerVal))); 2735} 2736 2737static AtomicOrdering mapFromLLVMOrdering(LLVMAtomicOrdering Ordering) { 2738 switch (Ordering) { 2739 case LLVMAtomicOrderingNotAtomic: return AtomicOrdering::NotAtomic; 2740 case LLVMAtomicOrderingUnordered: return AtomicOrdering::Unordered; 2741 case LLVMAtomicOrderingMonotonic: return AtomicOrdering::Monotonic; 2742 case LLVMAtomicOrderingAcquire: return AtomicOrdering::Acquire; 2743 case LLVMAtomicOrderingRelease: return AtomicOrdering::Release; 2744 case LLVMAtomicOrderingAcquireRelease: 2745 return AtomicOrdering::AcquireRelease; 2746 case LLVMAtomicOrderingSequentiallyConsistent: 2747 return AtomicOrdering::SequentiallyConsistent; 2748 } 2749 2750 llvm_unreachable("Invalid LLVMAtomicOrdering value!"); 2751} 2752 2753static LLVMAtomicOrdering mapToLLVMOrdering(AtomicOrdering Ordering) { 2754 switch (Ordering) { 2755 case AtomicOrdering::NotAtomic: return LLVMAtomicOrderingNotAtomic; 2756 case AtomicOrdering::Unordered: return LLVMAtomicOrderingUnordered; 2757 case AtomicOrdering::Monotonic: return LLVMAtomicOrderingMonotonic; 2758 case AtomicOrdering::Acquire: return LLVMAtomicOrderingAcquire; 2759 case AtomicOrdering::Release: return LLVMAtomicOrderingRelease; 2760 case AtomicOrdering::AcquireRelease: 2761 return LLVMAtomicOrderingAcquireRelease; 2762 case AtomicOrdering::SequentiallyConsistent: 2763 return LLVMAtomicOrderingSequentiallyConsistent; 2764 } 2765 2766 llvm_unreachable("Invalid AtomicOrdering value!"); 2767} 2768 2769LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering Ordering, 2770 LLVMBool isSingleThread, const char *Name) { 2771 return wrap( 2772 unwrap(B)->CreateFence(mapFromLLVMOrdering(Ordering), 2773 isSingleThread ? SingleThread : CrossThread, 2774 Name)); 2775} 2776 2777LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 2778 LLVMValueRef *Indices, unsigned NumIndices, 2779 const char *Name) { 2780 ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices); 2781 return wrap(unwrap(B)->CreateGEP(nullptr, unwrap(Pointer), IdxList, Name)); 2782} 2783 2784LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 2785 LLVMValueRef *Indices, unsigned NumIndices, 2786 const char *Name) { 2787 ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices); 2788 return wrap( 2789 unwrap(B)->CreateInBoundsGEP(nullptr, unwrap(Pointer), IdxList, Name)); 2790} 2791 2792LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 2793 unsigned Idx, const char *Name) { 2794 return wrap(unwrap(B)->CreateStructGEP(nullptr, unwrap(Pointer), Idx, Name)); 2795} 2796 2797LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, 2798 const char *Name) { 2799 return wrap(unwrap(B)->CreateGlobalString(Str, Name)); 2800} 2801 2802LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, 2803 const char *Name) { 2804 return wrap(unwrap(B)->CreateGlobalStringPtr(Str, Name)); 2805} 2806 2807LLVMBool LLVMGetVolatile(LLVMValueRef MemAccessInst) { 2808 Value *P = unwrap<Value>(MemAccessInst); 2809 if (LoadInst *LI = dyn_cast<LoadInst>(P)) 2810 return LI->isVolatile(); 2811 return cast<StoreInst>(P)->isVolatile(); 2812} 2813 2814void LLVMSetVolatile(LLVMValueRef MemAccessInst, LLVMBool isVolatile) { 2815 Value *P = unwrap<Value>(MemAccessInst); 2816 if (LoadInst *LI = dyn_cast<LoadInst>(P)) 2817 return LI->setVolatile(isVolatile); 2818 return cast<StoreInst>(P)->setVolatile(isVolatile); 2819} 2820 2821LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemAccessInst) { 2822 Value *P = unwrap<Value>(MemAccessInst); 2823 AtomicOrdering O; 2824 if (LoadInst *LI = dyn_cast<LoadInst>(P)) 2825 O = LI->getOrdering(); 2826 else 2827 O = cast<StoreInst>(P)->getOrdering(); 2828 return mapToLLVMOrdering(O); 2829} 2830 2831void LLVMSetOrdering(LLVMValueRef MemAccessInst, LLVMAtomicOrdering Ordering) { 2832 Value *P = unwrap<Value>(MemAccessInst); 2833 AtomicOrdering O = mapFromLLVMOrdering(Ordering); 2834 2835 if (LoadInst *LI = dyn_cast<LoadInst>(P)) 2836 return LI->setOrdering(O); 2837 return cast<StoreInst>(P)->setOrdering(O); 2838} 2839 2840/*--.. Casts ...............................................................--*/ 2841 2842LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef B, LLVMValueRef Val, 2843 LLVMTypeRef DestTy, const char *Name) { 2844 return wrap(unwrap(B)->CreateTrunc(unwrap(Val), unwrap(DestTy), Name)); 2845} 2846 2847LLVMValueRef LLVMBuildZExt(LLVMBuilderRef B, LLVMValueRef Val, 2848 LLVMTypeRef DestTy, const char *Name) { 2849 return wrap(unwrap(B)->CreateZExt(unwrap(Val), unwrap(DestTy), Name)); 2850} 2851 2852LLVMValueRef LLVMBuildSExt(LLVMBuilderRef B, LLVMValueRef Val, 2853 LLVMTypeRef DestTy, const char *Name) { 2854 return wrap(unwrap(B)->CreateSExt(unwrap(Val), unwrap(DestTy), Name)); 2855} 2856 2857LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef B, LLVMValueRef Val, 2858 LLVMTypeRef DestTy, const char *Name) { 2859 return wrap(unwrap(B)->CreateFPToUI(unwrap(Val), unwrap(DestTy), Name)); 2860} 2861 2862LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef B, LLVMValueRef Val, 2863 LLVMTypeRef DestTy, const char *Name) { 2864 return wrap(unwrap(B)->CreateFPToSI(unwrap(Val), unwrap(DestTy), Name)); 2865} 2866 2867LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef B, LLVMValueRef Val, 2868 LLVMTypeRef DestTy, const char *Name) { 2869 return wrap(unwrap(B)->CreateUIToFP(unwrap(Val), unwrap(DestTy), Name)); 2870} 2871 2872LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef B, LLVMValueRef Val, 2873 LLVMTypeRef DestTy, const char *Name) { 2874 return wrap(unwrap(B)->CreateSIToFP(unwrap(Val), unwrap(DestTy), Name)); 2875} 2876 2877LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef B, LLVMValueRef Val, 2878 LLVMTypeRef DestTy, const char *Name) { 2879 return wrap(unwrap(B)->CreateFPTrunc(unwrap(Val), unwrap(DestTy), Name)); 2880} 2881 2882LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef B, LLVMValueRef Val, 2883 LLVMTypeRef DestTy, const char *Name) { 2884 return wrap(unwrap(B)->CreateFPExt(unwrap(Val), unwrap(DestTy), Name)); 2885} 2886 2887LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef B, LLVMValueRef Val, 2888 LLVMTypeRef DestTy, const char *Name) { 2889 return wrap(unwrap(B)->CreatePtrToInt(unwrap(Val), unwrap(DestTy), Name)); 2890} 2891 2892LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef B, LLVMValueRef Val, 2893 LLVMTypeRef DestTy, const char *Name) { 2894 return wrap(unwrap(B)->CreateIntToPtr(unwrap(Val), unwrap(DestTy), Name)); 2895} 2896 2897LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef B, LLVMValueRef Val, 2898 LLVMTypeRef DestTy, const char *Name) { 2899 return wrap(unwrap(B)->CreateBitCast(unwrap(Val), unwrap(DestTy), Name)); 2900} 2901 2902LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef B, LLVMValueRef Val, 2903 LLVMTypeRef DestTy, const char *Name) { 2904 return wrap(unwrap(B)->CreateAddrSpaceCast(unwrap(Val), unwrap(DestTy), Name)); 2905} 2906 2907LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val, 2908 LLVMTypeRef DestTy, const char *Name) { 2909 return wrap(unwrap(B)->CreateZExtOrBitCast(unwrap(Val), unwrap(DestTy), 2910 Name)); 2911} 2912 2913LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val, 2914 LLVMTypeRef DestTy, const char *Name) { 2915 return wrap(unwrap(B)->CreateSExtOrBitCast(unwrap(Val), unwrap(DestTy), 2916 Name)); 2917} 2918 2919LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef B, LLVMValueRef Val, 2920 LLVMTypeRef DestTy, const char *Name) { 2921 return wrap(unwrap(B)->CreateTruncOrBitCast(unwrap(Val), unwrap(DestTy), 2922 Name)); 2923} 2924 2925LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val, 2926 LLVMTypeRef DestTy, const char *Name) { 2927 return wrap(unwrap(B)->CreateCast(Instruction::CastOps(map_from_llvmopcode(Op)), unwrap(Val), 2928 unwrap(DestTy), Name)); 2929} 2930 2931LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef B, LLVMValueRef Val, 2932 LLVMTypeRef DestTy, const char *Name) { 2933 return wrap(unwrap(B)->CreatePointerCast(unwrap(Val), unwrap(DestTy), Name)); 2934} 2935 2936LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef B, LLVMValueRef Val, 2937 LLVMTypeRef DestTy, const char *Name) { 2938 return wrap(unwrap(B)->CreateIntCast(unwrap(Val), unwrap(DestTy), 2939 /*isSigned*/true, Name)); 2940} 2941 2942LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef B, LLVMValueRef Val, 2943 LLVMTypeRef DestTy, const char *Name) { 2944 return wrap(unwrap(B)->CreateFPCast(unwrap(Val), unwrap(DestTy), Name)); 2945} 2946 2947/*--.. Comparisons .........................................................--*/ 2948 2949LLVMValueRef LLVMBuildICmp(LLVMBuilderRef B, LLVMIntPredicate Op, 2950 LLVMValueRef LHS, LLVMValueRef RHS, 2951 const char *Name) { 2952 return wrap(unwrap(B)->CreateICmp(static_cast<ICmpInst::Predicate>(Op), 2953 unwrap(LHS), unwrap(RHS), Name)); 2954} 2955 2956LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef B, LLVMRealPredicate Op, 2957 LLVMValueRef LHS, LLVMValueRef RHS, 2958 const char *Name) { 2959 return wrap(unwrap(B)->CreateFCmp(static_cast<FCmpInst::Predicate>(Op), 2960 unwrap(LHS), unwrap(RHS), Name)); 2961} 2962 2963/*--.. Miscellaneous instructions ..........................................--*/ 2964 2965LLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name) { 2966 return wrap(unwrap(B)->CreatePHI(unwrap(Ty), 0, Name)); 2967} 2968 2969LLVMValueRef LLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, 2970 LLVMValueRef *Args, unsigned NumArgs, 2971 const char *Name) { 2972 return wrap(unwrap(B)->CreateCall(unwrap(Fn), 2973 makeArrayRef(unwrap(Args), NumArgs), 2974 Name)); 2975} 2976 2977LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If, 2978 LLVMValueRef Then, LLVMValueRef Else, 2979 const char *Name) { 2980 return wrap(unwrap(B)->CreateSelect(unwrap(If), unwrap(Then), unwrap(Else), 2981 Name)); 2982} 2983 2984LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef B, LLVMValueRef List, 2985 LLVMTypeRef Ty, const char *Name) { 2986 return wrap(unwrap(B)->CreateVAArg(unwrap(List), unwrap(Ty), Name)); 2987} 2988 2989LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef B, LLVMValueRef VecVal, 2990 LLVMValueRef Index, const char *Name) { 2991 return wrap(unwrap(B)->CreateExtractElement(unwrap(VecVal), unwrap(Index), 2992 Name)); 2993} 2994 2995LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef B, LLVMValueRef VecVal, 2996 LLVMValueRef EltVal, LLVMValueRef Index, 2997 const char *Name) { 2998 return wrap(unwrap(B)->CreateInsertElement(unwrap(VecVal), unwrap(EltVal), 2999 unwrap(Index), Name)); 3000} 3001 3002LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef B, LLVMValueRef V1, 3003 LLVMValueRef V2, LLVMValueRef Mask, 3004 const char *Name) { 3005 return wrap(unwrap(B)->CreateShuffleVector(unwrap(V1), unwrap(V2), 3006 unwrap(Mask), Name)); 3007} 3008 3009LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef B, LLVMValueRef AggVal, 3010 unsigned Index, const char *Name) { 3011 return wrap(unwrap(B)->CreateExtractValue(unwrap(AggVal), Index, Name)); 3012} 3013 3014LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef B, LLVMValueRef AggVal, 3015 LLVMValueRef EltVal, unsigned Index, 3016 const char *Name) { 3017 return wrap(unwrap(B)->CreateInsertValue(unwrap(AggVal), unwrap(EltVal), 3018 Index, Name)); 3019} 3020 3021LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef B, LLVMValueRef Val, 3022 const char *Name) { 3023 return wrap(unwrap(B)->CreateIsNull(unwrap(Val), Name)); 3024} 3025 3026LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef B, LLVMValueRef Val, 3027 const char *Name) { 3028 return wrap(unwrap(B)->CreateIsNotNull(unwrap(Val), Name)); 3029} 3030 3031LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef B, LLVMValueRef LHS, 3032 LLVMValueRef RHS, const char *Name) { 3033 return wrap(unwrap(B)->CreatePtrDiff(unwrap(LHS), unwrap(RHS), Name)); 3034} 3035 3036LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B,LLVMAtomicRMWBinOp op, 3037 LLVMValueRef PTR, LLVMValueRef Val, 3038 LLVMAtomicOrdering ordering, 3039 LLVMBool singleThread) { 3040 AtomicRMWInst::BinOp intop; 3041 switch (op) { 3042 case LLVMAtomicRMWBinOpXchg: intop = AtomicRMWInst::Xchg; break; 3043 case LLVMAtomicRMWBinOpAdd: intop = AtomicRMWInst::Add; break; 3044 case LLVMAtomicRMWBinOpSub: intop = AtomicRMWInst::Sub; break; 3045 case LLVMAtomicRMWBinOpAnd: intop = AtomicRMWInst::And; break; 3046 case LLVMAtomicRMWBinOpNand: intop = AtomicRMWInst::Nand; break; 3047 case LLVMAtomicRMWBinOpOr: intop = AtomicRMWInst::Or; break; 3048 case LLVMAtomicRMWBinOpXor: intop = AtomicRMWInst::Xor; break; 3049 case LLVMAtomicRMWBinOpMax: intop = AtomicRMWInst::Max; break; 3050 case LLVMAtomicRMWBinOpMin: intop = AtomicRMWInst::Min; break; 3051 case LLVMAtomicRMWBinOpUMax: intop = AtomicRMWInst::UMax; break; 3052 case LLVMAtomicRMWBinOpUMin: intop = AtomicRMWInst::UMin; break; 3053 } 3054 return wrap(unwrap(B)->CreateAtomicRMW(intop, unwrap(PTR), unwrap(Val), 3055 mapFromLLVMOrdering(ordering), singleThread ? SingleThread : CrossThread)); 3056} 3057 3058LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr, 3059 LLVMValueRef Cmp, LLVMValueRef New, 3060 LLVMAtomicOrdering SuccessOrdering, 3061 LLVMAtomicOrdering FailureOrdering, 3062 LLVMBool singleThread) { 3063 3064 return wrap(unwrap(B)->CreateAtomicCmpXchg(unwrap(Ptr), unwrap(Cmp), 3065 unwrap(New), mapFromLLVMOrdering(SuccessOrdering), 3066 mapFromLLVMOrdering(FailureOrdering), 3067 singleThread ? SingleThread : CrossThread)); 3068} 3069 3070 3071LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst) { 3072 Value *P = unwrap<Value>(AtomicInst); 3073 3074 if (AtomicRMWInst *I = dyn_cast<AtomicRMWInst>(P)) 3075 return I->getSynchScope() == SingleThread; 3076 return cast<AtomicCmpXchgInst>(P)->getSynchScope() == SingleThread; 3077} 3078 3079void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool NewValue) { 3080 Value *P = unwrap<Value>(AtomicInst); 3081 SynchronizationScope Sync = NewValue ? SingleThread : CrossThread; 3082 3083 if (AtomicRMWInst *I = dyn_cast<AtomicRMWInst>(P)) 3084 return I->setSynchScope(Sync); 3085 return cast<AtomicCmpXchgInst>(P)->setSynchScope(Sync); 3086} 3087 3088LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst) { 3089 Value *P = unwrap<Value>(CmpXchgInst); 3090 return mapToLLVMOrdering(cast<AtomicCmpXchgInst>(P)->getSuccessOrdering()); 3091} 3092 3093void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst, 3094 LLVMAtomicOrdering Ordering) { 3095 Value *P = unwrap<Value>(CmpXchgInst); 3096 AtomicOrdering O = mapFromLLVMOrdering(Ordering); 3097 3098 return cast<AtomicCmpXchgInst>(P)->setSuccessOrdering(O); 3099} 3100 3101LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst) { 3102 Value *P = unwrap<Value>(CmpXchgInst); 3103 return mapToLLVMOrdering(cast<AtomicCmpXchgInst>(P)->getFailureOrdering()); 3104} 3105 3106void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst, 3107 LLVMAtomicOrdering Ordering) { 3108 Value *P = unwrap<Value>(CmpXchgInst); 3109 AtomicOrdering O = mapFromLLVMOrdering(Ordering); 3110 3111 return cast<AtomicCmpXchgInst>(P)->setFailureOrdering(O); 3112} 3113 3114/*===-- Module providers --------------------------------------------------===*/ 3115 3116LLVMModuleProviderRef 3117LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M) { 3118 return reinterpret_cast<LLVMModuleProviderRef>(M); 3119} 3120 3121void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP) { 3122 delete unwrap(MP); 3123} 3124 3125 3126/*===-- Memory buffers ----------------------------------------------------===*/ 3127 3128LLVMBool LLVMCreateMemoryBufferWithContentsOfFile( 3129 const char *Path, 3130 LLVMMemoryBufferRef *OutMemBuf, 3131 char **OutMessage) { 3132 3133 ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(Path); 3134 if (std::error_code EC = MBOrErr.getError()) { 3135 *OutMessage = strdup(EC.message().c_str()); 3136 return 1; 3137 } 3138 *OutMemBuf = wrap(MBOrErr.get().release()); 3139 return 0; 3140} 3141 3142LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, 3143 char **OutMessage) { 3144 ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getSTDIN(); 3145 if (std::error_code EC = MBOrErr.getError()) { 3146 *OutMessage = strdup(EC.message().c_str()); 3147 return 1; 3148 } 3149 *OutMemBuf = wrap(MBOrErr.get().release()); 3150 return 0; 3151} 3152 3153LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange( 3154 const char *InputData, 3155 size_t InputDataLength, 3156 const char *BufferName, 3157 LLVMBool RequiresNullTerminator) { 3158 3159 return wrap(MemoryBuffer::getMemBuffer(StringRef(InputData, InputDataLength), 3160 StringRef(BufferName), 3161 RequiresNullTerminator).release()); 3162} 3163 3164LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy( 3165 const char *InputData, 3166 size_t InputDataLength, 3167 const char *BufferName) { 3168 3169 return wrap( 3170 MemoryBuffer::getMemBufferCopy(StringRef(InputData, InputDataLength), 3171 StringRef(BufferName)).release()); 3172} 3173 3174const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf) { 3175 return unwrap(MemBuf)->getBufferStart(); 3176} 3177 3178size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf) { 3179 return unwrap(MemBuf)->getBufferSize(); 3180} 3181 3182void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf) { 3183 delete unwrap(MemBuf); 3184} 3185 3186/*===-- Pass Registry -----------------------------------------------------===*/ 3187 3188LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void) { 3189 return wrap(PassRegistry::getPassRegistry()); 3190} 3191 3192/*===-- Pass Manager ------------------------------------------------------===*/ 3193 3194LLVMPassManagerRef LLVMCreatePassManager() { 3195 return wrap(new legacy::PassManager()); 3196} 3197 3198LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M) { 3199 return wrap(new legacy::FunctionPassManager(unwrap(M))); 3200} 3201 3202LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef P) { 3203 return LLVMCreateFunctionPassManagerForModule( 3204 reinterpret_cast<LLVMModuleRef>(P)); 3205} 3206 3207LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M) { 3208 return unwrap<legacy::PassManager>(PM)->run(*unwrap(M)); 3209} 3210 3211LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM) { 3212 return unwrap<legacy::FunctionPassManager>(FPM)->doInitialization(); 3213} 3214 3215LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F) { 3216 return unwrap<legacy::FunctionPassManager>(FPM)->run(*unwrap<Function>(F)); 3217} 3218 3219LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM) { 3220 return unwrap<legacy::FunctionPassManager>(FPM)->doFinalization(); 3221} 3222 3223void LLVMDisposePassManager(LLVMPassManagerRef PM) { 3224 delete unwrap(PM); 3225} 3226 3227/*===-- Threading ------------------------------------------------------===*/ 3228 3229LLVMBool LLVMStartMultithreaded() { 3230 return LLVMIsMultithreaded(); 3231} 3232 3233void LLVMStopMultithreaded() { 3234} 3235 3236LLVMBool LLVMIsMultithreaded() { 3237 return llvm_is_multithreaded(); 3238} 3239