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 void LLVMInstructionEraseFromParent(LLVMValueRef Inst) {
1512   unwrap<Instruction>(Inst)->eraseFromParent();
1513 }
1514
1515 /*--.. Call and invoke instructions ........................................--*/
1516
1517 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr) {
1518   Value *V = unwrap(Instr);
1519   if (CallInst *CI = dyn_cast<CallInst>(V))
1520     return CI->getCallingConv();
1521   else if (InvokeInst *II = dyn_cast<InvokeInst>(V))
1522     return II->getCallingConv();
1523   llvm_unreachable("LLVMGetInstructionCallConv applies only to call and invoke!");
1524   return 0;
1525 }
1526
1527 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC) {
1528   Value *V = unwrap(Instr);
1529   if (CallInst *CI = dyn_cast<CallInst>(V))
1530     return CI->setCallingConv(static_cast<CallingConv::ID>(CC));
1531   else if (InvokeInst *II = dyn_cast<InvokeInst>(V))
1532     return II->setCallingConv(static_cast<CallingConv::ID>(CC));
1533   llvm_unreachable("LLVMSetInstructionCallConv applies only to call and invoke!");
1534 }
1535
1536 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index,
1537                            LLVMAttribute PA) {
1538   CallSite Call = CallSite(unwrap<Instruction>(Instr));
1539   Call.setAttributes(
1540     Call.getAttributes().addAttr(index, PA));
1541 }
1542
1543 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
1544                               LLVMAttribute PA) {
1545   CallSite Call = CallSite(unwrap<Instruction>(Instr));
1546   Call.setAttributes(
1547     Call.getAttributes().removeAttr(index, PA));
1548 }
1549
1550 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
1551                                 unsigned align) {
1552   CallSite Call = CallSite(unwrap<Instruction>(Instr));
1553   Call.setAttributes(
1554     Call.getAttributes().addAttr(index,
1555         Attribute::constructAlignmentFromInt(align)));
1556 }
1557
1558 /*--.. Operations on call instructions (only) ..............................--*/
1559
1560 LLVMBool LLVMIsTailCall(LLVMValueRef Call) {
1561   return unwrap<CallInst>(Call)->isTailCall();
1562 }
1563
1564 void LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall) {
1565   unwrap<CallInst>(Call)->setTailCall(isTailCall);
1566 }
1567
1568 /*--.. Operations on switch instructions (only) ............................--*/
1569
1570 LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef Switch) {
1571   return wrap(unwrap<SwitchInst>(Switch)->getDefaultDest());
1572 }
1573
1574 /*--.. Operations on phi nodes .............................................--*/
1575
1576 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
1577                      LLVMBasicBlockRef *IncomingBlocks, unsigned Count) {
1578   PHINode *PhiVal = unwrap<PHINode>(PhiNode);
1579   for (unsigned I = 0; I != Count; ++I)
1580     PhiVal->addIncoming(unwrap(IncomingValues[I]), unwrap(IncomingBlocks[I]));
1581 }
1582
1583 unsigned LLVMCountIncoming(LLVMValueRef PhiNode) {
1584   return unwrap<PHINode>(PhiNode)->getNumIncomingValues();
1585 }
1586
1587 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index) {
1588   return wrap(unwrap<PHINode>(PhiNode)->getIncomingValue(Index));
1589 }
1590
1591 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index) {
1592   return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index));
1593 }
1594
1595
1596 /*===-- Instruction builders ----------------------------------------------===*/
1597
1598 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C) {
1599   return wrap(new IRBuilder<>(*unwrap(C)));
1600 }
1601
1602 LLVMBuilderRef LLVMCreateBuilder(void) {
1603   return LLVMCreateBuilderInContext(LLVMGetGlobalContext());
1604 }
1605
1606 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
1607                          LLVMValueRef Instr) {
1608   BasicBlock *BB = unwrap(Block);
1609   Instruction *I = Instr? unwrap<Instruction>(Instr) : (Instruction*) BB->end();
1610   unwrap(Builder)->SetInsertPoint(BB, I);
1611 }
1612
1613 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr) {
1614   Instruction *I = unwrap<Instruction>(Instr);
1615   unwrap(Builder)->SetInsertPoint(I->getParent(), I);
1616 }
1617
1618 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block) {
1619   BasicBlock *BB = unwrap(Block);
1620   unwrap(Builder)->SetInsertPoint(BB);
1621 }
1622
1623 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder) {
1624    return wrap(unwrap(Builder)->GetInsertBlock());
1625 }
1626
1627 void LLVMClearInsertionPosition(LLVMBuilderRef Builder) {
1628   unwrap(Builder)->ClearInsertionPoint();
1629 }
1630
1631 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr) {
1632   unwrap(Builder)->Insert(unwrap<Instruction>(Instr));
1633 }
1634
1635 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
1636                                    const char *Name) {
1637   unwrap(Builder)->Insert(unwrap<Instruction>(Instr), Name);
1638 }
1639
1640 void LLVMDisposeBuilder(LLVMBuilderRef Builder) {
1641   delete unwrap(Builder);
1642 }
1643
1644 /*--.. Metadata builders ...................................................--*/
1645
1646 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L) {
1647   MDNode *Loc = L ? unwrap<MDNode>(L) : NULL;
1648   unwrap(Builder)->SetCurrentDebugLocation(DebugLoc::getFromDILocation(Loc));
1649 }
1650
1651 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder) {
1652   return wrap(unwrap(Builder)->getCurrentDebugLocation()
1653               .getAsMDNode(unwrap(Builder)->getContext()));
1654 }
1655
1656 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst) {
1657   unwrap(Builder)->SetInstDebugLocation(unwrap<Instruction>(Inst));
1658 }
1659
1660
1661 /*--.. Instruction builders ................................................--*/
1662
1663 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef B) {
1664   return wrap(unwrap(B)->CreateRetVoid());
1665 }
1666
1667 LLVMValueRef LLVMBuildRet(LLVMBuilderRef B, LLVMValueRef V) {
1668   return wrap(unwrap(B)->CreateRet(unwrap(V)));
1669 }
1670
1671 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef B, LLVMValueRef *RetVals,
1672                                    unsigned N) {
1673   return wrap(unwrap(B)->CreateAggregateRet(unwrap(RetVals), N));
1674 }
1675
1676 LLVMValueRef LLVMBuildBr(LLVMBuilderRef B, LLVMBasicBlockRef Dest) {
1677   return wrap(unwrap(B)->CreateBr(unwrap(Dest)));
1678 }
1679
1680 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef B, LLVMValueRef If,
1681                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Else) {
1682   return wrap(unwrap(B)->CreateCondBr(unwrap(If), unwrap(Then), unwrap(Else)));
1683 }
1684
1685 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef B, LLVMValueRef V,
1686                              LLVMBasicBlockRef Else, unsigned NumCases) {
1687   return wrap(unwrap(B)->CreateSwitch(unwrap(V), unwrap(Else), NumCases));
1688 }
1689
1690 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
1691                                  unsigned NumDests) {
1692   return wrap(unwrap(B)->CreateIndirectBr(unwrap(Addr), NumDests));
1693 }
1694
1695 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn,
1696                              LLVMValueRef *Args, unsigned NumArgs,
1697                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
1698                              const char *Name) {
1699   return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch),
1700                                       makeArrayRef(unwrap(Args), NumArgs),
1701                                       Name));
1702 }
1703
1704 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
1705                                  LLVMValueRef PersFn, unsigned NumClauses,
1706                                  const char *Name) {
1707   return wrap(unwrap(B)->CreateLandingPad(unwrap(Ty),
1708                                           cast<Function>(unwrap(PersFn)),
1709                                           NumClauses, Name));
1710 }
1711
1712 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn) {
1713   return wrap(unwrap(B)->CreateResume(unwrap(Exn)));
1714 }
1715
1716 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) {
1717   return wrap(unwrap(B)->CreateUnreachable());
1718 }
1719
1720 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
1721                  LLVMBasicBlockRef Dest) {
1722   unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest));
1723 }
1724
1725 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest) {
1726   unwrap<IndirectBrInst>(IndirectBr)->addDestination(unwrap(Dest));
1727 }
1728
1729 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal) {
1730   unwrap<LandingPadInst>(LandingPad)->
1731     addClause(cast<Constant>(unwrap(ClauseVal)));
1732 }
1733
1734 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val) {
1735   unwrap<LandingPadInst>(LandingPad)->setCleanup(Val);
1736 }
1737
1738 /*--.. Arithmetic ..........................................................--*/
1739
1740 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1741                           const char *Name) {
1742   return wrap(unwrap(B)->CreateAdd(unwrap(LHS), unwrap(RHS), Name));
1743 }
1744
1745 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1746                           const char *Name) {
1747   return wrap(unwrap(B)->CreateNSWAdd(unwrap(LHS), unwrap(RHS), Name));
1748 }
1749
1750 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1751                           const char *Name) {
1752   return wrap(unwrap(B)->CreateNUWAdd(unwrap(LHS), unwrap(RHS), Name));
1753 }
1754
1755 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1756                           const char *Name) {
1757   return wrap(unwrap(B)->CreateFAdd(unwrap(LHS), unwrap(RHS), Name));
1758 }
1759
1760 LLVMValueRef LLVMBuildSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1761                           const char *Name) {
1762   return wrap(unwrap(B)->CreateSub(unwrap(LHS), unwrap(RHS), Name));
1763 }
1764
1765 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1766                           const char *Name) {
1767   return wrap(unwrap(B)->CreateNSWSub(unwrap(LHS), unwrap(RHS), Name));
1768 }
1769
1770 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1771                           const char *Name) {
1772   return wrap(unwrap(B)->CreateNUWSub(unwrap(LHS), unwrap(RHS), Name));
1773 }
1774
1775 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1776                           const char *Name) {
1777   return wrap(unwrap(B)->CreateFSub(unwrap(LHS), unwrap(RHS), Name));
1778 }
1779
1780 LLVMValueRef LLVMBuildMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1781                           const char *Name) {
1782   return wrap(unwrap(B)->CreateMul(unwrap(LHS), unwrap(RHS), Name));
1783 }
1784
1785 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1786                           const char *Name) {
1787   return wrap(unwrap(B)->CreateNSWMul(unwrap(LHS), unwrap(RHS), Name));
1788 }
1789
1790 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1791                           const char *Name) {
1792   return wrap(unwrap(B)->CreateNUWMul(unwrap(LHS), unwrap(RHS), Name));
1793 }
1794
1795 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1796                           const char *Name) {
1797   return wrap(unwrap(B)->CreateFMul(unwrap(LHS), unwrap(RHS), Name));
1798 }
1799
1800 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1801                            const char *Name) {
1802   return wrap(unwrap(B)->CreateUDiv(unwrap(LHS), unwrap(RHS), Name));
1803 }
1804
1805 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1806                            const char *Name) {
1807   return wrap(unwrap(B)->CreateSDiv(unwrap(LHS), unwrap(RHS), Name));
1808 }
1809
1810 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef B, LLVMValueRef LHS,
1811                                 LLVMValueRef RHS, const char *Name) {
1812   return wrap(unwrap(B)->CreateExactSDiv(unwrap(LHS), unwrap(RHS), Name));
1813 }
1814
1815 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1816                            const char *Name) {
1817   return wrap(unwrap(B)->CreateFDiv(unwrap(LHS), unwrap(RHS), Name));
1818 }
1819
1820 LLVMValueRef LLVMBuildURem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1821                            const char *Name) {
1822   return wrap(unwrap(B)->CreateURem(unwrap(LHS), unwrap(RHS), Name));
1823 }
1824
1825 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1826                            const char *Name) {
1827   return wrap(unwrap(B)->CreateSRem(unwrap(LHS), unwrap(RHS), Name));
1828 }
1829
1830 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1831                            const char *Name) {
1832   return wrap(unwrap(B)->CreateFRem(unwrap(LHS), unwrap(RHS), Name));
1833 }
1834
1835 LLVMValueRef LLVMBuildShl(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1836                           const char *Name) {
1837   return wrap(unwrap(B)->CreateShl(unwrap(LHS), unwrap(RHS), Name));
1838 }
1839
1840 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1841                            const char *Name) {
1842   return wrap(unwrap(B)->CreateLShr(unwrap(LHS), unwrap(RHS), Name));
1843 }
1844
1845 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1846                            const char *Name) {
1847   return wrap(unwrap(B)->CreateAShr(unwrap(LHS), unwrap(RHS), Name));
1848 }
1849
1850 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1851                           const char *Name) {
1852   return wrap(unwrap(B)->CreateAnd(unwrap(LHS), unwrap(RHS), Name));
1853 }
1854
1855 LLVMValueRef LLVMBuildOr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1856                          const char *Name) {
1857   return wrap(unwrap(B)->CreateOr(unwrap(LHS), unwrap(RHS), Name));
1858 }
1859
1860 LLVMValueRef LLVMBuildXor(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
1861                           const char *Name) {
1862   return wrap(unwrap(B)->CreateXor(unwrap(LHS), unwrap(RHS), Name));
1863 }
1864
1865 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
1866                             LLVMValueRef LHS, LLVMValueRef RHS,
1867                             const char *Name) {
1868   return wrap(unwrap(B)->CreateBinOp(Instruction::BinaryOps(Op), unwrap(LHS),
1869                                      unwrap(RHS), Name));
1870 }
1871
1872 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
1873   return wrap(unwrap(B)->CreateNeg(unwrap(V), Name));
1874 }
1875
1876 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
1877                              const char *Name) {
1878   return wrap(unwrap(B)->CreateNSWNeg(unwrap(V), Name));
1879 }
1880
1881 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
1882                              const char *Name) {
1883   return wrap(unwrap(B)->CreateNUWNeg(unwrap(V), Name));
1884 }
1885
1886 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
1887   return wrap(unwrap(B)->CreateFNeg(unwrap(V), Name));
1888 }
1889
1890 LLVMValueRef LLVMBuildNot(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
1891   return wrap(unwrap(B)->CreateNot(unwrap(V), Name));
1892 }
1893
1894 /*--.. Memory ..............................................................--*/
1895
1896 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
1897                              const char *Name) {
1898   Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
1899   Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty));
1900   AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy);
1901   Instruction* Malloc = CallInst::CreateMalloc(unwrap(B)->GetInsertBlock(),
1902                                                ITy, unwrap(Ty), AllocSize,
1903                                                0, 0, "");
1904   return wrap(unwrap(B)->Insert(Malloc, Twine(Name)));
1905 }
1906
1907 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
1908                                   LLVMValueRef Val, const char *Name) {
1909   Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
1910   Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty));
1911   AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy);
1912   Instruction* Malloc = CallInst::CreateMalloc(unwrap(B)->GetInsertBlock(),
1913                                                ITy, unwrap(Ty), AllocSize,
1914                                                unwrap(Val), 0, "");
1915   return wrap(unwrap(B)->Insert(Malloc, Twine(Name)));
1916 }
1917
1918 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
1919                              const char *Name) {
1920   return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), 0, Name));
1921 }
1922
1923 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
1924                                   LLVMValueRef Val, const char *Name) {
1925   return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), unwrap(Val), Name));
1926 }
1927
1928 LLVMValueRef LLVMBuildFree(LLVMBuilderRef B, LLVMValueRef PointerVal) {
1929   return wrap(unwrap(B)->Insert(
1930      CallInst::CreateFree(unwrap(PointerVal), unwrap(B)->GetInsertBlock())));
1931 }
1932
1933
1934 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef B, LLVMValueRef PointerVal,
1935                            const char *Name) {
1936   return wrap(unwrap(B)->CreateLoad(unwrap(PointerVal), Name));
1937 }
1938
1939 LLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val,
1940                             LLVMValueRef PointerVal) {
1941   return wrap(unwrap(B)->CreateStore(unwrap(Val), unwrap(PointerVal)));
1942 }
1943
1944 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
1945                           LLVMValueRef *Indices, unsigned NumIndices,
1946                           const char *Name) {
1947   ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
1948   return wrap(unwrap(B)->CreateGEP(unwrap(Pointer), IdxList, Name));
1949 }
1950
1951 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
1952                                   LLVMValueRef *Indices, unsigned NumIndices,
1953                                   const char *Name) {
1954   ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
1955   return wrap(unwrap(B)->CreateInBoundsGEP(unwrap(Pointer), IdxList, Name));
1956 }
1957
1958 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
1959                                 unsigned Idx, const char *Name) {
1960   return wrap(unwrap(B)->CreateStructGEP(unwrap(Pointer), Idx, Name));
1961 }
1962
1963 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
1964                                    const char *Name) {
1965   return wrap(unwrap(B)->CreateGlobalString(Str, Name));
1966 }
1967
1968 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
1969                                       const char *Name) {
1970   return wrap(unwrap(B)->CreateGlobalStringPtr(Str, Name));
1971 }
1972
1973 /*--.. Casts ...............................................................--*/
1974
1975 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef B, LLVMValueRef Val,
1976                             LLVMTypeRef DestTy, const char *Name) {
1977   return wrap(unwrap(B)->CreateTrunc(unwrap(Val), unwrap(DestTy), Name));
1978 }
1979
1980 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef B, LLVMValueRef Val,
1981                            LLVMTypeRef DestTy, const char *Name) {
1982   return wrap(unwrap(B)->CreateZExt(unwrap(Val), unwrap(DestTy), Name));
1983 }
1984
1985 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef B, LLVMValueRef Val,
1986                            LLVMTypeRef DestTy, const char *Name) {
1987   return wrap(unwrap(B)->CreateSExt(unwrap(Val), unwrap(DestTy), Name));
1988 }
1989
1990 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef B, LLVMValueRef Val,
1991                              LLVMTypeRef DestTy, const char *Name) {
1992   return wrap(unwrap(B)->CreateFPToUI(unwrap(Val), unwrap(DestTy), Name));
1993 }
1994
1995 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef B, LLVMValueRef Val,
1996                              LLVMTypeRef DestTy, const char *Name) {
1997   return wrap(unwrap(B)->CreateFPToSI(unwrap(Val), unwrap(DestTy), Name));
1998 }
1999
2000 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef B, LLVMValueRef Val,
2001                              LLVMTypeRef DestTy, const char *Name) {
2002   return wrap(unwrap(B)->CreateUIToFP(unwrap(Val), unwrap(DestTy), Name));
2003 }
2004
2005 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef B, LLVMValueRef Val,
2006                              LLVMTypeRef DestTy, const char *Name) {
2007   return wrap(unwrap(B)->CreateSIToFP(unwrap(Val), unwrap(DestTy), Name));
2008 }
2009
2010 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef B, LLVMValueRef Val,
2011                               LLVMTypeRef DestTy, const char *Name) {
2012   return wrap(unwrap(B)->CreateFPTrunc(unwrap(Val), unwrap(DestTy), Name));
2013 }
2014
2015 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef B, LLVMValueRef Val,
2016                             LLVMTypeRef DestTy, const char *Name) {
2017   return wrap(unwrap(B)->CreateFPExt(unwrap(Val), unwrap(DestTy), Name));
2018 }
2019
2020 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef B, LLVMValueRef Val,
2021                                LLVMTypeRef DestTy, const char *Name) {
2022   return wrap(unwrap(B)->CreatePtrToInt(unwrap(Val), unwrap(DestTy), Name));
2023 }
2024
2025 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef B, LLVMValueRef Val,
2026                                LLVMTypeRef DestTy, const char *Name) {
2027   return wrap(unwrap(B)->CreateIntToPtr(unwrap(Val), unwrap(DestTy), Name));
2028 }
2029
2030 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef B, LLVMValueRef Val,
2031                               LLVMTypeRef DestTy, const char *Name) {
2032   return wrap(unwrap(B)->CreateBitCast(unwrap(Val), unwrap(DestTy), Name));
2033 }
2034
2035 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val,
2036                                     LLVMTypeRef DestTy, const char *Name) {
2037   return wrap(unwrap(B)->CreateZExtOrBitCast(unwrap(Val), unwrap(DestTy),
2038                                              Name));
2039 }
2040
2041 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val,
2042                                     LLVMTypeRef DestTy, const char *Name) {
2043   return wrap(unwrap(B)->CreateSExtOrBitCast(unwrap(Val), unwrap(DestTy),
2044                                              Name));
2045 }
2046
2047 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef B, LLVMValueRef Val,
2048                                      LLVMTypeRef DestTy, const char *Name) {
2049   return wrap(unwrap(B)->CreateTruncOrBitCast(unwrap(Val), unwrap(DestTy),
2050                                               Name));
2051 }
2052
2053 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
2054                            LLVMTypeRef DestTy, const char *Name) {
2055   return wrap(unwrap(B)->CreateCast(Instruction::CastOps(Op), unwrap(Val),
2056                                     unwrap(DestTy), Name));
2057 }
2058
2059 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef B, LLVMValueRef Val,
2060                                   LLVMTypeRef DestTy, const char *Name) {
2061   return wrap(unwrap(B)->CreatePointerCast(unwrap(Val), unwrap(DestTy), Name));
2062 }
2063
2064 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef B, LLVMValueRef Val,
2065                               LLVMTypeRef DestTy, const char *Name) {
2066   return wrap(unwrap(B)->CreateIntCast(unwrap(Val), unwrap(DestTy),
2067                                        /*isSigned*/true, Name));
2068 }
2069
2070 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef B, LLVMValueRef Val,
2071                              LLVMTypeRef DestTy, const char *Name) {
2072   return wrap(unwrap(B)->CreateFPCast(unwrap(Val), unwrap(DestTy), Name));
2073 }
2074
2075 /*--.. Comparisons .........................................................--*/
2076
2077 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef B, LLVMIntPredicate Op,
2078                            LLVMValueRef LHS, LLVMValueRef RHS,
2079                            const char *Name) {
2080   return wrap(unwrap(B)->CreateICmp(static_cast<ICmpInst::Predicate>(Op),
2081                                     unwrap(LHS), unwrap(RHS), Name));
2082 }
2083
2084 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef B, LLVMRealPredicate Op,
2085                            LLVMValueRef LHS, LLVMValueRef RHS,
2086                            const char *Name) {
2087   return wrap(unwrap(B)->CreateFCmp(static_cast<FCmpInst::Predicate>(Op),
2088                                     unwrap(LHS), unwrap(RHS), Name));
2089 }
2090
2091 /*--.. Miscellaneous instructions ..........................................--*/
2092
2093 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name) {
2094   return wrap(unwrap(B)->CreatePHI(unwrap(Ty), 0, Name));
2095 }
2096
2097 LLVMValueRef LLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn,
2098                            LLVMValueRef *Args, unsigned NumArgs,
2099                            const char *Name) {
2100   return wrap(unwrap(B)->CreateCall(unwrap(Fn),
2101                                     makeArrayRef(unwrap(Args), NumArgs),
2102                                     Name));
2103 }
2104
2105 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If,
2106                              LLVMValueRef Then, LLVMValueRef Else,
2107                              const char *Name) {
2108   return wrap(unwrap(B)->CreateSelect(unwrap(If), unwrap(Then), unwrap(Else),
2109                                       Name));
2110 }
2111
2112 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef B, LLVMValueRef List,
2113                             LLVMTypeRef Ty, const char *Name) {
2114   return wrap(unwrap(B)->CreateVAArg(unwrap(List), unwrap(Ty), Name));
2115 }
2116
2117 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef B, LLVMValueRef VecVal,
2118                                       LLVMValueRef Index, const char *Name) {
2119   return wrap(unwrap(B)->CreateExtractElement(unwrap(VecVal), unwrap(Index),
2120                                               Name));
2121 }
2122
2123 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef B, LLVMValueRef VecVal,
2124                                     LLVMValueRef EltVal, LLVMValueRef Index,
2125                                     const char *Name) {
2126   return wrap(unwrap(B)->CreateInsertElement(unwrap(VecVal), unwrap(EltVal),
2127                                              unwrap(Index), Name));
2128 }
2129
2130 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef B, LLVMValueRef V1,
2131                                     LLVMValueRef V2, LLVMValueRef Mask,
2132                                     const char *Name) {
2133   return wrap(unwrap(B)->CreateShuffleVector(unwrap(V1), unwrap(V2),
2134                                              unwrap(Mask), Name));
2135 }
2136
2137 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef B, LLVMValueRef AggVal,
2138                                    unsigned Index, const char *Name) {
2139   return wrap(unwrap(B)->CreateExtractValue(unwrap(AggVal), Index, Name));
2140 }
2141
2142 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef B, LLVMValueRef AggVal,
2143                                   LLVMValueRef EltVal, unsigned Index,
2144                                   const char *Name) {
2145   return wrap(unwrap(B)->CreateInsertValue(unwrap(AggVal), unwrap(EltVal),
2146                                            Index, Name));
2147 }
2148
2149 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef B, LLVMValueRef Val,
2150                              const char *Name) {
2151   return wrap(unwrap(B)->CreateIsNull(unwrap(Val), Name));
2152 }
2153
2154 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef B, LLVMValueRef Val,
2155                                 const char *Name) {
2156   return wrap(unwrap(B)->CreateIsNotNull(unwrap(Val), Name));
2157 }
2158
2159 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef B, LLVMValueRef LHS,
2160                               LLVMValueRef RHS, const char *Name) {
2161   return wrap(unwrap(B)->CreatePtrDiff(unwrap(LHS), unwrap(RHS), Name));
2162 }
2163
2164
2165 /*===-- Module providers --------------------------------------------------===*/
2166
2167 LLVMModuleProviderRef
2168 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M) {
2169   return reinterpret_cast<LLVMModuleProviderRef>(M);
2170 }
2171
2172 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP) {
2173   delete unwrap(MP);
2174 }
2175
2176
2177 /*===-- Memory buffers ----------------------------------------------------===*/
2178
2179 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(
2180     const char *Path,
2181     LLVMMemoryBufferRef *OutMemBuf,
2182     char **OutMessage) {
2183
2184   OwningPtr<MemoryBuffer> MB;
2185   error_code ec;
2186   if (!(ec = MemoryBuffer::getFile(Path, MB))) {
2187     *OutMemBuf = wrap(MB.take());
2188     return 0;
2189   }
2190
2191   *OutMessage = strdup(ec.message().c_str());
2192   return 1;
2193 }
2194
2195 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
2196                                          char **OutMessage) {
2197   OwningPtr<MemoryBuffer> MB;
2198   error_code ec;
2199   if (!(ec = MemoryBuffer::getSTDIN(MB))) {
2200     *OutMemBuf = wrap(MB.take());
2201     return 0;
2202   }
2203
2204   *OutMessage = strdup(ec.message().c_str());
2205   return 1;
2206 }
2207
2208 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf) {
2209   delete unwrap(MemBuf);
2210 }
2211
2212 /*===-- Pass Registry -----------------------------------------------------===*/
2213
2214 LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void) {
2215   return wrap(PassRegistry::getPassRegistry());
2216 }
2217
2218 /*===-- Pass Manager ------------------------------------------------------===*/
2219
2220 LLVMPassManagerRef LLVMCreatePassManager() {
2221   return wrap(new PassManager());
2222 }
2223
2224 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M) {
2225   return wrap(new FunctionPassManager(unwrap(M)));
2226 }
2227
2228 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef P) {
2229   return LLVMCreateFunctionPassManagerForModule(
2230                                             reinterpret_cast<LLVMModuleRef>(P));
2231 }
2232
2233 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M) {
2234   return unwrap<PassManager>(PM)->run(*unwrap(M));
2235 }
2236
2237 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM) {
2238   return unwrap<FunctionPassManager>(FPM)->doInitialization();
2239 }
2240
2241 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F) {
2242   return unwrap<FunctionPassManager>(FPM)->run(*unwrap<Function>(F));
2243 }
2244
2245 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM) {
2246   return unwrap<FunctionPassManager>(FPM)->doFinalization();
2247 }
2248
2249 void LLVMDisposePassManager(LLVMPassManagerRef PM) {
2250   delete unwrap(PM);
2251 }