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