LCOV - code coverage report
Current view: top level - lib/IR - Core.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 723 1642 44.0 %
Date: 2017-09-14 15:23:50 Functions: 248 584 42.5 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13