| //===-- Core.cpp ----------------------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file implements the common infrastructure (including the C bindings) |
| // for libLLVMCore.a, which implements the LLVM intermediate representation. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "llvm-c/Core.h" |
| #include "llvm/IR/Attributes.h" |
| #include "llvm/IR/Constants.h" |
| #include "llvm/IR/DebugInfoMetadata.h" |
| #include "llvm/IR/DerivedTypes.h" |
| #include "llvm/IR/DiagnosticInfo.h" |
| #include "llvm/IR/DiagnosticPrinter.h" |
| #include "llvm/IR/GlobalAlias.h" |
| #include "llvm/IR/GlobalVariable.h" |
| #include "llvm/IR/IRBuilder.h" |
| #include "llvm/IR/InlineAsm.h" |
| #include "llvm/IR/IntrinsicInst.h" |
| #include "llvm/IR/LLVMContext.h" |
| #include "llvm/IR/LegacyPassManager.h" |
| #include "llvm/IR/Module.h" |
| #include "llvm/InitializePasses.h" |
| #include "llvm/Support/Debug.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include "llvm/Support/FileSystem.h" |
| #include "llvm/Support/ManagedStatic.h" |
| #include "llvm/Support/MemoryBuffer.h" |
| #include "llvm/Support/Threading.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include <cassert> |
| #include <cstdlib> |
| #include <cstring> |
| #include <system_error> |
| |
| using namespace llvm; |
| |
| #define DEBUG_TYPE "ir" |
| |
| void llvm::initializeCore(PassRegistry &Registry) { |
| initializeDominatorTreeWrapperPassPass(Registry); |
| initializePrintModulePassWrapperPass(Registry); |
| initializePrintFunctionPassWrapperPass(Registry); |
| initializeSafepointIRVerifierPass(Registry); |
| initializeVerifierLegacyPassPass(Registry); |
| } |
| |
| void LLVMInitializeCore(LLVMPassRegistryRef R) { |
| initializeCore(*unwrap(R)); |
| } |
| |
| void LLVMShutdown() { |
| llvm_shutdown(); |
| } |
| |
| /*===-- Error handling ----------------------------------------------------===*/ |
| |
| char *LLVMCreateMessage(const char *Message) { |
| return strdup(Message); |
| } |
| |
| void LLVMDisposeMessage(char *Message) { |
| free(Message); |
| } |
| |
| |
| /*===-- Operations on contexts --------------------------------------------===*/ |
| |
| static ManagedStatic<LLVMContext> GlobalContext; |
| |
| LLVMContextRef LLVMContextCreate() { |
| return wrap(new LLVMContext()); |
| } |
| |
| LLVMContextRef LLVMGetGlobalContext() { return wrap(&*GlobalContext); } |
| |
| void LLVMContextSetDiagnosticHandler(LLVMContextRef C, |
| LLVMDiagnosticHandler Handler, |
| void *DiagnosticContext) { |
| unwrap(C)->setDiagnosticHandlerCallBack( |
| LLVM_EXTENSION reinterpret_cast<DiagnosticHandler::DiagnosticHandlerTy>( |
| Handler), |
| DiagnosticContext); |
| } |
| |
| LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C) { |
| return LLVM_EXTENSION reinterpret_cast<LLVMDiagnosticHandler>( |
| unwrap(C)->getDiagnosticHandlerCallBack()); |
| } |
| |
| void *LLVMContextGetDiagnosticContext(LLVMContextRef C) { |
| return unwrap(C)->getDiagnosticContext(); |
| } |
| |
| void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback, |
| void *OpaqueHandle) { |
| auto YieldCallback = |
| LLVM_EXTENSION reinterpret_cast<LLVMContext::YieldCallbackTy>(Callback); |
| unwrap(C)->setYieldCallback(YieldCallback, OpaqueHandle); |
| } |
| |
| LLVMBool LLVMContextShouldDiscardValueNames(LLVMContextRef C) { |
| return unwrap(C)->shouldDiscardValueNames(); |
| } |
| |
| void LLVMContextSetDiscardValueNames(LLVMContextRef C, LLVMBool Discard) { |
| unwrap(C)->setDiscardValueNames(Discard); |
| } |
| |
| void LLVMContextDispose(LLVMContextRef C) { |
| delete unwrap(C); |
| } |
| |
| unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char *Name, |
| unsigned SLen) { |
| return unwrap(C)->getMDKindID(StringRef(Name, SLen)); |
| } |
| |
| unsigned LLVMGetMDKindID(const char *Name, unsigned SLen) { |
| return LLVMGetMDKindIDInContext(LLVMGetGlobalContext(), Name, SLen); |
| } |
| |
| unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen) { |
| return Attribute::getAttrKindFromName(StringRef(Name, SLen)); |
| } |
| |
| unsigned LLVMGetLastEnumAttributeKind(void) { |
| return Attribute::AttrKind::EndAttrKinds; |
| } |
| |
| LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID, |
| uint64_t Val) { |
| auto &Ctx = *unwrap(C); |
| auto AttrKind = (Attribute::AttrKind)KindID; |
| |
| if (AttrKind == Attribute::AttrKind::ByVal) { |
| // After r362128, byval attributes need to have a type attribute. Provide a |
| // NULL one until a proper API is added for this. |
| return wrap(Attribute::getWithByValType(Ctx, NULL)); |
| } |
| |
| if (AttrKind == Attribute::AttrKind::StructRet) { |
| // Same as byval. |
| return wrap(Attribute::getWithStructRetType(Ctx, NULL)); |
| } |
| |
| return wrap(Attribute::get(Ctx, AttrKind, Val)); |
| } |
| |
| unsigned LLVMGetEnumAttributeKind(LLVMAttributeRef A) { |
| return unwrap(A).getKindAsEnum(); |
| } |
| |
| uint64_t LLVMGetEnumAttributeValue(LLVMAttributeRef A) { |
| auto Attr = unwrap(A); |
| if (Attr.isEnumAttribute()) |
| return 0; |
| return Attr.getValueAsInt(); |
| } |
| |
| LLVMAttributeRef LLVMCreateTypeAttribute(LLVMContextRef C, unsigned KindID, |
| LLVMTypeRef type_ref) { |
| auto &Ctx = *unwrap(C); |
| auto AttrKind = (Attribute::AttrKind)KindID; |
| return wrap(Attribute::get(Ctx, AttrKind, unwrap(type_ref))); |
| } |
| |
| LLVMTypeRef LLVMGetTypeAttributeValue(LLVMAttributeRef A) { |
| auto Attr = unwrap(A); |
| return wrap(Attr.getValueAsType()); |
| } |
| |
| LLVMAttributeRef LLVMCreateStringAttribute(LLVMContextRef C, |
| const char *K, unsigned KLength, |
| const char *V, unsigned VLength) { |
| return wrap(Attribute::get(*unwrap(C), StringRef(K, KLength), |
| StringRef(V, VLength))); |
| } |
| |
| const char *LLVMGetStringAttributeKind(LLVMAttributeRef A, |
| unsigned *Length) { |
| auto S = unwrap(A).getKindAsString(); |
| *Length = S.size(); |
| return S.data(); |
| } |
| |
| const char *LLVMGetStringAttributeValue(LLVMAttributeRef A, |
| unsigned *Length) { |
| auto S = unwrap(A).getValueAsString(); |
| *Length = S.size(); |
| return S.data(); |
| } |
| |
| LLVMBool LLVMIsEnumAttribute(LLVMAttributeRef A) { |
| auto Attr = unwrap(A); |
| return Attr.isEnumAttribute() || Attr.isIntAttribute(); |
| } |
| |
| LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A) { |
| return unwrap(A).isStringAttribute(); |
| } |
| |
| LLVMBool LLVMIsTypeAttribute(LLVMAttributeRef A) { |
| return unwrap(A).isTypeAttribute(); |
| } |
| |
| char *LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI) { |
| std::string MsgStorage; |
| raw_string_ostream Stream(MsgStorage); |
| DiagnosticPrinterRawOStream DP(Stream); |
| |
| unwrap(DI)->print(DP); |
| Stream.flush(); |
| |
| return LLVMCreateMessage(MsgStorage.c_str()); |
| } |
| |
| LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI) { |
| LLVMDiagnosticSeverity severity; |
| |
| switch(unwrap(DI)->getSeverity()) { |
| default: |
| severity = LLVMDSError; |
| break; |
| case DS_Warning: |
| severity = LLVMDSWarning; |
| break; |
| case DS_Remark: |
| severity = LLVMDSRemark; |
| break; |
| case DS_Note: |
| severity = LLVMDSNote; |
| break; |
| } |
| |
| return severity; |
| } |
| |
| /*===-- Operations on modules ---------------------------------------------===*/ |
| |
| LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID) { |
| return wrap(new Module(ModuleID, *GlobalContext)); |
| } |
| |
| LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID, |
| LLVMContextRef C) { |
| return wrap(new Module(ModuleID, *unwrap(C))); |
| } |
| |
| void LLVMDisposeModule(LLVMModuleRef M) { |
| delete unwrap(M); |
| } |
| |
| const char *LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len) { |
| auto &Str = unwrap(M)->getModuleIdentifier(); |
| *Len = Str.length(); |
| return Str.c_str(); |
| } |
| |
| void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len) { |
| unwrap(M)->setModuleIdentifier(StringRef(Ident, Len)); |
| } |
| |
| const char *LLVMGetSourceFileName(LLVMModuleRef M, size_t *Len) { |
| auto &Str = unwrap(M)->getSourceFileName(); |
| *Len = Str.length(); |
| return Str.c_str(); |
| } |
| |
| void LLVMSetSourceFileName(LLVMModuleRef M, const char *Name, size_t Len) { |
| unwrap(M)->setSourceFileName(StringRef(Name, Len)); |
| } |
| |
| /*--.. Data layout .........................................................--*/ |
| const char *LLVMGetDataLayoutStr(LLVMModuleRef M) { |
| return unwrap(M)->getDataLayoutStr().c_str(); |
| } |
| |
| const char *LLVMGetDataLayout(LLVMModuleRef M) { |
| return LLVMGetDataLayoutStr(M); |
| } |
| |
| void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr) { |
| unwrap(M)->setDataLayout(DataLayoutStr); |
| } |
| |
| /*--.. Target triple .......................................................--*/ |
| const char * LLVMGetTarget(LLVMModuleRef M) { |
| return unwrap(M)->getTargetTriple().c_str(); |
| } |
| |
| void LLVMSetTarget(LLVMModuleRef M, const char *Triple) { |
| unwrap(M)->setTargetTriple(Triple); |
| } |
| |
| /*--.. Module flags ........................................................--*/ |
| struct LLVMOpaqueModuleFlagEntry { |
| LLVMModuleFlagBehavior Behavior; |
| const char *Key; |
| size_t KeyLen; |
| LLVMMetadataRef Metadata; |
| }; |
| |
| static Module::ModFlagBehavior |
| map_to_llvmModFlagBehavior(LLVMModuleFlagBehavior Behavior) { |
| switch (Behavior) { |
| case LLVMModuleFlagBehaviorError: |
| return Module::ModFlagBehavior::Error; |
| case LLVMModuleFlagBehaviorWarning: |
| return Module::ModFlagBehavior::Warning; |
| case LLVMModuleFlagBehaviorRequire: |
| return Module::ModFlagBehavior::Require; |
| case LLVMModuleFlagBehaviorOverride: |
| return Module::ModFlagBehavior::Override; |
| case LLVMModuleFlagBehaviorAppend: |
| return Module::ModFlagBehavior::Append; |
| case LLVMModuleFlagBehaviorAppendUnique: |
| return Module::ModFlagBehavior::AppendUnique; |
| } |
| llvm_unreachable("Unknown LLVMModuleFlagBehavior"); |
| } |
| |
| static LLVMModuleFlagBehavior |
| map_from_llvmModFlagBehavior(Module::ModFlagBehavior Behavior) { |
| switch (Behavior) { |
| case Module::ModFlagBehavior::Error: |
| return LLVMModuleFlagBehaviorError; |
| case Module::ModFlagBehavior::Warning: |
| return LLVMModuleFlagBehaviorWarning; |
| case Module::ModFlagBehavior::Require: |
| return LLVMModuleFlagBehaviorRequire; |
| case Module::ModFlagBehavior::Override: |
| return LLVMModuleFlagBehaviorOverride; |
| case Module::ModFlagBehavior::Append: |
| return LLVMModuleFlagBehaviorAppend; |
| case Module::ModFlagBehavior::AppendUnique: |
| return LLVMModuleFlagBehaviorAppendUnique; |
| default: |
| llvm_unreachable("Unhandled Flag Behavior"); |
| } |
| } |
| |
| LLVMModuleFlagEntry *LLVMCopyModuleFlagsMetadata(LLVMModuleRef M, size_t *Len) { |
| SmallVector<Module::ModuleFlagEntry, 8> MFEs; |
| unwrap(M)->getModuleFlagsMetadata(MFEs); |
| |
| LLVMOpaqueModuleFlagEntry *Result = static_cast<LLVMOpaqueModuleFlagEntry *>( |
| safe_malloc(MFEs.size() * sizeof(LLVMOpaqueModuleFlagEntry))); |
| for (unsigned i = 0; i < MFEs.size(); ++i) { |
| const auto &ModuleFlag = MFEs[i]; |
| Result[i].Behavior = map_from_llvmModFlagBehavior(ModuleFlag.Behavior); |
| Result[i].Key = ModuleFlag.Key->getString().data(); |
| Result[i].KeyLen = ModuleFlag.Key->getString().size(); |
| Result[i].Metadata = wrap(ModuleFlag.Val); |
| } |
| *Len = MFEs.size(); |
| return Result; |
| } |
| |
| void LLVMDisposeModuleFlagsMetadata(LLVMModuleFlagEntry *Entries) { |
| free(Entries); |
| } |
| |
| LLVMModuleFlagBehavior |
| LLVMModuleFlagEntriesGetFlagBehavior(LLVMModuleFlagEntry *Entries, |
| unsigned Index) { |
| LLVMOpaqueModuleFlagEntry MFE = |
| static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]); |
| return MFE.Behavior; |
| } |
| |
| const char *LLVMModuleFlagEntriesGetKey(LLVMModuleFlagEntry *Entries, |
| unsigned Index, size_t *Len) { |
| LLVMOpaqueModuleFlagEntry MFE = |
| static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]); |
| *Len = MFE.KeyLen; |
| return MFE.Key; |
| } |
| |
| LLVMMetadataRef LLVMModuleFlagEntriesGetMetadata(LLVMModuleFlagEntry *Entries, |
| unsigned Index) { |
| LLVMOpaqueModuleFlagEntry MFE = |
| static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]); |
| return MFE.Metadata; |
| } |
| |
| LLVMMetadataRef LLVMGetModuleFlag(LLVMModuleRef M, |
| const char *Key, size_t KeyLen) { |
| return wrap(unwrap(M)->getModuleFlag({Key, KeyLen})); |
| } |
| |
| void LLVMAddModuleFlag(LLVMModuleRef M, LLVMModuleFlagBehavior Behavior, |
| const char *Key, size_t KeyLen, |
| LLVMMetadataRef Val) { |
| unwrap(M)->addModuleFlag(map_to_llvmModFlagBehavior(Behavior), |
| {Key, KeyLen}, unwrap(Val)); |
| } |
| |
| /*--.. Printing modules ....................................................--*/ |
| |
| void LLVMDumpModule(LLVMModuleRef M) { |
| unwrap(M)->print(errs(), nullptr, |
| /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true); |
| } |
| |
| LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename, |
| char **ErrorMessage) { |
| std::error_code EC; |
| raw_fd_ostream dest(Filename, EC, sys::fs::OF_TextWithCRLF); |
| if (EC) { |
| *ErrorMessage = strdup(EC.message().c_str()); |
| return true; |
| } |
| |
| unwrap(M)->print(dest, nullptr); |
| |
| dest.close(); |
| |
| if (dest.has_error()) { |
| std::string E = "Error printing to file: " + dest.error().message(); |
| *ErrorMessage = strdup(E.c_str()); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| char *LLVMPrintModuleToString(LLVMModuleRef M) { |
| std::string buf; |
| raw_string_ostream os(buf); |
| |
| unwrap(M)->print(os, nullptr); |
| os.flush(); |
| |
| return strdup(buf.c_str()); |
| } |
| |
| /*--.. Operations on inline assembler ......................................--*/ |
| void LLVMSetModuleInlineAsm2(LLVMModuleRef M, const char *Asm, size_t Len) { |
| unwrap(M)->setModuleInlineAsm(StringRef(Asm, Len)); |
| } |
| |
| void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm) { |
| unwrap(M)->setModuleInlineAsm(StringRef(Asm)); |
| } |
| |
| void LLVMAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm, size_t Len) { |
| unwrap(M)->appendModuleInlineAsm(StringRef(Asm, Len)); |
| } |
| |
| const char *LLVMGetModuleInlineAsm(LLVMModuleRef M, size_t *Len) { |
| auto &Str = unwrap(M)->getModuleInlineAsm(); |
| *Len = Str.length(); |
| return Str.c_str(); |
| } |
| |
| LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty, char *AsmString, |
| size_t AsmStringSize, char *Constraints, |
| size_t ConstraintsSize, LLVMBool HasSideEffects, |
| LLVMBool IsAlignStack, |
| LLVMInlineAsmDialect Dialect, LLVMBool CanThrow) { |
| InlineAsm::AsmDialect AD; |
| switch (Dialect) { |
| case LLVMInlineAsmDialectATT: |
| AD = InlineAsm::AD_ATT; |
| break; |
| case LLVMInlineAsmDialectIntel: |
| AD = InlineAsm::AD_Intel; |
| break; |
| } |
| return wrap(InlineAsm::get(unwrap<FunctionType>(Ty), |
| StringRef(AsmString, AsmStringSize), |
| StringRef(Constraints, ConstraintsSize), |
| HasSideEffects, IsAlignStack, AD, CanThrow)); |
| } |
| |
| /*--.. Operations on module contexts ......................................--*/ |
| LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M) { |
| return wrap(&unwrap(M)->getContext()); |
| } |
| |
| |
| /*===-- Operations on types -----------------------------------------------===*/ |
| |
| /*--.. Operations on all types (mostly) ....................................--*/ |
| |
| LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) { |
| switch (unwrap(Ty)->getTypeID()) { |
| case Type::VoidTyID: |
| return LLVMVoidTypeKind; |
| case Type::HalfTyID: |
| return LLVMHalfTypeKind; |
| case Type::BFloatTyID: |
| return LLVMBFloatTypeKind; |
| case Type::FloatTyID: |
| return LLVMFloatTypeKind; |
| case Type::DoubleTyID: |
| return LLVMDoubleTypeKind; |
| case Type::X86_FP80TyID: |
| return LLVMX86_FP80TypeKind; |
| case Type::FP128TyID: |
| return LLVMFP128TypeKind; |
| case Type::PPC_FP128TyID: |
| return LLVMPPC_FP128TypeKind; |
| case Type::LabelTyID: |
| return LLVMLabelTypeKind; |
| case Type::MetadataTyID: |
| return LLVMMetadataTypeKind; |
| case Type::IntegerTyID: |
| return LLVMIntegerTypeKind; |
| case Type::FunctionTyID: |
| return LLVMFunctionTypeKind; |
| case Type::StructTyID: |
| return LLVMStructTypeKind; |
| case Type::ArrayTyID: |
| return LLVMArrayTypeKind; |
| case Type::PointerTyID: |
| return LLVMPointerTypeKind; |
| case Type::FixedVectorTyID: |
| return LLVMVectorTypeKind; |
| case Type::X86_MMXTyID: |
| return LLVMX86_MMXTypeKind; |
| case Type::X86_AMXTyID: |
| return LLVMX86_AMXTypeKind; |
| case Type::TokenTyID: |
| return LLVMTokenTypeKind; |
| case Type::ScalableVectorTyID: |
| return LLVMScalableVectorTypeKind; |
| } |
| llvm_unreachable("Unhandled TypeID."); |
| } |
| |
| LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty) |
| { |
| return unwrap(Ty)->isSized(); |
| } |
| |
| LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty) { |
| return wrap(&unwrap(Ty)->getContext()); |
| } |
| |
| void LLVMDumpType(LLVMTypeRef Ty) { |
| return unwrap(Ty)->print(errs(), /*IsForDebug=*/true); |
| } |
| |
| char *LLVMPrintTypeToString(LLVMTypeRef Ty) { |
| std::string buf; |
| raw_string_ostream os(buf); |
| |
| if (unwrap(Ty)) |
| unwrap(Ty)->print(os); |
| else |
| os << "Printing <null> Type"; |
| |
| os.flush(); |
| |
| return strdup(buf.c_str()); |
| } |
| |
| /*--.. Operations on integer types .........................................--*/ |
| |
| LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getInt1Ty(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getInt8Ty(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getInt16Ty(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getInt32Ty(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getInt64Ty(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMInt128TypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getInt128Ty(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits) { |
| return wrap(IntegerType::get(*unwrap(C), NumBits)); |
| } |
| |
| LLVMTypeRef LLVMInt1Type(void) { |
| return LLVMInt1TypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMInt8Type(void) { |
| return LLVMInt8TypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMInt16Type(void) { |
| return LLVMInt16TypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMInt32Type(void) { |
| return LLVMInt32TypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMInt64Type(void) { |
| return LLVMInt64TypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMInt128Type(void) { |
| return LLVMInt128TypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMIntType(unsigned NumBits) { |
| return LLVMIntTypeInContext(LLVMGetGlobalContext(), NumBits); |
| } |
| |
| unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy) { |
| return unwrap<IntegerType>(IntegerTy)->getBitWidth(); |
| } |
| |
| /*--.. Operations on real types ............................................--*/ |
| |
| LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getHalfTy(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMBFloatTypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getBFloatTy(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getFloatTy(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getDoubleTy(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getX86_FP80Ty(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getFP128Ty(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getPPC_FP128Ty(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getX86_MMXTy(*unwrap(C)); |
| } |
| LLVMTypeRef LLVMX86AMXTypeInContext(LLVMContextRef C) { |
| return (LLVMTypeRef) Type::getX86_AMXTy(*unwrap(C)); |
| } |
| |
| LLVMTypeRef LLVMHalfType(void) { |
| return LLVMHalfTypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMBFloatType(void) { |
| return LLVMBFloatTypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMFloatType(void) { |
| return LLVMFloatTypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMDoubleType(void) { |
| return LLVMDoubleTypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMX86FP80Type(void) { |
| return LLVMX86FP80TypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMFP128Type(void) { |
| return LLVMFP128TypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMPPCFP128Type(void) { |
| return LLVMPPCFP128TypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMX86MMXType(void) { |
| return LLVMX86MMXTypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMX86AMXType(void) { |
| return LLVMX86AMXTypeInContext(LLVMGetGlobalContext()); |
| } |
| |
| /*--.. Operations on function types ........................................--*/ |
| |
| LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, |
| LLVMTypeRef *ParamTypes, unsigned ParamCount, |
| LLVMBool IsVarArg) { |
| ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount); |
| return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0)); |
| } |
| |
| LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) { |
| return unwrap<FunctionType>(FunctionTy)->isVarArg(); |
| } |
| |
| LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy) { |
| return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType()); |
| } |
| |
| unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy) { |
| return unwrap<FunctionType>(FunctionTy)->getNumParams(); |
| } |
| |
| void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest) { |
| FunctionType *Ty = unwrap<FunctionType>(FunctionTy); |
| for (Type *T : Ty->params()) |
| *Dest++ = wrap(T); |
| } |
| |
| /*--.. Operations on struct types ..........................................--*/ |
| |
| LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, |
| unsigned ElementCount, LLVMBool Packed) { |
| ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount); |
| return wrap(StructType::get(*unwrap(C), Tys, Packed != 0)); |
| } |
| |
| LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, |
| unsigned ElementCount, LLVMBool Packed) { |
| return LLVMStructTypeInContext(LLVMGetGlobalContext(), ElementTypes, |
| ElementCount, Packed); |
| } |
| |
| LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name) |
| { |
| return wrap(StructType::create(*unwrap(C), Name)); |
| } |
| |
| const char *LLVMGetStructName(LLVMTypeRef Ty) |
| { |
| StructType *Type = unwrap<StructType>(Ty); |
| if (!Type->hasName()) |
| return nullptr; |
| return Type->getName().data(); |
| } |
| |
| void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes, |
| unsigned ElementCount, LLVMBool Packed) { |
| ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount); |
| unwrap<StructType>(StructTy)->setBody(Tys, Packed != 0); |
| } |
| |
| unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy) { |
| return unwrap<StructType>(StructTy)->getNumElements(); |
| } |
| |
| void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest) { |
| StructType *Ty = unwrap<StructType>(StructTy); |
| for (Type *T : Ty->elements()) |
| *Dest++ = wrap(T); |
| } |
| |
| LLVMTypeRef LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy, unsigned i) { |
| StructType *Ty = unwrap<StructType>(StructTy); |
| return wrap(Ty->getTypeAtIndex(i)); |
| } |
| |
| LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy) { |
| return unwrap<StructType>(StructTy)->isPacked(); |
| } |
| |
| LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy) { |
| return unwrap<StructType>(StructTy)->isOpaque(); |
| } |
| |
| LLVMBool LLVMIsLiteralStruct(LLVMTypeRef StructTy) { |
| return unwrap<StructType>(StructTy)->isLiteral(); |
| } |
| |
| LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name) { |
| return wrap(StructType::getTypeByName(unwrap(M)->getContext(), Name)); |
| } |
| |
| LLVMTypeRef LLVMGetTypeByName2(LLVMContextRef C, const char *Name) { |
| return wrap(StructType::getTypeByName(*unwrap(C), Name)); |
| } |
| |
| /*--.. Operations on array, pointer, and vector types (sequence types) .....--*/ |
| |
| void LLVMGetSubtypes(LLVMTypeRef Tp, LLVMTypeRef *Arr) { |
| int i = 0; |
| for (auto *T : unwrap(Tp)->subtypes()) { |
| Arr[i] = wrap(T); |
| i++; |
| } |
| } |
| |
| LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount) { |
| return wrap(ArrayType::get(unwrap(ElementType), ElementCount)); |
| } |
| |
| LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace) { |
| return wrap(PointerType::get(unwrap(ElementType), AddressSpace)); |
| } |
| |
| LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) { |
| return wrap(FixedVectorType::get(unwrap(ElementType), ElementCount)); |
| } |
| |
| LLVMTypeRef LLVMScalableVectorType(LLVMTypeRef ElementType, |
| unsigned ElementCount) { |
| return wrap(ScalableVectorType::get(unwrap(ElementType), ElementCount)); |
| } |
| |
| LLVMTypeRef LLVMGetElementType(LLVMTypeRef WrappedTy) { |
| auto *Ty = unwrap<Type>(WrappedTy); |
| if (auto *PTy = dyn_cast<PointerType>(Ty)) |
| return wrap(PTy->getElementType()); |
| if (auto *ATy = dyn_cast<ArrayType>(Ty)) |
| return wrap(ATy->getElementType()); |
| return wrap(cast<VectorType>(Ty)->getElementType()); |
| } |
| |
| unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp) { |
| return unwrap(Tp)->getNumContainedTypes(); |
| } |
| |
| unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) { |
| return unwrap<ArrayType>(ArrayTy)->getNumElements(); |
| } |
| |
| unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy) { |
| return unwrap<PointerType>(PointerTy)->getAddressSpace(); |
| } |
| |
| unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) { |
| return unwrap<VectorType>(VectorTy)->getElementCount().getKnownMinValue(); |
| } |
| |
| /*--.. Operations on other types ...........................................--*/ |
| |
| LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C) { |
| return wrap(Type::getVoidTy(*unwrap(C))); |
| } |
| LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C) { |
| return wrap(Type::getLabelTy(*unwrap(C))); |
| } |
| LLVMTypeRef LLVMTokenTypeInContext(LLVMContextRef C) { |
| return wrap(Type::getTokenTy(*unwrap(C))); |
| } |
| LLVMTypeRef LLVMMetadataTypeInContext(LLVMContextRef C) { |
| return wrap(Type::getMetadataTy(*unwrap(C))); |
| } |
| |
| LLVMTypeRef LLVMVoidType(void) { |
| return LLVMVoidTypeInContext(LLVMGetGlobalContext()); |
| } |
| LLVMTypeRef LLVMLabelType(void) { |
| return LLVMLabelTypeInContext(LLVMGetGlobalContext()); |
| } |
| |
| /*===-- Operations on values ----------------------------------------------===*/ |
| |
| /*--.. Operations on all values ............................................--*/ |
| |
| LLVMTypeRef LLVMTypeOf(LLVMValueRef Val) { |
| return wrap(unwrap(Val)->getType()); |
| } |
| |
| LLVMValueKind LLVMGetValueKind(LLVMValueRef Val) { |
| switch(unwrap(Val)->getValueID()) { |
| #define LLVM_C_API 1 |
| #define HANDLE_VALUE(Name) \ |
| case Value::Name##Val: \ |
| return LLVM##Name##ValueKind; |
| #include "llvm/IR/Value.def" |
| default: |
| return LLVMInstructionValueKind; |
| } |
| } |
| |
| const char *LLVMGetValueName2(LLVMValueRef Val, size_t *Length) { |
| auto *V = unwrap(Val); |
| *Length = V->getName().size(); |
| return V->getName().data(); |
| } |
| |
| void LLVMSetValueName2(LLVMValueRef Val, const char *Name, size_t NameLen) { |
| unwrap(Val)->setName(StringRef(Name, NameLen)); |
| } |
| |
| const char *LLVMGetValueName(LLVMValueRef Val) { |
| return unwrap(Val)->getName().data(); |
| } |
| |
| void LLVMSetValueName(LLVMValueRef Val, const char *Name) { |
| unwrap(Val)->setName(Name); |
| } |
| |
| void LLVMDumpValue(LLVMValueRef Val) { |
| unwrap(Val)->print(errs(), /*IsForDebug=*/true); |
| } |
| |
| char* LLVMPrintValueToString(LLVMValueRef Val) { |
| std::string buf; |
| raw_string_ostream os(buf); |
| |
| if (unwrap(Val)) |
| unwrap(Val)->print(os); |
| else |
| os << "Printing <null> Value"; |
| |
| os.flush(); |
| |
| return strdup(buf.c_str()); |
| } |
| |
| void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal) { |
| unwrap(OldVal)->replaceAllUsesWith(unwrap(NewVal)); |
| } |
| |
| int LLVMHasMetadata(LLVMValueRef Inst) { |
| return unwrap<Instruction>(Inst)->hasMetadata(); |
| } |
| |
| LLVMValueRef LLVMGetMetadata(LLVMValueRef Inst, unsigned KindID) { |
| auto *I = unwrap<Instruction>(Inst); |
| assert(I && "Expected instruction"); |
| if (auto *MD = I->getMetadata(KindID)) |
| return wrap(MetadataAsValue::get(I->getContext(), MD)); |
| return nullptr; |
| } |
| |
| // MetadataAsValue uses a canonical format which strips the actual MDNode for |
| // MDNode with just a single constant value, storing just a ConstantAsMetadata |
| // This undoes this canonicalization, reconstructing the MDNode. |
| static MDNode *extractMDNode(MetadataAsValue *MAV) { |
| Metadata *MD = MAV->getMetadata(); |
| assert((isa<MDNode>(MD) || isa<ConstantAsMetadata>(MD)) && |
| "Expected a metadata node or a canonicalized constant"); |
| |
| if (MDNode *N = dyn_cast<MDNode>(MD)) |
| return N; |
| |
| return MDNode::get(MAV->getContext(), MD); |
| } |
| |
| void LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef Val) { |
| MDNode *N = Val ? extractMDNode(unwrap<MetadataAsValue>(Val)) : nullptr; |
| |
| unwrap<Instruction>(Inst)->setMetadata(KindID, N); |
| } |
| |
| struct LLVMOpaqueValueMetadataEntry { |
| unsigned Kind; |
| LLVMMetadataRef Metadata; |
| }; |
| |
| using MetadataEntries = SmallVectorImpl<std::pair<unsigned, MDNode *>>; |
| static LLVMValueMetadataEntry * |
| llvm_getMetadata(size_t *NumEntries, |
| llvm::function_ref<void(MetadataEntries &)> AccessMD) { |
| SmallVector<std::pair<unsigned, MDNode *>, 8> MVEs; |
| AccessMD(MVEs); |
| |
| LLVMOpaqueValueMetadataEntry *Result = |
| static_cast<LLVMOpaqueValueMetadataEntry *>( |
| safe_malloc(MVEs.size() * sizeof(LLVMOpaqueValueMetadataEntry))); |
| for (unsigned i = 0; i < MVEs.size(); ++i) { |
| const auto &ModuleFlag = MVEs[i]; |
| Result[i].Kind = ModuleFlag.first; |
| Result[i].Metadata = wrap(ModuleFlag.second); |
| } |
| *NumEntries = MVEs.size(); |
| return Result; |
| } |
| |
| LLVMValueMetadataEntry * |
| LLVMInstructionGetAllMetadataOtherThanDebugLoc(LLVMValueRef Value, |
| size_t *NumEntries) { |
| return llvm_getMetadata(NumEntries, [&Value](MetadataEntries &Entries) { |
| Entries.clear(); |
| unwrap<Instruction>(Value)->getAllMetadata(Entries); |
| }); |
| } |
| |
| /*--.. Conversion functions ................................................--*/ |
| |
| #define LLVM_DEFINE_VALUE_CAST(name) \ |
| LLVMValueRef LLVMIsA##name(LLVMValueRef Val) { \ |
| return wrap(static_cast<Value*>(dyn_cast_or_null<name>(unwrap(Val)))); \ |
| } |
| |
| LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DEFINE_VALUE_CAST) |
| |
| LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val) { |
| if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val))) |
| if (isa<MDNode>(MD->getMetadata()) || |
| isa<ValueAsMetadata>(MD->getMetadata())) |
| return Val; |
| return nullptr; |
| } |
| |
| LLVMValueRef LLVMIsAMDString(LLVMValueRef Val) { |
| if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val))) |
| if (isa<MDString>(MD->getMetadata())) |
| return Val; |
| return nullptr; |
| } |
| |
| /*--.. Operations on Uses ..................................................--*/ |
| LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val) { |
| Value *V = unwrap(Val); |
| Value::use_iterator I = V->use_begin(); |
| if (I == V->use_end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMUseRef LLVMGetNextUse(LLVMUseRef U) { |
| Use *Next = unwrap(U)->getNext(); |
| if (Next) |
| return wrap(Next); |
| return nullptr; |
| } |
| |
| LLVMValueRef LLVMGetUser(LLVMUseRef U) { |
| return wrap(unwrap(U)->getUser()); |
| } |
| |
| LLVMValueRef LLVMGetUsedValue(LLVMUseRef U) { |
| return wrap(unwrap(U)->get()); |
| } |
| |
| /*--.. Operations on Users .................................................--*/ |
| |
| static LLVMValueRef getMDNodeOperandImpl(LLVMContext &Context, const MDNode *N, |
| unsigned Index) { |
| Metadata *Op = N->getOperand(Index); |
| if (!Op) |
| return nullptr; |
| if (auto *C = dyn_cast<ConstantAsMetadata>(Op)) |
| return wrap(C->getValue()); |
| return wrap(MetadataAsValue::get(Context, Op)); |
| } |
| |
| LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index) { |
| Value *V = unwrap(Val); |
| if (auto *MD = dyn_cast<MetadataAsValue>(V)) { |
| if (auto *L = dyn_cast<ValueAsMetadata>(MD->getMetadata())) { |
| assert(Index == 0 && "Function-local metadata can only have one operand"); |
| return wrap(L->getValue()); |
| } |
| return getMDNodeOperandImpl(V->getContext(), |
| cast<MDNode>(MD->getMetadata()), Index); |
| } |
| |
| return wrap(cast<User>(V)->getOperand(Index)); |
| } |
| |
| LLVMUseRef LLVMGetOperandUse(LLVMValueRef Val, unsigned Index) { |
| Value *V = unwrap(Val); |
| return wrap(&cast<User>(V)->getOperandUse(Index)); |
| } |
| |
| void LLVMSetOperand(LLVMValueRef Val, unsigned Index, LLVMValueRef Op) { |
| unwrap<User>(Val)->setOperand(Index, unwrap(Op)); |
| } |
| |
| int LLVMGetNumOperands(LLVMValueRef Val) { |
| Value *V = unwrap(Val); |
| if (isa<MetadataAsValue>(V)) |
| return LLVMGetMDNodeNumOperands(Val); |
| |
| return cast<User>(V)->getNumOperands(); |
| } |
| |
| /*--.. Operations on constants of any type .................................--*/ |
| |
| LLVMValueRef LLVMConstNull(LLVMTypeRef Ty) { |
| return wrap(Constant::getNullValue(unwrap(Ty))); |
| } |
| |
| LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty) { |
| return wrap(Constant::getAllOnesValue(unwrap(Ty))); |
| } |
| |
| LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) { |
| return wrap(UndefValue::get(unwrap(Ty))); |
| } |
| |
| LLVMValueRef LLVMGetPoison(LLVMTypeRef Ty) { |
| return wrap(PoisonValue::get(unwrap(Ty))); |
| } |
| |
| LLVMBool LLVMIsConstant(LLVMValueRef Ty) { |
| return isa<Constant>(unwrap(Ty)); |
| } |
| |
| LLVMBool LLVMIsNull(LLVMValueRef Val) { |
| if (Constant *C = dyn_cast<Constant>(unwrap(Val))) |
| return C->isNullValue(); |
| return false; |
| } |
| |
| LLVMBool LLVMIsUndef(LLVMValueRef Val) { |
| return isa<UndefValue>(unwrap(Val)); |
| } |
| |
| LLVMBool LLVMIsPoison(LLVMValueRef Val) { |
| return isa<PoisonValue>(unwrap(Val)); |
| } |
| |
| LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) { |
| return wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty))); |
| } |
| |
| /*--.. Operations on metadata nodes ........................................--*/ |
| |
| LLVMMetadataRef LLVMMDStringInContext2(LLVMContextRef C, const char *Str, |
| size_t SLen) { |
| return wrap(MDString::get(*unwrap(C), StringRef(Str, SLen))); |
| } |
| |
| LLVMMetadataRef LLVMMDNodeInContext2(LLVMContextRef C, LLVMMetadataRef *MDs, |
| size_t Count) { |
| return wrap(MDNode::get(*unwrap(C), ArrayRef<Metadata*>(unwrap(MDs), Count))); |
| } |
| |
| LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str, |
| unsigned SLen) { |
| LLVMContext &Context = *unwrap(C); |
| return wrap(MetadataAsValue::get( |
| Context, MDString::get(Context, StringRef(Str, SLen)))); |
| } |
| |
| LLVMValueRef LLVMMDString(const char *Str, unsigned SLen) { |
| return LLVMMDStringInContext(LLVMGetGlobalContext(), Str, SLen); |
| } |
| |
| LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals, |
| unsigned Count) { |
| LLVMContext &Context = *unwrap(C); |
| SmallVector<Metadata *, 8> MDs; |
| for (auto *OV : makeArrayRef(Vals, Count)) { |
| Value *V = unwrap(OV); |
| Metadata *MD; |
| if (!V) |
| MD = nullptr; |
| else if (auto *C = dyn_cast<Constant>(V)) |
| MD = ConstantAsMetadata::get(C); |
| else if (auto *MDV = dyn_cast<MetadataAsValue>(V)) { |
| MD = MDV->getMetadata(); |
| assert(!isa<LocalAsMetadata>(MD) && "Unexpected function-local metadata " |
| "outside of direct argument to call"); |
| } else { |
| // This is function-local metadata. Pretend to make an MDNode. |
| assert(Count == 1 && |
| "Expected only one operand to function-local metadata"); |
| return wrap(MetadataAsValue::get(Context, LocalAsMetadata::get(V))); |
| } |
| |
| MDs.push_back(MD); |
| } |
| return wrap(MetadataAsValue::get(Context, MDNode::get(Context, MDs))); |
| } |
| |
| LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count) { |
| return LLVMMDNodeInContext(LLVMGetGlobalContext(), Vals, Count); |
| } |
| |
| LLVMValueRef LLVMMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD) { |
| return wrap(MetadataAsValue::get(*unwrap(C), unwrap(MD))); |
| } |
| |
| LLVMMetadataRef LLVMValueAsMetadata(LLVMValueRef Val) { |
| auto *V = unwrap(Val); |
| if (auto *C = dyn_cast<Constant>(V)) |
| return wrap(ConstantAsMetadata::get(C)); |
| if (auto *MAV = dyn_cast<MetadataAsValue>(V)) |
| return wrap(MAV->getMetadata()); |
| return wrap(ValueAsMetadata::get(V)); |
| } |
| |
| const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length) { |
| if (const auto *MD = dyn_cast<MetadataAsValue>(unwrap(V))) |
| if (const MDString *S = dyn_cast<MDString>(MD->getMetadata())) { |
| *Length = S->getString().size(); |
| return S->getString().data(); |
| } |
| *Length = 0; |
| return nullptr; |
| } |
| |
| unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V) { |
| auto *MD = cast<MetadataAsValue>(unwrap(V)); |
| if (isa<ValueAsMetadata>(MD->getMetadata())) |
| return 1; |
| return cast<MDNode>(MD->getMetadata())->getNumOperands(); |
| } |
| |
| LLVMNamedMDNodeRef LLVMGetFirstNamedMetadata(LLVMModuleRef M) { |
| Module *Mod = unwrap(M); |
| Module::named_metadata_iterator I = Mod->named_metadata_begin(); |
| if (I == Mod->named_metadata_end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMNamedMDNodeRef LLVMGetLastNamedMetadata(LLVMModuleRef M) { |
| Module *Mod = unwrap(M); |
| Module::named_metadata_iterator I = Mod->named_metadata_end(); |
| if (I == Mod->named_metadata_begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| LLVMNamedMDNodeRef LLVMGetNextNamedMetadata(LLVMNamedMDNodeRef NMD) { |
| NamedMDNode *NamedNode = unwrap<NamedMDNode>(NMD); |
| Module::named_metadata_iterator I(NamedNode); |
| if (++I == NamedNode->getParent()->named_metadata_end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMNamedMDNodeRef LLVMGetPreviousNamedMetadata(LLVMNamedMDNodeRef NMD) { |
| NamedMDNode *NamedNode = unwrap<NamedMDNode>(NMD); |
| Module::named_metadata_iterator I(NamedNode); |
| if (I == NamedNode->getParent()->named_metadata_begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| LLVMNamedMDNodeRef LLVMGetNamedMetadata(LLVMModuleRef M, |
| const char *Name, size_t NameLen) { |
| return wrap(unwrap(M)->getNamedMetadata(StringRef(Name, NameLen))); |
| } |
| |
| LLVMNamedMDNodeRef LLVMGetOrInsertNamedMetadata(LLVMModuleRef M, |
| const char *Name, size_t NameLen) { |
| return wrap(unwrap(M)->getOrInsertNamedMetadata({Name, NameLen})); |
| } |
| |
| const char *LLVMGetNamedMetadataName(LLVMNamedMDNodeRef NMD, size_t *NameLen) { |
| NamedMDNode *NamedNode = unwrap<NamedMDNode>(NMD); |
| *NameLen = NamedNode->getName().size(); |
| return NamedNode->getName().data(); |
| } |
| |
| void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest) { |
| auto *MD = cast<MetadataAsValue>(unwrap(V)); |
| if (auto *MDV = dyn_cast<ValueAsMetadata>(MD->getMetadata())) { |
| *Dest = wrap(MDV->getValue()); |
| return; |
| } |
| const auto *N = cast<MDNode>(MD->getMetadata()); |
| const unsigned numOperands = N->getNumOperands(); |
| LLVMContext &Context = unwrap(V)->getContext(); |
| for (unsigned i = 0; i < numOperands; i++) |
| Dest[i] = getMDNodeOperandImpl(Context, N, i); |
| } |
| |
| unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char *Name) { |
| if (NamedMDNode *N = unwrap(M)->getNamedMetadata(Name)) { |
| return N->getNumOperands(); |
| } |
| return 0; |
| } |
| |
| void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char *Name, |
| LLVMValueRef *Dest) { |
| NamedMDNode *N = unwrap(M)->getNamedMetadata(Name); |
| if (!N) |
| return; |
| LLVMContext &Context = unwrap(M)->getContext(); |
| for (unsigned i=0;i<N->getNumOperands();i++) |
| Dest[i] = wrap(MetadataAsValue::get(Context, N->getOperand(i))); |
| } |
| |
| void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char *Name, |
| LLVMValueRef Val) { |
| NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(Name); |
| if (!N) |
| return; |
| if (!Val) |
| return; |
| N->addOperand(extractMDNode(unwrap<MetadataAsValue>(Val))); |
| } |
| |
| const char *LLVMGetDebugLocDirectory(LLVMValueRef Val, unsigned *Length) { |
| if (!Length) return nullptr; |
| StringRef S; |
| if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) { |
| if (const auto &DL = I->getDebugLoc()) { |
| S = DL->getDirectory(); |
| } |
| } else if (const auto *GV = dyn_cast<GlobalVariable>(unwrap(Val))) { |
| SmallVector<DIGlobalVariableExpression *, 1> GVEs; |
| GV->getDebugInfo(GVEs); |
| if (GVEs.size()) |
| if (const DIGlobalVariable *DGV = GVEs[0]->getVariable()) |
| S = DGV->getDirectory(); |
| } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) { |
| if (const DISubprogram *DSP = F->getSubprogram()) |
| S = DSP->getDirectory(); |
| } else { |
| assert(0 && "Expected Instruction, GlobalVariable or Function"); |
| return nullptr; |
| } |
| *Length = S.size(); |
| return S.data(); |
| } |
| |
| const char *LLVMGetDebugLocFilename(LLVMValueRef Val, unsigned *Length) { |
| if (!Length) return nullptr; |
| StringRef S; |
| if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) { |
| if (const auto &DL = I->getDebugLoc()) { |
| S = DL->getFilename(); |
| } |
| } else if (const auto *GV = dyn_cast<GlobalVariable>(unwrap(Val))) { |
| SmallVector<DIGlobalVariableExpression *, 1> GVEs; |
| GV->getDebugInfo(GVEs); |
| if (GVEs.size()) |
| if (const DIGlobalVariable *DGV = GVEs[0]->getVariable()) |
| S = DGV->getFilename(); |
| } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) { |
| if (const DISubprogram *DSP = F->getSubprogram()) |
| S = DSP->getFilename(); |
| } else { |
| assert(0 && "Expected Instruction, GlobalVariable or Function"); |
| return nullptr; |
| } |
| *Length = S.size(); |
| return S.data(); |
| } |
| |
| unsigned LLVMGetDebugLocLine(LLVMValueRef Val) { |
| unsigned L = 0; |
| if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) { |
| if (const auto &DL = I->getDebugLoc()) { |
| L = DL->getLine(); |
| } |
| } else if (const auto *GV = dyn_cast<GlobalVariable>(unwrap(Val))) { |
| SmallVector<DIGlobalVariableExpression *, 1> GVEs; |
| GV->getDebugInfo(GVEs); |
| if (GVEs.size()) |
| if (const DIGlobalVariable *DGV = GVEs[0]->getVariable()) |
| L = DGV->getLine(); |
| } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) { |
| if (const DISubprogram *DSP = F->getSubprogram()) |
| L = DSP->getLine(); |
| } else { |
| assert(0 && "Expected Instruction, GlobalVariable or Function"); |
| return -1; |
| } |
| return L; |
| } |
| |
| unsigned LLVMGetDebugLocColumn(LLVMValueRef Val) { |
| unsigned C = 0; |
| if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) |
| if (const auto &DL = I->getDebugLoc()) |
| C = DL->getColumn(); |
| return C; |
| } |
| |
| /*--.. Operations on scalar constants ......................................--*/ |
| |
| LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, |
| LLVMBool SignExtend) { |
| return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0)); |
| } |
| |
| LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy, |
| unsigned NumWords, |
| const uint64_t Words[]) { |
| IntegerType *Ty = unwrap<IntegerType>(IntTy); |
| return wrap(ConstantInt::get(Ty->getContext(), |
| APInt(Ty->getBitWidth(), |
| makeArrayRef(Words, NumWords)))); |
| } |
| |
| LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char Str[], |
| uint8_t Radix) { |
| return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str), |
| Radix)); |
| } |
| |
| LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char Str[], |
| unsigned SLen, uint8_t Radix) { |
| return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str, SLen), |
| Radix)); |
| } |
| |
| LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N) { |
| return wrap(ConstantFP::get(unwrap(RealTy), N)); |
| } |
| |
| LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text) { |
| return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Text))); |
| } |
| |
| LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char Str[], |
| unsigned SLen) { |
| return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Str, SLen))); |
| } |
| |
| unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal) { |
| return unwrap<ConstantInt>(ConstantVal)->getZExtValue(); |
| } |
| |
| long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal) { |
| return unwrap<ConstantInt>(ConstantVal)->getSExtValue(); |
| } |
| |
| double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *LosesInfo) { |
| ConstantFP *cFP = unwrap<ConstantFP>(ConstantVal) ; |
| Type *Ty = cFP->getType(); |
| |
| if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() || |
| Ty->isDoubleTy()) { |
| *LosesInfo = false; |
| return cFP->getValueAPF().convertToDouble(); |
| } |
| |
| bool APFLosesInfo; |
| APFloat APF = cFP->getValueAPF(); |
| APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &APFLosesInfo); |
| *LosesInfo = APFLosesInfo; |
| return APF.convertToDouble(); |
| } |
| |
| /*--.. Operations on composite constants ...................................--*/ |
| |
| LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str, |
| unsigned Length, |
| LLVMBool DontNullTerminate) { |
| /* Inverted the sense of AddNull because ', 0)' is a |
| better mnemonic for null termination than ', 1)'. */ |
| return wrap(ConstantDataArray::getString(*unwrap(C), StringRef(Str, Length), |
| DontNullTerminate == 0)); |
| } |
| |
| LLVMValueRef LLVMConstString(const char *Str, unsigned Length, |
| LLVMBool DontNullTerminate) { |
| return LLVMConstStringInContext(LLVMGetGlobalContext(), Str, Length, |
| DontNullTerminate); |
| } |
| |
| LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef C, unsigned idx) { |
| return wrap(unwrap<ConstantDataSequential>(C)->getElementAsConstant(idx)); |
| } |
| |
| LLVMBool LLVMIsConstantString(LLVMValueRef C) { |
| return unwrap<ConstantDataSequential>(C)->isString(); |
| } |
| |
| const char *LLVMGetAsString(LLVMValueRef C, size_t *Length) { |
| StringRef Str = unwrap<ConstantDataSequential>(C)->getAsString(); |
| *Length = Str.size(); |
| return Str.data(); |
| } |
| |
| LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, |
| LLVMValueRef *ConstantVals, unsigned Length) { |
| ArrayRef<Constant*> V(unwrap<Constant>(ConstantVals, Length), Length); |
| return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V)); |
| } |
| |
| LLVMValueRef LLVMConstStructInContext(LLVMContextRef C, |
| LLVMValueRef *ConstantVals, |
| unsigned Count, LLVMBool Packed) { |
| Constant **Elements = unwrap<Constant>(ConstantVals, Count); |
| return wrap(ConstantStruct::getAnon(*unwrap(C), makeArrayRef(Elements, Count), |
| Packed != 0)); |
| } |
| |
| LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, |
| LLVMBool Packed) { |
| return LLVMConstStructInContext(LLVMGetGlobalContext(), ConstantVals, Count, |
| Packed); |
| } |
| |
| LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy, |
| LLVMValueRef *ConstantVals, |
| unsigned Count) { |
| Constant **Elements = unwrap<Constant>(ConstantVals, Count); |
| StructType *Ty = cast<StructType>(unwrap(StructTy)); |
| |
| return wrap(ConstantStruct::get(Ty, makeArrayRef(Elements, Count))); |
| } |
| |
| LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) { |
| return wrap(ConstantVector::get(makeArrayRef( |
| unwrap<Constant>(ScalarConstantVals, Size), Size))); |
| } |
| |
| /*-- Opcode mapping */ |
| |
| static LLVMOpcode map_to_llvmopcode(int opcode) |
| { |
| switch (opcode) { |
| default: llvm_unreachable("Unhandled Opcode."); |
| #define HANDLE_INST(num, opc, clas) case num: return LLVM##opc; |
| #include "llvm/IR/Instruction.def" |
| #undef HANDLE_INST |
| } |
| } |
| |
| static int map_from_llvmopcode(LLVMOpcode code) |
| { |
| switch (code) { |
| #define HANDLE_INST(num, opc, clas) case LLVM##opc: return num; |
| #include "llvm/IR/Instruction.def" |
| #undef HANDLE_INST |
| } |
| llvm_unreachable("Unhandled Opcode."); |
| } |
| |
| /*--.. Constant expressions ................................................--*/ |
| |
| LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal) { |
| return map_to_llvmopcode(unwrap<ConstantExpr>(ConstantVal)->getOpcode()); |
| } |
| |
| LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty) { |
| return wrap(ConstantExpr::getAlignOf(unwrap(Ty))); |
| } |
| |
| LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty) { |
| return wrap(ConstantExpr::getSizeOf(unwrap(Ty))); |
| } |
| |
| LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal) { |
| return wrap(ConstantExpr::getNeg(unwrap<Constant>(ConstantVal))); |
| } |
| |
| LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal) { |
| return wrap(ConstantExpr::getNSWNeg(unwrap<Constant>(ConstantVal))); |
| } |
| |
| LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal) { |
| return wrap(ConstantExpr::getNUWNeg(unwrap<Constant>(ConstantVal))); |
| } |
| |
| |
| LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal) { |
| return wrap(ConstantExpr::getFNeg(unwrap<Constant>(ConstantVal))); |
| } |
| |
| LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal) { |
| return wrap(ConstantExpr::getNot(unwrap<Constant>(ConstantVal))); |
| } |
| |
| LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getAdd(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, |
| LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getNSWAdd(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, |
| LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getNUWAdd(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getFAdd(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getSub(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, |
| LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getNSWSub(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, |
| LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getNUWSub(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getFSub(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getMul(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, |
| LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getNSWMul(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, |
| LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getNUWMul(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getFMul(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getUDiv(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstExactUDiv(LLVMValueRef LHSConstant, |
| LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getExactUDiv(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getSDiv(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, |
| LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getExactSDiv(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getFDiv(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getURem(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getSRem(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getFRem(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getAnd(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getOr(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getXor(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, |
| LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getICmp(Predicate, |
| unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, |
| LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getFCmp(Predicate, |
| unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getShl(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getLShr(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { |
| return wrap(ConstantExpr::getAShr(unwrap<Constant>(LHSConstant), |
| unwrap<Constant>(RHSConstant))); |
| } |
| |
| LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, |
| LLVMValueRef *ConstantIndices, unsigned NumIndices) { |
| ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices), |
| NumIndices); |
| Constant *Val = unwrap<Constant>(ConstantVal); |
| Type *Ty = |
| cast<PointerType>(Val->getType()->getScalarType())->getElementType(); |
| return wrap(ConstantExpr::getGetElementPtr(Ty, Val, IdxList)); |
| } |
| |
| LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, |
| LLVMValueRef *ConstantIndices, |
| unsigned NumIndices) { |
| ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices), |
| NumIndices); |
| Constant *Val = unwrap<Constant>(ConstantVal); |
| Type *Ty = |
| cast<PointerType>(Val->getType()->getScalarType())->getElementType(); |
| return wrap(ConstantExpr::getInBoundsGetElementPtr(Ty, Val, IdxList)); |
| } |
| |
| LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getTrunc(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getSExt(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getZExt(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getFPTrunc(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getFPExtend(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getUIToFP(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getSIToFP(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getFPToUI(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getFPToSI(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getPtrToInt(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getIntToPtr(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getBitCast(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal, |
| LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getAddrSpaceCast(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, |
| LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getZExtOrBitCast(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, |
| LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getSExtOrBitCast(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, |
| LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getTruncOrBitCast(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, |
| LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getPointerCast(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, |
| LLVMBool isSigned) { |
| return wrap(ConstantExpr::getIntegerCast(unwrap<Constant>(ConstantVal), |
| unwrap(ToType), isSigned)); |
| } |
| |
| LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { |
| return wrap(ConstantExpr::getFPCast(unwrap<Constant>(ConstantVal), |
| unwrap(ToType))); |
| } |
| |
| LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, |
| LLVMValueRef ConstantIfTrue, |
| LLVMValueRef ConstantIfFalse) { |
| return wrap(ConstantExpr::getSelect(unwrap<Constant>(ConstantCondition), |
| unwrap<Constant>(ConstantIfTrue), |
| unwrap<Constant>(ConstantIfFalse))); |
| } |
| |
| LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, |
| LLVMValueRef IndexConstant) { |
| return wrap(ConstantExpr::getExtractElement(unwrap<Constant>(VectorConstant), |
| unwrap<Constant>(IndexConstant))); |
| } |
| |
| LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, |
| LLVMValueRef ElementValueConstant, |
| LLVMValueRef IndexConstant) { |
| return wrap(ConstantExpr::getInsertElement(unwrap<Constant>(VectorConstant), |
| unwrap<Constant>(ElementValueConstant), |
| unwrap<Constant>(IndexConstant))); |
| } |
| |
| LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, |
| LLVMValueRef VectorBConstant, |
| LLVMValueRef MaskConstant) { |
| SmallVector<int, 16> IntMask; |
| ShuffleVectorInst::getShuffleMask(unwrap<Constant>(MaskConstant), IntMask); |
| return wrap(ConstantExpr::getShuffleVector(unwrap<Constant>(VectorAConstant), |
| unwrap<Constant>(VectorBConstant), |
| IntMask)); |
| } |
| |
| LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, |
| unsigned NumIdx) { |
| return wrap(ConstantExpr::getExtractValue(unwrap<Constant>(AggConstant), |
| makeArrayRef(IdxList, NumIdx))); |
| } |
| |
| LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, |
| LLVMValueRef ElementValueConstant, |
| unsigned *IdxList, unsigned NumIdx) { |
| return wrap(ConstantExpr::getInsertValue(unwrap<Constant>(AggConstant), |
| unwrap<Constant>(ElementValueConstant), |
| makeArrayRef(IdxList, NumIdx))); |
| } |
| |
| LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, const char *AsmString, |
| const char *Constraints, |
| LLVMBool HasSideEffects, |
| LLVMBool IsAlignStack) { |
| return wrap(InlineAsm::get(dyn_cast<FunctionType>(unwrap(Ty)), AsmString, |
| Constraints, HasSideEffects, IsAlignStack)); |
| } |
| |
| LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB) { |
| return wrap(BlockAddress::get(unwrap<Function>(F), unwrap(BB))); |
| } |
| |
| /*--.. Operations on global variables, functions, and aliases (globals) ....--*/ |
| |
| LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global) { |
| return wrap(unwrap<GlobalValue>(Global)->getParent()); |
| } |
| |
| LLVMBool LLVMIsDeclaration(LLVMValueRef Global) { |
| return unwrap<GlobalValue>(Global)->isDeclaration(); |
| } |
| |
| LLVMLinkage LLVMGetLinkage(LLVMValueRef Global) { |
| switch (unwrap<GlobalValue>(Global)->getLinkage()) { |
| case GlobalValue::ExternalLinkage: |
| return LLVMExternalLinkage; |
| case GlobalValue::AvailableExternallyLinkage: |
| return LLVMAvailableExternallyLinkage; |
| case GlobalValue::LinkOnceAnyLinkage: |
| return LLVMLinkOnceAnyLinkage; |
| case GlobalValue::LinkOnceODRLinkage: |
| return LLVMLinkOnceODRLinkage; |
| case GlobalValue::WeakAnyLinkage: |
| return LLVMWeakAnyLinkage; |
| case GlobalValue::WeakODRLinkage: |
| return LLVMWeakODRLinkage; |
| case GlobalValue::AppendingLinkage: |
| return LLVMAppendingLinkage; |
| case GlobalValue::InternalLinkage: |
| return LLVMInternalLinkage; |
| case GlobalValue::PrivateLinkage: |
| return LLVMPrivateLinkage; |
| case GlobalValue::ExternalWeakLinkage: |
| return LLVMExternalWeakLinkage; |
| case GlobalValue::CommonLinkage: |
| return LLVMCommonLinkage; |
| } |
| |
| llvm_unreachable("Invalid GlobalValue linkage!"); |
| } |
| |
| void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage) { |
| GlobalValue *GV = unwrap<GlobalValue>(Global); |
| |
| switch (Linkage) { |
| case LLVMExternalLinkage: |
| GV->setLinkage(GlobalValue::ExternalLinkage); |
| break; |
| case LLVMAvailableExternallyLinkage: |
| GV->setLinkage(GlobalValue::AvailableExternallyLinkage); |
| break; |
| case LLVMLinkOnceAnyLinkage: |
| GV->setLinkage(GlobalValue::LinkOnceAnyLinkage); |
| break; |
| case LLVMLinkOnceODRLinkage: |
| GV->setLinkage(GlobalValue::LinkOnceODRLinkage); |
| break; |
| case LLVMLinkOnceODRAutoHideLinkage: |
| LLVM_DEBUG( |
| errs() << "LLVMSetLinkage(): LLVMLinkOnceODRAutoHideLinkage is no " |
| "longer supported."); |
| break; |
| case LLVMWeakAnyLinkage: |
| GV->setLinkage(GlobalValue::WeakAnyLinkage); |
| break; |
| case LLVMWeakODRLinkage: |
| GV->setLinkage(GlobalValue::WeakODRLinkage); |
| break; |
| case LLVMAppendingLinkage: |
| GV->setLinkage(GlobalValue::AppendingLinkage); |
| break; |
| case LLVMInternalLinkage: |
| GV->setLinkage(GlobalValue::InternalLinkage); |
| break; |
| case LLVMPrivateLinkage: |
| GV->setLinkage(GlobalValue::PrivateLinkage); |
| break; |
| case LLVMLinkerPrivateLinkage: |
| GV->setLinkage(GlobalValue::PrivateLinkage); |
| break; |
| case LLVMLinkerPrivateWeakLinkage: |
| GV->setLinkage(GlobalValue::PrivateLinkage); |
| break; |
| case LLVMDLLImportLinkage: |
| LLVM_DEBUG( |
| errs() |
| << "LLVMSetLinkage(): LLVMDLLImportLinkage is no longer supported."); |
| break; |
| case LLVMDLLExportLinkage: |
| LLVM_DEBUG( |
| errs() |
| << "LLVMSetLinkage(): LLVMDLLExportLinkage is no longer supported."); |
| break; |
| case LLVMExternalWeakLinkage: |
| GV->setLinkage(GlobalValue::ExternalWeakLinkage); |
| break; |
| case LLVMGhostLinkage: |
| LLVM_DEBUG( |
| errs() << "LLVMSetLinkage(): LLVMGhostLinkage is no longer supported."); |
| break; |
| case LLVMCommonLinkage: |
| GV->setLinkage(GlobalValue::CommonLinkage); |
| break; |
| } |
| } |
| |
| const char *LLVMGetSection(LLVMValueRef Global) { |
| // Using .data() is safe because of how GlobalObject::setSection is |
| // implemented. |
| return unwrap<GlobalValue>(Global)->getSection().data(); |
| } |
| |
| void LLVMSetSection(LLVMValueRef Global, const char *Section) { |
| unwrap<GlobalObject>(Global)->setSection(Section); |
| } |
| |
| LLVMVisibility LLVMGetVisibility(LLVMValueRef Global) { |
| return static_cast<LLVMVisibility>( |
| unwrap<GlobalValue>(Global)->getVisibility()); |
| } |
| |
| void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz) { |
| unwrap<GlobalValue>(Global) |
| ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz)); |
| } |
| |
| LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global) { |
| return static_cast<LLVMDLLStorageClass>( |
| unwrap<GlobalValue>(Global)->getDLLStorageClass()); |
| } |
| |
| void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class) { |
| unwrap<GlobalValue>(Global)->setDLLStorageClass( |
| static_cast<GlobalValue::DLLStorageClassTypes>(Class)); |
| } |
| |
| LLVMUnnamedAddr LLVMGetUnnamedAddress(LLVMValueRef Global) { |
| switch (unwrap<GlobalValue>(Global)->getUnnamedAddr()) { |
| case GlobalVariable::UnnamedAddr::None: |
| return LLVMNoUnnamedAddr; |
| case GlobalVariable::UnnamedAddr::Local: |
| return LLVMLocalUnnamedAddr; |
| case GlobalVariable::UnnamedAddr::Global: |
| return LLVMGlobalUnnamedAddr; |
| } |
| llvm_unreachable("Unknown UnnamedAddr kind!"); |
| } |
| |
| void LLVMSetUnnamedAddress(LLVMValueRef Global, LLVMUnnamedAddr UnnamedAddr) { |
| GlobalValue *GV = unwrap<GlobalValue>(Global); |
| |
| switch (UnnamedAddr) { |
| case LLVMNoUnnamedAddr: |
| return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::None); |
| case LLVMLocalUnnamedAddr: |
| return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Local); |
| case LLVMGlobalUnnamedAddr: |
| return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Global); |
| } |
| } |
| |
| LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global) { |
| return unwrap<GlobalValue>(Global)->hasGlobalUnnamedAddr(); |
| } |
| |
| void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr) { |
| unwrap<GlobalValue>(Global)->setUnnamedAddr( |
| HasUnnamedAddr ? GlobalValue::UnnamedAddr::Global |
| : GlobalValue::UnnamedAddr::None); |
| } |
| |
| LLVMTypeRef LLVMGlobalGetValueType(LLVMValueRef Global) { |
| return wrap(unwrap<GlobalValue>(Global)->getValueType()); |
| } |
| |
| /*--.. Operations on global variables, load and store instructions .........--*/ |
| |
| unsigned LLVMGetAlignment(LLVMValueRef V) { |
| Value *P = unwrap<Value>(V); |
| if (GlobalObject *GV = dyn_cast<GlobalObject>(P)) |
| return GV->getAlignment(); |
| if (AllocaInst *AI = dyn_cast<AllocaInst>(P)) |
| return AI->getAlignment(); |
| if (LoadInst *LI = dyn_cast<LoadInst>(P)) |
| return LI->getAlignment(); |
| if (StoreInst *SI = dyn_cast<StoreInst>(P)) |
| return SI->getAlignment(); |
| if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(P)) |
| return RMWI->getAlign().value(); |
| if (AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(P)) |
| return CXI->getAlign().value(); |
| |
| llvm_unreachable( |
| "only GlobalValue, AllocaInst, LoadInst, StoreInst, AtomicRMWInst, " |
| "and AtomicCmpXchgInst have alignment"); |
| } |
| |
| void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes) { |
| Value *P = unwrap<Value>(V); |
| if (GlobalObject *GV = dyn_cast<GlobalObject>(P)) |
| GV->setAlignment(MaybeAlign(Bytes)); |
| else if (AllocaInst *AI = dyn_cast<AllocaInst>(P)) |
| AI->setAlignment(Align(Bytes)); |
| else if (LoadInst *LI = dyn_cast<LoadInst>(P)) |
| LI->setAlignment(Align(Bytes)); |
| else if (StoreInst *SI = dyn_cast<StoreInst>(P)) |
| SI->setAlignment(Align(Bytes)); |
| else if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(P)) |
| RMWI->setAlignment(Align(Bytes)); |
| else if (AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(P)) |
| CXI->setAlignment(Align(Bytes)); |
| else |
| llvm_unreachable( |
| "only GlobalValue, AllocaInst, LoadInst, StoreInst, AtomicRMWInst, and " |
| "and AtomicCmpXchgInst have alignment"); |
| } |
| |
| LLVMValueMetadataEntry *LLVMGlobalCopyAllMetadata(LLVMValueRef Value, |
| size_t *NumEntries) { |
| return llvm_getMetadata(NumEntries, [&Value](MetadataEntries &Entries) { |
| Entries.clear(); |
| if (Instruction *Instr = dyn_cast<Instruction>(unwrap(Value))) { |
| Instr->getAllMetadata(Entries); |
| } else { |
| unwrap<GlobalObject>(Value)->getAllMetadata(Entries); |
| } |
| }); |
| } |
| |
| unsigned LLVMValueMetadataEntriesGetKind(LLVMValueMetadataEntry *Entries, |
| unsigned Index) { |
| LLVMOpaqueValueMetadataEntry MVE = |
| static_cast<LLVMOpaqueValueMetadataEntry>(Entries[Index]); |
| return MVE.Kind; |
| } |
| |
| LLVMMetadataRef |
| LLVMValueMetadataEntriesGetMetadata(LLVMValueMetadataEntry *Entries, |
| unsigned Index) { |
| LLVMOpaqueValueMetadataEntry MVE = |
| static_cast<LLVMOpaqueValueMetadataEntry>(Entries[Index]); |
| return MVE.Metadata; |
| } |
| |
| void LLVMDisposeValueMetadataEntries(LLVMValueMetadataEntry *Entries) { |
| free(Entries); |
| } |
| |
| void LLVMGlobalSetMetadata(LLVMValueRef Global, unsigned Kind, |
| LLVMMetadataRef MD) { |
| unwrap<GlobalObject>(Global)->setMetadata(Kind, unwrap<MDNode>(MD)); |
| } |
| |
| void LLVMGlobalEraseMetadata(LLVMValueRef Global, unsigned Kind) { |
| unwrap<GlobalObject>(Global)->eraseMetadata(Kind); |
| } |
| |
| void LLVMGlobalClearMetadata(LLVMValueRef Global) { |
| unwrap<GlobalObject>(Global)->clearMetadata(); |
| } |
| |
| /*--.. Operations on global variables ......................................--*/ |
| |
| LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name) { |
| return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false, |
| GlobalValue::ExternalLinkage, nullptr, Name)); |
| } |
| |
| LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty, |
| const char *Name, |
| unsigned AddressSpace) { |
| return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false, |
| GlobalValue::ExternalLinkage, nullptr, Name, |
| nullptr, GlobalVariable::NotThreadLocal, |
| AddressSpace)); |
| } |
| |
| LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name) { |
| return wrap(unwrap(M)->getNamedGlobal(Name)); |
| } |
| |
| LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M) { |
| Module *Mod = unwrap(M); |
| Module::global_iterator I = Mod->global_begin(); |
| if (I == Mod->global_end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M) { |
| Module *Mod = unwrap(M); |
| Module::global_iterator I = Mod->global_end(); |
| if (I == Mod->global_begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar) { |
| GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar); |
| Module::global_iterator I(GV); |
| if (++I == GV->getParent()->global_end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar) { |
| GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar); |
| Module::global_iterator I(GV); |
| if (I == GV->getParent()->global_begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| void LLVMDeleteGlobal(LLVMValueRef GlobalVar) { |
| unwrap<GlobalVariable>(GlobalVar)->eraseFromParent(); |
| } |
| |
| LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar) { |
| GlobalVariable* GV = unwrap<GlobalVariable>(GlobalVar); |
| if ( !GV->hasInitializer() ) |
| return nullptr; |
| return wrap(GV->getInitializer()); |
| } |
| |
| void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) { |
| unwrap<GlobalVariable>(GlobalVar) |
| ->setInitializer(unwrap<Constant>(ConstantVal)); |
| } |
| |
| LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar) { |
| return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal(); |
| } |
| |
| void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal) { |
| unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0); |
| } |
| |
| LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar) { |
| return unwrap<GlobalVariable>(GlobalVar)->isConstant(); |
| } |
| |
| void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant) { |
| unwrap<GlobalVariable>(GlobalVar)->setConstant(IsConstant != 0); |
| } |
| |
| LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar) { |
| switch (unwrap<GlobalVariable>(GlobalVar)->getThreadLocalMode()) { |
| case GlobalVariable::NotThreadLocal: |
| return LLVMNotThreadLocal; |
| case GlobalVariable::GeneralDynamicTLSModel: |
| return LLVMGeneralDynamicTLSModel; |
| case GlobalVariable::LocalDynamicTLSModel: |
| return LLVMLocalDynamicTLSModel; |
| case GlobalVariable::InitialExecTLSModel: |
| return LLVMInitialExecTLSModel; |
| case GlobalVariable::LocalExecTLSModel: |
| return LLVMLocalExecTLSModel; |
| } |
| |
| llvm_unreachable("Invalid GlobalVariable thread local mode"); |
| } |
| |
| void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode) { |
| GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar); |
| |
| switch (Mode) { |
| case LLVMNotThreadLocal: |
| GV->setThreadLocalMode(GlobalVariable::NotThreadLocal); |
| break; |
| case LLVMGeneralDynamicTLSModel: |
| GV->setThreadLocalMode(GlobalVariable::GeneralDynamicTLSModel); |
| break; |
| case LLVMLocalDynamicTLSModel: |
| GV->setThreadLocalMode(GlobalVariable::LocalDynamicTLSModel); |
| break; |
| case LLVMInitialExecTLSModel: |
| GV->setThreadLocalMode(GlobalVariable::InitialExecTLSModel); |
| break; |
| case LLVMLocalExecTLSModel: |
| GV->setThreadLocalMode(GlobalVariable::LocalExecTLSModel); |
| break; |
| } |
| } |
| |
| LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar) { |
| return unwrap<GlobalVariable>(GlobalVar)->isExternallyInitialized(); |
| } |
| |
| void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit) { |
| unwrap<GlobalVariable>(GlobalVar)->setExternallyInitialized(IsExtInit); |
| } |
| |
| /*--.. Operations on aliases ......................................--*/ |
| |
| LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, |
| const char *Name) { |
| auto *PTy = cast<PointerType>(unwrap(Ty)); |
| return wrap(GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), |
| GlobalValue::ExternalLinkage, Name, |
| unwrap<Constant>(Aliasee), unwrap(M))); |
| } |
| |
| LLVMValueRef LLVMGetNamedGlobalAlias(LLVMModuleRef M, |
| const char *Name, size_t NameLen) { |
| return wrap(unwrap(M)->getNamedAlias(Name)); |
| } |
| |
| LLVMValueRef LLVMGetFirstGlobalAlias(LLVMModuleRef M) { |
| Module *Mod = unwrap(M); |
| Module::alias_iterator I = Mod->alias_begin(); |
| if (I == Mod->alias_end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMValueRef LLVMGetLastGlobalAlias(LLVMModuleRef M) { |
| Module *Mod = unwrap(M); |
| Module::alias_iterator I = Mod->alias_end(); |
| if (I == Mod->alias_begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| LLVMValueRef LLVMGetNextGlobalAlias(LLVMValueRef GA) { |
| GlobalAlias *Alias = unwrap<GlobalAlias>(GA); |
| Module::alias_iterator I(Alias); |
| if (++I == Alias->getParent()->alias_end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMValueRef LLVMGetPreviousGlobalAlias(LLVMValueRef GA) { |
| GlobalAlias *Alias = unwrap<GlobalAlias>(GA); |
| Module::alias_iterator I(Alias); |
| if (I == Alias->getParent()->alias_begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| LLVMValueRef LLVMAliasGetAliasee(LLVMValueRef Alias) { |
| return wrap(unwrap<GlobalAlias>(Alias)->getAliasee()); |
| } |
| |
| void LLVMAliasSetAliasee(LLVMValueRef Alias, LLVMValueRef Aliasee) { |
| unwrap<GlobalAlias>(Alias)->setAliasee(unwrap<Constant>(Aliasee)); |
| } |
| |
| /*--.. Operations on functions .............................................--*/ |
| |
| LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, |
| LLVMTypeRef FunctionTy) { |
| return wrap(Function::Create(unwrap<FunctionType>(FunctionTy), |
| GlobalValue::ExternalLinkage, Name, unwrap(M))); |
| } |
| |
| LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name) { |
| return wrap(unwrap(M)->getFunction(Name)); |
| } |
| |
| LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M) { |
| Module *Mod = unwrap(M); |
| Module::iterator I = Mod->begin(); |
| if (I == Mod->end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M) { |
| Module *Mod = unwrap(M); |
| Module::iterator I = Mod->end(); |
| if (I == Mod->begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn) { |
| Function *Func = unwrap<Function>(Fn); |
| Module::iterator I(Func); |
| if (++I == Func->getParent()->end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn) { |
| Function *Func = unwrap<Function>(Fn); |
| Module::iterator I(Func); |
| if (I == Func->getParent()->begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| void LLVMDeleteFunction(LLVMValueRef Fn) { |
| unwrap<Function>(Fn)->eraseFromParent(); |
| } |
| |
| LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn) { |
| return unwrap<Function>(Fn)->hasPersonalityFn(); |
| } |
| |
| LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn) { |
| return wrap(unwrap<Function>(Fn)->getPersonalityFn()); |
| } |
| |
| void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn) { |
| unwrap<Function>(Fn)->setPersonalityFn(unwrap<Constant>(PersonalityFn)); |
| } |
| |
| unsigned LLVMGetIntrinsicID(LLVMValueRef Fn) { |
| if (Function *F = dyn_cast<Function>(unwrap(Fn))) |
| return F->getIntrinsicID(); |
| return 0; |
| } |
| |
| static Intrinsic::ID llvm_map_to_intrinsic_id(unsigned ID) { |
| assert(ID < llvm::Intrinsic::num_intrinsics && "Intrinsic ID out of range"); |
| return llvm::Intrinsic::ID(ID); |
| } |
| |
| LLVMValueRef LLVMGetIntrinsicDeclaration(LLVMModuleRef Mod, |
| unsigned ID, |
| LLVMTypeRef *ParamTypes, |
| size_t ParamCount) { |
| ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount); |
| auto IID = llvm_map_to_intrinsic_id(ID); |
| return wrap(llvm::Intrinsic::getDeclaration(unwrap(Mod), IID, Tys)); |
| } |
| |
| const char *LLVMIntrinsicGetName(unsigned ID, size_t *NameLength) { |
| auto IID = llvm_map_to_intrinsic_id(ID); |
| auto Str = llvm::Intrinsic::getName(IID); |
| *NameLength = Str.size(); |
| return Str.data(); |
| } |
| |
| LLVMTypeRef LLVMIntrinsicGetType(LLVMContextRef Ctx, unsigned ID, |
| LLVMTypeRef *ParamTypes, size_t ParamCount) { |
| auto IID = llvm_map_to_intrinsic_id(ID); |
| ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount); |
| return wrap(llvm::Intrinsic::getType(*unwrap(Ctx), IID, Tys)); |
| } |
| |
| const char *LLVMIntrinsicCopyOverloadedName(unsigned ID, |
| LLVMTypeRef *ParamTypes, |
| size_t ParamCount, |
| size_t *NameLength) { |
| auto IID = llvm_map_to_intrinsic_id(ID); |
| ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount); |
| auto Str = llvm::Intrinsic::getNameNoUnnamedTypes(IID, Tys); |
| *NameLength = Str.length(); |
| return strdup(Str.c_str()); |
| } |
| |
| const char *LLVMIntrinsicCopyOverloadedName2(LLVMModuleRef Mod, unsigned ID, |
| LLVMTypeRef *ParamTypes, |
| size_t ParamCount, |
| size_t *NameLength) { |
| auto IID = llvm_map_to_intrinsic_id(ID); |
| ArrayRef<Type *> Tys(unwrap(ParamTypes), ParamCount); |
| auto Str = llvm::Intrinsic::getName(IID, Tys, unwrap(Mod)); |
| *NameLength = Str.length(); |
| return strdup(Str.c_str()); |
| } |
| |
| unsigned LLVMLookupIntrinsicID(const char *Name, size_t NameLen) { |
| return Function::lookupIntrinsicID({Name, NameLen}); |
| } |
| |
| LLVMBool LLVMIntrinsicIsOverloaded(unsigned ID) { |
| auto IID = llvm_map_to_intrinsic_id(ID); |
| return llvm::Intrinsic::isOverloaded(IID); |
| } |
| |
| unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn) { |
| return unwrap<Function>(Fn)->getCallingConv(); |
| } |
| |
| void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC) { |
| return unwrap<Function>(Fn)->setCallingConv( |
| static_cast<CallingConv::ID>(CC)); |
| } |
| |
| const char *LLVMGetGC(LLVMValueRef Fn) { |
| Function *F = unwrap<Function>(Fn); |
| return F->hasGC()? F->getGC().c_str() : nullptr; |
| } |
| |
| void LLVMSetGC(LLVMValueRef Fn, const char *GC) { |
| Function *F = unwrap<Function>(Fn); |
| if (GC) |
| F->setGC(GC); |
| else |
| F->clearGC(); |
| } |
| |
| void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, |
| LLVMAttributeRef A) { |
| unwrap<Function>(F)->addAttributeAtIndex(Idx, unwrap(A)); |
| } |
| |
| unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx) { |
| auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx); |
| return AS.getNumAttributes(); |
| } |
| |
| void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, |
| LLVMAttributeRef *Attrs) { |
| auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx); |
| for (auto A : AS) |
| *Attrs++ = wrap(A); |
| } |
| |
| LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F, |
| LLVMAttributeIndex Idx, |
| unsigned KindID) { |
| return wrap(unwrap<Function>(F)->getAttributeAtIndex( |
| Idx, (Attribute::AttrKind)KindID)); |
| } |
| |
| LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F, |
| LLVMAttributeIndex Idx, |
| const char *K, unsigned KLen) { |
| return wrap( |
| unwrap<Function>(F)->getAttributeAtIndex(Idx, StringRef(K, KLen))); |
| } |
| |
| void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, |
| unsigned KindID) { |
| unwrap<Function>(F)->removeAttributeAtIndex(Idx, (Attribute::AttrKind)KindID); |
| } |
| |
| void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, |
| const char *K, unsigned KLen) { |
| unwrap<Function>(F)->removeAttributeAtIndex(Idx, StringRef(K, KLen)); |
| } |
| |
| void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A, |
| const char *V) { |
| Function *Func = unwrap<Function>(Fn); |
| Attribute Attr = Attribute::get(Func->getContext(), A, V); |
| Func->addFnAttr(Attr); |
| } |
| |
| /*--.. Operations on parameters ............................................--*/ |
| |
| unsigned LLVMCountParams(LLVMValueRef FnRef) { |
| // This function is strictly redundant to |
| // LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(FnRef))) |
| return unwrap<Function>(FnRef)->arg_size(); |
| } |
| |
| void LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs) { |
| Function *Fn = unwrap<Function>(FnRef); |
| for (Argument &A : Fn->args()) |
| *ParamRefs++ = wrap(&A); |
| } |
| |
| LLVMValueRef LLVMGetParam(LLVMValueRef FnRef, unsigned index) { |
| Function *Fn = unwrap<Function>(FnRef); |
| return wrap(&Fn->arg_begin()[index]); |
| } |
| |
| LLVMValueRef LLVMGetParamParent(LLVMValueRef V) { |
| return wrap(unwrap<Argument>(V)->getParent()); |
| } |
| |
| LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn) { |
| Function *Func = unwrap<Function>(Fn); |
| Function::arg_iterator I = Func->arg_begin(); |
| if (I == Func->arg_end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn) { |
| Function *Func = unwrap<Function>(Fn); |
| Function::arg_iterator I = Func->arg_end(); |
| if (I == Func->arg_begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg) { |
| Argument *A = unwrap<Argument>(Arg); |
| Function *Fn = A->getParent(); |
| if (A->getArgNo() + 1 >= Fn->arg_size()) |
| return nullptr; |
| return wrap(&Fn->arg_begin()[A->getArgNo() + 1]); |
| } |
| |
| LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg) { |
| Argument *A = unwrap<Argument>(Arg); |
| if (A->getArgNo() == 0) |
| return nullptr; |
| return wrap(&A->getParent()->arg_begin()[A->getArgNo() - 1]); |
| } |
| |
| void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align) { |
| Argument *A = unwrap<Argument>(Arg); |
| A->addAttr(Attribute::getWithAlignment(A->getContext(), Align(align))); |
| } |
| |
| /*--.. Operations on ifuncs ................................................--*/ |
| |
| LLVMValueRef LLVMAddGlobalIFunc(LLVMModuleRef M, |
| const char *Name, size_t NameLen, |
| LLVMTypeRef Ty, unsigned AddrSpace, |
| LLVMValueRef Resolver) { |
| return wrap(GlobalIFunc::create(unwrap(Ty), AddrSpace, |
| GlobalValue::ExternalLinkage, |
| StringRef(Name, NameLen), |
| unwrap<Constant>(Resolver), unwrap(M))); |
| } |
| |
| LLVMValueRef LLVMGetNamedGlobalIFunc(LLVMModuleRef M, |
| const char *Name, size_t NameLen) { |
| return wrap(unwrap(M)->getNamedIFunc(StringRef(Name, NameLen))); |
| } |
| |
| LLVMValueRef LLVMGetFirstGlobalIFunc(LLVMModuleRef M) { |
| Module *Mod = unwrap(M); |
| Module::ifunc_iterator I = Mod->ifunc_begin(); |
| if (I == Mod->ifunc_end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMValueRef LLVMGetLastGlobalIFunc(LLVMModuleRef M) { |
| Module *Mod = unwrap(M); |
| Module::ifunc_iterator I = Mod->ifunc_end(); |
| if (I == Mod->ifunc_begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| LLVMValueRef LLVMGetNextGlobalIFunc(LLVMValueRef IFunc) { |
| GlobalIFunc *GIF = unwrap<GlobalIFunc>(IFunc); |
| Module::ifunc_iterator I(GIF); |
| if (++I == GIF->getParent()->ifunc_end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMValueRef LLVMGetPreviousGlobalIFunc(LLVMValueRef IFunc) { |
| GlobalIFunc *GIF = unwrap<GlobalIFunc>(IFunc); |
| Module::ifunc_iterator I(GIF); |
| if (I == GIF->getParent()->ifunc_begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| LLVMValueRef LLVMGetGlobalIFuncResolver(LLVMValueRef IFunc) { |
| return wrap(unwrap<GlobalIFunc>(IFunc)->getResolver()); |
| } |
| |
| void LLVMSetGlobalIFuncResolver(LLVMValueRef IFunc, LLVMValueRef Resolver) { |
| unwrap<GlobalIFunc>(IFunc)->setResolver(unwrap<Constant>(Resolver)); |
| } |
| |
| void LLVMEraseGlobalIFunc(LLVMValueRef IFunc) { |
| unwrap<GlobalIFunc>(IFunc)->eraseFromParent(); |
| } |
| |
| void LLVMRemoveGlobalIFunc(LLVMValueRef IFunc) { |
| unwrap<GlobalIFunc>(IFunc)->removeFromParent(); |
| } |
| |
| /*--.. Operations on basic blocks ..........................................--*/ |
| |
| LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB) { |
| return wrap(static_cast<Value*>(unwrap(BB))); |
| } |
| |
| LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val) { |
| return isa<BasicBlock>(unwrap(Val)); |
| } |
| |
| LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val) { |
| return wrap(unwrap<BasicBlock>(Val)); |
| } |
| |
| const char *LLVMGetBasicBlockName(LLVMBasicBlockRef BB) { |
| return unwrap(BB)->getName().data(); |
| } |
| |
| LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB) { |
| return wrap(unwrap(BB)->getParent()); |
| } |
| |
| LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB) { |
| return wrap(unwrap(BB)->getTerminator()); |
| } |
| |
| unsigned LLVMCountBasicBlocks(LLVMValueRef FnRef) { |
| return unwrap<Function>(FnRef)->size(); |
| } |
| |
| void LLVMGetBasicBlocks(LLVMValueRef FnRef, LLVMBasicBlockRef *BasicBlocksRefs){ |
| Function *Fn = unwrap<Function>(FnRef); |
| for (BasicBlock &BB : *Fn) |
| *BasicBlocksRefs++ = wrap(&BB); |
| } |
| |
| LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn) { |
| return wrap(&unwrap<Function>(Fn)->getEntryBlock()); |
| } |
| |
| LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn) { |
| Function *Func = unwrap<Function>(Fn); |
| Function::iterator I = Func->begin(); |
| if (I == Func->end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn) { |
| Function *Func = unwrap<Function>(Fn); |
| Function::iterator I = Func->end(); |
| if (I == Func->begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB) { |
| BasicBlock *Block = unwrap(BB); |
| Function::iterator I(Block); |
| if (++I == Block->getParent()->end()) |
| return nullptr; |
| return wrap(&*I); |
| } |
| |
| LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB) { |
| BasicBlock *Block = unwrap(BB); |
| Function::iterator I(Block); |
| if (I == Block->getParent()->begin()) |
| return nullptr; |
| return wrap(&*--I); |
| } |
| |
| LLVMBasicBlockRef LLVMCreateBasicBlockInContext(LLVMContextRef C, |
| const char *Name) { |
| return wrap(llvm::BasicBlock::Create(*unwrap(C), Name)); |
| } |
| |
| void LLVMInsertExistingBasicBlockAfterInsertBlock(LLVMBuilderRef Builder, |
| LLVMBasicBlockRef BB) { |
| BasicBlock *ToInsert = unwrap(BB); |
| BasicBlock *CurBB = |