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