https://github.com/rust-lang/rust http://git.dreamy.place/mirrors/rust/atom?h=1.62.0 2022-02-12T20:19:06+00:00 2022-02-12T20:19:06+00:00 John Paul Adrian Glaubitz glaubitz@physik.fu-berlin.de 2022-02-12T20:19:06+00:00 urn:sha1:990326fa74edb3aaccae68af8b9abff8a316b716 2022-01-21T15:50:33+00:00 Benjamin Lamowski benjamin.lamowski@kernkonzept.com 2021-05-31T12:34:23+00:00 urn:sha1:660d993c642a2f88b84d5e1f0d8602b8136b9b4e - Fix style errors. - L4-bender does not yet support dynamic linking. - Stack unwinding is not yet supported for x86_64-unknown-l4re-uclibc. For now, just abort on panics. - Use GNU-style linker options where possible. As suggested by review: - Use standard GNU-style ld syntax for relro flags. - Use standard GNU-style optimization flags and logic. - Use standard GNU-style ld syntax for --subsystem. - Don't read environment variables in L4Bender linker. Thanks to CARGO_ENCODED_RUSTFLAGS introduced in #9601, l4-bender's arguments can now be passed from the L4Re build system without resorting to custom parsing of environment variables. 2021-12-14T15:40:43+00:00 Frank Steffahn frank.steffahn@stu.uni-kiel.de 2021-12-14T14:23:34+00:00 urn:sha1:a957cefda63c76c7a91a705f683be45c684d4303 2021-11-10T16:35:42+00:00 Alex Crichton alex@alexcrichton.com 2021-11-01T14:11:05+00:00 urn:sha1:caa9e4a2d0feaee53df67677a190edab95c996af 2021-11-10T16:35:42+00:00 Alex Crichton alex@alexcrichton.com 2021-10-28T17:58:16+00:00 urn:sha1:7f3ffbc8c22d0084987966b0496a63ce4d6278d5 This commit goes through and updates various `#[cfg]` as appropriate to get the wasm64-unknown-unknown target behaving similarly to the wasm32-unknown-unknown target. Most of this is just updating various conditions for `target_arch = "wasm32"` to also account for `target_arch = "wasm64"` where appropriate. This commit also lists `wasm64` as an allow-listed architecture to not have the `restricted_std` feature enabled, enabling experimentation with `-Z build-std` externally. The main goal of this commit is to enable playing around with `wasm64-unknown-unknown` externally via `-Z build-std` in a way that's similar to the `wasm32-unknown-unknown` target. These targets are effectively the same and only differ in their pointer size, but wasm64 is much newer and has much less ecosystem/library support so it'll still take time to get wasm64 fully-fledged. 2021-09-28T02:31:47+00:00 Tomoaki Kawada kawada@kmckk.co.jp 2021-09-28T02:20:46+00:00 urn:sha1:da9ca41c318aadcc0a9e8f72f86c1d36c8fe6d5d SOLID[1] is an embedded development platform provided by Kyoto Microcomputer Co., Ltd. This commit introduces a basic Tier 3 support for SOLID. # New Targets The following targets are added: - `aarch64-kmc-solid_asp3` - `armv7a-kmc-solid_asp3-eabi` - `armv7a-kmc-solid_asp3-eabihf` SOLID's target software system can be divided into two parts: an RTOS kernel, which is responsible for threading and synchronization, and Core Services, which provides filesystems, networking, and other things. The RTOS kernel is a μITRON4.0[2][3]-derived kernel based on the open-source TOPPERS RTOS kernels[4]. For uniprocessor systems (more precisely, systems where only one processor core is allocated for SOLID), this will be the TOPPERS/ASP3 kernel. As μITRON is traditionally only specified at the source-code level, the ABI is unique to each implementation, which is why `asp3` is included in the target names. More targets could be added later, as we support other base kernels (there are at least three at the point of writing) and are interested in supporting other processor architectures in the future. # C Compiler Although SOLID provides its own supported C/C++ build toolchain, GNU Arm Embedded Toolchain seems to work for the purpose of building Rust. # Unresolved Questions A μITRON4 kernel can support `Thread::unpark` natively, but it's not used by this commit's implementation because the underlying kernel feature is also used to implement `Condvar`, and it's unclear whether `std` should guarantee that parking tokens are not clobbered by other synchronization primitives. # Unsupported or Unimplemented Features Most features are implemented. The following features are not implemented due to the lack of native support: - `fs::File::{file_attr, truncate, duplicate, set_permissions}` - `fs::{symlink, link, canonicalize}` - Process creation - Command-line arguments Backtrace generation is not really a good fit for embedded targets, so it's intentionally left unimplemented. Unwinding is functional, however. ## Dynamic Linking Dynamic linking is not supported. The target platform supports dynamic linking, but enabling this in Rust causes several problems. - The linker invocation used to build the shared object of `std` is too long for the platform-provided linker to handle. - A linker script with specific requirements is required for the compiled shared object to be actually loadable. As such, we decided to disable dynamic linking for now. Regardless, the users can try to create shared objects by manually invoking the linker. ## Executable Building an executable is not supported as the notion of "executable files" isn't well-defined for these targets. [1] https://solid.kmckk.com/SOLID/ [2] http://ertl.jp/ITRON/SPEC/mitron4-e.html [3] https://en.wikipedia.org/wiki/ITRON_project [4] https://toppers.jp/ 2021-08-10T09:09:00+00:00 ivmarkov ivan.markov@gmail.com 2021-07-29T17:18:22+00:00 urn:sha1:459eaa6baea4127b37769d0b7944fa00c175e770 2021-08-03T14:06:19+00:00 Alex Crichton alex@alexcrichton.com 2021-06-08T18:23:58+00:00 urn:sha1:1c07096a45a15de64216f12ec726333870e372b1 This commit intends to fill out some of the remaining pieces of the C-unwind ABI. This has a number of other changes with it though to move this design space forward a bit. Notably contained within here is: * On `panic=unwind`, the `extern "C"` ABI is now considered as "may unwind". This fixes a longstanding soundness issue where if you `panic!()` in an `extern "C"` function defined in Rust that's actually UB because the LLVM representation for the function has the `nounwind` attribute, but then you unwind. * Whether or not a function unwinds now mainly considers the ABI of the function instead of first checking the panic strategy. This fixes a miscompile of `extern "C-unwind"` with `panic=abort` because that ABI can still unwind. * The aborting stub for non-unwinding ABIs with `panic=unwind` has been reimplemented. Previously this was done as a small tweak during MIR generation, but this has been moved to a separate and dedicated MIR pass. This new pass will, for appropriate functions and function calls, insert a `cleanup` landing pad for any function call that may unwind within a function that is itself not allowed to unwind. Note that this subtly changes some behavior from before where previously on an unwind which was caught-to-abort it would run active destructors in the function, and now it simply immediately aborts the process. * The `#[unwind]` attribute has been removed and all users in tests and such are now using `C-unwind` and `#![feature(c_unwind)]`. I think this is largely the last piece of the RFC to implement. Unfortunately I believe this is still not stabilizable as-is because activating the feature gate changes the behavior of the existing `extern "C"` ABI in a way that has no replacement. My thinking for how to enable this is that we add support for the `C-unwind` ABI on stable Rust first, and then after it hits stable we change the behavior of the `C` ABI. That way anyone straddling stable/beta/nightly can switch to `C-unwind` safely. 2021-07-03T06:03:27+00:00 Charles Lew crlf0710@gmail.com 2021-07-03T04:24:47+00:00 urn:sha1:0d1919c7ab149e0ed7f88643f3f94d59c06429bd 2021-06-23T20:26:46+00:00 Smitty me@smitop.com 2021-06-23T20:26:46+00:00 urn:sha1:bdfcb88e8b6203ccb46a2fb6649979b773efc8ac