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 C bindings for libLLVMCore.a, which implements
  11 // 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/TypeSymbolTable.h"
  21 #include "llvm/ModuleProvider.h"
  22 #include "llvm/Support/MemoryBuffer.h"
  23 #include <cassert>
  24 #include <cstdlib>
  25 #include <cstring>
  26
  27 using namespace llvm;
  28
  29
  30 /*===-- Error handling ----------------------------------------------------===*/
  31
  32 void LLVMDisposeMessage(char *Message) {
  33   free(Message);
  34 }
  35
  36
  37 /*===-- Operations on modules ---------------------------------------------===*/
  38
  39 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID) {
  40   return wrap(new Module(ModuleID));
  41 }
  42
  43 void LLVMDisposeModule(LLVMModuleRef M) {
  44   delete unwrap(M);
  45 }
  46
  47 /*--.. Data layout .........................................................--*/
  48 const char * LLVMGetDataLayout(LLVMModuleRef M) {
  49   return unwrap(M)->getDataLayout().c_str();
  50 }
  51
  52 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple) {
  53   unwrap(M)->setDataLayout(Triple);
  54 }
  55
  56 /*--.. Target triple .......................................................--*/
  57 const char * LLVMGetTarget(LLVMModuleRef M) {
  58   return unwrap(M)->getTargetTriple().c_str();
  59 }
  60
  61 void LLVMSetTarget(LLVMModuleRef M, const char *Triple) {
  62   unwrap(M)->setTargetTriple(Triple);
  63 }
  64
  65 /*--.. Type names ..........................................................--*/
  66 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty) {
  67   return unwrap(M)->addTypeName(Name, unwrap(Ty));
  68 }
  69
  70 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name) {
  71   std::string N(Name);
  72
  73   TypeSymbolTable &TST = unwrap(M)->getTypeSymbolTable();
  74   for (TypeSymbolTable::iterator I = TST.begin(), E = TST.end(); I != E; ++I)
  75     if (I->first == N)
  76       TST.remove(I);
  77 }
  78
  79 void LLVMDumpModule(LLVMModuleRef M) {
  80   unwrap(M)->dump();
  81 }
  82
  83
  84 /*===-- Operations on types -----------------------------------------------===*/
  85
  86 /*--.. Operations on all types (mostly) ....................................--*/
  87
  88 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) {
  89   return static_cast<LLVMTypeKind>(unwrap(Ty)->getTypeID());
  90 }
  91
  92 void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType){
  93   DerivedType *Ty = unwrap<DerivedType>(AbstractType);
  94   Ty->refineAbstractTypeTo(unwrap(ConcreteType));
  95 }
  96
  97 /*--.. Operations on integer types .........................................--*/
  98
  99 LLVMTypeRef LLVMInt1Type()  { return (LLVMTypeRef) Type::Int1Ty;  }
 100 LLVMTypeRef LLVMInt8Type()  { return (LLVMTypeRef) Type::Int8Ty;  }
 101 LLVMTypeRef LLVMInt16Type() { return (LLVMTypeRef) Type::Int16Ty; }
 102 LLVMTypeRef LLVMInt32Type() { return (LLVMTypeRef) Type::Int32Ty; }
 103 LLVMTypeRef LLVMInt64Type() { return (LLVMTypeRef) Type::Int64Ty; }
 104
 105 LLVMTypeRef LLVMIntType(unsigned NumBits) {
 106   return wrap(IntegerType::get(NumBits));
 107 }
 108
 109 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy) {
 110   return unwrap<IntegerType>(IntegerTy)->getBitWidth();
 111 }
 112
 113 /*--.. Operations on real types ............................................--*/
 114
 115 LLVMTypeRef LLVMFloatType()    { return (LLVMTypeRef) Type::FloatTy;     }
 116 LLVMTypeRef LLVMDoubleType()   { return (LLVMTypeRef) Type::DoubleTy;    }
 117 LLVMTypeRef LLVMX86FP80Type()  { return (LLVMTypeRef) Type::X86_FP80Ty;  }
 118 LLVMTypeRef LLVMFP128Type()    { return (LLVMTypeRef) Type::FP128Ty;     }
 119 LLVMTypeRef LLVMPPCFP128Type() { return (LLVMTypeRef) Type::PPC_FP128Ty; }
 120
 121 /*--.. Operations on function types ........................................--*/
 122
 123 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
 124                              LLVMTypeRef *ParamTypes, unsigned ParamCount,
 125                              int IsVarArg) {
 126   std::vector<const Type*> Tys;
 127   for (LLVMTypeRef *I = ParamTypes, *E = ParamTypes + ParamCount; I != E; ++I)
 128     Tys.push_back(unwrap(*I));
 129
 130   return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0));
 131 }
 132
 133 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) {
 134   return unwrap<FunctionType>(FunctionTy)->isVarArg();
 135 }
 136
 137 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy) {
 138   return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType());
 139 }
 140
 141 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy) {
 142   return unwrap<FunctionType>(FunctionTy)->getNumParams();
 143 }
 144
 145 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest) {
 146   FunctionType *Ty = unwrap<FunctionType>(FunctionTy);
 147   for (FunctionType::param_iterator I = Ty->param_begin(),
 148                                     E = Ty->param_end(); I != E; ++I)
 149     *Dest++ = wrap(*I);
 150 }
 151
 152 /*--.. Operations on struct types ..........................................--*/
 153
 154 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes,
 155                            unsigned ElementCount, int Packed) {
 156   std::vector<const Type*> Tys;
 157   for (LLVMTypeRef *I = ElementTypes,
 158                    *E = ElementTypes + ElementCount; I != E; ++I)
 159     Tys.push_back(unwrap(*I));
 160
 161   return wrap(StructType::get(Tys, Packed != 0));
 162 }
 163
 164 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy) {
 165   return unwrap<StructType>(StructTy)->getNumElements();
 166 }
 167
 168 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest) {
 169   StructType *Ty = unwrap<StructType>(StructTy);
 170   for (FunctionType::param_iterator I = Ty->element_begin(),
 171                                     E = Ty->element_end(); I != E; ++I)
 172     *Dest++ = wrap(*I);
 173 }
 174
 175 int LLVMIsPackedStruct(LLVMTypeRef StructTy) {
 176   return unwrap<StructType>(StructTy)->isPacked();
 177 }
 178
 179 /*--.. Operations on array, pointer, and vector types (sequence types) .....--*/
 180
 181 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount) {
 182   return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
 183 }
 184
 185 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace) {
 186   return wrap(PointerType::get(unwrap(ElementType), AddressSpace));
 187 }
 188
 189 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) {
 190   return wrap(VectorType::get(unwrap(ElementType), ElementCount));
 191 }
 192
 193 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty) {
 194   return wrap(unwrap<SequentialType>(Ty)->getElementType());
 195 }
 196
 197 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) {
 198   return unwrap<ArrayType>(ArrayTy)->getNumElements();
 199 }
 200
 201 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy) {
 202   return unwrap<PointerType>(PointerTy)->getAddressSpace();
 203 }
 204
 205 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) {
 206   return unwrap<VectorType>(VectorTy)->getNumElements();
 207 }
 208
 209 /*--.. Operations on other types ...........................................--*/
 210
 211 LLVMTypeRef LLVMVoidType()  { return (LLVMTypeRef) Type::VoidTy;  }
 212 LLVMTypeRef LLVMLabelType() { return (LLVMTypeRef) Type::LabelTy; }
 213
 214 LLVMTypeRef LLVMOpaqueType() {
 215   return wrap(llvm::OpaqueType::get());
 216 }
 217
 218 /*--.. Operations on type handles ..........................................--*/
 219
 220 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy) {
 221   return wrap(new PATypeHolder(unwrap(PotentiallyAbstractTy)));
 222 }
 223
 224 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle) {
 225   delete unwrap(TypeHandle);
 226 }
 227
 228 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle) {
 229   return wrap(unwrap(TypeHandle)->get());
 230 }
 231
 232 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy) {
 233   unwrap<DerivedType>(AbstractTy)->refineAbstractTypeTo(unwrap(ConcreteTy));
 234 }
 235
 236
 237 /*===-- Operations on values ----------------------------------------------===*/
 238
 239 /*--.. Operations on all values ............................................--*/
 240
 241 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val) {
 242   return wrap(unwrap(Val)->getType());
 243 }
 244
 245 const char *LLVMGetValueName(LLVMValueRef Val) {
 246   return unwrap(Val)->getNameStart();
 247 }
 248
 249 void LLVMSetValueName(LLVMValueRef Val, const char *Name) {
 250   unwrap(Val)->setName(Name);
 251 }
 252
 253 void LLVMDumpValue(LLVMValueRef Val) {
 254   unwrap(Val)->dump();
 255 }
 256
 257 /*--.. Operations on constants of any type .................................--*/
 258
 259 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty) {
 260   return wrap(Constant::getNullValue(unwrap(Ty)));
 261 }
 262
 263 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty) {
 264   return wrap(Constant::getAllOnesValue(unwrap(Ty)));
 265 }
 266
 267 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) {
 268   return wrap(UndefValue::get(unwrap(Ty)));
 269 }
 270
 271 int LLVMIsConstant(LLVMValueRef Ty) {
 272   return isa<Constant>(unwrap(Ty));
 273 }
 274
 275 int LLVMIsNull(LLVMValueRef Val) {
 276   if (Constant *C = dyn_cast<Constant>(unwrap(Val)))
 277     return C->isNullValue();
 278   return false;
 279 }
 280
 281 int LLVMIsUndef(LLVMValueRef Val) {
 282   return isa<UndefValue>(unwrap(Val));
 283 }
 284
 285 /*--.. Operations on scalar constants ......................................--*/
 286
 287 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
 288                           int SignExtend) {
 289   return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0));
 290 }
 291
 292 static const fltSemantics &SemanticsForType(Type *Ty) {
 293   assert(Ty->isFloatingPoint() && "Type is not floating point!");
 294   if (Ty == Type::FloatTy)
 295     return APFloat::IEEEsingle;
 296   if (Ty == Type::DoubleTy)
 297     return APFloat::IEEEdouble;
 298   if (Ty == Type::X86_FP80Ty)
 299     return APFloat::x87DoubleExtended;
 300   if (Ty == Type::FP128Ty)
 301     return APFloat::IEEEquad;
 302   if (Ty == Type::PPC_FP128Ty)
 303     return APFloat::PPCDoubleDouble;
 304   return APFloat::Bogus;
 305 }
 306
 307 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N) {
 308   APFloat APN(N);
 309   APN.convert(SemanticsForType(unwrap(RealTy)), APFloat::rmNearestTiesToEven);
 310   return wrap(ConstantFP::get(unwrap(RealTy), APN));
 311 }
 312
 313 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text) {
 314   return wrap(ConstantFP::get(unwrap(RealTy),
 315                               APFloat(SemanticsForType(unwrap(RealTy)), Text)));
 316 }
 317
 318 /*--.. Operations on composite constants ...................................--*/
 319
 320 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
 321                              int DontNullTerminate) {
 322   /* Inverted the sense of AddNull because ', 0)' is a
 323      better mnemonic for null termination than ', 1)'. */
 324   return wrap(ConstantArray::get(std::string(Str, Length),
 325                                  DontNullTerminate == 0));
 326 }
 327
 328 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
 329                             LLVMValueRef *ConstantVals, unsigned Length) {
 330   return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length),
 331                                  unwrap<Constant>(ConstantVals, Length),
 332                                  Length));
 333 }
 334
 335 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
 336                              int Packed) {
 337   return wrap(ConstantStruct::get(unwrap<Constant>(ConstantVals, Count),
 338                                   Count, Packed != 0));
 339 }
 340
 341 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) {
 342   return wrap(ConstantVector::get(unwrap<Constant>(ScalarConstantVals, Size),
 343                                   Size));
 344 }
 345
 346 /*--.. Constant expressions ................................................--*/
 347
 348 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty) {
 349   return wrap(ConstantExpr::getSizeOf(unwrap(Ty)));
 350 }
 351
 352 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal) {
 353   return wrap(ConstantExpr::getNeg(unwrap<Constant>(ConstantVal)));
 354 }
 355
 356 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal) {
 357   return wrap(ConstantExpr::getNot(unwrap<Constant>(ConstantVal)));
 358 }
 359
 360 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 361   return wrap(ConstantExpr::getAdd(unwrap<Constant>(LHSConstant),
 362                                    unwrap<Constant>(RHSConstant)));
 363 }
 364
 365 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 366   return wrap(ConstantExpr::getSub(unwrap<Constant>(LHSConstant),
 367                                    unwrap<Constant>(RHSConstant)));
 368 }
 369
 370 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 371   return wrap(ConstantExpr::getMul(unwrap<Constant>(LHSConstant),
 372                                    unwrap<Constant>(RHSConstant)));
 373 }
 374
 375 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 376   return wrap(ConstantExpr::getUDiv(unwrap<Constant>(LHSConstant),
 377                                     unwrap<Constant>(RHSConstant)));
 378 }
 379
 380 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 381   return wrap(ConstantExpr::getSDiv(unwrap<Constant>(LHSConstant),
 382                                     unwrap<Constant>(RHSConstant)));
 383 }
 384
 385 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 386   return wrap(ConstantExpr::getFDiv(unwrap<Constant>(LHSConstant),
 387                                     unwrap<Constant>(RHSConstant)));
 388 }
 389
 390 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 391   return wrap(ConstantExpr::getURem(unwrap<Constant>(LHSConstant),
 392                                     unwrap<Constant>(RHSConstant)));
 393 }
 394
 395 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 396   return wrap(ConstantExpr::getSRem(unwrap<Constant>(LHSConstant),
 397                                     unwrap<Constant>(RHSConstant)));
 398 }
 399
 400 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 401   return wrap(ConstantExpr::getFRem(unwrap<Constant>(LHSConstant),
 402                                     unwrap<Constant>(RHSConstant)));
 403 }
 404
 405 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 406   return wrap(ConstantExpr::getAnd(unwrap<Constant>(LHSConstant),
 407                                    unwrap<Constant>(RHSConstant)));
 408 }
 409
 410 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 411   return wrap(ConstantExpr::getOr(unwrap<Constant>(LHSConstant),
 412                                   unwrap<Constant>(RHSConstant)));
 413 }
 414
 415 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 416   return wrap(ConstantExpr::getXor(unwrap<Constant>(LHSConstant),
 417                                    unwrap<Constant>(RHSConstant)));
 418 }
 419
 420 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
 421                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 422   return wrap(ConstantExpr::getICmp(Predicate,
 423                                     unwrap<Constant>(LHSConstant),
 424                                     unwrap<Constant>(RHSConstant)));
 425 }
 426
 427 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
 428                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 429   return wrap(ConstantExpr::getFCmp(Predicate,
 430                                     unwrap<Constant>(LHSConstant),
 431                                     unwrap<Constant>(RHSConstant)));
 432 }
 433
 434 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 435   return wrap(ConstantExpr::getShl(unwrap<Constant>(LHSConstant),
 436                                   unwrap<Constant>(RHSConstant)));
 437 }
 438
 439 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 440   return wrap(ConstantExpr::getLShr(unwrap<Constant>(LHSConstant),
 441                                     unwrap<Constant>(RHSConstant)));
 442 }
 443
 444 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
 445   return wrap(ConstantExpr::getAShr(unwrap<Constant>(LHSConstant),
 446                                     unwrap<Constant>(RHSConstant)));
 447 }
 448
 449 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
 450                           LLVMValueRef *ConstantIndices, unsigned NumIndices) {
 451   return wrap(ConstantExpr::getGetElementPtr(unwrap<Constant>(ConstantVal),
 452                                              unwrap<Constant>(ConstantIndices,
 453                                                               NumIndices),
 454                                              NumIndices));
 455 }
 456
 457 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
 458   return wrap(ConstantExpr::getTrunc(unwrap<Constant>(ConstantVal),
 459                                      unwrap(ToType)));
 460 }
 461
 462 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
 463   return wrap(ConstantExpr::getSExt(unwrap<Constant>(ConstantVal),
 464                                     unwrap(ToType)));
 465 }
 466
 467 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
 468   return wrap(ConstantExpr::getZExt(unwrap<Constant>(ConstantVal),
 469                                     unwrap(ToType)));
 470 }
 471
 472 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
 473   return wrap(ConstantExpr::getFPTrunc(unwrap<Constant>(ConstantVal),
 474                                        unwrap(ToType)));
 475 }
 476
 477 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
 478   return wrap(ConstantExpr::getFPExtend(unwrap<Constant>(ConstantVal),
 479                                         unwrap(ToType)));
 480 }
 481
 482 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
 483   return wrap(ConstantExpr::getUIToFP(unwrap<Constant>(ConstantVal),
 484                                       unwrap(ToType)));
 485 }
 486
 487 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
 488   return wrap(ConstantExpr::getSIToFP(unwrap<Constant>(ConstantVal),
 489                                       unwrap(ToType)));
 490 }
 491
 492 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
 493   return wrap(ConstantExpr::getFPToUI(unwrap<Constant>(ConstantVal),
 494                                       unwrap(ToType)));
 495 }
 496
 497 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
 498   return wrap(ConstantExpr::getFPToSI(unwrap<Constant>(ConstantVal),
 499                                       unwrap(ToType)));
 500 }
 501
 502 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
 503   return wrap(ConstantExpr::getPtrToInt(unwrap<Constant>(ConstantVal),
 504                                         unwrap(ToType)));
 505 }
 506
 507 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
 508   return wrap(ConstantExpr::getIntToPtr(unwrap<Constant>(ConstantVal),
 509                                         unwrap(ToType)));
 510 }
 511
 512 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
 513   return wrap(ConstantExpr::getBitCast(unwrap<Constant>(ConstantVal),
 514                                        unwrap(ToType)));
 515 }
 516
 517 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
 518                              LLVMValueRef ConstantIfTrue,
 519                              LLVMValueRef ConstantIfFalse) {
 520   return wrap(ConstantExpr::getSelect(unwrap<Constant>(ConstantCondition),
 521                                       unwrap<Constant>(ConstantIfTrue),
 522                                       unwrap<Constant>(ConstantIfFalse)));
 523 }
 524
 525 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
 526                                      LLVMValueRef IndexConstant) {
 527   return wrap(ConstantExpr::getExtractElement(unwrap<Constant>(VectorConstant),
 528                                               unwrap<Constant>(IndexConstant)));
 529 }
 530
 531 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
 532                                     LLVMValueRef ElementValueConstant,
 533                                     LLVMValueRef IndexConstant) {
 534   return wrap(ConstantExpr::getInsertElement(unwrap<Constant>(VectorConstant),
 535                                          unwrap<Constant>(ElementValueConstant),
 536                                              unwrap<Constant>(IndexConstant)));
 537 }
 538
 539 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
 540                                     LLVMValueRef VectorBConstant,
 541                                     LLVMValueRef MaskConstant) {
 542   return wrap(ConstantExpr::getShuffleVector(unwrap<Constant>(VectorAConstant),
 543                                              unwrap<Constant>(VectorBConstant),
 544                                              unwrap<Constant>(MaskConstant)));
 545 }
 546
 547 /*--.. Operations on global variables, functions, and aliases (globals) ....--*/
 548
 549 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global) {
 550   return wrap(unwrap<GlobalValue>(Global)->getParent());
 551 }
 552
 553 int LLVMIsDeclaration(LLVMValueRef Global) {
 554   return unwrap<GlobalValue>(Global)->isDeclaration();
 555 }
 556
 557 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global) {
 558   return static_cast<LLVMLinkage>(unwrap<GlobalValue>(Global)->getLinkage());
 559 }
 560
 561 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage) {
 562   unwrap<GlobalValue>(Global)
 563     ->setLinkage(static_cast<GlobalValue::LinkageTypes>(Linkage));
 564 }
 565
 566 const char *LLVMGetSection(LLVMValueRef Global) {
 567   return unwrap<GlobalValue>(Global)->getSection().c_str();
 568 }
 569
 570 void LLVMSetSection(LLVMValueRef Global, const char *Section) {
 571   unwrap<GlobalValue>(Global)->setSection(Section);
 572 }
 573
 574 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global) {
 575   return static_cast<LLVMVisibility>(
 576     unwrap<GlobalValue>(Global)->getVisibility());
 577 }
 578
 579 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz) {
 580   unwrap<GlobalValue>(Global)
 581     ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz));
 582 }
 583
 584 unsigned LLVMGetAlignment(LLVMValueRef Global) {
 585   return unwrap<GlobalValue>(Global)->getAlignment();
 586 }
 587
 588 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes) {
 589   unwrap<GlobalValue>(Global)->setAlignment(Bytes);
 590 }
 591
 592 /*--.. Operations on global variables ......................................--*/
 593
 594 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name) {
 595   return wrap(new GlobalVariable(unwrap(Ty), false,
 596                                  GlobalValue::ExternalLinkage, 0, Name,
 597                                  unwrap(M)));
 598 }
 599
 600 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name) {
 601   return wrap(unwrap(M)->getNamedGlobal(Name));
 602 }
 603
 604 void LLVMDeleteGlobal(LLVMValueRef GlobalVar) {
 605   unwrap<GlobalVariable>(GlobalVar)->eraseFromParent();
 606 }
 607
 608 int LLVMHasInitializer(LLVMValueRef GlobalVar) {
 609   return unwrap<GlobalVariable>(GlobalVar)->hasInitializer();
 610 }
 611
 612 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar) {
 613   return wrap(unwrap<GlobalVariable>(GlobalVar)->getInitializer());
 614 }
 615
 616 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) {
 617   unwrap<GlobalVariable>(GlobalVar)
 618     ->setInitializer(unwrap<Constant>(ConstantVal));
 619 }
 620
 621 int LLVMIsThreadLocal(LLVMValueRef GlobalVar) {
 622   return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal();
 623 }
 624
 625 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal) {
 626   unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0);
 627 }
 628
 629 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar) {
 630   return unwrap<GlobalVariable>(GlobalVar)->isConstant();
 631 }
 632
 633 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant) {
 634   unwrap<GlobalVariable>(GlobalVar)->setConstant(IsConstant != 0);
 635 }
 636
 637 /*--.. Operations on functions .............................................--*/
 638
 639 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
 640                              LLVMTypeRef FunctionTy) {
 641   return wrap(new Function(unwrap<FunctionType>(FunctionTy),
 642                            GlobalValue::ExternalLinkage, Name, unwrap(M)));
 643 }
 644
 645 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name) {
 646   return wrap(unwrap(M)->getFunction(Name));
 647 }
 648
 649 void LLVMDeleteFunction(LLVMValueRef Fn) {
 650   unwrap<Function>(Fn)->eraseFromParent();
 651 }
 652
 653 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn) {
 654   if (Function *F = dyn_cast<Function>(unwrap(Fn)))
 655     return F->getIntrinsicID();
 656   return 0;
 657 }
 658
 659 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn) {
 660   return unwrap<Function>(Fn)->getCallingConv();
 661 }
 662
 663 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC) {
 664   return unwrap<Function>(Fn)->setCallingConv(CC);
 665 }
 666
 667 const char *LLVMGetCollector(LLVMValueRef Fn) {
 668   Function *F = unwrap<Function>(Fn);
 669   return F->hasCollector()? F->getCollector() : 0;
 670 }
 671
 672 void LLVMSetCollector(LLVMValueRef Fn, const char *Coll) {
 673   Function *F = unwrap<Function>(Fn);
 674   if (Coll)
 675     F->setCollector(Coll);
 676   else
 677     F->clearCollector();
 678 }
 679
 680 /*--.. Operations on parameters ............................................--*/
 681
 682 unsigned LLVMCountParams(LLVMValueRef FnRef) {
 683   // This function is strictly redundant to
 684   //   LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(FnRef)))
 685   return unwrap<Function>(FnRef)->getArgumentList().size();
 686 }
 687
 688 void LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs) {
 689   Function *Fn = unwrap<Function>(FnRef);
 690   for (Function::arg_iterator I = Fn->arg_begin(),
 691                               E = Fn->arg_end(); I != E; I++)
 692     *ParamRefs++ = wrap(I);
 693 }
 694
 695 LLVMValueRef LLVMGetParam(LLVMValueRef FnRef, unsigned index) {
 696   Function::arg_iterator AI = unwrap<Function>(FnRef)->arg_begin();
 697   while (index --> 0)
 698     AI++;
 699   return wrap(AI);
 700 }
 701
 702 LLVMValueRef LLVMGetParamParent(LLVMValueRef V) {
 703   return wrap(unwrap<Argument>(V)->getParent());
 704 }
 705
 706 /*--.. Operations on basic blocks ..........................................--*/
 707
 708 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB) {
 709   return wrap(static_cast<Value*>(unwrap(BB)));
 710 }
 711
 712 int LLVMValueIsBasicBlock(LLVMValueRef Val) {
 713   return isa<BasicBlock>(unwrap(Val));
 714 }
 715
 716 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val) {
 717   return wrap(unwrap<BasicBlock>(Val));
 718 }
 719
 720 LLVMValueRef LLVMGetBasicBlockParent(LLVMValueRef V) {
 721   return wrap(unwrap<BasicBlock>(V)->getParent());
 722 }
 723
 724 unsigned LLVMCountBasicBlocks(LLVMValueRef FnRef) {
 725   return unwrap<Function>(FnRef)->getBasicBlockList().size();
 726 }
 727
 728 void LLVMGetBasicBlocks(LLVMValueRef FnRef, LLVMBasicBlockRef *BasicBlocksRefs){
 729   Function *Fn = unwrap<Function>(FnRef);
 730   for (Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++)
 731     *BasicBlocksRefs++ = wrap(I);
 732 }
 733
 734 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn) {
 735   return wrap(&unwrap<Function>(Fn)->getEntryBlock());
 736 }
 737
 738 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef FnRef, const char *Name) {
 739   return wrap(new BasicBlock(Name, unwrap<Function>(FnRef)));
 740 }
 741
 742 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBBRef,
 743                                        const char *Name) {
 744   BasicBlock *InsertBeforeBB = unwrap(InsertBeforeBBRef);
 745   return wrap(new BasicBlock(Name, InsertBeforeBB->getParent(),
 746                              InsertBeforeBB));
 747 }
 748
 749 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BBRef) {
 750   unwrap(BBRef)->eraseFromParent();
 751 }
 752
 753 /*--.. Operations on instructions ..........................................--*/
 754
 755 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst) {
 756   return wrap(unwrap<Instruction>(Inst)->getParent());
 757 }
 758
 759 /*--.. Call and invoke instructions ........................................--*/
 760
 761 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr) {
 762   Value *V = unwrap(Instr);
 763   if (CallInst *CI = dyn_cast<CallInst>(V))
 764     return CI->getCallingConv();
 765   else if (InvokeInst *II = dyn_cast<InvokeInst>(V))
 766     return II->getCallingConv();
 767   assert(0 && "LLVMGetInstructionCallConv applies only to call and invoke!");
 768   return 0;
 769 }
 770
 771 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC) {
 772   Value *V = unwrap(Instr);
 773   if (CallInst *CI = dyn_cast<CallInst>(V))
 774     return CI->setCallingConv(CC);
 775   else if (InvokeInst *II = dyn_cast<InvokeInst>(V))
 776     return II->setCallingConv(CC);
 777   assert(0 && "LLVMSetInstructionCallConv applies only to call and invoke!");
 778 }
 779
 780 /*--.. Operations on phi nodes .............................................--*/
 781
 782 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
 783                      LLVMBasicBlockRef *IncomingBlocks, unsigned Count) {
 784   PHINode *PhiVal = unwrap<PHINode>(PhiNode);
 785   for (unsigned I = 0; I != Count; ++I)
 786     PhiVal->addIncoming(unwrap(IncomingValues[I]), unwrap(IncomingBlocks[I]));
 787 }
 788
 789 unsigned LLVMCountIncoming(LLVMValueRef PhiNode) {
 790   return unwrap<PHINode>(PhiNode)->getNumIncomingValues();
 791 }
 792
 793 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index) {
 794   return wrap(unwrap<PHINode>(PhiNode)->getIncomingValue(Index));
 795 }
 796
 797 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index) {
 798   return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index));
 799 }
 800
 801
 802 /*===-- Instruction builders ----------------------------------------------===*/
 803
 804 LLVMBuilderRef LLVMCreateBuilder() {
 805   return wrap(new LLVMFoldingBuilder());
 806 }
 807
 808 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr) {
 809   Instruction *I = unwrap<Instruction>(Instr);
 810   unwrap(Builder)->SetInsertPoint(I->getParent(), I);
 811 }
 812
 813 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block) {
 814   BasicBlock *BB = unwrap(Block);
 815   unwrap(Builder)->SetInsertPoint(BB);
 816 }
 817
 818 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder) {
 819    return wrap(unwrap(Builder)->GetInsertBlock());
 820 }
 821
 822 void LLVMDisposeBuilder(LLVMBuilderRef Builder) {
 823   delete unwrap(Builder);
 824 }
 825
 826 /*--.. Instruction builders ................................................--*/
 827
 828 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef B) {
 829   return wrap(unwrap(B)->CreateRetVoid());
 830 }
 831
 832 LLVMValueRef LLVMBuildRet(LLVMBuilderRef B, LLVMValueRef V) {
 833   return wrap(unwrap(B)->CreateRet(unwrap(V)));
 834 }
 835
 836 LLVMValueRef LLVMBuildBr(LLVMBuilderRef B, LLVMBasicBlockRef Dest) {
 837   return wrap(unwrap(B)->CreateBr(unwrap(Dest)));
 838 }
 839
 840 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef B, LLVMValueRef If,
 841                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Else) {
 842   return wrap(unwrap(B)->CreateCondBr(unwrap(If), unwrap(Then), unwrap(Else)));
 843 }
 844
 845 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef B, LLVMValueRef V,
 846                              LLVMBasicBlockRef Else, unsigned NumCases) {
 847   return wrap(unwrap(B)->CreateSwitch(unwrap(V), unwrap(Else), NumCases));
 848 }
 849
 850 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn,
 851                              LLVMValueRef *Args, unsigned NumArgs,
 852                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
 853                              const char *Name) {
 854   return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch),
 855                                       unwrap(Args), unwrap(Args) + NumArgs,
 856                                       Name));
 857 }
 858
 859 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef B) {
 860   return wrap(unwrap(B)->CreateUnwind());
 861 }
 862
 863 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) {
 864   return wrap(unwrap(B)->CreateUnreachable());
 865 }
 866
 867 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
 868                  LLVMBasicBlockRef Dest) {
 869   unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest));
 870 }
 871
 872 /*--.. Arithmetic ..........................................................--*/
 873
 874 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 875                           const char *Name) {
 876   return wrap(unwrap(B)->CreateAdd(unwrap(LHS), unwrap(RHS), Name));
 877 }
 878
 879 LLVMValueRef LLVMBuildSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 880                           const char *Name) {
 881   return wrap(unwrap(B)->CreateSub(unwrap(LHS), unwrap(RHS), Name));
 882 }
 883
 884 LLVMValueRef LLVMBuildMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 885                           const char *Name) {
 886   return wrap(unwrap(B)->CreateMul(unwrap(LHS), unwrap(RHS), Name));
 887 }
 888
 889 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 890                            const char *Name) {
 891   return wrap(unwrap(B)->CreateUDiv(unwrap(LHS), unwrap(RHS), Name));
 892 }
 893
 894 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 895                            const char *Name) {
 896   return wrap(unwrap(B)->CreateSDiv(unwrap(LHS), unwrap(RHS), Name));
 897 }
 898
 899 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 900                            const char *Name) {
 901   return wrap(unwrap(B)->CreateFDiv(unwrap(LHS), unwrap(RHS), Name));
 902 }
 903
 904 LLVMValueRef LLVMBuildURem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 905                            const char *Name) {
 906   return wrap(unwrap(B)->CreateURem(unwrap(LHS), unwrap(RHS), Name));
 907 }
 908
 909 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 910                            const char *Name) {
 911   return wrap(unwrap(B)->CreateSRem(unwrap(LHS), unwrap(RHS), Name));
 912 }
 913
 914 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 915                            const char *Name) {
 916   return wrap(unwrap(B)->CreateFRem(unwrap(LHS), unwrap(RHS), Name));
 917 }
 918
 919 LLVMValueRef LLVMBuildShl(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 920                           const char *Name) {
 921   return wrap(unwrap(B)->CreateShl(unwrap(LHS), unwrap(RHS), Name));
 922 }
 923
 924 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 925                            const char *Name) {
 926   return wrap(unwrap(B)->CreateLShr(unwrap(LHS), unwrap(RHS), Name));
 927 }
 928
 929 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 930                            const char *Name) {
 931   return wrap(unwrap(B)->CreateAShr(unwrap(LHS), unwrap(RHS), Name));
 932 }
 933
 934 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 935                           const char *Name) {
 936   return wrap(unwrap(B)->CreateAnd(unwrap(LHS), unwrap(RHS), Name));
 937 }
 938
 939 LLVMValueRef LLVMBuildOr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 940                          const char *Name) {
 941   return wrap(unwrap(B)->CreateOr(unwrap(LHS), unwrap(RHS), Name));
 942 }
 943
 944 LLVMValueRef LLVMBuildXor(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
 945                           const char *Name) {
 946   return wrap(unwrap(B)->CreateXor(unwrap(LHS), unwrap(RHS), Name));
 947 }
 948
 949 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
 950   return wrap(unwrap(B)->CreateNeg(unwrap(V), Name));
 951 }
 952
 953 LLVMValueRef LLVMBuildNot(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
 954   return wrap(unwrap(B)->CreateNot(unwrap(V), Name));
 955 }
 956
 957 /*--.. Memory ..............................................................--*/
 958
 959 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
 960                              const char *Name) {
 961   return wrap(unwrap(B)->CreateMalloc(unwrap(Ty), 0, Name));
 962 }
 963
 964 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
 965                                   LLVMValueRef Val, const char *Name) {
 966   return wrap(unwrap(B)->CreateMalloc(unwrap(Ty), unwrap(Val), Name));
 967 }
 968
 969 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
 970                              const char *Name) {
 971   return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), 0, Name));
 972 }
 973
 974 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
 975                                   LLVMValueRef Val, const char *Name) {
 976   return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), unwrap(Val), Name));
 977 }
 978
 979 LLVMValueRef LLVMBuildFree(LLVMBuilderRef B, LLVMValueRef PointerVal) {
 980   return wrap(unwrap(B)->CreateFree(unwrap(PointerVal)));
 981 }
 982
 983
 984 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef B, LLVMValueRef PointerVal,
 985                            const char *Name) {
 986   return wrap(unwrap(B)->CreateLoad(unwrap(PointerVal), Name));
 987 }
 988
 989 LLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val,
 990                             LLVMValueRef PointerVal) {
 991   return wrap(unwrap(B)->CreateStore(unwrap(Val), unwrap(PointerVal)));
 992 }
 993
 994 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
 995                           LLVMValueRef *Indices, unsigned NumIndices,
 996                           const char *Name) {
 997   return wrap(unwrap(B)->CreateGEP(unwrap(Pointer), unwrap(Indices),
 998                                    unwrap(Indices) + NumIndices, Name));
 999 }
1000
1001 /*--.. Casts ...............................................................--*/
1002
1003 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef B, LLVMValueRef Val,
1004                             LLVMTypeRef DestTy, const char *Name) {
1005   return wrap(unwrap(B)->CreateTrunc(unwrap(Val), unwrap(DestTy), Name));
1006 }
1007
1008 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef B, LLVMValueRef Val,
1009                            LLVMTypeRef DestTy, const char *Name) {
1010   return wrap(unwrap(B)->CreateZExt(unwrap(Val), unwrap(DestTy), Name));
1011 }
1012
1013 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef B, LLVMValueRef Val,
1014                            LLVMTypeRef DestTy, const char *Name) {
1015   return wrap(unwrap(B)->CreateSExt(unwrap(Val), unwrap(DestTy), Name));
1016 }
1017
1018 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef B, LLVMValueRef Val,
1019                              LLVMTypeRef DestTy, const char *Name) {
1020   return wrap(unwrap(B)->CreateFPToUI(unwrap(Val), unwrap(DestTy), Name));
1021 }
1022
1023 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef B, LLVMValueRef Val,
1024                              LLVMTypeRef DestTy, const char *Name) {
1025   return wrap(unwrap(B)->CreateFPToSI(unwrap(Val), unwrap(DestTy), Name));
1026 }
1027
1028 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef B, LLVMValueRef Val,
1029                              LLVMTypeRef DestTy, const char *Name) {
1030   return wrap(unwrap(B)->CreateUIToFP(unwrap(Val), unwrap(DestTy), Name));
1031 }
1032
1033 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef B, LLVMValueRef Val,
1034                              LLVMTypeRef DestTy, const char *Name) {
1035   return wrap(unwrap(B)->CreateSIToFP(unwrap(Val), unwrap(DestTy), Name));
1036 }
1037
1038 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef B, LLVMValueRef Val,
1039                               LLVMTypeRef DestTy, const char *Name) {
1040   return wrap(unwrap(B)->CreateFPTrunc(unwrap(Val), unwrap(DestTy), Name));
1041 }
1042
1043 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef B, LLVMValueRef Val,
1044                             LLVMTypeRef DestTy, const char *Name) {
1045   return wrap(unwrap(B)->CreateFPExt(unwrap(Val), unwrap(DestTy), Name));
1046 }
1047
1048 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef B, LLVMValueRef Val,
1049                                LLVMTypeRef DestTy, const char *Name) {
1050   return wrap(unwrap(B)->CreatePtrToInt(unwrap(Val), unwrap(DestTy), Name));
1051 }
1052
1053 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef B, LLVMValueRef Val,
1054                                LLVMTypeRef DestTy, const char *Name) {
1055   return wrap(unwrap(B)->CreateIntToPtr(unwrap(Val), unwrap(DestTy), Name));
1056 }
1057
1058 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef B, LLVMValueRef Val,
1059                               LLVMTypeRef DestTy, const char *Name) {
1060   return wrap(unwrap(B)->CreateBitCast(unwrap(Val), unwrap(DestTy), Name));
1061 }
1062
1063 /*--.. Comparisons .........................................................--*/
1064
1065 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef B, LLVMIntPredicate Op,
1066                            LLVMValueRef LHS, LLVMValueRef RHS,
1067                            const char *Name) {
1068   return wrap(unwrap(B)->CreateICmp(static_cast<ICmpInst::Predicate>(Op),
1069                                     unwrap(LHS), unwrap(RHS), Name));
1070 }
1071
1072 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef B, LLVMRealPredicate Op,
1073                            LLVMValueRef LHS, LLVMValueRef RHS,
1074                            const char *Name) {
1075   return wrap(unwrap(B)->CreateFCmp(static_cast<FCmpInst::Predicate>(Op),
1076                                     unwrap(LHS), unwrap(RHS), Name));
1077 }
1078
1079 /*--.. Miscellaneous instructions ..........................................--*/
1080
1081 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name) {
1082   return wrap(unwrap(B)->CreatePHI(unwrap(Ty), Name));
1083 }
1084
1085 LLVMValueRef LLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn,
1086                            LLVMValueRef *Args, unsigned NumArgs,
1087                            const char *Name) {
1088   return wrap(unwrap(B)->CreateCall(unwrap(Fn), unwrap(Args),
1089                                     unwrap(Args) + NumArgs, Name));
1090 }
1091
1092 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If,
1093                              LLVMValueRef Then, LLVMValueRef Else,
1094                              const char *Name) {
1095   return wrap(unwrap(B)->CreateSelect(unwrap(If), unwrap(Then), unwrap(Else),
1096                                       Name));
1097 }
1098
1099 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef B, LLVMValueRef List,
1100                             LLVMTypeRef Ty, const char *Name) {
1101   return wrap(unwrap(B)->CreateVAArg(unwrap(List), unwrap(Ty), Name));
1102 }
1103
1104 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef B, LLVMValueRef VecVal,
1105                                       LLVMValueRef Index, const char *Name) {
1106   return wrap(unwrap(B)->CreateExtractElement(unwrap(VecVal), unwrap(Index),
1107                                               Name));
1108 }
1109
1110 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef B, LLVMValueRef VecVal,
1111                                     LLVMValueRef EltVal, LLVMValueRef Index,
1112                                     const char *Name) {
1113   return wrap(unwrap(B)->CreateInsertElement(unwrap(VecVal), unwrap(EltVal),
1114                                              unwrap(Index), Name));
1115 }
1116
1117 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef B, LLVMValueRef V1,
1118                                     LLVMValueRef V2, LLVMValueRef Mask,
1119                                     const char *Name) {
1120   return wrap(unwrap(B)->CreateShuffleVector(unwrap(V1), unwrap(V2),
1121                                              unwrap(Mask), Name));
1122 }
1123
1124
1125 /*===-- Module providers --------------------------------------------------===*/
1126
1127 LLVMModuleProviderRef
1128 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M) {
1129   return wrap(new ExistingModuleProvider(unwrap(M)));
1130 }
1131
1132 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP) {
1133   delete unwrap(MP);
1134 }
1135
1136
1137 /*===-- Memory buffers ----------------------------------------------------===*/
1138
1139 int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
1140                                              LLVMMemoryBufferRef *OutMemBuf,
1141                                              char **OutMessage) {
1142   std::string Error;
1143   if (MemoryBuffer *MB = MemoryBuffer::getFile(Path, strlen(Path), &Error)) {
1144     *OutMemBuf = wrap(MB);
1145     return 0;
1146   }
1147
1148   *OutMessage = strdup(Error.c_str());
1149   return 1;
1150 }
1151
1152 int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
1153                                     char **OutMessage) {
1154   if (MemoryBuffer *MB = MemoryBuffer::getSTDIN()) {
1155     *OutMemBuf = wrap(MB);
1156     return 0;
1157   }
1158
1159   *OutMessage = strdup("stdin is empty.");
1160   return 1;
1161 }
1162
1163 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf) {
1164   delete unwrap(MemBuf);
1165 }