2020-07-26 12:11:30 -05:00
|
|
|
|
#include "LLVMWrapper.h"
|
2017-03-16 15:10:04 -05:00
|
|
|
|
#include "llvm/IR/DebugInfoMetadata.h"
|
2014-09-12 10:17:58 -05:00
|
|
|
|
#include "llvm/IR/DiagnosticInfo.h"
|
|
|
|
|
#include "llvm/IR/DiagnosticPrinter.h"
|
2018-05-23 14:19:07 -05:00
|
|
|
|
#include "llvm/IR/GlobalVariable.h"
|
2016-08-01 18:35:09 -05:00
|
|
|
|
#include "llvm/IR/Instructions.h"
|
2020-06-03 23:19:34 -05:00
|
|
|
|
#include "llvm/IR/Intrinsics.h"
|
2016-12-30 05:22:11 -06:00
|
|
|
|
#include "llvm/Object/Archive.h"
|
2021-03-08 14:42:54 -06:00
|
|
|
|
#include "llvm/Object/COFFImportFile.h"
|
2016-12-30 05:22:11 -06:00
|
|
|
|
#include "llvm/Object/ObjectFile.h"
|
2017-07-23 10:14:38 -05:00
|
|
|
|
#include "llvm/Bitcode/BitcodeWriterPass.h"
|
2018-10-12 14:35:55 -05:00
|
|
|
|
#include "llvm/Support/Signals.h"
|
2017-07-21 06:26:41 -05:00
|
|
|
|
#include "llvm/ADT/Optional.h"
|
|
|
|
|
|
2018-10-12 14:35:55 -05:00
|
|
|
|
#include <iostream>
|
|
|
|
|
|
2011-10-21 19:35:52 -05:00
|
|
|
|
//===----------------------------------------------------------------------===
|
2011-03-15 16:57:26 -05:00
|
|
|
|
//
|
|
|
|
|
// This file defines alternate interfaces to core functions that are more
|
|
|
|
|
// readily callable by Rust's FFI.
|
|
|
|
|
//
|
2011-10-21 19:35:52 -05:00
|
|
|
|
//===----------------------------------------------------------------------===
|
2011-03-15 16:57:26 -05:00
|
|
|
|
|
2011-04-15 16:35:46 -05:00
|
|
|
|
using namespace llvm;
|
2012-09-11 01:05:51 -05:00
|
|
|
|
using namespace llvm::sys;
|
2013-12-16 22:58:21 -06:00
|
|
|
|
using namespace llvm::object;
|
2011-04-15 16:35:46 -05:00
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
// LLVMAtomicOrdering is already an enum - don't create another
|
|
|
|
|
// one.
|
2016-12-31 11:01:23 -06:00
|
|
|
|
static AtomicOrdering fromRust(LLVMAtomicOrdering Ordering) {
|
2016-08-01 18:35:09 -05:00
|
|
|
|
switch (Ordering) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
case LLVMAtomicOrderingNotAtomic:
|
|
|
|
|
return AtomicOrdering::NotAtomic;
|
|
|
|
|
case LLVMAtomicOrderingUnordered:
|
|
|
|
|
return AtomicOrdering::Unordered;
|
|
|
|
|
case LLVMAtomicOrderingMonotonic:
|
|
|
|
|
return AtomicOrdering::Monotonic;
|
|
|
|
|
case LLVMAtomicOrderingAcquire:
|
|
|
|
|
return AtomicOrdering::Acquire;
|
|
|
|
|
case LLVMAtomicOrderingRelease:
|
|
|
|
|
return AtomicOrdering::Release;
|
|
|
|
|
case LLVMAtomicOrderingAcquireRelease:
|
|
|
|
|
return AtomicOrdering::AcquireRelease;
|
|
|
|
|
case LLVMAtomicOrderingSequentiallyConsistent:
|
|
|
|
|
return AtomicOrdering::SequentiallyConsistent;
|
2016-08-01 18:35:09 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-11-20 10:47:29 -06:00
|
|
|
|
report_fatal_error("Invalid LLVMAtomicOrdering value!");
|
2016-08-01 18:35:09 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-10-10 07:11:28 -05:00
|
|
|
|
static LLVM_THREAD_LOCAL char *LastError;
|
2013-04-05 19:17:49 -05:00
|
|
|
|
|
2018-10-12 14:35:55 -05:00
|
|
|
|
// Custom error handler for fatal LLVM errors.
|
|
|
|
|
//
|
|
|
|
|
// Notably it exits the process with code 101, unlike LLVM's default of 1.
|
|
|
|
|
static void FatalErrorHandler(void *UserData,
|
2021-10-05 09:31:36 -05:00
|
|
|
|
#if LLVM_VERSION_LT(14, 0)
|
2018-10-12 14:35:55 -05:00
|
|
|
|
const std::string& Reason,
|
2021-10-05 09:31:36 -05:00
|
|
|
|
#else
|
|
|
|
|
const char* Reason,
|
|
|
|
|
#endif
|
2018-10-12 14:35:55 -05:00
|
|
|
|
bool GenCrashDiag) {
|
|
|
|
|
// Do the same thing that the default error handler does.
|
|
|
|
|
std::cerr << "LLVM ERROR: " << Reason << std::endl;
|
|
|
|
|
|
|
|
|
|
// Since this error handler exits the process, we have to run any cleanup that
|
|
|
|
|
// LLVM would run after handling the error. This might change with an LLVM
|
|
|
|
|
// upgrade.
|
|
|
|
|
sys::RunInterruptHandlers();
|
|
|
|
|
|
|
|
|
|
exit(101);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern "C" void LLVMRustInstallFatalErrorHandler() {
|
|
|
|
|
install_fatal_error_handler(FatalErrorHandler);
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-15 09:25:22 -05:00
|
|
|
|
extern "C" char *LLVMRustGetLastError(void) {
|
2016-12-31 11:01:23 -06:00
|
|
|
|
char *Ret = LastError;
|
2016-12-30 06:21:21 -06:00
|
|
|
|
LastError = nullptr;
|
2016-12-31 11:01:23 -06:00
|
|
|
|
return Ret;
|
2014-04-15 09:25:22 -05:00
|
|
|
|
}
|
|
|
|
|
|
2019-10-23 08:08:26 -05:00
|
|
|
|
extern "C" unsigned int LLVMRustGetInstructionCount(LLVMModuleRef M) {
|
|
|
|
|
return unwrap(M)->getInstructionCount();
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-04 14:19:23 -06:00
|
|
|
|
extern "C" void LLVMRustSetLastError(const char *Err) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
free((void *)LastError);
|
2016-12-31 11:01:23 -06:00
|
|
|
|
LastError = strdup(Err);
|
2011-03-15 16:57:26 -05:00
|
|
|
|
}
|
|
|
|
|
|
2018-01-04 14:19:23 -06:00
|
|
|
|
extern "C" LLVMContextRef LLVMRustContextCreate(bool shouldDiscardNames) {
|
|
|
|
|
auto ctx = new LLVMContext();
|
|
|
|
|
ctx->setDiscardValueNames(shouldDiscardNames);
|
|
|
|
|
return wrap(ctx);
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" void LLVMRustSetNormalizedTarget(LLVMModuleRef M,
|
2016-12-31 11:01:23 -06:00
|
|
|
|
const char *Triple) {
|
|
|
|
|
unwrap(M)->setTargetTriple(Triple::normalize(Triple));
|
2011-05-05 13:34:15 -05:00
|
|
|
|
}
|
|
|
|
|
|
2011-05-10 18:10:08 -05:00
|
|
|
|
extern "C" void LLVMRustPrintPassTimings() {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
raw_fd_ostream OS(2, false); // stderr.
|
2011-05-10 18:10:08 -05:00
|
|
|
|
TimerGroup::printAll(OS);
|
|
|
|
|
}
|
2011-10-31 16:42:17 -05:00
|
|
|
|
|
2020-03-09 19:00:00 -05:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustGetNamedValue(LLVMModuleRef M, const char *Name,
|
|
|
|
|
size_t NameLen) {
|
|
|
|
|
return wrap(unwrap(M)->getNamedValue(StringRef(Name, NameLen)));
|
2015-02-27 05:37:33 -06:00
|
|
|
|
}
|
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustGetOrInsertFunction(LLVMModuleRef M,
|
2016-12-30 05:22:11 -06:00
|
|
|
|
const char *Name,
|
2020-03-09 19:00:00 -05:00
|
|
|
|
size_t NameLen,
|
2016-12-30 05:22:11 -06:00
|
|
|
|
LLVMTypeRef FunctionTy) {
|
2020-03-09 19:00:00 -05:00
|
|
|
|
return wrap(unwrap(M)
|
|
|
|
|
->getOrInsertFunction(StringRef(Name, NameLen),
|
|
|
|
|
unwrap<FunctionType>(FunctionTy))
|
|
|
|
|
.getCallee()
|
|
|
|
|
);
|
2011-11-14 10:32:31 -06:00
|
|
|
|
}
|
2011-11-09 23:55:09 -06:00
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" LLVMValueRef
|
2019-12-04 14:00:28 -06:00
|
|
|
|
LLVMRustGetOrInsertGlobal(LLVMModuleRef M, const char *Name, size_t NameLen, LLVMTypeRef Ty) {
|
|
|
|
|
StringRef NameRef(Name, NameLen);
|
|
|
|
|
return wrap(unwrap(M)->getOrInsertGlobal(NameRef, unwrap(Ty)));
|
2015-03-03 16:57:44 -06:00
|
|
|
|
}
|
|
|
|
|
|
2018-05-23 14:19:07 -05:00
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustInsertPrivateGlobal(LLVMModuleRef M, LLVMTypeRef Ty) {
|
|
|
|
|
return wrap(new GlobalVariable(*unwrap(M),
|
|
|
|
|
unwrap(Ty),
|
|
|
|
|
false,
|
|
|
|
|
GlobalValue::PrivateLinkage,
|
|
|
|
|
nullptr));
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
extern "C" LLVMTypeRef LLVMRustMetadataTypeInContext(LLVMContextRef C) {
|
2011-11-09 23:55:09 -06:00
|
|
|
|
return wrap(Type::getMetadataTy(*unwrap(C)));
|
|
|
|
|
}
|
2012-06-21 17:01:32 -05:00
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) {
|
|
|
|
|
switch (Kind) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
case AlwaysInline:
|
|
|
|
|
return Attribute::AlwaysInline;
|
|
|
|
|
case ByVal:
|
|
|
|
|
return Attribute::ByVal;
|
|
|
|
|
case Cold:
|
|
|
|
|
return Attribute::Cold;
|
|
|
|
|
case InlineHint:
|
|
|
|
|
return Attribute::InlineHint;
|
|
|
|
|
case MinSize:
|
|
|
|
|
return Attribute::MinSize;
|
|
|
|
|
case Naked:
|
|
|
|
|
return Attribute::Naked;
|
|
|
|
|
case NoAlias:
|
|
|
|
|
return Attribute::NoAlias;
|
|
|
|
|
case NoCapture:
|
|
|
|
|
return Attribute::NoCapture;
|
|
|
|
|
case NoInline:
|
|
|
|
|
return Attribute::NoInline;
|
|
|
|
|
case NonNull:
|
|
|
|
|
return Attribute::NonNull;
|
|
|
|
|
case NoRedZone:
|
|
|
|
|
return Attribute::NoRedZone;
|
|
|
|
|
case NoReturn:
|
|
|
|
|
return Attribute::NoReturn;
|
|
|
|
|
case NoUnwind:
|
|
|
|
|
return Attribute::NoUnwind;
|
|
|
|
|
case OptimizeForSize:
|
|
|
|
|
return Attribute::OptimizeForSize;
|
|
|
|
|
case ReadOnly:
|
|
|
|
|
return Attribute::ReadOnly;
|
|
|
|
|
case SExt:
|
|
|
|
|
return Attribute::SExt;
|
|
|
|
|
case StructRet:
|
|
|
|
|
return Attribute::StructRet;
|
|
|
|
|
case UWTable:
|
|
|
|
|
return Attribute::UWTable;
|
|
|
|
|
case ZExt:
|
|
|
|
|
return Attribute::ZExt;
|
|
|
|
|
case InReg:
|
|
|
|
|
return Attribute::InReg;
|
2016-12-29 22:28:11 -06:00
|
|
|
|
case SanitizeThread:
|
|
|
|
|
return Attribute::SanitizeThread;
|
|
|
|
|
case SanitizeAddress:
|
|
|
|
|
return Attribute::SanitizeAddress;
|
|
|
|
|
case SanitizeMemory:
|
|
|
|
|
return Attribute::SanitizeMemory;
|
2018-09-26 11:19:55 -05:00
|
|
|
|
case NonLazyBind:
|
|
|
|
|
return Attribute::NonLazyBind;
|
2018-10-27 07:29:06 -05:00
|
|
|
|
case OptimizeNone:
|
|
|
|
|
return Attribute::OptimizeNone;
|
2019-02-09 08:55:30 -06:00
|
|
|
|
case ReturnsTwice:
|
|
|
|
|
return Attribute::ReturnsTwice;
|
2020-02-17 15:36:01 -06:00
|
|
|
|
case ReadNone:
|
|
|
|
|
return Attribute::ReadNone;
|
|
|
|
|
case InaccessibleMemOnly:
|
|
|
|
|
return Attribute::InaccessibleMemOnly;
|
2021-01-22 20:32:38 -06:00
|
|
|
|
case SanitizeHWAddress:
|
|
|
|
|
return Attribute::SanitizeHWAddress;
|
2021-02-20 10:02:23 -06:00
|
|
|
|
case WillReturn:
|
|
|
|
|
return Attribute::WillReturn;
|
2016-11-16 16:36:08 -06:00
|
|
|
|
}
|
2017-11-20 10:47:29 -06:00
|
|
|
|
report_fatal_error("bad AttributeKind");
|
2016-11-16 16:36:08 -06:00
|
|
|
|
}
|
|
|
|
|
|
2021-09-07 13:49:03 -05:00
|
|
|
|
template<typename T> static inline void AddAttribute(T *t, unsigned Index, Attribute Attr) {
|
|
|
|
|
#if LLVM_VERSION_LT(14, 0)
|
|
|
|
|
t->addAttribute(Index, Attr);
|
|
|
|
|
#else
|
2021-09-07 15:15:02 -05:00
|
|
|
|
t->addAttributeAtIndex(Index, Attr);
|
2021-09-07 13:49:03 -05:00
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" void LLVMRustAddCallSiteAttribute(LLVMValueRef Instr, unsigned Index,
|
|
|
|
|
LLVMRustAttribute RustAttr) {
|
2020-06-25 20:52:41 -05:00
|
|
|
|
CallBase *Call = unwrap<CallBase>(Instr);
|
2016-12-31 11:01:23 -06:00
|
|
|
|
Attribute Attr = Attribute::get(Call->getContext(), fromRust(RustAttr));
|
2021-09-07 13:49:03 -05:00
|
|
|
|
AddAttribute(Call, Index, Attr);
|
2013-08-05 23:21:37 -05:00
|
|
|
|
}
|
|
|
|
|
|
2021-01-24 11:15:05 -06:00
|
|
|
|
extern "C" void LLVMRustAddCallSiteAttrString(LLVMValueRef Instr, unsigned Index,
|
|
|
|
|
const char *Name) {
|
|
|
|
|
CallBase *Call = unwrap<CallBase>(Instr);
|
|
|
|
|
Attribute Attr = Attribute::get(Call->getContext(), Name);
|
2021-09-07 13:49:03 -05:00
|
|
|
|
AddAttribute(Call, Index, Attr);
|
2021-01-24 11:15:05 -06:00
|
|
|
|
}
|
|
|
|
|
|
2017-10-03 02:45:07 -05:00
|
|
|
|
extern "C" void LLVMRustAddAlignmentCallSiteAttr(LLVMValueRef Instr,
|
|
|
|
|
unsigned Index,
|
|
|
|
|
uint32_t Bytes) {
|
2020-06-25 20:52:41 -05:00
|
|
|
|
CallBase *Call = unwrap<CallBase>(Instr);
|
2021-09-08 09:47:41 -05:00
|
|
|
|
Attribute Attr = Attribute::getWithAlignment(Call->getContext(), Align(Bytes));
|
|
|
|
|
AddAttribute(Call, Index, Attr);
|
2017-10-03 02:45:07 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
extern "C" void LLVMRustAddDereferenceableCallSiteAttr(LLVMValueRef Instr,
|
2016-12-31 11:01:23 -06:00
|
|
|
|
unsigned Index,
|
|
|
|
|
uint64_t Bytes) {
|
2020-06-25 20:52:41 -05:00
|
|
|
|
CallBase *Call = unwrap<CallBase>(Instr);
|
2021-09-08 09:47:41 -05:00
|
|
|
|
Attribute Attr = Attribute::getWithDereferenceableBytes(Call->getContext(), Bytes);
|
|
|
|
|
AddAttribute(Call, Index, Attr);
|
2014-07-25 18:06:44 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-10-03 02:45:07 -05:00
|
|
|
|
extern "C" void LLVMRustAddDereferenceableOrNullCallSiteAttr(LLVMValueRef Instr,
|
|
|
|
|
unsigned Index,
|
|
|
|
|
uint64_t Bytes) {
|
2020-06-25 20:52:41 -05:00
|
|
|
|
CallBase *Call = unwrap<CallBase>(Instr);
|
2021-09-08 09:47:41 -05:00
|
|
|
|
Attribute Attr = Attribute::getWithDereferenceableOrNullBytes(Call->getContext(), Bytes);
|
|
|
|
|
AddAttribute(Call, Index, Attr);
|
2017-10-03 02:45:07 -05:00
|
|
|
|
}
|
|
|
|
|
|
2019-07-06 14:52:25 -05:00
|
|
|
|
extern "C" void LLVMRustAddByValCallSiteAttr(LLVMValueRef Instr, unsigned Index,
|
|
|
|
|
LLVMTypeRef Ty) {
|
2020-06-25 20:52:41 -05:00
|
|
|
|
CallBase *Call = unwrap<CallBase>(Instr);
|
2019-07-06 14:52:25 -05:00
|
|
|
|
Attribute Attr = Attribute::getWithByValType(Call->getContext(), unwrap(Ty));
|
2021-09-07 13:49:03 -05:00
|
|
|
|
AddAttribute(Call, Index, Attr);
|
2019-07-06 14:52:25 -05:00
|
|
|
|
}
|
|
|
|
|
|
2020-11-03 15:47:16 -06:00
|
|
|
|
extern "C" void LLVMRustAddStructRetCallSiteAttr(LLVMValueRef Instr, unsigned Index,
|
|
|
|
|
LLVMTypeRef Ty) {
|
|
|
|
|
CallBase *Call = unwrap<CallBase>(Instr);
|
|
|
|
|
Attribute Attr = Attribute::getWithStructRetType(Call->getContext(), unwrap(Ty));
|
2021-09-07 13:49:03 -05:00
|
|
|
|
AddAttribute(Call, Index, Attr);
|
2020-11-03 15:47:16 -06:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" void LLVMRustAddFunctionAttribute(LLVMValueRef Fn, unsigned Index,
|
|
|
|
|
LLVMRustAttribute RustAttr) {
|
2014-05-21 14:07:48 -05:00
|
|
|
|
Function *A = unwrap<Function>(Fn);
|
2016-12-31 11:01:23 -06:00
|
|
|
|
Attribute Attr = Attribute::get(A->getContext(), fromRust(RustAttr));
|
2021-09-07 13:49:03 -05:00
|
|
|
|
AddAttribute(A, Index, Attr);
|
2014-05-21 14:07:48 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-10-03 02:45:07 -05:00
|
|
|
|
extern "C" void LLVMRustAddAlignmentAttr(LLVMValueRef Fn,
|
|
|
|
|
unsigned Index,
|
|
|
|
|
uint32_t Bytes) {
|
|
|
|
|
Function *A = unwrap<Function>(Fn);
|
2021-09-07 13:49:03 -05:00
|
|
|
|
AddAttribute(A, Index, Attribute::getWithAlignment(
|
2021-08-24 08:44:17 -05:00
|
|
|
|
A->getContext(), llvm::Align(Bytes)));
|
2017-10-03 02:45:07 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" void LLVMRustAddDereferenceableAttr(LLVMValueRef Fn, unsigned Index,
|
|
|
|
|
uint64_t Bytes) {
|
2014-07-25 18:06:44 -05:00
|
|
|
|
Function *A = unwrap<Function>(Fn);
|
2021-09-07 13:49:03 -05:00
|
|
|
|
AddAttribute(A, Index, Attribute::getWithDereferenceableBytes(A->getContext(),
|
2021-08-24 08:44:17 -05:00
|
|
|
|
Bytes));
|
2014-07-25 18:06:44 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-10-03 02:45:07 -05:00
|
|
|
|
extern "C" void LLVMRustAddDereferenceableOrNullAttr(LLVMValueRef Fn,
|
|
|
|
|
unsigned Index,
|
|
|
|
|
uint64_t Bytes) {
|
|
|
|
|
Function *A = unwrap<Function>(Fn);
|
2021-09-07 13:49:03 -05:00
|
|
|
|
AddAttribute(A, Index, Attribute::getWithDereferenceableOrNullBytes(
|
2021-08-24 08:44:17 -05:00
|
|
|
|
A->getContext(), Bytes));
|
2017-10-03 02:45:07 -05:00
|
|
|
|
}
|
|
|
|
|
|
2019-07-06 14:52:25 -05:00
|
|
|
|
extern "C" void LLVMRustAddByValAttr(LLVMValueRef Fn, unsigned Index,
|
|
|
|
|
LLVMTypeRef Ty) {
|
|
|
|
|
Function *F = unwrap<Function>(Fn);
|
|
|
|
|
Attribute Attr = Attribute::getWithByValType(F->getContext(), unwrap(Ty));
|
2021-09-07 13:49:03 -05:00
|
|
|
|
AddAttribute(F, Index, Attr);
|
2019-07-06 14:52:25 -05:00
|
|
|
|
}
|
|
|
|
|
|
2020-11-03 15:47:16 -06:00
|
|
|
|
extern "C" void LLVMRustAddStructRetAttr(LLVMValueRef Fn, unsigned Index,
|
|
|
|
|
LLVMTypeRef Ty) {
|
|
|
|
|
Function *F = unwrap<Function>(Fn);
|
|
|
|
|
Attribute Attr = Attribute::getWithStructRetType(F->getContext(), unwrap(Ty));
|
2021-09-07 13:49:03 -05:00
|
|
|
|
AddAttribute(F, Index, Attr);
|
2020-11-03 15:47:16 -06:00
|
|
|
|
}
|
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
extern "C" void LLVMRustAddFunctionAttrStringValue(LLVMValueRef Fn,
|
2016-12-31 11:01:23 -06:00
|
|
|
|
unsigned Index,
|
2016-12-30 05:22:11 -06:00
|
|
|
|
const char *Name,
|
|
|
|
|
const char *Value) {
|
rustc: Update LLVM
This commit updates the LLVM submodule in use to the current HEAD of the LLVM
repository. This is primarily being done to start picking up unwinding support
for MSVC, which is currently unimplemented in the revision of LLVM we are using.
Along the way a few changes had to be made:
* As usual, lots of C++ debuginfo bindings in LLVM changed, so there were some
significant changes to our RustWrapper.cpp
* As usual, some pass management changed in LLVM, so clang was re-scrutinized to
ensure that we're doing the same thing as clang.
* Some optimization options are now passed directly into the
`PassManagerBuilder` instead of through CLI switches to LLVM.
* The `NoFramePointerElim` option was removed from LLVM, favoring instead the
`no-frame-pointer-elim` function attribute instead.
Additionally, LLVM has picked up some new optimizations which required fixing an
existing soundness hole in the IR we generate. It appears that the current LLVM
we use does not expose this hole. When an enum is moved, the previous slot in
memory is overwritten with a bit pattern corresponding to "dropped". When the
drop glue for this slot is run, however, the switch on the discriminant can
often start executing the `unreachable` block of the switch due to the
discriminant now being outside the normal range. This was patched over locally
for now by having the `unreachable` block just change to a `ret void`.
2015-05-14 14:10:43 -05:00
|
|
|
|
Function *F = unwrap<Function>(Fn);
|
2021-09-07 13:49:03 -05:00
|
|
|
|
AddAttribute(F, Index, Attribute::get(
|
2021-08-24 08:44:17 -05:00
|
|
|
|
F->getContext(), StringRef(Name), StringRef(Value)));
|
rustc: Update LLVM
This commit updates the LLVM submodule in use to the current HEAD of the LLVM
repository. This is primarily being done to start picking up unwinding support
for MSVC, which is currently unimplemented in the revision of LLVM we are using.
Along the way a few changes had to be made:
* As usual, lots of C++ debuginfo bindings in LLVM changed, so there were some
significant changes to our RustWrapper.cpp
* As usual, some pass management changed in LLVM, so clang was re-scrutinized to
ensure that we're doing the same thing as clang.
* Some optimization options are now passed directly into the
`PassManagerBuilder` instead of through CLI switches to LLVM.
* The `NoFramePointerElim` option was removed from LLVM, favoring instead the
`no-frame-pointer-elim` function attribute instead.
Additionally, LLVM has picked up some new optimizations which required fixing an
existing soundness hole in the IR we generate. It appears that the current LLVM
we use does not expose this hole. When an enum is moved, the previous slot in
memory is overwritten with a bit pattern corresponding to "dropped". When the
drop glue for this slot is run, however, the switch on the discriminant can
often start executing the `unreachable` block of the switch due to the
discriminant now being outside the normal range. This was patched over locally
for now by having the `unreachable` block just change to a `ret void`.
2015-05-14 14:10:43 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
extern "C" void LLVMRustRemoveFunctionAttributes(LLVMValueRef Fn,
|
2016-12-31 11:01:23 -06:00
|
|
|
|
unsigned Index,
|
|
|
|
|
LLVMRustAttribute RustAttr) {
|
2016-11-16 16:36:08 -06:00
|
|
|
|
Function *F = unwrap<Function>(Fn);
|
2016-12-31 11:01:23 -06:00
|
|
|
|
Attribute Attr = Attribute::get(F->getContext(), fromRust(RustAttr));
|
2016-11-21 05:30:05 -06:00
|
|
|
|
AttrBuilder B(Attr);
|
2017-07-21 11:15:03 -05:00
|
|
|
|
auto PAL = F->getAttributes();
|
2021-09-07 13:49:03 -05:00
|
|
|
|
AttributeList PALNew;
|
|
|
|
|
#if LLVM_VERSION_LT(14, 0)
|
|
|
|
|
PALNew = PAL.removeAttributes(F->getContext(), Index, B);
|
|
|
|
|
#else
|
2021-09-07 15:15:02 -05:00
|
|
|
|
PALNew = PAL.removeAttributesAtIndex(F->getContext(), Index, B);
|
2021-09-07 13:49:03 -05:00
|
|
|
|
#endif
|
2016-12-31 11:01:23 -06:00
|
|
|
|
F->setAttributes(PALNew);
|
2014-04-19 12:33:46 -05:00
|
|
|
|
}
|
2013-09-09 01:32:30 -05:00
|
|
|
|
|
2021-04-17 12:40:59 -05:00
|
|
|
|
// Enable a fast-math flag
|
|
|
|
|
//
|
|
|
|
|
// https://llvm.org/docs/LangRef.html#fast-math-flags
|
|
|
|
|
extern "C" void LLVMRustSetFastMath(LLVMValueRef V) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
if (auto I = dyn_cast<Instruction>(unwrap<Value>(V))) {
|
2018-01-22 19:28:23 -06:00
|
|
|
|
I->setFast(true);
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-03-14 18:01:12 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" LLVMValueRef
|
2021-07-04 10:49:51 -05:00
|
|
|
|
LLVMRustBuildAtomicLoad(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Source,
|
|
|
|
|
const char *Name, LLVMAtomicOrdering Order) {
|
2020-06-25 20:52:41 -05:00
|
|
|
|
Value *Ptr = unwrap(Source);
|
2021-07-04 10:49:51 -05:00
|
|
|
|
LoadInst *LI = unwrap(B)->CreateLoad(unwrap(Ty), Ptr, Name);
|
2016-12-31 11:01:23 -06:00
|
|
|
|
LI->setAtomic(fromRust(Order));
|
2020-06-25 20:52:41 -05:00
|
|
|
|
return wrap(LI);
|
2013-05-12 14:22:20 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustBuildAtomicStore(LLVMBuilderRef B,
|
2016-12-31 11:01:23 -06:00
|
|
|
|
LLVMValueRef V,
|
|
|
|
|
LLVMValueRef Target,
|
2017-06-01 13:50:53 -05:00
|
|
|
|
LLVMAtomicOrdering Order) {
|
2020-06-25 20:52:41 -05:00
|
|
|
|
StoreInst *SI = unwrap(B)->CreateStore(unwrap(V), unwrap(Target));
|
2016-12-31 11:01:23 -06:00
|
|
|
|
SI->setAtomic(fromRust(Order));
|
2020-06-25 20:52:41 -05:00
|
|
|
|
return wrap(SI);
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
|
|
|
|
|
2020-06-25 20:52:41 -05:00
|
|
|
|
// FIXME: Use the C-API LLVMBuildAtomicCmpXchg and LLVMSetWeak
|
|
|
|
|
// once we raise our minimum support to LLVM 10.
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" LLVMValueRef
|
2016-12-31 11:01:23 -06:00
|
|
|
|
LLVMRustBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Target,
|
|
|
|
|
LLVMValueRef Old, LLVMValueRef Source,
|
|
|
|
|
LLVMAtomicOrdering Order,
|
|
|
|
|
LLVMAtomicOrdering FailureOrder, LLVMBool Weak) {
|
2021-03-19 15:46:40 -05:00
|
|
|
|
#if LLVM_VERSION_GE(13,0)
|
2021-03-22 13:37:49 -05:00
|
|
|
|
// Rust probably knows the alignment of the target value and should be able to
|
|
|
|
|
// specify something more precise than MaybeAlign here. See also
|
|
|
|
|
// https://reviews.llvm.org/D97224 which may be a useful reference.
|
2021-03-16 15:11:09 -05:00
|
|
|
|
AtomicCmpXchgInst *ACXI = unwrap(B)->CreateAtomicCmpXchg(
|
|
|
|
|
unwrap(Target), unwrap(Old), unwrap(Source), llvm::MaybeAlign(), fromRust(Order),
|
|
|
|
|
fromRust(FailureOrder));
|
|
|
|
|
#else
|
2016-12-31 11:01:23 -06:00
|
|
|
|
AtomicCmpXchgInst *ACXI = unwrap(B)->CreateAtomicCmpXchg(
|
|
|
|
|
unwrap(Target), unwrap(Old), unwrap(Source), fromRust(Order),
|
|
|
|
|
fromRust(FailureOrder));
|
2021-03-16 15:11:09 -05:00
|
|
|
|
#endif
|
2016-12-31 11:01:23 -06:00
|
|
|
|
ACXI->setWeak(Weak);
|
|
|
|
|
return wrap(ACXI);
|
2012-10-21 21:23:50 -05:00
|
|
|
|
}
|
2016-08-01 18:35:09 -05:00
|
|
|
|
|
|
|
|
|
enum class LLVMRustSynchronizationScope {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
SingleThread,
|
|
|
|
|
CrossThread,
|
2016-08-01 18:35:09 -05:00
|
|
|
|
};
|
|
|
|
|
|
2017-07-21 07:02:52 -05:00
|
|
|
|
static SyncScope::ID fromRust(LLVMRustSynchronizationScope Scope) {
|
|
|
|
|
switch (Scope) {
|
|
|
|
|
case LLVMRustSynchronizationScope::SingleThread:
|
|
|
|
|
return SyncScope::SingleThread;
|
|
|
|
|
case LLVMRustSynchronizationScope::CrossThread:
|
|
|
|
|
return SyncScope::System;
|
|
|
|
|
default:
|
2017-11-20 10:47:29 -06:00
|
|
|
|
report_fatal_error("bad SynchronizationScope.");
|
2017-07-21 07:02:52 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
2016-08-01 18:35:09 -05:00
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" LLVMValueRef
|
2016-12-31 11:01:23 -06:00
|
|
|
|
LLVMRustBuildAtomicFence(LLVMBuilderRef B, LLVMAtomicOrdering Order,
|
|
|
|
|
LLVMRustSynchronizationScope Scope) {
|
|
|
|
|
return wrap(unwrap(B)->CreateFence(fromRust(Order), fromRust(Scope)));
|
2013-07-28 02:48:16 -05:00
|
|
|
|
}
|
2012-07-25 14:06:03 -05:00
|
|
|
|
|
2016-08-02 16:25:19 -05:00
|
|
|
|
enum class LLVMRustAsmDialect {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
Att,
|
|
|
|
|
Intel,
|
2016-08-02 16:25:19 -05:00
|
|
|
|
};
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
static InlineAsm::AsmDialect fromRust(LLVMRustAsmDialect Dialect) {
|
|
|
|
|
switch (Dialect) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
case LLVMRustAsmDialect::Att:
|
|
|
|
|
return InlineAsm::AD_ATT;
|
|
|
|
|
case LLVMRustAsmDialect::Intel:
|
|
|
|
|
return InlineAsm::AD_Intel;
|
|
|
|
|
default:
|
2017-11-20 10:47:29 -06:00
|
|
|
|
report_fatal_error("bad AsmDialect.");
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-08-02 16:25:19 -05:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-09 19:00:00 -05:00
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustInlineAsm(LLVMTypeRef Ty, char *AsmString, size_t AsmStringLen,
|
|
|
|
|
char *Constraints, size_t ConstraintsLen,
|
|
|
|
|
LLVMBool HasSideEffects, LLVMBool IsAlignStack,
|
|
|
|
|
LLVMRustAsmDialect Dialect) {
|
|
|
|
|
return wrap(InlineAsm::get(unwrap<FunctionType>(Ty),
|
|
|
|
|
StringRef(AsmString, AsmStringLen),
|
|
|
|
|
StringRef(Constraints, ConstraintsLen),
|
2016-12-31 11:01:23 -06:00
|
|
|
|
HasSideEffects, IsAlignStack, fromRust(Dialect)));
|
2013-03-10 00:37:50 -06:00
|
|
|
|
}
|
2013-06-13 23:25:12 -05:00
|
|
|
|
|
2020-03-09 19:00:00 -05:00
|
|
|
|
extern "C" bool LLVMRustInlineAsmVerify(LLVMTypeRef Ty, char *Constraints,
|
|
|
|
|
size_t ConstraintsLen) {
|
|
|
|
|
return InlineAsm::Verify(unwrap<FunctionType>(Ty),
|
|
|
|
|
StringRef(Constraints, ConstraintsLen));
|
2018-09-25 13:35:19 -05:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-09 19:00:00 -05:00
|
|
|
|
extern "C" void LLVMRustAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm,
|
|
|
|
|
size_t AsmLen) {
|
|
|
|
|
unwrap(M)->appendModuleInlineAsm(StringRef(Asm, AsmLen));
|
2017-03-21 19:50:23 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
typedef DIBuilder *LLVMRustDIBuilderRef;
|
2013-06-14 13:38:29 -05:00
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
template <typename DIT> DIT *unwrapDIPtr(LLVMMetadataRef Ref) {
|
2016-12-31 11:01:23 -06:00
|
|
|
|
return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
|
rustc: Update LLVM
This commit updates the LLVM submodule in use to the current HEAD of the LLVM
repository. This is primarily being done to start picking up unwinding support
for MSVC, which is currently unimplemented in the revision of LLVM we are using.
Along the way a few changes had to be made:
* As usual, lots of C++ debuginfo bindings in LLVM changed, so there were some
significant changes to our RustWrapper.cpp
* As usual, some pass management changed in LLVM, so clang was re-scrutinized to
ensure that we're doing the same thing as clang.
* Some optimization options are now passed directly into the
`PassManagerBuilder` instead of through CLI switches to LLVM.
* The `NoFramePointerElim` option was removed from LLVM, favoring instead the
`no-frame-pointer-elim` function attribute instead.
Additionally, LLVM has picked up some new optimizations which required fixing an
existing soundness hole in the IR we generate. It appears that the current LLVM
we use does not expose this hole. When an enum is moved, the previous slot in
memory is overwritten with a bit pattern corresponding to "dropped". When the
drop glue for this slot is run, however, the switch on the discriminant can
often start executing the `unreachable` block of the switch due to the
discriminant now being outside the normal range. This was patched over locally
for now by having the `unreachable` block just change to a `ret void`.
2015-05-14 14:10:43 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define DIDescriptor DIScope
|
|
|
|
|
#define DIArray DINodeArray
|
2016-12-31 11:01:23 -06:00
|
|
|
|
#define unwrapDI unwrapDIPtr
|
2013-06-14 13:38:29 -05:00
|
|
|
|
|
2016-11-18 16:15:14 -06:00
|
|
|
|
// These values **must** match debuginfo::DIFlags! They also *happen*
|
|
|
|
|
// to match LLVM, but that isn't required as we do giant sets of
|
|
|
|
|
// matching below. The value shouldn't be directly passed to LLVM.
|
|
|
|
|
enum class LLVMRustDIFlags : uint32_t {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
FlagZero = 0,
|
|
|
|
|
FlagPrivate = 1,
|
|
|
|
|
FlagProtected = 2,
|
|
|
|
|
FlagPublic = 3,
|
|
|
|
|
FlagFwdDecl = (1 << 2),
|
|
|
|
|
FlagAppleBlock = (1 << 3),
|
|
|
|
|
FlagBlockByrefStruct = (1 << 4),
|
|
|
|
|
FlagVirtual = (1 << 5),
|
|
|
|
|
FlagArtificial = (1 << 6),
|
|
|
|
|
FlagExplicit = (1 << 7),
|
|
|
|
|
FlagPrototyped = (1 << 8),
|
|
|
|
|
FlagObjcClassComplete = (1 << 9),
|
|
|
|
|
FlagObjectPointer = (1 << 10),
|
|
|
|
|
FlagVector = (1 << 11),
|
|
|
|
|
FlagStaticMember = (1 << 12),
|
|
|
|
|
FlagLValueReference = (1 << 13),
|
|
|
|
|
FlagRValueReference = (1 << 14),
|
2018-01-20 14:32:33 -06:00
|
|
|
|
FlagExternalTypeRef = (1 << 15),
|
|
|
|
|
FlagIntroducedVirtual = (1 << 18),
|
|
|
|
|
FlagBitField = (1 << 19),
|
|
|
|
|
FlagNoReturn = (1 << 20),
|
2016-12-30 05:22:11 -06:00
|
|
|
|
// Do not add values that are not supported by the minimum LLVM
|
2018-01-20 14:32:33 -06:00
|
|
|
|
// version we support! see llvm/include/llvm/IR/DebugInfoFlags.def
|
2016-11-18 16:15:14 -06:00
|
|
|
|
};
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
inline LLVMRustDIFlags operator&(LLVMRustDIFlags A, LLVMRustDIFlags B) {
|
|
|
|
|
return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(A) &
|
|
|
|
|
static_cast<uint32_t>(B));
|
2016-11-18 16:15:14 -06:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
inline LLVMRustDIFlags operator|(LLVMRustDIFlags A, LLVMRustDIFlags B) {
|
|
|
|
|
return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(A) |
|
|
|
|
|
static_cast<uint32_t>(B));
|
2016-11-18 16:15:14 -06:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
inline LLVMRustDIFlags &operator|=(LLVMRustDIFlags &A, LLVMRustDIFlags B) {
|
|
|
|
|
return A = A | B;
|
2016-11-18 16:15:14 -06:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
inline bool isSet(LLVMRustDIFlags F) { return F != LLVMRustDIFlags::FlagZero; }
|
2016-11-18 16:15:14 -06:00
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
inline LLVMRustDIFlags visibility(LLVMRustDIFlags F) {
|
|
|
|
|
return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(F) & 0x3);
|
2016-11-18 16:15:14 -06:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
static DINode::DIFlags fromRust(LLVMRustDIFlags Flags) {
|
|
|
|
|
DINode::DIFlags Result = DINode::DIFlags::FlagZero;
|
2016-11-18 16:15:14 -06:00
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
switch (visibility(Flags)) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
case LLVMRustDIFlags::FlagPrivate:
|
2016-12-31 11:01:23 -06:00
|
|
|
|
Result |= DINode::DIFlags::FlagPrivate;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
break;
|
|
|
|
|
case LLVMRustDIFlags::FlagProtected:
|
2016-12-31 11:01:23 -06:00
|
|
|
|
Result |= DINode::DIFlags::FlagProtected;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
break;
|
|
|
|
|
case LLVMRustDIFlags::FlagPublic:
|
2016-12-31 11:01:23 -06:00
|
|
|
|
Result |= DINode::DIFlags::FlagPublic;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
// The rest are handled below
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagFwdDecl)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagFwdDecl;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagAppleBlock)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagAppleBlock;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagVirtual)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagVirtual;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagArtificial)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagArtificial;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagExplicit)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagExplicit;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagPrototyped)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagPrototyped;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagObjcClassComplete)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagObjcClassComplete;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagObjectPointer)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagObjectPointer;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagVector)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagVector;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagStaticMember)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagStaticMember;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagLValueReference)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagLValueReference;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagRValueReference)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagRValueReference;
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2018-01-20 14:32:33 -06:00
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagIntroducedVirtual)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagIntroducedVirtual;
|
|
|
|
|
}
|
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagBitField)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagBitField;
|
|
|
|
|
}
|
|
|
|
|
if (isSet(Flags & LLVMRustDIFlags::FlagNoReturn)) {
|
|
|
|
|
Result |= DINode::DIFlags::FlagNoReturn;
|
|
|
|
|
}
|
2016-12-30 05:22:11 -06:00
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
return Result;
|
2016-11-18 16:15:14 -06:00
|
|
|
|
}
|
|
|
|
|
|
2019-01-16 11:59:03 -06:00
|
|
|
|
// These values **must** match debuginfo::DISPFlags! They also *happen*
|
|
|
|
|
// to match LLVM, but that isn't required as we do giant sets of
|
|
|
|
|
// matching below. The value shouldn't be directly passed to LLVM.
|
|
|
|
|
enum class LLVMRustDISPFlags : uint32_t {
|
|
|
|
|
SPFlagZero = 0,
|
|
|
|
|
SPFlagVirtual = 1,
|
|
|
|
|
SPFlagPureVirtual = 2,
|
|
|
|
|
SPFlagLocalToUnit = (1 << 2),
|
|
|
|
|
SPFlagDefinition = (1 << 3),
|
|
|
|
|
SPFlagOptimized = (1 << 4),
|
2019-04-04 15:05:41 -05:00
|
|
|
|
SPFlagMainSubprogram = (1 << 5),
|
2019-01-16 11:59:03 -06:00
|
|
|
|
// Do not add values that are not supported by the minimum LLVM
|
|
|
|
|
// version we support! see llvm/include/llvm/IR/DebugInfoFlags.def
|
|
|
|
|
// (In LLVM < 8, createFunction supported these as separate bool arguments.)
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
inline LLVMRustDISPFlags operator&(LLVMRustDISPFlags A, LLVMRustDISPFlags B) {
|
|
|
|
|
return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) &
|
|
|
|
|
static_cast<uint32_t>(B));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline LLVMRustDISPFlags operator|(LLVMRustDISPFlags A, LLVMRustDISPFlags B) {
|
|
|
|
|
return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) |
|
|
|
|
|
static_cast<uint32_t>(B));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline LLVMRustDISPFlags &operator|=(LLVMRustDISPFlags &A, LLVMRustDISPFlags B) {
|
|
|
|
|
return A = A | B;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline bool isSet(LLVMRustDISPFlags F) { return F != LLVMRustDISPFlags::SPFlagZero; }
|
|
|
|
|
|
|
|
|
|
inline LLVMRustDISPFlags virtuality(LLVMRustDISPFlags F) {
|
|
|
|
|
return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(F) & 0x3);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static DISubprogram::DISPFlags fromRust(LLVMRustDISPFlags SPFlags) {
|
|
|
|
|
DISubprogram::DISPFlags Result = DISubprogram::DISPFlags::SPFlagZero;
|
|
|
|
|
|
|
|
|
|
switch (virtuality(SPFlags)) {
|
|
|
|
|
case LLVMRustDISPFlags::SPFlagVirtual:
|
|
|
|
|
Result |= DISubprogram::DISPFlags::SPFlagVirtual;
|
|
|
|
|
break;
|
|
|
|
|
case LLVMRustDISPFlags::SPFlagPureVirtual:
|
|
|
|
|
Result |= DISubprogram::DISPFlags::SPFlagPureVirtual;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
// The rest are handled below
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagLocalToUnit)) {
|
|
|
|
|
Result |= DISubprogram::DISPFlags::SPFlagLocalToUnit;
|
|
|
|
|
}
|
|
|
|
|
if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagDefinition)) {
|
|
|
|
|
Result |= DISubprogram::DISPFlags::SPFlagDefinition;
|
|
|
|
|
}
|
|
|
|
|
if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagOptimized)) {
|
|
|
|
|
Result |= DISubprogram::DISPFlags::SPFlagOptimized;
|
|
|
|
|
}
|
2019-04-04 15:05:41 -05:00
|
|
|
|
if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagMainSubprogram)) {
|
|
|
|
|
Result |= DISubprogram::DISPFlags::SPFlagMainSubprogram;
|
|
|
|
|
}
|
2019-01-16 11:59:03 -06:00
|
|
|
|
|
|
|
|
|
return Result;
|
|
|
|
|
}
|
|
|
|
|
|
2019-01-22 15:01:14 -06:00
|
|
|
|
enum class LLVMRustDebugEmissionKind {
|
|
|
|
|
NoDebug,
|
|
|
|
|
FullDebug,
|
|
|
|
|
LineTablesOnly,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static DICompileUnit::DebugEmissionKind fromRust(LLVMRustDebugEmissionKind Kind) {
|
|
|
|
|
switch (Kind) {
|
|
|
|
|
case LLVMRustDebugEmissionKind::NoDebug:
|
|
|
|
|
return DICompileUnit::DebugEmissionKind::NoDebug;
|
|
|
|
|
case LLVMRustDebugEmissionKind::FullDebug:
|
|
|
|
|
return DICompileUnit::DebugEmissionKind::FullDebug;
|
|
|
|
|
case LLVMRustDebugEmissionKind::LineTablesOnly:
|
|
|
|
|
return DICompileUnit::DebugEmissionKind::LineTablesOnly;
|
|
|
|
|
default:
|
|
|
|
|
report_fatal_error("bad DebugEmissionKind.");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-31 00:17:15 -05:00
|
|
|
|
enum class LLVMRustChecksumKind {
|
|
|
|
|
None,
|
|
|
|
|
MD5,
|
|
|
|
|
SHA1,
|
2020-10-13 10:41:06 -05:00
|
|
|
|
SHA256,
|
2020-03-31 00:17:15 -05:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static Optional<DIFile::ChecksumKind> fromRust(LLVMRustChecksumKind Kind) {
|
|
|
|
|
switch (Kind) {
|
|
|
|
|
case LLVMRustChecksumKind::None:
|
|
|
|
|
return None;
|
|
|
|
|
case LLVMRustChecksumKind::MD5:
|
|
|
|
|
return DIFile::ChecksumKind::CSK_MD5;
|
|
|
|
|
case LLVMRustChecksumKind::SHA1:
|
|
|
|
|
return DIFile::ChecksumKind::CSK_SHA1;
|
2020-10-13 10:41:06 -05:00
|
|
|
|
case LLVMRustChecksumKind::SHA256:
|
|
|
|
|
return DIFile::ChecksumKind::CSK_SHA256;
|
2020-03-31 00:17:15 -05:00
|
|
|
|
default:
|
|
|
|
|
report_fatal_error("bad ChecksumKind.");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-30 08:50:12 -05:00
|
|
|
|
extern "C" uint32_t LLVMRustDebugMetadataVersion() {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return DEBUG_METADATA_VERSION;
|
2015-05-11 23:07:38 -05:00
|
|
|
|
}
|
2014-01-27 23:05:33 -06:00
|
|
|
|
|
2020-10-12 21:33:27 -05:00
|
|
|
|
extern "C" uint32_t LLVMRustVersionPatch() { return LLVM_VERSION_PATCH; }
|
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" uint32_t LLVMRustVersionMinor() { return LLVM_VERSION_MINOR; }
|
2015-01-24 05:00:35 -06:00
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" uint32_t LLVMRustVersionMajor() { return LLVM_VERSION_MAJOR; }
|
2015-01-24 05:00:35 -06:00
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" void LLVMRustAddModuleFlag(LLVMModuleRef M, const char *Name,
|
|
|
|
|
uint32_t Value) {
|
|
|
|
|
unwrap(M)->addModuleFlag(Module::Warning, Name, Value);
|
2014-01-27 23:05:33 -06:00
|
|
|
|
}
|
|
|
|
|
|
2017-12-12 11:27:37 -06:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD) {
|
|
|
|
|
return wrap(MetadataAsValue::get(*unwrap(C), unwrap(MD)));
|
2017-02-13 03:57:50 -06:00
|
|
|
|
}
|
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
extern "C" LLVMRustDIBuilderRef LLVMRustDIBuilderCreate(LLVMModuleRef M) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return new DIBuilder(*unwrap(M));
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
extern "C" void LLVMRustDIBuilderDispose(LLVMRustDIBuilderRef Builder) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
delete Builder;
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
extern "C" void LLVMRustDIBuilderFinalize(LLVMRustDIBuilderRef Builder) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
Builder->finalize();
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateCompileUnit(
|
|
|
|
|
LLVMRustDIBuilderRef Builder, unsigned Lang, LLVMMetadataRef FileRef,
|
2020-03-05 18:00:00 -06:00
|
|
|
|
const char *Producer, size_t ProducerLen, bool isOptimized,
|
|
|
|
|
const char *Flags, unsigned RuntimeVer,
|
|
|
|
|
const char *SplitName, size_t SplitNameLen,
|
2020-09-23 10:25:20 -05:00
|
|
|
|
LLVMRustDebugEmissionKind Kind,
|
|
|
|
|
uint64_t DWOId, bool SplitDebugInlining) {
|
2017-02-11 15:01:25 -06:00
|
|
|
|
auto *File = unwrapDI<DIFile>(FileRef);
|
|
|
|
|
|
2020-03-05 18:00:00 -06:00
|
|
|
|
return wrap(Builder->createCompileUnit(Lang, File, StringRef(Producer, ProducerLen),
|
|
|
|
|
isOptimized, Flags, RuntimeVer,
|
|
|
|
|
StringRef(SplitName, SplitNameLen),
|
2020-09-23 10:25:20 -05:00
|
|
|
|
fromRust(Kind), DWOId, SplitDebugInlining));
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-05 18:00:00 -06:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFile(
|
|
|
|
|
LLVMRustDIBuilderRef Builder,
|
|
|
|
|
const char *Filename, size_t FilenameLen,
|
2020-03-31 00:17:15 -05:00
|
|
|
|
const char *Directory, size_t DirectoryLen, LLVMRustChecksumKind CSKind,
|
|
|
|
|
const char *Checksum, size_t ChecksumLen) {
|
|
|
|
|
Optional<DIFile::ChecksumKind> llvmCSKind = fromRust(CSKind);
|
|
|
|
|
Optional<DIFile::ChecksumInfo<StringRef>> CSInfo{};
|
|
|
|
|
if (llvmCSKind)
|
|
|
|
|
CSInfo.emplace(*llvmCSKind, StringRef{Checksum, ChecksumLen});
|
2020-03-05 18:00:00 -06:00
|
|
|
|
return wrap(Builder->createFile(StringRef(Filename, FilenameLen),
|
2020-03-31 00:17:15 -05:00
|
|
|
|
StringRef(Directory, DirectoryLen),
|
|
|
|
|
CSInfo));
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef
|
2016-12-30 05:22:11 -06:00
|
|
|
|
LLVMRustDIBuilderCreateSubroutineType(LLVMRustDIBuilderRef Builder,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMMetadataRef ParameterTypes) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return wrap(Builder->createSubroutineType(
|
|
|
|
|
DITypeRefArray(unwrap<MDTuple>(ParameterTypes))));
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFunction(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
|
|
|
|
|
const char *Name, size_t NameLen,
|
|
|
|
|
const char *LinkageName, size_t LinkageNameLen,
|
|
|
|
|
LLVMMetadataRef File, unsigned LineNo,
|
2019-01-16 11:59:03 -06:00
|
|
|
|
LLVMMetadataRef Ty, unsigned ScopeLine, LLVMRustDIFlags Flags,
|
2020-02-10 14:30:51 -06:00
|
|
|
|
LLVMRustDISPFlags SPFlags, LLVMValueRef MaybeFn, LLVMMetadataRef TParam,
|
2019-01-16 11:59:03 -06:00
|
|
|
|
LLVMMetadataRef Decl) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
DITemplateParameterArray TParams =
|
|
|
|
|
DITemplateParameterArray(unwrap<MDTuple>(TParam));
|
2019-04-04 15:05:41 -05:00
|
|
|
|
DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags);
|
|
|
|
|
DINode::DIFlags llvmFlags = fromRust(Flags);
|
2019-01-16 11:59:03 -06:00
|
|
|
|
DISubprogram *Sub = Builder->createFunction(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
unwrapDI<DIScope>(Scope),
|
|
|
|
|
StringRef(Name, NameLen),
|
|
|
|
|
StringRef(LinkageName, LinkageNameLen),
|
|
|
|
|
unwrapDI<DIFile>(File), LineNo,
|
|
|
|
|
unwrapDI<DISubroutineType>(Ty), ScopeLine, llvmFlags,
|
2019-04-04 15:05:41 -05:00
|
|
|
|
llvmSPFlags, TParams, unwrapDIPtr<DISubprogram>(Decl));
|
2020-02-10 14:30:51 -06:00
|
|
|
|
if (MaybeFn)
|
|
|
|
|
unwrap<Function>(MaybeFn)->setSubprogram(Sub);
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return wrap(Sub);
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-05 18:00:00 -06:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateBasicType(
|
|
|
|
|
LLVMRustDIBuilderRef Builder, const char *Name, size_t NameLen,
|
2020-05-21 12:53:41 -05:00
|
|
|
|
uint64_t SizeInBits, unsigned Encoding) {
|
2020-03-05 18:00:00 -06:00
|
|
|
|
return wrap(Builder->createBasicType(StringRef(Name, NameLen), SizeInBits, Encoding));
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
2013-07-02 11:10:24 -05:00
|
|
|
|
|
2020-06-25 01:28:00 -05:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTypedef(
|
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Type, const char *Name, size_t NameLen,
|
|
|
|
|
LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Scope) {
|
|
|
|
|
return wrap(Builder->createTypedef(
|
|
|
|
|
unwrap<DIType>(Type), StringRef(Name, NameLen), unwrap<DIFile>(File),
|
2020-10-27 20:05:16 -05:00
|
|
|
|
LineNo, unwrapDIPtr<DIScope>(Scope)));
|
2020-06-25 01:28:00 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreatePointerType(
|
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef PointeeTy,
|
2020-03-05 18:00:00 -06:00
|
|
|
|
uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
|
|
|
|
|
const char *Name, size_t NameLen) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return wrap(Builder->createPointerType(unwrapDI<DIType>(PointeeTy),
|
2017-07-21 06:26:41 -05:00
|
|
|
|
SizeInBits, AlignInBits,
|
2020-03-05 18:00:00 -06:00
|
|
|
|
AddressSpace,
|
|
|
|
|
StringRef(Name, NameLen)));
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStructType(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
|
|
|
|
|
const char *Name, size_t NameLen,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
|
2017-02-04 04:51:10 -06:00
|
|
|
|
uint32_t AlignInBits, LLVMRustDIFlags Flags,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMMetadataRef DerivedFrom, LLVMMetadataRef Elements,
|
|
|
|
|
unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
|
2020-03-05 18:00:00 -06:00
|
|
|
|
const char *UniqueId, size_t UniqueIdLen) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return wrap(Builder->createStructType(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
|
|
|
|
|
unwrapDI<DIFile>(File), LineNumber,
|
2016-12-31 11:01:23 -06:00
|
|
|
|
SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIType>(DerivedFrom),
|
2016-12-30 05:22:11 -06:00
|
|
|
|
DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
|
2020-03-05 18:00:00 -06:00
|
|
|
|
unwrapDI<DIType>(VTableHolder), StringRef(UniqueId, UniqueIdLen)));
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-11-29 15:42:25 -06:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantPart(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
|
|
|
|
|
const char *Name, size_t NameLen,
|
2017-11-29 15:42:25 -06:00
|
|
|
|
LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
|
|
|
|
|
uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Discriminator,
|
2020-03-05 18:00:00 -06:00
|
|
|
|
LLVMMetadataRef Elements, const char *UniqueId, size_t UniqueIdLen) {
|
2017-11-29 15:42:25 -06:00
|
|
|
|
return wrap(Builder->createVariantPart(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
|
|
|
|
|
unwrapDI<DIFile>(File), LineNumber,
|
2017-11-29 15:42:25 -06:00
|
|
|
|
SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIDerivedType>(Discriminator),
|
2020-03-05 18:00:00 -06:00
|
|
|
|
DINodeArray(unwrapDI<MDTuple>(Elements)), StringRef(UniqueId, UniqueIdLen)));
|
2017-11-29 15:42:25 -06:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMemberType(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
|
|
|
|
|
const char *Name, size_t NameLen,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
|
2017-02-04 04:51:10 -06:00
|
|
|
|
uint32_t AlignInBits, uint64_t OffsetInBits, LLVMRustDIFlags Flags,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMMetadataRef Ty) {
|
2020-03-05 18:00:00 -06:00
|
|
|
|
return wrap(Builder->createMemberType(unwrapDI<DIDescriptor>(Scope),
|
|
|
|
|
StringRef(Name, NameLen),
|
2016-12-31 11:01:23 -06:00
|
|
|
|
unwrapDI<DIFile>(File), LineNo,
|
|
|
|
|
SizeInBits, AlignInBits, OffsetInBits,
|
|
|
|
|
fromRust(Flags), unwrapDI<DIType>(Ty)));
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
2013-07-02 11:10:24 -05:00
|
|
|
|
|
2017-11-29 15:42:25 -06:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantMemberType(
|
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
|
2020-03-05 18:00:00 -06:00
|
|
|
|
const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo,
|
|
|
|
|
uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, LLVMValueRef Discriminant,
|
2017-11-29 15:42:25 -06:00
|
|
|
|
LLVMRustDIFlags Flags, LLVMMetadataRef Ty) {
|
|
|
|
|
llvm::ConstantInt* D = nullptr;
|
|
|
|
|
if (Discriminant) {
|
|
|
|
|
D = unwrap<llvm::ConstantInt>(Discriminant);
|
|
|
|
|
}
|
2020-03-05 18:00:00 -06:00
|
|
|
|
return wrap(Builder->createVariantMemberType(unwrapDI<DIDescriptor>(Scope),
|
|
|
|
|
StringRef(Name, NameLen),
|
2017-11-29 15:42:25 -06:00
|
|
|
|
unwrapDI<DIFile>(File), LineNo,
|
|
|
|
|
SizeInBits, AlignInBits, OffsetInBits, D,
|
|
|
|
|
fromRust(Flags), unwrapDI<DIType>(Ty)));
|
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateLexicalBlock(
|
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
|
|
|
|
|
LLVMMetadataRef File, unsigned Line, unsigned Col) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return wrap(Builder->createLexicalBlock(unwrapDI<DIDescriptor>(Scope),
|
|
|
|
|
unwrapDI<DIFile>(File), Line, Col));
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
2013-07-02 11:10:24 -05:00
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef
|
2016-12-30 05:22:11 -06:00
|
|
|
|
LLVMRustDIBuilderCreateLexicalBlockFile(LLVMRustDIBuilderRef Builder,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMMetadataRef Scope,
|
|
|
|
|
LLVMMetadataRef File) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return wrap(Builder->createLexicalBlockFile(unwrapDI<DIDescriptor>(Scope),
|
|
|
|
|
unwrapDI<DIFile>(File)));
|
2016-08-24 21:34:31 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Context,
|
|
|
|
|
const char *Name, size_t NameLen,
|
|
|
|
|
const char *LinkageName, size_t LinkageNameLen,
|
|
|
|
|
LLVMMetadataRef File, unsigned LineNo,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMMetadataRef Ty, bool IsLocalToUnit, LLVMValueRef V,
|
|
|
|
|
LLVMMetadataRef Decl = nullptr, uint32_t AlignInBits = 0) {
|
2017-03-16 15:10:04 -05:00
|
|
|
|
llvm::GlobalVariable *InitVal = cast<llvm::GlobalVariable>(unwrap(V));
|
2016-12-11 03:08:20 -06:00
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
llvm::DIExpression *InitExpr = nullptr;
|
|
|
|
|
if (llvm::ConstantInt *IntVal = llvm::dyn_cast<llvm::ConstantInt>(InitVal)) {
|
|
|
|
|
InitExpr = Builder->createConstantValueExpression(
|
|
|
|
|
IntVal->getValue().getSExtValue());
|
|
|
|
|
} else if (llvm::ConstantFP *FPVal =
|
|
|
|
|
llvm::dyn_cast<llvm::ConstantFP>(InitVal)) {
|
|
|
|
|
InitExpr = Builder->createConstantValueExpression(
|
|
|
|
|
FPVal->getValueAPF().bitcastToAPInt().getZExtValue());
|
|
|
|
|
}
|
2016-12-11 03:08:20 -06:00
|
|
|
|
|
2017-03-16 15:10:04 -05:00
|
|
|
|
llvm::DIGlobalVariableExpression *VarExpr = Builder->createGlobalVariableExpression(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
unwrapDI<DIDescriptor>(Context), StringRef(Name, NameLen),
|
|
|
|
|
StringRef(LinkageName, LinkageNameLen),
|
2016-12-31 11:01:23 -06:00
|
|
|
|
unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), IsLocalToUnit,
|
2019-12-31 07:23:53 -06:00
|
|
|
|
/* isDefined */ true,
|
2018-11-07 06:34:43 -06:00
|
|
|
|
InitExpr, unwrapDIPtr<MDNode>(Decl),
|
|
|
|
|
/* templateParams */ nullptr,
|
|
|
|
|
AlignInBits);
|
2017-03-16 15:10:04 -05:00
|
|
|
|
|
|
|
|
|
InitVal->setMetadata("dbg", VarExpr);
|
|
|
|
|
|
|
|
|
|
return wrap(VarExpr);
|
2014-02-20 19:44:29 -06:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(
|
|
|
|
|
LLVMRustDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Scope,
|
2020-03-05 18:00:00 -06:00
|
|
|
|
const char *Name, size_t NameLen,
|
|
|
|
|
LLVMMetadataRef File, unsigned LineNo,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMMetadataRef Ty, bool AlwaysPreserve, LLVMRustDIFlags Flags,
|
2017-02-04 04:51:10 -06:00
|
|
|
|
unsigned ArgNo, uint32_t AlignInBits) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
if (Tag == 0x100) { // DW_TAG_auto_variable
|
|
|
|
|
return wrap(Builder->createAutoVariable(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
|
|
|
|
|
unwrapDI<DIFile>(File), LineNo,
|
2018-06-29 03:28:51 -05:00
|
|
|
|
unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags), AlignInBits));
|
2016-12-30 05:22:11 -06:00
|
|
|
|
} else {
|
|
|
|
|
return wrap(Builder->createParameterVariable(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), ArgNo,
|
|
|
|
|
unwrapDI<DIFile>(File), LineNo,
|
|
|
|
|
unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags)));
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef
|
2016-12-30 05:22:11 -06:00
|
|
|
|
LLVMRustDIBuilderCreateArrayType(LLVMRustDIBuilderRef Builder, uint64_t Size,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
uint32_t AlignInBits, LLVMMetadataRef Ty,
|
|
|
|
|
LLVMMetadataRef Subscripts) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return wrap(
|
|
|
|
|
Builder->createArrayType(Size, AlignInBits, unwrapDI<DIType>(Ty),
|
|
|
|
|
DINodeArray(unwrapDI<MDTuple>(Subscripts))));
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef
|
2016-12-30 05:22:11 -06:00
|
|
|
|
LLVMRustDIBuilderGetOrCreateSubrange(LLVMRustDIBuilderRef Builder, int64_t Lo,
|
|
|
|
|
int64_t Count) {
|
|
|
|
|
return wrap(Builder->getOrCreateSubrange(Lo, Count));
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef
|
2016-12-30 05:22:11 -06:00
|
|
|
|
LLVMRustDIBuilderGetOrCreateArray(LLVMRustDIBuilderRef Builder,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMMetadataRef *Ptr, unsigned Count) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
Metadata **DataValue = unwrap(Ptr);
|
|
|
|
|
return wrap(
|
|
|
|
|
Builder->getOrCreateArray(ArrayRef<Metadata *>(DataValue, Count)).get());
|
2013-06-14 13:38:29 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustDIBuilderInsertDeclareAtEnd(
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMValueRef V, LLVMMetadataRef VarInfo,
|
2020-02-10 14:52:20 -06:00
|
|
|
|
int64_t *AddrOps, unsigned AddrOpsCount, LLVMMetadataRef DL,
|
2013-06-11 02:57:25 -05:00
|
|
|
|
LLVMBasicBlockRef InsertAtEnd) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return wrap(Builder->insertDeclare(
|
2016-12-31 11:01:23 -06:00
|
|
|
|
unwrap(V), unwrap<DILocalVariable>(VarInfo),
|
2016-12-30 05:22:11 -06:00
|
|
|
|
Builder->createExpression(llvm::ArrayRef<int64_t>(AddrOps, AddrOpsCount)),
|
2020-10-29 11:45:15 -05:00
|
|
|
|
DebugLoc(cast<MDNode>(unwrap(DL))),
|
2016-12-30 05:22:11 -06:00
|
|
|
|
unwrap(InsertAtEnd)));
|
2013-06-11 02:57:25 -05:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-04 18:00:00 -06:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerator(
|
|
|
|
|
LLVMRustDIBuilderRef Builder, const char *Name, size_t NameLen,
|
|
|
|
|
int64_t Value, bool IsUnsigned) {
|
2020-03-05 18:00:00 -06:00
|
|
|
|
return wrap(Builder->createEnumerator(StringRef(Name, NameLen), Value, IsUnsigned));
|
2013-07-02 03:33:51 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerationType(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
|
|
|
|
|
const char *Name, size_t NameLen,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
|
|
|
|
|
uint32_t AlignInBits, LLVMMetadataRef Elements,
|
2019-01-16 11:59:03 -06:00
|
|
|
|
LLVMMetadataRef ClassTy, bool IsScoped) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return wrap(Builder->createEnumerationType(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
|
|
|
|
|
unwrapDI<DIFile>(File), LineNumber,
|
2016-12-30 05:22:11 -06:00
|
|
|
|
SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)),
|
2019-01-16 11:59:03 -06:00
|
|
|
|
unwrapDI<DIType>(ClassTy), "", IsScoped));
|
2013-07-02 11:10:24 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateUnionType(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
|
|
|
|
|
const char *Name, size_t NameLen,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
|
|
|
|
|
uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Elements,
|
2020-03-05 18:00:00 -06:00
|
|
|
|
unsigned RunTimeLang, const char *UniqueId, size_t UniqueIdLen) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return wrap(Builder->createUnionType(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), unwrapDI<DIFile>(File),
|
|
|
|
|
LineNumber, SizeInBits, AlignInBits, fromRust(Flags),
|
|
|
|
|
DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
|
|
|
|
|
StringRef(UniqueId, UniqueIdLen)));
|
2013-07-28 02:48:16 -05:00
|
|
|
|
}
|
2013-08-09 15:47:00 -05:00
|
|
|
|
|
2017-07-21 06:15:36 -05:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTemplateTypeParameter(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
|
2020-05-21 12:53:41 -05:00
|
|
|
|
const char *Name, size_t NameLen, LLVMMetadataRef Ty) {
|
2020-06-25 20:52:41 -05:00
|
|
|
|
bool IsDefault = false; // FIXME: should we ever set this true?
|
|
|
|
|
return wrap(Builder->createTemplateTypeParameter(
|
|
|
|
|
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), unwrapDI<DIType>(Ty), IsDefault));
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-05 18:00:00 -06:00
|
|
|
|
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateNameSpace(
|
|
|
|
|
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
|
|
|
|
|
const char *Name, size_t NameLen, bool ExportSymbols) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return wrap(Builder->createNameSpace(
|
2020-03-05 18:00:00 -06:00
|
|
|
|
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), ExportSymbols
|
|
|
|
|
));
|
2013-09-05 06:29:30 -05:00
|
|
|
|
}
|
2013-09-11 09:37:43 -05:00
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" void
|
2018-10-12 08:34:14 -05:00
|
|
|
|
LLVMRustDICompositeTypeReplaceArrays(LLVMRustDIBuilderRef Builder,
|
|
|
|
|
LLVMMetadataRef CompositeTy,
|
|
|
|
|
LLVMMetadataRef Elements,
|
|
|
|
|
LLVMMetadataRef Params) {
|
2016-12-31 11:01:23 -06:00
|
|
|
|
DICompositeType *Tmp = unwrapDI<DICompositeType>(CompositeTy);
|
2018-10-12 08:34:14 -05:00
|
|
|
|
Builder->replaceArrays(Tmp, DINodeArray(unwrap<MDTuple>(Elements)),
|
|
|
|
|
DINodeArray(unwrap<MDTuple>(Params)));
|
2013-09-11 09:37:43 -05:00
|
|
|
|
}
|
2013-10-11 18:56:11 -05:00
|
|
|
|
|
2020-02-10 14:52:20 -06:00
|
|
|
|
extern "C" LLVMMetadataRef
|
2021-01-13 13:55:49 -06:00
|
|
|
|
LLVMRustDIBuilderCreateDebugLocation(unsigned Line, unsigned Column,
|
2020-11-03 15:47:16 -06:00
|
|
|
|
LLVMMetadataRef ScopeRef,
|
2017-07-21 06:15:36 -05:00
|
|
|
|
LLVMMetadataRef InlinedAt) {
|
2020-11-03 15:47:16 -06:00
|
|
|
|
MDNode *Scope = unwrapDIPtr<MDNode>(ScopeRef);
|
|
|
|
|
DILocation *Loc = DILocation::get(
|
|
|
|
|
Scope->getContext(), Line, Column, Scope,
|
|
|
|
|
unwrapDIPtr<MDNode>(InlinedAt));
|
|
|
|
|
return wrap(Loc);
|
2015-01-30 12:25:07 -06:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" int64_t LLVMRustDIBuilderCreateOpDeref() {
|
|
|
|
|
return dwarf::DW_OP_deref;
|
2016-08-01 18:35:09 -05:00
|
|
|
|
}
|
|
|
|
|
|
2018-01-19 23:43:53 -06:00
|
|
|
|
extern "C" int64_t LLVMRustDIBuilderCreateOpPlusUconst() {
|
|
|
|
|
return dwarf::DW_OP_plus_uconst;
|
|
|
|
|
}
|
2016-08-01 18:35:09 -05:00
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" void LLVMRustWriteTypeToString(LLVMTypeRef Ty, RustStringRef Str) {
|
|
|
|
|
RawRustStringOstream OS(Str);
|
|
|
|
|
unwrap<llvm::Type>(Ty)->print(OS);
|
2013-10-11 18:56:11 -05:00
|
|
|
|
}
|
Implement LTO
This commit implements LTO for rust leveraging LLVM's passes. What this means
is:
* When compiling an rlib, in addition to insdering foo.o into the archive, also
insert foo.bc (the LLVM bytecode) of the optimized module.
* When the compiler detects the -Z lto option, it will attempt to perform LTO on
a staticlib or binary output. The compiler will emit an error if a dylib or
rlib output is being generated.
* The actual act of performing LTO is as follows:
1. Force all upstream libraries to have an rlib version available.
2. Load the bytecode of each upstream library from the rlib.
3. Link all this bytecode into the current LLVM module (just using llvm
apis)
4. Run an internalization pass which internalizes all symbols except those
found reachable for the local crate of compilation.
5. Run the LLVM LTO pass manager over this entire module
6a. If assembling an archive, then add all upstream rlibs into the output
archive. This ignores all of the object/bitcode/metadata files rust
generated and placed inside the rlibs.
6b. If linking a binary, create copies of all upstream rlibs, remove the
rust-generated object-file, and then link everything as usual.
As I have explained in #10741, this process is excruciatingly slow, so this is
*not* turned on by default, and it is also why I have decided to hide it behind
a -Z flag for now. The good news is that the binary sizes are about as small as
they can be as a result of LTO, so it's definitely working.
Closes #10741
Closes #10740
2013-12-03 01:19:29 -06:00
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" void LLVMRustWriteValueToString(LLVMValueRef V,
|
|
|
|
|
RustStringRef Str) {
|
|
|
|
|
RawRustStringOstream OS(Str);
|
2017-05-18 10:43:52 -05:00
|
|
|
|
if (!V) {
|
|
|
|
|
OS << "(null)";
|
|
|
|
|
} else {
|
|
|
|
|
OS << "(";
|
|
|
|
|
unwrap<llvm::Value>(V)->getType()->print(OS);
|
|
|
|
|
OS << ":";
|
|
|
|
|
unwrap<llvm::Value>(V)->print(OS);
|
|
|
|
|
OS << ")";
|
|
|
|
|
}
|
2014-01-15 13:39:08 -06:00
|
|
|
|
}
|
|
|
|
|
|
2014-05-10 03:30:55 -05:00
|
|
|
|
// LLVMArrayType function does not support 64-bit ElementCount
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" LLVMTypeRef LLVMRustArrayType(LLVMTypeRef ElementTy,
|
2016-12-30 05:22:11 -06:00
|
|
|
|
uint64_t ElementCount) {
|
2016-12-31 11:01:23 -06:00
|
|
|
|
return wrap(ArrayType::get(unwrap(ElementTy), ElementCount));
|
2014-05-10 03:30:55 -05:00
|
|
|
|
}
|
2014-09-12 10:17:58 -05:00
|
|
|
|
|
|
|
|
|
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Twine, LLVMTwineRef)
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" void LLVMRustWriteTwineToString(LLVMTwineRef T, RustStringRef Str) {
|
|
|
|
|
RawRustStringOstream OS(Str);
|
|
|
|
|
unwrap(T)->print(OS);
|
2014-09-12 10:17:58 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" void LLVMRustUnpackOptimizationDiagnostic(
|
2016-12-31 11:01:23 -06:00
|
|
|
|
LLVMDiagnosticInfoRef DI, RustStringRef PassNameOut,
|
2017-07-21 07:29:23 -05:00
|
|
|
|
LLVMValueRef *FunctionOut, unsigned* Line, unsigned* Column,
|
|
|
|
|
RustStringRef FilenameOut, RustStringRef MessageOut) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
// Undefined to call this not on an optimization diagnostic!
|
2016-12-31 11:01:23 -06:00
|
|
|
|
llvm::DiagnosticInfoOptimizationBase *Opt =
|
|
|
|
|
static_cast<llvm::DiagnosticInfoOptimizationBase *>(unwrap(DI));
|
2016-12-30 05:22:11 -06:00
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
RawRustStringOstream PassNameOS(PassNameOut);
|
|
|
|
|
PassNameOS << Opt->getPassName();
|
|
|
|
|
*FunctionOut = wrap(&Opt->getFunction());
|
2017-07-21 07:29:23 -05:00
|
|
|
|
|
|
|
|
|
RawRustStringOstream FilenameOS(FilenameOut);
|
|
|
|
|
DiagnosticLocation loc = Opt->getLocation();
|
|
|
|
|
if (loc.isValid()) {
|
|
|
|
|
*Line = loc.getLine();
|
|
|
|
|
*Column = loc.getColumn();
|
2019-01-16 11:59:03 -06:00
|
|
|
|
FilenameOS << loc.getAbsolutePath();
|
2017-07-21 07:29:23 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
RawRustStringOstream MessageOS(MessageOut);
|
|
|
|
|
MessageOS << Opt->getMsg();
|
2014-09-12 10:17:58 -05:00
|
|
|
|
}
|
|
|
|
|
|
2020-06-09 08:37:59 -05:00
|
|
|
|
enum class LLVMRustDiagnosticLevel {
|
|
|
|
|
Error,
|
|
|
|
|
Warning,
|
|
|
|
|
Note,
|
|
|
|
|
Remark,
|
|
|
|
|
};
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" void
|
2020-06-09 08:37:59 -05:00
|
|
|
|
LLVMRustUnpackInlineAsmDiagnostic(LLVMDiagnosticInfoRef DI,
|
|
|
|
|
LLVMRustDiagnosticLevel *LevelOut,
|
|
|
|
|
unsigned *CookieOut,
|
2021-07-28 14:31:47 -05:00
|
|
|
|
LLVMTwineRef *MessageOut) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
// Undefined to call this not on an inline assembly diagnostic!
|
2016-12-31 11:01:23 -06:00
|
|
|
|
llvm::DiagnosticInfoInlineAsm *IA =
|
|
|
|
|
static_cast<llvm::DiagnosticInfoInlineAsm *>(unwrap(DI));
|
2015-01-22 12:43:39 -06:00
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
*CookieOut = IA->getLocCookie();
|
|
|
|
|
*MessageOut = wrap(&IA->getMsgStr());
|
2020-06-09 08:37:59 -05:00
|
|
|
|
|
|
|
|
|
switch (IA->getSeverity()) {
|
|
|
|
|
case DS_Error:
|
|
|
|
|
*LevelOut = LLVMRustDiagnosticLevel::Error;
|
|
|
|
|
break;
|
|
|
|
|
case DS_Warning:
|
|
|
|
|
*LevelOut = LLVMRustDiagnosticLevel::Warning;
|
|
|
|
|
break;
|
|
|
|
|
case DS_Note:
|
|
|
|
|
*LevelOut = LLVMRustDiagnosticLevel::Note;
|
|
|
|
|
break;
|
|
|
|
|
case DS_Remark:
|
|
|
|
|
*LevelOut = LLVMRustDiagnosticLevel::Remark;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
report_fatal_error("Invalid LLVMRustDiagnosticLevel value!");
|
|
|
|
|
}
|
2015-01-22 12:43:39 -06:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" void LLVMRustWriteDiagnosticInfoToString(LLVMDiagnosticInfoRef DI,
|
|
|
|
|
RustStringRef Str) {
|
|
|
|
|
RawRustStringOstream OS(Str);
|
|
|
|
|
DiagnosticPrinterRawOStream DP(OS);
|
|
|
|
|
unwrap(DI)->print(DP);
|
2014-09-12 10:17:58 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
enum class LLVMRustDiagnosticKind {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
Other,
|
|
|
|
|
InlineAsm,
|
|
|
|
|
StackSize,
|
|
|
|
|
DebugMetadataVersion,
|
|
|
|
|
SampleProfile,
|
|
|
|
|
OptimizationRemark,
|
|
|
|
|
OptimizationRemarkMissed,
|
|
|
|
|
OptimizationRemarkAnalysis,
|
|
|
|
|
OptimizationRemarkAnalysisFPCommute,
|
|
|
|
|
OptimizationRemarkAnalysisAliasing,
|
|
|
|
|
OptimizationRemarkOther,
|
|
|
|
|
OptimizationFailure,
|
2018-03-12 12:11:59 -05:00
|
|
|
|
PGOProfile,
|
2018-07-17 18:20:51 -05:00
|
|
|
|
Linker,
|
2020-09-29 06:20:56 -05:00
|
|
|
|
Unsupported,
|
2021-07-28 14:31:47 -05:00
|
|
|
|
SrcMgr,
|
2016-08-01 18:35:09 -05:00
|
|
|
|
};
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
static LLVMRustDiagnosticKind toRust(DiagnosticKind Kind) {
|
|
|
|
|
switch (Kind) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
case DK_InlineAsm:
|
|
|
|
|
return LLVMRustDiagnosticKind::InlineAsm;
|
|
|
|
|
case DK_StackSize:
|
|
|
|
|
return LLVMRustDiagnosticKind::StackSize;
|
|
|
|
|
case DK_DebugMetadataVersion:
|
|
|
|
|
return LLVMRustDiagnosticKind::DebugMetadataVersion;
|
|
|
|
|
case DK_SampleProfile:
|
|
|
|
|
return LLVMRustDiagnosticKind::SampleProfile;
|
|
|
|
|
case DK_OptimizationRemark:
|
|
|
|
|
return LLVMRustDiagnosticKind::OptimizationRemark;
|
|
|
|
|
case DK_OptimizationRemarkMissed:
|
|
|
|
|
return LLVMRustDiagnosticKind::OptimizationRemarkMissed;
|
|
|
|
|
case DK_OptimizationRemarkAnalysis:
|
|
|
|
|
return LLVMRustDiagnosticKind::OptimizationRemarkAnalysis;
|
|
|
|
|
case DK_OptimizationRemarkAnalysisFPCommute:
|
|
|
|
|
return LLVMRustDiagnosticKind::OptimizationRemarkAnalysisFPCommute;
|
|
|
|
|
case DK_OptimizationRemarkAnalysisAliasing:
|
|
|
|
|
return LLVMRustDiagnosticKind::OptimizationRemarkAnalysisAliasing;
|
2018-03-12 12:11:59 -05:00
|
|
|
|
case DK_PGOProfile:
|
|
|
|
|
return LLVMRustDiagnosticKind::PGOProfile;
|
2018-07-17 18:20:51 -05:00
|
|
|
|
case DK_Linker:
|
|
|
|
|
return LLVMRustDiagnosticKind::Linker;
|
2020-09-29 06:20:56 -05:00
|
|
|
|
case DK_Unsupported:
|
|
|
|
|
return LLVMRustDiagnosticKind::Unsupported;
|
2021-07-28 14:31:47 -05:00
|
|
|
|
#if LLVM_VERSION_GE(13, 0)
|
|
|
|
|
case DK_SrcMgr:
|
|
|
|
|
return LLVMRustDiagnosticKind::SrcMgr;
|
|
|
|
|
#endif
|
2016-12-30 05:22:11 -06:00
|
|
|
|
default:
|
2016-12-31 11:01:23 -06:00
|
|
|
|
return (Kind >= DK_FirstRemark && Kind <= DK_LastRemark)
|
2016-12-30 05:22:11 -06:00
|
|
|
|
? LLVMRustDiagnosticKind::OptimizationRemarkOther
|
|
|
|
|
: LLVMRustDiagnosticKind::Other;
|
2016-08-01 18:35:09 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" LLVMRustDiagnosticKind
|
2016-12-31 11:01:23 -06:00
|
|
|
|
LLVMRustGetDiagInfoKind(LLVMDiagnosticInfoRef DI) {
|
|
|
|
|
return toRust((DiagnosticKind)unwrap(DI)->getKind());
|
2014-09-12 10:17:58 -05:00
|
|
|
|
}
|
2020-06-09 08:37:59 -05:00
|
|
|
|
|
2016-08-02 16:25:19 -05:00
|
|
|
|
// This is kept distinct from LLVMGetTypeKind, because when
|
|
|
|
|
// a new type kind is added, the Rust-side enum must be
|
|
|
|
|
// updated or UB will result.
|
|
|
|
|
extern "C" LLVMTypeKind LLVMRustGetTypeKind(LLVMTypeRef Ty) {
|
|
|
|
|
switch (unwrap(Ty)->getTypeID()) {
|
|
|
|
|
case Type::VoidTyID:
|
|
|
|
|
return LLVMVoidTypeKind;
|
|
|
|
|
case Type::HalfTyID:
|
|
|
|
|
return LLVMHalfTypeKind;
|
|
|
|
|
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;
|
2020-06-25 20:52:41 -05:00
|
|
|
|
case Type::FixedVectorTyID:
|
|
|
|
|
return LLVMVectorTypeKind;
|
2016-08-02 16:25:19 -05:00
|
|
|
|
case Type::X86_MMXTyID:
|
|
|
|
|
return LLVMX86_MMXTypeKind;
|
|
|
|
|
case Type::TokenTyID:
|
|
|
|
|
return LLVMTokenTypeKind;
|
2020-06-25 20:52:41 -05:00
|
|
|
|
case Type::ScalableVectorTyID:
|
|
|
|
|
return LLVMScalableVectorTypeKind;
|
|
|
|
|
case Type::BFloatTyID:
|
|
|
|
|
return LLVMBFloatTypeKind;
|
2020-11-03 15:47:16 -06:00
|
|
|
|
case Type::X86_AMXTyID:
|
|
|
|
|
return LLVMX86_AMXTypeKind;
|
2016-08-02 16:25:19 -05:00
|
|
|
|
}
|
2017-11-20 10:47:29 -06:00
|
|
|
|
report_fatal_error("Unhandled TypeID.");
|
2016-08-02 16:25:19 -05:00
|
|
|
|
}
|
2014-09-12 10:17:58 -05:00
|
|
|
|
|
2014-09-27 03:33:36 -05:00
|
|
|
|
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SMDiagnostic, LLVMSMDiagnosticRef)
|
|
|
|
|
|
2021-03-23 17:23:28 -05:00
|
|
|
|
#if LLVM_VERSION_LT(13, 0)
|
|
|
|
|
using LLVMInlineAsmDiagHandlerTy = LLVMContext::InlineAsmDiagHandlerTy;
|
|
|
|
|
#else
|
|
|
|
|
using LLVMInlineAsmDiagHandlerTy = void*;
|
|
|
|
|
#endif
|
|
|
|
|
|
2016-08-01 18:35:09 -05:00
|
|
|
|
extern "C" void LLVMRustSetInlineAsmDiagnosticHandler(
|
2021-03-23 17:23:28 -05:00
|
|
|
|
LLVMContextRef C, LLVMInlineAsmDiagHandlerTy H, void *CX) {
|
|
|
|
|
// Diagnostic handlers were unified in LLVM change 5de2d189e6ad, so starting
|
|
|
|
|
// with LLVM 13 this function is gone.
|
|
|
|
|
#if LLVM_VERSION_LT(13, 0)
|
2016-12-30 05:22:11 -06:00
|
|
|
|
unwrap(C)->setInlineAsmDiagnosticHandler(H, CX);
|
2021-03-23 17:23:28 -05:00
|
|
|
|
#endif
|
2014-09-27 03:33:36 -05:00
|
|
|
|
}
|
|
|
|
|
|
2021-07-28 14:31:47 -05:00
|
|
|
|
extern "C" LLVMSMDiagnosticRef LLVMRustGetSMDiagnostic(
|
|
|
|
|
LLVMDiagnosticInfoRef DI, unsigned *Cookie) {
|
|
|
|
|
#if LLVM_VERSION_GE(13, 0)
|
|
|
|
|
llvm::DiagnosticInfoSrcMgr *SM = static_cast<llvm::DiagnosticInfoSrcMgr *>(unwrap(DI));
|
|
|
|
|
*Cookie = SM->getLocCookie();
|
|
|
|
|
return wrap(&SM->getSMDiag());
|
|
|
|
|
#else
|
|
|
|
|
report_fatal_error("Shouldn't get called on older versions");
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-26 14:07:59 -05:00
|
|
|
|
extern "C" bool LLVMRustUnpackSMDiagnostic(LLVMSMDiagnosticRef DRef,
|
|
|
|
|
RustStringRef MessageOut,
|
|
|
|
|
RustStringRef BufferOut,
|
2020-06-09 08:37:59 -05:00
|
|
|
|
LLVMRustDiagnosticLevel* LevelOut,
|
2020-05-26 14:07:59 -05:00
|
|
|
|
unsigned* LocOut,
|
|
|
|
|
unsigned* RangesOut,
|
|
|
|
|
size_t* NumRanges) {
|
|
|
|
|
SMDiagnostic& D = *unwrap(DRef);
|
|
|
|
|
RawRustStringOstream MessageOS(MessageOut);
|
|
|
|
|
MessageOS << D.getMessage();
|
|
|
|
|
|
2020-06-09 08:37:59 -05:00
|
|
|
|
switch (D.getKind()) {
|
|
|
|
|
case SourceMgr::DK_Error:
|
|
|
|
|
*LevelOut = LLVMRustDiagnosticLevel::Error;
|
|
|
|
|
break;
|
|
|
|
|
case SourceMgr::DK_Warning:
|
|
|
|
|
*LevelOut = LLVMRustDiagnosticLevel::Warning;
|
|
|
|
|
break;
|
|
|
|
|
case SourceMgr::DK_Note:
|
|
|
|
|
*LevelOut = LLVMRustDiagnosticLevel::Note;
|
|
|
|
|
break;
|
|
|
|
|
case SourceMgr::DK_Remark:
|
|
|
|
|
*LevelOut = LLVMRustDiagnosticLevel::Remark;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
report_fatal_error("Invalid LLVMRustDiagnosticLevel value!");
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-26 14:07:59 -05:00
|
|
|
|
if (D.getLoc() == SMLoc())
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
const SourceMgr &LSM = *D.getSourceMgr();
|
|
|
|
|
const MemoryBuffer *LBuf = LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(D.getLoc()));
|
|
|
|
|
LLVMRustStringWriteImpl(BufferOut, LBuf->getBufferStart(), LBuf->getBufferSize());
|
|
|
|
|
|
|
|
|
|
*LocOut = D.getLoc().getPointer() - LBuf->getBufferStart();
|
|
|
|
|
|
|
|
|
|
*NumRanges = std::min(*NumRanges, D.getRanges().size());
|
|
|
|
|
size_t LineStart = *LocOut - (size_t)D.getColumnNo();
|
|
|
|
|
for (size_t i = 0; i < *NumRanges; i++) {
|
|
|
|
|
RangesOut[i * 2] = LineStart + D.getRanges()[i].first;
|
|
|
|
|
RangesOut[i * 2 + 1] = LineStart + D.getRanges()[i].second;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
2014-09-27 03:33:36 -05:00
|
|
|
|
}
|
2015-06-30 10:56:56 -05:00
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustBuildCleanupPad(LLVMBuilderRef B,
|
2016-12-30 05:22:11 -06:00
|
|
|
|
LLVMValueRef ParentPad,
|
2016-12-31 11:01:23 -06:00
|
|
|
|
unsigned ArgCount,
|
2016-12-30 05:22:11 -06:00
|
|
|
|
LLVMValueRef *LLArgs,
|
|
|
|
|
const char *Name) {
|
|
|
|
|
Value **Args = unwrap(LLArgs);
|
2016-12-30 06:21:21 -06:00
|
|
|
|
if (ParentPad == nullptr) {
|
2016-12-31 11:01:23 -06:00
|
|
|
|
Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
|
2016-12-30 05:22:11 -06:00
|
|
|
|
ParentPad = wrap(Constant::getNullValue(Ty));
|
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
return wrap(unwrap(B)->CreateCleanupPad(
|
|
|
|
|
unwrap(ParentPad), ArrayRef<Value *>(Args, ArgCount), Name));
|
2015-10-23 20:18:44 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustBuildCleanupRet(LLVMBuilderRef B,
|
2016-12-30 05:22:11 -06:00
|
|
|
|
LLVMValueRef CleanupPad,
|
|
|
|
|
LLVMBasicBlockRef UnwindBB) {
|
|
|
|
|
CleanupPadInst *Inst = cast<CleanupPadInst>(unwrap(CleanupPad));
|
2016-12-31 11:01:23 -06:00
|
|
|
|
return wrap(unwrap(B)->CreateCleanupRet(Inst, unwrap(UnwindBB)));
|
2015-10-23 20:18:44 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern "C" LLVMValueRef
|
2016-12-31 11:01:23 -06:00
|
|
|
|
LLVMRustBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
|
|
|
|
|
unsigned ArgCount, LLVMValueRef *LLArgs, const char *Name) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
Value **Args = unwrap(LLArgs);
|
2016-12-31 11:01:23 -06:00
|
|
|
|
return wrap(unwrap(B)->CreateCatchPad(
|
|
|
|
|
unwrap(ParentPad), ArrayRef<Value *>(Args, ArgCount), Name));
|
2015-10-23 20:18:44 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustBuildCatchRet(LLVMBuilderRef B,
|
2016-12-30 05:22:11 -06:00
|
|
|
|
LLVMValueRef Pad,
|
|
|
|
|
LLVMBasicBlockRef BB) {
|
2016-12-31 11:01:23 -06:00
|
|
|
|
return wrap(unwrap(B)->CreateCatchRet(cast<CatchPadInst>(unwrap(Pad)),
|
2016-12-30 05:22:11 -06:00
|
|
|
|
unwrap(BB)));
|
2015-10-23 20:18:44 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustBuildCatchSwitch(LLVMBuilderRef B,
|
2016-12-30 05:22:11 -06:00
|
|
|
|
LLVMValueRef ParentPad,
|
|
|
|
|
LLVMBasicBlockRef BB,
|
|
|
|
|
unsigned NumHandlers,
|
|
|
|
|
const char *Name) {
|
2016-12-30 06:21:21 -06:00
|
|
|
|
if (ParentPad == nullptr) {
|
2016-12-31 11:01:23 -06:00
|
|
|
|
Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
|
2016-12-30 05:22:11 -06:00
|
|
|
|
ParentPad = wrap(Constant::getNullValue(Ty));
|
|
|
|
|
}
|
2016-12-31 11:01:23 -06:00
|
|
|
|
return wrap(unwrap(B)->CreateCatchSwitch(unwrap(ParentPad), unwrap(BB),
|
2016-12-30 05:22:11 -06:00
|
|
|
|
NumHandlers, Name));
|
2015-10-23 20:18:44 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" void LLVMRustAddHandler(LLVMValueRef CatchSwitchRef,
|
|
|
|
|
LLVMBasicBlockRef Handler) {
|
|
|
|
|
Value *CatchSwitch = unwrap(CatchSwitchRef);
|
|
|
|
|
cast<CatchSwitchInst>(CatchSwitch)->addHandler(unwrap(Handler));
|
2015-10-23 20:18:44 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" OperandBundleDef *LLVMRustBuildOperandBundleDef(const char *Name,
|
|
|
|
|
LLVMValueRef *Inputs,
|
|
|
|
|
unsigned NumInputs) {
|
2015-10-23 20:18:44 -05:00
|
|
|
|
return new OperandBundleDef(Name, makeArrayRef(unwrap(Inputs), NumInputs));
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" void LLVMRustFreeOperandBundleDef(OperandBundleDef *Bundle) {
|
2015-10-23 20:18:44 -05:00
|
|
|
|
delete Bundle;
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-03 17:09:57 -05:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustBuildCall(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
|
2016-12-30 05:22:11 -06:00
|
|
|
|
LLVMValueRef *Args, unsigned NumArgs,
|
2020-03-09 19:00:00 -05:00
|
|
|
|
OperandBundleDef *Bundle) {
|
2020-06-25 20:52:41 -05:00
|
|
|
|
Value *Callee = unwrap(Fn);
|
2021-08-03 17:09:57 -05:00
|
|
|
|
FunctionType *FTy = unwrap<FunctionType>(Ty);
|
2016-12-31 11:01:23 -06:00
|
|
|
|
unsigned Len = Bundle ? 1 : 0;
|
|
|
|
|
ArrayRef<OperandBundleDef> Bundles = makeArrayRef(Bundle, Len);
|
2016-12-30 05:22:11 -06:00
|
|
|
|
return wrap(unwrap(B)->CreateCall(
|
2020-06-25 20:52:41 -05:00
|
|
|
|
FTy, Callee, makeArrayRef(unwrap(Args), NumArgs), Bundles));
|
2015-10-23 20:18:44 -05:00
|
|
|
|
}
|
|
|
|
|
|
2020-07-02 13:27:15 -05:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustGetInstrProfIncrementIntrinsic(LLVMModuleRef M) {
|
2020-06-03 23:19:34 -05:00
|
|
|
|
return wrap(llvm::Intrinsic::getDeclaration(unwrap(M),
|
|
|
|
|
(llvm::Intrinsic::ID)llvm::Intrinsic::instrprof_increment));
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-02 17:38:16 -05:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustBuildMemCpy(LLVMBuilderRef B,
|
|
|
|
|
LLVMValueRef Dst, unsigned DstAlign,
|
|
|
|
|
LLVMValueRef Src, unsigned SrcAlign,
|
|
|
|
|
LLVMValueRef Size, bool IsVolatile) {
|
2019-12-31 07:32:01 -06:00
|
|
|
|
return wrap(unwrap(B)->CreateMemCpy(
|
|
|
|
|
unwrap(Dst), MaybeAlign(DstAlign),
|
|
|
|
|
unwrap(Src), MaybeAlign(SrcAlign),
|
|
|
|
|
unwrap(Size), IsVolatile));
|
2018-11-02 17:38:16 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern "C" LLVMValueRef LLVMRustBuildMemMove(LLVMBuilderRef B,
|
|
|
|
|
LLVMValueRef Dst, unsigned DstAlign,
|
|
|
|
|
LLVMValueRef Src, unsigned SrcAlign,
|
|
|
|
|
LLVMValueRef Size, bool IsVolatile) {
|
2019-12-31 07:32:01 -06:00
|
|
|
|
return wrap(unwrap(B)->CreateMemMove(
|
|
|
|
|
unwrap(Dst), MaybeAlign(DstAlign),
|
|
|
|
|
unwrap(Src), MaybeAlign(SrcAlign),
|
|
|
|
|
unwrap(Size), IsVolatile));
|
2018-11-02 17:38:16 -05:00
|
|
|
|
}
|
|
|
|
|
|
2020-01-05 15:32:15 -06:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustBuildMemSet(LLVMBuilderRef B,
|
|
|
|
|
LLVMValueRef Dst, unsigned DstAlign,
|
|
|
|
|
LLVMValueRef Val,
|
|
|
|
|
LLVMValueRef Size, bool IsVolatile) {
|
2020-03-02 15:37:55 -06:00
|
|
|
|
return wrap(unwrap(B)->CreateMemSet(
|
|
|
|
|
unwrap(Dst), unwrap(Val), unwrap(Size), MaybeAlign(DstAlign), IsVolatile));
|
2020-01-05 15:32:15 -06:00
|
|
|
|
}
|
|
|
|
|
|
2015-10-23 20:18:44 -05:00
|
|
|
|
extern "C" LLVMValueRef
|
2021-08-03 17:09:57 -05:00
|
|
|
|
LLVMRustBuildInvoke(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
|
|
|
|
|
LLVMValueRef *Args, unsigned NumArgs,
|
|
|
|
|
LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
|
|
|
|
|
OperandBundleDef *Bundle, const char *Name) {
|
2020-06-25 20:52:41 -05:00
|
|
|
|
Value *Callee = unwrap(Fn);
|
2021-08-03 17:09:57 -05:00
|
|
|
|
FunctionType *FTy = unwrap<FunctionType>(Ty);
|
2016-12-31 11:01:23 -06:00
|
|
|
|
unsigned Len = Bundle ? 1 : 0;
|
|
|
|
|
ArrayRef<OperandBundleDef> Bundles = makeArrayRef(Bundle, Len);
|
2020-06-25 20:52:41 -05:00
|
|
|
|
return wrap(unwrap(B)->CreateInvoke(FTy, Callee, unwrap(Then), unwrap(Catch),
|
2016-12-30 05:22:11 -06:00
|
|
|
|
makeArrayRef(unwrap(Args), NumArgs),
|
|
|
|
|
Bundles, Name));
|
2015-10-23 20:18:44 -05:00
|
|
|
|
}
|
2016-02-04 11:40:28 -06:00
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" void LLVMRustPositionBuilderAtStart(LLVMBuilderRef B,
|
|
|
|
|
LLVMBasicBlockRef BB) {
|
2016-12-31 11:01:23 -06:00
|
|
|
|
auto Point = unwrap(BB)->getFirstInsertionPt();
|
|
|
|
|
unwrap(B)->SetInsertPoint(unwrap(BB), Point);
|
2016-02-04 11:40:28 -06:00
|
|
|
|
}
|
2016-03-28 10:57:31 -05:00
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" void LLVMRustSetComdat(LLVMModuleRef M, LLVMValueRef V,
|
2019-12-04 14:00:28 -06:00
|
|
|
|
const char *Name, size_t NameLen) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
Triple TargetTriple(unwrap(M)->getTargetTriple());
|
|
|
|
|
GlobalObject *GV = unwrap<GlobalObject>(V);
|
2020-11-23 14:56:07 -06:00
|
|
|
|
if (TargetTriple.supportsCOMDAT()) {
|
2019-12-04 14:00:28 -06:00
|
|
|
|
StringRef NameRef(Name, NameLen);
|
|
|
|
|
GV->setComdat(unwrap(M)->getOrInsertComdat(NameRef));
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-03-28 10:57:31 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern "C" void LLVMRustUnsetComdat(LLVMValueRef V) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
GlobalObject *GV = unwrap<GlobalObject>(V);
|
|
|
|
|
GV->setComdat(nullptr);
|
2016-03-28 10:57:31 -05:00
|
|
|
|
}
|
2016-09-01 13:52:33 -05:00
|
|
|
|
|
|
|
|
|
enum class LLVMRustLinkage {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
ExternalLinkage = 0,
|
|
|
|
|
AvailableExternallyLinkage = 1,
|
|
|
|
|
LinkOnceAnyLinkage = 2,
|
|
|
|
|
LinkOnceODRLinkage = 3,
|
|
|
|
|
WeakAnyLinkage = 4,
|
|
|
|
|
WeakODRLinkage = 5,
|
|
|
|
|
AppendingLinkage = 6,
|
|
|
|
|
InternalLinkage = 7,
|
|
|
|
|
PrivateLinkage = 8,
|
|
|
|
|
ExternalWeakLinkage = 9,
|
|
|
|
|
CommonLinkage = 10,
|
2016-09-01 13:52:33 -05:00
|
|
|
|
};
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
static LLVMRustLinkage toRust(LLVMLinkage Linkage) {
|
|
|
|
|
switch (Linkage) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
case LLVMExternalLinkage:
|
|
|
|
|
return LLVMRustLinkage::ExternalLinkage;
|
|
|
|
|
case LLVMAvailableExternallyLinkage:
|
|
|
|
|
return LLVMRustLinkage::AvailableExternallyLinkage;
|
|
|
|
|
case LLVMLinkOnceAnyLinkage:
|
|
|
|
|
return LLVMRustLinkage::LinkOnceAnyLinkage;
|
|
|
|
|
case LLVMLinkOnceODRLinkage:
|
|
|
|
|
return LLVMRustLinkage::LinkOnceODRLinkage;
|
|
|
|
|
case LLVMWeakAnyLinkage:
|
|
|
|
|
return LLVMRustLinkage::WeakAnyLinkage;
|
|
|
|
|
case LLVMWeakODRLinkage:
|
|
|
|
|
return LLVMRustLinkage::WeakODRLinkage;
|
|
|
|
|
case LLVMAppendingLinkage:
|
|
|
|
|
return LLVMRustLinkage::AppendingLinkage;
|
|
|
|
|
case LLVMInternalLinkage:
|
|
|
|
|
return LLVMRustLinkage::InternalLinkage;
|
|
|
|
|
case LLVMPrivateLinkage:
|
|
|
|
|
return LLVMRustLinkage::PrivateLinkage;
|
|
|
|
|
case LLVMExternalWeakLinkage:
|
|
|
|
|
return LLVMRustLinkage::ExternalWeakLinkage;
|
|
|
|
|
case LLVMCommonLinkage:
|
|
|
|
|
return LLVMRustLinkage::CommonLinkage;
|
|
|
|
|
default:
|
2017-11-20 10:47:29 -06:00
|
|
|
|
report_fatal_error("Invalid LLVMRustLinkage value!");
|
2016-12-30 05:22:11 -06:00
|
|
|
|
}
|
2016-09-01 13:52:33 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
static LLVMLinkage fromRust(LLVMRustLinkage Linkage) {
|
|
|
|
|
switch (Linkage) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
case LLVMRustLinkage::ExternalLinkage:
|
|
|
|
|
return LLVMExternalLinkage;
|
|
|
|
|
case LLVMRustLinkage::AvailableExternallyLinkage:
|
|
|
|
|
return LLVMAvailableExternallyLinkage;
|
|
|
|
|
case LLVMRustLinkage::LinkOnceAnyLinkage:
|
|
|
|
|
return LLVMLinkOnceAnyLinkage;
|
|
|
|
|
case LLVMRustLinkage::LinkOnceODRLinkage:
|
|
|
|
|
return LLVMLinkOnceODRLinkage;
|
|
|
|
|
case LLVMRustLinkage::WeakAnyLinkage:
|
|
|
|
|
return LLVMWeakAnyLinkage;
|
|
|
|
|
case LLVMRustLinkage::WeakODRLinkage:
|
|
|
|
|
return LLVMWeakODRLinkage;
|
|
|
|
|
case LLVMRustLinkage::AppendingLinkage:
|
|
|
|
|
return LLVMAppendingLinkage;
|
|
|
|
|
case LLVMRustLinkage::InternalLinkage:
|
|
|
|
|
return LLVMInternalLinkage;
|
|
|
|
|
case LLVMRustLinkage::PrivateLinkage:
|
|
|
|
|
return LLVMPrivateLinkage;
|
|
|
|
|
case LLVMRustLinkage::ExternalWeakLinkage:
|
|
|
|
|
return LLVMExternalWeakLinkage;
|
|
|
|
|
case LLVMRustLinkage::CommonLinkage:
|
|
|
|
|
return LLVMCommonLinkage;
|
|
|
|
|
}
|
2017-11-20 10:47:29 -06:00
|
|
|
|
report_fatal_error("Invalid LLVMRustLinkage value!");
|
2016-09-01 13:52:33 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern "C" LLVMRustLinkage LLVMRustGetLinkage(LLVMValueRef V) {
|
2016-12-31 11:01:23 -06:00
|
|
|
|
return toRust(LLVMGetLinkage(V));
|
2016-09-01 13:52:33 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" void LLVMRustSetLinkage(LLVMValueRef V,
|
|
|
|
|
LLVMRustLinkage RustLinkage) {
|
2016-12-31 11:01:23 -06:00
|
|
|
|
LLVMSetLinkage(V, fromRust(RustLinkage));
|
2016-09-01 13:52:33 -05:00
|
|
|
|
}
|
2016-11-16 16:36:08 -06:00
|
|
|
|
|
2021-07-30 19:00:00 -05:00
|
|
|
|
extern "C" LLVMValueRef LLVMRustConstInBoundsGEP2(LLVMTypeRef Ty,
|
|
|
|
|
LLVMValueRef ConstantVal,
|
|
|
|
|
LLVMValueRef *ConstantIndices,
|
|
|
|
|
unsigned NumIndices) {
|
|
|
|
|
ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
|
|
|
|
|
NumIndices);
|
|
|
|
|
Constant *Val = unwrap<Constant>(ConstantVal);
|
|
|
|
|
return wrap(ConstantExpr::getInBoundsGetElementPtr(unwrap(Ty), Val, IdxList));
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-25 17:32:46 -05:00
|
|
|
|
// Returns true if both high and low were successfully set. Fails in case constant wasn’t any of
|
|
|
|
|
// the common sizes (1, 8, 16, 32, 64, 128 bits)
|
|
|
|
|
extern "C" bool LLVMRustConstInt128Get(LLVMValueRef CV, bool sext, uint64_t *high, uint64_t *low)
|
|
|
|
|
{
|
|
|
|
|
auto C = unwrap<llvm::ConstantInt>(CV);
|
|
|
|
|
if (C->getBitWidth() > 128) { return false; }
|
|
|
|
|
APInt AP;
|
|
|
|
|
if (sext) {
|
|
|
|
|
AP = C->getValue().sextOrSelf(128);
|
|
|
|
|
} else {
|
|
|
|
|
AP = C->getValue().zextOrSelf(128);
|
|
|
|
|
}
|
|
|
|
|
*low = AP.getLoBits(64).getZExtValue();
|
|
|
|
|
*high = AP.getHiBits(64).getZExtValue();
|
|
|
|
|
return true;
|
2016-09-01 13:52:33 -05:00
|
|
|
|
}
|
2016-11-16 16:36:08 -06:00
|
|
|
|
|
2016-11-28 16:44:51 -06:00
|
|
|
|
enum class LLVMRustVisibility {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
Default = 0,
|
|
|
|
|
Hidden = 1,
|
|
|
|
|
Protected = 2,
|
2016-11-28 16:44:51 -06:00
|
|
|
|
};
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
static LLVMRustVisibility toRust(LLVMVisibility Vis) {
|
|
|
|
|
switch (Vis) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
case LLVMDefaultVisibility:
|
|
|
|
|
return LLVMRustVisibility::Default;
|
|
|
|
|
case LLVMHiddenVisibility:
|
|
|
|
|
return LLVMRustVisibility::Hidden;
|
|
|
|
|
case LLVMProtectedVisibility:
|
|
|
|
|
return LLVMRustVisibility::Protected;
|
|
|
|
|
}
|
2017-11-20 10:47:29 -06:00
|
|
|
|
report_fatal_error("Invalid LLVMRustVisibility value!");
|
2016-11-28 16:44:51 -06:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 11:01:23 -06:00
|
|
|
|
static LLVMVisibility fromRust(LLVMRustVisibility Vis) {
|
|
|
|
|
switch (Vis) {
|
2016-12-30 05:22:11 -06:00
|
|
|
|
case LLVMRustVisibility::Default:
|
|
|
|
|
return LLVMDefaultVisibility;
|
|
|
|
|
case LLVMRustVisibility::Hidden:
|
|
|
|
|
return LLVMHiddenVisibility;
|
|
|
|
|
case LLVMRustVisibility::Protected:
|
|
|
|
|
return LLVMProtectedVisibility;
|
|
|
|
|
}
|
2017-11-20 10:47:29 -06:00
|
|
|
|
report_fatal_error("Invalid LLVMRustVisibility value!");
|
2016-11-28 16:44:51 -06:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern "C" LLVMRustVisibility LLVMRustGetVisibility(LLVMValueRef V) {
|
2016-12-31 11:01:23 -06:00
|
|
|
|
return toRust(LLVMGetVisibility(V));
|
2016-11-28 16:44:51 -06:00
|
|
|
|
}
|
|
|
|
|
|
2017-02-10 11:29:39 -06:00
|
|
|
|
// Oh hey, a binding that makes sense for once? (because LLVM’s own do not)
|
|
|
|
|
extern "C" LLVMValueRef LLVMRustBuildIntCast(LLVMBuilderRef B, LLVMValueRef Val,
|
|
|
|
|
LLVMTypeRef DestTy, bool isSigned) {
|
|
|
|
|
return wrap(unwrap(B)->CreateIntCast(unwrap(Val), unwrap(DestTy), isSigned, ""));
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-30 05:22:11 -06:00
|
|
|
|
extern "C" void LLVMRustSetVisibility(LLVMValueRef V,
|
|
|
|
|
LLVMRustVisibility RustVisibility) {
|
2016-12-31 11:01:23 -06:00
|
|
|
|
LLVMSetVisibility(V, fromRust(RustVisibility));
|
2016-11-28 16:44:51 -06:00
|
|
|
|
}
|
2017-07-23 10:14:38 -05:00
|
|
|
|
|
2021-03-27 17:11:24 -05:00
|
|
|
|
extern "C" void LLVMRustSetDSOLocal(LLVMValueRef Global, bool is_dso_local) {
|
|
|
|
|
unwrap<GlobalValue>(Global)->setDSOLocal(is_dso_local);
|
|
|
|
|
}
|
|
|
|
|
|
2017-07-23 10:14:38 -05:00
|
|
|
|
struct LLVMRustModuleBuffer {
|
|
|
|
|
std::string data;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
extern "C" LLVMRustModuleBuffer*
|
|
|
|
|
LLVMRustModuleBufferCreate(LLVMModuleRef M) {
|
2019-12-31 07:08:25 -06:00
|
|
|
|
auto Ret = std::make_unique<LLVMRustModuleBuffer>();
|
2017-07-23 10:14:38 -05:00
|
|
|
|
{
|
|
|
|
|
raw_string_ostream OS(Ret->data);
|
|
|
|
|
{
|
|
|
|
|
legacy::PassManager PM;
|
|
|
|
|
PM.add(createBitcodeWriterPass(OS));
|
|
|
|
|
PM.run(*unwrap(M));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return Ret.release();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern "C" void
|
|
|
|
|
LLVMRustModuleBufferFree(LLVMRustModuleBuffer *Buffer) {
|
|
|
|
|
delete Buffer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern "C" const void*
|
|
|
|
|
LLVMRustModuleBufferPtr(const LLVMRustModuleBuffer *Buffer) {
|
|
|
|
|
return Buffer->data.data();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern "C" size_t
|
|
|
|
|
LLVMRustModuleBufferLen(const LLVMRustModuleBuffer *Buffer) {
|
|
|
|
|
return Buffer->data.length();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern "C" uint64_t
|
|
|
|
|
LLVMRustModuleCost(LLVMModuleRef M) {
|
2017-12-08 04:23:23 -06:00
|
|
|
|
auto f = unwrap(M)->functions();
|
|
|
|
|
return std::distance(std::begin(f), std::end(f));
|
2017-07-23 10:14:38 -05:00
|
|
|
|
}
|
2018-03-13 10:46:55 -05:00
|
|
|
|
|
|
|
|
|
// Vector reductions:
|
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildVectorReduceFAdd(LLVMBuilderRef B, LLVMValueRef Acc, LLVMValueRef Src) {
|
|
|
|
|
return wrap(unwrap(B)->CreateFAddReduce(unwrap(Acc),unwrap(Src)));
|
|
|
|
|
}
|
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildVectorReduceFMul(LLVMBuilderRef B, LLVMValueRef Acc, LLVMValueRef Src) {
|
|
|
|
|
return wrap(unwrap(B)->CreateFMulReduce(unwrap(Acc),unwrap(Src)));
|
|
|
|
|
}
|
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildVectorReduceAdd(LLVMBuilderRef B, LLVMValueRef Src) {
|
|
|
|
|
return wrap(unwrap(B)->CreateAddReduce(unwrap(Src)));
|
|
|
|
|
}
|
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildVectorReduceMul(LLVMBuilderRef B, LLVMValueRef Src) {
|
|
|
|
|
return wrap(unwrap(B)->CreateMulReduce(unwrap(Src)));
|
|
|
|
|
}
|
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildVectorReduceAnd(LLVMBuilderRef B, LLVMValueRef Src) {
|
|
|
|
|
return wrap(unwrap(B)->CreateAndReduce(unwrap(Src)));
|
|
|
|
|
}
|
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildVectorReduceOr(LLVMBuilderRef B, LLVMValueRef Src) {
|
|
|
|
|
return wrap(unwrap(B)->CreateOrReduce(unwrap(Src)));
|
|
|
|
|
}
|
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildVectorReduceXor(LLVMBuilderRef B, LLVMValueRef Src) {
|
|
|
|
|
return wrap(unwrap(B)->CreateXorReduce(unwrap(Src)));
|
|
|
|
|
}
|
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildVectorReduceMin(LLVMBuilderRef B, LLVMValueRef Src, bool IsSigned) {
|
|
|
|
|
return wrap(unwrap(B)->CreateIntMinReduce(unwrap(Src), IsSigned));
|
|
|
|
|
}
|
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildVectorReduceMax(LLVMBuilderRef B, LLVMValueRef Src, bool IsSigned) {
|
|
|
|
|
return wrap(unwrap(B)->CreateIntMaxReduce(unwrap(Src), IsSigned));
|
|
|
|
|
}
|
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildVectorReduceFMin(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
|
2020-11-03 15:47:16 -06:00
|
|
|
|
Instruction *I = unwrap(B)->CreateFPMinReduce(unwrap(Src));
|
|
|
|
|
I->setHasNoNaNs(NoNaN);
|
|
|
|
|
return wrap(I);
|
2018-03-13 10:46:55 -05:00
|
|
|
|
}
|
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildVectorReduceFMax(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
|
2020-11-03 15:47:16 -06:00
|
|
|
|
Instruction *I = unwrap(B)->CreateFPMaxReduce(unwrap(Src));
|
|
|
|
|
I->setHasNoNaNs(NoNaN);
|
|
|
|
|
return wrap(I);
|
2018-03-13 10:46:55 -05:00
|
|
|
|
}
|
2018-03-14 16:12:38 -05:00
|
|
|
|
|
2018-03-21 15:49:22 -05:00
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildMinNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) {
|
|
|
|
|
return wrap(unwrap(B)->CreateMinNum(unwrap(LHS),unwrap(RHS)));
|
|
|
|
|
}
|
|
|
|
|
extern "C" LLVMValueRef
|
|
|
|
|
LLVMRustBuildMaxNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) {
|
|
|
|
|
return wrap(unwrap(B)->CreateMaxNum(unwrap(LHS),unwrap(RHS)));
|
|
|
|
|
}
|
2021-03-08 14:42:54 -06:00
|
|
|
|
|
|
|
|
|
// This struct contains all necessary info about a symbol exported from a DLL.
|
|
|
|
|
struct LLVMRustCOFFShortExport {
|
|
|
|
|
const char* name;
|
2021-09-10 19:34:09 -05:00
|
|
|
|
bool ordinal_present;
|
|
|
|
|
// The value of `ordinal` is only meaningful if `ordinal_present` is true.
|
|
|
|
|
uint16_t ordinal;
|
2021-03-08 14:42:54 -06:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Machine must be a COFF machine type, as defined in PE specs.
|
|
|
|
|
extern "C" LLVMRustResult LLVMRustWriteImportLibrary(
|
|
|
|
|
const char* ImportName,
|
|
|
|
|
const char* Path,
|
|
|
|
|
const LLVMRustCOFFShortExport* Exports,
|
|
|
|
|
size_t NumExports,
|
|
|
|
|
uint16_t Machine,
|
|
|
|
|
bool MinGW)
|
|
|
|
|
{
|
|
|
|
|
std::vector<llvm::object::COFFShortExport> ConvertedExports;
|
|
|
|
|
ConvertedExports.reserve(NumExports);
|
|
|
|
|
|
|
|
|
|
for (size_t i = 0; i < NumExports; ++i) {
|
2021-09-10 19:34:09 -05:00
|
|
|
|
bool ordinal_present = Exports[i].ordinal_present;
|
|
|
|
|
uint16_t ordinal = ordinal_present ? Exports[i].ordinal : 0;
|
2021-03-08 14:42:54 -06:00
|
|
|
|
ConvertedExports.push_back(llvm::object::COFFShortExport{
|
|
|
|
|
Exports[i].name, // Name
|
|
|
|
|
std::string{}, // ExtName
|
|
|
|
|
std::string{}, // SymbolName
|
|
|
|
|
std::string{}, // AliasTarget
|
2021-09-10 19:34:09 -05:00
|
|
|
|
ordinal, // Ordinal
|
|
|
|
|
ordinal_present, // Noname
|
2021-03-08 14:42:54 -06:00
|
|
|
|
false, // Data
|
|
|
|
|
false, // Private
|
|
|
|
|
false // Constant
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
auto Error = llvm::object::writeImportLibrary(
|
|
|
|
|
ImportName,
|
|
|
|
|
Path,
|
|
|
|
|
ConvertedExports,
|
|
|
|
|
static_cast<llvm::COFF::MachineTypes>(Machine),
|
|
|
|
|
MinGW);
|
|
|
|
|
if (Error) {
|
|
|
|
|
std::string errorString;
|
|
|
|
|
llvm::raw_string_ostream stream(errorString);
|
|
|
|
|
stream << Error;
|
|
|
|
|
stream.flush();
|
|
|
|
|
LLVMRustSetLastError(errorString.c_str());
|
|
|
|
|
return LLVMRustResult::Failure;
|
|
|
|
|
} else {
|
|
|
|
|
return LLVMRustResult::Success;
|
|
|
|
|
}
|
|
|
|
|
}
|