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

Generated by: LCOV version 1.13