1249259Sdim//===-- Core.cpp ----------------------------------------------------------===// 2249259Sdim// 3249259Sdim// The LLVM Compiler Infrastructure 4249259Sdim// 5249259Sdim// This file is distributed under the University of Illinois Open Source 6249259Sdim// License. See LICENSE.TXT for details. 7249259Sdim// 8249259Sdim//===----------------------------------------------------------------------===// 9249259Sdim// 10249259Sdim// This file implements the common infrastructure (including the C bindings) 11249259Sdim// for libLLVMCore.a, which implements the LLVM intermediate representation. 12249259Sdim// 13249259Sdim//===----------------------------------------------------------------------===// 14249259Sdim 15249259Sdim#include "llvm-c/Core.h" 16249259Sdim#include "llvm/Bitcode/ReaderWriter.h" 17249259Sdim#include "llvm/IR/Attributes.h" 18249259Sdim#include "llvm/IR/Constants.h" 19249259Sdim#include "llvm/IR/DerivedTypes.h" 20249259Sdim#include "llvm/IR/GlobalAlias.h" 21249259Sdim#include "llvm/IR/GlobalVariable.h" 22249259Sdim#include "llvm/IR/InlineAsm.h" 23249259Sdim#include "llvm/IR/IntrinsicInst.h" 24252723Sdim#include "llvm/IR/IRBuilder.h" 25249259Sdim#include "llvm/IR/LLVMContext.h" 26252723Sdim#include "llvm/IR/Module.h" 27249259Sdim#include "llvm/PassManager.h" 28249259Sdim#include "llvm/Support/CallSite.h" 29249259Sdim#include "llvm/Support/Debug.h" 30249259Sdim#include "llvm/Support/ErrorHandling.h" 31249259Sdim#include "llvm/Support/ManagedStatic.h" 32249259Sdim#include "llvm/Support/MemoryBuffer.h" 33249259Sdim#include "llvm/Support/raw_ostream.h" 34249259Sdim#include "llvm/Support/system_error.h" 35249259Sdim#include "llvm/Support/Threading.h" 36249259Sdim#include <cassert> 37249259Sdim#include <cstdlib> 38249259Sdim#include <cstring> 39249259Sdim 40249259Sdimusing namespace llvm; 41249259Sdim 42249259Sdimvoid llvm::initializeCore(PassRegistry &Registry) { 43249259Sdim initializeDominatorTreePass(Registry); 44249259Sdim initializePrintModulePassPass(Registry); 45249259Sdim initializePrintFunctionPassPass(Registry); 46249259Sdim initializePrintBasicBlockPassPass(Registry); 47249259Sdim initializeVerifierPass(Registry); 48249259Sdim initializePreVerifierPass(Registry); 49249259Sdim} 50249259Sdim 51249259Sdimvoid LLVMInitializeCore(LLVMPassRegistryRef R) { 52249259Sdim initializeCore(*unwrap(R)); 53249259Sdim} 54249259Sdim 55249259Sdimvoid LLVMShutdown() { 56249259Sdim llvm_shutdown(); 57249259Sdim} 58249259Sdim 59249259Sdim/*===-- Error handling ----------------------------------------------------===*/ 60249259Sdim 61263509Sdimchar *LLVMCreateMessage(const char *Message) { 62263509Sdim return strdup(Message); 63263509Sdim} 64263509Sdim 65249259Sdimvoid LLVMDisposeMessage(char *Message) { 66249259Sdim free(Message); 67249259Sdim} 68249259Sdim 69249259Sdim 70249259Sdim/*===-- Operations on contexts --------------------------------------------===*/ 71249259Sdim 72249259SdimLLVMContextRef LLVMContextCreate() { 73249259Sdim return wrap(new LLVMContext()); 74249259Sdim} 75249259Sdim 76249259SdimLLVMContextRef LLVMGetGlobalContext() { 77249259Sdim return wrap(&getGlobalContext()); 78249259Sdim} 79249259Sdim 80249259Sdimvoid LLVMContextDispose(LLVMContextRef C) { 81249259Sdim delete unwrap(C); 82249259Sdim} 83249259Sdim 84249259Sdimunsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char* Name, 85249259Sdim unsigned SLen) { 86249259Sdim return unwrap(C)->getMDKindID(StringRef(Name, SLen)); 87249259Sdim} 88249259Sdim 89249259Sdimunsigned LLVMGetMDKindID(const char* Name, unsigned SLen) { 90249259Sdim return LLVMGetMDKindIDInContext(LLVMGetGlobalContext(), Name, SLen); 91249259Sdim} 92249259Sdim 93249259Sdim 94249259Sdim/*===-- Operations on modules ---------------------------------------------===*/ 95249259Sdim 96249259SdimLLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID) { 97249259Sdim return wrap(new Module(ModuleID, getGlobalContext())); 98249259Sdim} 99249259Sdim 100263509SdimLLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID, 101249259Sdim LLVMContextRef C) { 102249259Sdim return wrap(new Module(ModuleID, *unwrap(C))); 103249259Sdim} 104249259Sdim 105249259Sdimvoid LLVMDisposeModule(LLVMModuleRef M) { 106249259Sdim delete unwrap(M); 107249259Sdim} 108249259Sdim 109249259Sdim/*--.. Data layout .........................................................--*/ 110249259Sdimconst char * LLVMGetDataLayout(LLVMModuleRef M) { 111249259Sdim return unwrap(M)->getDataLayout().c_str(); 112249259Sdim} 113249259Sdim 114249259Sdimvoid LLVMSetDataLayout(LLVMModuleRef M, const char *Triple) { 115249259Sdim unwrap(M)->setDataLayout(Triple); 116249259Sdim} 117249259Sdim 118249259Sdim/*--.. Target triple .......................................................--*/ 119249259Sdimconst char * LLVMGetTarget(LLVMModuleRef M) { 120249259Sdim return unwrap(M)->getTargetTriple().c_str(); 121249259Sdim} 122249259Sdim 123249259Sdimvoid LLVMSetTarget(LLVMModuleRef M, const char *Triple) { 124249259Sdim unwrap(M)->setTargetTriple(Triple); 125249259Sdim} 126249259Sdim 127249259Sdimvoid LLVMDumpModule(LLVMModuleRef M) { 128249259Sdim unwrap(M)->dump(); 129249259Sdim} 130249259Sdim 131249259SdimLLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename, 132249259Sdim char **ErrorMessage) { 133249259Sdim std::string error; 134249259Sdim raw_fd_ostream dest(Filename, error); 135249259Sdim if (!error.empty()) { 136249259Sdim *ErrorMessage = strdup(error.c_str()); 137249259Sdim return true; 138249259Sdim } 139249259Sdim 140249259Sdim unwrap(M)->print(dest, NULL); 141249259Sdim 142249259Sdim if (!error.empty()) { 143249259Sdim *ErrorMessage = strdup(error.c_str()); 144249259Sdim return true; 145249259Sdim } 146249259Sdim dest.flush(); 147249259Sdim return false; 148249259Sdim} 149249259Sdim 150263509Sdimchar *LLVMPrintModuleToString(LLVMModuleRef M) { 151263509Sdim std::string buf; 152263509Sdim raw_string_ostream os(buf); 153263509Sdim 154263509Sdim unwrap(M)->print(os, NULL); 155263509Sdim os.flush(); 156263509Sdim 157263509Sdim return strdup(buf.c_str()); 158263509Sdim} 159263509Sdim 160249259Sdim/*--.. Operations on inline assembler ......................................--*/ 161249259Sdimvoid LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm) { 162249259Sdim unwrap(M)->setModuleInlineAsm(StringRef(Asm)); 163249259Sdim} 164249259Sdim 165249259Sdim 166249259Sdim/*--.. Operations on module contexts ......................................--*/ 167249259SdimLLVMContextRef LLVMGetModuleContext(LLVMModuleRef M) { 168249259Sdim return wrap(&unwrap(M)->getContext()); 169249259Sdim} 170249259Sdim 171249259Sdim 172249259Sdim/*===-- Operations on types -----------------------------------------------===*/ 173249259Sdim 174249259Sdim/*--.. Operations on all types (mostly) ....................................--*/ 175249259Sdim 176249259SdimLLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) { 177249259Sdim switch (unwrap(Ty)->getTypeID()) { 178249259Sdim default: llvm_unreachable("Unhandled TypeID."); 179249259Sdim case Type::VoidTyID: 180249259Sdim return LLVMVoidTypeKind; 181249259Sdim case Type::HalfTyID: 182249259Sdim return LLVMHalfTypeKind; 183249259Sdim case Type::FloatTyID: 184249259Sdim return LLVMFloatTypeKind; 185249259Sdim case Type::DoubleTyID: 186249259Sdim return LLVMDoubleTypeKind; 187249259Sdim case Type::X86_FP80TyID: 188249259Sdim return LLVMX86_FP80TypeKind; 189249259Sdim case Type::FP128TyID: 190249259Sdim return LLVMFP128TypeKind; 191249259Sdim case Type::PPC_FP128TyID: 192249259Sdim return LLVMPPC_FP128TypeKind; 193249259Sdim case Type::LabelTyID: 194249259Sdim return LLVMLabelTypeKind; 195249259Sdim case Type::MetadataTyID: 196249259Sdim return LLVMMetadataTypeKind; 197249259Sdim case Type::IntegerTyID: 198249259Sdim return LLVMIntegerTypeKind; 199249259Sdim case Type::FunctionTyID: 200249259Sdim return LLVMFunctionTypeKind; 201249259Sdim case Type::StructTyID: 202249259Sdim return LLVMStructTypeKind; 203249259Sdim case Type::ArrayTyID: 204249259Sdim return LLVMArrayTypeKind; 205249259Sdim case Type::PointerTyID: 206249259Sdim return LLVMPointerTypeKind; 207249259Sdim case Type::VectorTyID: 208249259Sdim return LLVMVectorTypeKind; 209249259Sdim case Type::X86_MMXTyID: 210249259Sdim return LLVMX86_MMXTypeKind; 211249259Sdim } 212249259Sdim} 213249259Sdim 214249259SdimLLVMBool LLVMTypeIsSized(LLVMTypeRef Ty) 215249259Sdim{ 216249259Sdim return unwrap(Ty)->isSized(); 217249259Sdim} 218249259Sdim 219249259SdimLLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty) { 220249259Sdim return wrap(&unwrap(Ty)->getContext()); 221249259Sdim} 222249259Sdim 223263509Sdimvoid LLVMDumpType(LLVMTypeRef Ty) { 224263509Sdim return unwrap(Ty)->dump(); 225263509Sdim} 226263509Sdim 227263509Sdimchar *LLVMPrintTypeToString(LLVMTypeRef Ty) { 228263509Sdim std::string buf; 229263509Sdim raw_string_ostream os(buf); 230263509Sdim 231263509Sdim unwrap(Ty)->print(os); 232263509Sdim os.flush(); 233263509Sdim 234263509Sdim return strdup(buf.c_str()); 235263509Sdim} 236263509Sdim 237249259Sdim/*--.. Operations on integer types .........................................--*/ 238249259Sdim 239249259SdimLLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C) { 240249259Sdim return (LLVMTypeRef) Type::getInt1Ty(*unwrap(C)); 241249259Sdim} 242249259SdimLLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C) { 243249259Sdim return (LLVMTypeRef) Type::getInt8Ty(*unwrap(C)); 244249259Sdim} 245249259SdimLLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C) { 246249259Sdim return (LLVMTypeRef) Type::getInt16Ty(*unwrap(C)); 247249259Sdim} 248249259SdimLLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C) { 249249259Sdim return (LLVMTypeRef) Type::getInt32Ty(*unwrap(C)); 250249259Sdim} 251249259SdimLLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C) { 252249259Sdim return (LLVMTypeRef) Type::getInt64Ty(*unwrap(C)); 253249259Sdim} 254249259SdimLLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits) { 255249259Sdim return wrap(IntegerType::get(*unwrap(C), NumBits)); 256249259Sdim} 257249259Sdim 258249259SdimLLVMTypeRef LLVMInt1Type(void) { 259249259Sdim return LLVMInt1TypeInContext(LLVMGetGlobalContext()); 260249259Sdim} 261249259SdimLLVMTypeRef LLVMInt8Type(void) { 262249259Sdim return LLVMInt8TypeInContext(LLVMGetGlobalContext()); 263249259Sdim} 264249259SdimLLVMTypeRef LLVMInt16Type(void) { 265249259Sdim return LLVMInt16TypeInContext(LLVMGetGlobalContext()); 266249259Sdim} 267249259SdimLLVMTypeRef LLVMInt32Type(void) { 268249259Sdim return LLVMInt32TypeInContext(LLVMGetGlobalContext()); 269249259Sdim} 270249259SdimLLVMTypeRef LLVMInt64Type(void) { 271249259Sdim return LLVMInt64TypeInContext(LLVMGetGlobalContext()); 272249259Sdim} 273249259SdimLLVMTypeRef LLVMIntType(unsigned NumBits) { 274249259Sdim return LLVMIntTypeInContext(LLVMGetGlobalContext(), NumBits); 275249259Sdim} 276249259Sdim 277249259Sdimunsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy) { 278249259Sdim return unwrap<IntegerType>(IntegerTy)->getBitWidth(); 279249259Sdim} 280249259Sdim 281249259Sdim/*--.. Operations on real types ............................................--*/ 282249259Sdim 283249259SdimLLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C) { 284249259Sdim return (LLVMTypeRef) Type::getHalfTy(*unwrap(C)); 285249259Sdim} 286249259SdimLLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C) { 287249259Sdim return (LLVMTypeRef) Type::getFloatTy(*unwrap(C)); 288249259Sdim} 289249259SdimLLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C) { 290249259Sdim return (LLVMTypeRef) Type::getDoubleTy(*unwrap(C)); 291249259Sdim} 292249259SdimLLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C) { 293249259Sdim return (LLVMTypeRef) Type::getX86_FP80Ty(*unwrap(C)); 294249259Sdim} 295249259SdimLLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C) { 296249259Sdim return (LLVMTypeRef) Type::getFP128Ty(*unwrap(C)); 297249259Sdim} 298249259SdimLLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C) { 299249259Sdim return (LLVMTypeRef) Type::getPPC_FP128Ty(*unwrap(C)); 300249259Sdim} 301249259SdimLLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C) { 302249259Sdim return (LLVMTypeRef) Type::getX86_MMXTy(*unwrap(C)); 303249259Sdim} 304249259Sdim 305249259SdimLLVMTypeRef LLVMHalfType(void) { 306249259Sdim return LLVMHalfTypeInContext(LLVMGetGlobalContext()); 307249259Sdim} 308249259SdimLLVMTypeRef LLVMFloatType(void) { 309249259Sdim return LLVMFloatTypeInContext(LLVMGetGlobalContext()); 310249259Sdim} 311249259SdimLLVMTypeRef LLVMDoubleType(void) { 312249259Sdim return LLVMDoubleTypeInContext(LLVMGetGlobalContext()); 313249259Sdim} 314249259SdimLLVMTypeRef LLVMX86FP80Type(void) { 315249259Sdim return LLVMX86FP80TypeInContext(LLVMGetGlobalContext()); 316249259Sdim} 317249259SdimLLVMTypeRef LLVMFP128Type(void) { 318249259Sdim return LLVMFP128TypeInContext(LLVMGetGlobalContext()); 319249259Sdim} 320249259SdimLLVMTypeRef LLVMPPCFP128Type(void) { 321249259Sdim return LLVMPPCFP128TypeInContext(LLVMGetGlobalContext()); 322249259Sdim} 323249259SdimLLVMTypeRef LLVMX86MMXType(void) { 324249259Sdim return LLVMX86MMXTypeInContext(LLVMGetGlobalContext()); 325249259Sdim} 326249259Sdim 327249259Sdim/*--.. Operations on function types ........................................--*/ 328249259Sdim 329249259SdimLLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, 330249259Sdim LLVMTypeRef *ParamTypes, unsigned ParamCount, 331249259Sdim LLVMBool IsVarArg) { 332249259Sdim ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount); 333249259Sdim return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0)); 334249259Sdim} 335249259Sdim 336249259SdimLLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) { 337249259Sdim return unwrap<FunctionType>(FunctionTy)->isVarArg(); 338249259Sdim} 339249259Sdim 340249259SdimLLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy) { 341249259Sdim return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType()); 342249259Sdim} 343249259Sdim 344249259Sdimunsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy) { 345249259Sdim return unwrap<FunctionType>(FunctionTy)->getNumParams(); 346249259Sdim} 347249259Sdim 348249259Sdimvoid LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest) { 349249259Sdim FunctionType *Ty = unwrap<FunctionType>(FunctionTy); 350249259Sdim for (FunctionType::param_iterator I = Ty->param_begin(), 351249259Sdim E = Ty->param_end(); I != E; ++I) 352249259Sdim *Dest++ = wrap(*I); 353249259Sdim} 354249259Sdim 355249259Sdim/*--.. Operations on struct types ..........................................--*/ 356249259Sdim 357249259SdimLLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, 358249259Sdim unsigned ElementCount, LLVMBool Packed) { 359249259Sdim ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount); 360249259Sdim return wrap(StructType::get(*unwrap(C), Tys, Packed != 0)); 361249259Sdim} 362249259Sdim 363249259SdimLLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, 364249259Sdim unsigned ElementCount, LLVMBool Packed) { 365249259Sdim return LLVMStructTypeInContext(LLVMGetGlobalContext(), ElementTypes, 366249259Sdim ElementCount, Packed); 367249259Sdim} 368249259Sdim 369249259SdimLLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name) 370249259Sdim{ 371249259Sdim return wrap(StructType::create(*unwrap(C), Name)); 372249259Sdim} 373249259Sdim 374249259Sdimconst char *LLVMGetStructName(LLVMTypeRef Ty) 375249259Sdim{ 376249259Sdim StructType *Type = unwrap<StructType>(Ty); 377249259Sdim if (!Type->hasName()) 378249259Sdim return 0; 379249259Sdim return Type->getName().data(); 380249259Sdim} 381249259Sdim 382249259Sdimvoid LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes, 383249259Sdim unsigned ElementCount, LLVMBool Packed) { 384249259Sdim ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount); 385249259Sdim unwrap<StructType>(StructTy)->setBody(Tys, Packed != 0); 386249259Sdim} 387249259Sdim 388249259Sdimunsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy) { 389249259Sdim return unwrap<StructType>(StructTy)->getNumElements(); 390249259Sdim} 391249259Sdim 392249259Sdimvoid LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest) { 393249259Sdim StructType *Ty = unwrap<StructType>(StructTy); 394249259Sdim for (StructType::element_iterator I = Ty->element_begin(), 395249259Sdim E = Ty->element_end(); I != E; ++I) 396249259Sdim *Dest++ = wrap(*I); 397249259Sdim} 398249259Sdim 399249259SdimLLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy) { 400249259Sdim return unwrap<StructType>(StructTy)->isPacked(); 401249259Sdim} 402249259Sdim 403249259SdimLLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy) { 404249259Sdim return unwrap<StructType>(StructTy)->isOpaque(); 405249259Sdim} 406249259Sdim 407249259SdimLLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name) { 408249259Sdim return wrap(unwrap(M)->getTypeByName(Name)); 409249259Sdim} 410249259Sdim 411249259Sdim/*--.. Operations on array, pointer, and vector types (sequence types) .....--*/ 412249259Sdim 413249259SdimLLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount) { 414249259Sdim return wrap(ArrayType::get(unwrap(ElementType), ElementCount)); 415249259Sdim} 416249259Sdim 417249259SdimLLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace) { 418249259Sdim return wrap(PointerType::get(unwrap(ElementType), AddressSpace)); 419249259Sdim} 420249259Sdim 421249259SdimLLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) { 422249259Sdim return wrap(VectorType::get(unwrap(ElementType), ElementCount)); 423249259Sdim} 424249259Sdim 425249259SdimLLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty) { 426249259Sdim return wrap(unwrap<SequentialType>(Ty)->getElementType()); 427249259Sdim} 428249259Sdim 429249259Sdimunsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) { 430249259Sdim return unwrap<ArrayType>(ArrayTy)->getNumElements(); 431249259Sdim} 432249259Sdim 433249259Sdimunsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy) { 434249259Sdim return unwrap<PointerType>(PointerTy)->getAddressSpace(); 435249259Sdim} 436249259Sdim 437249259Sdimunsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) { 438249259Sdim return unwrap<VectorType>(VectorTy)->getNumElements(); 439249259Sdim} 440249259Sdim 441249259Sdim/*--.. Operations on other types ...........................................--*/ 442249259Sdim 443249259SdimLLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C) { 444249259Sdim return wrap(Type::getVoidTy(*unwrap(C))); 445249259Sdim} 446249259SdimLLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C) { 447249259Sdim return wrap(Type::getLabelTy(*unwrap(C))); 448249259Sdim} 449249259Sdim 450249259SdimLLVMTypeRef LLVMVoidType(void) { 451249259Sdim return LLVMVoidTypeInContext(LLVMGetGlobalContext()); 452249259Sdim} 453249259SdimLLVMTypeRef LLVMLabelType(void) { 454249259Sdim return LLVMLabelTypeInContext(LLVMGetGlobalContext()); 455249259Sdim} 456249259Sdim 457249259Sdim/*===-- Operations on values ----------------------------------------------===*/ 458249259Sdim 459249259Sdim/*--.. Operations on all values ............................................--*/ 460249259Sdim 461249259SdimLLVMTypeRef LLVMTypeOf(LLVMValueRef Val) { 462249259Sdim return wrap(unwrap(Val)->getType()); 463249259Sdim} 464249259Sdim 465249259Sdimconst char *LLVMGetValueName(LLVMValueRef Val) { 466249259Sdim return unwrap(Val)->getName().data(); 467249259Sdim} 468249259Sdim 469249259Sdimvoid LLVMSetValueName(LLVMValueRef Val, const char *Name) { 470249259Sdim unwrap(Val)->setName(Name); 471249259Sdim} 472249259Sdim 473249259Sdimvoid LLVMDumpValue(LLVMValueRef Val) { 474249259Sdim unwrap(Val)->dump(); 475249259Sdim} 476249259Sdim 477263509Sdimchar* LLVMPrintValueToString(LLVMValueRef Val) { 478263509Sdim std::string buf; 479263509Sdim raw_string_ostream os(buf); 480263509Sdim 481263509Sdim unwrap(Val)->print(os); 482263509Sdim os.flush(); 483263509Sdim 484263509Sdim return strdup(buf.c_str()); 485263509Sdim} 486263509Sdim 487249259Sdimvoid LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal) { 488249259Sdim unwrap(OldVal)->replaceAllUsesWith(unwrap(NewVal)); 489249259Sdim} 490249259Sdim 491249259Sdimint LLVMHasMetadata(LLVMValueRef Inst) { 492249259Sdim return unwrap<Instruction>(Inst)->hasMetadata(); 493249259Sdim} 494249259Sdim 495249259SdimLLVMValueRef LLVMGetMetadata(LLVMValueRef Inst, unsigned KindID) { 496249259Sdim return wrap(unwrap<Instruction>(Inst)->getMetadata(KindID)); 497249259Sdim} 498249259Sdim 499249259Sdimvoid LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef MD) { 500249259Sdim unwrap<Instruction>(Inst)->setMetadata(KindID, MD? unwrap<MDNode>(MD) : NULL); 501249259Sdim} 502249259Sdim 503249259Sdim/*--.. Conversion functions ................................................--*/ 504249259Sdim 505249259Sdim#define LLVM_DEFINE_VALUE_CAST(name) \ 506249259Sdim LLVMValueRef LLVMIsA##name(LLVMValueRef Val) { \ 507249259Sdim return wrap(static_cast<Value*>(dyn_cast_or_null<name>(unwrap(Val)))); \ 508249259Sdim } 509249259Sdim 510249259SdimLLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DEFINE_VALUE_CAST) 511249259Sdim 512249259Sdim/*--.. Operations on Uses ..................................................--*/ 513249259SdimLLVMUseRef LLVMGetFirstUse(LLVMValueRef Val) { 514249259Sdim Value *V = unwrap(Val); 515249259Sdim Value::use_iterator I = V->use_begin(); 516249259Sdim if (I == V->use_end()) 517249259Sdim return 0; 518249259Sdim return wrap(&(I.getUse())); 519249259Sdim} 520249259Sdim 521249259SdimLLVMUseRef LLVMGetNextUse(LLVMUseRef U) { 522249259Sdim Use *Next = unwrap(U)->getNext(); 523249259Sdim if (Next) 524249259Sdim return wrap(Next); 525249259Sdim return 0; 526249259Sdim} 527249259Sdim 528249259SdimLLVMValueRef LLVMGetUser(LLVMUseRef U) { 529249259Sdim return wrap(unwrap(U)->getUser()); 530249259Sdim} 531249259Sdim 532249259SdimLLVMValueRef LLVMGetUsedValue(LLVMUseRef U) { 533249259Sdim return wrap(unwrap(U)->get()); 534249259Sdim} 535249259Sdim 536249259Sdim/*--.. Operations on Users .................................................--*/ 537249259SdimLLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index) { 538249259Sdim Value *V = unwrap(Val); 539249259Sdim if (MDNode *MD = dyn_cast<MDNode>(V)) 540249259Sdim return wrap(MD->getOperand(Index)); 541249259Sdim return wrap(cast<User>(V)->getOperand(Index)); 542249259Sdim} 543249259Sdim 544249259Sdimvoid LLVMSetOperand(LLVMValueRef Val, unsigned Index, LLVMValueRef Op) { 545249259Sdim unwrap<User>(Val)->setOperand(Index, unwrap(Op)); 546249259Sdim} 547249259Sdim 548249259Sdimint LLVMGetNumOperands(LLVMValueRef Val) { 549249259Sdim Value *V = unwrap(Val); 550249259Sdim if (MDNode *MD = dyn_cast<MDNode>(V)) 551249259Sdim return MD->getNumOperands(); 552249259Sdim return cast<User>(V)->getNumOperands(); 553249259Sdim} 554249259Sdim 555249259Sdim/*--.. Operations on constants of any type .................................--*/ 556249259Sdim 557249259SdimLLVMValueRef LLVMConstNull(LLVMTypeRef Ty) { 558249259Sdim return wrap(Constant::getNullValue(unwrap(Ty))); 559249259Sdim} 560249259Sdim 561249259SdimLLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty) { 562249259Sdim return wrap(Constant::getAllOnesValue(unwrap(Ty))); 563249259Sdim} 564249259Sdim 565249259SdimLLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) { 566249259Sdim return wrap(UndefValue::get(unwrap(Ty))); 567249259Sdim} 568249259Sdim 569249259SdimLLVMBool LLVMIsConstant(LLVMValueRef Ty) { 570249259Sdim return isa<Constant>(unwrap(Ty)); 571249259Sdim} 572249259Sdim 573249259SdimLLVMBool LLVMIsNull(LLVMValueRef Val) { 574249259Sdim if (Constant *C = dyn_cast<Constant>(unwrap(Val))) 575249259Sdim return C->isNullValue(); 576249259Sdim return false; 577249259Sdim} 578249259Sdim 579249259SdimLLVMBool LLVMIsUndef(LLVMValueRef Val) { 580249259Sdim return isa<UndefValue>(unwrap(Val)); 581249259Sdim} 582249259Sdim 583249259SdimLLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) { 584249259Sdim return 585249259Sdim wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty))); 586249259Sdim} 587249259Sdim 588249259Sdim/*--.. Operations on metadata nodes ........................................--*/ 589249259Sdim 590249259SdimLLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str, 591249259Sdim unsigned SLen) { 592249259Sdim return wrap(MDString::get(*unwrap(C), StringRef(Str, SLen))); 593249259Sdim} 594249259Sdim 595249259SdimLLVMValueRef LLVMMDString(const char *Str, unsigned SLen) { 596249259Sdim return LLVMMDStringInContext(LLVMGetGlobalContext(), Str, SLen); 597249259Sdim} 598249259Sdim 599249259SdimLLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals, 600249259Sdim unsigned Count) { 601249259Sdim return wrap(MDNode::get(*unwrap(C), 602249259Sdim makeArrayRef(unwrap<Value>(Vals, Count), Count))); 603249259Sdim} 604249259Sdim 605249259SdimLLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count) { 606249259Sdim return LLVMMDNodeInContext(LLVMGetGlobalContext(), Vals, Count); 607249259Sdim} 608249259Sdim 609249259Sdimconst char *LLVMGetMDString(LLVMValueRef V, unsigned* Len) { 610249259Sdim if (const MDString *S = dyn_cast<MDString>(unwrap(V))) { 611249259Sdim *Len = S->getString().size(); 612249259Sdim return S->getString().data(); 613249259Sdim } 614249259Sdim *Len = 0; 615249259Sdim return 0; 616249259Sdim} 617249259Sdim 618249259Sdimunsigned LLVMGetMDNodeNumOperands(LLVMValueRef V) 619249259Sdim{ 620249259Sdim return cast<MDNode>(unwrap(V))->getNumOperands(); 621249259Sdim} 622249259Sdim 623249259Sdimvoid LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest) 624249259Sdim{ 625249259Sdim const MDNode *N = cast<MDNode>(unwrap(V)); 626249259Sdim const unsigned numOperands = N->getNumOperands(); 627249259Sdim for (unsigned i = 0; i < numOperands; i++) 628249259Sdim Dest[i] = wrap(N->getOperand(i)); 629249259Sdim} 630249259Sdim 631249259Sdimunsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char* name) 632249259Sdim{ 633249259Sdim if (NamedMDNode *N = unwrap(M)->getNamedMetadata(name)) { 634249259Sdim return N->getNumOperands(); 635249259Sdim } 636249259Sdim return 0; 637249259Sdim} 638249259Sdim 639249259Sdimvoid LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char* name, LLVMValueRef *Dest) 640249259Sdim{ 641249259Sdim NamedMDNode *N = unwrap(M)->getNamedMetadata(name); 642249259Sdim if (!N) 643249259Sdim return; 644249259Sdim for (unsigned i=0;i<N->getNumOperands();i++) 645249259Sdim Dest[i] = wrap(N->getOperand(i)); 646249259Sdim} 647249259Sdim 648249259Sdimvoid LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char* name, 649249259Sdim LLVMValueRef Val) 650249259Sdim{ 651249259Sdim NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(name); 652249259Sdim if (!N) 653249259Sdim return; 654249259Sdim MDNode *Op = Val ? unwrap<MDNode>(Val) : NULL; 655249259Sdim if (Op) 656249259Sdim N->addOperand(Op); 657249259Sdim} 658249259Sdim 659249259Sdim/*--.. Operations on scalar constants ......................................--*/ 660249259Sdim 661249259SdimLLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, 662249259Sdim LLVMBool SignExtend) { 663249259Sdim return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0)); 664249259Sdim} 665249259Sdim 666249259SdimLLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy, 667249259Sdim unsigned NumWords, 668249259Sdim const uint64_t Words[]) { 669249259Sdim IntegerType *Ty = unwrap<IntegerType>(IntTy); 670249259Sdim return wrap(ConstantInt::get(Ty->getContext(), 671249259Sdim APInt(Ty->getBitWidth(), 672249259Sdim makeArrayRef(Words, NumWords)))); 673249259Sdim} 674249259Sdim 675249259SdimLLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char Str[], 676249259Sdim uint8_t Radix) { 677249259Sdim return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str), 678249259Sdim Radix)); 679249259Sdim} 680249259Sdim 681249259SdimLLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char Str[], 682249259Sdim unsigned SLen, uint8_t Radix) { 683249259Sdim return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str, SLen), 684249259Sdim Radix)); 685249259Sdim} 686249259Sdim 687249259SdimLLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N) { 688249259Sdim return wrap(ConstantFP::get(unwrap(RealTy), N)); 689249259Sdim} 690249259Sdim 691249259SdimLLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text) { 692249259Sdim return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Text))); 693249259Sdim} 694249259Sdim 695249259SdimLLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char Str[], 696249259Sdim unsigned SLen) { 697249259Sdim return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Str, SLen))); 698249259Sdim} 699249259Sdim 700249259Sdimunsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal) { 701249259Sdim return unwrap<ConstantInt>(ConstantVal)->getZExtValue(); 702249259Sdim} 703249259Sdim 704249259Sdimlong long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal) { 705249259Sdim return unwrap<ConstantInt>(ConstantVal)->getSExtValue(); 706249259Sdim} 707249259Sdim 708249259Sdim/*--.. Operations on composite constants ...................................--*/ 709249259Sdim 710249259SdimLLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str, 711249259Sdim unsigned Length, 712249259Sdim LLVMBool DontNullTerminate) { 713249259Sdim /* Inverted the sense of AddNull because ', 0)' is a 714249259Sdim better mnemonic for null termination than ', 1)'. */ 715249259Sdim return wrap(ConstantDataArray::getString(*unwrap(C), StringRef(Str, Length), 716249259Sdim DontNullTerminate == 0)); 717249259Sdim} 718263509SdimLLVMValueRef LLVMConstStructInContext(LLVMContextRef C, 719249259Sdim LLVMValueRef *ConstantVals, 720249259Sdim unsigned Count, LLVMBool Packed) { 721249259Sdim Constant **Elements = unwrap<Constant>(ConstantVals, Count); 722249259Sdim return wrap(ConstantStruct::getAnon(*unwrap(C), makeArrayRef(Elements, Count), 723249259Sdim Packed != 0)); 724249259Sdim} 725249259Sdim 726249259SdimLLVMValueRef LLVMConstString(const char *Str, unsigned Length, 727249259Sdim LLVMBool DontNullTerminate) { 728249259Sdim return LLVMConstStringInContext(LLVMGetGlobalContext(), Str, Length, 729249259Sdim DontNullTerminate); 730249259Sdim} 731249259SdimLLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, 732249259Sdim LLVMValueRef *ConstantVals, unsigned Length) { 733249259Sdim ArrayRef<Constant*> V(unwrap<Constant>(ConstantVals, Length), Length); 734249259Sdim return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V)); 735249259Sdim} 736249259SdimLLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, 737249259Sdim LLVMBool Packed) { 738249259Sdim return LLVMConstStructInContext(LLVMGetGlobalContext(), ConstantVals, Count, 739249259Sdim Packed); 740249259Sdim} 741249259Sdim 742249259SdimLLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy, 743249259Sdim LLVMValueRef *ConstantVals, 744249259Sdim unsigned Count) { 745249259Sdim Constant **Elements = unwrap<Constant>(ConstantVals, Count); 746249259Sdim StructType *Ty = cast<StructType>(unwrap(StructTy)); 747249259Sdim 748249259Sdim return wrap(ConstantStruct::get(Ty, makeArrayRef(Elements, Count))); 749249259Sdim} 750249259Sdim 751249259SdimLLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) { 752249259Sdim return wrap(ConstantVector::get(makeArrayRef( 753249259Sdim unwrap<Constant>(ScalarConstantVals, Size), Size))); 754249259Sdim} 755249259Sdim 756249259Sdim/*-- Opcode mapping */ 757249259Sdim 758249259Sdimstatic LLVMOpcode map_to_llvmopcode(int opcode) 759249259Sdim{ 760249259Sdim switch (opcode) { 761249259Sdim default: llvm_unreachable("Unhandled Opcode."); 762249259Sdim#define HANDLE_INST(num, opc, clas) case num: return LLVM##opc; 763249259Sdim#include "llvm/IR/Instruction.def" 764249259Sdim#undef HANDLE_INST 765249259Sdim } 766249259Sdim} 767249259Sdim 768249259Sdimstatic int map_from_llvmopcode(LLVMOpcode code) 769249259Sdim{ 770249259Sdim switch (code) { 771249259Sdim#define HANDLE_INST(num, opc, clas) case LLVM##opc: return num; 772249259Sdim#include "llvm/IR/Instruction.def" 773249259Sdim#undef HANDLE_INST 774249259Sdim } 775249259Sdim llvm_unreachable("Unhandled Opcode."); 776249259Sdim} 777249259Sdim 778249259Sdim/*--.. Constant expressions ................................................--*/ 779249259Sdim 780249259SdimLLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal) { 781249259Sdim return map_to_llvmopcode(unwrap<ConstantExpr>(ConstantVal)->getOpcode()); 782249259Sdim} 783249259Sdim 784249259SdimLLVMValueRef LLVMAlignOf(LLVMTypeRef Ty) { 785249259Sdim return wrap(ConstantExpr::getAlignOf(unwrap(Ty))); 786249259Sdim} 787249259Sdim 788249259SdimLLVMValueRef LLVMSizeOf(LLVMTypeRef Ty) { 789249259Sdim return wrap(ConstantExpr::getSizeOf(unwrap(Ty))); 790249259Sdim} 791249259Sdim 792249259SdimLLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal) { 793249259Sdim return wrap(ConstantExpr::getNeg(unwrap<Constant>(ConstantVal))); 794249259Sdim} 795249259Sdim 796249259SdimLLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal) { 797249259Sdim return wrap(ConstantExpr::getNSWNeg(unwrap<Constant>(ConstantVal))); 798249259Sdim} 799249259Sdim 800249259SdimLLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal) { 801249259Sdim return wrap(ConstantExpr::getNUWNeg(unwrap<Constant>(ConstantVal))); 802249259Sdim} 803249259Sdim 804249259Sdim 805249259SdimLLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal) { 806249259Sdim return wrap(ConstantExpr::getFNeg(unwrap<Constant>(ConstantVal))); 807249259Sdim} 808249259Sdim 809249259SdimLLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal) { 810249259Sdim return wrap(ConstantExpr::getNot(unwrap<Constant>(ConstantVal))); 811249259Sdim} 812249259Sdim 813249259SdimLLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 814249259Sdim return wrap(ConstantExpr::getAdd(unwrap<Constant>(LHSConstant), 815249259Sdim unwrap<Constant>(RHSConstant))); 816249259Sdim} 817249259Sdim 818249259SdimLLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, 819249259Sdim LLVMValueRef RHSConstant) { 820249259Sdim return wrap(ConstantExpr::getNSWAdd(unwrap<Constant>(LHSConstant), 821249259Sdim unwrap<Constant>(RHSConstant))); 822249259Sdim} 823249259Sdim 824249259SdimLLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, 825249259Sdim LLVMValueRef RHSConstant) { 826249259Sdim return wrap(ConstantExpr::getNUWAdd(unwrap<Constant>(LHSConstant), 827249259Sdim unwrap<Constant>(RHSConstant))); 828249259Sdim} 829249259Sdim 830249259SdimLLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 831249259Sdim return wrap(ConstantExpr::getFAdd(unwrap<Constant>(LHSConstant), 832249259Sdim unwrap<Constant>(RHSConstant))); 833249259Sdim} 834249259Sdim 835249259SdimLLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 836249259Sdim return wrap(ConstantExpr::getSub(unwrap<Constant>(LHSConstant), 837249259Sdim unwrap<Constant>(RHSConstant))); 838249259Sdim} 839249259Sdim 840249259SdimLLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, 841249259Sdim LLVMValueRef RHSConstant) { 842249259Sdim return wrap(ConstantExpr::getNSWSub(unwrap<Constant>(LHSConstant), 843249259Sdim unwrap<Constant>(RHSConstant))); 844249259Sdim} 845249259Sdim 846249259SdimLLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, 847249259Sdim LLVMValueRef RHSConstant) { 848249259Sdim return wrap(ConstantExpr::getNUWSub(unwrap<Constant>(LHSConstant), 849249259Sdim unwrap<Constant>(RHSConstant))); 850249259Sdim} 851249259Sdim 852249259SdimLLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 853249259Sdim return wrap(ConstantExpr::getFSub(unwrap<Constant>(LHSConstant), 854249259Sdim unwrap<Constant>(RHSConstant))); 855249259Sdim} 856249259Sdim 857249259SdimLLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 858249259Sdim return wrap(ConstantExpr::getMul(unwrap<Constant>(LHSConstant), 859249259Sdim unwrap<Constant>(RHSConstant))); 860249259Sdim} 861249259Sdim 862249259SdimLLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, 863249259Sdim LLVMValueRef RHSConstant) { 864249259Sdim return wrap(ConstantExpr::getNSWMul(unwrap<Constant>(LHSConstant), 865249259Sdim unwrap<Constant>(RHSConstant))); 866249259Sdim} 867249259Sdim 868249259SdimLLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, 869249259Sdim LLVMValueRef RHSConstant) { 870249259Sdim return wrap(ConstantExpr::getNUWMul(unwrap<Constant>(LHSConstant), 871249259Sdim unwrap<Constant>(RHSConstant))); 872249259Sdim} 873249259Sdim 874249259SdimLLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 875249259Sdim return wrap(ConstantExpr::getFMul(unwrap<Constant>(LHSConstant), 876249259Sdim unwrap<Constant>(RHSConstant))); 877249259Sdim} 878249259Sdim 879249259SdimLLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 880249259Sdim return wrap(ConstantExpr::getUDiv(unwrap<Constant>(LHSConstant), 881249259Sdim unwrap<Constant>(RHSConstant))); 882249259Sdim} 883249259Sdim 884249259SdimLLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 885249259Sdim return wrap(ConstantExpr::getSDiv(unwrap<Constant>(LHSConstant), 886249259Sdim unwrap<Constant>(RHSConstant))); 887249259Sdim} 888249259Sdim 889249259SdimLLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, 890249259Sdim LLVMValueRef RHSConstant) { 891249259Sdim return wrap(ConstantExpr::getExactSDiv(unwrap<Constant>(LHSConstant), 892249259Sdim unwrap<Constant>(RHSConstant))); 893249259Sdim} 894249259Sdim 895249259SdimLLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 896249259Sdim return wrap(ConstantExpr::getFDiv(unwrap<Constant>(LHSConstant), 897249259Sdim unwrap<Constant>(RHSConstant))); 898249259Sdim} 899249259Sdim 900249259SdimLLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 901249259Sdim return wrap(ConstantExpr::getURem(unwrap<Constant>(LHSConstant), 902249259Sdim unwrap<Constant>(RHSConstant))); 903249259Sdim} 904249259Sdim 905249259SdimLLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 906249259Sdim return wrap(ConstantExpr::getSRem(unwrap<Constant>(LHSConstant), 907249259Sdim unwrap<Constant>(RHSConstant))); 908249259Sdim} 909249259Sdim 910249259SdimLLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 911249259Sdim return wrap(ConstantExpr::getFRem(unwrap<Constant>(LHSConstant), 912249259Sdim unwrap<Constant>(RHSConstant))); 913249259Sdim} 914249259Sdim 915249259SdimLLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 916249259Sdim return wrap(ConstantExpr::getAnd(unwrap<Constant>(LHSConstant), 917249259Sdim unwrap<Constant>(RHSConstant))); 918249259Sdim} 919249259Sdim 920249259SdimLLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 921249259Sdim return wrap(ConstantExpr::getOr(unwrap<Constant>(LHSConstant), 922249259Sdim unwrap<Constant>(RHSConstant))); 923249259Sdim} 924249259Sdim 925249259SdimLLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 926249259Sdim return wrap(ConstantExpr::getXor(unwrap<Constant>(LHSConstant), 927249259Sdim unwrap<Constant>(RHSConstant))); 928249259Sdim} 929249259Sdim 930249259SdimLLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, 931249259Sdim LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 932249259Sdim return wrap(ConstantExpr::getICmp(Predicate, 933249259Sdim unwrap<Constant>(LHSConstant), 934249259Sdim unwrap<Constant>(RHSConstant))); 935249259Sdim} 936249259Sdim 937249259SdimLLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, 938249259Sdim LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 939249259Sdim return wrap(ConstantExpr::getFCmp(Predicate, 940249259Sdim unwrap<Constant>(LHSConstant), 941249259Sdim unwrap<Constant>(RHSConstant))); 942249259Sdim} 943249259Sdim 944249259SdimLLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 945249259Sdim return wrap(ConstantExpr::getShl(unwrap<Constant>(LHSConstant), 946249259Sdim unwrap<Constant>(RHSConstant))); 947249259Sdim} 948249259Sdim 949249259SdimLLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 950249259Sdim return wrap(ConstantExpr::getLShr(unwrap<Constant>(LHSConstant), 951249259Sdim unwrap<Constant>(RHSConstant))); 952249259Sdim} 953249259Sdim 954249259SdimLLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { 955249259Sdim return wrap(ConstantExpr::getAShr(unwrap<Constant>(LHSConstant), 956249259Sdim unwrap<Constant>(RHSConstant))); 957249259Sdim} 958249259Sdim 959249259SdimLLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, 960249259Sdim LLVMValueRef *ConstantIndices, unsigned NumIndices) { 961249259Sdim ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices), 962249259Sdim NumIndices); 963249259Sdim return wrap(ConstantExpr::getGetElementPtr(unwrap<Constant>(ConstantVal), 964249259Sdim IdxList)); 965249259Sdim} 966249259Sdim 967249259SdimLLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, 968249259Sdim LLVMValueRef *ConstantIndices, 969249259Sdim unsigned NumIndices) { 970249259Sdim Constant* Val = unwrap<Constant>(ConstantVal); 971249259Sdim ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices), 972249259Sdim NumIndices); 973249259Sdim return wrap(ConstantExpr::getInBoundsGetElementPtr(Val, IdxList)); 974249259Sdim} 975249259Sdim 976249259SdimLLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 977249259Sdim return wrap(ConstantExpr::getTrunc(unwrap<Constant>(ConstantVal), 978249259Sdim unwrap(ToType))); 979249259Sdim} 980249259Sdim 981249259SdimLLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 982249259Sdim return wrap(ConstantExpr::getSExt(unwrap<Constant>(ConstantVal), 983249259Sdim unwrap(ToType))); 984249259Sdim} 985249259Sdim 986249259SdimLLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 987249259Sdim return wrap(ConstantExpr::getZExt(unwrap<Constant>(ConstantVal), 988249259Sdim unwrap(ToType))); 989249259Sdim} 990249259Sdim 991249259SdimLLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 992249259Sdim return wrap(ConstantExpr::getFPTrunc(unwrap<Constant>(ConstantVal), 993249259Sdim unwrap(ToType))); 994249259Sdim} 995249259Sdim 996249259SdimLLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 997249259Sdim return wrap(ConstantExpr::getFPExtend(unwrap<Constant>(ConstantVal), 998249259Sdim unwrap(ToType))); 999249259Sdim} 1000249259Sdim 1001249259SdimLLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1002249259Sdim return wrap(ConstantExpr::getUIToFP(unwrap<Constant>(ConstantVal), 1003249259Sdim unwrap(ToType))); 1004249259Sdim} 1005249259Sdim 1006249259SdimLLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1007249259Sdim return wrap(ConstantExpr::getSIToFP(unwrap<Constant>(ConstantVal), 1008249259Sdim unwrap(ToType))); 1009249259Sdim} 1010249259Sdim 1011249259SdimLLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1012249259Sdim return wrap(ConstantExpr::getFPToUI(unwrap<Constant>(ConstantVal), 1013249259Sdim unwrap(ToType))); 1014249259Sdim} 1015249259Sdim 1016249259SdimLLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1017249259Sdim return wrap(ConstantExpr::getFPToSI(unwrap<Constant>(ConstantVal), 1018249259Sdim unwrap(ToType))); 1019249259Sdim} 1020249259Sdim 1021249259SdimLLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1022249259Sdim return wrap(ConstantExpr::getPtrToInt(unwrap<Constant>(ConstantVal), 1023249259Sdim unwrap(ToType))); 1024249259Sdim} 1025249259Sdim 1026249259SdimLLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1027249259Sdim return wrap(ConstantExpr::getIntToPtr(unwrap<Constant>(ConstantVal), 1028249259Sdim unwrap(ToType))); 1029249259Sdim} 1030249259Sdim 1031249259SdimLLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1032249259Sdim return wrap(ConstantExpr::getBitCast(unwrap<Constant>(ConstantVal), 1033249259Sdim unwrap(ToType))); 1034249259Sdim} 1035249259Sdim 1036263509SdimLLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal, 1037263509Sdim LLVMTypeRef ToType) { 1038263509Sdim return wrap(ConstantExpr::getAddrSpaceCast(unwrap<Constant>(ConstantVal), 1039263509Sdim unwrap(ToType))); 1040263509Sdim} 1041263509Sdim 1042249259SdimLLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, 1043249259Sdim LLVMTypeRef ToType) { 1044249259Sdim return wrap(ConstantExpr::getZExtOrBitCast(unwrap<Constant>(ConstantVal), 1045249259Sdim unwrap(ToType))); 1046249259Sdim} 1047249259Sdim 1048249259SdimLLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, 1049249259Sdim LLVMTypeRef ToType) { 1050249259Sdim return wrap(ConstantExpr::getSExtOrBitCast(unwrap<Constant>(ConstantVal), 1051249259Sdim unwrap(ToType))); 1052249259Sdim} 1053249259Sdim 1054249259SdimLLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, 1055249259Sdim LLVMTypeRef ToType) { 1056249259Sdim return wrap(ConstantExpr::getTruncOrBitCast(unwrap<Constant>(ConstantVal), 1057249259Sdim unwrap(ToType))); 1058249259Sdim} 1059249259Sdim 1060249259SdimLLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, 1061249259Sdim LLVMTypeRef ToType) { 1062249259Sdim return wrap(ConstantExpr::getPointerCast(unwrap<Constant>(ConstantVal), 1063249259Sdim unwrap(ToType))); 1064249259Sdim} 1065249259Sdim 1066249259SdimLLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, 1067249259Sdim LLVMBool isSigned) { 1068249259Sdim return wrap(ConstantExpr::getIntegerCast(unwrap<Constant>(ConstantVal), 1069249259Sdim unwrap(ToType), isSigned)); 1070249259Sdim} 1071249259Sdim 1072249259SdimLLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { 1073249259Sdim return wrap(ConstantExpr::getFPCast(unwrap<Constant>(ConstantVal), 1074249259Sdim unwrap(ToType))); 1075249259Sdim} 1076249259Sdim 1077249259SdimLLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, 1078249259Sdim LLVMValueRef ConstantIfTrue, 1079249259Sdim LLVMValueRef ConstantIfFalse) { 1080249259Sdim return wrap(ConstantExpr::getSelect(unwrap<Constant>(ConstantCondition), 1081249259Sdim unwrap<Constant>(ConstantIfTrue), 1082249259Sdim unwrap<Constant>(ConstantIfFalse))); 1083249259Sdim} 1084249259Sdim 1085249259SdimLLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, 1086249259Sdim LLVMValueRef IndexConstant) { 1087249259Sdim return wrap(ConstantExpr::getExtractElement(unwrap<Constant>(VectorConstant), 1088249259Sdim unwrap<Constant>(IndexConstant))); 1089249259Sdim} 1090249259Sdim 1091249259SdimLLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, 1092249259Sdim LLVMValueRef ElementValueConstant, 1093249259Sdim LLVMValueRef IndexConstant) { 1094249259Sdim return wrap(ConstantExpr::getInsertElement(unwrap<Constant>(VectorConstant), 1095249259Sdim unwrap<Constant>(ElementValueConstant), 1096249259Sdim unwrap<Constant>(IndexConstant))); 1097249259Sdim} 1098249259Sdim 1099249259SdimLLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, 1100249259Sdim LLVMValueRef VectorBConstant, 1101249259Sdim LLVMValueRef MaskConstant) { 1102249259Sdim return wrap(ConstantExpr::getShuffleVector(unwrap<Constant>(VectorAConstant), 1103249259Sdim unwrap<Constant>(VectorBConstant), 1104249259Sdim unwrap<Constant>(MaskConstant))); 1105249259Sdim} 1106249259Sdim 1107249259SdimLLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, 1108249259Sdim unsigned NumIdx) { 1109249259Sdim return wrap(ConstantExpr::getExtractValue(unwrap<Constant>(AggConstant), 1110249259Sdim makeArrayRef(IdxList, NumIdx))); 1111249259Sdim} 1112249259Sdim 1113249259SdimLLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, 1114249259Sdim LLVMValueRef ElementValueConstant, 1115249259Sdim unsigned *IdxList, unsigned NumIdx) { 1116249259Sdim return wrap(ConstantExpr::getInsertValue(unwrap<Constant>(AggConstant), 1117249259Sdim unwrap<Constant>(ElementValueConstant), 1118249259Sdim makeArrayRef(IdxList, NumIdx))); 1119249259Sdim} 1120249259Sdim 1121249259SdimLLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, const char *AsmString, 1122249259Sdim const char *Constraints, 1123249259Sdim LLVMBool HasSideEffects, 1124249259Sdim LLVMBool IsAlignStack) { 1125249259Sdim return wrap(InlineAsm::get(dyn_cast<FunctionType>(unwrap(Ty)), AsmString, 1126249259Sdim Constraints, HasSideEffects, IsAlignStack)); 1127249259Sdim} 1128249259Sdim 1129249259SdimLLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB) { 1130249259Sdim return wrap(BlockAddress::get(unwrap<Function>(F), unwrap(BB))); 1131249259Sdim} 1132249259Sdim 1133249259Sdim/*--.. Operations on global variables, functions, and aliases (globals) ....--*/ 1134249259Sdim 1135249259SdimLLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global) { 1136249259Sdim return wrap(unwrap<GlobalValue>(Global)->getParent()); 1137249259Sdim} 1138249259Sdim 1139249259SdimLLVMBool LLVMIsDeclaration(LLVMValueRef Global) { 1140249259Sdim return unwrap<GlobalValue>(Global)->isDeclaration(); 1141249259Sdim} 1142249259Sdim 1143249259SdimLLVMLinkage LLVMGetLinkage(LLVMValueRef Global) { 1144249259Sdim switch (unwrap<GlobalValue>(Global)->getLinkage()) { 1145249259Sdim case GlobalValue::ExternalLinkage: 1146249259Sdim return LLVMExternalLinkage; 1147249259Sdim case GlobalValue::AvailableExternallyLinkage: 1148249259Sdim return LLVMAvailableExternallyLinkage; 1149249259Sdim case GlobalValue::LinkOnceAnyLinkage: 1150249259Sdim return LLVMLinkOnceAnyLinkage; 1151249259Sdim case GlobalValue::LinkOnceODRLinkage: 1152249259Sdim return LLVMLinkOnceODRLinkage; 1153249259Sdim case GlobalValue::WeakAnyLinkage: 1154249259Sdim return LLVMWeakAnyLinkage; 1155249259Sdim case GlobalValue::WeakODRLinkage: 1156249259Sdim return LLVMWeakODRLinkage; 1157249259Sdim case GlobalValue::AppendingLinkage: 1158249259Sdim return LLVMAppendingLinkage; 1159249259Sdim case GlobalValue::InternalLinkage: 1160249259Sdim return LLVMInternalLinkage; 1161249259Sdim case GlobalValue::PrivateLinkage: 1162249259Sdim return LLVMPrivateLinkage; 1163249259Sdim case GlobalValue::LinkerPrivateLinkage: 1164249259Sdim return LLVMLinkerPrivateLinkage; 1165249259Sdim case GlobalValue::LinkerPrivateWeakLinkage: 1166249259Sdim return LLVMLinkerPrivateWeakLinkage; 1167249259Sdim case GlobalValue::DLLImportLinkage: 1168249259Sdim return LLVMDLLImportLinkage; 1169249259Sdim case GlobalValue::DLLExportLinkage: 1170249259Sdim return LLVMDLLExportLinkage; 1171249259Sdim case GlobalValue::ExternalWeakLinkage: 1172249259Sdim return LLVMExternalWeakLinkage; 1173249259Sdim case GlobalValue::CommonLinkage: 1174249259Sdim return LLVMCommonLinkage; 1175249259Sdim } 1176249259Sdim 1177249259Sdim llvm_unreachable("Invalid GlobalValue linkage!"); 1178249259Sdim} 1179249259Sdim 1180249259Sdimvoid LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage) { 1181249259Sdim GlobalValue *GV = unwrap<GlobalValue>(Global); 1182249259Sdim 1183249259Sdim switch (Linkage) { 1184249259Sdim case LLVMExternalLinkage: 1185249259Sdim GV->setLinkage(GlobalValue::ExternalLinkage); 1186249259Sdim break; 1187249259Sdim case LLVMAvailableExternallyLinkage: 1188249259Sdim GV->setLinkage(GlobalValue::AvailableExternallyLinkage); 1189249259Sdim break; 1190249259Sdim case LLVMLinkOnceAnyLinkage: 1191249259Sdim GV->setLinkage(GlobalValue::LinkOnceAnyLinkage); 1192249259Sdim break; 1193249259Sdim case LLVMLinkOnceODRLinkage: 1194249259Sdim GV->setLinkage(GlobalValue::LinkOnceODRLinkage); 1195249259Sdim break; 1196249259Sdim case LLVMLinkOnceODRAutoHideLinkage: 1197263509Sdim DEBUG(errs() << "LLVMSetLinkage(): LLVMLinkOnceODRAutoHideLinkage is no " 1198263509Sdim "longer supported."); 1199249259Sdim break; 1200249259Sdim case LLVMWeakAnyLinkage: 1201249259Sdim GV->setLinkage(GlobalValue::WeakAnyLinkage); 1202249259Sdim break; 1203249259Sdim case LLVMWeakODRLinkage: 1204249259Sdim GV->setLinkage(GlobalValue::WeakODRLinkage); 1205249259Sdim break; 1206249259Sdim case LLVMAppendingLinkage: 1207249259Sdim GV->setLinkage(GlobalValue::AppendingLinkage); 1208249259Sdim break; 1209249259Sdim case LLVMInternalLinkage: 1210249259Sdim GV->setLinkage(GlobalValue::InternalLinkage); 1211249259Sdim break; 1212249259Sdim case LLVMPrivateLinkage: 1213249259Sdim GV->setLinkage(GlobalValue::PrivateLinkage); 1214249259Sdim break; 1215249259Sdim case LLVMLinkerPrivateLinkage: 1216249259Sdim GV->setLinkage(GlobalValue::LinkerPrivateLinkage); 1217249259Sdim break; 1218249259Sdim case LLVMLinkerPrivateWeakLinkage: 1219249259Sdim GV->setLinkage(GlobalValue::LinkerPrivateWeakLinkage); 1220249259Sdim break; 1221249259Sdim case LLVMDLLImportLinkage: 1222249259Sdim GV->setLinkage(GlobalValue::DLLImportLinkage); 1223249259Sdim break; 1224249259Sdim case LLVMDLLExportLinkage: 1225249259Sdim GV->setLinkage(GlobalValue::DLLExportLinkage); 1226249259Sdim break; 1227249259Sdim case LLVMExternalWeakLinkage: 1228249259Sdim GV->setLinkage(GlobalValue::ExternalWeakLinkage); 1229249259Sdim break; 1230249259Sdim case LLVMGhostLinkage: 1231249259Sdim DEBUG(errs() 1232249259Sdim << "LLVMSetLinkage(): LLVMGhostLinkage is no longer supported."); 1233249259Sdim break; 1234249259Sdim case LLVMCommonLinkage: 1235249259Sdim GV->setLinkage(GlobalValue::CommonLinkage); 1236249259Sdim break; 1237249259Sdim } 1238249259Sdim} 1239249259Sdim 1240249259Sdimconst char *LLVMGetSection(LLVMValueRef Global) { 1241249259Sdim return unwrap<GlobalValue>(Global)->getSection().c_str(); 1242249259Sdim} 1243249259Sdim 1244249259Sdimvoid LLVMSetSection(LLVMValueRef Global, const char *Section) { 1245249259Sdim unwrap<GlobalValue>(Global)->setSection(Section); 1246249259Sdim} 1247249259Sdim 1248249259SdimLLVMVisibility LLVMGetVisibility(LLVMValueRef Global) { 1249249259Sdim return static_cast<LLVMVisibility>( 1250249259Sdim unwrap<GlobalValue>(Global)->getVisibility()); 1251249259Sdim} 1252249259Sdim 1253249259Sdimvoid LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz) { 1254249259Sdim unwrap<GlobalValue>(Global) 1255249259Sdim ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz)); 1256249259Sdim} 1257249259Sdim 1258263509Sdim/*--.. Operations on global variables, load and store instructions .........--*/ 1259263509Sdim 1260263509Sdimunsigned LLVMGetAlignment(LLVMValueRef V) { 1261263509Sdim Value *P = unwrap<Value>(V); 1262263509Sdim if (GlobalValue *GV = dyn_cast<GlobalValue>(P)) 1263263509Sdim return GV->getAlignment(); 1264263509Sdim if (LoadInst *LI = dyn_cast<LoadInst>(P)) 1265263509Sdim return LI->getAlignment(); 1266263509Sdim if (StoreInst *SI = dyn_cast<StoreInst>(P)) 1267263509Sdim return SI->getAlignment(); 1268263509Sdim 1269263509Sdim llvm_unreachable("only GlobalValue, LoadInst and StoreInst have alignment"); 1270249259Sdim} 1271249259Sdim 1272263509Sdimvoid LLVMSetAlignment(LLVMValueRef V, unsigned Bytes) { 1273263509Sdim Value *P = unwrap<Value>(V); 1274263509Sdim if (GlobalValue *GV = dyn_cast<GlobalValue>(P)) 1275263509Sdim GV->setAlignment(Bytes); 1276263509Sdim else if (LoadInst *LI = dyn_cast<LoadInst>(P)) 1277263509Sdim LI->setAlignment(Bytes); 1278263509Sdim else if (StoreInst *SI = dyn_cast<StoreInst>(P)) 1279263509Sdim SI->setAlignment(Bytes); 1280263509Sdim else 1281263509Sdim llvm_unreachable("only GlobalValue, LoadInst and StoreInst have alignment"); 1282249259Sdim} 1283249259Sdim 1284249259Sdim/*--.. Operations on global variables ......................................--*/ 1285249259Sdim 1286249259SdimLLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name) { 1287249259Sdim return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false, 1288249259Sdim GlobalValue::ExternalLinkage, 0, Name)); 1289249259Sdim} 1290249259Sdim 1291249259SdimLLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty, 1292249259Sdim const char *Name, 1293249259Sdim unsigned AddressSpace) { 1294249259Sdim return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false, 1295249259Sdim GlobalValue::ExternalLinkage, 0, Name, 0, 1296249259Sdim GlobalVariable::NotThreadLocal, AddressSpace)); 1297249259Sdim} 1298249259Sdim 1299249259SdimLLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name) { 1300249259Sdim return wrap(unwrap(M)->getNamedGlobal(Name)); 1301249259Sdim} 1302249259Sdim 1303249259SdimLLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M) { 1304249259Sdim Module *Mod = unwrap(M); 1305249259Sdim Module::global_iterator I = Mod->global_begin(); 1306249259Sdim if (I == Mod->global_end()) 1307249259Sdim return 0; 1308249259Sdim return wrap(I); 1309249259Sdim} 1310249259Sdim 1311249259SdimLLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M) { 1312249259Sdim Module *Mod = unwrap(M); 1313249259Sdim Module::global_iterator I = Mod->global_end(); 1314249259Sdim if (I == Mod->global_begin()) 1315249259Sdim return 0; 1316249259Sdim return wrap(--I); 1317249259Sdim} 1318249259Sdim 1319249259SdimLLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar) { 1320249259Sdim GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar); 1321249259Sdim Module::global_iterator I = GV; 1322249259Sdim if (++I == GV->getParent()->global_end()) 1323249259Sdim return 0; 1324249259Sdim return wrap(I); 1325249259Sdim} 1326249259Sdim 1327249259SdimLLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar) { 1328249259Sdim GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar); 1329249259Sdim Module::global_iterator I = GV; 1330249259Sdim if (I == GV->getParent()->global_begin()) 1331249259Sdim return 0; 1332249259Sdim return wrap(--I); 1333249259Sdim} 1334249259Sdim 1335249259Sdimvoid LLVMDeleteGlobal(LLVMValueRef GlobalVar) { 1336249259Sdim unwrap<GlobalVariable>(GlobalVar)->eraseFromParent(); 1337249259Sdim} 1338249259Sdim 1339249259SdimLLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar) { 1340249259Sdim GlobalVariable* GV = unwrap<GlobalVariable>(GlobalVar); 1341249259Sdim if ( !GV->hasInitializer() ) 1342249259Sdim return 0; 1343249259Sdim return wrap(GV->getInitializer()); 1344249259Sdim} 1345249259Sdim 1346249259Sdimvoid LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) { 1347249259Sdim unwrap<GlobalVariable>(GlobalVar) 1348249259Sdim ->setInitializer(unwrap<Constant>(ConstantVal)); 1349249259Sdim} 1350249259Sdim 1351249259SdimLLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar) { 1352249259Sdim return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal(); 1353249259Sdim} 1354249259Sdim 1355249259Sdimvoid LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal) { 1356249259Sdim unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0); 1357249259Sdim} 1358249259Sdim 1359249259SdimLLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar) { 1360249259Sdim return unwrap<GlobalVariable>(GlobalVar)->isConstant(); 1361249259Sdim} 1362249259Sdim 1363249259Sdimvoid LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant) { 1364249259Sdim unwrap<GlobalVariable>(GlobalVar)->setConstant(IsConstant != 0); 1365249259Sdim} 1366249259Sdim 1367252723SdimLLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar) { 1368252723Sdim switch (unwrap<GlobalVariable>(GlobalVar)->getThreadLocalMode()) { 1369252723Sdim case GlobalVariable::NotThreadLocal: 1370252723Sdim return LLVMNotThreadLocal; 1371252723Sdim case GlobalVariable::GeneralDynamicTLSModel: 1372252723Sdim return LLVMGeneralDynamicTLSModel; 1373252723Sdim case GlobalVariable::LocalDynamicTLSModel: 1374252723Sdim return LLVMLocalDynamicTLSModel; 1375252723Sdim case GlobalVariable::InitialExecTLSModel: 1376252723Sdim return LLVMInitialExecTLSModel; 1377252723Sdim case GlobalVariable::LocalExecTLSModel: 1378252723Sdim return LLVMLocalExecTLSModel; 1379252723Sdim } 1380252723Sdim 1381252723Sdim llvm_unreachable("Invalid GlobalVariable thread local mode"); 1382252723Sdim} 1383252723Sdim 1384252723Sdimvoid LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode) { 1385252723Sdim GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar); 1386252723Sdim 1387252723Sdim switch (Mode) { 1388252723Sdim case LLVMNotThreadLocal: 1389252723Sdim GV->setThreadLocalMode(GlobalVariable::NotThreadLocal); 1390252723Sdim break; 1391252723Sdim case LLVMGeneralDynamicTLSModel: 1392252723Sdim GV->setThreadLocalMode(GlobalVariable::GeneralDynamicTLSModel); 1393252723Sdim break; 1394252723Sdim case LLVMLocalDynamicTLSModel: 1395252723Sdim GV->setThreadLocalMode(GlobalVariable::LocalDynamicTLSModel); 1396252723Sdim break; 1397252723Sdim case LLVMInitialExecTLSModel: 1398252723Sdim GV->setThreadLocalMode(GlobalVariable::InitialExecTLSModel); 1399252723Sdim break; 1400252723Sdim case LLVMLocalExecTLSModel: 1401252723Sdim GV->setThreadLocalMode(GlobalVariable::LocalExecTLSModel); 1402252723Sdim break; 1403252723Sdim } 1404252723Sdim} 1405252723Sdim 1406252723SdimLLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar) { 1407252723Sdim return unwrap<GlobalVariable>(GlobalVar)->isExternallyInitialized(); 1408252723Sdim} 1409252723Sdim 1410252723Sdimvoid LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit) { 1411252723Sdim unwrap<GlobalVariable>(GlobalVar)->setExternallyInitialized(IsExtInit); 1412252723Sdim} 1413252723Sdim 1414249259Sdim/*--.. Operations on aliases ......................................--*/ 1415249259Sdim 1416249259SdimLLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, 1417249259Sdim const char *Name) { 1418249259Sdim return wrap(new GlobalAlias(unwrap(Ty), GlobalValue::ExternalLinkage, Name, 1419249259Sdim unwrap<Constant>(Aliasee), unwrap (M))); 1420249259Sdim} 1421249259Sdim 1422249259Sdim/*--.. Operations on functions .............................................--*/ 1423249259Sdim 1424249259SdimLLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, 1425249259Sdim LLVMTypeRef FunctionTy) { 1426249259Sdim return wrap(Function::Create(unwrap<FunctionType>(FunctionTy), 1427249259Sdim GlobalValue::ExternalLinkage, Name, unwrap(M))); 1428249259Sdim} 1429249259Sdim 1430249259SdimLLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name) { 1431249259Sdim return wrap(unwrap(M)->getFunction(Name)); 1432249259Sdim} 1433249259Sdim 1434249259SdimLLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M) { 1435249259Sdim Module *Mod = unwrap(M); 1436249259Sdim Module::iterator I = Mod->begin(); 1437249259Sdim if (I == Mod->end()) 1438249259Sdim return 0; 1439249259Sdim return wrap(I); 1440249259Sdim} 1441249259Sdim 1442249259SdimLLVMValueRef LLVMGetLastFunction(LLVMModuleRef M) { 1443249259Sdim Module *Mod = unwrap(M); 1444249259Sdim Module::iterator I = Mod->end(); 1445249259Sdim if (I == Mod->begin()) 1446249259Sdim return 0; 1447249259Sdim return wrap(--I); 1448249259Sdim} 1449249259Sdim 1450249259SdimLLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn) { 1451249259Sdim Function *Func = unwrap<Function>(Fn); 1452249259Sdim Module::iterator I = Func; 1453249259Sdim if (++I == Func->getParent()->end()) 1454249259Sdim return 0; 1455249259Sdim return wrap(I); 1456249259Sdim} 1457249259Sdim 1458249259SdimLLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn) { 1459249259Sdim Function *Func = unwrap<Function>(Fn); 1460249259Sdim Module::iterator I = Func; 1461249259Sdim if (I == Func->getParent()->begin()) 1462249259Sdim return 0; 1463249259Sdim return wrap(--I); 1464249259Sdim} 1465249259Sdim 1466249259Sdimvoid LLVMDeleteFunction(LLVMValueRef Fn) { 1467249259Sdim unwrap<Function>(Fn)->eraseFromParent(); 1468249259Sdim} 1469249259Sdim 1470249259Sdimunsigned LLVMGetIntrinsicID(LLVMValueRef Fn) { 1471249259Sdim if (Function *F = dyn_cast<Function>(unwrap(Fn))) 1472249259Sdim return F->getIntrinsicID(); 1473249259Sdim return 0; 1474249259Sdim} 1475249259Sdim 1476249259Sdimunsigned LLVMGetFunctionCallConv(LLVMValueRef Fn) { 1477249259Sdim return unwrap<Function>(Fn)->getCallingConv(); 1478249259Sdim} 1479249259Sdim 1480249259Sdimvoid LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC) { 1481249259Sdim return unwrap<Function>(Fn)->setCallingConv( 1482249259Sdim static_cast<CallingConv::ID>(CC)); 1483249259Sdim} 1484249259Sdim 1485249259Sdimconst char *LLVMGetGC(LLVMValueRef Fn) { 1486249259Sdim Function *F = unwrap<Function>(Fn); 1487249259Sdim return F->hasGC()? F->getGC() : 0; 1488249259Sdim} 1489249259Sdim 1490249259Sdimvoid LLVMSetGC(LLVMValueRef Fn, const char *GC) { 1491249259Sdim Function *F = unwrap<Function>(Fn); 1492249259Sdim if (GC) 1493249259Sdim F->setGC(GC); 1494249259Sdim else 1495249259Sdim F->clearGC(); 1496249259Sdim} 1497249259Sdim 1498249259Sdimvoid LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA) { 1499249259Sdim Function *Func = unwrap<Function>(Fn); 1500249259Sdim const AttributeSet PAL = Func->getAttributes(); 1501249259Sdim AttrBuilder B(PA); 1502249259Sdim const AttributeSet PALnew = 1503249259Sdim PAL.addAttributes(Func->getContext(), AttributeSet::FunctionIndex, 1504249259Sdim AttributeSet::get(Func->getContext(), 1505249259Sdim AttributeSet::FunctionIndex, B)); 1506249259Sdim Func->setAttributes(PALnew); 1507249259Sdim} 1508249259Sdim 1509252723Sdimvoid LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A, 1510252723Sdim const char *V) { 1511252723Sdim Function *Func = unwrap<Function>(Fn); 1512252723Sdim AttributeSet::AttrIndex Idx = 1513252723Sdim AttributeSet::AttrIndex(AttributeSet::FunctionIndex); 1514252723Sdim AttrBuilder B; 1515252723Sdim 1516252723Sdim B.addAttribute(A, V); 1517252723Sdim AttributeSet Set = AttributeSet::get(Func->getContext(), Idx, B); 1518252723Sdim Func->addAttributes(Idx, Set); 1519252723Sdim} 1520252723Sdim 1521249259Sdimvoid LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA) { 1522249259Sdim Function *Func = unwrap<Function>(Fn); 1523249259Sdim const AttributeSet PAL = Func->getAttributes(); 1524249259Sdim AttrBuilder B(PA); 1525249259Sdim const AttributeSet PALnew = 1526249259Sdim PAL.removeAttributes(Func->getContext(), AttributeSet::FunctionIndex, 1527249259Sdim AttributeSet::get(Func->getContext(), 1528249259Sdim AttributeSet::FunctionIndex, B)); 1529249259Sdim Func->setAttributes(PALnew); 1530249259Sdim} 1531249259Sdim 1532249259SdimLLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn) { 1533249259Sdim Function *Func = unwrap<Function>(Fn); 1534249259Sdim const AttributeSet PAL = Func->getAttributes(); 1535249259Sdim return (LLVMAttribute)PAL.Raw(AttributeSet::FunctionIndex); 1536249259Sdim} 1537249259Sdim 1538249259Sdim/*--.. Operations on parameters ............................................--*/ 1539249259Sdim 1540249259Sdimunsigned LLVMCountParams(LLVMValueRef FnRef) { 1541249259Sdim // This function is strictly redundant to 1542249259Sdim // LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(FnRef))) 1543249259Sdim return unwrap<Function>(FnRef)->arg_size(); 1544249259Sdim} 1545249259Sdim 1546249259Sdimvoid LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs) { 1547249259Sdim Function *Fn = unwrap<Function>(FnRef); 1548249259Sdim for (Function::arg_iterator I = Fn->arg_begin(), 1549249259Sdim E = Fn->arg_end(); I != E; I++) 1550249259Sdim *ParamRefs++ = wrap(I); 1551249259Sdim} 1552249259Sdim 1553249259SdimLLVMValueRef LLVMGetParam(LLVMValueRef FnRef, unsigned index) { 1554249259Sdim Function::arg_iterator AI = unwrap<Function>(FnRef)->arg_begin(); 1555249259Sdim while (index --> 0) 1556249259Sdim AI++; 1557249259Sdim return wrap(AI); 1558249259Sdim} 1559249259Sdim 1560249259SdimLLVMValueRef LLVMGetParamParent(LLVMValueRef V) { 1561249259Sdim return wrap(unwrap<Argument>(V)->getParent()); 1562249259Sdim} 1563249259Sdim 1564249259SdimLLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn) { 1565249259Sdim Function *Func = unwrap<Function>(Fn); 1566249259Sdim Function::arg_iterator I = Func->arg_begin(); 1567249259Sdim if (I == Func->arg_end()) 1568249259Sdim return 0; 1569249259Sdim return wrap(I); 1570249259Sdim} 1571249259Sdim 1572249259SdimLLVMValueRef LLVMGetLastParam(LLVMValueRef Fn) { 1573249259Sdim Function *Func = unwrap<Function>(Fn); 1574249259Sdim Function::arg_iterator I = Func->arg_end(); 1575249259Sdim if (I == Func->arg_begin()) 1576249259Sdim return 0; 1577249259Sdim return wrap(--I); 1578249259Sdim} 1579249259Sdim 1580249259SdimLLVMValueRef LLVMGetNextParam(LLVMValueRef Arg) { 1581249259Sdim Argument *A = unwrap<Argument>(Arg); 1582249259Sdim Function::arg_iterator I = A; 1583249259Sdim if (++I == A->getParent()->arg_end()) 1584249259Sdim return 0; 1585249259Sdim return wrap(I); 1586249259Sdim} 1587249259Sdim 1588249259SdimLLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg) { 1589249259Sdim Argument *A = unwrap<Argument>(Arg); 1590249259Sdim Function::arg_iterator I = A; 1591249259Sdim if (I == A->getParent()->arg_begin()) 1592249259Sdim return 0; 1593249259Sdim return wrap(--I); 1594249259Sdim} 1595249259Sdim 1596249259Sdimvoid LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA) { 1597249259Sdim Argument *A = unwrap<Argument>(Arg); 1598249259Sdim AttrBuilder B(PA); 1599249259Sdim A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B)); 1600249259Sdim} 1601249259Sdim 1602249259Sdimvoid LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA) { 1603249259Sdim Argument *A = unwrap<Argument>(Arg); 1604249259Sdim AttrBuilder B(PA); 1605249259Sdim A->removeAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B)); 1606249259Sdim} 1607249259Sdim 1608249259SdimLLVMAttribute LLVMGetAttribute(LLVMValueRef Arg) { 1609249259Sdim Argument *A = unwrap<Argument>(Arg); 1610249259Sdim return (LLVMAttribute)A->getParent()->getAttributes(). 1611249259Sdim Raw(A->getArgNo()+1); 1612249259Sdim} 1613249259Sdim 1614263509Sdim 1615249259Sdimvoid LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align) { 1616249259Sdim Argument *A = unwrap<Argument>(Arg); 1617249259Sdim AttrBuilder B; 1618249259Sdim B.addAlignmentAttr(align); 1619249259Sdim A->addAttr(AttributeSet::get(A->getContext(),A->getArgNo() + 1, B)); 1620249259Sdim} 1621249259Sdim 1622249259Sdim/*--.. Operations on basic blocks ..........................................--*/ 1623249259Sdim 1624249259SdimLLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB) { 1625249259Sdim return wrap(static_cast<Value*>(unwrap(BB))); 1626249259Sdim} 1627249259Sdim 1628249259SdimLLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val) { 1629249259Sdim return isa<BasicBlock>(unwrap(Val)); 1630249259Sdim} 1631249259Sdim 1632249259SdimLLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val) { 1633249259Sdim return wrap(unwrap<BasicBlock>(Val)); 1634249259Sdim} 1635249259Sdim 1636249259SdimLLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB) { 1637249259Sdim return wrap(unwrap(BB)->getParent()); 1638249259Sdim} 1639249259Sdim 1640249259SdimLLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB) { 1641249259Sdim return wrap(unwrap(BB)->getTerminator()); 1642249259Sdim} 1643249259Sdim 1644249259Sdimunsigned LLVMCountBasicBlocks(LLVMValueRef FnRef) { 1645249259Sdim return unwrap<Function>(FnRef)->size(); 1646249259Sdim} 1647249259Sdim 1648249259Sdimvoid LLVMGetBasicBlocks(LLVMValueRef FnRef, LLVMBasicBlockRef *BasicBlocksRefs){ 1649249259Sdim Function *Fn = unwrap<Function>(FnRef); 1650249259Sdim for (Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++) 1651249259Sdim *BasicBlocksRefs++ = wrap(I); 1652249259Sdim} 1653249259Sdim 1654249259SdimLLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn) { 1655249259Sdim return wrap(&unwrap<Function>(Fn)->getEntryBlock()); 1656249259Sdim} 1657249259Sdim 1658249259SdimLLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn) { 1659249259Sdim Function *Func = unwrap<Function>(Fn); 1660249259Sdim Function::iterator I = Func->begin(); 1661249259Sdim if (I == Func->end()) 1662249259Sdim return 0; 1663249259Sdim return wrap(I); 1664249259Sdim} 1665249259Sdim 1666249259SdimLLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn) { 1667249259Sdim Function *Func = unwrap<Function>(Fn); 1668249259Sdim Function::iterator I = Func->end(); 1669249259Sdim if (I == Func->begin()) 1670249259Sdim return 0; 1671249259Sdim return wrap(--I); 1672249259Sdim} 1673249259Sdim 1674249259SdimLLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB) { 1675249259Sdim BasicBlock *Block = unwrap(BB); 1676249259Sdim Function::iterator I = Block; 1677249259Sdim if (++I == Block->getParent()->end()) 1678249259Sdim return 0; 1679249259Sdim return wrap(I); 1680249259Sdim} 1681249259Sdim 1682249259SdimLLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB) { 1683249259Sdim BasicBlock *Block = unwrap(BB); 1684249259Sdim Function::iterator I = Block; 1685249259Sdim if (I == Block->getParent()->begin()) 1686249259Sdim return 0; 1687249259Sdim return wrap(--I); 1688249259Sdim} 1689249259Sdim 1690249259SdimLLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, 1691249259Sdim LLVMValueRef FnRef, 1692249259Sdim const char *Name) { 1693249259Sdim return wrap(BasicBlock::Create(*unwrap(C), Name, unwrap<Function>(FnRef))); 1694249259Sdim} 1695249259Sdim 1696249259SdimLLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef FnRef, const char *Name) { 1697249259Sdim return LLVMAppendBasicBlockInContext(LLVMGetGlobalContext(), FnRef, Name); 1698249259Sdim} 1699249259Sdim 1700249259SdimLLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, 1701249259Sdim LLVMBasicBlockRef BBRef, 1702249259Sdim const char *Name) { 1703249259Sdim BasicBlock *BB = unwrap(BBRef); 1704249259Sdim return wrap(BasicBlock::Create(*unwrap(C), Name, BB->getParent(), BB)); 1705249259Sdim} 1706249259Sdim 1707249259SdimLLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef BBRef, 1708249259Sdim const char *Name) { 1709249259Sdim return LLVMInsertBasicBlockInContext(LLVMGetGlobalContext(), BBRef, Name); 1710249259Sdim} 1711249259Sdim 1712249259Sdimvoid LLVMDeleteBasicBlock(LLVMBasicBlockRef BBRef) { 1713249259Sdim unwrap(BBRef)->eraseFromParent(); 1714249259Sdim} 1715249259Sdim 1716249259Sdimvoid LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BBRef) { 1717249259Sdim unwrap(BBRef)->removeFromParent(); 1718249259Sdim} 1719249259Sdim 1720249259Sdimvoid LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos) { 1721249259Sdim unwrap(BB)->moveBefore(unwrap(MovePos)); 1722249259Sdim} 1723249259Sdim 1724249259Sdimvoid LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos) { 1725249259Sdim unwrap(BB)->moveAfter(unwrap(MovePos)); 1726249259Sdim} 1727249259Sdim 1728249259Sdim/*--.. Operations on instructions ..........................................--*/ 1729249259Sdim 1730249259SdimLLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst) { 1731249259Sdim return wrap(unwrap<Instruction>(Inst)->getParent()); 1732249259Sdim} 1733249259Sdim 1734249259SdimLLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB) { 1735249259Sdim BasicBlock *Block = unwrap(BB); 1736249259Sdim BasicBlock::iterator I = Block->begin(); 1737249259Sdim if (I == Block->end()) 1738249259Sdim return 0; 1739249259Sdim return wrap(I); 1740249259Sdim} 1741249259Sdim 1742249259SdimLLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB) { 1743249259Sdim BasicBlock *Block = unwrap(BB); 1744249259Sdim BasicBlock::iterator I = Block->end(); 1745249259Sdim if (I == Block->begin()) 1746249259Sdim return 0; 1747249259Sdim return wrap(--I); 1748249259Sdim} 1749249259Sdim 1750249259SdimLLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst) { 1751249259Sdim Instruction *Instr = unwrap<Instruction>(Inst); 1752249259Sdim BasicBlock::iterator I = Instr; 1753249259Sdim if (++I == Instr->getParent()->end()) 1754249259Sdim return 0; 1755249259Sdim return wrap(I); 1756249259Sdim} 1757249259Sdim 1758249259SdimLLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst) { 1759249259Sdim Instruction *Instr = unwrap<Instruction>(Inst); 1760249259Sdim BasicBlock::iterator I = Instr; 1761249259Sdim if (I == Instr->getParent()->begin()) 1762249259Sdim return 0; 1763249259Sdim return wrap(--I); 1764249259Sdim} 1765249259Sdim 1766249259Sdimvoid LLVMInstructionEraseFromParent(LLVMValueRef Inst) { 1767249259Sdim unwrap<Instruction>(Inst)->eraseFromParent(); 1768249259Sdim} 1769249259Sdim 1770249259SdimLLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst) { 1771249259Sdim if (ICmpInst *I = dyn_cast<ICmpInst>(unwrap(Inst))) 1772249259Sdim return (LLVMIntPredicate)I->getPredicate(); 1773249259Sdim if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst))) 1774249259Sdim if (CE->getOpcode() == Instruction::ICmp) 1775249259Sdim return (LLVMIntPredicate)CE->getPredicate(); 1776249259Sdim return (LLVMIntPredicate)0; 1777249259Sdim} 1778249259Sdim 1779249259SdimLLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst) { 1780249259Sdim if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst))) 1781249259Sdim return map_to_llvmopcode(C->getOpcode()); 1782249259Sdim return (LLVMOpcode)0; 1783249259Sdim} 1784249259Sdim 1785249259Sdim/*--.. Call and invoke instructions ........................................--*/ 1786249259Sdim 1787249259Sdimunsigned LLVMGetInstructionCallConv(LLVMValueRef Instr) { 1788249259Sdim Value *V = unwrap(Instr); 1789249259Sdim if (CallInst *CI = dyn_cast<CallInst>(V)) 1790249259Sdim return CI->getCallingConv(); 1791249259Sdim if (InvokeInst *II = dyn_cast<InvokeInst>(V)) 1792249259Sdim return II->getCallingConv(); 1793249259Sdim llvm_unreachable("LLVMGetInstructionCallConv applies only to call and invoke!"); 1794249259Sdim} 1795249259Sdim 1796249259Sdimvoid LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC) { 1797249259Sdim Value *V = unwrap(Instr); 1798249259Sdim if (CallInst *CI = dyn_cast<CallInst>(V)) 1799249259Sdim return CI->setCallingConv(static_cast<CallingConv::ID>(CC)); 1800249259Sdim else if (InvokeInst *II = dyn_cast<InvokeInst>(V)) 1801249259Sdim return II->setCallingConv(static_cast<CallingConv::ID>(CC)); 1802249259Sdim llvm_unreachable("LLVMSetInstructionCallConv applies only to call and invoke!"); 1803249259Sdim} 1804249259Sdim 1805263509Sdimvoid LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, 1806249259Sdim LLVMAttribute PA) { 1807249259Sdim CallSite Call = CallSite(unwrap<Instruction>(Instr)); 1808249259Sdim AttrBuilder B(PA); 1809249259Sdim Call.setAttributes( 1810249259Sdim Call.getAttributes().addAttributes(Call->getContext(), index, 1811249259Sdim AttributeSet::get(Call->getContext(), 1812249259Sdim index, B))); 1813249259Sdim} 1814249259Sdim 1815263509Sdimvoid LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index, 1816249259Sdim LLVMAttribute PA) { 1817249259Sdim CallSite Call = CallSite(unwrap<Instruction>(Instr)); 1818249259Sdim AttrBuilder B(PA); 1819249259Sdim Call.setAttributes(Call.getAttributes() 1820249259Sdim .removeAttributes(Call->getContext(), index, 1821249259Sdim AttributeSet::get(Call->getContext(), 1822249259Sdim index, B))); 1823249259Sdim} 1824249259Sdim 1825263509Sdimvoid LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, 1826249259Sdim unsigned align) { 1827249259Sdim CallSite Call = CallSite(unwrap<Instruction>(Instr)); 1828249259Sdim AttrBuilder B; 1829249259Sdim B.addAlignmentAttr(align); 1830249259Sdim Call.setAttributes(Call.getAttributes() 1831249259Sdim .addAttributes(Call->getContext(), index, 1832249259Sdim AttributeSet::get(Call->getContext(), 1833249259Sdim index, B))); 1834249259Sdim} 1835249259Sdim 1836249259Sdim/*--.. Operations on call instructions (only) ..............................--*/ 1837249259Sdim 1838249259SdimLLVMBool LLVMIsTailCall(LLVMValueRef Call) { 1839249259Sdim return unwrap<CallInst>(Call)->isTailCall(); 1840249259Sdim} 1841249259Sdim 1842249259Sdimvoid LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall) { 1843249259Sdim unwrap<CallInst>(Call)->setTailCall(isTailCall); 1844249259Sdim} 1845249259Sdim 1846249259Sdim/*--.. Operations on switch instructions (only) ............................--*/ 1847249259Sdim 1848249259SdimLLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef Switch) { 1849249259Sdim return wrap(unwrap<SwitchInst>(Switch)->getDefaultDest()); 1850249259Sdim} 1851249259Sdim 1852249259Sdim/*--.. Operations on phi nodes .............................................--*/ 1853249259Sdim 1854249259Sdimvoid LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, 1855249259Sdim LLVMBasicBlockRef *IncomingBlocks, unsigned Count) { 1856249259Sdim PHINode *PhiVal = unwrap<PHINode>(PhiNode); 1857249259Sdim for (unsigned I = 0; I != Count; ++I) 1858249259Sdim PhiVal->addIncoming(unwrap(IncomingValues[I]), unwrap(IncomingBlocks[I])); 1859249259Sdim} 1860249259Sdim 1861249259Sdimunsigned LLVMCountIncoming(LLVMValueRef PhiNode) { 1862249259Sdim return unwrap<PHINode>(PhiNode)->getNumIncomingValues(); 1863249259Sdim} 1864249259Sdim 1865249259SdimLLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index) { 1866249259Sdim return wrap(unwrap<PHINode>(PhiNode)->getIncomingValue(Index)); 1867249259Sdim} 1868249259Sdim 1869249259SdimLLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index) { 1870249259Sdim return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index)); 1871249259Sdim} 1872249259Sdim 1873249259Sdim 1874249259Sdim/*===-- Instruction builders ----------------------------------------------===*/ 1875249259Sdim 1876249259SdimLLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C) { 1877249259Sdim return wrap(new IRBuilder<>(*unwrap(C))); 1878249259Sdim} 1879249259Sdim 1880249259SdimLLVMBuilderRef LLVMCreateBuilder(void) { 1881249259Sdim return LLVMCreateBuilderInContext(LLVMGetGlobalContext()); 1882249259Sdim} 1883249259Sdim 1884249259Sdimvoid LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, 1885249259Sdim LLVMValueRef Instr) { 1886249259Sdim BasicBlock *BB = unwrap(Block); 1887249259Sdim Instruction *I = Instr? unwrap<Instruction>(Instr) : (Instruction*) BB->end(); 1888249259Sdim unwrap(Builder)->SetInsertPoint(BB, I); 1889249259Sdim} 1890249259Sdim 1891249259Sdimvoid LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr) { 1892249259Sdim Instruction *I = unwrap<Instruction>(Instr); 1893249259Sdim unwrap(Builder)->SetInsertPoint(I->getParent(), I); 1894249259Sdim} 1895249259Sdim 1896249259Sdimvoid LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block) { 1897249259Sdim BasicBlock *BB = unwrap(Block); 1898249259Sdim unwrap(Builder)->SetInsertPoint(BB); 1899249259Sdim} 1900249259Sdim 1901249259SdimLLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder) { 1902249259Sdim return wrap(unwrap(Builder)->GetInsertBlock()); 1903249259Sdim} 1904249259Sdim 1905249259Sdimvoid LLVMClearInsertionPosition(LLVMBuilderRef Builder) { 1906249259Sdim unwrap(Builder)->ClearInsertionPoint(); 1907249259Sdim} 1908249259Sdim 1909249259Sdimvoid LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr) { 1910249259Sdim unwrap(Builder)->Insert(unwrap<Instruction>(Instr)); 1911249259Sdim} 1912249259Sdim 1913249259Sdimvoid LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, 1914249259Sdim const char *Name) { 1915249259Sdim unwrap(Builder)->Insert(unwrap<Instruction>(Instr), Name); 1916249259Sdim} 1917249259Sdim 1918249259Sdimvoid LLVMDisposeBuilder(LLVMBuilderRef Builder) { 1919249259Sdim delete unwrap(Builder); 1920249259Sdim} 1921249259Sdim 1922249259Sdim/*--.. Metadata builders ...................................................--*/ 1923249259Sdim 1924249259Sdimvoid LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L) { 1925249259Sdim MDNode *Loc = L ? unwrap<MDNode>(L) : NULL; 1926249259Sdim unwrap(Builder)->SetCurrentDebugLocation(DebugLoc::getFromDILocation(Loc)); 1927249259Sdim} 1928249259Sdim 1929249259SdimLLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder) { 1930249259Sdim return wrap(unwrap(Builder)->getCurrentDebugLocation() 1931249259Sdim .getAsMDNode(unwrap(Builder)->getContext())); 1932249259Sdim} 1933249259Sdim 1934249259Sdimvoid LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst) { 1935249259Sdim unwrap(Builder)->SetInstDebugLocation(unwrap<Instruction>(Inst)); 1936249259Sdim} 1937249259Sdim 1938249259Sdim 1939249259Sdim/*--.. Instruction builders ................................................--*/ 1940249259Sdim 1941249259SdimLLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef B) { 1942249259Sdim return wrap(unwrap(B)->CreateRetVoid()); 1943249259Sdim} 1944249259Sdim 1945249259SdimLLVMValueRef LLVMBuildRet(LLVMBuilderRef B, LLVMValueRef V) { 1946249259Sdim return wrap(unwrap(B)->CreateRet(unwrap(V))); 1947249259Sdim} 1948249259Sdim 1949249259SdimLLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef B, LLVMValueRef *RetVals, 1950249259Sdim unsigned N) { 1951249259Sdim return wrap(unwrap(B)->CreateAggregateRet(unwrap(RetVals), N)); 1952249259Sdim} 1953249259Sdim 1954249259SdimLLVMValueRef LLVMBuildBr(LLVMBuilderRef B, LLVMBasicBlockRef Dest) { 1955249259Sdim return wrap(unwrap(B)->CreateBr(unwrap(Dest))); 1956249259Sdim} 1957249259Sdim 1958249259SdimLLVMValueRef LLVMBuildCondBr(LLVMBuilderRef B, LLVMValueRef If, 1959249259Sdim LLVMBasicBlockRef Then, LLVMBasicBlockRef Else) { 1960249259Sdim return wrap(unwrap(B)->CreateCondBr(unwrap(If), unwrap(Then), unwrap(Else))); 1961249259Sdim} 1962249259Sdim 1963249259SdimLLVMValueRef LLVMBuildSwitch(LLVMBuilderRef B, LLVMValueRef V, 1964249259Sdim LLVMBasicBlockRef Else, unsigned NumCases) { 1965249259Sdim return wrap(unwrap(B)->CreateSwitch(unwrap(V), unwrap(Else), NumCases)); 1966249259Sdim} 1967249259Sdim 1968249259SdimLLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr, 1969249259Sdim unsigned NumDests) { 1970249259Sdim return wrap(unwrap(B)->CreateIndirectBr(unwrap(Addr), NumDests)); 1971249259Sdim} 1972249259Sdim 1973249259SdimLLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn, 1974249259Sdim LLVMValueRef *Args, unsigned NumArgs, 1975249259Sdim LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, 1976249259Sdim const char *Name) { 1977249259Sdim return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch), 1978249259Sdim makeArrayRef(unwrap(Args), NumArgs), 1979249259Sdim Name)); 1980249259Sdim} 1981249259Sdim 1982249259SdimLLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, 1983249259Sdim LLVMValueRef PersFn, unsigned NumClauses, 1984249259Sdim const char *Name) { 1985249259Sdim return wrap(unwrap(B)->CreateLandingPad(unwrap(Ty), 1986249259Sdim cast<Function>(unwrap(PersFn)), 1987249259Sdim NumClauses, Name)); 1988249259Sdim} 1989249259Sdim 1990249259SdimLLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn) { 1991249259Sdim return wrap(unwrap(B)->CreateResume(unwrap(Exn))); 1992249259Sdim} 1993249259Sdim 1994249259SdimLLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) { 1995249259Sdim return wrap(unwrap(B)->CreateUnreachable()); 1996249259Sdim} 1997249259Sdim 1998249259Sdimvoid LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, 1999249259Sdim LLVMBasicBlockRef Dest) { 2000249259Sdim unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest)); 2001249259Sdim} 2002249259Sdim 2003249259Sdimvoid LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest) { 2004249259Sdim unwrap<IndirectBrInst>(IndirectBr)->addDestination(unwrap(Dest)); 2005249259Sdim} 2006249259Sdim 2007249259Sdimvoid LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal) { 2008249259Sdim unwrap<LandingPadInst>(LandingPad)-> 2009249259Sdim addClause(cast<Constant>(unwrap(ClauseVal))); 2010249259Sdim} 2011249259Sdim 2012249259Sdimvoid LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val) { 2013249259Sdim unwrap<LandingPadInst>(LandingPad)->setCleanup(Val); 2014249259Sdim} 2015249259Sdim 2016249259Sdim/*--.. Arithmetic ..........................................................--*/ 2017249259Sdim 2018249259SdimLLVMValueRef LLVMBuildAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2019249259Sdim const char *Name) { 2020249259Sdim return wrap(unwrap(B)->CreateAdd(unwrap(LHS), unwrap(RHS), Name)); 2021249259Sdim} 2022249259Sdim 2023249259SdimLLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2024249259Sdim const char *Name) { 2025249259Sdim return wrap(unwrap(B)->CreateNSWAdd(unwrap(LHS), unwrap(RHS), Name)); 2026249259Sdim} 2027249259Sdim 2028249259SdimLLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2029249259Sdim const char *Name) { 2030249259Sdim return wrap(unwrap(B)->CreateNUWAdd(unwrap(LHS), unwrap(RHS), Name)); 2031249259Sdim} 2032249259Sdim 2033249259SdimLLVMValueRef LLVMBuildFAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2034249259Sdim const char *Name) { 2035249259Sdim return wrap(unwrap(B)->CreateFAdd(unwrap(LHS), unwrap(RHS), Name)); 2036249259Sdim} 2037249259Sdim 2038249259SdimLLVMValueRef LLVMBuildSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2039249259Sdim const char *Name) { 2040249259Sdim return wrap(unwrap(B)->CreateSub(unwrap(LHS), unwrap(RHS), Name)); 2041249259Sdim} 2042249259Sdim 2043249259SdimLLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2044249259Sdim const char *Name) { 2045249259Sdim return wrap(unwrap(B)->CreateNSWSub(unwrap(LHS), unwrap(RHS), Name)); 2046249259Sdim} 2047249259Sdim 2048249259SdimLLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2049249259Sdim const char *Name) { 2050249259Sdim return wrap(unwrap(B)->CreateNUWSub(unwrap(LHS), unwrap(RHS), Name)); 2051249259Sdim} 2052249259Sdim 2053249259SdimLLVMValueRef LLVMBuildFSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2054249259Sdim const char *Name) { 2055249259Sdim return wrap(unwrap(B)->CreateFSub(unwrap(LHS), unwrap(RHS), Name)); 2056249259Sdim} 2057249259Sdim 2058249259SdimLLVMValueRef LLVMBuildMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2059249259Sdim const char *Name) { 2060249259Sdim return wrap(unwrap(B)->CreateMul(unwrap(LHS), unwrap(RHS), Name)); 2061249259Sdim} 2062249259Sdim 2063249259SdimLLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2064249259Sdim const char *Name) { 2065249259Sdim return wrap(unwrap(B)->CreateNSWMul(unwrap(LHS), unwrap(RHS), Name)); 2066249259Sdim} 2067249259Sdim 2068249259SdimLLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2069249259Sdim const char *Name) { 2070249259Sdim return wrap(unwrap(B)->CreateNUWMul(unwrap(LHS), unwrap(RHS), Name)); 2071249259Sdim} 2072249259Sdim 2073249259SdimLLVMValueRef LLVMBuildFMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2074249259Sdim const char *Name) { 2075249259Sdim return wrap(unwrap(B)->CreateFMul(unwrap(LHS), unwrap(RHS), Name)); 2076249259Sdim} 2077249259Sdim 2078249259SdimLLVMValueRef LLVMBuildUDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2079249259Sdim const char *Name) { 2080249259Sdim return wrap(unwrap(B)->CreateUDiv(unwrap(LHS), unwrap(RHS), Name)); 2081249259Sdim} 2082249259Sdim 2083249259SdimLLVMValueRef LLVMBuildSDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2084249259Sdim const char *Name) { 2085249259Sdim return wrap(unwrap(B)->CreateSDiv(unwrap(LHS), unwrap(RHS), Name)); 2086249259Sdim} 2087249259Sdim 2088249259SdimLLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef B, LLVMValueRef LHS, 2089249259Sdim LLVMValueRef RHS, const char *Name) { 2090249259Sdim return wrap(unwrap(B)->CreateExactSDiv(unwrap(LHS), unwrap(RHS), Name)); 2091249259Sdim} 2092249259Sdim 2093249259SdimLLVMValueRef LLVMBuildFDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2094249259Sdim const char *Name) { 2095249259Sdim return wrap(unwrap(B)->CreateFDiv(unwrap(LHS), unwrap(RHS), Name)); 2096249259Sdim} 2097249259Sdim 2098249259SdimLLVMValueRef LLVMBuildURem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2099249259Sdim const char *Name) { 2100249259Sdim return wrap(unwrap(B)->CreateURem(unwrap(LHS), unwrap(RHS), Name)); 2101249259Sdim} 2102249259Sdim 2103249259SdimLLVMValueRef LLVMBuildSRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2104249259Sdim const char *Name) { 2105249259Sdim return wrap(unwrap(B)->CreateSRem(unwrap(LHS), unwrap(RHS), Name)); 2106249259Sdim} 2107249259Sdim 2108249259SdimLLVMValueRef LLVMBuildFRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2109249259Sdim const char *Name) { 2110249259Sdim return wrap(unwrap(B)->CreateFRem(unwrap(LHS), unwrap(RHS), Name)); 2111249259Sdim} 2112249259Sdim 2113249259SdimLLVMValueRef LLVMBuildShl(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2114249259Sdim const char *Name) { 2115249259Sdim return wrap(unwrap(B)->CreateShl(unwrap(LHS), unwrap(RHS), Name)); 2116249259Sdim} 2117249259Sdim 2118249259SdimLLVMValueRef LLVMBuildLShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2119249259Sdim const char *Name) { 2120249259Sdim return wrap(unwrap(B)->CreateLShr(unwrap(LHS), unwrap(RHS), Name)); 2121249259Sdim} 2122249259Sdim 2123249259SdimLLVMValueRef LLVMBuildAShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2124249259Sdim const char *Name) { 2125249259Sdim return wrap(unwrap(B)->CreateAShr(unwrap(LHS), unwrap(RHS), Name)); 2126249259Sdim} 2127249259Sdim 2128249259SdimLLVMValueRef LLVMBuildAnd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2129249259Sdim const char *Name) { 2130249259Sdim return wrap(unwrap(B)->CreateAnd(unwrap(LHS), unwrap(RHS), Name)); 2131249259Sdim} 2132249259Sdim 2133249259SdimLLVMValueRef LLVMBuildOr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2134249259Sdim const char *Name) { 2135249259Sdim return wrap(unwrap(B)->CreateOr(unwrap(LHS), unwrap(RHS), Name)); 2136249259Sdim} 2137249259Sdim 2138249259SdimLLVMValueRef LLVMBuildXor(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, 2139249259Sdim const char *Name) { 2140249259Sdim return wrap(unwrap(B)->CreateXor(unwrap(LHS), unwrap(RHS), Name)); 2141249259Sdim} 2142249259Sdim 2143249259SdimLLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op, 2144249259Sdim LLVMValueRef LHS, LLVMValueRef RHS, 2145249259Sdim const char *Name) { 2146249259Sdim return wrap(unwrap(B)->CreateBinOp(Instruction::BinaryOps(map_from_llvmopcode(Op)), unwrap(LHS), 2147249259Sdim unwrap(RHS), Name)); 2148249259Sdim} 2149249259Sdim 2150249259SdimLLVMValueRef LLVMBuildNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) { 2151249259Sdim return wrap(unwrap(B)->CreateNeg(unwrap(V), Name)); 2152249259Sdim} 2153249259Sdim 2154249259SdimLLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V, 2155249259Sdim const char *Name) { 2156249259Sdim return wrap(unwrap(B)->CreateNSWNeg(unwrap(V), Name)); 2157249259Sdim} 2158249259Sdim 2159249259SdimLLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V, 2160249259Sdim const char *Name) { 2161249259Sdim return wrap(unwrap(B)->CreateNUWNeg(unwrap(V), Name)); 2162249259Sdim} 2163249259Sdim 2164249259SdimLLVMValueRef LLVMBuildFNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) { 2165249259Sdim return wrap(unwrap(B)->CreateFNeg(unwrap(V), Name)); 2166249259Sdim} 2167249259Sdim 2168249259SdimLLVMValueRef LLVMBuildNot(LLVMBuilderRef B, LLVMValueRef V, const char *Name) { 2169249259Sdim return wrap(unwrap(B)->CreateNot(unwrap(V), Name)); 2170249259Sdim} 2171249259Sdim 2172249259Sdim/*--.. Memory ..............................................................--*/ 2173249259Sdim 2174249259SdimLLVMValueRef LLVMBuildMalloc(LLVMBuilderRef B, LLVMTypeRef Ty, 2175249259Sdim const char *Name) { 2176249259Sdim Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext()); 2177249259Sdim Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty)); 2178249259Sdim AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy); 2179263509Sdim Instruction* Malloc = CallInst::CreateMalloc(unwrap(B)->GetInsertBlock(), 2180263509Sdim ITy, unwrap(Ty), AllocSize, 2181249259Sdim 0, 0, ""); 2182249259Sdim return wrap(unwrap(B)->Insert(Malloc, Twine(Name))); 2183249259Sdim} 2184249259Sdim 2185249259SdimLLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef B, LLVMTypeRef Ty, 2186249259Sdim LLVMValueRef Val, const char *Name) { 2187249259Sdim Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext()); 2188249259Sdim Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty)); 2189249259Sdim AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy); 2190263509Sdim Instruction* Malloc = CallInst::CreateMalloc(unwrap(B)->GetInsertBlock(), 2191263509Sdim ITy, unwrap(Ty), AllocSize, 2192249259Sdim unwrap(Val), 0, ""); 2193249259Sdim return wrap(unwrap(B)->Insert(Malloc, Twine(Name))); 2194249259Sdim} 2195249259Sdim 2196249259SdimLLVMValueRef LLVMBuildAlloca(LLVMBuilderRef B, LLVMTypeRef Ty, 2197249259Sdim const char *Name) { 2198249259Sdim return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), 0, Name)); 2199249259Sdim} 2200249259Sdim 2201249259SdimLLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef B, LLVMTypeRef Ty, 2202249259Sdim LLVMValueRef Val, const char *Name) { 2203249259Sdim return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), unwrap(Val), Name)); 2204249259Sdim} 2205249259Sdim 2206249259SdimLLVMValueRef LLVMBuildFree(LLVMBuilderRef B, LLVMValueRef PointerVal) { 2207249259Sdim return wrap(unwrap(B)->Insert( 2208249259Sdim CallInst::CreateFree(unwrap(PointerVal), unwrap(B)->GetInsertBlock()))); 2209249259Sdim} 2210249259Sdim 2211249259Sdim 2212249259SdimLLVMValueRef LLVMBuildLoad(LLVMBuilderRef B, LLVMValueRef PointerVal, 2213249259Sdim const char *Name) { 2214249259Sdim return wrap(unwrap(B)->CreateLoad(unwrap(PointerVal), Name)); 2215249259Sdim} 2216249259Sdim 2217263509SdimLLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val, 2218249259Sdim LLVMValueRef PointerVal) { 2219249259Sdim return wrap(unwrap(B)->CreateStore(unwrap(Val), unwrap(PointerVal))); 2220249259Sdim} 2221249259Sdim 2222249259SdimLLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 2223249259Sdim LLVMValueRef *Indices, unsigned NumIndices, 2224249259Sdim const char *Name) { 2225249259Sdim ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices); 2226249259Sdim return wrap(unwrap(B)->CreateGEP(unwrap(Pointer), IdxList, Name)); 2227249259Sdim} 2228249259Sdim 2229249259SdimLLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 2230249259Sdim LLVMValueRef *Indices, unsigned NumIndices, 2231249259Sdim const char *Name) { 2232249259Sdim ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices); 2233249259Sdim return wrap(unwrap(B)->CreateInBoundsGEP(unwrap(Pointer), IdxList, Name)); 2234249259Sdim} 2235249259Sdim 2236249259SdimLLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 2237249259Sdim unsigned Idx, const char *Name) { 2238249259Sdim return wrap(unwrap(B)->CreateStructGEP(unwrap(Pointer), Idx, Name)); 2239249259Sdim} 2240249259Sdim 2241249259SdimLLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, 2242249259Sdim const char *Name) { 2243249259Sdim return wrap(unwrap(B)->CreateGlobalString(Str, Name)); 2244249259Sdim} 2245249259Sdim 2246249259SdimLLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, 2247249259Sdim const char *Name) { 2248249259Sdim return wrap(unwrap(B)->CreateGlobalStringPtr(Str, Name)); 2249249259Sdim} 2250249259Sdim 2251249259SdimLLVMBool LLVMGetVolatile(LLVMValueRef MemAccessInst) { 2252249259Sdim Value *P = unwrap<Value>(MemAccessInst); 2253249259Sdim if (LoadInst *LI = dyn_cast<LoadInst>(P)) 2254249259Sdim return LI->isVolatile(); 2255249259Sdim return cast<StoreInst>(P)->isVolatile(); 2256249259Sdim} 2257249259Sdim 2258249259Sdimvoid LLVMSetVolatile(LLVMValueRef MemAccessInst, LLVMBool isVolatile) { 2259249259Sdim Value *P = unwrap<Value>(MemAccessInst); 2260249259Sdim if (LoadInst *LI = dyn_cast<LoadInst>(P)) 2261249259Sdim return LI->setVolatile(isVolatile); 2262249259Sdim return cast<StoreInst>(P)->setVolatile(isVolatile); 2263249259Sdim} 2264249259Sdim 2265249259Sdim/*--.. Casts ...............................................................--*/ 2266249259Sdim 2267249259SdimLLVMValueRef LLVMBuildTrunc(LLVMBuilderRef B, LLVMValueRef Val, 2268249259Sdim LLVMTypeRef DestTy, const char *Name) { 2269249259Sdim return wrap(unwrap(B)->CreateTrunc(unwrap(Val), unwrap(DestTy), Name)); 2270249259Sdim} 2271249259Sdim 2272249259SdimLLVMValueRef LLVMBuildZExt(LLVMBuilderRef B, LLVMValueRef Val, 2273249259Sdim LLVMTypeRef DestTy, const char *Name) { 2274249259Sdim return wrap(unwrap(B)->CreateZExt(unwrap(Val), unwrap(DestTy), Name)); 2275249259Sdim} 2276249259Sdim 2277249259SdimLLVMValueRef LLVMBuildSExt(LLVMBuilderRef B, LLVMValueRef Val, 2278249259Sdim LLVMTypeRef DestTy, const char *Name) { 2279249259Sdim return wrap(unwrap(B)->CreateSExt(unwrap(Val), unwrap(DestTy), Name)); 2280249259Sdim} 2281249259Sdim 2282249259SdimLLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef B, LLVMValueRef Val, 2283249259Sdim LLVMTypeRef DestTy, const char *Name) { 2284249259Sdim return wrap(unwrap(B)->CreateFPToUI(unwrap(Val), unwrap(DestTy), Name)); 2285249259Sdim} 2286249259Sdim 2287249259SdimLLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef B, LLVMValueRef Val, 2288249259Sdim LLVMTypeRef DestTy, const char *Name) { 2289249259Sdim return wrap(unwrap(B)->CreateFPToSI(unwrap(Val), unwrap(DestTy), Name)); 2290249259Sdim} 2291249259Sdim 2292249259SdimLLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef B, LLVMValueRef Val, 2293249259Sdim LLVMTypeRef DestTy, const char *Name) { 2294249259Sdim return wrap(unwrap(B)->CreateUIToFP(unwrap(Val), unwrap(DestTy), Name)); 2295249259Sdim} 2296249259Sdim 2297249259SdimLLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef B, LLVMValueRef Val, 2298249259Sdim LLVMTypeRef DestTy, const char *Name) { 2299249259Sdim return wrap(unwrap(B)->CreateSIToFP(unwrap(Val), unwrap(DestTy), Name)); 2300249259Sdim} 2301249259Sdim 2302249259SdimLLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef B, LLVMValueRef Val, 2303249259Sdim LLVMTypeRef DestTy, const char *Name) { 2304249259Sdim return wrap(unwrap(B)->CreateFPTrunc(unwrap(Val), unwrap(DestTy), Name)); 2305249259Sdim} 2306249259Sdim 2307249259SdimLLVMValueRef LLVMBuildFPExt(LLVMBuilderRef B, LLVMValueRef Val, 2308249259Sdim LLVMTypeRef DestTy, const char *Name) { 2309249259Sdim return wrap(unwrap(B)->CreateFPExt(unwrap(Val), unwrap(DestTy), Name)); 2310249259Sdim} 2311249259Sdim 2312249259SdimLLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef B, LLVMValueRef Val, 2313249259Sdim LLVMTypeRef DestTy, const char *Name) { 2314249259Sdim return wrap(unwrap(B)->CreatePtrToInt(unwrap(Val), unwrap(DestTy), Name)); 2315249259Sdim} 2316249259Sdim 2317249259SdimLLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef B, LLVMValueRef Val, 2318249259Sdim LLVMTypeRef DestTy, const char *Name) { 2319249259Sdim return wrap(unwrap(B)->CreateIntToPtr(unwrap(Val), unwrap(DestTy), Name)); 2320249259Sdim} 2321249259Sdim 2322249259SdimLLVMValueRef LLVMBuildBitCast(LLVMBuilderRef B, LLVMValueRef Val, 2323249259Sdim LLVMTypeRef DestTy, const char *Name) { 2324249259Sdim return wrap(unwrap(B)->CreateBitCast(unwrap(Val), unwrap(DestTy), Name)); 2325249259Sdim} 2326249259Sdim 2327263509SdimLLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef B, LLVMValueRef Val, 2328263509Sdim LLVMTypeRef DestTy, const char *Name) { 2329263509Sdim return wrap(unwrap(B)->CreateAddrSpaceCast(unwrap(Val), unwrap(DestTy), Name)); 2330263509Sdim} 2331263509Sdim 2332249259SdimLLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val, 2333249259Sdim LLVMTypeRef DestTy, const char *Name) { 2334249259Sdim return wrap(unwrap(B)->CreateZExtOrBitCast(unwrap(Val), unwrap(DestTy), 2335249259Sdim Name)); 2336249259Sdim} 2337249259Sdim 2338249259SdimLLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val, 2339249259Sdim LLVMTypeRef DestTy, const char *Name) { 2340249259Sdim return wrap(unwrap(B)->CreateSExtOrBitCast(unwrap(Val), unwrap(DestTy), 2341249259Sdim Name)); 2342249259Sdim} 2343249259Sdim 2344249259SdimLLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef B, LLVMValueRef Val, 2345249259Sdim LLVMTypeRef DestTy, const char *Name) { 2346249259Sdim return wrap(unwrap(B)->CreateTruncOrBitCast(unwrap(Val), unwrap(DestTy), 2347249259Sdim Name)); 2348249259Sdim} 2349249259Sdim 2350249259SdimLLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val, 2351249259Sdim LLVMTypeRef DestTy, const char *Name) { 2352249259Sdim return wrap(unwrap(B)->CreateCast(Instruction::CastOps(map_from_llvmopcode(Op)), unwrap(Val), 2353249259Sdim unwrap(DestTy), Name)); 2354249259Sdim} 2355249259Sdim 2356249259SdimLLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef B, LLVMValueRef Val, 2357249259Sdim LLVMTypeRef DestTy, const char *Name) { 2358249259Sdim return wrap(unwrap(B)->CreatePointerCast(unwrap(Val), unwrap(DestTy), Name)); 2359249259Sdim} 2360249259Sdim 2361249259SdimLLVMValueRef LLVMBuildIntCast(LLVMBuilderRef B, LLVMValueRef Val, 2362249259Sdim LLVMTypeRef DestTy, const char *Name) { 2363249259Sdim return wrap(unwrap(B)->CreateIntCast(unwrap(Val), unwrap(DestTy), 2364249259Sdim /*isSigned*/true, Name)); 2365249259Sdim} 2366249259Sdim 2367249259SdimLLVMValueRef LLVMBuildFPCast(LLVMBuilderRef B, LLVMValueRef Val, 2368249259Sdim LLVMTypeRef DestTy, const char *Name) { 2369249259Sdim return wrap(unwrap(B)->CreateFPCast(unwrap(Val), unwrap(DestTy), Name)); 2370249259Sdim} 2371249259Sdim 2372249259Sdim/*--.. Comparisons .........................................................--*/ 2373249259Sdim 2374249259SdimLLVMValueRef LLVMBuildICmp(LLVMBuilderRef B, LLVMIntPredicate Op, 2375249259Sdim LLVMValueRef LHS, LLVMValueRef RHS, 2376249259Sdim const char *Name) { 2377249259Sdim return wrap(unwrap(B)->CreateICmp(static_cast<ICmpInst::Predicate>(Op), 2378249259Sdim unwrap(LHS), unwrap(RHS), Name)); 2379249259Sdim} 2380249259Sdim 2381249259SdimLLVMValueRef LLVMBuildFCmp(LLVMBuilderRef B, LLVMRealPredicate Op, 2382249259Sdim LLVMValueRef LHS, LLVMValueRef RHS, 2383249259Sdim const char *Name) { 2384249259Sdim return wrap(unwrap(B)->CreateFCmp(static_cast<FCmpInst::Predicate>(Op), 2385249259Sdim unwrap(LHS), unwrap(RHS), Name)); 2386249259Sdim} 2387249259Sdim 2388249259Sdim/*--.. Miscellaneous instructions ..........................................--*/ 2389249259Sdim 2390249259SdimLLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name) { 2391249259Sdim return wrap(unwrap(B)->CreatePHI(unwrap(Ty), 0, Name)); 2392249259Sdim} 2393249259Sdim 2394249259SdimLLVMValueRef LLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, 2395249259Sdim LLVMValueRef *Args, unsigned NumArgs, 2396249259Sdim const char *Name) { 2397249259Sdim return wrap(unwrap(B)->CreateCall(unwrap(Fn), 2398249259Sdim makeArrayRef(unwrap(Args), NumArgs), 2399249259Sdim Name)); 2400249259Sdim} 2401249259Sdim 2402249259SdimLLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If, 2403249259Sdim LLVMValueRef Then, LLVMValueRef Else, 2404249259Sdim const char *Name) { 2405249259Sdim return wrap(unwrap(B)->CreateSelect(unwrap(If), unwrap(Then), unwrap(Else), 2406249259Sdim Name)); 2407249259Sdim} 2408249259Sdim 2409249259SdimLLVMValueRef LLVMBuildVAArg(LLVMBuilderRef B, LLVMValueRef List, 2410249259Sdim LLVMTypeRef Ty, const char *Name) { 2411249259Sdim return wrap(unwrap(B)->CreateVAArg(unwrap(List), unwrap(Ty), Name)); 2412249259Sdim} 2413249259Sdim 2414249259SdimLLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef B, LLVMValueRef VecVal, 2415249259Sdim LLVMValueRef Index, const char *Name) { 2416249259Sdim return wrap(unwrap(B)->CreateExtractElement(unwrap(VecVal), unwrap(Index), 2417249259Sdim Name)); 2418249259Sdim} 2419249259Sdim 2420249259SdimLLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef B, LLVMValueRef VecVal, 2421249259Sdim LLVMValueRef EltVal, LLVMValueRef Index, 2422249259Sdim const char *Name) { 2423249259Sdim return wrap(unwrap(B)->CreateInsertElement(unwrap(VecVal), unwrap(EltVal), 2424249259Sdim unwrap(Index), Name)); 2425249259Sdim} 2426249259Sdim 2427249259SdimLLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef B, LLVMValueRef V1, 2428249259Sdim LLVMValueRef V2, LLVMValueRef Mask, 2429249259Sdim const char *Name) { 2430249259Sdim return wrap(unwrap(B)->CreateShuffleVector(unwrap(V1), unwrap(V2), 2431249259Sdim unwrap(Mask), Name)); 2432249259Sdim} 2433249259Sdim 2434249259SdimLLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef B, LLVMValueRef AggVal, 2435249259Sdim unsigned Index, const char *Name) { 2436249259Sdim return wrap(unwrap(B)->CreateExtractValue(unwrap(AggVal), Index, Name)); 2437249259Sdim} 2438249259Sdim 2439249259SdimLLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef B, LLVMValueRef AggVal, 2440249259Sdim LLVMValueRef EltVal, unsigned Index, 2441249259Sdim const char *Name) { 2442249259Sdim return wrap(unwrap(B)->CreateInsertValue(unwrap(AggVal), unwrap(EltVal), 2443249259Sdim Index, Name)); 2444249259Sdim} 2445249259Sdim 2446249259SdimLLVMValueRef LLVMBuildIsNull(LLVMBuilderRef B, LLVMValueRef Val, 2447249259Sdim const char *Name) { 2448249259Sdim return wrap(unwrap(B)->CreateIsNull(unwrap(Val), Name)); 2449249259Sdim} 2450249259Sdim 2451249259SdimLLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef B, LLVMValueRef Val, 2452249259Sdim const char *Name) { 2453249259Sdim return wrap(unwrap(B)->CreateIsNotNull(unwrap(Val), Name)); 2454249259Sdim} 2455249259Sdim 2456249259SdimLLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef B, LLVMValueRef LHS, 2457249259Sdim LLVMValueRef RHS, const char *Name) { 2458249259Sdim return wrap(unwrap(B)->CreatePtrDiff(unwrap(LHS), unwrap(RHS), Name)); 2459249259Sdim} 2460249259Sdim 2461263509SdimLLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B,LLVMAtomicRMWBinOp op, 2462263509Sdim LLVMValueRef PTR, LLVMValueRef Val, 2463263509Sdim LLVMAtomicOrdering ordering, 2464252723Sdim LLVMBool singleThread) { 2465252723Sdim AtomicRMWInst::BinOp intop; 2466252723Sdim switch (op) { 2467252723Sdim case LLVMAtomicRMWBinOpXchg: intop = AtomicRMWInst::Xchg; break; 2468252723Sdim case LLVMAtomicRMWBinOpAdd: intop = AtomicRMWInst::Add; break; 2469252723Sdim case LLVMAtomicRMWBinOpSub: intop = AtomicRMWInst::Sub; break; 2470252723Sdim case LLVMAtomicRMWBinOpAnd: intop = AtomicRMWInst::And; break; 2471252723Sdim case LLVMAtomicRMWBinOpNand: intop = AtomicRMWInst::Nand; break; 2472252723Sdim case LLVMAtomicRMWBinOpOr: intop = AtomicRMWInst::Or; break; 2473252723Sdim case LLVMAtomicRMWBinOpXor: intop = AtomicRMWInst::Xor; break; 2474252723Sdim case LLVMAtomicRMWBinOpMax: intop = AtomicRMWInst::Max; break; 2475252723Sdim case LLVMAtomicRMWBinOpMin: intop = AtomicRMWInst::Min; break; 2476252723Sdim case LLVMAtomicRMWBinOpUMax: intop = AtomicRMWInst::UMax; break; 2477252723Sdim case LLVMAtomicRMWBinOpUMin: intop = AtomicRMWInst::UMin; break; 2478252723Sdim } 2479252723Sdim AtomicOrdering intordering; 2480252723Sdim switch (ordering) { 2481252723Sdim case LLVMAtomicOrderingNotAtomic: intordering = NotAtomic; break; 2482252723Sdim case LLVMAtomicOrderingUnordered: intordering = Unordered; break; 2483252723Sdim case LLVMAtomicOrderingMonotonic: intordering = Monotonic; break; 2484252723Sdim case LLVMAtomicOrderingAcquire: intordering = Acquire; break; 2485252723Sdim case LLVMAtomicOrderingRelease: intordering = Release; break; 2486263509Sdim case LLVMAtomicOrderingAcquireRelease: 2487263509Sdim intordering = AcquireRelease; 2488252723Sdim break; 2489263509Sdim case LLVMAtomicOrderingSequentiallyConsistent: 2490263509Sdim intordering = SequentiallyConsistent; 2491252723Sdim break; 2492252723Sdim } 2493263509Sdim return wrap(unwrap(B)->CreateAtomicRMW(intop, unwrap(PTR), unwrap(Val), 2494252723Sdim intordering, singleThread ? SingleThread : CrossThread)); 2495252723Sdim} 2496249259Sdim 2497252723Sdim 2498249259Sdim/*===-- Module providers --------------------------------------------------===*/ 2499249259Sdim 2500249259SdimLLVMModuleProviderRef 2501249259SdimLLVMCreateModuleProviderForExistingModule(LLVMModuleRef M) { 2502249259Sdim return reinterpret_cast<LLVMModuleProviderRef>(M); 2503249259Sdim} 2504249259Sdim 2505249259Sdimvoid LLVMDisposeModuleProvider(LLVMModuleProviderRef MP) { 2506249259Sdim delete unwrap(MP); 2507249259Sdim} 2508249259Sdim 2509249259Sdim 2510249259Sdim/*===-- Memory buffers ----------------------------------------------------===*/ 2511249259Sdim 2512249259SdimLLVMBool LLVMCreateMemoryBufferWithContentsOfFile( 2513249259Sdim const char *Path, 2514249259Sdim LLVMMemoryBufferRef *OutMemBuf, 2515249259Sdim char **OutMessage) { 2516249259Sdim 2517249259Sdim OwningPtr<MemoryBuffer> MB; 2518249259Sdim error_code ec; 2519249259Sdim if (!(ec = MemoryBuffer::getFile(Path, MB))) { 2520249259Sdim *OutMemBuf = wrap(MB.take()); 2521249259Sdim return 0; 2522249259Sdim } 2523249259Sdim 2524249259Sdim *OutMessage = strdup(ec.message().c_str()); 2525249259Sdim return 1; 2526249259Sdim} 2527249259Sdim 2528249259SdimLLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, 2529249259Sdim char **OutMessage) { 2530249259Sdim OwningPtr<MemoryBuffer> MB; 2531249259Sdim error_code ec; 2532249259Sdim if (!(ec = MemoryBuffer::getSTDIN(MB))) { 2533249259Sdim *OutMemBuf = wrap(MB.take()); 2534249259Sdim return 0; 2535249259Sdim } 2536249259Sdim 2537249259Sdim *OutMessage = strdup(ec.message().c_str()); 2538249259Sdim return 1; 2539249259Sdim} 2540249259Sdim 2541249259SdimLLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange( 2542249259Sdim const char *InputData, 2543249259Sdim size_t InputDataLength, 2544249259Sdim const char *BufferName, 2545249259Sdim LLVMBool RequiresNullTerminator) { 2546249259Sdim 2547249259Sdim return wrap(MemoryBuffer::getMemBuffer( 2548249259Sdim StringRef(InputData, InputDataLength), 2549249259Sdim StringRef(BufferName), 2550249259Sdim RequiresNullTerminator)); 2551249259Sdim} 2552249259Sdim 2553249259SdimLLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy( 2554249259Sdim const char *InputData, 2555249259Sdim size_t InputDataLength, 2556249259Sdim const char *BufferName) { 2557249259Sdim 2558249259Sdim return wrap(MemoryBuffer::getMemBufferCopy( 2559249259Sdim StringRef(InputData, InputDataLength), 2560249259Sdim StringRef(BufferName))); 2561249259Sdim} 2562249259Sdim 2563252723Sdimconst char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf) { 2564252723Sdim return unwrap(MemBuf)->getBufferStart(); 2565252723Sdim} 2566249259Sdim 2567252723Sdimsize_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf) { 2568252723Sdim return unwrap(MemBuf)->getBufferSize(); 2569252723Sdim} 2570252723Sdim 2571249259Sdimvoid LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf) { 2572249259Sdim delete unwrap(MemBuf); 2573249259Sdim} 2574249259Sdim 2575249259Sdim/*===-- Pass Registry -----------------------------------------------------===*/ 2576249259Sdim 2577249259SdimLLVMPassRegistryRef LLVMGetGlobalPassRegistry(void) { 2578249259Sdim return wrap(PassRegistry::getPassRegistry()); 2579249259Sdim} 2580249259Sdim 2581249259Sdim/*===-- Pass Manager ------------------------------------------------------===*/ 2582249259Sdim 2583249259SdimLLVMPassManagerRef LLVMCreatePassManager() { 2584249259Sdim return wrap(new PassManager()); 2585249259Sdim} 2586249259Sdim 2587249259SdimLLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M) { 2588249259Sdim return wrap(new FunctionPassManager(unwrap(M))); 2589249259Sdim} 2590249259Sdim 2591249259SdimLLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef P) { 2592249259Sdim return LLVMCreateFunctionPassManagerForModule( 2593249259Sdim reinterpret_cast<LLVMModuleRef>(P)); 2594249259Sdim} 2595249259Sdim 2596249259SdimLLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M) { 2597249259Sdim return unwrap<PassManager>(PM)->run(*unwrap(M)); 2598249259Sdim} 2599249259Sdim 2600249259SdimLLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM) { 2601249259Sdim return unwrap<FunctionPassManager>(FPM)->doInitialization(); 2602249259Sdim} 2603249259Sdim 2604249259SdimLLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F) { 2605249259Sdim return unwrap<FunctionPassManager>(FPM)->run(*unwrap<Function>(F)); 2606249259Sdim} 2607249259Sdim 2608249259SdimLLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM) { 2609249259Sdim return unwrap<FunctionPassManager>(FPM)->doFinalization(); 2610249259Sdim} 2611249259Sdim 2612249259Sdimvoid LLVMDisposePassManager(LLVMPassManagerRef PM) { 2613249259Sdim delete unwrap(PM); 2614249259Sdim} 2615249259Sdim 2616249259Sdim/*===-- Threading ------------------------------------------------------===*/ 2617249259Sdim 2618249259SdimLLVMBool LLVMStartMultithreaded() { 2619249259Sdim return llvm_start_multithreaded(); 2620249259Sdim} 2621249259Sdim 2622249259Sdimvoid LLVMStopMultithreaded() { 2623249259Sdim llvm_stop_multithreaded(); 2624249259Sdim} 2625249259Sdim 2626249259SdimLLVMBool LLVMIsMultithreaded() { 2627249259Sdim return llvm_is_multithreaded(); 2628249259Sdim} 2629