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