mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ab5a2bc731
rust/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1927 lines
67 KiB
C++
Raw Normal View History

Move `rustllvm` into `rustc_llvm`
2020-07-26 12:11:30 -05:00
#include "LLVMWrapper.h"
add missing global metadata
2017-03-16 15:10:04 -05:00
#include "llvm/IR/DebugInfoMetadata.h"
Emit LLVM optimization remarks when enabled with `-Cremark` The default diagnostic handler considers all remarks to be disabled by default unless configured otherwise through LLVM internal flags: `-pass-remarks`, `-pass-remarks-missed`, and `-pass-remarks-analysis`. This behaviour makes `-Cremark` ineffective on its own. Fix this by configuring a custom diagnostic handler that enables optimization remarks based on the value of `-Cremark` option. With `-Cremark=all` enabling all remarks.
2021-11-11 18:00:00 -06:00
#include "llvm/IR/DiagnosticHandler.h"
Add -C remark for LLVM optimization remarks Fixes #17116.
2014-09-12 10:17:58 -05:00
#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/IR/DiagnosticPrinter.h"
Make globals with private linkage unnamed. Fixes #50862.
2018-05-23 14:19:07 -05:00
#include "llvm/IR/GlobalVariable.h"
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
#include "llvm/IR/Instructions.h"
[WIP] injects llvm intrinsic instrprof.increment for coverage reports This initial version only injects counters at the top of each function. Rust Coverage will require injecting additional counters at each conditional code branch.
2020-06-03 23:19:34 -05:00
#include "llvm/IR/Intrinsics.h"
Add elementtype attributes for llvm.arm.ldrex/strex intrinsics These intrinsics (and a few more, but there are the only ones exposed by stdarch) require an elementtype attribute in LLVM 15.
2022-07-19 08:03:39 -05:00
#include "llvm/IR/IntrinsicsARM.h"
Add missing include
2022-04-19 07:55:24 -05:00
#include "llvm/IR/Mangler.h"
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
#include "llvm/Object/Archive.h"
Add first cut of functionality for #58713: support for #[link(kind = "raw-dylib")]. This does not yet support #[link_name] attributes on functions, the #[link_ordinal] attribute, #[link(kind = "raw-dylib")] on extern blocks in bin crates, or stdcall functions on 32-bit x86.
2021-03-08 14:42:54 -06:00
#include "llvm/Object/COFFImportFile.h"
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
#include "llvm/Object/ObjectFile.h"
RustWrapper: add missing include This is required after LLVM change 3c4410dfcaaf (aka https://reviews.llvm.org/D121168) did some includes cleanup.
2022-03-10 10:16:33 -06:00
#include "llvm/Pass.h"
Never use legacy PM for writing bitcode
2022-09-18 13:53:38 -05:00
#include "llvm/Bitcode/BitcodeWriter.h"
exit with status code 101 on fatal LLVM error Fixes #54992.
2018-10-12 14:35:55 -05:00
#include "llvm/Support/Signals.h"
rustllvm: adjust usage of createPointerType
2017-07-21 06:26:41 -05:00
#include "llvm/ADT/Optional.h"
exit with status code 101 on fatal LLVM error Fixes #54992.
2018-10-12 14:35:55 -05:00
#include <iostream>
Get 'make tidy' to work rustllvm and rt again
2011-10-21 19:35:52 -05:00
//===----------------------------------------------------------------------===
rustc: Add support for LLVM memory buffer creation via a wrapper function
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.
//
Get 'make tidy' to work rustllvm and rt again
2011-10-21 19:35:52 -05:00
//===----------------------------------------------------------------------===
rustc: Add support for LLVM memory buffer creation via a wrapper function
2011-03-15 16:57:26 -05:00
Add a -S option for producing assembly. I will move more of it to rust once the necessary APIs are available in C.
2011-04-15 16:35:46 -05:00
using namespace llvm;
jit: Separate JIT execution into two functions and load crates before main lookup
2012-09-11 01:05:51 -05:00
using namespace llvm::sys;
rustc: Optimize reading metadata by 4x We were previously reading metadata via `ar p`, but as learned from rustdoc awhile back, spawning a process to do something is pretty slow. Turns out LLVM has an Archive class to read archives, but it cannot write archives. This commits adds bindings to the read-only version of the LLVM archive class (with a new type that only has a read() method), and then it uses this class when reading the metadata out of rlibs. When you put this in tandem of not compressing the metadata, reading the metadata is 4x faster than it used to be The timings I got for reading metadata from the respective libraries was: libstd-04ff901e-0.9-pre.dylib => 100ms libstd-04ff901e-0.9-pre.rlib => 23ms librustuv-7945354c-0.9-pre.dylib => 4ms librustuv-7945354c-0.9-pre.rlib => 1ms librustc-5b94a16f-0.9-pre.dylib => 87ms librustc-5b94a16f-0.9-pre.rlib => 35ms libextra-a6ebb16f-0.9-pre.dylib => 63ms libextra-a6ebb16f-0.9-pre.rlib => 15ms libsyntax-2e4c0458-0.9-pre.dylib => 86ms libsyntax-2e4c0458-0.9-pre.rlib => 22ms In order to always take advantage of these faster metadata read-times, I sort the files in filesearch based on whether they have an rlib extension or not (prefer all rlib files first). Overall, this halved the compile time for a `fn main() {}` crate from 0.185s to 0.095s on my system (when preferring dynamic linking). Reading metadata is still the slowest pass of the compiler at 0.035s, but it's getting pretty close to linking at 0.021s! The next best optimization is to just not copy the metadata from LLVM because that's the most expensive part of reading metadata right now.
2013-12-16 22:58:21 -06:00
using namespace llvm::object;
Add a -S option for producing assembly. I will move more of it to rust once the necessary APIs are available in C.
2011-04-15 16:35:46 -05:00
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
// LLVMAtomicOrdering is already an enum - don't create another
// one.
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
static AtomicOrdering fromRust(LLVMAtomicOrdering Ordering) {
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
switch (Ordering) {
Ran clang-format on src/rustllvm with llvm as the coding style.
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;
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
}
[rustllvm] Use report_fatal_error over llvm_unreachable This makes it more robust when assertions are disabled, crashing instead of causing UB. Also introduces a tidy check to enforce this rule, which in turn necessitated making tidy run on src/rustllvm. Fixes #44020
2017-11-20 10:47:29 -06:00
report_fatal_error("Invalid LLVMAtomicOrdering value!");
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
}
Band-aid fix to stop race conditions in llvm errors This is a big hammer, but should be effective at completely removing a few issues, including inconsistent error messages and segfaults when LLVM workers race to report results LLVM_THREAD_LOCAL has been present in LLVM since 8 months before 3.7 (the earliest supported LLVM version that Rust can use) Maybe fixes #43402 (third time lucky?)
2017-10-10 07:11:28 -05:00
static LLVM_THREAD_LOCAL char *LastError;
rustllvm: Only initialize command-line arguments once In my WIP on rustpkg, I was calling driver code that calls LLVMRustWriteOutputFile more than once. This was making LLVM unhappy, since that function has code that initializes the command-line options for LLVM, and I guess you can't do that more than once. So, check if they've already been initialized.
2013-04-05 19:17:49 -05:00
exit with status code 101 on fatal LLVM error Fixes #54992.
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,
RustWrapper: adapt for LLVM API change of fatal_error_handler_t No functional changes intended. The LLVM commit https://github.com/llvm/llvm-project/commit/e463b69736da8b0a950ecd937cf990401bdfcdeb changed an argument of fatal_error_handler_t from std::string to char*. This adapts RustWrapper accordingly.
2021-10-05 09:31:36 -05:00
#if LLVM_VERSION_LT(14, 0)
exit with status code 101 on fatal LLVM error Fixes #54992.
2018-10-12 14:35:55 -05:00
const std::string& Reason,
RustWrapper: adapt for LLVM API change of fatal_error_handler_t No functional changes intended. The LLVM commit https://github.com/llvm/llvm-project/commit/e463b69736da8b0a950ecd937cf990401bdfcdeb changed an argument of fatal_error_handler_t from std::string to char*. This adapts RustWrapper accordingly.
2021-10-05 09:31:36 -05:00
#else
const char* Reason,
#endif
exit with status code 101 on fatal LLVM error Fixes #54992.
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);
}
Windows: Disable LLVM crash dialog boxes.
2022-01-27 18:53:17 -06:00
extern "C" void LLVMRustDisableSystemDialogsOnCrash() {
sys::DisableSystemDialogsOnCrash();
}
rustc: Fix passing errors from LLVM to rustc Many of the instances of setting a global error variable ended up leaving a dangling pointer into free'd memory. This changes the method of error transmission to strdup any error and "relinquish ownership" to rustc when it gets an error. The corresponding Rust code will then free the error as necessary. Closes #12865
2014-04-15 09:25:22 -05:00
extern "C" char *LLVMRustGetLastError(void) {
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
char *Ret = LastError;
Switching from NULL to nullptr in src/rustllvm.
2016-12-30 06:21:21 -06:00
LastError = nullptr;
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
return Ret;
rustc: Fix passing errors from LLVM to rustc Many of the instances of setting a global error variable ended up leaving a dangling pointer into free'd memory. This changes the method of error transmission to strdup any error and "relinquish ownership" to rustc when it gets an error. The corresponding Rust code will then free the error as necessary. Closes #12865
2014-04-15 09:25:22 -05:00
}
Use name-discarding LLVM context This is only applicable when neither of --emit=llvm-ir or --emit=llvm-bc are not requested. In case either of these outputs are wanted, but the benefits of such context are desired as well, -Zfewer_names option provides the same functionality regardless of the outputs requested.
2018-01-04 14:19:23 -06:00
extern "C" void LLVMRustSetLastError(const char *Err) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
free((void *)LastError);
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
LastError = strdup(Err);
rustc: Add support for LLVM memory buffer creation via a wrapper function
2011-03-15 16:57:26 -05:00
}
Use name-discarding LLVM context This is only applicable when neither of --emit=llvm-ir or --emit=llvm-bc are not requested. In case either of these outputs are wanted, but the benefits of such context are desired as well, -Zfewer_names option provides the same functionality regardless of the outputs requested.
2018-01-04 14:19:23 -06:00
extern "C" LLVMContextRef LLVMRustContextCreate(bool shouldDiscardNames) {
auto ctx = new LLVMContext();
ctx->setDiscardValueNames(shouldDiscardNames);
return wrap(ctx);
}
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" void LLVMRustSetNormalizedTarget(LLVMModuleRef M,
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
const char *Triple) {
unwrap(M)->setTargetTriple(Triple::normalize(Triple));
rustc: Add a binding to LLVM's bitcode parser
2011-05-05 13:34:15 -05:00
}
Add --time-llvm-passes.
2011-05-10 18:10:08 -05:00
extern "C" void LLVMRustPrintPassTimings() {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
raw_fd_ostream OS(2, false); // stderr.
Add --time-llvm-passes.
2011-05-10 18:10:08 -05:00
TimerGroup::printAll(OS);
}
rustc: Enable segmented stacks in LLVM when --stack-growth is on
2011-10-31 16:42:17 -05:00
librustc_codegen_llvm: Use slices instead of 0-terminated strings Changed functions: * LLVMRustGetOrInsertFunction * LLVMRustGetNamedValue * LLVMRustBuildCall (removed unused name argument) * LLVMRustInlineAsm * LLVMRustInlineAsmVerify * LLVMRustAppendModuleInlineAsm
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)));
Wrap LLVM’s Module::getNamedValue
2015-02-27 05:37:33 -06:00
}
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
extern "C" LLVMValueRef LLVMRustGetOrInsertFunction(LLVMModuleRef M,
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
const char *Name,
librustc_codegen_llvm: Use slices instead of 0-terminated strings Changed functions: * LLVMRustGetOrInsertFunction * LLVMRustGetNamedValue * LLVMRustBuildCall (removed unused name argument) * LLVMRustInlineAsm * LLVMRustInlineAsmVerify * LLVMRustAppendModuleInlineAsm
2020-03-09 19:00:00 -05:00
size_t NameLen,
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
LLVMTypeRef FunctionTy) {
librustc_codegen_llvm: Use slices instead of 0-terminated strings Changed functions: * LLVMRustGetOrInsertFunction * LLVMRustGetNamedValue * LLVMRustBuildCall (removed unused name argument) * LLVMRustInlineAsm * LLVMRustInlineAsmVerify * LLVMRustAppendModuleInlineAsm
2020-03-09 19:00:00 -05:00
return wrap(unwrap(M)
->getOrInsertFunction(StringRef(Name, NameLen),
unwrap<FunctionType>(FunctionTy))
.getCallee()
);
rustllvm: Add a GetOrInsertFunction wrapper Fixes issue #1161 Test-case-by: Brian Anderson <banderson@mozilla.com> Signed-off-by: Haitao Li <lihaitao@gmail.com>
2011-11-14 10:32:31 -06:00
}
Generate basic debug info for files, functions and compile units.
2011-11-09 23:55:09 -06:00
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" LLVMValueRef
Migrate to LLVM{Get,Set}ValueName2 The deprecated `LLVM{Get,Set}ValueName` only work with NUL-terminated strings, but the `2` variants use explicit lengths, which fits better with Rust strings and slices. We now use these in new helper functions `llvm::{get,set}_value_name` that convert to/from `&[u8]`.
2019-12-04 14:00:28 -06:00
LLVMRustGetOrInsertGlobal(LLVMModuleRef M, const char *Name, size_t NameLen, LLVMTypeRef Ty) {
Make `LLVMRustGetOrInsertGlobal` always return a `GlobalVariable` `Module::getOrInsertGlobal` returns a `Constant*`, which is a super class of `GlobalVariable`, but if the given type doesn't match an existing declaration, it returns a bitcast of that global instead. This causes UB when we pass that to `LLVMGetVisibility` which unconditionally casts the opaque argument to a `GlobalValue*`. Instead, we can do our own get-or-insert without worrying whether existing types match exactly. It's not relevant when we're just trying to get/set the linkage and visibility, and if types are needed we can bitcast or error nicely from `rustc_codegen_llvm` instead.
2021-11-19 21:33:29 -06:00
Module *Mod = unwrap(M);
Migrate to LLVM{Get,Set}ValueName2 The deprecated `LLVM{Get,Set}ValueName` only work with NUL-terminated strings, but the `2` variants use explicit lengths, which fits better with Rust strings and slices. We now use these in new helper functions `llvm::{get,set}_value_name` that convert to/from `&[u8]`.
2019-12-04 14:00:28 -06:00
StringRef NameRef(Name, NameLen);
Make `LLVMRustGetOrInsertGlobal` always return a `GlobalVariable` `Module::getOrInsertGlobal` returns a `Constant*`, which is a super class of `GlobalVariable`, but if the given type doesn't match an existing declaration, it returns a bitcast of that global instead. This causes UB when we pass that to `LLVMGetVisibility` which unconditionally casts the opaque argument to a `GlobalValue*`. Instead, we can do our own get-or-insert without worrying whether existing types match exactly. It's not relevant when we're just trying to get/set the linkage and visibility, and if types are needed we can bitcast or error nicely from `rustc_codegen_llvm` instead.
2021-11-19 21:33:29 -06:00
// We don't use Module::getOrInsertGlobal because that returns a Constant*,
// which may either be the real GlobalVariable*, or a constant bitcast of it
// if our type doesn't match the original declaration. We always want the
// GlobalVariable* so we can access linkage, visibility, etc.
GlobalVariable *GV = Mod->getGlobalVariable(NameRef, true);
if (!GV)
GV = new GlobalVariable(*Mod, unwrap(Ty), false,
GlobalValue::ExternalLinkage, nullptr, NameRef);
return wrap(GV);
Implement LLVMGetOrInsertGlobal wrapper
2015-03-03 16:57:44 -06:00
}
Make globals with private linkage unnamed. Fixes #50862.
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));
}
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
extern "C" LLVMTypeRef LLVMRustMetadataTypeInContext(LLVMContextRef C) {
Generate basic debug info for files, functions and compile units.
2011-11-09 23:55:09 -06:00
return wrap(Type::getMetadataTy(*unwrap(C)));
}
Adding a bunch of atomic intrinsics. Adding a test cases for the atomic intrinsics.
2012-06-21 17:01:32 -05:00
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) {
switch (Kind) {
Ran clang-format on src/rustllvm with llvm as the coding style.
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;
Stop emitting CET prologues for naked functions We can apply nocf_check as a hack for now.
2022-07-06 21:07:52 -05:00
case NoCfCheck:
return Attribute::NoCfCheck;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
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;
sanitizer support
2016-12-29 22:28:11 -06:00
case SanitizeThread:
return Attribute::SanitizeThread;
case SanitizeAddress:
return Attribute::SanitizeAddress;
case SanitizeMemory:
return Attribute::SanitizeMemory;
Support for disabling the PLT on ELF targets Disable the PLT where possible to improve performance for indirect calls into shared libraries. This optimization is enabled by default where possible. - Add the `NonLazyBind` attribute to `rustllvm`: This attribute informs LLVM to skip PLT calls in codegen. - Disable PLT unconditionally: Apply the `NonLazyBind` attribute on every function. - Only enable no-plt when full relro is enabled: Ensures we only enable it when we have linker support. - Add `-Z plt` as a compiler option
2018-09-26 11:19:55 -05:00
case NonLazyBind:
return Attribute::NonLazyBind;
Implement optimize(size) and optimize(speed)
2018-10-27 07:29:06 -05:00
case OptimizeNone:
return Attribute::OptimizeNone;
Implement ffi_returns_twice attribute
2019-02-09 08:55:30 -06:00
case ReturnsTwice:
return Attribute::ReturnsTwice;
Implement asm! codegen
2020-02-17 15:36:01 -06:00
case ReadNone:
return Attribute::ReadNone;
case InaccessibleMemOnly:
return Attribute::InaccessibleMemOnly;
HWASan support
2021-01-22 20:32:38 -06:00
case SanitizeHWAddress:
return Attribute::SanitizeHWAddress;
Mark pure asm as willreturn
2021-02-20 10:02:23 -06:00
case WillReturn:
return Attribute::WillReturn;
add rustc option for using LLVM stack smash protection LLVM has built-in heuristics for adding stack canaries to functions. These heuristics can be selected with LLVM function attributes. This patch adds a rustc option `-Z stack-protector={none,basic,strong,all}` which controls the use of these attributes. This gives rustc the same stack smash protection support as clang offers through options `-fno-stack-protector`, `-fstack-protector`, `-fstack-protector-strong`, and `-fstack-protector-all`. The protection this can offer is demonstrated in test/ui/abi/stack-protector.rs. This fills a gap in the current list of rustc exploit mitigations (https://doc.rust-lang.org/rustc/exploit-mitigations.html), originally discussed in #15179. Stack smash protection adds runtime overhead and is therefore still off by default, but now users have the option to trade performance for security as they see fit. An example use case is adding Rust code in an existing C/C++ code base compiled with stack smash protection. Without the ability to add stack smash protection to the Rust code, the code base artifacts could be exploitable in ways not possible if the code base remained pure C/C++. Stack smash protection support is present in LLVM for almost all the current tier 1/tier 2 targets: see test/assembly/stack-protector/stack-protector-target-support.rs. The one exception is nvptx64-nvidia-cuda. This patch follows clang's example, and adds a warning message printed if stack smash protection is used with this target (see test/ui/stack-protector/warn-stack-protector-unsupported.rs). Support for tier 3 targets has not been checked. Since the heuristics are applied at the LLVM level, the heuristics are expected to add stack smash protection to a fraction of functions comparable to C/C++. Some experiments demonstrating how Rust code is affected by the different heuristics can be found in test/assembly/stack-protector/stack-protector-heuristics-effect.rs. There is potential for better heuristics using Rust-specific safety information. For example it might be reasonable to skip stack smash protection in functions which transitively only use safe Rust code, or which uses only a subset of functions the user declares safe (such as anything under `std.*`). Such alternative heuristics could be added at a later point. LLVM also offers a "safestack" sanitizer as an alternative way to guard against stack smashing (see #26612). This could possibly also be included as a stack-protection heuristic. An alternative is to add it as a sanitizer (#39699). This is what clang does: safestack is exposed with option `-fsanitize=safe-stack`. The options are only supported by the LLVM backend, but as with other codegen options it is visible in the main codegen option help menu. The heuristic names "basic", "strong", and "all" are hopefully sufficiently generic to be usable in other backends as well. Reviewed-by: Nikita Popov <nikic@php.net> Extra commits during review: - [address-review] make the stack-protector option unstable - [address-review] reduce detail level of stack-protector option help text - [address-review] correct grammar in comment - [address-review] use compiler flag to avoid merging functions in test - [address-review] specify min LLVM version in fortanix stack-protector test Only for Fortanix test, since this target specifically requests the `--x86-experimental-lvi-inline-asm-hardening` flag. - [address-review] specify required LLVM components in stack-protector tests - move stack protector option enum closer to other similar option enums - rustc_interface/tests: sort debug option list in tracking hash test - add an explicit `none` stack-protector option Revert "set LLVM requirements for all stack protector support test revisions" This reverts commit a49b74f92a4e7d701d6f6cf63d207a8aff2e0f68.
2021-04-06 14:37:49 -05:00
case StackProtectReq:
return Attribute::StackProtectReq;
case StackProtectStrong:
return Attribute::StackProtectStrong;
case StackProtect:
return Attribute::StackProtect;
Apply noundef attribute to &T, &mut T, Box<T>, bool This doesn't handle `char` because it's a bit awkward to distinguish it from u32 at this point in codegen. Note that for some types (like `&Struct` and `&mut Struct`), we already apply `dereferenceable`, which implies `noundef`, so the IR does not change.
2022-02-05 00:00:37 -06:00
case NoUndef:
return Attribute::NoUndef;
MemTagSanitizer Support Adds support for the LLVM MemTagSanitizer.
2021-12-03 15:11:13 -06:00
case SanitizeMemTag:
return Attribute::SanitizeMemTag;
Add ShadowCallStack Support Adds support for the LLVM ShadowCallStack sanitizer.
2022-06-17 13:14:58 -05:00
case ShadowCallStack:
return Attribute::ShadowCallStack;
codegen: use new {re,de,}allocator annotations in llvm This obviates the patch that teaches LLVM internals about _rust_{re,de}alloc functions by putting annotations directly in the IR for the optimizer. The sole test change is required to anchor FileCheck to the body of the `box_uninitialized` method, so it doesn't see the `allocalign` on `__rust_alloc` and get mad about the string `alloca` showing up. Since I was there anyway, I added some checks on the attributes to prove the right attributes got set. While we're here, we also emit allocator attributes on __rust_alloc_zeroed. This should allow LLVM to perform more optimizations for zeroed blocks, and probably fixes #90032. [This comment](https://github.com/rust-lang/rust/issues/24194#issuecomment-308791157) mentions "weird UB-like behaviour with bitvec iterators in rustc_data_structures" so we may need to back this change out if things go wrong. The new test cases require LLVM 15, so we copy them into LLVM 14-supporting versions, which we can delete when we drop LLVM 14.
2022-03-21 14:30:54 -05:00
case AllocSize:
return Attribute::AllocSize;
#if LLVM_VERSION_GE(15, 0)
case AllocatedPointer:
return Attribute::AllocatedPointer;
case AllocAlign:
return Attribute::AllocAlign;
#endif
Use llvm::Attribute API instead of "raw value" APIs, which will be removed in LLVM 4.0. The librustc_llvm API remains mostly unchanged, except that llvm::Attribute is no longer a bitflag but represents only a *single* attribute. The ability to store many attributes in a small number of bits and modify them without interacting with LLVM is only used in rustc_trans::abi and closely related modules, and only attributes for function arguments are considered there. Thus rustc_trans::abi now has its own bit-packed representation of argument attributes, which are translated to rustc_llvm::Attribute when applying the attributes.
2016-11-16 16:36:08 -06:00
}
[rustllvm] Use report_fatal_error over llvm_unreachable This makes it more robust when assertions are disabled, crashing instead of causing UB. Also introduces a tidy check to enforce this rule, which in turn necessitated making tidy run on src/rustllvm. Fixes #44020
2017-11-20 10:47:29 -06:00
report_fatal_error("bad AttributeKind");
Use llvm::Attribute API instead of "raw value" APIs, which will be removed in LLVM 4.0. The librustc_llvm API remains mostly unchanged, except that llvm::Attribute is no longer a bitflag but represents only a *single* attribute. The ability to store many attributes in a small number of bits and modify them without interacting with LLVM is only used in rustc_trans::abi and closely related modules, and only attributes for function arguments are considered there. Thus rustc_trans::abi now has its own bit-packed representation of argument attributes, which are translated to rustc_llvm::Attribute when applying the attributes.
2016-11-16 16:36:08 -06:00
}
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
template<typename T> static inline void AddAttributes(T *t, unsigned Index,
LLVMAttributeRef *Attrs, size_t AttrsLen) {
AttributeList PAL = t->getAttributes();
AttributeList PALNew;
RustWrapper: avoid deleted unclear attribute methods These were deleted in https://reviews.llvm.org/D108614, and in C++ I definitely see the argument for their removal. I didn't try and propagate the changes up into higher layers of rustc in this change because my initial goal was to get rustc working against LLVM HEAD promptly, but I'm happy to follow up with some refactoring to make the API on the Rust side match the LLVM API more directly (though the way the enum works in Rust makes the API less scary IMO). r? @nagisa cc @nikic
2021-09-07 13:49:03 -05:00
#if LLVM_VERSION_LT(14, 0)
AttrBuilder doesn't take a context in old LLVM
2022-02-26 16:16:01 -06:00
AttrBuilder B;
for (LLVMAttributeRef Attr : makeArrayRef(Attrs, AttrsLen))
B.addAttribute(unwrap(Attr));
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
PALNew = PAL.addAttributes(t->getContext(), Index, B);
RustWrapper: avoid deleted unclear attribute methods These were deleted in https://reviews.llvm.org/D108614, and in C++ I definitely see the argument for their removal. I didn't try and propagate the changes up into higher layers of rustc in this change because my initial goal was to get rustc working against LLVM HEAD promptly, but I'm happy to follow up with some refactoring to make the API on the Rust side match the LLVM API more directly (though the way the enum works in Rust makes the API less scary IMO). r? @nagisa cc @nikic
2021-09-07 13:49:03 -05:00
#else
AttrBuilder doesn't take a context in old LLVM
2022-02-26 16:16:01 -06:00
AttrBuilder B(t->getContext());
for (LLVMAttributeRef Attr : makeArrayRef(Attrs, AttrsLen))
B.addAttribute(unwrap(Attr));
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
PALNew = PAL.addAttributesAtIndex(t->getContext(), Index, B);
RustWrapper: avoid deleted unclear attribute methods These were deleted in https://reviews.llvm.org/D108614, and in C++ I definitely see the argument for their removal. I didn't try and propagate the changes up into higher layers of rustc in this change because my initial goal was to get rustc working against LLVM HEAD promptly, but I'm happy to follow up with some refactoring to make the API on the Rust side match the LLVM API more directly (though the way the enum works in Rust makes the API less scary IMO). r? @nagisa cc @nikic
2021-09-07 13:49:03 -05:00
#endif
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
t->setAttributes(PALNew);
RustWrapper: avoid deleted unclear attribute methods These were deleted in https://reviews.llvm.org/D108614, and in C++ I definitely see the argument for their removal. I didn't try and propagate the changes up into higher layers of rustc in this change because my initial goal was to get rustc working against LLVM HEAD promptly, but I'm happy to follow up with some refactoring to make the API on the Rust side match the LLVM API more directly (though the way the enum works in Rust makes the API less scary IMO). r? @nagisa cc @nikic
2021-09-07 13:49:03 -05:00
}
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
extern "C" void LLVMRustAddFunctionAttributes(LLVMValueRef Fn, unsigned Index,
LLVMAttributeRef *Attrs, size_t AttrsLen) {
Function *F = unwrap<Function>(Fn);
AddAttributes(F, Index, Attrs, AttrsLen);
rustc_trans: compute better align/dereferenceable attributes from pointees.
2017-10-03 02:45:07 -05:00
}
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
extern "C" void LLVMRustAddCallSiteAttributes(LLVMValueRef Instr, unsigned Index,
LLVMAttributeRef *Attrs, size_t AttrsLen) {
Prepare for LLVM 11
2020-06-25 20:52:41 -05:00
CallBase *Call = unwrap<CallBase>(Instr);
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
AddAttributes(Call, Index, Attrs, AttrsLen);
Pass type to byval attributes
2019-07-06 14:52:25 -05:00
}
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
extern "C" LLVMAttributeRef LLVMRustCreateAttrNoValue(LLVMContextRef C,
LLVMRustAttribute RustAttr) {
return wrap(Attribute::get(*unwrap(C), fromRust(RustAttr)));
Support LLVM 12 in rustc
2020-11-03 15:47:16 -06:00
}
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
extern "C" LLVMAttributeRef LLVMRustCreateAlignmentAttr(LLVMContextRef C,
uint64_t Bytes) {
return wrap(Attribute::getWithAlignment(*unwrap(C), llvm::Align(Bytes)));
rustc_trans: compute better align/dereferenceable attributes from pointees.
2017-10-03 02:45:07 -05:00
}
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
extern "C" LLVMAttributeRef LLVMRustCreateDereferenceableAttr(LLVMContextRef C,
uint64_t Bytes) {
return wrap(Attribute::getWithDereferenceableBytes(*unwrap(C), Bytes));
librustc: Use builder for llvm attributes.
2014-07-25 18:06:44 -05:00
}
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
extern "C" LLVMAttributeRef LLVMRustCreateDereferenceableOrNullAttr(LLVMContextRef C,
uint64_t Bytes) {
return wrap(Attribute::getWithDereferenceableOrNullBytes(*unwrap(C), Bytes));
rustc_trans: compute better align/dereferenceable attributes from pointees.
2017-10-03 02:45:07 -05:00
}
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
extern "C" LLVMAttributeRef LLVMRustCreateByValAttr(LLVMContextRef C, LLVMTypeRef Ty) {
return wrap(Attribute::getWithByValType(*unwrap(C), unwrap(Ty)));
Pass type to byval attributes
2019-07-06 14:52:25 -05:00
}
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
extern "C" LLVMAttributeRef LLVMRustCreateStructRetAttr(LLVMContextRef C, LLVMTypeRef Ty) {
return wrap(Attribute::getWithStructRetType(*unwrap(C), unwrap(Ty)));
Support LLVM 12 in rustc
2020-11-03 15:47:16 -06:00
}
Add elementtype attributes for llvm.arm.ldrex/strex intrinsics These intrinsics (and a few more, but there are the only ones exposed by stdarch) require an elementtype attribute in LLVM 15.
2022-07-19 08:03:39 -05:00
extern "C" LLVMAttributeRef LLVMRustCreateElementTypeAttr(LLVMContextRef C, LLVMTypeRef Ty) {
#if LLVM_VERSION_GE(15, 0)
return wrap(Attribute::get(*unwrap(C), Attribute::ElementType, unwrap(Ty)));
#else
report_fatal_error("Should not be needed on LLVM < 15");
#endif
}
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
extern "C" LLVMAttributeRef LLVMRustCreateUWTableAttr(LLVMContextRef C, bool Async) {
llvm: migrate to new parameter-bearing uwtable attr In https://reviews.llvm.org/D114543 the uwtable attribute gained a flag so that we can ask for sync uwtables instead of async, as the former are much cheaper. The default is async, so that's what I've done here, but I left a TODO that we might be able to do better. While in here I went ahead and dropped support for removing uwtable attributes in rustc: we never did it, so I didn't write the extra C++ bridge code to make it work. Maybe I should have done the same thing with the `sync|async` parameter but we'll see.
2022-02-14 13:01:19 -06:00
#if LLVM_VERSION_LT(15, 0)
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
return wrap(Attribute::get(*unwrap(C), Attribute::UWTable));
RustWrapper: avoid deleted unclear attribute methods These were deleted in https://reviews.llvm.org/D108614, and in C++ I definitely see the argument for their removal. I didn't try and propagate the changes up into higher layers of rustc in this change because my initial goal was to get rustc working against LLVM HEAD promptly, but I'm happy to follow up with some refactoring to make the API on the Rust side match the LLVM API more directly (though the way the enum works in Rust makes the API less scary IMO). r? @nagisa cc @nikic
2021-09-07 13:49:03 -05:00
#else
Add LLVM attributes in batches instead of individually This should improve performance.
2022-02-21 10:19:16 -06:00
return wrap(Attribute::getWithUWTableKind(
*unwrap(C), Async ? UWTableKind::Async : UWTableKind::Sync));
RustWrapper: avoid deleted unclear attribute methods These were deleted in https://reviews.llvm.org/D108614, and in C++ I definitely see the argument for their removal. I didn't try and propagate the changes up into higher layers of rustc in this change because my initial goal was to get rustc working against LLVM HEAD promptly, but I'm happy to follow up with some refactoring to make the API on the Rust side match the LLVM API more directly (though the way the enum works in Rust makes the API less scary IMO). r? @nagisa cc @nikic
2021-09-07 13:49:03 -05:00
#endif
rustc: Ensure closures are "split-stack" In upgrading LLVM, only rust functions had the "split-stack" attribute added. This commit changes the addition of LLVM's "split-stack" attribute to *always* occur and then we remove it sometimes if the "no_split_stack" rust attribute is present. Closes #13625
2014-04-19 12:33:46 -05:00
}
add `noalias` attribute to ~ return values
2013-09-09 01:32:30 -05:00
codegen: use new {re,de,}allocator annotations in llvm This obviates the patch that teaches LLVM internals about _rust_{re,de}alloc functions by putting annotations directly in the IR for the optimizer. The sole test change is required to anchor FileCheck to the body of the `box_uninitialized` method, so it doesn't see the `allocalign` on `__rust_alloc` and get mad about the string `alloca` showing up. Since I was there anyway, I added some checks on the attributes to prove the right attributes got set. While we're here, we also emit allocator attributes on __rust_alloc_zeroed. This should allow LLVM to perform more optimizations for zeroed blocks, and probably fixes #90032. [This comment](https://github.com/rust-lang/rust/issues/24194#issuecomment-308791157) mentions "weird UB-like behaviour with bitvec iterators in rustc_data_structures" so we may need to back this change out if things go wrong. The new test cases require LLVM 15, so we copy them into LLVM 14-supporting versions, which we can delete when we drop LLVM 14.
2022-03-21 14:30:54 -05:00
extern "C" LLVMAttributeRef LLVMRustCreateAllocSizeAttr(LLVMContextRef C, uint32_t ElementSizeArg) {
return wrap(Attribute::getWithAllocSizeArgs(*unwrap(C), ElementSizeArg, None));
}
#if LLVM_VERSION_GE(15, 0)
// These values **must** match ffi::AllocKindFlags.
// It _happens_ to match the LLVM values of llvm::AllocFnKind,
// but that's happenstance and we do explicit conversions before
// passing them to LLVM.
enum class LLVMRustAllocKindFlags : uint64_t {
Unknown = 0,
Alloc = 1,
Realloc = 1 << 1,
Free = 1 << 2,
Uninitialized = 1 << 3,
Zeroed = 1 << 4,
Aligned = 1 << 5,
};
static LLVMRustAllocKindFlags operator&(LLVMRustAllocKindFlags A, LLVMRustAllocKindFlags B) {
return static_cast<LLVMRustAllocKindFlags>(static_cast<uint64_t>(A) &
static_cast<uint64_t>(B));
}
static bool isSet(LLVMRustAllocKindFlags F) { return F != LLVMRustAllocKindFlags::Unknown; }
static llvm::AllocFnKind allocKindFromRust(LLVMRustAllocKindFlags F) {
llvm::AllocFnKind AFK = llvm::AllocFnKind::Unknown;
if (isSet(F & LLVMRustAllocKindFlags::Alloc)) {
AFK |= llvm::AllocFnKind::Alloc;
}
if (isSet(F & LLVMRustAllocKindFlags::Realloc)) {
AFK |= llvm::AllocFnKind::Realloc;
}
if (isSet(F & LLVMRustAllocKindFlags::Free)) {
AFK |= llvm::AllocFnKind::Free;
}
if (isSet(F & LLVMRustAllocKindFlags::Uninitialized)) {
AFK |= llvm::AllocFnKind::Uninitialized;
}
if (isSet(F & LLVMRustAllocKindFlags::Zeroed)) {
AFK |= llvm::AllocFnKind::Zeroed;
}
if (isSet(F & LLVMRustAllocKindFlags::Aligned)) {
AFK |= llvm::AllocFnKind::Aligned;
}
return AFK;
}
#endif
extern "C" LLVMAttributeRef LLVMRustCreateAllocKindAttr(LLVMContextRef C, uint64_t AllocKindArg) {
#if LLVM_VERSION_GE(15, 0)
return wrap(Attribute::get(*unwrap(C), Attribute::AllocKind,
static_cast<uint64_t>(allocKindFromRust(static_cast<LLVMRustAllocKindFlags>(AllocKindArg)))));
#else
report_fatal_error(
"allockind attributes are new in LLVM 15 and should not be used on older LLVMs");
#endif
}
Don't set `fast`(-math) for certain simd ops `fast-math` implies things like functions not being able to accept as an argument or return as a result, say, `inf` which made these functions confusingly named or behaving incorrectly, depending on how you interpret it. Since the time when these intrinsics have been implemented the intrinsics user's (stdsimd) approach has changed significantly and so now it is required that these intrinsics operate normally rather than in "whatever" way. Fixes #84268
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) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
if (auto I = dyn_cast<Instruction>(unwrap<Value>(V))) {
llvm6: Tweak fast math intrinsics Looks like they did some refactoring of flags in the backend and this should catch us up! The "unsafe algebra" boolean has been split into a number of boolean flags for various operations, and this updates to use the `setFast` function which should hopefully have the same behavior as before. This was updated in llvm-mirror/llvm@00e900afd
2018-01-22 19:28:23 -06:00
I->setFast(true);
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Add intrinsics for float arithmetic with `fast` flag enabled `fast` a.k.a UnsafeAlgebra is the flag for enabling all "unsafe" (according to llvm) float optimizations. See LangRef for more information http://llvm.org/docs/LangRef.html#fast-math-flags Providing these operations with less precise associativity rules (for example) is useful to numerical applications. For example, the summation loop: let sum = 0.; for element in data { sum += *element; } Using the default floating point semantics, this loop expresses the floats must be added in a sequence, one after another. This constraint is usually completely unintended, and it means that no autovectorization is possible.
2016-03-14 18:01:12 -05:00
}
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" LLVMValueRef
Pass type when creating atomic load Instead of determining it from the pointer type, explicitly pass the type to load.
2021-07-04 10:49:51 -05:00
LLVMRustBuildAtomicLoad(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Source,
const char *Name, LLVMAtomicOrdering Order) {
Prepare for LLVM 11
2020-06-25 20:52:41 -05:00
Value *Ptr = unwrap(Source);
Pass type when creating atomic load Instead of determining it from the pointer type, explicitly pass the type to load.
2021-07-04 10:49:51 -05:00
LoadInst *LI = unwrap(B)->CreateLoad(unwrap(Ty), Ptr, Name);
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
LI->setAtomic(fromRust(Order));
Prepare for LLVM 11
2020-06-25 20:52:41 -05:00
return wrap(LI);
Adds atomic_load, atomic_load_acq, atomic_store, and atomic_store_rel intrinsics. The default versions (atomic_load and atomic_store) are sequentially consistent. The atomic_load_acq intrinsic acquires as described in [1]. The atomic_store_rel intrinsic releases as described in [1]. [1]: http://llvm.org/docs/Atomics.html
2013-05-12 14:22:20 -05:00
}
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
extern "C" LLVMValueRef LLVMRustBuildAtomicStore(LLVMBuilderRef B,
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
LLVMValueRef V,
LLVMValueRef Target,
rustc_trans: avoid working with sizes/offsets and alignments as integers.
2017-06-01 13:50:53 -05:00
LLVMAtomicOrdering Order) {
Prepare for LLVM 11
2020-06-25 20:52:41 -05:00
StoreInst *SI = unwrap(B)->CreateStore(unwrap(V), unwrap(Target));
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
SI->setAtomic(fromRust(Order));
Prepare for LLVM 11
2020-06-25 20:52:41 -05:00
return wrap(SI);
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
finish type-auditing rustllvm
2016-08-02 16:25:19 -05:00
enum class LLVMRustAsmDialect {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
Att,
Intel,
finish type-auditing rustllvm
2016-08-02 16:25:19 -05:00
};
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
static InlineAsm::AsmDialect fromRust(LLVMRustAsmDialect Dialect) {
switch (Dialect) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
case LLVMRustAsmDialect::Att:
return InlineAsm::AD_ATT;
case LLVMRustAsmDialect::Intel:
return InlineAsm::AD_Intel;
default:
[rustllvm] Use report_fatal_error over llvm_unreachable This makes it more robust when assertions are disabled, crashing instead of causing UB. Also introduces a tidy check to enforce this rule, which in turn necessitated making tidy run on src/rustllvm. Fixes #44020
2017-11-20 10:47:29 -06:00
report_fatal_error("bad AsmDialect.");
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
finish type-auditing rustllvm
2016-08-02 16:25:19 -05:00
}
librustc_codegen_llvm: Use slices instead of 0-terminated strings Changed functions: * LLVMRustGetOrInsertFunction * LLVMRustGetNamedValue * LLVMRustBuildCall (removed unused name argument) * LLVMRustInlineAsm * LLVMRustInlineAsmVerify * LLVMRustAppendModuleInlineAsm
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,
Adjust llvm wrapper for unwinding support for inlineasm
2021-08-28 12:02:00 -05:00
LLVMRustAsmDialect Dialect, LLVMBool CanThrow) {
librustc_codegen_llvm: Use slices instead of 0-terminated strings Changed functions: * LLVMRustGetOrInsertFunction * LLVMRustGetNamedValue * LLVMRustBuildCall (removed unused name argument) * LLVMRustInlineAsm * LLVMRustInlineAsmVerify * LLVMRustAppendModuleInlineAsm
2020-03-09 19:00:00 -05:00
return wrap(InlineAsm::get(unwrap<FunctionType>(Ty),
StringRef(AsmString, AsmStringLen),
StringRef(Constraints, ConstraintsLen),
Adjust llvm wrapper for unwinding support for inlineasm
2021-08-28 12:02:00 -05:00
HasSideEffects, IsAlignStack,
fromRust(Dialect), CanThrow));
Parse inline assembly.
2013-03-10 00:37:50 -06:00
}
Revert "Revert "Remove all usage of the global LLVMContextRef"" This reverts commit 541c657a738006d78171aa261125a6a46f283b35.
2013-06-13 23:25:12 -05:00
librustc_codegen_llvm: Use slices instead of 0-terminated strings Changed functions: * LLVMRustGetOrInsertFunction * LLVMRustGetNamedValue * LLVMRustBuildCall (removed unused name argument) * LLVMRustInlineAsm * LLVMRustInlineAsmVerify * LLVMRustAppendModuleInlineAsm
2020-03-09 19:00:00 -05:00
extern "C" bool LLVMRustInlineAsmVerify(LLVMTypeRef Ty, char *Constraints,
size_t ConstraintsLen) {
llvm-wrapper: adapt for LLVM API change
2022-07-12 10:36:28 -05:00
#if LLVM_VERSION_LT(15, 0)
librustc_codegen_llvm: Use slices instead of 0-terminated strings Changed functions: * LLVMRustGetOrInsertFunction * LLVMRustGetNamedValue * LLVMRustBuildCall (removed unused name argument) * LLVMRustInlineAsm * LLVMRustInlineAsmVerify * LLVMRustAppendModuleInlineAsm
2020-03-09 19:00:00 -05:00
return InlineAsm::Verify(unwrap<FunctionType>(Ty),
StringRef(Constraints, ConstraintsLen));
llvm-wrapper: adapt for LLVM API change
2022-07-12 10:36:28 -05:00
#else
// llvm::Error converts to true if it is an error.
return !llvm::errorToBool(InlineAsm::verify(
unwrap<FunctionType>(Ty), StringRef(Constraints, ConstraintsLen)));
#endif
codegen_llvm: check inline assembly constraints with LLVM LLVM provides a way of checking whether the constraints and the actual inline assembly make sense. This commit introduces a check before emitting code for the inline assembly. If LLVM rejects the inline assembly (or its constraints), then the compiler emits an error E0668 ("malformed inline assembly"). Signed-off-by: Levente Kurusa <lkurusa@acm.org>
2018-09-25 13:35:19 -05:00
}
librustc_codegen_llvm: Use slices instead of 0-terminated strings Changed functions: * LLVMRustGetOrInsertFunction * LLVMRustGetNamedValue * LLVMRustBuildCall (removed unused name argument) * LLVMRustInlineAsm * LLVMRustInlineAsmVerify * LLVMRustAppendModuleInlineAsm
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));
Expose LLVM appendModuleInlineAsm
2017-03-21 19:50:23 -05:00
}
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
typedef DIBuilder *LLVMRustDIBuilderRef;
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
template <typename DIT> DIT *unwrapDIPtr(LLVMMetadataRef Ref) {
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
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
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
#define unwrapDI unwrapDIPtr
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
[LLVM] Introduce a stable representation of DIFlags In LLVM 4.0, this enum becomes an actual type-safe enum, which breaks all of the interfaces. Introduce our own copy of the bitflags that we can then safely convert to the LLVM one.
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 {
Ran clang-format on src/rustllvm with llvm as the coding style.
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),
Teach rustc about DW_AT_noreturn and a few more DIFlags
2018-01-20 14:32:33 -06:00
FlagExternalTypeRef = (1 << 15),
FlagIntroducedVirtual = (1 << 18),
FlagBitField = (1 << 19),
FlagNoReturn = (1 << 20),
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
// Do not add values that are not supported by the minimum LLVM
Teach rustc about DW_AT_noreturn and a few more DIFlags
2018-01-20 14:32:33 -06:00
// version we support! see llvm/include/llvm/IR/DebugInfoFlags.def
[LLVM] Introduce a stable representation of DIFlags In LLVM 4.0, this enum becomes an actual type-safe enum, which breaks all of the interfaces. Introduce our own copy of the bitflags that we can then safely convert to the LLVM one.
2016-11-18 16:15:14 -06:00
};
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
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));
[LLVM] Introduce a stable representation of DIFlags In LLVM 4.0, this enum becomes an actual type-safe enum, which breaks all of the interfaces. Introduce our own copy of the bitflags that we can then safely convert to the LLVM one.
2016-11-18 16:15:14 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
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));
[LLVM] Introduce a stable representation of DIFlags In LLVM 4.0, this enum becomes an actual type-safe enum, which breaks all of the interfaces. Introduce our own copy of the bitflags that we can then safely convert to the LLVM one.
2016-11-18 16:15:14 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
inline LLVMRustDIFlags &operator|=(LLVMRustDIFlags &A, LLVMRustDIFlags B) {
return A = A | B;
[LLVM] Introduce a stable representation of DIFlags In LLVM 4.0, this enum becomes an actual type-safe enum, which breaks all of the interfaces. Introduce our own copy of the bitflags that we can then safely convert to the LLVM one.
2016-11-18 16:15:14 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
inline bool isSet(LLVMRustDIFlags F) { return F != LLVMRustDIFlags::FlagZero; }
[LLVM] Introduce a stable representation of DIFlags In LLVM 4.0, this enum becomes an actual type-safe enum, which breaks all of the interfaces. Introduce our own copy of the bitflags that we can then safely convert to the LLVM one.
2016-11-18 16:15:14 -06:00
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
inline LLVMRustDIFlags visibility(LLVMRustDIFlags F) {
return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(F) & 0x3);
[LLVM] Introduce a stable representation of DIFlags In LLVM 4.0, this enum becomes an actual type-safe enum, which breaks all of the interfaces. Introduce our own copy of the bitflags that we can then safely convert to the LLVM one.
2016-11-18 16:15:14 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
static DINode::DIFlags fromRust(LLVMRustDIFlags Flags) {
DINode::DIFlags Result = DINode::DIFlags::FlagZero;
[LLVM] Introduce a stable representation of DIFlags In LLVM 4.0, this enum becomes an actual type-safe enum, which breaks all of the interfaces. Introduce our own copy of the bitflags that we can then safely convert to the LLVM one.
2016-11-18 16:15:14 -06:00
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
switch (visibility(Flags)) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
case LLVMRustDIFlags::FlagPrivate:
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
Result |= DINode::DIFlags::FlagPrivate;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
break;
case LLVMRustDIFlags::FlagProtected:
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
Result |= DINode::DIFlags::FlagProtected;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
break;
case LLVMRustDIFlags::FlagPublic:
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
Result |= DINode::DIFlags::FlagPublic;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
break;
default:
// The rest are handled below
break;
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
if (isSet(Flags & LLVMRustDIFlags::FlagFwdDecl)) {
Result |= DINode::DIFlags::FlagFwdDecl;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
if (isSet(Flags & LLVMRustDIFlags::FlagAppleBlock)) {
Result |= DINode::DIFlags::FlagAppleBlock;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
if (isSet(Flags & LLVMRustDIFlags::FlagVirtual)) {
Result |= DINode::DIFlags::FlagVirtual;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
if (isSet(Flags & LLVMRustDIFlags::FlagArtificial)) {
Result |= DINode::DIFlags::FlagArtificial;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
if (isSet(Flags & LLVMRustDIFlags::FlagExplicit)) {
Result |= DINode::DIFlags::FlagExplicit;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
if (isSet(Flags & LLVMRustDIFlags::FlagPrototyped)) {
Result |= DINode::DIFlags::FlagPrototyped;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
if (isSet(Flags & LLVMRustDIFlags::FlagObjcClassComplete)) {
Result |= DINode::DIFlags::FlagObjcClassComplete;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
if (isSet(Flags & LLVMRustDIFlags::FlagObjectPointer)) {
Result |= DINode::DIFlags::FlagObjectPointer;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
if (isSet(Flags & LLVMRustDIFlags::FlagVector)) {
Result |= DINode::DIFlags::FlagVector;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
if (isSet(Flags & LLVMRustDIFlags::FlagStaticMember)) {
Result |= DINode::DIFlags::FlagStaticMember;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
if (isSet(Flags & LLVMRustDIFlags::FlagLValueReference)) {
Result |= DINode::DIFlags::FlagLValueReference;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
if (isSet(Flags & LLVMRustDIFlags::FlagRValueReference)) {
Result |= DINode::DIFlags::FlagRValueReference;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Teach rustc about DW_AT_noreturn and a few more DIFlags
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;
}
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
return Result;
[LLVM] Introduce a stable representation of DIFlags In LLVM 4.0, this enum becomes an actual type-safe enum, which breaks all of the interfaces. Introduce our own copy of the bitflags that we can then safely convert to the LLVM one.
2016-11-18 16:15:14 -06:00
}
Rebase to the llvm-project monorepo The new git submodule src/llvm-project is a monorepo replacing src/llvm and src/tools/{clang,lld,lldb}. This also serves as a rebase for these projects to the new 8.x branch from trunk. The src/llvm-emscripten fork is unchanged for now.
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),
rustc: Start implementing compat with LLVM 9 This commit doesn't actually migrate to LLVM 9, but it brings our own C++ bindings in line with LLVM 9 and able to compile against tip of tree. The changes made were: * The `MainSubprogram` flag for debuginfo moved between flag types. * Iteration of archive members was tweaked slightly and we have to construct the two iterators before constructing the returned `RustArchiveIterator` value. * The `getOrInsertFunction` binding now returns a wrapper which we use `getCallee()` on to get the value we're interested in.
2019-04-04 15:05:41 -05:00
SPFlagMainSubprogram = (1 << 5),
Rebase to the llvm-project monorepo The new git submodule src/llvm-project is a monorepo replacing src/llvm and src/tools/{clang,lld,lldb}. This also serves as a rebase for these projects to the new 8.x branch from trunk. The src/llvm-emscripten fork is unchanged for now.
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;
}
rustc: Start implementing compat with LLVM 9 This commit doesn't actually migrate to LLVM 9, but it brings our own C++ bindings in line with LLVM 9 and able to compile against tip of tree. The changes made were: * The `MainSubprogram` flag for debuginfo moved between flag types. * Iteration of archive members was tweaked slightly and we have to construct the two iterators before constructing the returned `RustArchiveIterator` value. * The `getOrInsertFunction` binding now returns a wrapper which we use `getCallee()` on to get the value we're interested in.
2019-04-04 15:05:41 -05:00
if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagMainSubprogram)) {
Result |= DISubprogram::DISPFlags::SPFlagMainSubprogram;
}
Rebase to the llvm-project monorepo The new git submodule src/llvm-project is a monorepo replacing src/llvm and src/tools/{clang,lld,lldb}. This also serves as a rebase for these projects to the new 8.x branch from trunk. The src/llvm-emscripten fork is unchanged for now.
2019-01-16 11:59:03 -06:00
return Result;
}
Set the DICompileUnit emissionKind
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.");
}
}
Add hash of source files in debug info * Adds either an MD5 or SHA1 hash to the debug info. * Adds new unstable option `-Z src-hash-algorithm` to control the hashing algorithm.
2020-03-31 00:17:15 -05:00
enum class LLVMRustChecksumKind {
None,
MD5,
SHA1,
Add support for SHA256 source file hashing for LLVM 11+.
2020-10-13 10:41:06 -05:00
SHA256,
Add hash of source files in debug info * Adds either an MD5 or SHA1 hash to the debug info. * Adds new unstable option `-Z src-hash-algorithm` to control the hashing algorithm.
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;
Add support for SHA256 source file hashing for LLVM 11+.
2020-10-13 10:41:06 -05:00
case LLVMRustChecksumKind::SHA256:
return DIFile::ChecksumKind::CSK_SHA256;
Add hash of source files in debug info * Adds either an MD5 or SHA1 hash to the debug info. * Adds new unstable option `-Z src-hash-algorithm` to control the hashing algorithm.
2020-03-31 00:17:15 -05:00
default:
report_fatal_error("bad ChecksumKind.");
}
}
Remove useless `const`
2015-05-30 08:50:12 -05:00
extern "C" uint32_t LLVMRustDebugMetadataVersion() {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return DEBUG_METADATA_VERSION;
rustc_llvm: Don't export constants across dlls For imports of constants across DLLs to work on Windows it *requires* that the import be marked with `dllimport` (unlike functions where the marker is optional, but strongly recommended). This currently isn't working for importing FFI constants across boundaries, however, so the one constant exported from `rustc_llvm.dll` is now a function to be called instead.
2015-05-11 23:07:38 -05:00
}
Add appropriate LLVM module flags for debug info. Set "Dwarf Version" to 2 on OS X to avoid toolchain incompatibility, and set "Debug Info Version" to prevent debug info from being stripped from bitcode. Fixes #11352.
2014-01-27 23:05:33 -06:00
Use probe-stack=inline-asm in LLVM 11+
2020-10-12 21:33:27 -05:00
extern "C" uint32_t LLVMRustVersionPatch() { return LLVM_VERSION_PATCH; }
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" uint32_t LLVMRustVersionMinor() { return LLVM_VERSION_MINOR; }
rustc_trans: don't hardcode llvm version for conditional intrinsics This commit introduce a third parameter for compatible_ifn!, as new intrinsics are being added in recent LLVM releases and there is no need to hardcode a specific case. Signed-off-by: Luca Bruno <lucab@debian.org>
2015-01-24 05:00:35 -06:00
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" uint32_t LLVMRustVersionMajor() { return LLVM_VERSION_MAJOR; }
rustc_trans: don't hardcode llvm version for conditional intrinsics This commit introduce a third parameter for compatible_ifn!, as new intrinsics are being added in recent LLVM releases and there is no need to hardcode a specific case. Signed-off-by: Luca Bruno <lucab@debian.org>
2015-01-24 05:00:35 -06:00
Use error-on-mismatch policy for PAuth module flags. This agrees with Clang, and avoids an error when using LTO with mixed C/Rust. LLVM considers different behaviour flags to be a mismatch, even when the flag value itself is the same. This also makes the flag setting explicit for all uses of LLVMRustAddModuleFlag.
2022-01-19 08:51:59 -06:00
extern "C" void LLVMRustAddModuleFlag(
LLVMModuleRef M,
Module::ModFlagBehavior MergeBehavior,
const char *Name,
uint32_t Value) {
unwrap(M)->addModuleFlag(MergeBehavior, Name, Value);
Add appropriate LLVM module flags for debug info. Set "Dwarf Version" to 2 on OS X to avoid toolchain incompatibility, and set "Debug Info Version" to prevent debug info from being stripped from bitcode. Fixes #11352.
2014-01-27 23:05:33 -06:00
}
Add LLVM module flags required for the VFE opt To apply the optimization the `Virtual Function Elim` module flag has to be set. To apply this optimization post-link the `LTOPostLink` module flag has to be set.
2022-04-21 07:35:40 -05:00
extern "C" bool LLVMRustHasModuleFlag(LLVMModuleRef M, const char *Name,
size_t Len) {
return unwrap(M)->getModuleFlag(StringRef(Name, Len)) != nullptr;
}
Fix return value of `LLVMRustMetadataAsValue` `LLVMRustMetadataAsValue` would previously return `void`, despite the corresponding Rust function expecting to return a `ValueRef`.
2017-12-12 11:27:37 -06:00
extern "C" LLVMValueRef LLVMRustMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD) {
return wrap(MetadataAsValue::get(*unwrap(C), unwrap(MD)));
Add profiling support, through the rustc -Z profile flag. When -Z profile is passed, the GCDAProfiling LLVM pass is added to the pipeline, which uses debug information to instrument the IR. After compiling with -Z profile, the $(OUT_DIR)/$(CRATE_NAME).gcno file is created, containing initial profiling information. After running the program built, the $(OUT_DIR)/$(CRATE_NAME).gcda file is created, containing branch counters. The created *.gcno and *.gcda files can be processed using the "llvm-cov gcov" and "lcov" tools. The profiling data LLVM generates does not faithfully follow the GCC's format for *.gcno and *.gcda files, and so it will probably not work with other tools (such as gcov itself) that consume these files.
2017-02-13 03:57:50 -06:00
}
Add metadata generation for vtables when using VFE This adds the typeid and `vcall_visibility` metadata to vtables when the -Cvirtual-function-elimination flag is set. The typeid is generated in the same way as for the `llvm.type.checked.load` intrinsic from the trait_ref. The offset that is added to the typeid is always 0. This is because LLVM assumes that vtables are constructed according to the definition in the Itanium ABI. This includes an "address point" of the vtable. In C++ this is the offset in the vtable where information for RTTI is placed. Since there is no RTTI information in Rust's vtables, this "address point" is always 0. This "address point" in combination with the offset passed to the `llvm.type.checked.load` intrinsic determines the final function that should be loaded from the vtable in the `WholeProgramDevirtualization` pass in LLVM. That's why the `llvm.type.checked.load` intrinsics are generated with the typeid of the trait, rather than with that of the function that is called. This matches what `clang` does for C++. The vcall_visibility metadata depends on three factors: 1. LTO level: Currently this is always fat LTO, because LLVM only supports this optimization with fat LTO. 2. Visibility of the trait: If the trait is publicly visible, VFE can only act on its vtables after linking. 3. Number of CGUs: if there is more than one CGU, also vtables with restricted visibility could be seen outside of the CGU, so VFE can only act on them after linking. To reflect this, there are three visibility levels: Public, LinkageUnit, and TranslationUnit.
2022-04-21 08:02:54 -05:00
extern "C" void LLVMRustGlobalAddMetadata(
LLVMValueRef Global, unsigned Kind, LLVMMetadataRef MD) {
unwrap<GlobalObject>(Global)->addMetadata(Kind, *unwrap<MDNode>(MD));
}
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
extern "C" LLVMRustDIBuilderRef LLVMRustDIBuilderCreate(LLVMModuleRef M) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return new DIBuilder(*unwrap(M));
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
extern "C" void LLVMRustDIBuilderDispose(LLVMRustDIBuilderRef Builder) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
delete Builder;
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
extern "C" void LLVMRustDIBuilderFinalize(LLVMRustDIBuilderRef Builder) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
Builder->finalize();
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateCompileUnit(
LLVMRustDIBuilderRef Builder, unsigned Lang, LLVMMetadataRef FileRef,
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
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,
llvm: update ffi bindings for split dwarf This commit modifies the FFI bindings to LLVM required for Split DWARF support in rustc. In particular: - `addPassesToEmitFile`'s wrapper, `LLVMRustWriteOutputFile` now takes a `DwoPath` `const char*`. When disabled, `nullptr` should be provided which will preserve existing behaviour. When enabled, the path to the `.dwo` file should be provided. - `createCompileUnit`'s wrapper, `LLVMRustDIBuilderCreateCompileUnit` now has two additional arguments, for the `DWOId` and to enable `SplitDebugInlining`. `DWOId` should always be zero. - `createTargetMachine`'s wrapper, `LLVMRustCreateTargetMachine` has an additional argument which should be provided the path to the `.dwo` when enabled. Signed-off-by: David Wood <david@davidtw.co>
2020-09-23 10:25:20 -05:00
LLVMRustDebugEmissionKind Kind,
uint64_t DWOId, bool SplitDebugInlining) {
[LLVM 4.0] Fix CreateCompileUnit
2017-02-11 15:01:25 -06:00
auto *File = unwrapDI<DIFile>(FileRef);
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
return wrap(Builder->createCompileUnit(Lang, File, StringRef(Producer, ProducerLen),
isOptimized, Flags, RuntimeVer,
StringRef(SplitName, SplitNameLen),
llvm: update ffi bindings for split dwarf This commit modifies the FFI bindings to LLVM required for Split DWARF support in rustc. In particular: - `addPassesToEmitFile`'s wrapper, `LLVMRustWriteOutputFile` now takes a `DwoPath` `const char*`. When disabled, `nullptr` should be provided which will preserve existing behaviour. When enabled, the path to the `.dwo` file should be provided. - `createCompileUnit`'s wrapper, `LLVMRustDIBuilderCreateCompileUnit` now has two additional arguments, for the `DWOId` and to enable `SplitDebugInlining`. `DWOId` should always be zero. - `createTargetMachine`'s wrapper, `LLVMRustCreateTargetMachine` has an additional argument which should be provided the path to the `.dwo` when enabled. Signed-off-by: David Wood <david@davidtw.co>
2020-09-23 10:25:20 -05:00
fromRust(Kind), DWOId, SplitDebugInlining));
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFile(
LLVMRustDIBuilderRef Builder,
const char *Filename, size_t FilenameLen,
Add hash of source files in debug info * Adds either an MD5 or SHA1 hash to the debug info. * Adds new unstable option `-Z src-hash-algorithm` to control the hashing algorithm.
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});
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
return wrap(Builder->createFile(StringRef(Filename, FilenameLen),
Add hash of source files in debug info * Adds either an MD5 or SHA1 hash to the debug info. * Adds new unstable option `-Z src-hash-algorithm` to control the hashing algorithm.
2020-03-31 00:17:15 -05:00
StringRef(Directory, DirectoryLen),
CSInfo));
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
LLVMRustDIBuilderCreateSubroutineType(LLVMRustDIBuilderRef Builder,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMMetadataRef ParameterTypes) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return wrap(Builder->createSubroutineType(
DITypeRefArray(unwrap<MDTuple>(ParameterTypes))));
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFunction(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
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,
Rebase to the llvm-project monorepo The new git submodule src/llvm-project is a monorepo replacing src/llvm and src/tools/{clang,lld,lldb}. This also serves as a rebase for these projects to the new 8.x branch from trunk. The src/llvm-emscripten fork is unchanged for now.
2019-01-16 11:59:03 -06:00
LLVMMetadataRef Ty, unsigned ScopeLine, LLVMRustDIFlags Flags,
rustc_codegen_llvm: move DISubprogram creation to a dbg_scope_fn method.
2020-02-10 14:30:51 -06:00
LLVMRustDISPFlags SPFlags, LLVMValueRef MaybeFn, LLVMMetadataRef TParam,
Rebase to the llvm-project monorepo The new git submodule src/llvm-project is a monorepo replacing src/llvm and src/tools/{clang,lld,lldb}. This also serves as a rebase for these projects to the new 8.x branch from trunk. The src/llvm-emscripten fork is unchanged for now.
2019-01-16 11:59:03 -06:00
LLVMMetadataRef Decl) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
DITemplateParameterArray TParams =
DITemplateParameterArray(unwrap<MDTuple>(TParam));
rustc: Start implementing compat with LLVM 9 This commit doesn't actually migrate to LLVM 9, but it brings our own C++ bindings in line with LLVM 9 and able to compile against tip of tree. The changes made were: * The `MainSubprogram` flag for debuginfo moved between flag types. * Iteration of archive members was tweaked slightly and we have to construct the two iterators before constructing the returned `RustArchiveIterator` value. * The `getOrInsertFunction` binding now returns a wrapper which we use `getCallee()` on to get the value we're interested in.
2019-04-04 15:05:41 -05:00
DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags);
DINode::DIFlags llvmFlags = fromRust(Flags);
Rebase to the llvm-project monorepo The new git submodule src/llvm-project is a monorepo replacing src/llvm and src/tools/{clang,lld,lldb}. This also serves as a rebase for these projects to the new 8.x branch from trunk. The src/llvm-emscripten fork is unchanged for now.
2019-01-16 11:59:03 -06:00
DISubprogram *Sub = Builder->createFunction(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
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,
rustc: Start implementing compat with LLVM 9 This commit doesn't actually migrate to LLVM 9, but it brings our own C++ bindings in line with LLVM 9 and able to compile against tip of tree. The changes made were: * The `MainSubprogram` flag for debuginfo moved between flag types. * Iteration of archive members was tweaked slightly and we have to construct the two iterators before constructing the returned `RustArchiveIterator` value. * The `getOrInsertFunction` binding now returns a wrapper which we use `getCallee()` on to get the value we're interested in.
2019-04-04 15:05:41 -05:00
llvmSPFlags, TParams, unwrapDIPtr<DISubprogram>(Decl));
rustc_codegen_llvm: move DISubprogram creation to a dbg_scope_fn method.
2020-02-10 14:30:51 -06:00
if (MaybeFn)
unwrap<Function>(MaybeFn)->setSubprogram(Sub);
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return wrap(Sub);
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateBasicType(
LLVMRustDIBuilderRef Builder, const char *Name, size_t NameLen,
rustllvm: Fix warnings about unused function parameters
2020-05-21 12:53:41 -05:00
uint64_t SizeInBits, unsigned Encoding) {
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
return wrap(Builder->createBasicType(StringRef(Name, NameLen), SizeInBits, Encoding));
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
debuginfo: Support for tuple-style enums (WIP)
2013-07-02 11:10:24 -05:00
debuginfo: Define int/float types in terms of MSVC-recognized types. PDB debug information doesn't appear to be emitted for basic types. By defining u32 as a typedef for unsigned __int32 when targeting MSVC, we allow CDB and other debuggers to recognize "u32" as a type/expression. This in turn unblocks rust-lang#70052 "Update hashbrown to 0.8.0" by allowing $T1 ..= $T3 to resolve, which would otherwise fail to resolve when builtin types fail to parse.
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),
Use unwrapDIPtr because the Scope may be passed as None
2020-10-27 20:05:16 -05:00
LineNo, unwrapDIPtr<DIScope>(Scope)));
debuginfo: Define int/float types in terms of MSVC-recognized types. PDB debug information doesn't appear to be emitted for basic types. By defining u32 as a typedef for unsigned __int32 when targeting MSVC, we allow CDB and other debuggers to recognize "u32" as a type/expression. This in turn unblocks rust-lang#70052 "Update hashbrown to 0.8.0" by allowing $T1 ..= $T3 to resolve, which would otherwise fail to resolve when builtin types fail to parse.
2020-06-25 01:28:00 -05:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreatePointerType(
LLVMRustDIBuilderRef Builder, LLVMMetadataRef PointeeTy,
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
const char *Name, size_t NameLen) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return wrap(Builder->createPointerType(unwrapDI<DIType>(PointeeTy),
rustllvm: adjust usage of createPointerType
2017-07-21 06:26:41 -05:00
SizeInBits, AlignInBits,
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
AddressSpace,
StringRef(Name, NameLen)));
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStructType(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
const char *Name, size_t NameLen,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
[llvm] Use 32-bits for alignment LLVM 4.0 changes this. This change is fine to make for LLVM 3.9 as we won't have alignments greater than 2^32-1.
2017-02-04 04:51:10 -06:00
uint32_t AlignInBits, LLVMRustDIFlags Flags,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMMetadataRef DerivedFrom, LLVMMetadataRef Elements,
unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
const char *UniqueId, size_t UniqueIdLen) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return wrap(Builder->createStructType(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
unwrapDI<DIFile>(File), LineNumber,
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIType>(DerivedFrom),
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
unwrapDI<DIType>(VTableHolder), StringRef(UniqueId, UniqueIdLen)));
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
Fix DWARF generation for enums The DWARF generated for Rust enums was always somewhat unusual. Rather than using DWARF constructs directly, it would emit magic field names like "RUST$ENCODED$ENUM$0$Name" and "RUST$ENUM$DISR". Since PR #45225, though, even this has not worked -- the ad hoc scheme was not updated to handle the wider variety of niche-filling layout optimizations now available. This patch changes the generated DWARF to use the standard tags meant for this purpose; namely, DW_TAG_variant and DW_TAG_variant_part. The patch to implement this went in to LLVM 7. In order to work with older versions of LLVM, and because LLVM doesn't do anything here for PDB, the existing code is kept as a fallback mode. Support for this DWARF is in the Rust lldb and in gdb 8.2. Closes #32920 Closes #32924 Closes #52762 Closes #53153
2017-11-29 15:42:25 -06:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantPart(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
const char *Name, size_t NameLen,
Fix DWARF generation for enums The DWARF generated for Rust enums was always somewhat unusual. Rather than using DWARF constructs directly, it would emit magic field names like "RUST$ENCODED$ENUM$0$Name" and "RUST$ENUM$DISR". Since PR #45225, though, even this has not worked -- the ad hoc scheme was not updated to handle the wider variety of niche-filling layout optimizations now available. This patch changes the generated DWARF to use the standard tags meant for this purpose; namely, DW_TAG_variant and DW_TAG_variant_part. The patch to implement this went in to LLVM 7. In order to work with older versions of LLVM, and because LLVM doesn't do anything here for PDB, the existing code is kept as a fallback mode. Support for this DWARF is in the Rust lldb and in gdb 8.2. Closes #32920 Closes #32924 Closes #52762 Closes #53153
2017-11-29 15:42:25 -06:00
LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Discriminator,
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
LLVMMetadataRef Elements, const char *UniqueId, size_t UniqueIdLen) {
Fix DWARF generation for enums The DWARF generated for Rust enums was always somewhat unusual. Rather than using DWARF constructs directly, it would emit magic field names like "RUST$ENCODED$ENUM$0$Name" and "RUST$ENUM$DISR". Since PR #45225, though, even this has not worked -- the ad hoc scheme was not updated to handle the wider variety of niche-filling layout optimizations now available. This patch changes the generated DWARF to use the standard tags meant for this purpose; namely, DW_TAG_variant and DW_TAG_variant_part. The patch to implement this went in to LLVM 7. In order to work with older versions of LLVM, and because LLVM doesn't do anything here for PDB, the existing code is kept as a fallback mode. Support for this DWARF is in the Rust lldb and in gdb 8.2. Closes #32920 Closes #32924 Closes #52762 Closes #53153
2017-11-29 15:42:25 -06:00
return wrap(Builder->createVariantPart(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
unwrapDI<DIFile>(File), LineNumber,
Fix DWARF generation for enums The DWARF generated for Rust enums was always somewhat unusual. Rather than using DWARF constructs directly, it would emit magic field names like "RUST$ENCODED$ENUM$0$Name" and "RUST$ENUM$DISR". Since PR #45225, though, even this has not worked -- the ad hoc scheme was not updated to handle the wider variety of niche-filling layout optimizations now available. This patch changes the generated DWARF to use the standard tags meant for this purpose; namely, DW_TAG_variant and DW_TAG_variant_part. The patch to implement this went in to LLVM 7. In order to work with older versions of LLVM, and because LLVM doesn't do anything here for PDB, the existing code is kept as a fallback mode. Support for this DWARF is in the Rust lldb and in gdb 8.2. Closes #32920 Closes #32924 Closes #52762 Closes #53153
2017-11-29 15:42:25 -06:00
SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIDerivedType>(Discriminator),
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
DINodeArray(unwrapDI<MDTuple>(Elements)), StringRef(UniqueId, UniqueIdLen)));
Fix DWARF generation for enums The DWARF generated for Rust enums was always somewhat unusual. Rather than using DWARF constructs directly, it would emit magic field names like "RUST$ENCODED$ENUM$0$Name" and "RUST$ENUM$DISR". Since PR #45225, though, even this has not worked -- the ad hoc scheme was not updated to handle the wider variety of niche-filling layout optimizations now available. This patch changes the generated DWARF to use the standard tags meant for this purpose; namely, DW_TAG_variant and DW_TAG_variant_part. The patch to implement this went in to LLVM 7. In order to work with older versions of LLVM, and because LLVM doesn't do anything here for PDB, the existing code is kept as a fallback mode. Support for this DWARF is in the Rust lldb and in gdb 8.2. Closes #32920 Closes #32924 Closes #52762 Closes #53153
2017-11-29 15:42:25 -06:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMemberType(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
const char *Name, size_t NameLen,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
[llvm] Use 32-bits for alignment LLVM 4.0 changes this. This change is fine to make for LLVM 3.9 as we won't have alignments greater than 2^32-1.
2017-02-04 04:51:10 -06:00
uint32_t AlignInBits, uint64_t OffsetInBits, LLVMRustDIFlags Flags,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMMetadataRef Ty) {
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
return wrap(Builder->createMemberType(unwrapDI<DIDescriptor>(Scope),
StringRef(Name, NameLen),
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
unwrapDI<DIFile>(File), LineNo,
SizeInBits, AlignInBits, OffsetInBits,
fromRust(Flags), unwrapDI<DIType>(Ty)));
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
debuginfo: Support for tuple-style enums (WIP)
2013-07-02 11:10:24 -05:00
Fix DWARF generation for enums The DWARF generated for Rust enums was always somewhat unusual. Rather than using DWARF constructs directly, it would emit magic field names like "RUST$ENCODED$ENUM$0$Name" and "RUST$ENUM$DISR". Since PR #45225, though, even this has not worked -- the ad hoc scheme was not updated to handle the wider variety of niche-filling layout optimizations now available. This patch changes the generated DWARF to use the standard tags meant for this purpose; namely, DW_TAG_variant and DW_TAG_variant_part. The patch to implement this went in to LLVM 7. In order to work with older versions of LLVM, and because LLVM doesn't do anything here for PDB, the existing code is kept as a fallback mode. Support for this DWARF is in the Rust lldb and in gdb 8.2. Closes #32920 Closes #32924 Closes #52762 Closes #53153
2017-11-29 15:42:25 -06:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantMemberType(
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
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,
Fix DWARF generation for enums The DWARF generated for Rust enums was always somewhat unusual. Rather than using DWARF constructs directly, it would emit magic field names like "RUST$ENCODED$ENUM$0$Name" and "RUST$ENUM$DISR". Since PR #45225, though, even this has not worked -- the ad hoc scheme was not updated to handle the wider variety of niche-filling layout optimizations now available. This patch changes the generated DWARF to use the standard tags meant for this purpose; namely, DW_TAG_variant and DW_TAG_variant_part. The patch to implement this went in to LLVM 7. In order to work with older versions of LLVM, and because LLVM doesn't do anything here for PDB, the existing code is kept as a fallback mode. Support for this DWARF is in the Rust lldb and in gdb 8.2. Closes #32920 Closes #32924 Closes #52762 Closes #53153
2017-11-29 15:42:25 -06:00
LLVMRustDIFlags Flags, LLVMMetadataRef Ty) {
llvm::ConstantInt* D = nullptr;
if (Discriminant) {
D = unwrap<llvm::ConstantInt>(Discriminant);
}
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
return wrap(Builder->createVariantMemberType(unwrapDI<DIDescriptor>(Scope),
StringRef(Name, NameLen),
Fix DWARF generation for enums The DWARF generated for Rust enums was always somewhat unusual. Rather than using DWARF constructs directly, it would emit magic field names like "RUST$ENCODED$ENUM$0$Name" and "RUST$ENUM$DISR". Since PR #45225, though, even this has not worked -- the ad hoc scheme was not updated to handle the wider variety of niche-filling layout optimizations now available. This patch changes the generated DWARF to use the standard tags meant for this purpose; namely, DW_TAG_variant and DW_TAG_variant_part. The patch to implement this went in to LLVM 7. In order to work with older versions of LLVM, and because LLVM doesn't do anything here for PDB, the existing code is kept as a fallback mode. Support for this DWARF is in the Rust lldb and in gdb 8.2. Closes #32920 Closes #32924 Closes #52762 Closes #53153
2017-11-29 15:42:25 -06:00
unwrapDI<DIFile>(File), LineNo,
SizeInBits, AlignInBits, OffsetInBits, D,
fromRust(Flags), unwrapDI<DIType>(Ty)));
}
debuginfo: Change C++-like encoding for enums. The updated encoding should be able to handle niche layouts where more than one variant has fields.
2022-06-20 10:50:27 -05:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticMemberType(
LLVMRustDIBuilderRef Builder,
LLVMMetadataRef Scope,
const char *Name,
size_t NameLen,
LLVMMetadataRef File,
unsigned LineNo,
LLVMMetadataRef Ty,
LLVMRustDIFlags Flags,
LLVMValueRef val,
uint32_t AlignInBits
) {
return wrap(Builder->createStaticMemberType(
unwrapDI<DIDescriptor>(Scope),
StringRef(Name, NameLen),
unwrapDI<DIFile>(File),
LineNo,
unwrapDI<DIType>(Ty),
fromRust(Flags),
unwrap<llvm::ConstantInt>(val),
AlignInBits
));
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateLexicalBlock(
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
LLVMMetadataRef File, unsigned Line, unsigned Col) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return wrap(Builder->createLexicalBlock(unwrapDI<DIDescriptor>(Scope),
unwrapDI<DIFile>(File), Line, Col));
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
debuginfo: Support for tuple-style enums (WIP)
2013-07-02 11:10:24 -05:00
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
LLVMRustDIBuilderCreateLexicalBlockFile(LLVMRustDIBuilderRef Builder,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMMetadataRef Scope,
LLVMMetadataRef File) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return wrap(Builder->createLexicalBlockFile(unwrapDI<DIDescriptor>(Scope),
unwrapDI<DIFile>(File)));
Fix debug line info for macro expansions. Macro expansions produce code tagged with debug locations that are completely different from the surrounding expressions. This wrecks havoc on debugger's ability the step over source lines. In order to have a good line stepping behavior in debugger, we overwrite debug locations of macro expansions with that of the outermost expansion site.
2016-08-24 21:34:31 -05:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
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,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMMetadataRef Ty, bool IsLocalToUnit, LLVMValueRef V,
LLVMMetadataRef Decl = nullptr, uint32_t AlignInBits = 0) {
add missing global metadata
2017-03-16 15:10:04 -05:00
llvm::GlobalVariable *InitVal = cast<llvm::GlobalVariable>(unwrap(V));
Update LLVM global variable debug info API for 4.0 This teaches Rust about an LLVM 4.0 API change for creating debug info for global variables. This change was made in upstream LLVM patch https://reviews.llvm.org/D20147 This is almost 1:1 copy of how clang did it in http://reviews.llvm.org/D20415
2016-12-11 03:08:20 -06:00
Ran clang-format on src/rustllvm with llvm as the coding style.
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());
}
Update LLVM global variable debug info API for 4.0 This teaches Rust about an LLVM 4.0 API change for creating debug info for global variables. This change was made in upstream LLVM patch https://reviews.llvm.org/D20147 This is almost 1:1 copy of how clang did it in http://reviews.llvm.org/D20415
2016-12-11 03:08:20 -06:00
add missing global metadata
2017-03-16 15:10:04 -05:00
llvm::DIGlobalVariableExpression *VarExpr = Builder->createGlobalVariableExpression(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
unwrapDI<DIDescriptor>(Context), StringRef(Name, NameLen),
StringRef(LinkageName, LinkageNameLen),
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), IsLocalToUnit,
Pass isDefined parameter to createGlobalVariableExpression()
2019-12-31 07:23:53 -06:00
/* isDefined */ true,
Conditionally compile in only the extra argument.
2018-11-07 06:34:43 -06:00
InitExpr, unwrapDIPtr<MDNode>(Decl),
/* templateParams */ nullptr,
AlignInBits);
add missing global metadata
2017-03-16 15:10:04 -05:00
InitVal->setMetadata("dbg", VarExpr);
return wrap(VarExpr);
Initial support for emitting DWARF for static vars. Only supports crate level statics. No debug info is generated for function level statics. Closes #9227.
2014-02-20 19:44:29 -06:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(
LLVMRustDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Scope,
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
const char *Name, size_t NameLen,
LLVMMetadataRef File, unsigned LineNo,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMMetadataRef Ty, bool AlwaysPreserve, LLVMRustDIFlags Flags,
[llvm] Use 32-bits for alignment LLVM 4.0 changes this. This change is fine to make for LLVM 3.9 as we won't have alignments greater than 2^32-1.
2017-02-04 04:51:10 -06:00
unsigned ArgNo, uint32_t AlignInBits) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
if (Tag == 0x100) { // DW_TAG_auto_variable
return wrap(Builder->createAutoVariable(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
unwrapDI<DIFile>(File), LineNo,
bump minimum LLVM version to 5.0
2018-06-29 03:28:51 -05:00
unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags), AlignInBits));
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
} else {
return wrap(Builder->createParameterVariable(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
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)));
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
LLVMRustDIBuilderCreateArrayType(LLVMRustDIBuilderRef Builder, uint64_t Size,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
uint32_t AlignInBits, LLVMMetadataRef Ty,
LLVMMetadataRef Subscripts) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return wrap(
Builder->createArrayType(Size, AlignInBits, unwrapDI<DIType>(Ty),
DINodeArray(unwrapDI<MDTuple>(Subscripts))));
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
LLVMRustDIBuilderGetOrCreateSubrange(LLVMRustDIBuilderRef Builder, int64_t Lo,
int64_t Count) {
return wrap(Builder->getOrCreateSubrange(Lo, Count));
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
LLVMRustDIBuilderGetOrCreateArray(LLVMRustDIBuilderRef Builder,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMMetadataRef *Ptr, unsigned Count) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
Metadata **DataValue = unwrap(Ptr);
return wrap(
Builder->getOrCreateArray(ArrayRef<Metadata *>(DataValue, Count)).get());
Use DIBuilder in debuginfo
2013-06-14 13:38:29 -05:00
}
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
extern "C" LLVMValueRef LLVMRustDIBuilderInsertDeclareAtEnd(
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMRustDIBuilderRef Builder, LLVMValueRef V, LLVMMetadataRef VarInfo,
RustWrapper: adapt for an LLVM API change No functional changes intended. The LLVM commit https://github.com/llvm/llvm-project/commit/ec501f15a8b8ace2b283732740d6d65d40d82e09 removed the signed version of `createExpression`. This adapts the Rust LLVM wrappers accordingly.
2022-01-03 04:25:33 -06:00
uint64_t *AddrOps, unsigned AddrOpsCount, LLVMMetadataRef DL,
Made the while DebugContext mutable, not just created_* hashes Disabled create_arg
2013-06-11 02:57:25 -05:00
LLVMBasicBlockRef InsertAtEnd) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return wrap(Builder->insertDeclare(
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
unwrap(V), unwrap<DILocalVariable>(VarInfo),
RustWrapper: adapt for an LLVM API change No functional changes intended. The LLVM commit https://github.com/llvm/llvm-project/commit/ec501f15a8b8ace2b283732740d6d65d40d82e09 removed the signed version of `createExpression`. This adapts the Rust LLVM wrappers accordingly.
2022-01-03 04:25:33 -06:00
Builder->createExpression(llvm::ArrayRef<uint64_t>(AddrOps, AddrOpsCount)),
rustc_llvm: unwrap LLVMMetadataRef before casting Directly casting the opaque pointer was [reported] to cause an "incomplete type" error with GCC 9.3: ``` llvm-wrapper/RustWrapper.cpp:939:31: required from here /usr/include/c++/9.3/type_traits:1301:12: error: invalid use of incomplete type 'struct LLVMOpaqueMetadata' 1301 | struct is_base_of | ^~~~~~~~~~ In file included from [...]/rust/src/llvm-project/llvm/include/llvm-c/BitReader.h:23, from llvm-wrapper/LLVMWrapper.h:1, from llvm-wrapper/RustWrapper.cpp:1: [...]/rust/src/llvm-project/llvm/include/llvm-c/Types.h:89:16: note: forward declaration of 'struct LLVMOpaqueMetadata' 89 | typedef struct LLVMOpaqueMetadata *LLVMMetadataRef; | ^~~~~~~~~~~~~~~~~~ ``` [reported]: https://zulip-archive.rust-lang.org/182449tcompilerhelp/12215halprustcllvmbuildfail.html#214915124 A simple `unwrap` fixes the issue.
2020-10-29 11:45:15 -05:00
DebugLoc(cast<MDNode>(unwrap(DL))),
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
unwrap(InsertAtEnd)));
Made the while DebugContext mutable, not just created_* hashes Disabled create_arg
2013-06-11 02:57:25 -05:00
}
Change DIBuilderCreateEnumerator signature to match LLVM 9 No functional changes intended.
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) {
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
return wrap(Builder->createEnumerator(StringRef(Name, NameLen), Value, IsUnsigned));
debuginfo: Added support for c-style enums.
2013-07-02 03:33:51 -05:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerationType(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
const char *Name, size_t NameLen,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
uint32_t AlignInBits, LLVMMetadataRef Elements,
Rebase to the llvm-project monorepo The new git submodule src/llvm-project is a monorepo replacing src/llvm and src/tools/{clang,lld,lldb}. This also serves as a rebase for these projects to the new 8.x branch from trunk. The src/llvm-emscripten fork is unchanged for now.
2019-01-16 11:59:03 -06:00
LLVMMetadataRef ClassTy, bool IsScoped) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return wrap(Builder->createEnumerationType(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
unwrapDI<DIFile>(File), LineNumber,
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)),
Rebase to the llvm-project monorepo The new git submodule src/llvm-project is a monorepo replacing src/llvm and src/tools/{clang,lld,lldb}. This also serves as a rebase for these projects to the new 8.x branch from trunk. The src/llvm-emscripten fork is unchanged for now.
2019-01-16 11:59:03 -06:00
unwrapDI<DIType>(ClassTy), "", IsScoped));
debuginfo: Support for tuple-style enums (WIP)
2013-07-02 11:10:24 -05:00
}
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateUnionType(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
const char *Name, size_t NameLen,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Elements,
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
unsigned RunTimeLang, const char *UniqueId, size_t UniqueIdLen) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return wrap(Builder->createUnionType(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
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)));
Add an atomic fence intrinsic
2013-07-28 02:48:16 -05:00
}
Implement an `address_insignificant` attribute This can be applied to statics and it will indicate that LLVM will attempt to merge the constant in .data with other statics. I have preliminarily applied this to all of the statics generated by the new `ifmt!` syntax extension. I compiled a file with 1000 calls to `ifmt!` and a separate file with 1000 calls to `fmt!` to compare the sizes, and the results were: fmt 310k ifmt (before) 529k ifmt (after) 202k This now means that ifmt! is both faster and smaller than fmt!, yay!
2013-08-09 15:47:00 -05:00
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTemplateTypeParameter(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
rustllvm: Fix warnings about unused function parameters
2020-05-21 12:53:41 -05:00
const char *Name, size_t NameLen, LLVMMetadataRef Ty) {
Prepare for LLVM 11
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));
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateNameSpace(
LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
const char *Name, size_t NameLen, bool ExportSymbols) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return wrap(Builder->createNameSpace(
Use slices in preference to 0-terminated strings Additionally whenever possible match C API provided by the LLVM.
2020-03-05 18:00:00 -06:00
unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), ExportSymbols
));
debuginfo: Wrapped namespace facilities of llvm::DIBuilder
2013-09-05 06:29:30 -05:00
}
debuginfo: Support for recursive types.
2013-09-11 09:37:43 -05:00
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" void
Add template parameter debuginfo to generic types This changes debuginfo generation to add template parameters to generic types. With this change the DWARF now has DW_TAG_template_type_param for types, not just for functions, like: <2><40d>: Abbrev Number: 6 (DW_TAG_structure_type) <40e> DW_AT_name : (indirect string, offset: 0x375): Generic<i32> <412> DW_AT_byte_size : 4 <413> DW_AT_alignment : 4 ... <3><41f>: Abbrev Number: 8 (DW_TAG_template_type_param) <420> DW_AT_type : <0x42a> <424> DW_AT_name : (indirect string, offset: 0xa65e): T Closes #9224
2018-10-12 08:34:14 -05:00
LLVMRustDICompositeTypeReplaceArrays(LLVMRustDIBuilderRef Builder,
LLVMMetadataRef CompositeTy,
LLVMMetadataRef Elements,
LLVMMetadataRef Params) {
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
DICompositeType *Tmp = unwrapDI<DICompositeType>(CompositeTy);
Add template parameter debuginfo to generic types This changes debuginfo generation to add template parameters to generic types. With this change the DWARF now has DW_TAG_template_type_param for types, not just for functions, like: <2><40d>: Abbrev Number: 6 (DW_TAG_structure_type) <40e> DW_AT_name : (indirect string, offset: 0x375): Generic<i32> <412> DW_AT_byte_size : 4 <413> DW_AT_alignment : 4 ... <3><41f>: Abbrev Number: 8 (DW_TAG_template_type_param) <420> DW_AT_type : <0x42a> <424> DW_AT_name : (indirect string, offset: 0xa65e): T Closes #9224
2018-10-12 08:34:14 -05:00
Builder->replaceArrays(Tmp, DINodeArray(unwrap<MDTuple>(Elements)),
DINodeArray(unwrap<MDTuple>(Params)));
debuginfo: Support for recursive types.
2013-09-11 09:37:43 -05:00
}
have LLVM print type strings for us Example: void ({ i64, %tydesc*, i8*, i8*, i8 }*, i64*, %"struct.std::fmt::Formatter[#1]"*)* Before, we would print 20 levels deep due to recursion in the type definition.
2013-10-11 18:56:11 -05:00
rustc_codegen_llvm: avoid converting between DILocation and Value.
2020-02-10 14:52:20 -06:00
extern "C" LLVMMetadataRef
Remove the unused context from CreateDebugLocation This went unused in commit 88d874de6395, part of #68965.
2021-01-13 13:55:49 -06:00
LLVMRustDIBuilderCreateDebugLocation(unsigned Line, unsigned Column,
Support LLVM 12 in rustc
2020-11-03 15:47:16 -06:00
LLVMMetadataRef ScopeRef,
rustllvm: use LLVMMetadataRef
2017-07-21 06:15:36 -05:00
LLVMMetadataRef InlinedAt) {
Support LLVM 12 in rustc
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);
Update LLVM to rust-llvm-2015-01-30
2015-01-30 12:25:07 -06:00
}
RustWrapper: adapt for an LLVM API change No functional changes intended. The LLVM commit https://github.com/llvm/llvm-project/commit/ec501f15a8b8ace2b283732740d6d65d40d82e09 removed the signed version of `createExpression`. This adapts the Rust LLVM wrappers accordingly.
2022-01-03 04:25:33 -06:00
extern "C" uint64_t LLVMRustDIBuilderCreateOpDeref() {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return dwarf::DW_OP_deref;
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
}
RustWrapper: adapt for an LLVM API change No functional changes intended. The LLVM commit https://github.com/llvm/llvm-project/commit/ec501f15a8b8ace2b283732740d6d65d40d82e09 removed the signed version of `createExpression`. This adapts the Rust LLVM wrappers accordingly.
2022-01-03 04:25:33 -06:00
extern "C" uint64_t LLVMRustDIBuilderCreateOpPlusUconst() {
Update DW_OP_plus to DW_OP_plus_uconst LLVM <= 4.0 used a non-standard interpretation of `DW_OP_plus`. In the DWARF standard, this adds two items on the expressions stack. LLVM's behavior was more like DWARF's `DW_OP_plus_uconst` -- adding a constant that follows the op. The patch series starting with [D33892] switched to the standard DWARF interpretation, so we need to follow. [D33892]: https://reviews.llvm.org/D33892
2018-01-19 23:43:53 -06:00
return dwarf::DW_OP_plus_uconst;
}
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
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);
have LLVM print type strings for us Example: void ({ i64, %tydesc*, i8*, i8*, i8 }*, i64*, %"struct.std::fmt::Formatter[#1]"*)* Before, we would print 20 levels deep due to recursion in the type definition.
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
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
extern "C" void LLVMRustWriteValueToString(LLVMValueRef V,
RustStringRef Str) {
RawRustStringOstream OS(Str);
add NullOp::SizeOf and BinOp::Offset
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 << ")";
}
Issue #3511 - Rationalize temporary lifetimes. Major changes: - Define temporary scopes in a syntax-based way that basically defaults to the innermost statement or conditional block, except for in a `let` initializer, where we default to the innermost block. Rules are documented in the code, but not in the manual (yet). See new test run-pass/cleanup-value-scopes.rs for examples. - Refactors Datum to better define cleanup roles. - Refactor cleanup scopes to not be tied to basic blocks, permitting us to have a very large number of scopes (one per AST node). - Introduce nascent documentation in trans/doc.rs covering datums and cleanup in a more comprehensive way.
2014-01-15 13:39:08 -06:00
}
rustllvm: Add LLVMRustArrayType LLVM internally uses `uint64_t` for array size, but the corresponding C API (`LLVMArrayType`) uses `unsigned int` so ths value is truncated. Therefore rustc generates wrong type for fixed-sized large vector e.g. `[0 x i8]` for `[0u8, ..(1 << 32)]`. This patch adds `LLVMRustArrayType` function for `uint64_t` support.
2014-05-10 03:30:55 -05:00
// LLVMArrayType function does not support 64-bit ElementCount
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
extern "C" LLVMTypeRef LLVMRustArrayType(LLVMTypeRef ElementTy,
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
uint64_t ElementCount) {
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
return wrap(ArrayType::get(unwrap(ElementTy), ElementCount));
rustllvm: Add LLVMRustArrayType LLVM internally uses `uint64_t` for array size, but the corresponding C API (`LLVMArrayType`) uses `unsigned int` so ths value is truncated. Therefore rustc generates wrong type for fixed-sized large vector e.g. `[0 x i8]` for `[0u8, ..(1 << 32)]`. This patch adds `LLVMRustArrayType` function for `uint64_t` support.
2014-05-10 03:30:55 -05:00
}
Add -C remark for LLVM optimization remarks Fixes #17116.
2014-09-12 10:17:58 -05:00
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Twine, LLVMTwineRef)
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
extern "C" void LLVMRustWriteTwineToString(LLVMTwineRef T, RustStringRef Str) {
RawRustStringOstream OS(Str);
unwrap(T)->print(OS);
Add -C remark for LLVM optimization remarks Fixes #17116.
2014-09-12 10:17:58 -05:00
}
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" void LLVMRustUnpackOptimizationDiagnostic(
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
LLVMDiagnosticInfoRef DI, RustStringRef PassNameOut,
rustllvm: split DebugLoc in UnpackOptimizationDiagnostic
2017-07-21 07:29:23 -05:00
LLVMValueRef *FunctionOut, unsigned* Line, unsigned* Column,
RustStringRef FilenameOut, RustStringRef MessageOut) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
// Undefined to call this not on an optimization diagnostic!
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
llvm::DiagnosticInfoOptimizationBase *Opt =
static_cast<llvm::DiagnosticInfoOptimizationBase *>(unwrap(DI));
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
RawRustStringOstream PassNameOS(PassNameOut);
PassNameOS << Opt->getPassName();
*FunctionOut = wrap(&Opt->getFunction());
rustllvm: split DebugLoc in UnpackOptimizationDiagnostic
2017-07-21 07:29:23 -05:00
RawRustStringOstream FilenameOS(FilenameOut);
DiagnosticLocation loc = Opt->getLocation();
if (loc.isValid()) {
*Line = loc.getLine();
*Column = loc.getColumn();
Rebase to the llvm-project monorepo The new git submodule src/llvm-project is a monorepo replacing src/llvm and src/tools/{clang,lld,lldb}. This also serves as a rebase for these projects to the new 8.x branch from trunk. The src/llvm-emscripten fork is unchanged for now.
2019-01-16 11:59:03 -06:00
FilenameOS << loc.getAbsolutePath();
rustllvm: split DebugLoc in UnpackOptimizationDiagnostic
2017-07-21 07:29:23 -05:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
RawRustStringOstream MessageOS(MessageOut);
MessageOS << Opt->getMsg();
Add -C remark for LLVM optimization remarks Fixes #17116.
2014-09-12 10:17:58 -05:00
}
Handle assembler warnings properly
2020-06-09 08:37:59 -05:00
enum class LLVMRustDiagnosticLevel {
Error,
Warning,
Note,
Remark,
};
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
extern "C" void
Handle assembler warnings properly
2020-06-09 08:37:59 -05:00
LLVMRustUnpackInlineAsmDiagnostic(LLVMDiagnosticInfoRef DI,
LLVMRustDiagnosticLevel *LevelOut,
unsigned *CookieOut,
Handle SrcMgr diagnostics This is how InlineAsm diagnostics with source information are reported now. Previously a separate InlineAsm diagnostic handler was used.
2021-07-28 14:31:47 -05:00
LLVMTwineRef *MessageOut) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
// Undefined to call this not on an inline assembly diagnostic!
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
llvm::DiagnosticInfoInlineAsm *IA =
static_cast<llvm::DiagnosticInfoInlineAsm *>(unwrap(DI));
Better inline assembly errors
2015-01-22 12:43:39 -06:00
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
*CookieOut = IA->getLocCookie();
*MessageOut = wrap(&IA->getMsgStr());
Handle assembler warnings properly
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!");
}
Better inline assembly errors
2015-01-22 12:43:39 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
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);
Add -C remark for LLVM optimization remarks Fixes #17116.
2014-09-12 10:17:58 -05:00
}
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
enum class LLVMRustDiagnosticKind {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
Other,
InlineAsm,
StackSize,
DebugMetadataVersion,
SampleProfile,
OptimizationRemark,
OptimizationRemarkMissed,
OptimizationRemarkAnalysis,
OptimizationRemarkAnalysisFPCommute,
OptimizationRemarkAnalysisAliasing,
OptimizationRemarkOther,
OptimizationFailure,
librustc_llvm: Show PGO diagnostics properly. Signed-off-by: Emilio Cobos Álvarez <emilio@crisal.io>
2018-03-12 12:11:59 -05:00
PGOProfile,
rustc: Handle linker diagnostic from LLVM Previously linker diagnostic were being hidden when two modules were linked together but failed to link. This commit fixes the situation by ensuring that we have a diagnostic handler installed and also adds support for handling linker diagnostics.
2018-07-17 18:20:51 -05:00
Linker,
Update LLVM and add Unsupported diagnostic Secure entry functions do not support if arguments are passed on the stack. An "unsupported" diagnostic will be emitted by LLVM if that is the case. This commits adds support in Rust for that diagnostic so that an error will be output if that is the case! Signed-off-by: Hugues de Valon <hugues.devalon@arm.com>
2020-09-29 06:20:56 -05:00
Unsupported,
Handle SrcMgr diagnostics This is how InlineAsm diagnostics with source information are reported now. Previously a separate InlineAsm diagnostic handler was used.
2021-07-28 14:31:47 -05:00
SrcMgr,
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
};
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
static LLVMRustDiagnosticKind toRust(DiagnosticKind Kind) {
switch (Kind) {
Ran clang-format on src/rustllvm with llvm as the coding style.
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:
Recognize machine optimization remarks
2021-11-11 18:00:00 -06:00
case DK_MachineOptimizationRemark:
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return LLVMRustDiagnosticKind::OptimizationRemark;
case DK_OptimizationRemarkMissed:
Recognize machine optimization remarks
2021-11-11 18:00:00 -06:00
case DK_MachineOptimizationRemarkMissed:
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return LLVMRustDiagnosticKind::OptimizationRemarkMissed;
case DK_OptimizationRemarkAnalysis:
Recognize machine optimization remarks
2021-11-11 18:00:00 -06:00
case DK_MachineOptimizationRemarkAnalysis:
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return LLVMRustDiagnosticKind::OptimizationRemarkAnalysis;
case DK_OptimizationRemarkAnalysisFPCommute:
return LLVMRustDiagnosticKind::OptimizationRemarkAnalysisFPCommute;
case DK_OptimizationRemarkAnalysisAliasing:
return LLVMRustDiagnosticKind::OptimizationRemarkAnalysisAliasing;
librustc_llvm: Show PGO diagnostics properly. Signed-off-by: Emilio Cobos Álvarez <emilio@crisal.io>
2018-03-12 12:11:59 -05:00
case DK_PGOProfile:
return LLVMRustDiagnosticKind::PGOProfile;
rustc: Handle linker diagnostic from LLVM Previously linker diagnostic were being hidden when two modules were linked together but failed to link. This commit fixes the situation by ensuring that we have a diagnostic handler installed and also adds support for handling linker diagnostics.
2018-07-17 18:20:51 -05:00
case DK_Linker:
return LLVMRustDiagnosticKind::Linker;
Update LLVM and add Unsupported diagnostic Secure entry functions do not support if arguments are passed on the stack. An "unsupported" diagnostic will be emitted by LLVM if that is the case. This commits adds support in Rust for that diagnostic so that an error will be output if that is the case! Signed-off-by: Hugues de Valon <hugues.devalon@arm.com>
2020-09-29 06:20:56 -05:00
case DK_Unsupported:
return LLVMRustDiagnosticKind::Unsupported;
Handle SrcMgr diagnostics This is how InlineAsm diagnostics with source information are reported now. Previously a separate InlineAsm diagnostic handler was used.
2021-07-28 14:31:47 -05:00
case DK_SrcMgr:
return LLVMRustDiagnosticKind::SrcMgr;
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
default:
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
return (Kind >= DK_FirstRemark && Kind <= DK_LastRemark)
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
? LLVMRustDiagnosticKind::OptimizationRemarkOther
: LLVMRustDiagnosticKind::Other;
begin auditing the C++ types in RustWrapper
2016-08-01 18:35:09 -05:00
}
}
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" LLVMRustDiagnosticKind
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
LLVMRustGetDiagInfoKind(LLVMDiagnosticInfoRef DI) {
return toRust((DiagnosticKind)unwrap(DI)->getKind());
Add -C remark for LLVM optimization remarks Fixes #17116.
2014-09-12 10:17:58 -05:00
}
Handle assembler warnings properly
2020-06-09 08:37:59 -05:00
finish type-auditing rustllvm
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;
Prepare for LLVM 11
2020-06-25 20:52:41 -05:00
case Type::FixedVectorTyID:
return LLVMVectorTypeKind;
finish type-auditing rustllvm
2016-08-02 16:25:19 -05:00
case Type::X86_MMXTyID:
return LLVMX86_MMXTypeKind;
case Type::TokenTyID:
return LLVMTokenTypeKind;
Prepare for LLVM 11
2020-06-25 20:52:41 -05:00
case Type::ScalableVectorTyID:
return LLVMScalableVectorTypeKind;
case Type::BFloatTyID:
return LLVMBFloatTypeKind;
Support LLVM 12 in rustc
2020-11-03 15:47:16 -06:00
case Type::X86_AMXTyID:
return LLVMX86_AMXTypeKind;
RustWrapper: update for TypedPointerType in LLVM This is a result of https://reviews.llvm.org/D130592.
2022-08-04 10:31:01 -05:00
#if LLVM_VERSION_GE(15, 0) && LLVM_VERSION_LT(16, 0)
RustWrapper: explicitly don't handle DXILPointerTyID This new enum entry was introduced in https://reviews.llvm.org/D122268, and if I'm reading correctly there's no case where we'd ever encounter it in our uses of LLVM. To preserve the ability to compile this file with -Werror -Wswitch we add an explicit case for this entry.
2022-04-28 12:53:52 -05:00
case Type::DXILPointerTyID:
report_fatal_error("Rust does not support DirectX typed pointers.");
break;
RustWrapper: update for TypedPointerType in LLVM This is a result of https://reviews.llvm.org/D130592.
2022-08-04 10:31:01 -05:00
#endif
#if LLVM_VERSION_GE(16, 0)
case Type::TypedPointerTyID:
report_fatal_error("Rust does not support typed pointers.");
break;
RustWrapper: explicitly don't handle DXILPointerTyID This new enum entry was introduced in https://reviews.llvm.org/D122268, and if I'm reading correctly there's no case where we'd ever encounter it in our uses of LLVM. To preserve the ability to compile this file with -Werror -Wswitch we add an explicit case for this entry.
2022-04-28 12:53:52 -05:00
#endif
finish type-auditing rustllvm
2016-08-02 16:25:19 -05:00
}
[rustllvm] Use report_fatal_error over llvm_unreachable This makes it more robust when assertions are disabled, crashing instead of causing UB. Also introduces a tidy check to enforce this rule, which in turn necessitated making tidy run on src/rustllvm. Fixes #44020
2017-11-20 10:47:29 -06:00
report_fatal_error("Unhandled TypeID.");
finish type-auditing rustllvm
2016-08-02 16:25:19 -05:00
}
Add -C remark for LLVM optimization remarks Fixes #17116.
2014-09-12 10:17:58 -05:00
Translate inline assembly errors back to source locations Fixes #17552.
2014-09-27 03:33:36 -05:00
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SMDiagnostic, LLVMSMDiagnosticRef)
Handle SrcMgr diagnostics This is how InlineAsm diagnostics with source information are reported now. Previously a separate InlineAsm diagnostic handler was used.
2021-07-28 14:31:47 -05:00
extern "C" LLVMSMDiagnosticRef LLVMRustGetSMDiagnostic(
LLVMDiagnosticInfoRef DI, unsigned *Cookie) {
llvm::DiagnosticInfoSrcMgr *SM = static_cast<llvm::DiagnosticInfoSrcMgr *>(unwrap(DI));
*Cookie = SM->getLocCookie();
return wrap(&SM->getSMDiag());
}
Improve inline asm error diagnostics
2020-05-26 14:07:59 -05:00
extern "C" bool LLVMRustUnpackSMDiagnostic(LLVMSMDiagnosticRef DRef,
RustStringRef MessageOut,
RustStringRef BufferOut,
Handle assembler warnings properly
2020-06-09 08:37:59 -05:00
LLVMRustDiagnosticLevel* LevelOut,
Improve inline asm error diagnostics
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();
Handle assembler warnings properly
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!");
}
Improve inline asm error diagnostics
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;
Translate inline assembly errors back to source locations Fixes #17552.
2014-09-27 03:33:36 -05:00
}
rustc_trans: Update LLVMBuildLandingPad signature The C API of this function changed so it no longer takes a personality function. A shim was introduced to call the right LLVM function (depending on which version we're compiled against) to set the personality function on the outer function. The compiler only ever sets one personality function for all generated functions, so this should be equivalent.
2015-06-30 10:56:56 -05:00
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
extern "C" LLVMValueRef LLVMRustBuildCleanupPad(LLVMBuilderRef B,
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
LLVMValueRef ParentPad,
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
unsigned ArgCount,
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
LLVMValueRef *LLArgs,
const char *Name) {
Value **Args = unwrap(LLArgs);
Switching from NULL to nullptr in src/rustllvm.
2016-12-30 06:21:21 -06:00
if (ParentPad == nullptr) {
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
ParentPad = wrap(Constant::getNullValue(Ty));
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
return wrap(unwrap(B)->CreateCleanupPad(
unwrap(ParentPad), ArrayRef<Value *>(Args, ArgCount), Name));
trans: Reimplement unwinding on MSVC This commit transitions the compiler to using the new exception handling instructions in LLVM for implementing unwinding for MSVC. This affects both 32 and 64-bit MSVC as they're both now using SEH-based strategies. In terms of standard library support, lots more details about how SEH unwinding is implemented can be found in the commits. In terms of trans, this change necessitated a few modifications: * Branches were added to detect when the old landingpad instruction is used or the new cleanuppad instruction is used to `trans::cleanup`. * The return value from `cleanuppad` is not stored in an `alloca` (because it cannot be). * Each block in trans now has an `Option<LandingPad>` instead of `is_lpad: bool` for indicating whether it's in a landing pad or not. The new exception handling intrinsics require that on MSVC each `call` inside of a landing pad is annotated with which landing pad that it's in. This change to the basic block means that whenever a `call` or `invoke` instruction is generated we know whether to annotate it as part of a cleanuppad or not. * Lots of modifications were made to the instruction builders to construct the new instructions as well as pass the tagging information for the call/invoke instructions. * The translation of the `try` intrinsics for MSVC has been overhauled to use the new `catchpad` instruction. The filter function is now also a rustc-generated function instead of a purely libstd-defined function. The libstd definition still exists, it just has a stable ABI across architectures and leaves some of the really weird implementation details to the compiler (e.g. the `localescape` and `localrecover` intrinsics).
2015-10-23 20:18:44 -05:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
extern "C" LLVMValueRef LLVMRustBuildCleanupRet(LLVMBuilderRef B,
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
LLVMValueRef CleanupPad,
LLVMBasicBlockRef UnwindBB) {
CleanupPadInst *Inst = cast<CleanupPadInst>(unwrap(CleanupPad));
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
return wrap(unwrap(B)->CreateCleanupRet(Inst, unwrap(UnwindBB)));
trans: Reimplement unwinding on MSVC This commit transitions the compiler to using the new exception handling instructions in LLVM for implementing unwinding for MSVC. This affects both 32 and 64-bit MSVC as they're both now using SEH-based strategies. In terms of standard library support, lots more details about how SEH unwinding is implemented can be found in the commits. In terms of trans, this change necessitated a few modifications: * Branches were added to detect when the old landingpad instruction is used or the new cleanuppad instruction is used to `trans::cleanup`. * The return value from `cleanuppad` is not stored in an `alloca` (because it cannot be). * Each block in trans now has an `Option<LandingPad>` instead of `is_lpad: bool` for indicating whether it's in a landing pad or not. The new exception handling intrinsics require that on MSVC each `call` inside of a landing pad is annotated with which landing pad that it's in. This change to the basic block means that whenever a `call` or `invoke` instruction is generated we know whether to annotate it as part of a cleanuppad or not. * Lots of modifications were made to the instruction builders to construct the new instructions as well as pass the tagging information for the call/invoke instructions. * The translation of the `try` intrinsics for MSVC has been overhauled to use the new `catchpad` instruction. The filter function is now also a rustc-generated function instead of a purely libstd-defined function. The libstd definition still exists, it just has a stable ABI across architectures and leaves some of the really weird implementation details to the compiler (e.g. the `localescape` and `localrecover` intrinsics).
2015-10-23 20:18:44 -05:00
}
extern "C" LLVMValueRef
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
LLVMRustBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
unsigned ArgCount, LLVMValueRef *LLArgs, const char *Name) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
Value **Args = unwrap(LLArgs);
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
return wrap(unwrap(B)->CreateCatchPad(
unwrap(ParentPad), ArrayRef<Value *>(Args, ArgCount), Name));
trans: Reimplement unwinding on MSVC This commit transitions the compiler to using the new exception handling instructions in LLVM for implementing unwinding for MSVC. This affects both 32 and 64-bit MSVC as they're both now using SEH-based strategies. In terms of standard library support, lots more details about how SEH unwinding is implemented can be found in the commits. In terms of trans, this change necessitated a few modifications: * Branches were added to detect when the old landingpad instruction is used or the new cleanuppad instruction is used to `trans::cleanup`. * The return value from `cleanuppad` is not stored in an `alloca` (because it cannot be). * Each block in trans now has an `Option<LandingPad>` instead of `is_lpad: bool` for indicating whether it's in a landing pad or not. The new exception handling intrinsics require that on MSVC each `call` inside of a landing pad is annotated with which landing pad that it's in. This change to the basic block means that whenever a `call` or `invoke` instruction is generated we know whether to annotate it as part of a cleanuppad or not. * Lots of modifications were made to the instruction builders to construct the new instructions as well as pass the tagging information for the call/invoke instructions. * The translation of the `try` intrinsics for MSVC has been overhauled to use the new `catchpad` instruction. The filter function is now also a rustc-generated function instead of a purely libstd-defined function. The libstd definition still exists, it just has a stable ABI across architectures and leaves some of the really weird implementation details to the compiler (e.g. the `localescape` and `localrecover` intrinsics).
2015-10-23 20:18:44 -05:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
extern "C" LLVMValueRef LLVMRustBuildCatchRet(LLVMBuilderRef B,
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
LLVMValueRef Pad,
LLVMBasicBlockRef BB) {
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
return wrap(unwrap(B)->CreateCatchRet(cast<CatchPadInst>(unwrap(Pad)),
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
unwrap(BB)));
trans: Reimplement unwinding on MSVC This commit transitions the compiler to using the new exception handling instructions in LLVM for implementing unwinding for MSVC. This affects both 32 and 64-bit MSVC as they're both now using SEH-based strategies. In terms of standard library support, lots more details about how SEH unwinding is implemented can be found in the commits. In terms of trans, this change necessitated a few modifications: * Branches were added to detect when the old landingpad instruction is used or the new cleanuppad instruction is used to `trans::cleanup`. * The return value from `cleanuppad` is not stored in an `alloca` (because it cannot be). * Each block in trans now has an `Option<LandingPad>` instead of `is_lpad: bool` for indicating whether it's in a landing pad or not. The new exception handling intrinsics require that on MSVC each `call` inside of a landing pad is annotated with which landing pad that it's in. This change to the basic block means that whenever a `call` or `invoke` instruction is generated we know whether to annotate it as part of a cleanuppad or not. * Lots of modifications were made to the instruction builders to construct the new instructions as well as pass the tagging information for the call/invoke instructions. * The translation of the `try` intrinsics for MSVC has been overhauled to use the new `catchpad` instruction. The filter function is now also a rustc-generated function instead of a purely libstd-defined function. The libstd definition still exists, it just has a stable ABI across architectures and leaves some of the really weird implementation details to the compiler (e.g. the `localescape` and `localrecover` intrinsics).
2015-10-23 20:18:44 -05:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
extern "C" LLVMValueRef LLVMRustBuildCatchSwitch(LLVMBuilderRef B,
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
LLVMValueRef ParentPad,
LLVMBasicBlockRef BB,
unsigned NumHandlers,
const char *Name) {
Switching from NULL to nullptr in src/rustllvm.
2016-12-30 06:21:21 -06:00
if (ParentPad == nullptr) {
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
ParentPad = wrap(Constant::getNullValue(Ty));
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
return wrap(unwrap(B)->CreateCatchSwitch(unwrap(ParentPad), unwrap(BB),
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
NumHandlers, Name));
trans: Reimplement unwinding on MSVC This commit transitions the compiler to using the new exception handling instructions in LLVM for implementing unwinding for MSVC. This affects both 32 and 64-bit MSVC as they're both now using SEH-based strategies. In terms of standard library support, lots more details about how SEH unwinding is implemented can be found in the commits. In terms of trans, this change necessitated a few modifications: * Branches were added to detect when the old landingpad instruction is used or the new cleanuppad instruction is used to `trans::cleanup`. * The return value from `cleanuppad` is not stored in an `alloca` (because it cannot be). * Each block in trans now has an `Option<LandingPad>` instead of `is_lpad: bool` for indicating whether it's in a landing pad or not. The new exception handling intrinsics require that on MSVC each `call` inside of a landing pad is annotated with which landing pad that it's in. This change to the basic block means that whenever a `call` or `invoke` instruction is generated we know whether to annotate it as part of a cleanuppad or not. * Lots of modifications were made to the instruction builders to construct the new instructions as well as pass the tagging information for the call/invoke instructions. * The translation of the `try` intrinsics for MSVC has been overhauled to use the new `catchpad` instruction. The filter function is now also a rustc-generated function instead of a purely libstd-defined function. The libstd definition still exists, it just has a stable ABI across architectures and leaves some of the really weird implementation details to the compiler (e.g. the `localescape` and `localrecover` intrinsics).
2015-10-23 20:18:44 -05:00
}
Ran clang-format on src/rustllvm with llvm as the coding style.
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));
trans: Reimplement unwinding on MSVC This commit transitions the compiler to using the new exception handling instructions in LLVM for implementing unwinding for MSVC. This affects both 32 and 64-bit MSVC as they're both now using SEH-based strategies. In terms of standard library support, lots more details about how SEH unwinding is implemented can be found in the commits. In terms of trans, this change necessitated a few modifications: * Branches were added to detect when the old landingpad instruction is used or the new cleanuppad instruction is used to `trans::cleanup`. * The return value from `cleanuppad` is not stored in an `alloca` (because it cannot be). * Each block in trans now has an `Option<LandingPad>` instead of `is_lpad: bool` for indicating whether it's in a landing pad or not. The new exception handling intrinsics require that on MSVC each `call` inside of a landing pad is annotated with which landing pad that it's in. This change to the basic block means that whenever a `call` or `invoke` instruction is generated we know whether to annotate it as part of a cleanuppad or not. * Lots of modifications were made to the instruction builders to construct the new instructions as well as pass the tagging information for the call/invoke instructions. * The translation of the `try` intrinsics for MSVC has been overhauled to use the new `catchpad` instruction. The filter function is now also a rustc-generated function instead of a purely libstd-defined function. The libstd definition still exists, it just has a stable ABI across architectures and leaves some of the really weird implementation details to the compiler (e.g. the `localescape` and `localrecover` intrinsics).
2015-10-23 20:18:44 -05:00
}
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" OperandBundleDef *LLVMRustBuildOperandBundleDef(const char *Name,
LLVMValueRef *Inputs,
unsigned NumInputs) {
trans: Reimplement unwinding on MSVC This commit transitions the compiler to using the new exception handling instructions in LLVM for implementing unwinding for MSVC. This affects both 32 and 64-bit MSVC as they're both now using SEH-based strategies. In terms of standard library support, lots more details about how SEH unwinding is implemented can be found in the commits. In terms of trans, this change necessitated a few modifications: * Branches were added to detect when the old landingpad instruction is used or the new cleanuppad instruction is used to `trans::cleanup`. * The return value from `cleanuppad` is not stored in an `alloca` (because it cannot be). * Each block in trans now has an `Option<LandingPad>` instead of `is_lpad: bool` for indicating whether it's in a landing pad or not. The new exception handling intrinsics require that on MSVC each `call` inside of a landing pad is annotated with which landing pad that it's in. This change to the basic block means that whenever a `call` or `invoke` instruction is generated we know whether to annotate it as part of a cleanuppad or not. * Lots of modifications were made to the instruction builders to construct the new instructions as well as pass the tagging information for the call/invoke instructions. * The translation of the `try` intrinsics for MSVC has been overhauled to use the new `catchpad` instruction. The filter function is now also a rustc-generated function instead of a purely libstd-defined function. The libstd definition still exists, it just has a stable ABI across architectures and leaves some of the really weird implementation details to the compiler (e.g. the `localescape` and `localrecover` intrinsics).
2015-10-23 20:18:44 -05:00
return new OperandBundleDef(Name, makeArrayRef(unwrap(Inputs), NumInputs));
}
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" void LLVMRustFreeOperandBundleDef(OperandBundleDef *Bundle) {
trans: Reimplement unwinding on MSVC This commit transitions the compiler to using the new exception handling instructions in LLVM for implementing unwinding for MSVC. This affects both 32 and 64-bit MSVC as they're both now using SEH-based strategies. In terms of standard library support, lots more details about how SEH unwinding is implemented can be found in the commits. In terms of trans, this change necessitated a few modifications: * Branches were added to detect when the old landingpad instruction is used or the new cleanuppad instruction is used to `trans::cleanup`. * The return value from `cleanuppad` is not stored in an `alloca` (because it cannot be). * Each block in trans now has an `Option<LandingPad>` instead of `is_lpad: bool` for indicating whether it's in a landing pad or not. The new exception handling intrinsics require that on MSVC each `call` inside of a landing pad is annotated with which landing pad that it's in. This change to the basic block means that whenever a `call` or `invoke` instruction is generated we know whether to annotate it as part of a cleanuppad or not. * Lots of modifications were made to the instruction builders to construct the new instructions as well as pass the tagging information for the call/invoke instructions. * The translation of the `try` intrinsics for MSVC has been overhauled to use the new `catchpad` instruction. The filter function is now also a rustc-generated function instead of a purely libstd-defined function. The libstd definition still exists, it just has a stable ABI across architectures and leaves some of the really weird implementation details to the compiler (e.g. the `localescape` and `localrecover` intrinsics).
2015-10-23 20:18:44 -05:00
delete Bundle;
}
Prepare call/invoke for opaque pointers Rather than relying on `getPointerElementType()` from LLVM function pointers, we now pass the function type explicitly when building `call` or `invoke` instructions.
2021-08-03 17:09:57 -05:00
extern "C" LLVMValueRef LLVMRustBuildCall(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
LLVMValueRef *Args, unsigned NumArgs,
librustc_codegen_llvm: Use slices instead of 0-terminated strings Changed functions: * LLVMRustGetOrInsertFunction * LLVMRustGetNamedValue * LLVMRustBuildCall (removed unused name argument) * LLVMRustInlineAsm * LLVMRustInlineAsmVerify * LLVMRustAppendModuleInlineAsm
2020-03-09 19:00:00 -05:00
OperandBundleDef *Bundle) {
Prepare for LLVM 11
2020-06-25 20:52:41 -05:00
Value *Callee = unwrap(Fn);
Prepare call/invoke for opaque pointers Rather than relying on `getPointerElementType()` from LLVM function pointers, we now pass the function type explicitly when building `call` or `invoke` instructions.
2021-08-03 17:09:57 -05:00
FunctionType *FTy = unwrap<FunctionType>(Ty);
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
unsigned Len = Bundle ? 1 : 0;
ArrayRef<OperandBundleDef> Bundles = makeArrayRef(Bundle, Len);
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
return wrap(unwrap(B)->CreateCall(
Prepare for LLVM 11
2020-06-25 20:52:41 -05:00
FTy, Callee, makeArrayRef(unwrap(Args), NumArgs), Bundles));
trans: Reimplement unwinding on MSVC This commit transitions the compiler to using the new exception handling instructions in LLVM for implementing unwinding for MSVC. This affects both 32 and 64-bit MSVC as they're both now using SEH-based strategies. In terms of standard library support, lots more details about how SEH unwinding is implemented can be found in the commits. In terms of trans, this change necessitated a few modifications: * Branches were added to detect when the old landingpad instruction is used or the new cleanuppad instruction is used to `trans::cleanup`. * The return value from `cleanuppad` is not stored in an `alloca` (because it cannot be). * Each block in trans now has an `Option<LandingPad>` instead of `is_lpad: bool` for indicating whether it's in a landing pad or not. The new exception handling intrinsics require that on MSVC each `call` inside of a landing pad is annotated with which landing pad that it's in. This change to the basic block means that whenever a `call` or `invoke` instruction is generated we know whether to annotate it as part of a cleanuppad or not. * Lots of modifications were made to the instruction builders to construct the new instructions as well as pass the tagging information for the call/invoke instructions. * The translation of the `try` intrinsics for MSVC has been overhauled to use the new `catchpad` instruction. The filter function is now also a rustc-generated function instead of a purely libstd-defined function. The libstd definition still exists, it just has a stable ABI across architectures and leaves some of the really weird implementation details to the compiler (e.g. the `localescape` and `localrecover` intrinsics).
2015-10-23 20:18:44 -05:00
}
Generating the coverage map rustc now generates the coverage map and can support (limited) coverage report generation, at the function level. Example: $ BUILD=$HOME/rust/build/x86_64-unknown-linux-gnu $ $BUILD/stage1/bin/rustc -Zinstrument-coverage \ $HOME/rust/src/test/run-make-fulldeps/instrument-coverage/main.rs $ LLVM_PROFILE_FILE="main.profraw" ./main called $ $BUILD/llvm/bin/llvm-profdata merge -sparse main.profraw -o main.profdata $ $BUILD/llvm/bin/llvm-cov show --instr-profile=main.profdata main 1| 1|pub fn will_be_called() { 2| 1| println!("called"); 3| 1|} 4| | 5| 0|pub fn will_not_be_called() { 6| 0| println!("should not have been called"); 7| 0|} 8| | 9| 1|fn main() { 10| 1| let less = 1; 11| 1| let more = 100; 12| 1| 13| 1| if less < more { 14| 1| will_be_called(); 15| 1| } else { 16| 1| will_not_be_called(); 17| 1| } 18| 1|}
2020-07-02 13:27:15 -05:00
extern "C" LLVMValueRef LLVMRustGetInstrProfIncrementIntrinsic(LLVMModuleRef M) {
[WIP] injects llvm intrinsic instrprof.increment for coverage reports This initial version only injects counters at the top of each function. Rust Coverage will require injecting additional counters at each conditional code branch.
2020-06-03 23:19:34 -05:00
return wrap(llvm::Intrinsic::getDeclaration(unwrap(M),
(llvm::Intrinsic::ID)llvm::Intrinsic::instrprof_increment));
}
Support memcpy/memmove with differing src/dst alignment If LLVM 7 is used, generate memcpy/memmove with differing src/dst alignment. I've added new FFI functions to construct these through the builder API, which is more convenient than dealing with differing intrinsic signatures depending on the LLVM version.
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) {
Switch to using MaybeAlign APIs The integer versions are deprecated
2019-12-31 07:32:01 -06:00
return wrap(unwrap(B)->CreateMemCpy(
unwrap(Dst), MaybeAlign(DstAlign),
unwrap(Src), MaybeAlign(SrcAlign),
unwrap(Size), IsVolatile));
Support memcpy/memmove with differing src/dst alignment If LLVM 7 is used, generate memcpy/memmove with differing src/dst alignment. I've added new FFI functions to construct these through the builder API, which is more convenient than dealing with differing intrinsic signatures depending on the LLVM version.
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) {
Switch to using MaybeAlign APIs The integer versions are deprecated
2019-12-31 07:32:01 -06:00
return wrap(unwrap(B)->CreateMemMove(
unwrap(Dst), MaybeAlign(DstAlign),
unwrap(Src), MaybeAlign(SrcAlign),
unwrap(Size), IsVolatile));
Support memcpy/memmove with differing src/dst alignment If LLVM 7 is used, generate memcpy/memmove with differing src/dst alignment. I've added new FFI functions to construct these through the builder API, which is more convenient than dealing with differing intrinsic signatures depending on the LLVM version.
2018-11-02 17:38:16 -05:00
}
Use IRBuilder to create memset To avoid creating memsets with outdated signature. For some reason SROA chokes on this when using NewPM.
2020-01-05 15:32:15 -06:00
extern "C" LLVMValueRef LLVMRustBuildMemSet(LLVMBuilderRef B,
LLVMValueRef Dst, unsigned DstAlign,
LLVMValueRef Val,
LLVMValueRef Size, bool IsVolatile) {
Update CreateMemSet() usage for LLVM 10
2020-03-02 15:37:55 -06:00
return wrap(unwrap(B)->CreateMemSet(
unwrap(Dst), unwrap(Val), unwrap(Size), MaybeAlign(DstAlign), IsVolatile));
Use IRBuilder to create memset To avoid creating memsets with outdated signature. For some reason SROA chokes on this when using NewPM.
2020-01-05 15:32:15 -06:00
}
trans: Reimplement unwinding on MSVC This commit transitions the compiler to using the new exception handling instructions in LLVM for implementing unwinding for MSVC. This affects both 32 and 64-bit MSVC as they're both now using SEH-based strategies. In terms of standard library support, lots more details about how SEH unwinding is implemented can be found in the commits. In terms of trans, this change necessitated a few modifications: * Branches were added to detect when the old landingpad instruction is used or the new cleanuppad instruction is used to `trans::cleanup`. * The return value from `cleanuppad` is not stored in an `alloca` (because it cannot be). * Each block in trans now has an `Option<LandingPad>` instead of `is_lpad: bool` for indicating whether it's in a landing pad or not. The new exception handling intrinsics require that on MSVC each `call` inside of a landing pad is annotated with which landing pad that it's in. This change to the basic block means that whenever a `call` or `invoke` instruction is generated we know whether to annotate it as part of a cleanuppad or not. * Lots of modifications were made to the instruction builders to construct the new instructions as well as pass the tagging information for the call/invoke instructions. * The translation of the `try` intrinsics for MSVC has been overhauled to use the new `catchpad` instruction. The filter function is now also a rustc-generated function instead of a purely libstd-defined function. The libstd definition still exists, it just has a stable ABI across architectures and leaves some of the really weird implementation details to the compiler (e.g. the `localescape` and `localrecover` intrinsics).
2015-10-23 20:18:44 -05:00
extern "C" LLVMValueRef
Prepare call/invoke for opaque pointers Rather than relying on `getPointerElementType()` from LLVM function pointers, we now pass the function type explicitly when building `call` or `invoke` instructions.
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) {
Prepare for LLVM 11
2020-06-25 20:52:41 -05:00
Value *Callee = unwrap(Fn);
Prepare call/invoke for opaque pointers Rather than relying on `getPointerElementType()` from LLVM function pointers, we now pass the function type explicitly when building `call` or `invoke` instructions.
2021-08-03 17:09:57 -05:00
FunctionType *FTy = unwrap<FunctionType>(Ty);
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
unsigned Len = Bundle ? 1 : 0;
ArrayRef<OperandBundleDef> Bundles = makeArrayRef(Bundle, Len);
Prepare for LLVM 11
2020-06-25 20:52:41 -05:00
return wrap(unwrap(B)->CreateInvoke(FTy, Callee, unwrap(Then), unwrap(Catch),
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
makeArrayRef(unwrap(Args), NumArgs),
Bundles, Name));
trans: Reimplement unwinding on MSVC This commit transitions the compiler to using the new exception handling instructions in LLVM for implementing unwinding for MSVC. This affects both 32 and 64-bit MSVC as they're both now using SEH-based strategies. In terms of standard library support, lots more details about how SEH unwinding is implemented can be found in the commits. In terms of trans, this change necessitated a few modifications: * Branches were added to detect when the old landingpad instruction is used or the new cleanuppad instruction is used to `trans::cleanup`. * The return value from `cleanuppad` is not stored in an `alloca` (because it cannot be). * Each block in trans now has an `Option<LandingPad>` instead of `is_lpad: bool` for indicating whether it's in a landing pad or not. The new exception handling intrinsics require that on MSVC each `call` inside of a landing pad is annotated with which landing pad that it's in. This change to the basic block means that whenever a `call` or `invoke` instruction is generated we know whether to annotate it as part of a cleanuppad or not. * Lots of modifications were made to the instruction builders to construct the new instructions as well as pass the tagging information for the call/invoke instructions. * The translation of the `try` intrinsics for MSVC has been overhauled to use the new `catchpad` instruction. The filter function is now also a rustc-generated function instead of a purely libstd-defined function. The libstd definition still exists, it just has a stable ABI across architectures and leaves some of the really weird implementation details to the compiler (e.g. the `localescape` and `localrecover` intrinsics).
2015-10-23 20:18:44 -05:00
}
Implement filling drop in MIR Hopefully the author caught all the cases. For the mir_dynamic_drops_3 test case the ratio of memsets to other instructions is 12%. On the other hand we actually do not double drop for at least the test cases provided anymore in MIR.
2016-02-04 11:40:28 -06:00
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" void LLVMRustPositionBuilderAtStart(LLVMBuilderRef B,
LLVMBasicBlockRef BB) {
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
auto Point = unwrap(BB)->getFirstInsertionPt();
unwrap(B)->SetInsertPoint(unwrap(BB), Point);
Implement filling drop in MIR Hopefully the author caught all the cases. For the mir_dynamic_drops_3 test case the ratio of memsets to other instructions is 12%. On the other hand we actually do not double drop for at least the test cases provided anymore in MIR.
2016-02-04 11:40:28 -06:00
}
Use weak_odr linkage when reusing definitions across codegen units When reuing a definition across codegen units, we obviously cannot use internal linkage, but using external linkage means that we can end up with multiple conflicting definitions of a single symbol across multiple crates. Since the definitions should all be equal semantically, we can use weak_odr linkage to resolve the situation. Fixes #32518
2016-03-28 10:57:31 -05:00
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" void LLVMRustSetComdat(LLVMModuleRef M, LLVMValueRef V,
Migrate to LLVM{Get,Set}ValueName2 The deprecated `LLVM{Get,Set}ValueName` only work with NUL-terminated strings, but the `2` variants use explicit lengths, which fits better with Rust strings and slices. We now use these in new helper functions `llvm::{get,set}_value_name` that convert to/from `&[u8]`.
2019-12-04 14:00:28 -06:00
const char *Name, size_t NameLen) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
Triple TargetTriple(unwrap(M)->getTargetTriple());
GlobalObject *GV = unwrap<GlobalObject>(V);
Upgrades the coverage map to Version 4 Changes the coverage map injected into binaries compiled with `-Zinstrument-coverage` to LLVM Coverage Mapping Format, Version 4 (from Version 3). Note, binaries compiled with this version will require LLVM tools from at least LLVM Version 11.
2020-11-23 14:56:07 -06:00
if (TargetTriple.supportsCOMDAT()) {
Migrate to LLVM{Get,Set}ValueName2 The deprecated `LLVM{Get,Set}ValueName` only work with NUL-terminated strings, but the `2` variants use explicit lengths, which fits better with Rust strings and slices. We now use these in new helper functions `llvm::{get,set}_value_name` that convert to/from `&[u8]`.
2019-12-04 14:00:28 -06:00
StringRef NameRef(Name, NameLen);
GV->setComdat(unwrap(M)->getOrInsertComdat(NameRef));
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Use weak_odr linkage when reusing definitions across codegen units When reuing a definition across codegen units, we obviously cannot use internal linkage, but using external linkage means that we can end up with multiple conflicting definitions of a single symbol across multiple crates. Since the definitions should all be equal semantically, we can use weak_odr linkage to resolve the situation. Fixes #32518
2016-03-28 10:57:31 -05:00
}
Fix incorrect LLVM Linkage enum The `Linkage` enum in librustc_llvm got out of sync with the version in LLVM and it caused two variants of the #[linkage=""] attribute to break. This adds the functions `LLVMRustGetLinkage` and `LLVMRustSetLinkage` which convert between the Rust Linkage enum and the LLVM one, which should stop this from breaking every time LLVM changes it. Fixes #33992
2016-09-01 13:52:33 -05:00
enum class LLVMRustLinkage {
Ran clang-format on src/rustllvm with llvm as the coding style.
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,
Fix incorrect LLVM Linkage enum The `Linkage` enum in librustc_llvm got out of sync with the version in LLVM and it caused two variants of the #[linkage=""] attribute to break. This adds the functions `LLVMRustGetLinkage` and `LLVMRustSetLinkage` which convert between the Rust Linkage enum and the LLVM one, which should stop this from breaking every time LLVM changes it. Fixes #33992
2016-09-01 13:52:33 -05:00
};
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
static LLVMRustLinkage toRust(LLVMLinkage Linkage) {
switch (Linkage) {
Ran clang-format on src/rustllvm with llvm as the coding style.
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:
[rustllvm] Use report_fatal_error over llvm_unreachable This makes it more robust when assertions are disabled, crashing instead of causing UB. Also introduces a tidy check to enforce this rule, which in turn necessitated making tidy run on src/rustllvm. Fixes #44020
2017-11-20 10:47:29 -06:00
report_fatal_error("Invalid LLVMRustLinkage value!");
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
}
Fix incorrect LLVM Linkage enum The `Linkage` enum in librustc_llvm got out of sync with the version in LLVM and it caused two variants of the #[linkage=""] attribute to break. This adds the functions `LLVMRustGetLinkage` and `LLVMRustSetLinkage` which convert between the Rust Linkage enum and the LLVM one, which should stop this from breaking every time LLVM changes it. Fixes #33992
2016-09-01 13:52:33 -05:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
static LLVMLinkage fromRust(LLVMRustLinkage Linkage) {
switch (Linkage) {
Ran clang-format on src/rustllvm with llvm as the coding style.
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;
}
[rustllvm] Use report_fatal_error over llvm_unreachable This makes it more robust when assertions are disabled, crashing instead of causing UB. Also introduces a tidy check to enforce this rule, which in turn necessitated making tidy run on src/rustllvm. Fixes #44020
2017-11-20 10:47:29 -06:00
report_fatal_error("Invalid LLVMRustLinkage value!");
Fix incorrect LLVM Linkage enum The `Linkage` enum in librustc_llvm got out of sync with the version in LLVM and it caused two variants of the #[linkage=""] attribute to break. This adds the functions `LLVMRustGetLinkage` and `LLVMRustSetLinkage` which convert between the Rust Linkage enum and the LLVM one, which should stop this from breaking every time LLVM changes it. Fixes #33992
2016-09-01 13:52:33 -05:00
}
extern "C" LLVMRustLinkage LLVMRustGetLinkage(LLVMValueRef V) {
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
return toRust(LLVMGetLinkage(V));
Fix incorrect LLVM Linkage enum The `Linkage` enum in librustc_llvm got out of sync with the version in LLVM and it caused two variants of the #[linkage=""] attribute to break. This adds the functions `LLVMRustGetLinkage` and `LLVMRustSetLinkage` which convert between the Rust Linkage enum and the LLVM one, which should stop this from breaking every time LLVM changes it. Fixes #33992
2016-09-01 13:52:33 -05:00
}
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" void LLVMRustSetLinkage(LLVMValueRef V,
LLVMRustLinkage RustLinkage) {
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
LLVMSetLinkage(V, fromRust(RustLinkage));
Fix incorrect LLVM Linkage enum The `Linkage` enum in librustc_llvm got out of sync with the version in LLVM and it caused two variants of the #[linkage=""] attribute to break. This adds the functions `LLVMRustGetLinkage` and `LLVMRustSetLinkage` which convert between the Rust Linkage enum and the LLVM one, which should stop this from breaking every time LLVM changes it. Fixes #33992
2016-09-01 13:52:33 -05:00
}
Use llvm::Attribute API instead of "raw value" APIs, which will be removed in LLVM 4.0. The librustc_llvm API remains mostly unchanged, except that llvm::Attribute is no longer a bitflag but represents only a *single* attribute. The ability to store many attributes in a small number of bits and modify them without interacting with LLVM is only used in rustc_trans::abi and closely related modules, and only attributes for function arguments are considered there. Thus rustc_trans::abi now has its own bit-packed representation of argument attributes, which are translated to rustc_llvm::Attribute when applying the attributes.
2016-11-16 16:36:08 -06:00
Replace LLVMConstInBoundsGEP with LLVMConstInBoundsGEP2* A custom reimplementation of LLVMConstInBoundsGEP2 is used, since the LLVM contains a declaration of LLVMConstInBoundsGEP2 but not the implementation.
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));
}
Introduce a fallible variant of LLVMConstIntGetZExtValue which verifies that a constant bit width is within 64 bits or fails.
2022-09-08 19:00:00 -05:00
extern "C" bool LLVMRustConstIntGetZExtValue(LLVMValueRef CV, uint64_t *value) {
auto C = unwrap<llvm::ConstantInt>(CV);
if (C->getBitWidth() > 64)
return false;
*value = C->getZExtValue();
return true;
}
Add a way to retrieve constant value in 128 bits Fixes rebase fallout, makes code correct in presence of 128-bit constants. This commit includes manual merge conflict resolution changes from a rebase by @est31.
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;
RustWrapper: adapt to APInt API changes in LLVM 15 In https://reviews.llvm.org/D125556 upstream changed sext() and zext() to allow some no-op cases, which previously required use of the *OrSelf() methods, which I assume is what was going on here. The *OrSelf() methods got removed in https://reviews.llvm.org/D125559 after two weeks of deprecation because they came with some bonus (probably-undesired) behavior. Since the behavior of sext() and zext() changed slightly, I kept the old *OrSelf() calls in LLVM 14 and earlier, and only use the new version in LLVM 15. r? @nikic
2022-06-07 13:28:20 -05:00
#if LLVM_VERSION_GE(15, 0)
if (sext) {
AP = C->getValue().sext(128);
} else {
AP = C->getValue().zext(128);
}
#else
Add a way to retrieve constant value in 128 bits Fixes rebase fallout, makes code correct in presence of 128-bit constants. This commit includes manual merge conflict resolution changes from a rebase by @est31.
2016-08-25 17:32:46 -05:00
if (sext) {
AP = C->getValue().sextOrSelf(128);
} else {
AP = C->getValue().zextOrSelf(128);
}
RustWrapper: adapt to APInt API changes in LLVM 15 In https://reviews.llvm.org/D125556 upstream changed sext() and zext() to allow some no-op cases, which previously required use of the *OrSelf() methods, which I assume is what was going on here. The *OrSelf() methods got removed in https://reviews.llvm.org/D125559 after two weeks of deprecation because they came with some bonus (probably-undesired) behavior. Since the behavior of sext() and zext() changed slightly, I kept the old *OrSelf() calls in LLVM 14 and earlier, and only use the new version in LLVM 15. r? @nikic
2022-06-07 13:28:20 -05:00
#endif
Add a way to retrieve constant value in 128 bits Fixes rebase fallout, makes code correct in presence of 128-bit constants. This commit includes manual merge conflict resolution changes from a rebase by @est31.
2016-08-25 17:32:46 -05:00
*low = AP.getLoBits(64).getZExtValue();
*high = AP.getHiBits(64).getZExtValue();
return true;
Fix incorrect LLVM Linkage enum The `Linkage` enum in librustc_llvm got out of sync with the version in LLVM and it caused two variants of the #[linkage=""] attribute to break. This adds the functions `LLVMRustGetLinkage` and `LLVMRustSetLinkage` which convert between the Rust Linkage enum and the LLVM one, which should stop this from breaking every time LLVM changes it. Fixes #33992
2016-09-01 13:52:33 -05:00
}
Use llvm::Attribute API instead of "raw value" APIs, which will be removed in LLVM 4.0. The librustc_llvm API remains mostly unchanged, except that llvm::Attribute is no longer a bitflag but represents only a *single* attribute. The ability to store many attributes in a small number of bits and modify them without interacting with LLVM is only used in rustc_trans::abi and closely related modules, and only attributes for function arguments are considered there. Thus rustc_trans::abi now has its own bit-packed representation of argument attributes, which are translated to rustc_llvm::Attribute when applying the attributes.
2016-11-16 16:36:08 -06:00
Make LLVM symbol visibility FFI types more stable.
2016-11-28 16:44:51 -06:00
enum class LLVMRustVisibility {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
Default = 0,
Hidden = 1,
Protected = 2,
Make LLVM symbol visibility FFI types more stable.
2016-11-28 16:44:51 -06:00
};
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
static LLVMRustVisibility toRust(LLVMVisibility Vis) {
switch (Vis) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
case LLVMDefaultVisibility:
return LLVMRustVisibility::Default;
case LLVMHiddenVisibility:
return LLVMRustVisibility::Hidden;
case LLVMProtectedVisibility:
return LLVMRustVisibility::Protected;
}
[rustllvm] Use report_fatal_error over llvm_unreachable This makes it more robust when assertions are disabled, crashing instead of causing UB. Also introduces a tidy check to enforce this rule, which in turn necessitated making tidy run on src/rustllvm. Fixes #44020
2017-11-20 10:47:29 -06:00
report_fatal_error("Invalid LLVMRustVisibility value!");
Make LLVM symbol visibility FFI types more stable.
2016-11-28 16:44:51 -06:00
}
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
static LLVMVisibility fromRust(LLVMRustVisibility Vis) {
switch (Vis) {
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
case LLVMRustVisibility::Default:
return LLVMDefaultVisibility;
case LLVMRustVisibility::Hidden:
return LLVMHiddenVisibility;
case LLVMRustVisibility::Protected:
return LLVMProtectedVisibility;
}
[rustllvm] Use report_fatal_error over llvm_unreachable This makes it more robust when assertions are disabled, crashing instead of causing UB. Also introduces a tidy check to enforce this rule, which in turn necessitated making tidy run on src/rustllvm. Fixes #44020
2017-11-20 10:47:29 -06:00
report_fatal_error("Invalid LLVMRustVisibility value!");
Make LLVM symbol visibility FFI types more stable.
2016-11-28 16:44:51 -06:00
}
extern "C" LLVMRustVisibility LLVMRustGetVisibility(LLVMValueRef V) {
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
return toRust(LLVMGetVisibility(V));
Make LLVM symbol visibility FFI types more stable.
2016-11-28 16:44:51 -06:00
}
Fix intcast, use it where appropriate
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, ""));
}
Ran clang-format on src/rustllvm with llvm as the coding style.
2016-12-30 05:22:11 -06:00
extern "C" void LLVMRustSetVisibility(LLVMValueRef V,
LLVMRustVisibility RustVisibility) {
Improve naming style in rustllvm. As per the LLVM style guide, use CamelCase for all locals and classes, and camelCase for all non-FFI functions. Also, make names of variables of commonly used types more consistent. Fixes #38688.
2016-12-31 11:01:23 -06:00
LLVMSetVisibility(V, fromRust(RustVisibility));
Make LLVM symbol visibility FFI types more stable.
2016-11-28 16:44:51 -06:00
}
rustc: Enable LTO and multiple codegen units This commit is a refactoring of the LTO backend in Rust to support compilations with multiple codegen units. The immediate result of this PR is to remove the artificial error emitted by rustc about `-C lto -C codegen-units-8`, but longer term this is intended to lay the groundwork for LTO with incremental compilation and ultimately be the underpinning of ThinLTO support. The problem here that needed solving is that when rustc is producing multiple codegen units in one compilation LTO needs to merge them all together. Previously only upstream dependencies were merged and it was inherently relied on that there was only one local codegen unit. Supporting this involved refactoring the optimization backend architecture for rustc, namely splitting the `optimize_and_codegen` function into `optimize` and `codegen`. After an LLVM module has been optimized it may be blocked and queued up for LTO, and only after LTO are modules code generated. Non-LTO compilations should look the same as they do today backend-wise, we'll spin up a thread for each codegen unit and optimize/codegen in that thread. LTO compilations will, however, send the LLVM module back to the coordinator thread once optimizations have finished. When all LLVM modules have finished optimizing the coordinator will invoke the LTO backend, producing a further list of LLVM modules. Currently this is always a list of one LLVM module. The coordinator then spawns further work to run LTO and code generation passes over each module. In the course of this refactoring a number of other pieces were refactored: * Management of the bytecode encoding in rlibs was centralized into one module instead of being scattered across LTO and linking. * Some internal refactorings on the link stage of the compiler was done to work directly from `CompiledModule` structures instead of lists of paths. * The trans time-graph output was tweaked a little to include a name on each bar and inflate the size of the bars a little
2017-07-23 10:14:38 -05:00
Manually set dso_local when its valid to do so This should have no real effect in most cases, as e.g. `hidden` visibility already implies `dso_local` (or at least LLVM IR does not preserve the `dso_local` setting if the item is already `hidden`), but it should fix `-Crelocation-model=static` and improve codegen in executables. Note that this PR does not exhaustively port the logic in [clang]. Only the obviously correct portion and what is necessary to fix a regression from LLVM 12 that relates to `-Crelocation_model=static`. Fixes #83335 [clang]: https://github.com/llvm/llvm-project/blob/3001d080c813da20b329303bf8f45451480e5905/clang/lib/CodeGen/CodeGenModule.cpp#L945-L1039
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);
}
rustc: Enable LTO and multiple codegen units This commit is a refactoring of the LTO backend in Rust to support compilations with multiple codegen units. The immediate result of this PR is to remove the artificial error emitted by rustc about `-C lto -C codegen-units-8`, but longer term this is intended to lay the groundwork for LTO with incremental compilation and ultimately be the underpinning of ThinLTO support. The problem here that needed solving is that when rustc is producing multiple codegen units in one compilation LTO needs to merge them all together. Previously only upstream dependencies were merged and it was inherently relied on that there was only one local codegen unit. Supporting this involved refactoring the optimization backend architecture for rustc, namely splitting the `optimize_and_codegen` function into `optimize` and `codegen`. After an LLVM module has been optimized it may be blocked and queued up for LTO, and only after LTO are modules code generated. Non-LTO compilations should look the same as they do today backend-wise, we'll spin up a thread for each codegen unit and optimize/codegen in that thread. LTO compilations will, however, send the LLVM module back to the coordinator thread once optimizations have finished. When all LLVM modules have finished optimizing the coordinator will invoke the LTO backend, producing a further list of LLVM modules. Currently this is always a list of one LLVM module. The coordinator then spawns further work to run LTO and code generation passes over each module. In the course of this refactoring a number of other pieces were refactored: * Management of the bytecode encoding in rlibs was centralized into one module instead of being scattered across LTO and linking. * Some internal refactorings on the link stage of the compiler was done to work directly from `CompiledModule` structures instead of lists of paths. * The trans time-graph output was tweaked a little to include a name on each bar and inflate the size of the bars a little
2017-07-23 10:14:38 -05:00
struct LLVMRustModuleBuffer {
std::string data;
};
extern "C" LLVMRustModuleBuffer*
LLVMRustModuleBufferCreate(LLVMModuleRef M) {
Handle removal of llvm::make_unique()
2019-12-31 07:08:25 -06:00
auto Ret = std::make_unique<LLVMRustModuleBuffer>();
rustc: Enable LTO and multiple codegen units This commit is a refactoring of the LTO backend in Rust to support compilations with multiple codegen units. The immediate result of this PR is to remove the artificial error emitted by rustc about `-C lto -C codegen-units-8`, but longer term this is intended to lay the groundwork for LTO with incremental compilation and ultimately be the underpinning of ThinLTO support. The problem here that needed solving is that when rustc is producing multiple codegen units in one compilation LTO needs to merge them all together. Previously only upstream dependencies were merged and it was inherently relied on that there was only one local codegen unit. Supporting this involved refactoring the optimization backend architecture for rustc, namely splitting the `optimize_and_codegen` function into `optimize` and `codegen`. After an LLVM module has been optimized it may be blocked and queued up for LTO, and only after LTO are modules code generated. Non-LTO compilations should look the same as they do today backend-wise, we'll spin up a thread for each codegen unit and optimize/codegen in that thread. LTO compilations will, however, send the LLVM module back to the coordinator thread once optimizations have finished. When all LLVM modules have finished optimizing the coordinator will invoke the LTO backend, producing a further list of LLVM modules. Currently this is always a list of one LLVM module. The coordinator then spawns further work to run LTO and code generation passes over each module. In the course of this refactoring a number of other pieces were refactored: * Management of the bytecode encoding in rlibs was centralized into one module instead of being scattered across LTO and linking. * Some internal refactorings on the link stage of the compiler was done to work directly from `CompiledModule` structures instead of lists of paths. * The trans time-graph output was tweaked a little to include a name on each bar and inflate the size of the bars a little
2017-07-23 10:14:38 -05:00
{
raw_string_ostream OS(Ret->data);
Never use legacy PM for writing bitcode
2022-09-18 13:53:38 -05:00
WriteBitcodeToFile(*unwrap(M), OS);
rustc: Enable LTO and multiple codegen units This commit is a refactoring of the LTO backend in Rust to support compilations with multiple codegen units. The immediate result of this PR is to remove the artificial error emitted by rustc about `-C lto -C codegen-units-8`, but longer term this is intended to lay the groundwork for LTO with incremental compilation and ultimately be the underpinning of ThinLTO support. The problem here that needed solving is that when rustc is producing multiple codegen units in one compilation LTO needs to merge them all together. Previously only upstream dependencies were merged and it was inherently relied on that there was only one local codegen unit. Supporting this involved refactoring the optimization backend architecture for rustc, namely splitting the `optimize_and_codegen` function into `optimize` and `codegen`. After an LLVM module has been optimized it may be blocked and queued up for LTO, and only after LTO are modules code generated. Non-LTO compilations should look the same as they do today backend-wise, we'll spin up a thread for each codegen unit and optimize/codegen in that thread. LTO compilations will, however, send the LLVM module back to the coordinator thread once optimizations have finished. When all LLVM modules have finished optimizing the coordinator will invoke the LTO backend, producing a further list of LLVM modules. Currently this is always a list of one LLVM module. The coordinator then spawns further work to run LTO and code generation passes over each module. In the course of this refactoring a number of other pieces were refactored: * Management of the bytecode encoding in rlibs was centralized into one module instead of being scattered across LTO and linking. * Some internal refactorings on the link stage of the compiler was done to work directly from `CompiledModule` structures instead of lists of paths. * The trans time-graph output was tweaked a little to include a name on each bar and inflate the size of the bars a little
2017-07-23 10:14:38 -05:00
}
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) {
Simplify LLVMRustModuleCost()
2017-12-08 04:23:23 -06:00
auto f = unwrap(M)->functions();
return std::distance(std::begin(f), std::end(f));
rustc: Enable LTO and multiple codegen units This commit is a refactoring of the LTO backend in Rust to support compilations with multiple codegen units. The immediate result of this PR is to remove the artificial error emitted by rustc about `-C lto -C codegen-units-8`, but longer term this is intended to lay the groundwork for LTO with incremental compilation and ultimately be the underpinning of ThinLTO support. The problem here that needed solving is that when rustc is producing multiple codegen units in one compilation LTO needs to merge them all together. Previously only upstream dependencies were merged and it was inherently relied on that there was only one local codegen unit. Supporting this involved refactoring the optimization backend architecture for rustc, namely splitting the `optimize_and_codegen` function into `optimize` and `codegen`. After an LLVM module has been optimized it may be blocked and queued up for LTO, and only after LTO are modules code generated. Non-LTO compilations should look the same as they do today backend-wise, we'll spin up a thread for each codegen unit and optimize/codegen in that thread. LTO compilations will, however, send the LLVM module back to the coordinator thread once optimizations have finished. When all LLVM modules have finished optimizing the coordinator will invoke the LTO backend, producing a further list of LLVM modules. Currently this is always a list of one LLVM module. The coordinator then spawns further work to run LTO and code generation passes over each module. In the course of this refactoring a number of other pieces were refactored: * Management of the bytecode encoding in rlibs was centralized into one module instead of being scattered across LTO and linking. * Some internal refactorings on the link stage of the compiler was done to work directly from `CompiledModule` structures instead of lists of paths. * The trans time-graph output was tweaked a little to include a name on each bar and inflate the size of the bars a little
2017-07-23 10:14:38 -05:00
}
add intrinsics for portable packed simd vector reductions
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) {
Support LLVM 12 in rustc
2020-11-03 15:47:16 -06:00
Instruction *I = unwrap(B)->CreateFPMinReduce(unwrap(Src));
I->setHasNoNaNs(NoNaN);
return wrap(I);
add intrinsics for portable packed simd vector reductions
2018-03-13 10:46:55 -05:00
}
extern "C" LLVMValueRef
LLVMRustBuildVectorReduceFMax(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
Support LLVM 12 in rustc
2020-11-03 15:47:16 -06:00
Instruction *I = unwrap(B)->CreateFPMaxReduce(unwrap(Src));
I->setHasNoNaNs(NoNaN);
return wrap(I);
add intrinsics for portable packed simd vector reductions
2018-03-13 10:46:55 -05:00
}
add dummy symbols for LLVM<6
2018-03-14 16:12:38 -05:00
implement minmax intrinsics
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)));
}
Add first cut of functionality for #58713: support for #[link(kind = "raw-dylib")]. This does not yet support #[link_name] attributes on functions, the #[link_ordinal] attribute, #[link(kind = "raw-dylib")] on extern blocks in bin crates, or stdcall functions on 32-bit x86.
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;
Implement #[link_ordinal] attribute in the context of #[link(kind = "raw-dylib")].
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;
Add first cut of functionality for #58713: support for #[link(kind = "raw-dylib")]. This does not yet support #[link_name] attributes on functions, the #[link_ordinal] attribute, #[link(kind = "raw-dylib")] on extern blocks in bin crates, or stdcall functions on 32-bit x86.
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) {
Implement #[link_ordinal] attribute in the context of #[link(kind = "raw-dylib")].
2021-09-10 19:34:09 -05:00
bool ordinal_present = Exports[i].ordinal_present;
uint16_t ordinal = ordinal_present ? Exports[i].ordinal : 0;
Add first cut of functionality for #58713: support for #[link(kind = "raw-dylib")]. This does not yet support #[link_name] attributes on functions, the #[link_ordinal] attribute, #[link(kind = "raw-dylib")] on extern blocks in bin crates, or stdcall functions on 32-bit x86.
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
Implement #[link_ordinal] attribute in the context of #[link(kind = "raw-dylib")].
2021-09-10 19:34:09 -05:00
ordinal, // Ordinal
ordinal_present, // Noname
Add first cut of functionality for #58713: support for #[link(kind = "raw-dylib")]. This does not yet support #[link_name] attributes on functions, the #[link_ordinal] attribute, #[link(kind = "raw-dylib")] on extern blocks in bin crates, or stdcall functions on 32-bit x86.
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;
}
}
Emit LLVM optimization remarks when enabled with `-Cremark` The default diagnostic handler considers all remarks to be disabled by default unless configured otherwise through LLVM internal flags: `-pass-remarks`, `-pass-remarks-missed`, and `-pass-remarks-analysis`. This behaviour makes `-Cremark` ineffective on its own. Fix this by configuring a custom diagnostic handler that enables optimization remarks based on the value of `-Cremark` option. With `-Cremark=all` enabling all remarks.
2021-11-11 18:00:00 -06:00
// Transfers ownership of DiagnosticHandler unique_ptr to the caller.
extern "C" DiagnosticHandler *
LLVMRustContextGetDiagnosticHandler(LLVMContextRef C) {
std::unique_ptr<DiagnosticHandler> DH = unwrap(C)->getDiagnosticHandler();
return DH.release();
}
// Sets unique_ptr to object of DiagnosticHandler to provide custom diagnostic
// handling. Ownership of the handler is moved to the LLVMContext.
extern "C" void LLVMRustContextSetDiagnosticHandler(LLVMContextRef C,
DiagnosticHandler *DH) {
unwrap(C)->setDiagnosticHandler(std::unique_ptr<DiagnosticHandler>(DH));
}
using LLVMDiagnosticHandlerTy = DiagnosticHandler::DiagnosticHandlerTy;
// Configures a diagnostic handler that invokes provided callback when a
// backend needs to emit a diagnostic.
//
// When RemarkAllPasses is true, remarks are enabled for all passes. Otherwise
// the RemarkPasses array specifies individual passes for which remarks will be
// enabled.
extern "C" void LLVMRustContextConfigureDiagnosticHandler(
LLVMContextRef C, LLVMDiagnosticHandlerTy DiagnosticHandlerCallback,
void *DiagnosticHandlerContext, bool RemarkAllPasses,
const char * const * RemarkPasses, size_t RemarkPassesLen) {
class RustDiagnosticHandler final : public DiagnosticHandler {
public:
RustDiagnosticHandler(LLVMDiagnosticHandlerTy DiagnosticHandlerCallback,
void *DiagnosticHandlerContext,
bool RemarkAllPasses,
std::vector<std::string> RemarkPasses)
: DiagnosticHandlerCallback(DiagnosticHandlerCallback),
DiagnosticHandlerContext(DiagnosticHandlerContext),
RemarkAllPasses(RemarkAllPasses),
RemarkPasses(RemarkPasses) {}
virtual bool handleDiagnostics(const DiagnosticInfo &DI) override {
if (DiagnosticHandlerCallback) {
DiagnosticHandlerCallback(DI, DiagnosticHandlerContext);
return true;
}
return false;
}
bool isAnalysisRemarkEnabled(StringRef PassName) const override {
return isRemarkEnabled(PassName);
}
bool isMissedOptRemarkEnabled(StringRef PassName) const override {
return isRemarkEnabled(PassName);
}
bool isPassedOptRemarkEnabled(StringRef PassName) const override {
return isRemarkEnabled(PassName);
}
bool isAnyRemarkEnabled() const override {
return RemarkAllPasses || !RemarkPasses.empty();
}
private:
bool isRemarkEnabled(StringRef PassName) const {
if (RemarkAllPasses)
return true;
for (auto &Pass : RemarkPasses)
if (Pass == PassName)
return true;
return false;
}
LLVMDiagnosticHandlerTy DiagnosticHandlerCallback = nullptr;
void *DiagnosticHandlerContext = nullptr;
bool RemarkAllPasses = false;
std::vector<std::string> RemarkPasses;
};
std::vector<std::string> Passes;
for (size_t I = 0; I != RemarkPassesLen; ++I)
Passes.push_back(RemarkPasses[I]);
unwrap(C)->setDiagnosticHandler(std::make_unique<RustDiagnosticHandler>(
DiagnosticHandlerCallback, DiagnosticHandlerContext, RemarkAllPasses, Passes));
}
Add codegen for global_asm! sym operands
2022-02-28 18:53:25 -06:00
extern "C" void LLVMRustGetMangledName(LLVMValueRef V, RustStringRef Str) {
RawRustStringOstream OS(Str);
GlobalValue *GV = unwrap<GlobalValue>(V);
Mangler().getNameWithPrefix(OS, GV, true);
}
llvm-wrapper: adapt for LLVMConstExtractValue removal
2022-06-29 09:00:40 -05:00
// LLVMGetAggregateElement was added in LLVM 15. For earlier LLVM versions just
// use its implementation.
#if LLVM_VERSION_LT(15, 0)
extern "C" LLVMValueRef LLVMGetAggregateElement(LLVMValueRef C, unsigned Idx) {
return wrap(unwrap<Constant>(C)->getAggregateElement(Idx));
}
#endif
Add elementtype attributes for llvm.arm.ldrex/strex intrinsics These intrinsics (and a few more, but there are the only ones exposed by stdarch) require an elementtype attribute in LLVM 15.
2022-07-19 08:03:39 -05:00
extern "C" int32_t LLVMRustGetElementTypeArgIndex(LLVMValueRef CallSite) {
#if LLVM_VERSION_GE(15, 0)
auto *CB = unwrap<CallBase>(CallSite);
switch (CB->getIntrinsicID()) {
case Intrinsic::arm_ldrex:
return 0;
case Intrinsic::arm_strex:
return 1;
}
#endif
return -1;
}
Reference in New Issue Copy Permalink