• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/ADT/StringSwitch.h"
17 #include "llvm/IR/Attributes.h"
18 #include "llvm/IR/CallSite.h"
19 #include "llvm/IR/Constants.h"
20 #include "llvm/IR/DerivedTypes.h"
21 #include "llvm/IR/DiagnosticInfo.h"
22 #include "llvm/IR/DiagnosticPrinter.h"
23 #include "llvm/IR/GlobalAlias.h"
24 #include "llvm/IR/GlobalVariable.h"
25 #include "llvm/IR/IRBuilder.h"
26 #include "llvm/IR/InlineAsm.h"
27 #include "llvm/IR/IntrinsicInst.h"
28 #include "llvm/IR/LLVMContext.h"
29 #include "llvm/IR/LegacyPassManager.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/Support/Debug.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "llvm/Support/FileSystem.h"
34 #include "llvm/Support/ManagedStatic.h"
35 #include "llvm/Support/MemoryBuffer.h"
36 #include "llvm/Support/Threading.h"
37 #include "llvm/Support/raw_ostream.h"
38 #include <cassert>
39 #include <cstdlib>
40 #include <cstring>
41 #include <system_error>
42 
43 using namespace llvm;
44 
45 #define DEBUG_TYPE "ir"
46 
initializeCore(PassRegistry & Registry)47 void llvm::initializeCore(PassRegistry &Registry) {
48   initializeDominatorTreeWrapperPassPass(Registry);
49   initializePrintModulePassWrapperPass(Registry);
50   initializePrintFunctionPassWrapperPass(Registry);
51   initializePrintBasicBlockPassPass(Registry);
52   initializeSafepointIRVerifierPass(Registry);
53   initializeVerifierLegacyPassPass(Registry);
54 }
55 
LLVMInitializeCore(LLVMPassRegistryRef R)56 void LLVMInitializeCore(LLVMPassRegistryRef R) {
57   initializeCore(*unwrap(R));
58 }
59 
LLVMShutdown()60 void LLVMShutdown() {
61   llvm_shutdown();
62 }
63 
64 /*===-- Error handling ----------------------------------------------------===*/
65 
LLVMCreateMessage(const char * Message)66 char *LLVMCreateMessage(const char *Message) {
67   return strdup(Message);
68 }
69 
LLVMDisposeMessage(char * Message)70 void LLVMDisposeMessage(char *Message) {
71   free(Message);
72 }
73 
74 
75 /*===-- Operations on contexts --------------------------------------------===*/
76 
77 static ManagedStatic<LLVMContext> GlobalContext;
78 
LLVMContextCreate()79 LLVMContextRef LLVMContextCreate() {
80   return wrap(new LLVMContext());
81 }
82 
LLVMGetGlobalContext()83 LLVMContextRef LLVMGetGlobalContext() { return wrap(&*GlobalContext); }
84 
LLVMContextSetDiagnosticHandler(LLVMContextRef C,LLVMDiagnosticHandler Handler,void * DiagnosticContext)85 void LLVMContextSetDiagnosticHandler(LLVMContextRef C,
86                                      LLVMDiagnosticHandler Handler,
87                                      void *DiagnosticContext) {
88   unwrap(C)->setDiagnosticHandlerCallBack(
89       LLVM_EXTENSION reinterpret_cast<DiagnosticHandler::DiagnosticHandlerTy>(
90           Handler),
91       DiagnosticContext);
92 }
93 
LLVMContextGetDiagnosticHandler(LLVMContextRef C)94 LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C) {
95   return LLVM_EXTENSION reinterpret_cast<LLVMDiagnosticHandler>(
96       unwrap(C)->getDiagnosticHandlerCallBack());
97 }
98 
LLVMContextGetDiagnosticContext(LLVMContextRef C)99 void *LLVMContextGetDiagnosticContext(LLVMContextRef C) {
100   return unwrap(C)->getDiagnosticContext();
101 }
102 
LLVMContextSetYieldCallback(LLVMContextRef C,LLVMYieldCallback Callback,void * OpaqueHandle)103 void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback,
104                                  void *OpaqueHandle) {
105   auto YieldCallback =
106     LLVM_EXTENSION reinterpret_cast<LLVMContext::YieldCallbackTy>(Callback);
107   unwrap(C)->setYieldCallback(YieldCallback, OpaqueHandle);
108 }
109 
LLVMContextDispose(LLVMContextRef C)110 void LLVMContextDispose(LLVMContextRef C) {
111   delete unwrap(C);
112 }
113 
LLVMGetMDKindIDInContext(LLVMContextRef C,const char * Name,unsigned SLen)114 unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char *Name,
115                                   unsigned SLen) {
116   return unwrap(C)->getMDKindID(StringRef(Name, SLen));
117 }
118 
LLVMGetMDKindID(const char * Name,unsigned SLen)119 unsigned LLVMGetMDKindID(const char *Name, unsigned SLen) {
120   return LLVMGetMDKindIDInContext(LLVMGetGlobalContext(), Name, SLen);
121 }
122 
123 #define GET_ATTR_KIND_FROM_NAME
124 #include "AttributesCompatFunc.inc"
125 
LLVMGetEnumAttributeKindForName(const char * Name,size_t SLen)126 unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen) {
127   return getAttrKindFromName(StringRef(Name, SLen));
128 }
129 
LLVMGetLastEnumAttributeKind(void)130 unsigned LLVMGetLastEnumAttributeKind(void) {
131   return Attribute::AttrKind::EndAttrKinds;
132 }
133 
LLVMCreateEnumAttribute(LLVMContextRef C,unsigned KindID,uint64_t Val)134 LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID,
135                                          uint64_t Val) {
136   return wrap(Attribute::get(*unwrap(C), (Attribute::AttrKind)KindID, Val));
137 }
138 
LLVMGetEnumAttributeKind(LLVMAttributeRef A)139 unsigned LLVMGetEnumAttributeKind(LLVMAttributeRef A) {
140   return unwrap(A).getKindAsEnum();
141 }
142 
LLVMGetEnumAttributeValue(LLVMAttributeRef A)143 uint64_t LLVMGetEnumAttributeValue(LLVMAttributeRef A) {
144   auto Attr = unwrap(A);
145   if (Attr.isEnumAttribute())
146     return 0;
147   return Attr.getValueAsInt();
148 }
149 
LLVMCreateStringAttribute(LLVMContextRef C,const char * K,unsigned KLength,const char * V,unsigned VLength)150 LLVMAttributeRef LLVMCreateStringAttribute(LLVMContextRef C,
151                                            const char *K, unsigned KLength,
152                                            const char *V, unsigned VLength) {
153   return wrap(Attribute::get(*unwrap(C), StringRef(K, KLength),
154                              StringRef(V, VLength)));
155 }
156 
LLVMGetStringAttributeKind(LLVMAttributeRef A,unsigned * Length)157 const char *LLVMGetStringAttributeKind(LLVMAttributeRef A,
158                                        unsigned *Length) {
159   auto S = unwrap(A).getKindAsString();
160   *Length = S.size();
161   return S.data();
162 }
163 
LLVMGetStringAttributeValue(LLVMAttributeRef A,unsigned * Length)164 const char *LLVMGetStringAttributeValue(LLVMAttributeRef A,
165                                         unsigned *Length) {
166   auto S = unwrap(A).getValueAsString();
167   *Length = S.size();
168   return S.data();
169 }
170 
LLVMIsEnumAttribute(LLVMAttributeRef A)171 LLVMBool LLVMIsEnumAttribute(LLVMAttributeRef A) {
172   auto Attr = unwrap(A);
173   return Attr.isEnumAttribute() || Attr.isIntAttribute();
174 }
175 
LLVMIsStringAttribute(LLVMAttributeRef A)176 LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A) {
177   return unwrap(A).isStringAttribute();
178 }
179 
LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI)180 char *LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI) {
181   std::string MsgStorage;
182   raw_string_ostream Stream(MsgStorage);
183   DiagnosticPrinterRawOStream DP(Stream);
184 
185   unwrap(DI)->print(DP);
186   Stream.flush();
187 
188   return LLVMCreateMessage(MsgStorage.c_str());
189 }
190 
LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI)191 LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI) {
192     LLVMDiagnosticSeverity severity;
193 
194     switch(unwrap(DI)->getSeverity()) {
195     default:
196       severity = LLVMDSError;
197       break;
198     case DS_Warning:
199       severity = LLVMDSWarning;
200       break;
201     case DS_Remark:
202       severity = LLVMDSRemark;
203       break;
204     case DS_Note:
205       severity = LLVMDSNote;
206       break;
207     }
208 
209     return severity;
210 }
211 
212 /*===-- Operations on modules ---------------------------------------------===*/
213 
LLVMModuleCreateWithName(const char * ModuleID)214 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID) {
215   return wrap(new Module(ModuleID, *GlobalContext));
216 }
217 
LLVMModuleCreateWithNameInContext(const char * ModuleID,LLVMContextRef C)218 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
219                                                 LLVMContextRef C) {
220   return wrap(new Module(ModuleID, *unwrap(C)));
221 }
222 
LLVMDisposeModule(LLVMModuleRef M)223 void LLVMDisposeModule(LLVMModuleRef M) {
224   delete unwrap(M);
225 }
226 
LLVMGetModuleIdentifier(LLVMModuleRef M,size_t * Len)227 const char *LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len) {
228   auto &Str = unwrap(M)->getModuleIdentifier();
229   *Len = Str.length();
230   return Str.c_str();
231 }
232 
LLVMSetModuleIdentifier(LLVMModuleRef M,const char * Ident,size_t Len)233 void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len) {
234   unwrap(M)->setModuleIdentifier(StringRef(Ident, Len));
235 }
236 
LLVMGetSourceFileName(LLVMModuleRef M,size_t * Len)237 const char *LLVMGetSourceFileName(LLVMModuleRef M, size_t *Len) {
238   auto &Str = unwrap(M)->getSourceFileName();
239   *Len = Str.length();
240   return Str.c_str();
241 }
242 
LLVMSetSourceFileName(LLVMModuleRef M,const char * Name,size_t Len)243 void LLVMSetSourceFileName(LLVMModuleRef M, const char *Name, size_t Len) {
244   unwrap(M)->setSourceFileName(StringRef(Name, Len));
245 }
246 
247 /*--.. Data layout .........................................................--*/
LLVMGetDataLayoutStr(LLVMModuleRef M)248 const char *LLVMGetDataLayoutStr(LLVMModuleRef M) {
249   return unwrap(M)->getDataLayoutStr().c_str();
250 }
251 
LLVMGetDataLayout(LLVMModuleRef M)252 const char *LLVMGetDataLayout(LLVMModuleRef M) {
253   return LLVMGetDataLayoutStr(M);
254 }
255 
LLVMSetDataLayout(LLVMModuleRef M,const char * DataLayoutStr)256 void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr) {
257   unwrap(M)->setDataLayout(DataLayoutStr);
258 }
259 
260 /*--.. Target triple .......................................................--*/
LLVMGetTarget(LLVMModuleRef M)261 const char * LLVMGetTarget(LLVMModuleRef M) {
262   return unwrap(M)->getTargetTriple().c_str();
263 }
264 
LLVMSetTarget(LLVMModuleRef M,const char * Triple)265 void LLVMSetTarget(LLVMModuleRef M, const char *Triple) {
266   unwrap(M)->setTargetTriple(Triple);
267 }
268 
269 /*--.. Module flags ........................................................--*/
270 struct LLVMOpaqueModuleFlagEntry {
271   LLVMModuleFlagBehavior Behavior;
272   const char *Key;
273   size_t KeyLen;
274   LLVMMetadataRef Metadata;
275 };
276 
277 static Module::ModFlagBehavior
map_to_llvmModFlagBehavior(LLVMModuleFlagBehavior Behavior)278 map_to_llvmModFlagBehavior(LLVMModuleFlagBehavior Behavior) {
279   switch (Behavior) {
280   case LLVMModuleFlagBehaviorError:
281     return Module::ModFlagBehavior::Error;
282   case LLVMModuleFlagBehaviorWarning:
283     return Module::ModFlagBehavior::Warning;
284   case LLVMModuleFlagBehaviorRequire:
285     return Module::ModFlagBehavior::Require;
286   case LLVMModuleFlagBehaviorOverride:
287     return Module::ModFlagBehavior::Override;
288   case LLVMModuleFlagBehaviorAppend:
289     return Module::ModFlagBehavior::Append;
290   case LLVMModuleFlagBehaviorAppendUnique:
291     return Module::ModFlagBehavior::AppendUnique;
292   }
293   llvm_unreachable("Unknown LLVMModuleFlagBehavior");
294 }
295 
296 static LLVMModuleFlagBehavior
map_from_llvmModFlagBehavior(Module::ModFlagBehavior Behavior)297 map_from_llvmModFlagBehavior(Module::ModFlagBehavior Behavior) {
298   switch (Behavior) {
299   case Module::ModFlagBehavior::Error:
300     return LLVMModuleFlagBehaviorError;
301   case Module::ModFlagBehavior::Warning:
302     return LLVMModuleFlagBehaviorWarning;
303   case Module::ModFlagBehavior::Require:
304     return LLVMModuleFlagBehaviorRequire;
305   case Module::ModFlagBehavior::Override:
306     return LLVMModuleFlagBehaviorOverride;
307   case Module::ModFlagBehavior::Append:
308     return LLVMModuleFlagBehaviorAppend;
309   case Module::ModFlagBehavior::AppendUnique:
310     return LLVMModuleFlagBehaviorAppendUnique;
311   default:
312     llvm_unreachable("Unhandled Flag Behavior");
313   }
314 }
315 
LLVMCopyModuleFlagsMetadata(LLVMModuleRef M,size_t * Len)316 LLVMModuleFlagEntry *LLVMCopyModuleFlagsMetadata(LLVMModuleRef M, size_t *Len) {
317   SmallVector<Module::ModuleFlagEntry, 8> MFEs;
318   unwrap(M)->getModuleFlagsMetadata(MFEs);
319 
320   LLVMOpaqueModuleFlagEntry *Result = static_cast<LLVMOpaqueModuleFlagEntry *>(
321       safe_malloc(MFEs.size() * sizeof(LLVMOpaqueModuleFlagEntry)));
322   for (unsigned i = 0; i < MFEs.size(); ++i) {
323     const auto &ModuleFlag = MFEs[i];
324     Result[i].Behavior = map_from_llvmModFlagBehavior(ModuleFlag.Behavior);
325     Result[i].Key = ModuleFlag.Key->getString().data();
326     Result[i].KeyLen = ModuleFlag.Key->getString().size();
327     Result[i].Metadata = wrap(ModuleFlag.Val);
328   }
329   *Len = MFEs.size();
330   return Result;
331 }
332 
LLVMDisposeModuleFlagsMetadata(LLVMModuleFlagEntry * Entries)333 void LLVMDisposeModuleFlagsMetadata(LLVMModuleFlagEntry *Entries) {
334   free(Entries);
335 }
336 
337 LLVMModuleFlagBehavior
LLVMModuleFlagEntriesGetFlagBehavior(LLVMModuleFlagEntry * Entries,unsigned Index)338 LLVMModuleFlagEntriesGetFlagBehavior(LLVMModuleFlagEntry *Entries,
339                                      unsigned Index) {
340   LLVMOpaqueModuleFlagEntry MFE =
341       static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]);
342   return MFE.Behavior;
343 }
344 
LLVMModuleFlagEntriesGetKey(LLVMModuleFlagEntry * Entries,unsigned Index,size_t * Len)345 const char *LLVMModuleFlagEntriesGetKey(LLVMModuleFlagEntry *Entries,
346                                         unsigned Index, size_t *Len) {
347   LLVMOpaqueModuleFlagEntry MFE =
348       static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]);
349   *Len = MFE.KeyLen;
350   return MFE.Key;
351 }
352 
LLVMModuleFlagEntriesGetMetadata(LLVMModuleFlagEntry * Entries,unsigned Index)353 LLVMMetadataRef LLVMModuleFlagEntriesGetMetadata(LLVMModuleFlagEntry *Entries,
354                                                  unsigned Index) {
355   LLVMOpaqueModuleFlagEntry MFE =
356       static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]);
357   return MFE.Metadata;
358 }
359 
LLVMGetModuleFlag(LLVMModuleRef M,const char * Key,size_t KeyLen)360 LLVMMetadataRef LLVMGetModuleFlag(LLVMModuleRef M,
361                                   const char *Key, size_t KeyLen) {
362   return wrap(unwrap(M)->getModuleFlag({Key, KeyLen}));
363 }
364 
LLVMAddModuleFlag(LLVMModuleRef M,LLVMModuleFlagBehavior Behavior,const char * Key,size_t KeyLen,LLVMMetadataRef Val)365 void LLVMAddModuleFlag(LLVMModuleRef M, LLVMModuleFlagBehavior Behavior,
366                        const char *Key, size_t KeyLen,
367                        LLVMMetadataRef Val) {
368   unwrap(M)->addModuleFlag(map_to_llvmModFlagBehavior(Behavior),
369                            {Key, KeyLen}, unwrap(Val));
370 }
371 
372 /*--.. Printing modules ....................................................--*/
373 
LLVMDumpModule(LLVMModuleRef M)374 void LLVMDumpModule(LLVMModuleRef M) {
375   unwrap(M)->print(errs(), nullptr,
376                    /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
377 }
378 
LLVMPrintModuleToFile(LLVMModuleRef M,const char * Filename,char ** ErrorMessage)379 LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename,
380                                char **ErrorMessage) {
381   std::error_code EC;
382   raw_fd_ostream dest(Filename, EC, sys::fs::F_Text);
383   if (EC) {
384     *ErrorMessage = strdup(EC.message().c_str());
385     return true;
386   }
387 
388   unwrap(M)->print(dest, nullptr);
389 
390   dest.close();
391 
392   if (dest.has_error()) {
393     std::string E = "Error printing to file: " + dest.error().message();
394     *ErrorMessage = strdup(E.c_str());
395     return true;
396   }
397 
398   return false;
399 }
400 
LLVMPrintModuleToString(LLVMModuleRef M)401 char *LLVMPrintModuleToString(LLVMModuleRef M) {
402   std::string buf;
403   raw_string_ostream os(buf);
404 
405   unwrap(M)->print(os, nullptr);
406   os.flush();
407 
408   return strdup(buf.c_str());
409 }
410 
411 /*--.. Operations on inline assembler ......................................--*/
LLVMSetModuleInlineAsm2(LLVMModuleRef M,const char * Asm,size_t Len)412 void LLVMSetModuleInlineAsm2(LLVMModuleRef M, const char *Asm, size_t Len) {
413   unwrap(M)->setModuleInlineAsm(StringRef(Asm, Len));
414 }
415 
LLVMSetModuleInlineAsm(LLVMModuleRef M,const char * Asm)416 void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm) {
417   unwrap(M)->setModuleInlineAsm(StringRef(Asm));
418 }
419 
LLVMAppendModuleInlineAsm(LLVMModuleRef M,const char * Asm,size_t Len)420 void LLVMAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm, size_t Len) {
421   unwrap(M)->appendModuleInlineAsm(StringRef(Asm, Len));
422 }
423 
LLVMGetModuleInlineAsm(LLVMModuleRef M,size_t * Len)424 const char *LLVMGetModuleInlineAsm(LLVMModuleRef M, size_t *Len) {
425   auto &Str = unwrap(M)->getModuleInlineAsm();
426   *Len = Str.length();
427   return Str.c_str();
428 }
429 
LLVMGetInlineAsm(LLVMTypeRef Ty,char * AsmString,size_t AsmStringSize,char * Constraints,size_t ConstraintsSize,LLVMBool HasSideEffects,LLVMBool IsAlignStack,LLVMInlineAsmDialect Dialect)430 LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty,
431                               char *AsmString, size_t AsmStringSize,
432                               char *Constraints, size_t ConstraintsSize,
433                               LLVMBool HasSideEffects, LLVMBool IsAlignStack,
434                               LLVMInlineAsmDialect Dialect) {
435   InlineAsm::AsmDialect AD;
436   switch (Dialect) {
437   case LLVMInlineAsmDialectATT:
438     AD = InlineAsm::AD_ATT;
439     break;
440   case LLVMInlineAsmDialectIntel:
441     AD = InlineAsm::AD_Intel;
442     break;
443   }
444   return wrap(InlineAsm::get(unwrap<FunctionType>(Ty),
445                              StringRef(AsmString, AsmStringSize),
446                              StringRef(Constraints, ConstraintsSize),
447                              HasSideEffects, IsAlignStack, AD));
448 }
449 
450 
451 /*--.. Operations on module contexts ......................................--*/
LLVMGetModuleContext(LLVMModuleRef M)452 LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M) {
453   return wrap(&unwrap(M)->getContext());
454 }
455 
456 
457 /*===-- Operations on types -----------------------------------------------===*/
458 
459 /*--.. Operations on all types (mostly) ....................................--*/
460 
LLVMGetTypeKind(LLVMTypeRef Ty)461 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) {
462   switch (unwrap(Ty)->getTypeID()) {
463   case Type::VoidTyID:
464     return LLVMVoidTypeKind;
465   case Type::HalfTyID:
466     return LLVMHalfTypeKind;
467   case Type::FloatTyID:
468     return LLVMFloatTypeKind;
469   case Type::DoubleTyID:
470     return LLVMDoubleTypeKind;
471   case Type::X86_FP80TyID:
472     return LLVMX86_FP80TypeKind;
473   case Type::FP128TyID:
474     return LLVMFP128TypeKind;
475   case Type::PPC_FP128TyID:
476     return LLVMPPC_FP128TypeKind;
477   case Type::LabelTyID:
478     return LLVMLabelTypeKind;
479   case Type::MetadataTyID:
480     return LLVMMetadataTypeKind;
481   case Type::IntegerTyID:
482     return LLVMIntegerTypeKind;
483   case Type::FunctionTyID:
484     return LLVMFunctionTypeKind;
485   case Type::StructTyID:
486     return LLVMStructTypeKind;
487   case Type::ArrayTyID:
488     return LLVMArrayTypeKind;
489   case Type::PointerTyID:
490     return LLVMPointerTypeKind;
491   case Type::VectorTyID:
492     return LLVMVectorTypeKind;
493   case Type::X86_MMXTyID:
494     return LLVMX86_MMXTypeKind;
495   case Type::TokenTyID:
496     return LLVMTokenTypeKind;
497   }
498   llvm_unreachable("Unhandled TypeID.");
499 }
500 
LLVMTypeIsSized(LLVMTypeRef Ty)501 LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty)
502 {
503     return unwrap(Ty)->isSized();
504 }
505 
LLVMGetTypeContext(LLVMTypeRef Ty)506 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty) {
507   return wrap(&unwrap(Ty)->getContext());
508 }
509 
LLVMDumpType(LLVMTypeRef Ty)510 void LLVMDumpType(LLVMTypeRef Ty) {
511   return unwrap(Ty)->print(errs(), /*IsForDebug=*/true);
512 }
513 
LLVMPrintTypeToString(LLVMTypeRef Ty)514 char *LLVMPrintTypeToString(LLVMTypeRef Ty) {
515   std::string buf;
516   raw_string_ostream os(buf);
517 
518   if (unwrap(Ty))
519     unwrap(Ty)->print(os);
520   else
521     os << "Printing <null> Type";
522 
523   os.flush();
524 
525   return strdup(buf.c_str());
526 }
527 
528 /*--.. Operations on integer types .........................................--*/
529 
LLVMInt1TypeInContext(LLVMContextRef C)530 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C)  {
531   return (LLVMTypeRef) Type::getInt1Ty(*unwrap(C));
532 }
LLVMInt8TypeInContext(LLVMContextRef C)533 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C)  {
534   return (LLVMTypeRef) Type::getInt8Ty(*unwrap(C));
535 }
LLVMInt16TypeInContext(LLVMContextRef C)536 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C) {
537   return (LLVMTypeRef) Type::getInt16Ty(*unwrap(C));
538 }
LLVMInt32TypeInContext(LLVMContextRef C)539 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C) {
540   return (LLVMTypeRef) Type::getInt32Ty(*unwrap(C));
541 }
LLVMInt64TypeInContext(LLVMContextRef C)542 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C) {
543   return (LLVMTypeRef) Type::getInt64Ty(*unwrap(C));
544 }
LLVMInt128TypeInContext(LLVMContextRef C)545 LLVMTypeRef LLVMInt128TypeInContext(LLVMContextRef C) {
546   return (LLVMTypeRef) Type::getInt128Ty(*unwrap(C));
547 }
LLVMIntTypeInContext(LLVMContextRef C,unsigned NumBits)548 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits) {
549   return wrap(IntegerType::get(*unwrap(C), NumBits));
550 }
551 
LLVMInt1Type(void)552 LLVMTypeRef LLVMInt1Type(void)  {
553   return LLVMInt1TypeInContext(LLVMGetGlobalContext());
554 }
LLVMInt8Type(void)555 LLVMTypeRef LLVMInt8Type(void)  {
556   return LLVMInt8TypeInContext(LLVMGetGlobalContext());
557 }
LLVMInt16Type(void)558 LLVMTypeRef LLVMInt16Type(void) {
559   return LLVMInt16TypeInContext(LLVMGetGlobalContext());
560 }
LLVMInt32Type(void)561 LLVMTypeRef LLVMInt32Type(void) {
562   return LLVMInt32TypeInContext(LLVMGetGlobalContext());
563 }
LLVMInt64Type(void)564 LLVMTypeRef LLVMInt64Type(void) {
565   return LLVMInt64TypeInContext(LLVMGetGlobalContext());
566 }
LLVMInt128Type(void)567 LLVMTypeRef LLVMInt128Type(void) {
568   return LLVMInt128TypeInContext(LLVMGetGlobalContext());
569 }
LLVMIntType(unsigned NumBits)570 LLVMTypeRef LLVMIntType(unsigned NumBits) {
571   return LLVMIntTypeInContext(LLVMGetGlobalContext(), NumBits);
572 }
573 
LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy)574 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy) {
575   return unwrap<IntegerType>(IntegerTy)->getBitWidth();
576 }
577 
578 /*--.. Operations on real types ............................................--*/
579 
LLVMHalfTypeInContext(LLVMContextRef C)580 LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C) {
581   return (LLVMTypeRef) Type::getHalfTy(*unwrap(C));
582 }
LLVMFloatTypeInContext(LLVMContextRef C)583 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C) {
584   return (LLVMTypeRef) Type::getFloatTy(*unwrap(C));
585 }
LLVMDoubleTypeInContext(LLVMContextRef C)586 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C) {
587   return (LLVMTypeRef) Type::getDoubleTy(*unwrap(C));
588 }
LLVMX86FP80TypeInContext(LLVMContextRef C)589 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C) {
590   return (LLVMTypeRef) Type::getX86_FP80Ty(*unwrap(C));
591 }
LLVMFP128TypeInContext(LLVMContextRef C)592 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C) {
593   return (LLVMTypeRef) Type::getFP128Ty(*unwrap(C));
594 }
LLVMPPCFP128TypeInContext(LLVMContextRef C)595 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C) {
596   return (LLVMTypeRef) Type::getPPC_FP128Ty(*unwrap(C));
597 }
LLVMX86MMXTypeInContext(LLVMContextRef C)598 LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C) {
599   return (LLVMTypeRef) Type::getX86_MMXTy(*unwrap(C));
600 }
601 
LLVMHalfType(void)602 LLVMTypeRef LLVMHalfType(void) {
603   return LLVMHalfTypeInContext(LLVMGetGlobalContext());
604 }
LLVMFloatType(void)605 LLVMTypeRef LLVMFloatType(void) {
606   return LLVMFloatTypeInContext(LLVMGetGlobalContext());
607 }
LLVMDoubleType(void)608 LLVMTypeRef LLVMDoubleType(void) {
609   return LLVMDoubleTypeInContext(LLVMGetGlobalContext());
610 }
LLVMX86FP80Type(void)611 LLVMTypeRef LLVMX86FP80Type(void) {
612   return LLVMX86FP80TypeInContext(LLVMGetGlobalContext());
613 }
LLVMFP128Type(void)614 LLVMTypeRef LLVMFP128Type(void) {
615   return LLVMFP128TypeInContext(LLVMGetGlobalContext());
616 }
LLVMPPCFP128Type(void)617 LLVMTypeRef LLVMPPCFP128Type(void) {
618   return LLVMPPCFP128TypeInContext(LLVMGetGlobalContext());
619 }
LLVMX86MMXType(void)620 LLVMTypeRef LLVMX86MMXType(void) {
621   return LLVMX86MMXTypeInContext(LLVMGetGlobalContext());
622 }
623 
624 /*--.. Operations on function types ........................................--*/
625 
LLVMFunctionType(LLVMTypeRef ReturnType,LLVMTypeRef * ParamTypes,unsigned ParamCount,LLVMBool IsVarArg)626 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
627                              LLVMTypeRef *ParamTypes, unsigned ParamCount,
628                              LLVMBool IsVarArg) {
629   ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
630   return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0));
631 }
632 
LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy)633 LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) {
634   return unwrap<FunctionType>(FunctionTy)->isVarArg();
635 }
636 
LLVMGetReturnType(LLVMTypeRef FunctionTy)637 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy) {
638   return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType());
639 }
640 
LLVMCountParamTypes(LLVMTypeRef FunctionTy)641 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy) {
642   return unwrap<FunctionType>(FunctionTy)->getNumParams();
643 }
644 
LLVMGetParamTypes(LLVMTypeRef FunctionTy,LLVMTypeRef * Dest)645 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest) {
646   FunctionType *Ty = unwrap<FunctionType>(FunctionTy);
647   for (FunctionType::param_iterator I = Ty->param_begin(),
648                                     E = Ty->param_end(); I != E; ++I)
649     *Dest++ = wrap(*I);
650 }
651 
652 /*--.. Operations on struct types ..........................................--*/
653 
LLVMStructTypeInContext(LLVMContextRef C,LLVMTypeRef * ElementTypes,unsigned ElementCount,LLVMBool Packed)654 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
655                            unsigned ElementCount, LLVMBool Packed) {
656   ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount);
657   return wrap(StructType::get(*unwrap(C), Tys, Packed != 0));
658 }
659 
LLVMStructType(LLVMTypeRef * ElementTypes,unsigned ElementCount,LLVMBool Packed)660 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes,
661                            unsigned ElementCount, LLVMBool Packed) {
662   return LLVMStructTypeInContext(LLVMGetGlobalContext(), ElementTypes,
663                                  ElementCount, Packed);
664 }
665 
LLVMStructCreateNamed(LLVMContextRef C,const char * Name)666 LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name)
667 {
668   return wrap(StructType::create(*unwrap(C), Name));
669 }
670 
LLVMGetStructName(LLVMTypeRef Ty)671 const char *LLVMGetStructName(LLVMTypeRef Ty)
672 {
673   StructType *Type = unwrap<StructType>(Ty);
674   if (!Type->hasName())
675     return nullptr;
676   return Type->getName().data();
677 }
678 
LLVMStructSetBody(LLVMTypeRef StructTy,LLVMTypeRef * ElementTypes,unsigned ElementCount,LLVMBool Packed)679 void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes,
680                        unsigned ElementCount, LLVMBool Packed) {
681   ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount);
682   unwrap<StructType>(StructTy)->setBody(Tys, Packed != 0);
683 }
684 
LLVMCountStructElementTypes(LLVMTypeRef StructTy)685 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy) {
686   return unwrap<StructType>(StructTy)->getNumElements();
687 }
688 
LLVMGetStructElementTypes(LLVMTypeRef StructTy,LLVMTypeRef * Dest)689 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest) {
690   StructType *Ty = unwrap<StructType>(StructTy);
691   for (StructType::element_iterator I = Ty->element_begin(),
692                                     E = Ty->element_end(); I != E; ++I)
693     *Dest++ = wrap(*I);
694 }
695 
LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy,unsigned i)696 LLVMTypeRef LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy, unsigned i) {
697   StructType *Ty = unwrap<StructType>(StructTy);
698   return wrap(Ty->getTypeAtIndex(i));
699 }
700 
LLVMIsPackedStruct(LLVMTypeRef StructTy)701 LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy) {
702   return unwrap<StructType>(StructTy)->isPacked();
703 }
704 
LLVMIsOpaqueStruct(LLVMTypeRef StructTy)705 LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy) {
706   return unwrap<StructType>(StructTy)->isOpaque();
707 }
708 
LLVMGetTypeByName(LLVMModuleRef M,const char * Name)709 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name) {
710   return wrap(unwrap(M)->getTypeByName(Name));
711 }
712 
713 /*--.. Operations on array, pointer, and vector types (sequence types) .....--*/
714 
LLVMGetSubtypes(LLVMTypeRef Tp,LLVMTypeRef * Arr)715 void LLVMGetSubtypes(LLVMTypeRef Tp, LLVMTypeRef *Arr) {
716     int i = 0;
717     for (auto *T : unwrap(Tp)->subtypes()) {
718         Arr[i] = wrap(T);
719         i++;
720     }
721 }
722 
LLVMArrayType(LLVMTypeRef ElementType,unsigned ElementCount)723 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount) {
724   return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
725 }
726 
LLVMPointerType(LLVMTypeRef ElementType,unsigned AddressSpace)727 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace) {
728   return wrap(PointerType::get(unwrap(ElementType), AddressSpace));
729 }
730 
LLVMVectorType(LLVMTypeRef ElementType,unsigned ElementCount)731 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) {
732   return wrap(VectorType::get(unwrap(ElementType), ElementCount));
733 }
734 
LLVMGetElementType(LLVMTypeRef WrappedTy)735 LLVMTypeRef LLVMGetElementType(LLVMTypeRef WrappedTy) {
736   auto *Ty = unwrap<Type>(WrappedTy);
737   if (auto *PTy = dyn_cast<PointerType>(Ty))
738     return wrap(PTy->getElementType());
739   return wrap(cast<SequentialType>(Ty)->getElementType());
740 }
741 
LLVMGetNumContainedTypes(LLVMTypeRef Tp)742 unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp) {
743     return unwrap(Tp)->getNumContainedTypes();
744 }
745 
LLVMGetArrayLength(LLVMTypeRef ArrayTy)746 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) {
747   return unwrap<ArrayType>(ArrayTy)->getNumElements();
748 }
749 
LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy)750 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy) {
751   return unwrap<PointerType>(PointerTy)->getAddressSpace();
752 }
753 
LLVMGetVectorSize(LLVMTypeRef VectorTy)754 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) {
755   return unwrap<VectorType>(VectorTy)->getNumElements();
756 }
757 
758 /*--.. Operations on other types ...........................................--*/
759 
LLVMVoidTypeInContext(LLVMContextRef C)760 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C)  {
761   return wrap(Type::getVoidTy(*unwrap(C)));
762 }
LLVMLabelTypeInContext(LLVMContextRef C)763 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C) {
764   return wrap(Type::getLabelTy(*unwrap(C)));
765 }
LLVMTokenTypeInContext(LLVMContextRef C)766 LLVMTypeRef LLVMTokenTypeInContext(LLVMContextRef C) {
767   return wrap(Type::getTokenTy(*unwrap(C)));
768 }
LLVMMetadataTypeInContext(LLVMContextRef C)769 LLVMTypeRef LLVMMetadataTypeInContext(LLVMContextRef C) {
770   return wrap(Type::getMetadataTy(*unwrap(C)));
771 }
772 
LLVMVoidType(void)773 LLVMTypeRef LLVMVoidType(void)  {
774   return LLVMVoidTypeInContext(LLVMGetGlobalContext());
775 }
LLVMLabelType(void)776 LLVMTypeRef LLVMLabelType(void) {
777   return LLVMLabelTypeInContext(LLVMGetGlobalContext());
778 }
779 
780 /*===-- Operations on values ----------------------------------------------===*/
781 
782 /*--.. Operations on all values ............................................--*/
783 
LLVMTypeOf(LLVMValueRef Val)784 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val) {
785   return wrap(unwrap(Val)->getType());
786 }
787 
LLVMGetValueKind(LLVMValueRef Val)788 LLVMValueKind LLVMGetValueKind(LLVMValueRef Val) {
789     switch(unwrap(Val)->getValueID()) {
790 #define HANDLE_VALUE(Name) \
791   case Value::Name##Val: \
792     return LLVM##Name##ValueKind;
793 #include "llvm/IR/Value.def"
794   default:
795     return LLVMInstructionValueKind;
796   }
797 }
798 
LLVMGetValueName2(LLVMValueRef Val,size_t * Length)799 const char *LLVMGetValueName2(LLVMValueRef Val, size_t *Length) {
800   auto *V = unwrap(Val);
801   *Length = V->getName().size();
802   return V->getName().data();
803 }
804 
LLVMSetValueName2(LLVMValueRef Val,const char * Name,size_t NameLen)805 void LLVMSetValueName2(LLVMValueRef Val, const char *Name, size_t NameLen) {
806   unwrap(Val)->setName(StringRef(Name, NameLen));
807 }
808 
LLVMGetValueName(LLVMValueRef Val)809 const char *LLVMGetValueName(LLVMValueRef Val) {
810   return unwrap(Val)->getName().data();
811 }
812 
LLVMSetValueName(LLVMValueRef Val,const char * Name)813 void LLVMSetValueName(LLVMValueRef Val, const char *Name) {
814   unwrap(Val)->setName(Name);
815 }
816 
LLVMDumpValue(LLVMValueRef Val)817 void LLVMDumpValue(LLVMValueRef Val) {
818   unwrap(Val)->print(errs(), /*IsForDebug=*/true);
819 }
820 
LLVMPrintValueToString(LLVMValueRef Val)821 char* LLVMPrintValueToString(LLVMValueRef Val) {
822   std::string buf;
823   raw_string_ostream os(buf);
824 
825   if (unwrap(Val))
826     unwrap(Val)->print(os);
827   else
828     os << "Printing <null> Value";
829 
830   os.flush();
831 
832   return strdup(buf.c_str());
833 }
834 
LLVMReplaceAllUsesWith(LLVMValueRef OldVal,LLVMValueRef NewVal)835 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal) {
836   unwrap(OldVal)->replaceAllUsesWith(unwrap(NewVal));
837 }
838 
LLVMHasMetadata(LLVMValueRef Inst)839 int LLVMHasMetadata(LLVMValueRef Inst) {
840   return unwrap<Instruction>(Inst)->hasMetadata();
841 }
842 
LLVMGetMetadata(LLVMValueRef Inst,unsigned KindID)843 LLVMValueRef LLVMGetMetadata(LLVMValueRef Inst, unsigned KindID) {
844   auto *I = unwrap<Instruction>(Inst);
845   assert(I && "Expected instruction");
846   if (auto *MD = I->getMetadata(KindID))
847     return wrap(MetadataAsValue::get(I->getContext(), MD));
848   return nullptr;
849 }
850 
851 // MetadataAsValue uses a canonical format which strips the actual MDNode for
852 // MDNode with just a single constant value, storing just a ConstantAsMetadata
853 // This undoes this canonicalization, reconstructing the MDNode.
extractMDNode(MetadataAsValue * MAV)854 static MDNode *extractMDNode(MetadataAsValue *MAV) {
855   Metadata *MD = MAV->getMetadata();
856   assert((isa<MDNode>(MD) || isa<ConstantAsMetadata>(MD)) &&
857       "Expected a metadata node or a canonicalized constant");
858 
859   if (MDNode *N = dyn_cast<MDNode>(MD))
860     return N;
861 
862   return MDNode::get(MAV->getContext(), MD);
863 }
864 
LLVMSetMetadata(LLVMValueRef Inst,unsigned KindID,LLVMValueRef Val)865 void LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef Val) {
866   MDNode *N = Val ? extractMDNode(unwrap<MetadataAsValue>(Val)) : nullptr;
867 
868   unwrap<Instruction>(Inst)->setMetadata(KindID, N);
869 }
870 
871 /*--.. Conversion functions ................................................--*/
872 
873 #define LLVM_DEFINE_VALUE_CAST(name)                                       \
874   LLVMValueRef LLVMIsA##name(LLVMValueRef Val) {                           \
875     return wrap(static_cast<Value*>(dyn_cast_or_null<name>(unwrap(Val)))); \
876   }
877 
LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DEFINE_VALUE_CAST)878 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DEFINE_VALUE_CAST)
879 
880 LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val) {
881   if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
882     if (isa<MDNode>(MD->getMetadata()) ||
883         isa<ValueAsMetadata>(MD->getMetadata()))
884       return Val;
885   return nullptr;
886 }
887 
LLVMIsAMDString(LLVMValueRef Val)888 LLVMValueRef LLVMIsAMDString(LLVMValueRef Val) {
889   if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
890     if (isa<MDString>(MD->getMetadata()))
891       return Val;
892   return nullptr;
893 }
894 
895 /*--.. Operations on Uses ..................................................--*/
LLVMGetFirstUse(LLVMValueRef Val)896 LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val) {
897   Value *V = unwrap(Val);
898   Value::use_iterator I = V->use_begin();
899   if (I == V->use_end())
900     return nullptr;
901   return wrap(&*I);
902 }
903 
LLVMGetNextUse(LLVMUseRef U)904 LLVMUseRef LLVMGetNextUse(LLVMUseRef U) {
905   Use *Next = unwrap(U)->getNext();
906   if (Next)
907     return wrap(Next);
908   return nullptr;
909 }
910 
LLVMGetUser(LLVMUseRef U)911 LLVMValueRef LLVMGetUser(LLVMUseRef U) {
912   return wrap(unwrap(U)->getUser());
913 }
914 
LLVMGetUsedValue(LLVMUseRef U)915 LLVMValueRef LLVMGetUsedValue(LLVMUseRef U) {
916   return wrap(unwrap(U)->get());
917 }
918 
919 /*--.. Operations on Users .................................................--*/
920 
getMDNodeOperandImpl(LLVMContext & Context,const MDNode * N,unsigned Index)921 static LLVMValueRef getMDNodeOperandImpl(LLVMContext &Context, const MDNode *N,
922                                          unsigned Index) {
923   Metadata *Op = N->getOperand(Index);
924   if (!Op)
925     return nullptr;
926   if (auto *C = dyn_cast<ConstantAsMetadata>(Op))
927     return wrap(C->getValue());
928   return wrap(MetadataAsValue::get(Context, Op));
929 }
930 
LLVMGetOperand(LLVMValueRef Val,unsigned Index)931 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index) {
932   Value *V = unwrap(Val);
933   if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
934     if (auto *L = dyn_cast<ValueAsMetadata>(MD->getMetadata())) {
935       assert(Index == 0 && "Function-local metadata can only have one operand");
936       return wrap(L->getValue());
937     }
938     return getMDNodeOperandImpl(V->getContext(),
939                                 cast<MDNode>(MD->getMetadata()), Index);
940   }
941 
942   return wrap(cast<User>(V)->getOperand(Index));
943 }
944 
LLVMGetOperandUse(LLVMValueRef Val,unsigned Index)945 LLVMUseRef LLVMGetOperandUse(LLVMValueRef Val, unsigned Index) {
946   Value *V = unwrap(Val);
947   return wrap(&cast<User>(V)->getOperandUse(Index));
948 }
949 
LLVMSetOperand(LLVMValueRef Val,unsigned Index,LLVMValueRef Op)950 void LLVMSetOperand(LLVMValueRef Val, unsigned Index, LLVMValueRef Op) {
951   unwrap<User>(Val)->setOperand(Index, unwrap(Op));
952 }
953 
LLVMGetNumOperands(LLVMValueRef Val)954 int LLVMGetNumOperands(LLVMValueRef Val) {
955   Value *V = unwrap(Val);
956   if (isa<MetadataAsValue>(V))
957     return LLVMGetMDNodeNumOperands(Val);
958 
959   return cast<User>(V)->getNumOperands();
960 }
961 
962 /*--.. Operations on constants of any type .................................--*/
963 
LLVMConstNull(LLVMTypeRef Ty)964 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty) {
965   return wrap(Constant::getNullValue(unwrap(Ty)));
966 }
967 
LLVMConstAllOnes(LLVMTypeRef Ty)968 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty) {
969   return wrap(Constant::getAllOnesValue(unwrap(Ty)));
970 }
971 
LLVMGetUndef(LLVMTypeRef Ty)972 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) {
973   return wrap(UndefValue::get(unwrap(Ty)));
974 }
975 
LLVMIsConstant(LLVMValueRef Ty)976 LLVMBool LLVMIsConstant(LLVMValueRef Ty) {
977   return isa<Constant>(unwrap(Ty));
978 }
979 
LLVMIsNull(LLVMValueRef Val)980 LLVMBool LLVMIsNull(LLVMValueRef Val) {
981   if (Constant *C = dyn_cast<Constant>(unwrap(Val)))
982     return C->isNullValue();
983   return false;
984 }
985 
LLVMIsUndef(LLVMValueRef Val)986 LLVMBool LLVMIsUndef(LLVMValueRef Val) {
987   return isa<UndefValue>(unwrap(Val));
988 }
989 
LLVMConstPointerNull(LLVMTypeRef Ty)990 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) {
991   return wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty)));
992 }
993 
994 /*--.. Operations on metadata nodes ........................................--*/
995 
LLVMMDStringInContext(LLVMContextRef C,const char * Str,unsigned SLen)996 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
997                                    unsigned SLen) {
998   LLVMContext &Context = *unwrap(C);
999   return wrap(MetadataAsValue::get(
1000       Context, MDString::get(Context, StringRef(Str, SLen))));
1001 }
1002 
LLVMMDString(const char * Str,unsigned SLen)1003 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen) {
1004   return LLVMMDStringInContext(LLVMGetGlobalContext(), Str, SLen);
1005 }
1006 
LLVMMDNodeInContext(LLVMContextRef C,LLVMValueRef * Vals,unsigned Count)1007 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
1008                                  unsigned Count) {
1009   LLVMContext &Context = *unwrap(C);
1010   SmallVector<Metadata *, 8> MDs;
1011   for (auto *OV : makeArrayRef(Vals, Count)) {
1012     Value *V = unwrap(OV);
1013     Metadata *MD;
1014     if (!V)
1015       MD = nullptr;
1016     else if (auto *C = dyn_cast<Constant>(V))
1017       MD = ConstantAsMetadata::get(C);
1018     else if (auto *MDV = dyn_cast<MetadataAsValue>(V)) {
1019       MD = MDV->getMetadata();
1020       assert(!isa<LocalAsMetadata>(MD) && "Unexpected function-local metadata "
1021                                           "outside of direct argument to call");
1022     } else {
1023       // This is function-local metadata.  Pretend to make an MDNode.
1024       assert(Count == 1 &&
1025              "Expected only one operand to function-local metadata");
1026       return wrap(MetadataAsValue::get(Context, LocalAsMetadata::get(V)));
1027     }
1028 
1029     MDs.push_back(MD);
1030   }
1031   return wrap(MetadataAsValue::get(Context, MDNode::get(Context, MDs)));
1032 }
1033 
LLVMMDNode(LLVMValueRef * Vals,unsigned Count)1034 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count) {
1035   return LLVMMDNodeInContext(LLVMGetGlobalContext(), Vals, Count);
1036 }
1037 
LLVMMetadataAsValue(LLVMContextRef C,LLVMMetadataRef MD)1038 LLVMValueRef LLVMMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD) {
1039   return wrap(MetadataAsValue::get(*unwrap(C), unwrap(MD)));
1040 }
1041 
LLVMValueAsMetadata(LLVMValueRef Val)1042 LLVMMetadataRef LLVMValueAsMetadata(LLVMValueRef Val) {
1043   auto *V = unwrap(Val);
1044   if (auto *C = dyn_cast<Constant>(V))
1045     return wrap(ConstantAsMetadata::get(C));
1046   if (auto *MAV = dyn_cast<MetadataAsValue>(V))
1047     return wrap(MAV->getMetadata());
1048   return wrap(ValueAsMetadata::get(V));
1049 }
1050 
LLVMGetMDString(LLVMValueRef V,unsigned * Length)1051 const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length) {
1052   if (const auto *MD = dyn_cast<MetadataAsValue>(unwrap(V)))
1053     if (const MDString *S = dyn_cast<MDString>(MD->getMetadata())) {
1054       *Length = S->getString().size();
1055       return S->getString().data();
1056     }
1057   *Length = 0;
1058   return nullptr;
1059 }
1060 
LLVMGetMDNodeNumOperands(LLVMValueRef V)1061 unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V) {
1062   auto *MD = cast<MetadataAsValue>(unwrap(V));
1063   if (isa<ValueAsMetadata>(MD->getMetadata()))
1064     return 1;
1065   return cast<MDNode>(MD->getMetadata())->getNumOperands();
1066 }
1067 
LLVMGetMDNodeOperands(LLVMValueRef V,LLVMValueRef * Dest)1068 void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest) {
1069   auto *MD = cast<MetadataAsValue>(unwrap(V));
1070   if (auto *MDV = dyn_cast<ValueAsMetadata>(MD->getMetadata())) {
1071     *Dest = wrap(MDV->getValue());
1072     return;
1073   }
1074   const auto *N = cast<MDNode>(MD->getMetadata());
1075   const unsigned numOperands = N->getNumOperands();
1076   LLVMContext &Context = unwrap(V)->getContext();
1077   for (unsigned i = 0; i < numOperands; i++)
1078     Dest[i] = getMDNodeOperandImpl(Context, N, i);
1079 }
1080 
LLVMGetNamedMetadataNumOperands(LLVMModuleRef M,const char * Name)1081 unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char *Name) {
1082   if (NamedMDNode *N = unwrap(M)->getNamedMetadata(Name)) {
1083     return N->getNumOperands();
1084   }
1085   return 0;
1086 }
1087 
LLVMGetNamedMetadataOperands(LLVMModuleRef M,const char * Name,LLVMValueRef * Dest)1088 void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char *Name,
1089                                   LLVMValueRef *Dest) {
1090   NamedMDNode *N = unwrap(M)->getNamedMetadata(Name);
1091   if (!N)
1092     return;
1093   LLVMContext &Context = unwrap(M)->getContext();
1094   for (unsigned i=0;i<N->getNumOperands();i++)
1095     Dest[i] = wrap(MetadataAsValue::get(Context, N->getOperand(i)));
1096 }
1097 
LLVMAddNamedMetadataOperand(LLVMModuleRef M,const char * Name,LLVMValueRef Val)1098 void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char *Name,
1099                                  LLVMValueRef Val) {
1100   NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(Name);
1101   if (!N)
1102     return;
1103   if (!Val)
1104     return;
1105   N->addOperand(extractMDNode(unwrap<MetadataAsValue>(Val)));
1106 }
1107 
1108 /*--.. Operations on scalar constants ......................................--*/
1109 
LLVMConstInt(LLVMTypeRef IntTy,unsigned long long N,LLVMBool SignExtend)1110 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
1111                           LLVMBool SignExtend) {
1112   return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0));
1113 }
1114 
LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy,unsigned NumWords,const uint64_t Words[])1115 LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy,
1116                                               unsigned NumWords,
1117                                               const uint64_t Words[]) {
1118     IntegerType *Ty = unwrap<IntegerType>(IntTy);
1119     return wrap(ConstantInt::get(Ty->getContext(),
1120                                  APInt(Ty->getBitWidth(),
1121                                        makeArrayRef(Words, NumWords))));
1122 }
1123 
LLVMConstIntOfString(LLVMTypeRef IntTy,const char Str[],uint8_t Radix)1124 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char Str[],
1125                                   uint8_t Radix) {
1126   return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str),
1127                                Radix));
1128 }
1129 
LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy,const char Str[],unsigned SLen,uint8_t Radix)1130 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char Str[],
1131                                          unsigned SLen, uint8_t Radix) {
1132   return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str, SLen),
1133                                Radix));
1134 }
1135 
LLVMConstReal(LLVMTypeRef RealTy,double N)1136 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N) {
1137   return wrap(ConstantFP::get(unwrap(RealTy), N));
1138 }
1139 
LLVMConstRealOfString(LLVMTypeRef RealTy,const char * Text)1140 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text) {
1141   return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Text)));
1142 }
1143 
LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy,const char Str[],unsigned SLen)1144 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char Str[],
1145                                           unsigned SLen) {
1146   return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Str, SLen)));
1147 }
1148 
LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal)1149 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal) {
1150   return unwrap<ConstantInt>(ConstantVal)->getZExtValue();
1151 }
1152 
LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal)1153 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal) {
1154   return unwrap<ConstantInt>(ConstantVal)->getSExtValue();
1155 }
1156 
LLVMConstRealGetDouble(LLVMValueRef ConstantVal,LLVMBool * LosesInfo)1157 double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *LosesInfo) {
1158   ConstantFP *cFP = unwrap<ConstantFP>(ConstantVal) ;
1159   Type *Ty = cFP->getType();
1160 
1161   if (Ty->isFloatTy()) {
1162     *LosesInfo = false;
1163     return cFP->getValueAPF().convertToFloat();
1164   }
1165 
1166   if (Ty->isDoubleTy()) {
1167     *LosesInfo = false;
1168     return cFP->getValueAPF().convertToDouble();
1169   }
1170 
1171   bool APFLosesInfo;
1172   APFloat APF = cFP->getValueAPF();
1173   APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &APFLosesInfo);
1174   *LosesInfo = APFLosesInfo;
1175   return APF.convertToDouble();
1176 }
1177 
1178 /*--.. Operations on composite constants ...................................--*/
1179 
LLVMConstStringInContext(LLVMContextRef C,const char * Str,unsigned Length,LLVMBool DontNullTerminate)1180 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
1181                                       unsigned Length,
1182                                       LLVMBool DontNullTerminate) {
1183   /* Inverted the sense of AddNull because ', 0)' is a
1184      better mnemonic for null termination than ', 1)'. */
1185   return wrap(ConstantDataArray::getString(*unwrap(C), StringRef(Str, Length),
1186                                            DontNullTerminate == 0));
1187 }
1188 
LLVMConstString(const char * Str,unsigned Length,LLVMBool DontNullTerminate)1189 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
1190                              LLVMBool DontNullTerminate) {
1191   return LLVMConstStringInContext(LLVMGetGlobalContext(), Str, Length,
1192                                   DontNullTerminate);
1193 }
1194 
LLVMGetElementAsConstant(LLVMValueRef C,unsigned idx)1195 LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef C, unsigned idx) {
1196   return wrap(unwrap<ConstantDataSequential>(C)->getElementAsConstant(idx));
1197 }
1198 
LLVMIsConstantString(LLVMValueRef C)1199 LLVMBool LLVMIsConstantString(LLVMValueRef C) {
1200   return unwrap<ConstantDataSequential>(C)->isString();
1201 }
1202 
LLVMGetAsString(LLVMValueRef C,size_t * Length)1203 const char *LLVMGetAsString(LLVMValueRef C, size_t *Length) {
1204   StringRef Str = unwrap<ConstantDataSequential>(C)->getAsString();
1205   *Length = Str.size();
1206   return Str.data();
1207 }
1208 
LLVMConstArray(LLVMTypeRef ElementTy,LLVMValueRef * ConstantVals,unsigned Length)1209 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
1210                             LLVMValueRef *ConstantVals, unsigned Length) {
1211   ArrayRef<Constant*> V(unwrap<Constant>(ConstantVals, Length), Length);
1212   return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V));
1213 }
1214 
LLVMConstStructInContext(LLVMContextRef C,LLVMValueRef * ConstantVals,unsigned Count,LLVMBool Packed)1215 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
1216                                       LLVMValueRef *ConstantVals,
1217                                       unsigned Count, LLVMBool Packed) {
1218   Constant **Elements = unwrap<Constant>(ConstantVals, Count);
1219   return wrap(ConstantStruct::getAnon(*unwrap(C), makeArrayRef(Elements, Count),
1220                                       Packed != 0));
1221 }
1222 
LLVMConstStruct(LLVMValueRef * ConstantVals,unsigned Count,LLVMBool Packed)1223 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
1224                              LLVMBool Packed) {
1225   return LLVMConstStructInContext(LLVMGetGlobalContext(), ConstantVals, Count,
1226                                   Packed);
1227 }
1228 
LLVMConstNamedStruct(LLVMTypeRef StructTy,LLVMValueRef * ConstantVals,unsigned Count)1229 LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy,
1230                                   LLVMValueRef *ConstantVals,
1231                                   unsigned Count) {
1232   Constant **Elements = unwrap<Constant>(ConstantVals, Count);
1233   StructType *Ty = cast<StructType>(unwrap(StructTy));
1234 
1235   return wrap(ConstantStruct::get(Ty, makeArrayRef(Elements, Count)));
1236 }
1237 
LLVMConstVector(LLVMValueRef * ScalarConstantVals,unsigned Size)1238 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) {
1239   return wrap(ConstantVector::get(makeArrayRef(
1240                             unwrap<Constant>(ScalarConstantVals, Size), Size)));
1241 }
1242 
1243 /*-- Opcode mapping */
1244 
map_to_llvmopcode(int opcode)1245 static LLVMOpcode map_to_llvmopcode(int opcode)
1246 {
1247     switch (opcode) {
1248       default: llvm_unreachable("Unhandled Opcode.");
1249 #define HANDLE_INST(num, opc, clas) case num: return LLVM##opc;
1250 #include "llvm/IR/Instruction.def"
1251 #undef HANDLE_INST
1252     }
1253 }
1254 
map_from_llvmopcode(LLVMOpcode code)1255 static int map_from_llvmopcode(LLVMOpcode code)
1256 {
1257     switch (code) {
1258 #define HANDLE_INST(num, opc, clas) case LLVM##opc: return num;
1259 #include "llvm/IR/Instruction.def"
1260 #undef HANDLE_INST
1261     }
1262     llvm_unreachable("Unhandled Opcode.");
1263 }
1264 
1265 /*--.. Constant expressions ................................................--*/
1266 
LLVMGetConstOpcode(LLVMValueRef ConstantVal)1267 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal) {
1268   return map_to_llvmopcode(unwrap<ConstantExpr>(ConstantVal)->getOpcode());
1269 }
1270 
LLVMAlignOf(LLVMTypeRef Ty)1271 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty) {
1272   return wrap(ConstantExpr::getAlignOf(unwrap(Ty)));
1273 }
1274 
LLVMSizeOf(LLVMTypeRef Ty)1275 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty) {
1276   return wrap(ConstantExpr::getSizeOf(unwrap(Ty)));
1277 }
1278 
LLVMConstNeg(LLVMValueRef ConstantVal)1279 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal) {
1280   return wrap(ConstantExpr::getNeg(unwrap<Constant>(ConstantVal)));
1281 }
1282 
LLVMConstNSWNeg(LLVMValueRef ConstantVal)1283 LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal) {
1284   return wrap(ConstantExpr::getNSWNeg(unwrap<Constant>(ConstantVal)));
1285 }
1286 
LLVMConstNUWNeg(LLVMValueRef ConstantVal)1287 LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal) {
1288   return wrap(ConstantExpr::getNUWNeg(unwrap<Constant>(ConstantVal)));
1289 }
1290 
1291 
LLVMConstFNeg(LLVMValueRef ConstantVal)1292 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal) {
1293   return wrap(ConstantExpr::getFNeg(unwrap<Constant>(ConstantVal)));
1294 }
1295 
LLVMConstNot(LLVMValueRef ConstantVal)1296 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal) {
1297   return wrap(ConstantExpr::getNot(unwrap<Constant>(ConstantVal)));
1298 }
1299 
LLVMConstAdd(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1300 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1301   return wrap(ConstantExpr::getAdd(unwrap<Constant>(LHSConstant),
1302                                    unwrap<Constant>(RHSConstant)));
1303 }
1304 
LLVMConstNSWAdd(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1305 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant,
1306                              LLVMValueRef RHSConstant) {
1307   return wrap(ConstantExpr::getNSWAdd(unwrap<Constant>(LHSConstant),
1308                                       unwrap<Constant>(RHSConstant)));
1309 }
1310 
LLVMConstNUWAdd(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1311 LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant,
1312                              LLVMValueRef RHSConstant) {
1313   return wrap(ConstantExpr::getNUWAdd(unwrap<Constant>(LHSConstant),
1314                                       unwrap<Constant>(RHSConstant)));
1315 }
1316 
LLVMConstFAdd(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1317 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1318   return wrap(ConstantExpr::getFAdd(unwrap<Constant>(LHSConstant),
1319                                     unwrap<Constant>(RHSConstant)));
1320 }
1321 
LLVMConstSub(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1322 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1323   return wrap(ConstantExpr::getSub(unwrap<Constant>(LHSConstant),
1324                                    unwrap<Constant>(RHSConstant)));
1325 }
1326 
LLVMConstNSWSub(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1327 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant,
1328                              LLVMValueRef RHSConstant) {
1329   return wrap(ConstantExpr::getNSWSub(unwrap<Constant>(LHSConstant),
1330                                       unwrap<Constant>(RHSConstant)));
1331 }
1332 
LLVMConstNUWSub(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1333 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant,
1334                              LLVMValueRef RHSConstant) {
1335   return wrap(ConstantExpr::getNUWSub(unwrap<Constant>(LHSConstant),
1336                                       unwrap<Constant>(RHSConstant)));
1337 }
1338 
LLVMConstFSub(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1339 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1340   return wrap(ConstantExpr::getFSub(unwrap<Constant>(LHSConstant),
1341                                     unwrap<Constant>(RHSConstant)));
1342 }
1343 
LLVMConstMul(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1344 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1345   return wrap(ConstantExpr::getMul(unwrap<Constant>(LHSConstant),
1346                                    unwrap<Constant>(RHSConstant)));
1347 }
1348 
LLVMConstNSWMul(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1349 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant,
1350                              LLVMValueRef RHSConstant) {
1351   return wrap(ConstantExpr::getNSWMul(unwrap<Constant>(LHSConstant),
1352                                       unwrap<Constant>(RHSConstant)));
1353 }
1354 
LLVMConstNUWMul(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1355 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant,
1356                              LLVMValueRef RHSConstant) {
1357   return wrap(ConstantExpr::getNUWMul(unwrap<Constant>(LHSConstant),
1358                                       unwrap<Constant>(RHSConstant)));
1359 }
1360 
LLVMConstFMul(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1361 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1362   return wrap(ConstantExpr::getFMul(unwrap<Constant>(LHSConstant),
1363                                     unwrap<Constant>(RHSConstant)));
1364 }
1365 
LLVMConstUDiv(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1366 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1367   return wrap(ConstantExpr::getUDiv(unwrap<Constant>(LHSConstant),
1368                                     unwrap<Constant>(RHSConstant)));
1369 }
1370 
LLVMConstExactUDiv(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1371 LLVMValueRef LLVMConstExactUDiv(LLVMValueRef LHSConstant,
1372                                 LLVMValueRef RHSConstant) {
1373   return wrap(ConstantExpr::getExactUDiv(unwrap<Constant>(LHSConstant),
1374                                          unwrap<Constant>(RHSConstant)));
1375 }
1376 
LLVMConstSDiv(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1377 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1378   return wrap(ConstantExpr::getSDiv(unwrap<Constant>(LHSConstant),
1379                                     unwrap<Constant>(RHSConstant)));
1380 }
1381 
LLVMConstExactSDiv(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1382 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant,
1383                                 LLVMValueRef RHSConstant) {
1384   return wrap(ConstantExpr::getExactSDiv(unwrap<Constant>(LHSConstant),
1385                                          unwrap<Constant>(RHSConstant)));
1386 }
1387 
LLVMConstFDiv(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1388 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1389   return wrap(ConstantExpr::getFDiv(unwrap<Constant>(LHSConstant),
1390                                     unwrap<Constant>(RHSConstant)));
1391 }
1392 
LLVMConstURem(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1393 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1394   return wrap(ConstantExpr::getURem(unwrap<Constant>(LHSConstant),
1395                                     unwrap<Constant>(RHSConstant)));
1396 }
1397 
LLVMConstSRem(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1398 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1399   return wrap(ConstantExpr::getSRem(unwrap<Constant>(LHSConstant),
1400                                     unwrap<Constant>(RHSConstant)));
1401 }
1402 
LLVMConstFRem(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1403 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1404   return wrap(ConstantExpr::getFRem(unwrap<Constant>(LHSConstant),
1405                                     unwrap<Constant>(RHSConstant)));
1406 }
1407 
LLVMConstAnd(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1408 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1409   return wrap(ConstantExpr::getAnd(unwrap<Constant>(LHSConstant),
1410                                    unwrap<Constant>(RHSConstant)));
1411 }
1412 
LLVMConstOr(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1413 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1414   return wrap(ConstantExpr::getOr(unwrap<Constant>(LHSConstant),
1415                                   unwrap<Constant>(RHSConstant)));
1416 }
1417 
LLVMConstXor(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1418 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1419   return wrap(ConstantExpr::getXor(unwrap<Constant>(LHSConstant),
1420                                    unwrap<Constant>(RHSConstant)));
1421 }
1422 
LLVMConstICmp(LLVMIntPredicate Predicate,LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1423 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
1424                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1425   return wrap(ConstantExpr::getICmp(Predicate,
1426                                     unwrap<Constant>(LHSConstant),
1427                                     unwrap<Constant>(RHSConstant)));
1428 }
1429 
LLVMConstFCmp(LLVMRealPredicate Predicate,LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1430 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
1431                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1432   return wrap(ConstantExpr::getFCmp(Predicate,
1433                                     unwrap<Constant>(LHSConstant),
1434                                     unwrap<Constant>(RHSConstant)));
1435 }
1436 
LLVMConstShl(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1437 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1438   return wrap(ConstantExpr::getShl(unwrap<Constant>(LHSConstant),
1439                                    unwrap<Constant>(RHSConstant)));
1440 }
1441 
LLVMConstLShr(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1442 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1443   return wrap(ConstantExpr::getLShr(unwrap<Constant>(LHSConstant),
1444                                     unwrap<Constant>(RHSConstant)));
1445 }
1446 
LLVMConstAShr(LLVMValueRef LHSConstant,LLVMValueRef RHSConstant)1447 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1448   return wrap(ConstantExpr::getAShr(unwrap<Constant>(LHSConstant),
1449                                     unwrap<Constant>(RHSConstant)));
1450 }
1451 
LLVMConstGEP(LLVMValueRef ConstantVal,LLVMValueRef * ConstantIndices,unsigned NumIndices)1452 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
1453                           LLVMValueRef *ConstantIndices, unsigned NumIndices) {
1454   ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
1455                                NumIndices);
1456   return wrap(ConstantExpr::getGetElementPtr(
1457       nullptr, unwrap<Constant>(ConstantVal), IdxList));
1458 }
1459 
LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,LLVMValueRef * ConstantIndices,unsigned NumIndices)1460 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
1461                                   LLVMValueRef *ConstantIndices,
1462                                   unsigned NumIndices) {
1463   Constant* Val = unwrap<Constant>(ConstantVal);
1464   ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
1465                                NumIndices);
1466   return wrap(ConstantExpr::getInBoundsGetElementPtr(nullptr, Val, IdxList));
1467 }
1468 
LLVMConstTrunc(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1469 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1470   return wrap(ConstantExpr::getTrunc(unwrap<Constant>(ConstantVal),
1471                                      unwrap(ToType)));
1472 }
1473 
LLVMConstSExt(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1474 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1475   return wrap(ConstantExpr::getSExt(unwrap<Constant>(ConstantVal),
1476                                     unwrap(ToType)));
1477 }
1478 
LLVMConstZExt(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1479 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1480   return wrap(ConstantExpr::getZExt(unwrap<Constant>(ConstantVal),
1481                                     unwrap(ToType)));
1482 }
1483 
LLVMConstFPTrunc(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1484 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1485   return wrap(ConstantExpr::getFPTrunc(unwrap<Constant>(ConstantVal),
1486                                        unwrap(ToType)));
1487 }
1488 
LLVMConstFPExt(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1489 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1490   return wrap(ConstantExpr::getFPExtend(unwrap<Constant>(ConstantVal),
1491                                         unwrap(ToType)));
1492 }
1493 
LLVMConstUIToFP(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1494 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1495   return wrap(ConstantExpr::getUIToFP(unwrap<Constant>(ConstantVal),
1496                                       unwrap(ToType)));
1497 }
1498 
LLVMConstSIToFP(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1499 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1500   return wrap(ConstantExpr::getSIToFP(unwrap<Constant>(ConstantVal),
1501                                       unwrap(ToType)));
1502 }
1503 
LLVMConstFPToUI(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1504 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1505   return wrap(ConstantExpr::getFPToUI(unwrap<Constant>(ConstantVal),
1506                                       unwrap(ToType)));
1507 }
1508 
LLVMConstFPToSI(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1509 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1510   return wrap(ConstantExpr::getFPToSI(unwrap<Constant>(ConstantVal),
1511                                       unwrap(ToType)));
1512 }
1513 
LLVMConstPtrToInt(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1514 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1515   return wrap(ConstantExpr::getPtrToInt(unwrap<Constant>(ConstantVal),
1516                                         unwrap(ToType)));
1517 }
1518 
LLVMConstIntToPtr(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1519 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1520   return wrap(ConstantExpr::getIntToPtr(unwrap<Constant>(ConstantVal),
1521                                         unwrap(ToType)));
1522 }
1523 
LLVMConstBitCast(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1524 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1525   return wrap(ConstantExpr::getBitCast(unwrap<Constant>(ConstantVal),
1526                                        unwrap(ToType)));
1527 }
1528 
LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1529 LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal,
1530                                     LLVMTypeRef ToType) {
1531   return wrap(ConstantExpr::getAddrSpaceCast(unwrap<Constant>(ConstantVal),
1532                                              unwrap(ToType)));
1533 }
1534 
LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1535 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
1536                                     LLVMTypeRef ToType) {
1537   return wrap(ConstantExpr::getZExtOrBitCast(unwrap<Constant>(ConstantVal),
1538                                              unwrap(ToType)));
1539 }
1540 
LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1541 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
1542                                     LLVMTypeRef ToType) {
1543   return wrap(ConstantExpr::getSExtOrBitCast(unwrap<Constant>(ConstantVal),
1544                                              unwrap(ToType)));
1545 }
1546 
LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1547 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
1548                                      LLVMTypeRef ToType) {
1549   return wrap(ConstantExpr::getTruncOrBitCast(unwrap<Constant>(ConstantVal),
1550                                               unwrap(ToType)));
1551 }
1552 
LLVMConstPointerCast(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1553 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
1554                                   LLVMTypeRef ToType) {
1555   return wrap(ConstantExpr::getPointerCast(unwrap<Constant>(ConstantVal),
1556                                            unwrap(ToType)));
1557 }
1558 
LLVMConstIntCast(LLVMValueRef ConstantVal,LLVMTypeRef ToType,LLVMBool isSigned)1559 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
1560                               LLVMBool isSigned) {
1561   return wrap(ConstantExpr::getIntegerCast(unwrap<Constant>(ConstantVal),
1562                                            unwrap(ToType), isSigned));
1563 }
1564 
LLVMConstFPCast(LLVMValueRef ConstantVal,LLVMTypeRef ToType)1565 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1566   return wrap(ConstantExpr::getFPCast(unwrap<Constant>(ConstantVal),
1567                                       unwrap(ToType)));
1568 }
1569 
LLVMConstSelect(LLVMValueRef ConstantCondition,LLVMValueRef ConstantIfTrue,LLVMValueRef ConstantIfFalse)1570 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
1571                              LLVMValueRef ConstantIfTrue,
1572                              LLVMValueRef ConstantIfFalse) {
1573   return wrap(ConstantExpr::getSelect(unwrap<Constant>(ConstantCondition),
1574                                       unwrap<Constant>(ConstantIfTrue),
1575                                       unwrap<Constant>(ConstantIfFalse)));
1576 }
1577 
LLVMConstExtractElement(LLVMValueRef VectorConstant,LLVMValueRef IndexConstant)1578 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
1579                                      LLVMValueRef IndexConstant) {
1580   return wrap(ConstantExpr::getExtractElement(unwrap<Constant>(VectorConstant),
1581                                               unwrap<Constant>(IndexConstant)));
1582 }
1583 
LLVMConstInsertElement(LLVMValueRef VectorConstant,LLVMValueRef ElementValueConstant,LLVMValueRef IndexConstant)1584 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
1585                                     LLVMValueRef ElementValueConstant,
1586                                     LLVMValueRef IndexConstant) {
1587   return wrap(ConstantExpr::getInsertElement(unwrap<Constant>(VectorConstant),
1588                                          unwrap<Constant>(ElementValueConstant),
1589                                              unwrap<Constant>(IndexConstant)));
1590 }
1591 
LLVMConstShuffleVector(LLVMValueRef VectorAConstant,LLVMValueRef VectorBConstant,LLVMValueRef MaskConstant)1592 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
1593                                     LLVMValueRef VectorBConstant,
1594                                     LLVMValueRef MaskConstant) {
1595   return wrap(ConstantExpr::getShuffleVector(unwrap<Constant>(VectorAConstant),
1596                                              unwrap<Constant>(VectorBConstant),
1597                                              unwrap<Constant>(MaskConstant)));
1598 }
1599 
LLVMConstExtractValue(LLVMValueRef AggConstant,unsigned * IdxList,unsigned NumIdx)1600 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
1601                                    unsigned NumIdx) {
1602   return wrap(ConstantExpr::getExtractValue(unwrap<Constant>(AggConstant),
1603                                             makeArrayRef(IdxList, NumIdx)));
1604 }
1605 
LLVMConstInsertValue(LLVMValueRef AggConstant,LLVMValueRef ElementValueConstant,unsigned * IdxList,unsigned NumIdx)1606 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
1607                                   LLVMValueRef ElementValueConstant,
1608                                   unsigned *IdxList, unsigned NumIdx) {
1609   return wrap(ConstantExpr::getInsertValue(unwrap<Constant>(AggConstant),
1610                                          unwrap<Constant>(ElementValueConstant),
1611                                            makeArrayRef(IdxList, NumIdx)));
1612 }
1613 
LLVMConstInlineAsm(LLVMTypeRef Ty,const char * AsmString,const char * Constraints,LLVMBool HasSideEffects,LLVMBool IsAlignStack)1614 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, const char *AsmString,
1615                                 const char *Constraints,
1616                                 LLVMBool HasSideEffects,
1617                                 LLVMBool IsAlignStack) {
1618   return wrap(InlineAsm::get(dyn_cast<FunctionType>(unwrap(Ty)), AsmString,
1619                              Constraints, HasSideEffects, IsAlignStack));
1620 }
1621 
LLVMBlockAddress(LLVMValueRef F,LLVMBasicBlockRef BB)1622 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB) {
1623   return wrap(BlockAddress::get(unwrap<Function>(F), unwrap(BB)));
1624 }
1625 
1626 /*--.. Operations on global variables, functions, and aliases (globals) ....--*/
1627 
LLVMGetGlobalParent(LLVMValueRef Global)1628 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global) {
1629   return wrap(unwrap<GlobalValue>(Global)->getParent());
1630 }
1631 
LLVMIsDeclaration(LLVMValueRef Global)1632 LLVMBool LLVMIsDeclaration(LLVMValueRef Global) {
1633   return unwrap<GlobalValue>(Global)->isDeclaration();
1634 }
1635 
LLVMGetLinkage(LLVMValueRef Global)1636 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global) {
1637   switch (unwrap<GlobalValue>(Global)->getLinkage()) {
1638   case GlobalValue::ExternalLinkage:
1639     return LLVMExternalLinkage;
1640   case GlobalValue::AvailableExternallyLinkage:
1641     return LLVMAvailableExternallyLinkage;
1642   case GlobalValue::LinkOnceAnyLinkage:
1643     return LLVMLinkOnceAnyLinkage;
1644   case GlobalValue::LinkOnceODRLinkage:
1645     return LLVMLinkOnceODRLinkage;
1646   case GlobalValue::WeakAnyLinkage:
1647     return LLVMWeakAnyLinkage;
1648   case GlobalValue::WeakODRLinkage:
1649     return LLVMWeakODRLinkage;
1650   case GlobalValue::AppendingLinkage:
1651     return LLVMAppendingLinkage;
1652   case GlobalValue::InternalLinkage:
1653     return LLVMInternalLinkage;
1654   case GlobalValue::PrivateLinkage:
1655     return LLVMPrivateLinkage;
1656   case GlobalValue::ExternalWeakLinkage:
1657     return LLVMExternalWeakLinkage;
1658   case GlobalValue::CommonLinkage:
1659     return LLVMCommonLinkage;
1660   }
1661 
1662   llvm_unreachable("Invalid GlobalValue linkage!");
1663 }
1664 
LLVMSetLinkage(LLVMValueRef Global,LLVMLinkage Linkage)1665 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage) {
1666   GlobalValue *GV = unwrap<GlobalValue>(Global);
1667 
1668   switch (Linkage) {
1669   case LLVMExternalLinkage:
1670     GV->setLinkage(GlobalValue::ExternalLinkage);
1671     break;
1672   case LLVMAvailableExternallyLinkage:
1673     GV->setLinkage(GlobalValue::AvailableExternallyLinkage);
1674     break;
1675   case LLVMLinkOnceAnyLinkage:
1676     GV->setLinkage(GlobalValue::LinkOnceAnyLinkage);
1677     break;
1678   case LLVMLinkOnceODRLinkage:
1679     GV->setLinkage(GlobalValue::LinkOnceODRLinkage);
1680     break;
1681   case LLVMLinkOnceODRAutoHideLinkage:
1682     LLVM_DEBUG(
1683         errs() << "LLVMSetLinkage(): LLVMLinkOnceODRAutoHideLinkage is no "
1684                   "longer supported.");
1685     break;
1686   case LLVMWeakAnyLinkage:
1687     GV->setLinkage(GlobalValue::WeakAnyLinkage);
1688     break;
1689   case LLVMWeakODRLinkage:
1690     GV->setLinkage(GlobalValue::WeakODRLinkage);
1691     break;
1692   case LLVMAppendingLinkage:
1693     GV->setLinkage(GlobalValue::AppendingLinkage);
1694     break;
1695   case LLVMInternalLinkage:
1696     GV->setLinkage(GlobalValue::InternalLinkage);
1697     break;
1698   case LLVMPrivateLinkage:
1699     GV->setLinkage(GlobalValue::PrivateLinkage);
1700     break;
1701   case LLVMLinkerPrivateLinkage:
1702     GV->setLinkage(GlobalValue::PrivateLinkage);
1703     break;
1704   case LLVMLinkerPrivateWeakLinkage:
1705     GV->setLinkage(GlobalValue::PrivateLinkage);
1706     break;
1707   case LLVMDLLImportLinkage:
1708     LLVM_DEBUG(
1709         errs()
1710         << "LLVMSetLinkage(): LLVMDLLImportLinkage is no longer supported.");
1711     break;
1712   case LLVMDLLExportLinkage:
1713     LLVM_DEBUG(
1714         errs()
1715         << "LLVMSetLinkage(): LLVMDLLExportLinkage is no longer supported.");
1716     break;
1717   case LLVMExternalWeakLinkage:
1718     GV->setLinkage(GlobalValue::ExternalWeakLinkage);
1719     break;
1720   case LLVMGhostLinkage:
1721     LLVM_DEBUG(
1722         errs() << "LLVMSetLinkage(): LLVMGhostLinkage is no longer supported.");
1723     break;
1724   case LLVMCommonLinkage:
1725     GV->setLinkage(GlobalValue::CommonLinkage);
1726     break;
1727   }
1728 }
1729 
LLVMGetSection(LLVMValueRef Global)1730 const char *LLVMGetSection(LLVMValueRef Global) {
1731   // Using .data() is safe because of how GlobalObject::setSection is
1732   // implemented.
1733   return unwrap<GlobalValue>(Global)->getSection().data();
1734 }
1735 
LLVMSetSection(LLVMValueRef Global,const char * Section)1736 void LLVMSetSection(LLVMValueRef Global, const char *Section) {
1737   unwrap<GlobalObject>(Global)->setSection(Section);
1738 }
1739 
LLVMGetVisibility(LLVMValueRef Global)1740 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global) {
1741   return static_cast<LLVMVisibility>(
1742     unwrap<GlobalValue>(Global)->getVisibility());
1743 }
1744 
LLVMSetVisibility(LLVMValueRef Global,LLVMVisibility Viz)1745 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz) {
1746   unwrap<GlobalValue>(Global)
1747     ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz));
1748 }
1749 
LLVMGetDLLStorageClass(LLVMValueRef Global)1750 LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global) {
1751   return static_cast<LLVMDLLStorageClass>(
1752       unwrap<GlobalValue>(Global)->getDLLStorageClass());
1753 }
1754 
LLVMSetDLLStorageClass(LLVMValueRef Global,LLVMDLLStorageClass Class)1755 void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class) {
1756   unwrap<GlobalValue>(Global)->setDLLStorageClass(
1757       static_cast<GlobalValue::DLLStorageClassTypes>(Class));
1758 }
1759 
LLVMGetUnnamedAddress(LLVMValueRef Global)1760 LLVMUnnamedAddr LLVMGetUnnamedAddress(LLVMValueRef Global) {
1761   switch (unwrap<GlobalValue>(Global)->getUnnamedAddr()) {
1762   case GlobalVariable::UnnamedAddr::None:
1763     return LLVMNoUnnamedAddr;
1764   case GlobalVariable::UnnamedAddr::Local:
1765     return LLVMLocalUnnamedAddr;
1766   case GlobalVariable::UnnamedAddr::Global:
1767     return LLVMGlobalUnnamedAddr;
1768   }
1769   llvm_unreachable("Unknown UnnamedAddr kind!");
1770 }
1771 
LLVMSetUnnamedAddress(LLVMValueRef Global,LLVMUnnamedAddr UnnamedAddr)1772 void LLVMSetUnnamedAddress(LLVMValueRef Global, LLVMUnnamedAddr UnnamedAddr) {
1773   GlobalValue *GV = unwrap<GlobalValue>(Global);
1774 
1775   switch (UnnamedAddr) {
1776   case LLVMNoUnnamedAddr:
1777     return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::None);
1778   case LLVMLocalUnnamedAddr:
1779     return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Local);
1780   case LLVMGlobalUnnamedAddr:
1781     return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Global);
1782   }
1783 }
1784 
LLVMHasUnnamedAddr(LLVMValueRef Global)1785 LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global) {
1786   return unwrap<GlobalValue>(Global)->hasGlobalUnnamedAddr();
1787 }
1788 
LLVMSetUnnamedAddr(LLVMValueRef Global,LLVMBool HasUnnamedAddr)1789 void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr) {
1790   unwrap<GlobalValue>(Global)->setUnnamedAddr(
1791       HasUnnamedAddr ? GlobalValue::UnnamedAddr::Global
1792                      : GlobalValue::UnnamedAddr::None);
1793 }
1794 
1795 /*--.. Operations on global variables, load and store instructions .........--*/
1796 
LLVMGetAlignment(LLVMValueRef V)1797 unsigned LLVMGetAlignment(LLVMValueRef V) {
1798   Value *P = unwrap<Value>(V);
1799   if (GlobalValue *GV = dyn_cast<GlobalValue>(P))
1800     return GV->getAlignment();
1801   if (AllocaInst *AI = dyn_cast<AllocaInst>(P))
1802     return AI->getAlignment();
1803   if (LoadInst *LI = dyn_cast<LoadInst>(P))
1804     return LI->getAlignment();
1805   if (StoreInst *SI = dyn_cast<StoreInst>(P))
1806     return SI->getAlignment();
1807 
1808   llvm_unreachable(
1809       "only GlobalValue, AllocaInst, LoadInst and StoreInst have alignment");
1810 }
1811 
LLVMSetAlignment(LLVMValueRef V,unsigned Bytes)1812 void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes) {
1813   Value *P = unwrap<Value>(V);
1814   if (GlobalObject *GV = dyn_cast<GlobalObject>(P))
1815     GV->setAlignment(Bytes);
1816   else if (AllocaInst *AI = dyn_cast<AllocaInst>(P))
1817     AI->setAlignment(Bytes);
1818   else if (LoadInst *LI = dyn_cast<LoadInst>(P))
1819     LI->setAlignment(Bytes);
1820   else if (StoreInst *SI = dyn_cast<StoreInst>(P))
1821     SI->setAlignment(Bytes);
1822   else
1823     llvm_unreachable(
1824         "only GlobalValue, AllocaInst, LoadInst and StoreInst have alignment");
1825 }
1826 
1827 /*--.. Operations on global variables ......................................--*/
1828 
LLVMAddGlobal(LLVMModuleRef M,LLVMTypeRef Ty,const char * Name)1829 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name) {
1830   return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false,
1831                                  GlobalValue::ExternalLinkage, nullptr, Name));
1832 }
1833 
LLVMAddGlobalInAddressSpace(LLVMModuleRef M,LLVMTypeRef Ty,const char * Name,unsigned AddressSpace)1834 LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty,
1835                                          const char *Name,
1836                                          unsigned AddressSpace) {
1837   return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false,
1838                                  GlobalValue::ExternalLinkage, nullptr, Name,
1839                                  nullptr, GlobalVariable::NotThreadLocal,
1840                                  AddressSpace));
1841 }
1842 
LLVMGetNamedGlobal(LLVMModuleRef M,const char * Name)1843 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name) {
1844   return wrap(unwrap(M)->getNamedGlobal(Name));
1845 }
1846 
LLVMGetFirstGlobal(LLVMModuleRef M)1847 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M) {
1848   Module *Mod = unwrap(M);
1849   Module::global_iterator I = Mod->global_begin();
1850   if (I == Mod->global_end())
1851     return nullptr;
1852   return wrap(&*I);
1853 }
1854 
LLVMGetLastGlobal(LLVMModuleRef M)1855 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M) {
1856   Module *Mod = unwrap(M);
1857   Module::global_iterator I = Mod->global_end();
1858   if (I == Mod->global_begin())
1859     return nullptr;
1860   return wrap(&*--I);
1861 }
1862 
LLVMGetNextGlobal(LLVMValueRef GlobalVar)1863 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar) {
1864   GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar);
1865   Module::global_iterator I(GV);
1866   if (++I == GV->getParent()->global_end())
1867     return nullptr;
1868   return wrap(&*I);
1869 }
1870 
LLVMGetPreviousGlobal(LLVMValueRef GlobalVar)1871 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar) {
1872   GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar);
1873   Module::global_iterator I(GV);
1874   if (I == GV->getParent()->global_begin())
1875     return nullptr;
1876   return wrap(&*--I);
1877 }
1878 
LLVMDeleteGlobal(LLVMValueRef GlobalVar)1879 void LLVMDeleteGlobal(LLVMValueRef GlobalVar) {
1880   unwrap<GlobalVariable>(GlobalVar)->eraseFromParent();
1881 }
1882 
LLVMGetInitializer(LLVMValueRef GlobalVar)1883 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar) {
1884   GlobalVariable* GV = unwrap<GlobalVariable>(GlobalVar);
1885   if ( !GV->hasInitializer() )
1886     return nullptr;
1887   return wrap(GV->getInitializer());
1888 }
1889 
LLVMSetInitializer(LLVMValueRef GlobalVar,LLVMValueRef ConstantVal)1890 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) {
1891   unwrap<GlobalVariable>(GlobalVar)
1892     ->setInitializer(unwrap<Constant>(ConstantVal));
1893 }
1894 
LLVMIsThreadLocal(LLVMValueRef GlobalVar)1895 LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar) {
1896   return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal();
1897 }
1898 
LLVMSetThreadLocal(LLVMValueRef GlobalVar,LLVMBool IsThreadLocal)1899 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal) {
1900   unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0);
1901 }
1902 
LLVMIsGlobalConstant(LLVMValueRef GlobalVar)1903 LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar) {
1904   return unwrap<GlobalVariable>(GlobalVar)->isConstant();
1905 }
1906 
LLVMSetGlobalConstant(LLVMValueRef GlobalVar,LLVMBool IsConstant)1907 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant) {
1908   unwrap<GlobalVariable>(GlobalVar)->setConstant(IsConstant != 0);
1909 }
1910 
LLVMGetThreadLocalMode(LLVMValueRef GlobalVar)1911 LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar) {
1912   switch (unwrap<GlobalVariable>(GlobalVar)->getThreadLocalMode()) {
1913   case GlobalVariable::NotThreadLocal:
1914     return LLVMNotThreadLocal;
1915   case GlobalVariable::GeneralDynamicTLSModel:
1916     return LLVMGeneralDynamicTLSModel;
1917   case GlobalVariable::LocalDynamicTLSModel:
1918     return LLVMLocalDynamicTLSModel;
1919   case GlobalVariable::InitialExecTLSModel:
1920     return LLVMInitialExecTLSModel;
1921   case GlobalVariable::LocalExecTLSModel:
1922     return LLVMLocalExecTLSModel;
1923   }
1924 
1925   llvm_unreachable("Invalid GlobalVariable thread local mode");
1926 }
1927 
LLVMSetThreadLocalMode(LLVMValueRef GlobalVar,LLVMThreadLocalMode Mode)1928 void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode) {
1929   GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar);
1930 
1931   switch (Mode) {
1932   case LLVMNotThreadLocal:
1933     GV->setThreadLocalMode(GlobalVariable::NotThreadLocal);
1934     break;
1935   case LLVMGeneralDynamicTLSModel:
1936     GV->setThreadLocalMode(GlobalVariable::GeneralDynamicTLSModel);
1937     break;
1938   case LLVMLocalDynamicTLSModel:
1939     GV->setThreadLocalMode(GlobalVariable::LocalDynamicTLSModel);
1940     break;
1941   case LLVMInitialExecTLSModel:
1942     GV->setThreadLocalMode(GlobalVariable::InitialExecTLSModel);
1943     break;
1944   case LLVMLocalExecTLSModel:
1945     GV->setThreadLocalMode(GlobalVariable::LocalExecTLSModel);
1946     break;
1947   }
1948 }
1949 
LLVMIsExternallyInitialized(LLVMValueRef GlobalVar)1950 LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar) {
1951   return unwrap<GlobalVariable>(GlobalVar)->isExternallyInitialized();
1952 }
1953 
LLVMSetExternallyInitialized(LLVMValueRef GlobalVar,LLVMBool IsExtInit)1954 void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit) {
1955   unwrap<GlobalVariable>(GlobalVar)->setExternallyInitialized(IsExtInit);
1956 }
1957 
1958 /*--.. Operations on aliases ......................................--*/
1959 
LLVMAddAlias(LLVMModuleRef M,LLVMTypeRef Ty,LLVMValueRef Aliasee,const char * Name)1960 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
1961                           const char *Name) {
1962   auto *PTy = cast<PointerType>(unwrap(Ty));
1963   return wrap(GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
1964                                   GlobalValue::ExternalLinkage, Name,
1965                                   unwrap<Constant>(Aliasee), unwrap(M)));
1966 }
1967 
LLVMGetNamedGlobalAlias(LLVMModuleRef M,const char * Name,size_t NameLen)1968 LLVMValueRef LLVMGetNamedGlobalAlias(LLVMModuleRef M,
1969                                      const char *Name, size_t NameLen) {
1970   return wrap(unwrap(M)->getNamedAlias(Name));
1971 }
1972 
LLVMGetFirstGlobalAlias(LLVMModuleRef M)1973 LLVMValueRef LLVMGetFirstGlobalAlias(LLVMModuleRef M) {
1974   Module *Mod = unwrap(M);
1975   Module::alias_iterator I = Mod->alias_begin();
1976   if (I == Mod->alias_end())
1977     return nullptr;
1978   return wrap(&*I);
1979 }
1980 
LLVMGetLastGlobalAlias(LLVMModuleRef M)1981 LLVMValueRef LLVMGetLastGlobalAlias(LLVMModuleRef M) {
1982   Module *Mod = unwrap(M);
1983   Module::alias_iterator I = Mod->alias_end();
1984   if (I == Mod->alias_begin())
1985     return nullptr;
1986   return wrap(&*--I);
1987 }
1988 
LLVMGetNextGlobalAlias(LLVMValueRef GA)1989 LLVMValueRef LLVMGetNextGlobalAlias(LLVMValueRef GA) {
1990   GlobalAlias *Alias = unwrap<GlobalAlias>(GA);
1991   Module::alias_iterator I(Alias);
1992   if (++I == Alias->getParent()->alias_end())
1993     return nullptr;
1994   return wrap(&*I);
1995 }
1996 
LLVMGetPreviousGlobalAlias(LLVMValueRef GA)1997 LLVMValueRef LLVMGetPreviousGlobalAlias(LLVMValueRef GA) {
1998   GlobalAlias *Alias = unwrap<GlobalAlias>(GA);
1999   Module::alias_iterator I(Alias);
2000   if (I == Alias->getParent()->alias_begin())
2001     return nullptr;
2002   return wrap(&*--I);
2003 }
2004 
LLVMAliasGetAliasee(LLVMValueRef Alias)2005 LLVMValueRef LLVMAliasGetAliasee(LLVMValueRef Alias) {
2006   return wrap(unwrap<GlobalAlias>(Alias)->getAliasee());
2007 }
2008 
LLVMAliasSetAliasee(LLVMValueRef Alias,LLVMValueRef Aliasee)2009 void LLVMAliasSetAliasee(LLVMValueRef Alias, LLVMValueRef Aliasee) {
2010   unwrap<GlobalAlias>(Alias)->setAliasee(unwrap<Constant>(Aliasee));
2011 }
2012 
2013 /*--.. Operations on functions .............................................--*/
2014 
LLVMAddFunction(LLVMModuleRef M,const char * Name,LLVMTypeRef FunctionTy)2015 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
2016                              LLVMTypeRef FunctionTy) {
2017   return wrap(Function::Create(unwrap<FunctionType>(FunctionTy),
2018                                GlobalValue::ExternalLinkage, Name, unwrap(M)));
2019 }
2020 
LLVMGetNamedFunction(LLVMModuleRef M,const char * Name)2021 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name) {
2022   return wrap(unwrap(M)->getFunction(Name));
2023 }
2024 
LLVMGetFirstFunction(LLVMModuleRef M)2025 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M) {
2026   Module *Mod = unwrap(M);
2027   Module::iterator I = Mod->begin();
2028   if (I == Mod->end())
2029     return nullptr;
2030   return wrap(&*I);
2031 }
2032 
LLVMGetLastFunction(LLVMModuleRef M)2033 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M) {
2034   Module *Mod = unwrap(M);
2035   Module::iterator I = Mod->end();
2036   if (I == Mod->begin())
2037     return nullptr;
2038   return wrap(&*--I);
2039 }
2040 
LLVMGetNextFunction(LLVMValueRef Fn)2041 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn) {
2042   Function *Func = unwrap<Function>(Fn);
2043   Module::iterator I(Func);
2044   if (++I == Func->getParent()->end())
2045     return nullptr;
2046   return wrap(&*I);
2047 }
2048 
LLVMGetPreviousFunction(LLVMValueRef Fn)2049 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn) {
2050   Function *Func = unwrap<Function>(Fn);
2051   Module::iterator I(Func);
2052   if (I == Func->getParent()->begin())
2053     return nullptr;
2054   return wrap(&*--I);
2055 }
2056 
LLVMDeleteFunction(LLVMValueRef Fn)2057 void LLVMDeleteFunction(LLVMValueRef Fn) {
2058   unwrap<Function>(Fn)->eraseFromParent();
2059 }
2060 
LLVMHasPersonalityFn(LLVMValueRef Fn)2061 LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn) {
2062   return unwrap<Function>(Fn)->hasPersonalityFn();
2063 }
2064 
LLVMGetPersonalityFn(LLVMValueRef Fn)2065 LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn) {
2066   return wrap(unwrap<Function>(Fn)->getPersonalityFn());
2067 }
2068 
LLVMSetPersonalityFn(LLVMValueRef Fn,LLVMValueRef PersonalityFn)2069 void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn) {
2070   unwrap<Function>(Fn)->setPersonalityFn(unwrap<Constant>(PersonalityFn));
2071 }
2072 
LLVMGetIntrinsicID(LLVMValueRef Fn)2073 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn) {
2074   if (Function *F = dyn_cast<Function>(unwrap(Fn)))
2075     return F->getIntrinsicID();
2076   return 0;
2077 }
2078 
LLVMGetFunctionCallConv(LLVMValueRef Fn)2079 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn) {
2080   return unwrap<Function>(Fn)->getCallingConv();
2081 }
2082 
LLVMSetFunctionCallConv(LLVMValueRef Fn,unsigned CC)2083 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC) {
2084   return unwrap<Function>(Fn)->setCallingConv(
2085     static_cast<CallingConv::ID>(CC));
2086 }
2087 
LLVMGetGC(LLVMValueRef Fn)2088 const char *LLVMGetGC(LLVMValueRef Fn) {
2089   Function *F = unwrap<Function>(Fn);
2090   return F->hasGC()? F->getGC().c_str() : nullptr;
2091 }
2092 
LLVMSetGC(LLVMValueRef Fn,const char * GC)2093 void LLVMSetGC(LLVMValueRef Fn, const char *GC) {
2094   Function *F = unwrap<Function>(Fn);
2095   if (GC)
2096     F->setGC(GC);
2097   else
2098     F->clearGC();
2099 }
2100 
LLVMAddAttributeAtIndex(LLVMValueRef F,LLVMAttributeIndex Idx,LLVMAttributeRef A)2101 void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2102                              LLVMAttributeRef A) {
2103   unwrap<Function>(F)->addAttribute(Idx, unwrap(A));
2104 }
2105 
LLVMGetAttributeCountAtIndex(LLVMValueRef F,LLVMAttributeIndex Idx)2106 unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx) {
2107   auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
2108   return AS.getNumAttributes();
2109 }
2110 
LLVMGetAttributesAtIndex(LLVMValueRef F,LLVMAttributeIndex Idx,LLVMAttributeRef * Attrs)2111 void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2112                               LLVMAttributeRef *Attrs) {
2113   auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
2114   for (auto A : AS)
2115     *Attrs++ = wrap(A);
2116 }
2117 
LLVMGetEnumAttributeAtIndex(LLVMValueRef F,LLVMAttributeIndex Idx,unsigned KindID)2118 LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F,
2119                                              LLVMAttributeIndex Idx,
2120                                              unsigned KindID) {
2121   return wrap(unwrap<Function>(F)->getAttribute(Idx,
2122                                                 (Attribute::AttrKind)KindID));
2123 }
2124 
LLVMGetStringAttributeAtIndex(LLVMValueRef F,LLVMAttributeIndex Idx,const char * K,unsigned KLen)2125 LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F,
2126                                                LLVMAttributeIndex Idx,
2127                                                const char *K, unsigned KLen) {
2128   return wrap(unwrap<Function>(F)->getAttribute(Idx, StringRef(K, KLen)));
2129 }
2130 
LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F,LLVMAttributeIndex Idx,unsigned KindID)2131 void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2132                                     unsigned KindID) {
2133   unwrap<Function>(F)->removeAttribute(Idx, (Attribute::AttrKind)KindID);
2134 }
2135 
LLVMRemoveStringAttributeAtIndex(LLVMValueRef F,LLVMAttributeIndex Idx,const char * K,unsigned KLen)2136 void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2137                                       const char *K, unsigned KLen) {
2138   unwrap<Function>(F)->removeAttribute(Idx, StringRef(K, KLen));
2139 }
2140 
LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn,const char * A,const char * V)2141 void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A,
2142                                         const char *V) {
2143   Function *Func = unwrap<Function>(Fn);
2144   Attribute Attr = Attribute::get(Func->getContext(), A, V);
2145   Func->addAttribute(AttributeList::FunctionIndex, Attr);
2146 }
2147 
2148 /*--.. Operations on parameters ............................................--*/
2149 
LLVMCountParams(LLVMValueRef FnRef)2150 unsigned LLVMCountParams(LLVMValueRef FnRef) {
2151   // This function is strictly redundant to
2152   //   LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(FnRef)))
2153   return unwrap<Function>(FnRef)->arg_size();
2154 }
2155 
LLVMGetParams(LLVMValueRef FnRef,LLVMValueRef * ParamRefs)2156 void LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs) {
2157   Function *Fn = unwrap<Function>(FnRef);
2158   for (Function::arg_iterator I = Fn->arg_begin(),
2159                               E = Fn->arg_end(); I != E; I++)
2160     *ParamRefs++ = wrap(&*I);
2161 }
2162 
LLVMGetParam(LLVMValueRef FnRef,unsigned index)2163 LLVMValueRef LLVMGetParam(LLVMValueRef FnRef, unsigned index) {
2164   Function *Fn = unwrap<Function>(FnRef);
2165   return wrap(&Fn->arg_begin()[index]);
2166 }
2167 
LLVMGetParamParent(LLVMValueRef V)2168 LLVMValueRef LLVMGetParamParent(LLVMValueRef V) {
2169   return wrap(unwrap<Argument>(V)->getParent());
2170 }
2171 
LLVMGetFirstParam(LLVMValueRef Fn)2172 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn) {
2173   Function *Func = unwrap<Function>(Fn);
2174   Function::arg_iterator I = Func->arg_begin();
2175   if (I == Func->arg_end())
2176     return nullptr;
2177   return wrap(&*I);
2178 }
2179 
LLVMGetLastParam(LLVMValueRef Fn)2180 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn) {
2181   Function *Func = unwrap<Function>(Fn);
2182   Function::arg_iterator I = Func->arg_end();
2183   if (I == Func->arg_begin())
2184     return nullptr;
2185   return wrap(&*--I);
2186 }
2187 
LLVMGetNextParam(LLVMValueRef Arg)2188 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg) {
2189   Argument *A = unwrap<Argument>(Arg);
2190   Function *Fn = A->getParent();
2191   if (A->getArgNo() + 1 >= Fn->arg_size())
2192     return nullptr;
2193   return wrap(&Fn->arg_begin()[A->getArgNo() + 1]);
2194 }
2195 
LLVMGetPreviousParam(LLVMValueRef Arg)2196 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg) {
2197   Argument *A = unwrap<Argument>(Arg);
2198   if (A->getArgNo() == 0)
2199     return nullptr;
2200   return wrap(&A->getParent()->arg_begin()[A->getArgNo() - 1]);
2201 }
2202 
LLVMSetParamAlignment(LLVMValueRef Arg,unsigned align)2203 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align) {
2204   Argument *A = unwrap<Argument>(Arg);
2205   A->addAttr(Attribute::getWithAlignment(A->getContext(), align));
2206 }
2207 
2208 /*--.. Operations on basic blocks ..........................................--*/
2209 
LLVMBasicBlockAsValue(LLVMBasicBlockRef BB)2210 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB) {
2211   return wrap(static_cast<Value*>(unwrap(BB)));
2212 }
2213 
LLVMValueIsBasicBlock(LLVMValueRef Val)2214 LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val) {
2215   return isa<BasicBlock>(unwrap(Val));
2216 }
2217 
LLVMValueAsBasicBlock(LLVMValueRef Val)2218 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val) {
2219   return wrap(unwrap<BasicBlock>(Val));
2220 }
2221 
LLVMGetBasicBlockName(LLVMBasicBlockRef BB)2222 const char *LLVMGetBasicBlockName(LLVMBasicBlockRef BB) {
2223   return unwrap(BB)->getName().data();
2224 }
2225 
LLVMGetBasicBlockParent(LLVMBasicBlockRef BB)2226 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB) {
2227   return wrap(unwrap(BB)->getParent());
2228 }
2229 
LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB)2230 LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB) {
2231   return wrap(unwrap(BB)->getTerminator());
2232 }
2233 
LLVMCountBasicBlocks(LLVMValueRef FnRef)2234 unsigned LLVMCountBasicBlocks(LLVMValueRef FnRef) {
2235   return unwrap<Function>(FnRef)->size();
2236 }
2237 
LLVMGetBasicBlocks(LLVMValueRef FnRef,LLVMBasicBlockRef * BasicBlocksRefs)2238 void LLVMGetBasicBlocks(LLVMValueRef FnRef, LLVMBasicBlockRef *BasicBlocksRefs){
2239   Function *Fn = unwrap<Function>(FnRef);
2240   for (BasicBlock &BB : *Fn)
2241     *BasicBlocksRefs++ = wrap(&BB);
2242 }
2243 
LLVMGetEntryBasicBlock(LLVMValueRef Fn)2244 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn) {
2245   return wrap(&unwrap<Function>(Fn)->getEntryBlock());
2246 }
2247 
LLVMGetFirstBasicBlock(LLVMValueRef Fn)2248 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn) {
2249   Function *Func = unwrap<Function>(Fn);
2250   Function::iterator I = Func->begin();
2251   if (I == Func->end())
2252     return nullptr;
2253   return wrap(&*I);
2254 }
2255 
LLVMGetLastBasicBlock(LLVMValueRef Fn)2256 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn) {
2257   Function *Func = unwrap<Function>(Fn);
2258   Function::iterator I = Func->end();
2259   if (I == Func->begin())
2260     return nullptr;
2261   return wrap(&*--I);
2262 }
2263 
LLVMGetNextBasicBlock(LLVMBasicBlockRef BB)2264 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB) {
2265   BasicBlock *Block = unwrap(BB);
2266   Function::iterator I(Block);
2267   if (++I == Block->getParent()->end())
2268     return nullptr;
2269   return wrap(&*I);
2270 }
2271 
LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB)2272 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB) {
2273   BasicBlock *Block = unwrap(BB);
2274   Function::iterator I(Block);
2275   if (I == Block->getParent()->begin())
2276     return nullptr;
2277   return wrap(&*--I);
2278 }
2279 
LLVMAppendBasicBlockInContext(LLVMContextRef C,LLVMValueRef FnRef,const char * Name)2280 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
2281                                                 LLVMValueRef FnRef,
2282                                                 const char *Name) {
2283   return wrap(BasicBlock::Create(*unwrap(C), Name, unwrap<Function>(FnRef)));
2284 }
2285 
LLVMAppendBasicBlock(LLVMValueRef FnRef,const char * Name)2286 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef FnRef, const char *Name) {
2287   return LLVMAppendBasicBlockInContext(LLVMGetGlobalContext(), FnRef, Name);
2288 }
2289 
LLVMInsertBasicBlockInContext(LLVMContextRef C,LLVMBasicBlockRef BBRef,const char * Name)2290 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
2291                                                 LLVMBasicBlockRef BBRef,
2292                                                 const char *Name) {
2293   BasicBlock *BB = unwrap(BBRef);
2294   return wrap(BasicBlock::Create(*unwrap(C), Name, BB->getParent(), BB));
2295 }
2296 
LLVMInsertBasicBlock(LLVMBasicBlockRef BBRef,const char * Name)2297 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef BBRef,
2298                                        const char *Name) {
2299   return LLVMInsertBasicBlockInContext(LLVMGetGlobalContext(), BBRef, Name);
2300 }
2301 
LLVMDeleteBasicBlock(LLVMBasicBlockRef BBRef)2302 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BBRef) {
2303   unwrap(BBRef)->eraseFromParent();
2304 }
2305 
LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BBRef)2306 void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BBRef) {
2307   unwrap(BBRef)->removeFromParent();
2308 }
2309 
LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB,LLVMBasicBlockRef MovePos)2310 void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos) {
2311   unwrap(BB)->moveBefore(unwrap(MovePos));
2312 }
2313 
LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB,LLVMBasicBlockRef MovePos)2314 void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos) {
2315   unwrap(BB)->moveAfter(unwrap(MovePos));
2316 }
2317 
2318 /*--.. Operations on instructions ..........................................--*/
2319 
LLVMGetInstructionParent(LLVMValueRef Inst)2320 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst) {
2321   return wrap(unwrap<Instruction>(Inst)->getParent());
2322 }
2323 
LLVMGetFirstInstruction(LLVMBasicBlockRef BB)2324 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB) {
2325   BasicBlock *Block = unwrap(BB);
2326   BasicBlock::iterator I = Block->begin();
2327   if (I == Block->end())
2328     return nullptr;
2329   return wrap(&*I);
2330 }
2331 
LLVMGetLastInstruction(LLVMBasicBlockRef BB)2332 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB) {
2333   BasicBlock *Block = unwrap(BB);
2334   BasicBlock::iterator I = Block->end();
2335   if (I == Block->begin())
2336     return nullptr;
2337   return wrap(&*--I);
2338 }
2339 
LLVMGetNextInstruction(LLVMValueRef Inst)2340 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst) {
2341   Instruction *Instr = unwrap<Instruction>(Inst);
2342   BasicBlock::iterator I(Instr);
2343   if (++I == Instr->getParent()->end())
2344     return nullptr;
2345   return wrap(&*I);
2346 }
2347 
LLVMGetPreviousInstruction(LLVMValueRef Inst)2348 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst) {
2349   Instruction *Instr = unwrap<Instruction>(Inst);
2350   BasicBlock::iterator I(Instr);
2351   if (I == Instr->getParent()->begin())
2352     return nullptr;
2353   return wrap(&*--I);
2354 }
2355 
LLVMInstructionRemoveFromParent(LLVMValueRef Inst)2356 void LLVMInstructionRemoveFromParent(LLVMValueRef Inst) {
2357   unwrap<Instruction>(Inst)->removeFromParent();
2358 }
2359 
LLVMInstructionEraseFromParent(LLVMValueRef Inst)2360 void LLVMInstructionEraseFromParent(LLVMValueRef Inst) {
2361   unwrap<Instruction>(Inst)->eraseFromParent();
2362 }
2363 
LLVMGetICmpPredicate(LLVMValueRef Inst)2364 LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst) {
2365   if (ICmpInst *I = dyn_cast<ICmpInst>(unwrap(Inst)))
2366     return (LLVMIntPredicate)I->getPredicate();
2367   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst)))
2368     if (CE->getOpcode() == Instruction::ICmp)
2369       return (LLVMIntPredicate)CE->getPredicate();
2370   return (LLVMIntPredicate)0;
2371 }
2372 
LLVMGetFCmpPredicate(LLVMValueRef Inst)2373 LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst) {
2374   if (FCmpInst *I = dyn_cast<FCmpInst>(unwrap(Inst)))
2375     return (LLVMRealPredicate)I->getPredicate();
2376   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst)))
2377     if (CE->getOpcode() == Instruction::FCmp)
2378       return (LLVMRealPredicate)CE->getPredicate();
2379   return (LLVMRealPredicate)0;
2380 }
2381 
LLVMGetInstructionOpcode(LLVMValueRef Inst)2382 LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst) {
2383   if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst)))
2384     return map_to_llvmopcode(C->getOpcode());
2385   return (LLVMOpcode)0;
2386 }
2387 
LLVMInstructionClone(LLVMValueRef Inst)2388 LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst) {
2389   if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst)))
2390     return wrap(C->clone());
2391   return nullptr;
2392 }
2393 
LLVMGetNumArgOperands(LLVMValueRef Instr)2394 unsigned LLVMGetNumArgOperands(LLVMValueRef Instr) {
2395   if (FuncletPadInst *FPI = dyn_cast<FuncletPadInst>(unwrap(Instr))) {
2396     return FPI->getNumArgOperands();
2397   }
2398   return CallSite(unwrap<Instruction>(Instr)).getNumArgOperands();
2399 }
2400 
2401 /*--.. Call and invoke instructions ........................................--*/
2402 
LLVMGetInstructionCallConv(LLVMValueRef Instr)2403 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr) {
2404   return CallSite(unwrap<Instruction>(Instr)).getCallingConv();
2405 }
2406 
LLVMSetInstructionCallConv(LLVMValueRef Instr,unsigned CC)2407 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC) {
2408   return CallSite(unwrap<Instruction>(Instr))
2409     .setCallingConv(static_cast<CallingConv::ID>(CC));
2410 }
2411 
LLVMSetInstrParamAlignment(LLVMValueRef Instr,unsigned index,unsigned align)2412 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
2413                                 unsigned align) {
2414   CallSite Call = CallSite(unwrap<Instruction>(Instr));
2415   Attribute AlignAttr = Attribute::getWithAlignment(Call->getContext(), align);
2416   Call.addAttribute(index, AlignAttr);
2417 }
2418 
LLVMAddCallSiteAttribute(LLVMValueRef C,LLVMAttributeIndex Idx,LLVMAttributeRef A)2419 void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
2420                               LLVMAttributeRef A) {
2421   CallSite(unwrap<Instruction>(C)).addAttribute(Idx, unwrap(A));
2422 }
2423 
LLVMGetCallSiteAttributeCount(LLVMValueRef C,LLVMAttributeIndex Idx)2424 unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C,
2425                                        LLVMAttributeIndex Idx) {
2426   auto CS = CallSite(unwrap<Instruction>(C));
2427   auto AS = CS.getAttributes().getAttributes(Idx);
2428   return AS.getNumAttributes();
2429 }
2430 
LLVMGetCallSiteAttributes(LLVMValueRef C,LLVMAttributeIndex Idx,LLVMAttributeRef * Attrs)2431 void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx,
2432                                LLVMAttributeRef *Attrs) {
2433   auto CS = CallSite(unwrap<Instruction>(C));
2434   auto AS = CS.getAttributes().getAttributes(Idx);
2435   for (auto A : AS)
2436     *Attrs++ = wrap(A);
2437 }
2438 
LLVMGetCallSiteEnumAttribute(LLVMValueRef C,LLVMAttributeIndex Idx,unsigned KindID)2439 LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C,
2440                                               LLVMAttributeIndex Idx,
2441                                               unsigned KindID) {
2442   return wrap(CallSite(unwrap<Instruction>(C))
2443     .getAttribute(Idx, (Attribute::AttrKind)KindID));
2444 }
2445 
LLVMGetCallSiteStringAttribute(LLVMValueRef C,LLVMAttributeIndex Idx,const char * K,unsigned KLen)2446 LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C,
2447                                                 LLVMAttributeIndex Idx,
2448                                                 const char *K, unsigned KLen) {
2449   return wrap(CallSite(unwrap<Instruction>(C))
2450     .getAttribute(Idx, StringRef(K, KLen)));
2451 }
2452 
LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C,LLVMAttributeIndex Idx,unsigned KindID)2453 void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
2454                                      unsigned KindID) {
2455   CallSite(unwrap<Instruction>(C))
2456     .removeAttribute(Idx, (Attribute::AttrKind)KindID);
2457 }
2458 
LLVMRemoveCallSiteStringAttribute(LLVMValueRef C,LLVMAttributeIndex Idx,const char * K,unsigned KLen)2459 void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
2460                                        const char *K, unsigned KLen) {
2461   CallSite(unwrap<Instruction>(C)).removeAttribute(Idx, StringRef(K, KLen));
2462 }
2463 
LLVMGetCalledValue(LLVMValueRef Instr)2464 LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr) {
2465   return wrap(CallSite(unwrap<Instruction>(Instr)).getCalledValue());
2466 }
2467 
2468 /*--.. Operations on call instructions (only) ..............................--*/
2469 
LLVMIsTailCall(LLVMValueRef Call)2470 LLVMBool LLVMIsTailCall(LLVMValueRef Call) {
2471   return unwrap<CallInst>(Call)->isTailCall();
2472 }
2473 
LLVMSetTailCall(LLVMValueRef Call,LLVMBool isTailCall)2474 void LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall) {
2475   unwrap<CallInst>(Call)->setTailCall(isTailCall);
2476 }
2477 
2478 /*--.. Operations on invoke instructions (only) ............................--*/
2479 
LLVMGetNormalDest(LLVMValueRef Invoke)2480 LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef Invoke) {
2481   return wrap(unwrap<InvokeInst>(Invoke)->getNormalDest());
2482 }
2483 
LLVMGetUnwindDest(LLVMValueRef Invoke)2484 LLVMBasicBlockRef LLVMGetUnwindDest(LLVMValueRef Invoke) {
2485   if (CleanupReturnInst *CRI = dyn_cast<CleanupReturnInst>(unwrap(Invoke))) {
2486     return wrap(CRI->getUnwindDest());
2487   } else if (CatchSwitchInst *CSI = dyn_cast<CatchSwitchInst>(unwrap(Invoke))) {
2488     return wrap(CSI->getUnwindDest());
2489   }
2490   return wrap(unwrap<InvokeInst>(Invoke)->getUnwindDest());
2491 }
2492 
LLVMSetNormalDest(LLVMValueRef Invoke,LLVMBasicBlockRef B)2493 void LLVMSetNormalDest(LLVMValueRef Invoke, LLVMBasicBlockRef B) {
2494   unwrap<InvokeInst>(Invoke)->setNormalDest(unwrap(B));
2495 }
2496 
LLVMSetUnwindDest(LLVMValueRef Invoke,LLVMBasicBlockRef B)2497 void LLVMSetUnwindDest(LLVMValueRef Invoke, LLVMBasicBlockRef B) {
2498   if (CleanupReturnInst *CRI = dyn_cast<CleanupReturnInst>(unwrap(Invoke))) {
2499     return CRI->setUnwindDest(unwrap(B));
2500   } else if (CatchSwitchInst *CSI = dyn_cast<CatchSwitchInst>(unwrap(Invoke))) {
2501     return CSI->setUnwindDest(unwrap(B));
2502   }
2503   unwrap<InvokeInst>(Invoke)->setUnwindDest(unwrap(B));
2504 }
2505 
2506 /*--.. Operations on terminators ...........................................--*/
2507 
LLVMGetNumSuccessors(LLVMValueRef Term)2508 unsigned LLVMGetNumSuccessors(LLVMValueRef Term) {
2509   return unwrap<TerminatorInst>(Term)->getNumSuccessors();
2510 }
2511 
LLVMGetSuccessor(LLVMValueRef Term,unsigned i)2512 LLVMBasicBlockRef LLVMGetSuccessor(LLVMValueRef Term, unsigned i) {
2513   return wrap(unwrap<TerminatorInst>(Term)->getSuccessor(i));
2514 }
2515 
LLVMSetSuccessor(LLVMValueRef Term,unsigned i,LLVMBasicBlockRef block)2516 void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block) {
2517   return unwrap<TerminatorInst>(Term)->setSuccessor(i,unwrap(block));
2518 }
2519 
2520 /*--.. Operations on branch instructions (only) ............................--*/
2521 
LLVMIsConditional(LLVMValueRef Branch)2522 LLVMBool LLVMIsConditional(LLVMValueRef Branch) {
2523   return unwrap<BranchInst>(Branch)->isConditional();
2524 }
2525 
LLVMGetCondition(LLVMValueRef Branch)2526 LLVMValueRef LLVMGetCondition(LLVMValueRef Branch) {
2527   return wrap(unwrap<BranchInst>(Branch)->getCondition());
2528 }
2529 
LLVMSetCondition(LLVMValueRef Branch,LLVMValueRef Cond)2530 void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond) {
2531   return unwrap<BranchInst>(Branch)->setCondition(unwrap(Cond));
2532 }
2533 
2534 /*--.. Operations on switch instructions (only) ............................--*/
2535 
LLVMGetSwitchDefaultDest(LLVMValueRef Switch)2536 LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef Switch) {
2537   return wrap(unwrap<SwitchInst>(Switch)->getDefaultDest());
2538 }
2539 
2540 /*--.. Operations on alloca instructions (only) ............................--*/
2541 
LLVMGetAllocatedType(LLVMValueRef Alloca)2542 LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca) {
2543   return wrap(unwrap<AllocaInst>(Alloca)->getAllocatedType());
2544 }
2545 
2546 /*--.. Operations on gep instructions (only) ...............................--*/
2547 
LLVMIsInBounds(LLVMValueRef GEP)2548 LLVMBool LLVMIsInBounds(LLVMValueRef GEP) {
2549   return unwrap<GetElementPtrInst>(GEP)->isInBounds();
2550 }
2551 
LLVMSetIsInBounds(LLVMValueRef GEP,LLVMBool InBounds)2552 void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds) {
2553   return unwrap<GetElementPtrInst>(GEP)->setIsInBounds(InBounds);
2554 }
2555 
2556 /*--.. Operations on phi nodes .............................................--*/
2557 
LLVMAddIncoming(LLVMValueRef PhiNode,LLVMValueRef * IncomingValues,LLVMBasicBlockRef * IncomingBlocks,unsigned Count)2558 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
2559                      LLVMBasicBlockRef *IncomingBlocks, unsigned Count) {
2560   PHINode *PhiVal = unwrap<PHINode>(PhiNode);
2561   for (unsigned I = 0; I != Count; ++I)
2562     PhiVal->addIncoming(unwrap(IncomingValues[I]), unwrap(IncomingBlocks[I]));
2563 }
2564 
LLVMCountIncoming(LLVMValueRef PhiNode)2565 unsigned LLVMCountIncoming(LLVMValueRef PhiNode) {
2566   return unwrap<PHINode>(PhiNode)->getNumIncomingValues();
2567 }
2568 
LLVMGetIncomingValue(LLVMValueRef PhiNode,unsigned Index)2569 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index) {
2570   return wrap(unwrap<PHINode>(PhiNode)->getIncomingValue(Index));
2571 }
2572 
LLVMGetIncomingBlock(LLVMValueRef PhiNode,unsigned Index)2573 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index) {
2574   return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index));
2575 }
2576 
2577 /*--.. Operations on extractvalue and insertvalue nodes ....................--*/
2578 
LLVMGetNumIndices(LLVMValueRef Inst)2579 unsigned LLVMGetNumIndices(LLVMValueRef Inst) {
2580   auto *I = unwrap(Inst);
2581   if (auto *GEP = dyn_cast<GetElementPtrInst>(I))
2582     return GEP->getNumIndices();
2583   if (auto *EV = dyn_cast<ExtractValueInst>(I))
2584     return EV->getNumIndices();
2585   if (auto *IV = dyn_cast<InsertValueInst>(I))
2586     return IV->getNumIndices();
2587   llvm_unreachable(
2588     "LLVMGetNumIndices applies only to extractvalue and insertvalue!");
2589 }
2590 
LLVMGetIndices(LLVMValueRef Inst)2591 const unsigned *LLVMGetIndices(LLVMValueRef Inst) {
2592   auto *I = unwrap(Inst);
2593   if (auto *EV = dyn_cast<ExtractValueInst>(I))
2594     return EV->getIndices().data();
2595   if (auto *IV = dyn_cast<InsertValueInst>(I))
2596     return IV->getIndices().data();
2597   llvm_unreachable(
2598     "LLVMGetIndices applies only to extractvalue and insertvalue!");
2599 }
2600 
2601 
2602 /*===-- Instruction builders ----------------------------------------------===*/
2603 
LLVMCreateBuilderInContext(LLVMContextRef C)2604 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C) {
2605   return wrap(new IRBuilder<>(*unwrap(C)));
2606 }
2607 
LLVMCreateBuilder(void)2608 LLVMBuilderRef LLVMCreateBuilder(void) {
2609   return LLVMCreateBuilderInContext(LLVMGetGlobalContext());
2610 }
2611 
LLVMPositionBuilder(LLVMBuilderRef Builder,LLVMBasicBlockRef Block,LLVMValueRef Instr)2612 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
2613                          LLVMValueRef Instr) {
2614   BasicBlock *BB = unwrap(Block);
2615   auto I = Instr ? unwrap<Instruction>(Instr)->getIterator() : BB->end();
2616   unwrap(Builder)->SetInsertPoint(BB, I);
2617 }
2618 
LLVMPositionBuilderBefore(LLVMBuilderRef Builder,LLVMValueRef Instr)2619 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr) {
2620   Instruction *I = unwrap<Instruction>(Instr);
2621   unwrap(Builder)->SetInsertPoint(I->getParent(), I->getIterator());
2622 }
2623 
LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder,LLVMBasicBlockRef Block)2624 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block) {
2625   BasicBlock *BB = unwrap(Block);
2626   unwrap(Builder)->SetInsertPoint(BB);
2627 }
2628 
LLVMGetInsertBlock(LLVMBuilderRef Builder)2629 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder) {
2630    return wrap(unwrap(Builder)->GetInsertBlock());
2631 }
2632 
LLVMClearInsertionPosition(LLVMBuilderRef Builder)2633 void LLVMClearInsertionPosition(LLVMBuilderRef Builder) {
2634   unwrap(Builder)->ClearInsertionPoint();
2635 }
2636 
LLVMInsertIntoBuilder(LLVMBuilderRef Builder,LLVMValueRef Instr)2637 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr) {
2638   unwrap(Builder)->Insert(unwrap<Instruction>(Instr));
2639 }
2640 
LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder,LLVMValueRef Instr,const char * Name)2641 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
2642                                    const char *Name) {
2643   unwrap(Builder)->Insert(unwrap<Instruction>(Instr), Name);
2644 }
2645 
LLVMDisposeBuilder(LLVMBuilderRef Builder)2646 void LLVMDisposeBuilder(LLVMBuilderRef Builder) {
2647   delete unwrap(Builder);
2648 }
2649 
2650 /*--.. Metadata builders ...................................................--*/
2651 
LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder,LLVMValueRef L)2652 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L) {
2653   MDNode *Loc =
2654       L ? cast<MDNode>(unwrap<MetadataAsValue>(L)->getMetadata()) : nullptr;
2655   unwrap(Builder)->SetCurrentDebugLocation(DebugLoc(Loc));
2656 }
2657 
LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder)2658 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder) {
2659   LLVMContext &Context = unwrap(Builder)->getContext();
2660   return wrap(MetadataAsValue::get(
2661       Context, unwrap(Builder)->getCurrentDebugLocation().getAsMDNode()));
2662 }
2663 
LLVMSetInstDebugLocation(LLVMBuilderRef Builder,LLVMValueRef Inst)2664 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst) {
2665   unwrap(Builder)->SetInstDebugLocation(unwrap<Instruction>(Inst));
2666 }
2667 
2668 
2669 /*--.. Instruction builders ................................................--*/
2670 
LLVMBuildRetVoid(LLVMBuilderRef B)2671 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef B) {
2672   return wrap(unwrap(B)->CreateRetVoid());
2673 }
2674 
LLVMBuildRet(LLVMBuilderRef B,LLVMValueRef V)2675 LLVMValueRef LLVMBuildRet(LLVMBuilderRef B, LLVMValueRef V) {
2676   return wrap(unwrap(B)->CreateRet(unwrap(V)));
2677 }
2678 
LLVMBuildAggregateRet(LLVMBuilderRef B,LLVMValueRef * RetVals,unsigned N)2679 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef B, LLVMValueRef *RetVals,
2680                                    unsigned N) {
2681   return wrap(unwrap(B)->CreateAggregateRet(unwrap(RetVals), N));
2682 }
2683 
LLVMBuildBr(LLVMBuilderRef B,LLVMBasicBlockRef Dest)2684 LLVMValueRef LLVMBuildBr(LLVMBuilderRef B, LLVMBasicBlockRef Dest) {
2685   return wrap(unwrap(B)->CreateBr(unwrap(Dest)));
2686 }
2687 
LLVMBuildCondBr(LLVMBuilderRef B,LLVMValueRef If,LLVMBasicBlockRef Then,LLVMBasicBlockRef Else)2688 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef B, LLVMValueRef If,
2689                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Else) {
2690   return wrap(unwrap(B)->CreateCondBr(unwrap(If), unwrap(Then), unwrap(Else)));
2691 }
2692 
LLVMBuildSwitch(LLVMBuilderRef B,LLVMValueRef V,LLVMBasicBlockRef Else,unsigned NumCases)2693 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef B, LLVMValueRef V,
2694                              LLVMBasicBlockRef Else, unsigned NumCases) {
2695   return wrap(unwrap(B)->CreateSwitch(unwrap(V), unwrap(Else), NumCases));
2696 }
2697 
LLVMBuildIndirectBr(LLVMBuilderRef B,LLVMValueRef Addr,unsigned NumDests)2698 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
2699                                  unsigned NumDests) {
2700   return wrap(unwrap(B)->CreateIndirectBr(unwrap(Addr), NumDests));
2701 }
2702 
LLVMBuildInvoke(LLVMBuilderRef B,LLVMValueRef Fn,LLVMValueRef * Args,unsigned NumArgs,LLVMBasicBlockRef Then,LLVMBasicBlockRef Catch,const char * Name)2703 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn,
2704                              LLVMValueRef *Args, unsigned NumArgs,
2705                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
2706                              const char *Name) {
2707   return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch),
2708                                       makeArrayRef(unwrap(Args), NumArgs),
2709                                       Name));
2710 }
2711 
LLVMBuildLandingPad(LLVMBuilderRef B,LLVMTypeRef Ty,LLVMValueRef PersFn,unsigned NumClauses,const char * Name)2712 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
2713                                  LLVMValueRef PersFn, unsigned NumClauses,
2714                                  const char *Name) {
2715   // The personality used to live on the landingpad instruction, but now it
2716   // lives on the parent function. For compatibility, take the provided
2717   // personality and put it on the parent function.
2718   if (PersFn)
2719     unwrap(B)->GetInsertBlock()->getParent()->setPersonalityFn(
2720         cast<Function>(unwrap(PersFn)));
2721   return wrap(unwrap(B)->CreateLandingPad(unwrap(Ty), NumClauses, Name));
2722 }
2723 
LLVMBuildCatchPad(LLVMBuilderRef B,LLVMValueRef ParentPad,LLVMValueRef * Args,unsigned NumArgs,const char * Name)2724 LLVMValueRef LLVMBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
2725                                LLVMValueRef *Args, unsigned NumArgs,
2726                                const char *Name) {
2727   return wrap(unwrap(B)->CreateCatchPad(unwrap(ParentPad),
2728                                         makeArrayRef(unwrap(Args), NumArgs),
2729                                         Name));
2730 }
2731 
LLVMBuildCleanupPad(LLVMBuilderRef B,LLVMValueRef ParentPad,LLVMValueRef * Args,unsigned NumArgs,const char * Name)2732 LLVMValueRef LLVMBuildCleanupPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
2733                                  LLVMValueRef *Args, unsigned NumArgs,
2734                                  const char *Name) {
2735   if (ParentPad == nullptr) {
2736     Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
2737     ParentPad = wrap(Constant::getNullValue(Ty));
2738   }
2739   return wrap(unwrap(B)->CreateCleanupPad(unwrap(ParentPad),
2740                                           makeArrayRef(unwrap(Args), NumArgs),
2741                                           Name));
2742 }
2743 
LLVMBuildResume(LLVMBuilderRef B,LLVMValueRef Exn)2744 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn) {
2745   return wrap(unwrap(B)->CreateResume(unwrap(Exn)));
2746 }
2747 
LLVMBuildCatchSwitch(LLVMBuilderRef B,LLVMValueRef ParentPad,LLVMBasicBlockRef UnwindBB,unsigned NumHandlers,const char * Name)2748 LLVMValueRef LLVMBuildCatchSwitch(LLVMBuilderRef B, LLVMValueRef ParentPad,
2749                                   LLVMBasicBlockRef UnwindBB,
2750                                   unsigned NumHandlers, const char *Name) {
2751   if (ParentPad == nullptr) {
2752     Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
2753     ParentPad = wrap(Constant::getNullValue(Ty));
2754   }
2755   return wrap(unwrap(B)->CreateCatchSwitch(unwrap(ParentPad), unwrap(UnwindBB),
2756                                            NumHandlers, Name));
2757 }
2758 
LLVMBuildCatchRet(LLVMBuilderRef B,LLVMValueRef CatchPad,LLVMBasicBlockRef BB)2759 LLVMValueRef LLVMBuildCatchRet(LLVMBuilderRef B, LLVMValueRef CatchPad,
2760                                LLVMBasicBlockRef BB) {
2761   return wrap(unwrap(B)->CreateCatchRet(unwrap<CatchPadInst>(CatchPad),
2762                                         unwrap(BB)));
2763 }
2764 
LLVMBuildCleanupRet(LLVMBuilderRef B,LLVMValueRef CatchPad,LLVMBasicBlockRef BB)2765 LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B, LLVMValueRef CatchPad,
2766                                  LLVMBasicBlockRef BB) {
2767   return wrap(unwrap(B)->CreateCleanupRet(unwrap<CleanupPadInst>(CatchPad),
2768                                           unwrap(BB)));
2769 }
2770 
LLVMBuildUnreachable(LLVMBuilderRef B)2771 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) {
2772   return wrap(unwrap(B)->CreateUnreachable());
2773 }
2774 
LLVMAddCase(LLVMValueRef Switch,LLVMValueRef OnVal,LLVMBasicBlockRef Dest)2775 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
2776                  LLVMBasicBlockRef Dest) {
2777   unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest));
2778 }
2779 
LLVMAddDestination(LLVMValueRef IndirectBr,LLVMBasicBlockRef Dest)2780 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest) {
2781   unwrap<IndirectBrInst>(IndirectBr)->addDestination(unwrap(Dest));
2782 }
2783 
LLVMGetNumClauses(LLVMValueRef LandingPad)2784 unsigned LLVMGetNumClauses(LLVMValueRef LandingPad) {
2785   return unwrap<LandingPadInst>(LandingPad)->getNumClauses();
2786 }
2787 
LLVMGetClause(LLVMValueRef LandingPad,unsigned Idx)2788 LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx) {
2789   return wrap(unwrap<LandingPadInst>(LandingPad)->getClause(Idx));
2790 }
2791 
LLVMAddClause(LLVMValueRef LandingPad,LLVMValueRef ClauseVal)2792 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal) {
2793   unwrap<LandingPadInst>(LandingPad)->
2794     addClause(cast<Constant>(unwrap(ClauseVal)));
2795 }
2796 
LLVMIsCleanup(LLVMValueRef LandingPad)2797 LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad) {
2798   return unwrap<LandingPadInst>(LandingPad)->isCleanup();
2799 }
2800 
LLVMSetCleanup(LLVMValueRef LandingPad,LLVMBool Val)2801 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val) {
2802   unwrap<LandingPadInst>(LandingPad)->setCleanup(Val);
2803 }
2804 
LLVMAddHandler(LLVMValueRef CatchSwitch,LLVMBasicBlockRef Dest)2805 void LLVMAddHandler(LLVMValueRef CatchSwitch, LLVMBasicBlockRef Dest) {
2806   unwrap<CatchSwitchInst>(CatchSwitch)->addHandler(unwrap(Dest));
2807 }
2808 
LLVMGetNumHandlers(LLVMValueRef CatchSwitch)2809 unsigned LLVMGetNumHandlers(LLVMValueRef CatchSwitch) {
2810   return unwrap<CatchSwitchInst>(CatchSwitch)->getNumHandlers();
2811 }
2812 
LLVMGetHandlers(LLVMValueRef CatchSwitch,LLVMBasicBlockRef * Handlers)2813 void LLVMGetHandlers(LLVMValueRef CatchSwitch, LLVMBasicBlockRef *Handlers) {
2814   CatchSwitchInst *CSI = unwrap<CatchSwitchInst>(CatchSwitch);
2815   for (CatchSwitchInst::handler_iterator I = CSI->handler_begin(),
2816                                          E = CSI->handler_end(); I != E; ++I)
2817     *Handlers++ = wrap(*I);
2818 }
2819 
LLVMGetParentCatchSwitch(LLVMValueRef CatchPad)2820 LLVMValueRef LLVMGetParentCatchSwitch(LLVMValueRef CatchPad) {
2821   return wrap(unwrap<CatchPadInst>(CatchPad)->getCatchSwitch());
2822 }
2823 
LLVMSetParentCatchSwitch(LLVMValueRef CatchPad,LLVMValueRef CatchSwitch)2824 void LLVMSetParentCatchSwitch(LLVMValueRef CatchPad, LLVMValueRef CatchSwitch) {
2825   unwrap<CatchPadInst>(CatchPad)
2826     ->setCatchSwitch(unwrap<CatchSwitchInst>(CatchSwitch));
2827 }
2828 
2829 /*--.. Funclets ...........................................................--*/
2830 
LLVMGetArgOperand(LLVMValueRef Funclet,unsigned i)2831 LLVMValueRef LLVMGetArgOperand(LLVMValueRef Funclet, unsigned i) {
2832   return wrap(unwrap<FuncletPadInst>(Funclet)->getArgOperand(i));
2833 }
2834 
LLVMSetArgOperand(LLVMValueRef Funclet,unsigned i,LLVMValueRef value)2835 void LLVMSetArgOperand(LLVMValueRef Funclet, unsigned i, LLVMValueRef value) {
2836   unwrap<FuncletPadInst>(Funclet)->setArgOperand(i, unwrap(value));
2837 }
2838 
2839 /*--.. Arithmetic ..........................................................--*/
2840 
LLVMBuildAdd(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2841 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2842                           const char *Name) {
2843   return wrap(unwrap(B)->CreateAdd(unwrap(LHS), unwrap(RHS), Name));
2844 }
2845 
LLVMBuildNSWAdd(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2846 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2847                           const char *Name) {
2848   return wrap(unwrap(B)->CreateNSWAdd(unwrap(LHS), unwrap(RHS), Name));
2849 }
2850 
LLVMBuildNUWAdd(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2851 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2852                           const char *Name) {
2853   return wrap(unwrap(B)->CreateNUWAdd(unwrap(LHS), unwrap(RHS), Name));
2854 }
2855 
LLVMBuildFAdd(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2856 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2857                           const char *Name) {
2858   return wrap(unwrap(B)->CreateFAdd(unwrap(LHS), unwrap(RHS), Name));
2859 }
2860 
LLVMBuildSub(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2861 LLVMValueRef LLVMBuildSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2862                           const char *Name) {
2863   return wrap(unwrap(B)->CreateSub(unwrap(LHS), unwrap(RHS), Name));
2864 }
2865 
LLVMBuildNSWSub(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2866 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2867                           const char *Name) {
2868   return wrap(unwrap(B)->CreateNSWSub(unwrap(LHS), unwrap(RHS), Name));
2869 }
2870 
LLVMBuildNUWSub(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2871 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2872                           const char *Name) {
2873   return wrap(unwrap(B)->CreateNUWSub(unwrap(LHS), unwrap(RHS), Name));
2874 }
2875 
LLVMBuildFSub(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2876 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2877                           const char *Name) {
2878   return wrap(unwrap(B)->CreateFSub(unwrap(LHS), unwrap(RHS), Name));
2879 }
2880 
LLVMBuildMul(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2881 LLVMValueRef LLVMBuildMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2882                           const char *Name) {
2883   return wrap(unwrap(B)->CreateMul(unwrap(LHS), unwrap(RHS), Name));
2884 }
2885 
LLVMBuildNSWMul(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2886 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2887                           const char *Name) {
2888   return wrap(unwrap(B)->CreateNSWMul(unwrap(LHS), unwrap(RHS), Name));
2889 }
2890 
LLVMBuildNUWMul(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2891 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2892                           const char *Name) {
2893   return wrap(unwrap(B)->CreateNUWMul(unwrap(LHS), unwrap(RHS), Name));
2894 }
2895 
LLVMBuildFMul(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2896 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2897                           const char *Name) {
2898   return wrap(unwrap(B)->CreateFMul(unwrap(LHS), unwrap(RHS), Name));
2899 }
2900 
LLVMBuildUDiv(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2901 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2902                            const char *Name) {
2903   return wrap(unwrap(B)->CreateUDiv(unwrap(LHS), unwrap(RHS), Name));
2904 }
2905 
LLVMBuildExactUDiv(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2906 LLVMValueRef LLVMBuildExactUDiv(LLVMBuilderRef B, LLVMValueRef LHS,
2907                                 LLVMValueRef RHS, const char *Name) {
2908   return wrap(unwrap(B)->CreateExactUDiv(unwrap(LHS), unwrap(RHS), Name));
2909 }
2910 
LLVMBuildSDiv(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2911 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2912                            const char *Name) {
2913   return wrap(unwrap(B)->CreateSDiv(unwrap(LHS), unwrap(RHS), Name));
2914 }
2915 
LLVMBuildExactSDiv(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2916 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef B, LLVMValueRef LHS,
2917                                 LLVMValueRef RHS, const char *Name) {
2918   return wrap(unwrap(B)->CreateExactSDiv(unwrap(LHS), unwrap(RHS), Name));
2919 }
2920 
LLVMBuildFDiv(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2921 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2922                            const char *Name) {
2923   return wrap(unwrap(B)->CreateFDiv(unwrap(LHS), unwrap(RHS), Name));
2924 }
2925 
LLVMBuildURem(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2926 LLVMValueRef LLVMBuildURem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2927                            const char *Name) {
2928   return wrap(unwrap(B)->CreateURem(unwrap(LHS), unwrap(RHS), Name));
2929 }
2930 
LLVMBuildSRem(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2931 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2932                            const char *Name) {
2933   return wrap(unwrap(B)->CreateSRem(unwrap(LHS), unwrap(RHS), Name));
2934 }
2935 
LLVMBuildFRem(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2936 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2937                            const char *Name) {
2938   return wrap(unwrap(B)->CreateFRem(unwrap(LHS), unwrap(RHS), Name));
2939 }
2940 
LLVMBuildShl(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2941 LLVMValueRef LLVMBuildShl(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2942                           const char *Name) {
2943   return wrap(unwrap(B)->CreateShl(unwrap(LHS), unwrap(RHS), Name));
2944 }
2945 
LLVMBuildLShr(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2946 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2947                            const char *Name) {
2948   return wrap(unwrap(B)->CreateLShr(unwrap(LHS), unwrap(RHS), Name));
2949 }
2950 
LLVMBuildAShr(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2951 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2952                            const char *Name) {
2953   return wrap(unwrap(B)->CreateAShr(unwrap(LHS), unwrap(RHS), Name));
2954 }
2955 
LLVMBuildAnd(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2956 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2957                           const char *Name) {
2958   return wrap(unwrap(B)->CreateAnd(unwrap(LHS), unwrap(RHS), Name));
2959 }
2960 
LLVMBuildOr(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2961 LLVMValueRef LLVMBuildOr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2962                          const char *Name) {
2963   return wrap(unwrap(B)->CreateOr(unwrap(LHS), unwrap(RHS), Name));
2964 }
2965 
LLVMBuildXor(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2966 LLVMValueRef LLVMBuildXor(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
2967                           const char *Name) {
2968   return wrap(unwrap(B)->CreateXor(unwrap(LHS), unwrap(RHS), Name));
2969 }
2970 
LLVMBuildBinOp(LLVMBuilderRef B,LLVMOpcode Op,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)2971 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
2972                             LLVMValueRef LHS, LLVMValueRef RHS,
2973                             const char *Name) {
2974   return wrap(unwrap(B)->CreateBinOp(Instruction::BinaryOps(map_from_llvmopcode(Op)), unwrap(LHS),
2975                                      unwrap(RHS), Name));
2976 }
2977 
LLVMBuildNeg(LLVMBuilderRef B,LLVMValueRef V,const char * Name)2978 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
2979   return wrap(unwrap(B)->CreateNeg(unwrap(V), Name));
2980 }
2981 
LLVMBuildNSWNeg(LLVMBuilderRef B,LLVMValueRef V,const char * Name)2982 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
2983                              const char *Name) {
2984   return wrap(unwrap(B)->CreateNSWNeg(unwrap(V), Name));
2985 }
2986 
LLVMBuildNUWNeg(LLVMBuilderRef B,LLVMValueRef V,const char * Name)2987 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
2988                              const char *Name) {
2989   return wrap(unwrap(B)->CreateNUWNeg(unwrap(V), Name));
2990 }
2991 
LLVMBuildFNeg(LLVMBuilderRef B,LLVMValueRef V,const char * Name)2992 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
2993   return wrap(unwrap(B)->CreateFNeg(unwrap(V), Name));
2994 }
2995 
LLVMBuildNot(LLVMBuilderRef B,LLVMValueRef V,const char * Name)2996 LLVMValueRef LLVMBuildNot(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
2997   return wrap(unwrap(B)->CreateNot(unwrap(V), Name));
2998 }
2999 
3000 /*--.. Memory ..............................................................--*/
3001 
LLVMBuildMalloc(LLVMBuilderRef B,LLVMTypeRef Ty,const char * Name)3002 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
3003                              const char *Name) {
3004   Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
3005   Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty));
3006   AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy);
3007   Instruction* Malloc = CallInst::CreateMalloc(unwrap(B)->GetInsertBlock(),
3008                                                ITy, unwrap(Ty), AllocSize,
3009                                                nullptr, nullptr, "");
3010   return wrap(unwrap(B)->Insert(Malloc, Twine(Name)));
3011 }
3012 
LLVMBuildArrayMalloc(LLVMBuilderRef B,LLVMTypeRef Ty,LLVMValueRef Val,const char * Name)3013 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
3014                                   LLVMValueRef Val, const char *Name) {
3015   Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
3016   Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty));
3017   AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy);
3018   Instruction* Malloc = CallInst::CreateMalloc(unwrap(B)->GetInsertBlock(),
3019                                                ITy, unwrap(Ty), AllocSize,
3020                                                unwrap(Val), nullptr, "");
3021   return wrap(unwrap(B)->Insert(Malloc, Twine(Name)));
3022 }
3023 
LLVMBuildAlloca(LLVMBuilderRef B,LLVMTypeRef Ty,const char * Name)3024 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
3025                              const char *Name) {
3026   return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), nullptr, Name));
3027 }
3028 
LLVMBuildArrayAlloca(LLVMBuilderRef B,LLVMTypeRef Ty,LLVMValueRef Val,const char * Name)3029 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
3030                                   LLVMValueRef Val, const char *Name) {
3031   return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), unwrap(Val), Name));
3032 }
3033 
LLVMBuildFree(LLVMBuilderRef B,LLVMValueRef PointerVal)3034 LLVMValueRef LLVMBuildFree(LLVMBuilderRef B, LLVMValueRef PointerVal) {
3035   return wrap(unwrap(B)->Insert(
3036      CallInst::CreateFree(unwrap(PointerVal), unwrap(B)->GetInsertBlock())));
3037 }
3038 
LLVMBuildLoad(LLVMBuilderRef B,LLVMValueRef PointerVal,const char * Name)3039 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef B, LLVMValueRef PointerVal,
3040                            const char *Name) {
3041   return wrap(unwrap(B)->CreateLoad(unwrap(PointerVal), Name));
3042 }
3043 
LLVMBuildStore(LLVMBuilderRef B,LLVMValueRef Val,LLVMValueRef PointerVal)3044 LLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val,
3045                             LLVMValueRef PointerVal) {
3046   return wrap(unwrap(B)->CreateStore(unwrap(Val), unwrap(PointerVal)));
3047 }
3048 
mapFromLLVMOrdering(LLVMAtomicOrdering Ordering)3049 static AtomicOrdering mapFromLLVMOrdering(LLVMAtomicOrdering Ordering) {
3050   switch (Ordering) {
3051     case LLVMAtomicOrderingNotAtomic: return AtomicOrdering::NotAtomic;
3052     case LLVMAtomicOrderingUnordered: return AtomicOrdering::Unordered;
3053     case LLVMAtomicOrderingMonotonic: return AtomicOrdering::Monotonic;
3054     case LLVMAtomicOrderingAcquire: return AtomicOrdering::Acquire;
3055     case LLVMAtomicOrderingRelease: return AtomicOrdering::Release;
3056     case LLVMAtomicOrderingAcquireRelease:
3057       return AtomicOrdering::AcquireRelease;
3058     case LLVMAtomicOrderingSequentiallyConsistent:
3059       return AtomicOrdering::SequentiallyConsistent;
3060   }
3061 
3062   llvm_unreachable("Invalid LLVMAtomicOrdering value!");
3063 }
3064 
mapToLLVMOrdering(AtomicOrdering Ordering)3065 static LLVMAtomicOrdering mapToLLVMOrdering(AtomicOrdering Ordering) {
3066   switch (Ordering) {
3067     case AtomicOrdering::NotAtomic: return LLVMAtomicOrderingNotAtomic;
3068     case AtomicOrdering::Unordered: return LLVMAtomicOrderingUnordered;
3069     case AtomicOrdering::Monotonic: return LLVMAtomicOrderingMonotonic;
3070     case AtomicOrdering::Acquire: return LLVMAtomicOrderingAcquire;
3071     case AtomicOrdering::Release: return LLVMAtomicOrderingRelease;
3072     case AtomicOrdering::AcquireRelease:
3073       return LLVMAtomicOrderingAcquireRelease;
3074     case AtomicOrdering::SequentiallyConsistent:
3075       return LLVMAtomicOrderingSequentiallyConsistent;
3076   }
3077 
3078   llvm_unreachable("Invalid AtomicOrdering value!");
3079 }
3080 
3081 // TODO: Should this and other atomic instructions support building with
3082 // "syncscope"?
LLVMBuildFence(LLVMBuilderRef B,LLVMAtomicOrdering Ordering,LLVMBool isSingleThread,const char * Name)3083 LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering Ordering,
3084                             LLVMBool isSingleThread, const char *Name) {
3085   return wrap(
3086     unwrap(B)->CreateFence(mapFromLLVMOrdering(Ordering),
3087                            isSingleThread ? SyncScope::SingleThread
3088                                           : SyncScope::System,
3089                            Name));
3090 }
3091 
LLVMBuildGEP(LLVMBuilderRef B,LLVMValueRef Pointer,LLVMValueRef * Indices,unsigned NumIndices,const char * Name)3092 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
3093                           LLVMValueRef *Indices, unsigned NumIndices,
3094                           const char *Name) {
3095   ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
3096   return wrap(unwrap(B)->CreateGEP(nullptr, unwrap(Pointer), IdxList, Name));
3097 }
3098 
LLVMBuildInBoundsGEP(LLVMBuilderRef B,LLVMValueRef Pointer,LLVMValueRef * Indices,unsigned NumIndices,const char * Name)3099 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
3100                                   LLVMValueRef *Indices, unsigned NumIndices,
3101                                   const char *Name) {
3102   ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
3103   return wrap(
3104       unwrap(B)->CreateInBoundsGEP(nullptr, unwrap(Pointer), IdxList, Name));
3105 }
3106 
LLVMBuildStructGEP(LLVMBuilderRef B,LLVMValueRef Pointer,unsigned Idx,const char * Name)3107 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
3108                                 unsigned Idx, const char *Name) {
3109   return wrap(unwrap(B)->CreateStructGEP(nullptr, unwrap(Pointer), Idx, Name));
3110 }
3111 
LLVMBuildGlobalString(LLVMBuilderRef B,const char * Str,const char * Name)3112 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
3113                                    const char *Name) {
3114   return wrap(unwrap(B)->CreateGlobalString(Str, Name));
3115 }
3116 
LLVMBuildGlobalStringPtr(LLVMBuilderRef B,const char * Str,const char * Name)3117 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
3118                                       const char *Name) {
3119   return wrap(unwrap(B)->CreateGlobalStringPtr(Str, Name));
3120 }
3121 
LLVMGetVolatile(LLVMValueRef MemAccessInst)3122 LLVMBool LLVMGetVolatile(LLVMValueRef MemAccessInst) {
3123   Value *P = unwrap<Value>(MemAccessInst);
3124   if (LoadInst *LI = dyn_cast<LoadInst>(P))
3125     return LI->isVolatile();
3126   return cast<StoreInst>(P)->isVolatile();
3127 }
3128 
LLVMSetVolatile(LLVMValueRef MemAccessInst,LLVMBool isVolatile)3129 void LLVMSetVolatile(LLVMValueRef MemAccessInst, LLVMBool isVolatile) {
3130   Value *P = unwrap<Value>(MemAccessInst);
3131   if (LoadInst *LI = dyn_cast<LoadInst>(P))
3132     return LI->setVolatile(isVolatile);
3133   return cast<StoreInst>(P)->setVolatile(isVolatile);
3134 }
3135 
LLVMGetOrdering(LLVMValueRef MemAccessInst)3136 LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemAccessInst) {
3137   Value *P = unwrap<Value>(MemAccessInst);
3138   AtomicOrdering O;
3139   if (LoadInst *LI = dyn_cast<LoadInst>(P))
3140     O = LI->getOrdering();
3141   else
3142     O = cast<StoreInst>(P)->getOrdering();
3143   return mapToLLVMOrdering(O);
3144 }
3145 
LLVMSetOrdering(LLVMValueRef MemAccessInst,LLVMAtomicOrdering Ordering)3146 void LLVMSetOrdering(LLVMValueRef MemAccessInst, LLVMAtomicOrdering Ordering) {
3147   Value *P = unwrap<Value>(MemAccessInst);
3148   AtomicOrdering O = mapFromLLVMOrdering(Ordering);
3149 
3150   if (LoadInst *LI = dyn_cast<LoadInst>(P))
3151     return LI->setOrdering(O);
3152   return cast<StoreInst>(P)->setOrdering(O);
3153 }
3154 
3155 /*--.. Casts ...............................................................--*/
3156 
LLVMBuildTrunc(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3157 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef B, LLVMValueRef Val,
3158                             LLVMTypeRef DestTy, const char *Name) {
3159   return wrap(unwrap(B)->CreateTrunc(unwrap(Val), unwrap(DestTy), Name));
3160 }
3161 
LLVMBuildZExt(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3162 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef B, LLVMValueRef Val,
3163                            LLVMTypeRef DestTy, const char *Name) {
3164   return wrap(unwrap(B)->CreateZExt(unwrap(Val), unwrap(DestTy), Name));
3165 }
3166 
LLVMBuildSExt(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3167 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef B, LLVMValueRef Val,
3168                            LLVMTypeRef DestTy, const char *Name) {
3169   return wrap(unwrap(B)->CreateSExt(unwrap(Val), unwrap(DestTy), Name));
3170 }
3171 
LLVMBuildFPToUI(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3172 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef B, LLVMValueRef Val,
3173                              LLVMTypeRef DestTy, const char *Name) {
3174   return wrap(unwrap(B)->CreateFPToUI(unwrap(Val), unwrap(DestTy), Name));
3175 }
3176 
LLVMBuildFPToSI(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3177 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef B, LLVMValueRef Val,
3178                              LLVMTypeRef DestTy, const char *Name) {
3179   return wrap(unwrap(B)->CreateFPToSI(unwrap(Val), unwrap(DestTy), Name));
3180 }
3181 
LLVMBuildUIToFP(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3182 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef B, LLVMValueRef Val,
3183                              LLVMTypeRef DestTy, const char *Name) {
3184   return wrap(unwrap(B)->CreateUIToFP(unwrap(Val), unwrap(DestTy), Name));
3185 }
3186 
LLVMBuildSIToFP(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3187 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef B, LLVMValueRef Val,
3188                              LLVMTypeRef DestTy, const char *Name) {
3189   return wrap(unwrap(B)->CreateSIToFP(unwrap(Val), unwrap(DestTy), Name));
3190 }
3191 
LLVMBuildFPTrunc(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3192 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef B, LLVMValueRef Val,
3193                               LLVMTypeRef DestTy, const char *Name) {
3194   return wrap(unwrap(B)->CreateFPTrunc(unwrap(Val), unwrap(DestTy), Name));
3195 }
3196 
LLVMBuildFPExt(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3197 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef B, LLVMValueRef Val,
3198                             LLVMTypeRef DestTy, const char *Name) {
3199   return wrap(unwrap(B)->CreateFPExt(unwrap(Val), unwrap(DestTy), Name));
3200 }
3201 
LLVMBuildPtrToInt(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3202 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef B, LLVMValueRef Val,
3203                                LLVMTypeRef DestTy, const char *Name) {
3204   return wrap(unwrap(B)->CreatePtrToInt(unwrap(Val), unwrap(DestTy), Name));
3205 }
3206 
LLVMBuildIntToPtr(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3207 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef B, LLVMValueRef Val,
3208                                LLVMTypeRef DestTy, const char *Name) {
3209   return wrap(unwrap(B)->CreateIntToPtr(unwrap(Val), unwrap(DestTy), Name));
3210 }
3211 
LLVMBuildBitCast(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3212 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef B, LLVMValueRef Val,
3213                               LLVMTypeRef DestTy, const char *Name) {
3214   return wrap(unwrap(B)->CreateBitCast(unwrap(Val), unwrap(DestTy), Name));
3215 }
3216 
LLVMBuildAddrSpaceCast(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3217 LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef B, LLVMValueRef Val,
3218                                     LLVMTypeRef DestTy, const char *Name) {
3219   return wrap(unwrap(B)->CreateAddrSpaceCast(unwrap(Val), unwrap(DestTy), Name));
3220 }
3221 
LLVMBuildZExtOrBitCast(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3222 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val,
3223                                     LLVMTypeRef DestTy, const char *Name) {
3224   return wrap(unwrap(B)->CreateZExtOrBitCast(unwrap(Val), unwrap(DestTy),
3225                                              Name));
3226 }
3227 
LLVMBuildSExtOrBitCast(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3228 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val,
3229                                     LLVMTypeRef DestTy, const char *Name) {
3230   return wrap(unwrap(B)->CreateSExtOrBitCast(unwrap(Val), unwrap(DestTy),
3231                                              Name));
3232 }
3233 
LLVMBuildTruncOrBitCast(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3234 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef B, LLVMValueRef Val,
3235                                      LLVMTypeRef DestTy, const char *Name) {
3236   return wrap(unwrap(B)->CreateTruncOrBitCast(unwrap(Val), unwrap(DestTy),
3237                                               Name));
3238 }
3239 
LLVMBuildCast(LLVMBuilderRef B,LLVMOpcode Op,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3240 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
3241                            LLVMTypeRef DestTy, const char *Name) {
3242   return wrap(unwrap(B)->CreateCast(Instruction::CastOps(map_from_llvmopcode(Op)), unwrap(Val),
3243                                     unwrap(DestTy), Name));
3244 }
3245 
LLVMBuildPointerCast(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3246 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef B, LLVMValueRef Val,
3247                                   LLVMTypeRef DestTy, const char *Name) {
3248   return wrap(unwrap(B)->CreatePointerCast(unwrap(Val), unwrap(DestTy), Name));
3249 }
3250 
LLVMBuildIntCast(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3251 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef B, LLVMValueRef Val,
3252                               LLVMTypeRef DestTy, const char *Name) {
3253   return wrap(unwrap(B)->CreateIntCast(unwrap(Val), unwrap(DestTy),
3254                                        /*isSigned*/true, Name));
3255 }
3256 
LLVMBuildFPCast(LLVMBuilderRef B,LLVMValueRef Val,LLVMTypeRef DestTy,const char * Name)3257 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef B, LLVMValueRef Val,
3258                              LLVMTypeRef DestTy, const char *Name) {
3259   return wrap(unwrap(B)->CreateFPCast(unwrap(Val), unwrap(DestTy), Name));
3260 }
3261 
3262 /*--.. Comparisons .........................................................--*/
3263 
LLVMBuildICmp(LLVMBuilderRef B,LLVMIntPredicate Op,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)3264 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef B, LLVMIntPredicate Op,
3265                            LLVMValueRef LHS, LLVMValueRef RHS,
3266                            const char *Name) {
3267   return wrap(unwrap(B)->CreateICmp(static_cast<ICmpInst::Predicate>(Op),
3268                                     unwrap(LHS), unwrap(RHS), Name));
3269 }
3270 
LLVMBuildFCmp(LLVMBuilderRef B,LLVMRealPredicate Op,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)3271 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef B, LLVMRealPredicate Op,
3272                            LLVMValueRef LHS, LLVMValueRef RHS,
3273                            const char *Name) {
3274   return wrap(unwrap(B)->CreateFCmp(static_cast<FCmpInst::Predicate>(Op),
3275                                     unwrap(LHS), unwrap(RHS), Name));
3276 }
3277 
3278 /*--.. Miscellaneous instructions ..........................................--*/
3279 
LLVMBuildPhi(LLVMBuilderRef B,LLVMTypeRef Ty,const char * Name)3280 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name) {
3281   return wrap(unwrap(B)->CreatePHI(unwrap(Ty), 0, Name));
3282 }
3283 
LLVMBuildCall(LLVMBuilderRef B,LLVMValueRef Fn,LLVMValueRef * Args,unsigned NumArgs,const char * Name)3284 LLVMValueRef LLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn,
3285                            LLVMValueRef *Args, unsigned NumArgs,
3286                            const char *Name) {
3287   return wrap(unwrap(B)->CreateCall(unwrap(Fn),
3288                                     makeArrayRef(unwrap(Args), NumArgs),
3289                                     Name));
3290 }
3291 
LLVMBuildSelect(LLVMBuilderRef B,LLVMValueRef If,LLVMValueRef Then,LLVMValueRef Else,const char * Name)3292 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If,
3293                              LLVMValueRef Then, LLVMValueRef Else,
3294                              const char *Name) {
3295   return wrap(unwrap(B)->CreateSelect(unwrap(If), unwrap(Then), unwrap(Else),
3296                                       Name));
3297 }
3298 
LLVMBuildVAArg(LLVMBuilderRef B,LLVMValueRef List,LLVMTypeRef Ty,const char * Name)3299 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef B, LLVMValueRef List,
3300                             LLVMTypeRef Ty, const char *Name) {
3301   return wrap(unwrap(B)->CreateVAArg(unwrap(List), unwrap(Ty), Name));
3302 }
3303 
LLVMBuildExtractElement(LLVMBuilderRef B,LLVMValueRef VecVal,LLVMValueRef Index,const char * Name)3304 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef B, LLVMValueRef VecVal,
3305                                       LLVMValueRef Index, const char *Name) {
3306   return wrap(unwrap(B)->CreateExtractElement(unwrap(VecVal), unwrap(Index),
3307                                               Name));
3308 }
3309 
LLVMBuildInsertElement(LLVMBuilderRef B,LLVMValueRef VecVal,LLVMValueRef EltVal,LLVMValueRef Index,const char * Name)3310 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef B, LLVMValueRef VecVal,
3311                                     LLVMValueRef EltVal, LLVMValueRef Index,
3312                                     const char *Name) {
3313   return wrap(unwrap(B)->CreateInsertElement(unwrap(VecVal), unwrap(EltVal),
3314                                              unwrap(Index), Name));
3315 }
3316 
LLVMBuildShuffleVector(LLVMBuilderRef B,LLVMValueRef V1,LLVMValueRef V2,LLVMValueRef Mask,const char * Name)3317 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef B, LLVMValueRef V1,
3318                                     LLVMValueRef V2, LLVMValueRef Mask,
3319                                     const char *Name) {
3320   return wrap(unwrap(B)->CreateShuffleVector(unwrap(V1), unwrap(V2),
3321                                              unwrap(Mask), Name));
3322 }
3323 
LLVMBuildExtractValue(LLVMBuilderRef B,LLVMValueRef AggVal,unsigned Index,const char * Name)3324 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef B, LLVMValueRef AggVal,
3325                                    unsigned Index, const char *Name) {
3326   return wrap(unwrap(B)->CreateExtractValue(unwrap(AggVal), Index, Name));
3327 }
3328 
LLVMBuildInsertValue(LLVMBuilderRef B,LLVMValueRef AggVal,LLVMValueRef EltVal,unsigned Index,const char * Name)3329 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef B, LLVMValueRef AggVal,
3330                                   LLVMValueRef EltVal, unsigned Index,
3331                                   const char *Name) {
3332   return wrap(unwrap(B)->CreateInsertValue(unwrap(AggVal), unwrap(EltVal),
3333                                            Index, Name));
3334 }
3335 
LLVMBuildIsNull(LLVMBuilderRef B,LLVMValueRef Val,const char * Name)3336 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef B, LLVMValueRef Val,
3337                              const char *Name) {
3338   return wrap(unwrap(B)->CreateIsNull(unwrap(Val), Name));
3339 }
3340 
LLVMBuildIsNotNull(LLVMBuilderRef B,LLVMValueRef Val,const char * Name)3341 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef B, LLVMValueRef Val,
3342                                 const char *Name) {
3343   return wrap(unwrap(B)->CreateIsNotNull(unwrap(Val), Name));
3344 }
3345 
LLVMBuildPtrDiff(LLVMBuilderRef B,LLVMValueRef LHS,LLVMValueRef RHS,const char * Name)3346 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef B, LLVMValueRef LHS,
3347                               LLVMValueRef RHS, const char *Name) {
3348   return wrap(unwrap(B)->CreatePtrDiff(unwrap(LHS), unwrap(RHS), Name));
3349 }
3350 
LLVMBuildAtomicRMW(LLVMBuilderRef B,LLVMAtomicRMWBinOp op,LLVMValueRef PTR,LLVMValueRef Val,LLVMAtomicOrdering ordering,LLVMBool singleThread)3351 LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B,LLVMAtomicRMWBinOp op,
3352                                LLVMValueRef PTR, LLVMValueRef Val,
3353                                LLVMAtomicOrdering ordering,
3354                                LLVMBool singleThread) {
3355   AtomicRMWInst::BinOp intop;
3356   switch (op) {
3357     case LLVMAtomicRMWBinOpXchg: intop = AtomicRMWInst::Xchg; break;
3358     case LLVMAtomicRMWBinOpAdd: intop = AtomicRMWInst::Add; break;
3359     case LLVMAtomicRMWBinOpSub: intop = AtomicRMWInst::Sub; break;
3360     case LLVMAtomicRMWBinOpAnd: intop = AtomicRMWInst::And; break;
3361     case LLVMAtomicRMWBinOpNand: intop = AtomicRMWInst::Nand; break;
3362     case LLVMAtomicRMWBinOpOr: intop = AtomicRMWInst::Or; break;
3363     case LLVMAtomicRMWBinOpXor: intop = AtomicRMWInst::Xor; break;
3364     case LLVMAtomicRMWBinOpMax: intop = AtomicRMWInst::Max; break;
3365     case LLVMAtomicRMWBinOpMin: intop = AtomicRMWInst::Min; break;
3366     case LLVMAtomicRMWBinOpUMax: intop = AtomicRMWInst::UMax; break;
3367     case LLVMAtomicRMWBinOpUMin: intop = AtomicRMWInst::UMin; break;
3368   }
3369   return wrap(unwrap(B)->CreateAtomicRMW(intop, unwrap(PTR), unwrap(Val),
3370     mapFromLLVMOrdering(ordering), singleThread ? SyncScope::SingleThread
3371                                                 : SyncScope::System));
3372 }
3373 
LLVMBuildAtomicCmpXchg(LLVMBuilderRef B,LLVMValueRef Ptr,LLVMValueRef Cmp,LLVMValueRef New,LLVMAtomicOrdering SuccessOrdering,LLVMAtomicOrdering FailureOrdering,LLVMBool singleThread)3374 LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
3375                                     LLVMValueRef Cmp, LLVMValueRef New,
3376                                     LLVMAtomicOrdering SuccessOrdering,
3377                                     LLVMAtomicOrdering FailureOrdering,
3378                                     LLVMBool singleThread) {
3379 
3380   return wrap(unwrap(B)->CreateAtomicCmpXchg(unwrap(Ptr), unwrap(Cmp),
3381                 unwrap(New), mapFromLLVMOrdering(SuccessOrdering),
3382                 mapFromLLVMOrdering(FailureOrdering),
3383                 singleThread ? SyncScope::SingleThread : SyncScope::System));
3384 }
3385 
3386 
LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst)3387 LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst) {
3388   Value *P = unwrap<Value>(AtomicInst);
3389 
3390   if (AtomicRMWInst *I = dyn_cast<AtomicRMWInst>(P))
3391     return I->getSyncScopeID() == SyncScope::SingleThread;
3392   return cast<AtomicCmpXchgInst>(P)->getSyncScopeID() ==
3393              SyncScope::SingleThread;
3394 }
3395 
LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst,LLVMBool NewValue)3396 void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool NewValue) {
3397   Value *P = unwrap<Value>(AtomicInst);
3398   SyncScope::ID SSID = NewValue ? SyncScope::SingleThread : SyncScope::System;
3399 
3400   if (AtomicRMWInst *I = dyn_cast<AtomicRMWInst>(P))
3401     return I->setSyncScopeID(SSID);
3402   return cast<AtomicCmpXchgInst>(P)->setSyncScopeID(SSID);
3403 }
3404 
LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst)3405 LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst)  {
3406   Value *P = unwrap<Value>(CmpXchgInst);
3407   return mapToLLVMOrdering(cast<AtomicCmpXchgInst>(P)->getSuccessOrdering());
3408 }
3409 
LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst,LLVMAtomicOrdering Ordering)3410 void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst,
3411                                    LLVMAtomicOrdering Ordering) {
3412   Value *P = unwrap<Value>(CmpXchgInst);
3413   AtomicOrdering O = mapFromLLVMOrdering(Ordering);
3414 
3415   return cast<AtomicCmpXchgInst>(P)->setSuccessOrdering(O);
3416 }
3417 
LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst)3418 LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst)  {
3419   Value *P = unwrap<Value>(CmpXchgInst);
3420   return mapToLLVMOrdering(cast<AtomicCmpXchgInst>(P)->getFailureOrdering());
3421 }
3422 
LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst,LLVMAtomicOrdering Ordering)3423 void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst,
3424                                    LLVMAtomicOrdering Ordering) {
3425   Value *P = unwrap<Value>(CmpXchgInst);
3426   AtomicOrdering O = mapFromLLVMOrdering(Ordering);
3427 
3428   return cast<AtomicCmpXchgInst>(P)->setFailureOrdering(O);
3429 }
3430 
3431 /*===-- Module providers --------------------------------------------------===*/
3432 
3433 LLVMModuleProviderRef
LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M)3434 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M) {
3435   return reinterpret_cast<LLVMModuleProviderRef>(M);
3436 }
3437 
LLVMDisposeModuleProvider(LLVMModuleProviderRef MP)3438 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP) {
3439   delete unwrap(MP);
3440 }
3441 
3442 
3443 /*===-- Memory buffers ----------------------------------------------------===*/
3444 
LLVMCreateMemoryBufferWithContentsOfFile(const char * Path,LLVMMemoryBufferRef * OutMemBuf,char ** OutMessage)3445 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(
3446     const char *Path,
3447     LLVMMemoryBufferRef *OutMemBuf,
3448     char **OutMessage) {
3449 
3450   ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(Path);
3451   if (std::error_code EC = MBOrErr.getError()) {
3452     *OutMessage = strdup(EC.message().c_str());
3453     return 1;
3454   }
3455   *OutMemBuf = wrap(MBOrErr.get().release());
3456   return 0;
3457 }
3458 
LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef * OutMemBuf,char ** OutMessage)3459 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
3460                                          char **OutMessage) {
3461   ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getSTDIN();
3462   if (std::error_code EC = MBOrErr.getError()) {
3463     *OutMessage = strdup(EC.message().c_str());
3464     return 1;
3465   }
3466   *OutMemBuf = wrap(MBOrErr.get().release());
3467   return 0;
3468 }
3469 
LLVMCreateMemoryBufferWithMemoryRange(const char * InputData,size_t InputDataLength,const char * BufferName,LLVMBool RequiresNullTerminator)3470 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(
3471     const char *InputData,
3472     size_t InputDataLength,
3473     const char *BufferName,
3474     LLVMBool RequiresNullTerminator) {
3475 
3476   return wrap(MemoryBuffer::getMemBuffer(StringRef(InputData, InputDataLength),
3477                                          StringRef(BufferName),
3478                                          RequiresNullTerminator).release());
3479 }
3480 
LLVMCreateMemoryBufferWithMemoryRangeCopy(const char * InputData,size_t InputDataLength,const char * BufferName)3481 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(
3482     const char *InputData,
3483     size_t InputDataLength,
3484     const char *BufferName) {
3485 
3486   return wrap(
3487       MemoryBuffer::getMemBufferCopy(StringRef(InputData, InputDataLength),
3488                                      StringRef(BufferName)).release());
3489 }
3490 
LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf)3491 const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf) {
3492   return unwrap(MemBuf)->getBufferStart();
3493 }
3494 
LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf)3495 size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf) {
3496   return unwrap(MemBuf)->getBufferSize();
3497 }
3498 
LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf)3499 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf) {
3500   delete unwrap(MemBuf);
3501 }
3502 
3503 /*===-- Pass Registry -----------------------------------------------------===*/
3504 
LLVMGetGlobalPassRegistry(void)3505 LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void) {
3506   return wrap(PassRegistry::getPassRegistry());
3507 }
3508 
3509 /*===-- Pass Manager ------------------------------------------------------===*/
3510 
LLVMCreatePassManager()3511 LLVMPassManagerRef LLVMCreatePassManager() {
3512   return wrap(new legacy::PassManager());
3513 }
3514 
LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M)3515 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M) {
3516   return wrap(new legacy::FunctionPassManager(unwrap(M)));
3517 }
3518 
LLVMCreateFunctionPassManager(LLVMModuleProviderRef P)3519 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef P) {
3520   return LLVMCreateFunctionPassManagerForModule(
3521                                             reinterpret_cast<LLVMModuleRef>(P));
3522 }
3523 
LLVMRunPassManager(LLVMPassManagerRef PM,LLVMModuleRef M)3524 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M) {
3525   return unwrap<legacy::PassManager>(PM)->run(*unwrap(M));
3526 }
3527 
LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM)3528 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM) {
3529   return unwrap<legacy::FunctionPassManager>(FPM)->doInitialization();
3530 }
3531 
LLVMRunFunctionPassManager(LLVMPassManagerRef FPM,LLVMValueRef F)3532 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F) {
3533   return unwrap<legacy::FunctionPassManager>(FPM)->run(*unwrap<Function>(F));
3534 }
3535 
LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM)3536 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM) {
3537   return unwrap<legacy::FunctionPassManager>(FPM)->doFinalization();
3538 }
3539 
LLVMDisposePassManager(LLVMPassManagerRef PM)3540 void LLVMDisposePassManager(LLVMPassManagerRef PM) {
3541   delete unwrap(PM);
3542 }
3543 
3544 /*===-- Threading ------------------------------------------------------===*/
3545 
LLVMStartMultithreaded()3546 LLVMBool LLVMStartMultithreaded() {
3547   return LLVMIsMultithreaded();
3548 }
3549 
LLVMStopMultithreaded()3550 void LLVMStopMultithreaded() {
3551 }
3552 
LLVMIsMultithreaded()3553 LLVMBool LLVMIsMultithreaded() {
3554   return llvm_is_multithreaded();
3555 }
3556