mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ddcd7cac41
rust/tests/ui/layout/zero-sized-array-enum-niche.stderr

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

451 lines
15 KiB
Plaintext
Raw Normal View History

Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
error: layout_of(std::result::Result<[u32; 0], bool>) = Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(4 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(0 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: Some(
Niche {
offset: Size(0 bytes),
value: Int(
I8,
false,
),
valid_range: 0..=1,
},
),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
variants: Multiple {
tag: Initialized {
value: Int(
I8,
false,
),
valid_range: 0..=1,
},
tag_encoding: Direct,
tag_field: 0,
variants: [
Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(4 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(4 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: None,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
variants: Single {
index: 0,
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
},
Layout {
size: Size(2 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
align: AbiAndPrefAlign {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Align(1 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
pref: $PREF_ALIGN,
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(1 bytes),
],
memory_index: [
0,
],
},
largest_niche: Some(
Niche {
offset: Size(1 bytes),
value: Int(
I8,
false,
),
valid_range: 0..=1,
},
),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
variants: Single {
index: 1,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(1 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
},
],
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
}
--> $DIR/zero-sized-array-enum-niche.rs:13:1
|
LL | type AlignedResult = Result<[u32; 0], bool>;
| ^^^^^^^^^^^^^^^^^^
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
error: layout_of(MultipleAlignments) = Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(4 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
fields: Arbitrary {
offsets: [
Size(0 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: Some(
Niche {
offset: Size(0 bytes),
value: Int(
I8,
false,
),
valid_range: 0..=2,
},
),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
variants: Multiple {
tag: Initialized {
value: Int(
I8,
false,
),
valid_range: 0..=2,
},
tag_encoding: Direct,
tag_field: 0,
variants: [
Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(2 bytes),
align: AbiAndPrefAlign {
abi: Align(2 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
fields: Arbitrary {
offsets: [
Size(2 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: None,
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
variants: Single {
index: 0,
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(2 bytes),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
},
Layout {
size: Size(4 bytes),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
align: AbiAndPrefAlign {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Align(4 bytes),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
pref: $PREF_ALIGN,
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Aggregate {
sized: true,
},
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
fields: Arbitrary {
offsets: [
Size(4 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: None,
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
variants: Single {
index: 1,
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
},
Layout {
size: Size(2 bytes),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
align: AbiAndPrefAlign {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Align(1 bytes),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
pref: $PREF_ALIGN,
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Aggregate {
sized: true,
},
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
fields: Arbitrary {
offsets: [
Size(1 bytes),
],
memory_index: [
0,
],
},
largest_niche: Some(
Niche {
offset: Size(1 bytes),
value: Int(
I8,
false,
),
valid_range: 0..=1,
},
),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
variants: Single {
index: 2,
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(1 bytes),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
},
],
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
}
--> $DIR/zero-sized-array-enum-niche.rs:21:1
|
LL | enum MultipleAlignments {
| ^^^^^^^^^^^^^^^^^^^^^^^
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
error: layout_of(std::result::Result<[u32; 0], Packed<std::num::NonZeroU16>>) = Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(4 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(0 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: Some(
Niche {
offset: Size(0 bytes),
value: Int(
I8,
false,
),
valid_range: 0..=1,
},
),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
variants: Multiple {
tag: Initialized {
value: Int(
I8,
false,
),
valid_range: 0..=1,
},
tag_encoding: Direct,
tag_field: 0,
variants: [
Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(4 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(4 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: None,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
variants: Single {
index: 0,
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
},
Layout {
size: Size(3 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
align: AbiAndPrefAlign {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Align(1 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
pref: $PREF_ALIGN,
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(1 bytes),
],
memory_index: [
0,
],
},
largest_niche: Some(
Niche {
offset: Size(1 bytes),
value: Int(
I16,
false,
),
valid_range: 1..=65535,
},
),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
variants: Single {
index: 1,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(1 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
},
],
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
}
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
--> $DIR/zero-sized-array-enum-niche.rs:37:1
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
|
LL | type NicheLosesToTagged = Result<[u32; 0], Packed<std::num::NonZeroU16>>;
| ^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(std::result::Result<[u32; 0], Packed<U16IsZero>>) = Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(4 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(0 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: Some(
Niche {
offset: Size(0 bytes),
value: Int(
I16,
false,
),
valid_range: 0..=1,
},
),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
variants: Multiple {
tag: Initialized {
value: Int(
I16,
false,
),
valid_range: 0..=1,
},
tag_encoding: Niche {
Change name of "dataful" variant to "untagged" This is in anticipation of a new enum layout, in which the niche optimization may be applied even when multiple variants have data.
2022-08-24 20:14:23 -05:00
untagged_variant: 1,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
niche_variants: 0..=0,
niche_start: 1,
},
tag_field: 0,
variants: [
Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(0 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(0 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: None,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
variants: Single {
index: 0,
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
},
Layout {
size: Size(2 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
align: AbiAndPrefAlign {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Align(1 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
pref: $PREF_ALIGN,
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(0 bytes),
],
memory_index: [
0,
],
},
largest_niche: Some(
Niche {
offset: Size(0 bytes),
value: Int(
I16,
false,
),
valid_range: 0..=0,
},
),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
variants: Single {
index: 1,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(1 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
},
],
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
}
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
--> $DIR/zero-sized-array-enum-niche.rs:44:1
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
|
LL | type NicheWinsOverTagged = Result<[u32; 0], Packed<U16IsZero>>;
| ^^^^^^^^^^^^^^^^^^^^^^^^
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
error: aborting due to 4 previous errors
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
Reference in New Issue Copy Permalink