contrib/llvm/lib/VMCore/Core.cpp

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