| Age | Commit message (Collapse) | Author | Lines |
|
|
|
- Move the type parameter from `encode` and `decode` methods to
the trait.
- Remove `UseSpecialized(En|De)codable` traits.
- Remove blanket impls for references.
- Add `RefDecodable` trait to allow deserializing to arena-allocated
references safely.
- Remove ability to (de)serialize HIR.
- Create proc-macros `(Ty)?(En|De)codable` to help implement these new
traits.
|
|
with the correct space
Before this patch, a function pointer stored within an aggregate like a
struct or an enum would always have the default address space `0`.
This patch removes this assumption and instead, introspects the inner
type being pointed at, storing the target address space in the PointeeInfo
struct so that downstream users may query it.
|
|
functions
This patch extends the existing `type_i8p` method so that it requires an
explicit address space to be specified. Before this patch, the
`type_i8p` method implcitily assumed the default address space, which is
not a safe transformation on all targets, namely AVR.
The Rust compiler already has support for tracking the "instruction
address space" on a per-target basis. This patch extends the code
generation routines so that an address space must always be specified.
In my estimation, around 15% of the callers of `type_i8p` produced
invalid code on AVR due to the loss of address space prior to LLVM final
code generation. This would lead to unavoidable assertion errors
relating to invalid bitcasts.
With this patch, the address space is always either 1) explicitly set to
the instruction address space because the logic is dealing with functions
which must be placed there, or 2) explicitly set to the default address
space 0 because the logic can only operate on data space pointers and thus
we keep the existing semantics of assuming the default, "data" address space.
|
|
tag/niche terminology cleanup
The term "discriminant" was used in two ways throughout the compiler:
* every enum variant has a corresponding discriminant, that can be given explicitly with `Variant = N`.
* that discriminant is then encoded in memory to store which variant is active -- but this encoded form of the discriminant was also often called "discriminant", even though it is conceptually quite different (e.g., it can be smaller in size, or even use niche-filling).
After discussion with @eddyb, this renames the second term to "tag". The way the tag is encoded can be either `TagEncoding::Direct` (formerly `DiscriminantKind::Tag`) or `TagEncoding::Niche` (formerly `DiscrimianntKind::Niche`).
This finally resolves some long-standing confusion I had about the handling of variant indices and discriminants, which surfaced in https://github.com/rust-lang/rust/pull/72419.
(There is also a `DiscriminantKind` type in libcore, it remains unaffected. I think this corresponds to the discriminant, not the tag, so that seems all right.)
r? @eddyb
|
|
This patch brings the AVR calling convention argument classification
logic in line with AVR Clang's behaviour.
AVR-Clang currently uses the `clang::DefaultABIInfo` ABI implementation.
This calling convention promotes all aggregates to indirect, no matter their
size.
It is also unnecessary to perform any integer width extension for AVR as
the minimum argument size matches the minimum describable size of
abi::Primitive::Int - 8 bits.
At some point in the future, an AVR-GCC compatible argument
classification implementation should be adopted in both Clang and Rust.
|
|
|
|
|
|
|
|
|
|
rustc_target::abi: rename FieldPlacement to FieldsShape.
Originally suggested by @eddyb.
|
|
|
|
This is a pure refactoring with no behavior changes.
|
|
(clippy::single_match)
Makes code more compact and reduces nestig.
|
|
|
|
Rename LayoutDetails to just Layout.
|
|
|
|
|
|
|
|
|
|
Abi::is_signed: assert that we are a Scalar
A bit more sanity checking, suggested by @eddyb. This makes this method actually "safer" than `TyS::is_signed`, so I made sure Miri consistently uses the `Abi` version.
Though I am not sure if this would have caught the mistake where the layout of a zero-sized enum was asked for its sign.
r? @eddyb
|
|
|
|
|
|
long lost assertion
This reverts part of commit 9712fa405944cb8d5416556ac4b1f26365a10658.
|
|
mem::zeroed/uninit: panic on types that do not permit zero-initialization
r? @eddyb @oli-obk
Cc https://github.com/rust-lang/rust/issues/62825
Also see [this summary comment](https://github.com/rust-lang/rust/pull/66059#issuecomment-586734747)
|
|
Miri visitor: detect primitive types based on type, not layout (also, more tests)
I also converted the union-based transmutes to use `mem::transmute` for increased readability.
r? @eddyb @oli-obk
|
|
|
|
|
|
Adjust Miri value visitor, and doc-comment layout components
I realized that I still didn't have quite the right intuition for how our `LayoutDetails` work, so I had to adjust the Miri value visitor to the things I understood better now. I also added some doc-comments to `LayoutDetails` as a hopefully canonical place to note such things.
The main visitor change is that we *first* look at all the fields (according to `FieldPlacement`), and *then* check the variants and handle `Multiple` appropriately. I did not quite realize how orthogonal "fields" and "variants" are.
I also moved the check for the scalar ABI to *after* checking all the fields; this leads to better (more type-driven) error messages.
And it looks like we can finally remove that magic hack for `ty::Generator`. :D
r? @oli-obk for the Miri/visitor changes and @eddyb for the layout docs
The Miri PR is at: https://github.com/rust-lang/miri/pull/1178
|
|
|
|
also add tests for ScalarPair enums
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Implement proper C ABI lowering for RISC-V
This is necessary for full RISC-V psABI compliance when passing argument across C FFI boundary.
cc @lenary
|
|
|
|
|
|
|
|
|
|
see accouncement at https://docs.microsoft.com/welcome-to-docs
|
|
|
|
Fix constant propagation for scalar pairs
We now only propagate a scalar pair if the Rvalue is a tuple with two scalars. This for example avoids propagating a (u8, u8) value when Rvalue has type `((), u8, u8)` (see the regression test). While this is a correct thing to do, implementation is tricky and will be done later.
Fixes #66971
Fixes #66339
Fixes #67019
|
|
We now only propagate a scalar pair if the Rvalue is a tuple with two
scalars. This for example avoids propagating a (u8, u8) value when
Rvalue has type `((), u8, u8)` (see the regression test). While this is
a correct thing to do, implementation is tricky and will be done later.
Fixes #66971
Fixes #66339
Fixes #67019
|
|
|
|
|