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