nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-01 15:01:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #87922 - Manishearth:c-enum-target-spec, r=nagisa,eddyb

Browse Source 
Add c_enum_min_bits target spec field, use for arm-none and thumb-none targets

Fixes https://github.com/rust-lang/rust/issues/87917

<s>Haven't tested this yet, still playing around.</s>

This seems to fix the issue.
This commit is contained in:
Manish Goregaokar 2021-08-12 10:04:14 -07:00 committed by GitHub
commit 692833a28f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 529 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
compiler/rustc_middle/src/ty/layout.rs
View File

@ -112,9 +112,6 @@ impl IntegerExt for Integer {
let unsigned_fit = Integer::fit_unsigned(cmp::max(min as u128, max as u128));
let signed_fit = cmp::max(Integer::fit_signed(min), Integer::fit_signed(max));
let mut min_from_extern = None;
let min_default = I8;
if let Some(ity) = repr.int {
let discr = Integer::from_attr(&tcx, ity);
let fit = if ity.is_signed() { signed_fit } else { unsigned_fit };
@ -128,19 +125,14 @@ impl IntegerExt for Integer {
return (discr, ity.is_signed());
}
if repr.c() {
match &tcx.sess.target.arch[..] {
"hexagon" => min_from_extern = Some(I8),
// WARNING: the ARM EABI has two variants; the one corresponding
// to `at_least == I32` appears to be used on Linux and NetBSD,
// but some systems may use the variant corresponding to no
// lower bound. However, we don't run on those yet...?
"arm" => min_from_extern = Some(I32),
_ => min_from_extern = Some(I32),
}
}
let at_least = min_from_extern.unwrap_or(min_default);
let at_least = if repr.c() {
// This is usually I32, however it can be different on some platforms,
// notably hexagon and arm-none/thumb-none
tcx.data_layout().c_enum_min_size
} else {
// repr(Rust) enums try to be as small as possible
I8
};
// If there are no negative values, we can use the unsigned fit.
if min >= 0 {

17
compiler/rustc_target/src/abi/mod.rs
View File

@ -36,6 +36,9 @@ pub struct TargetDataLayout {
pub vector_align: Vec<(Size, AbiAndPrefAlign)>,
pub instruction_address_space: AddressSpace,
/// Minimum size of #[repr(C)] enums (default I32 bits)
pub c_enum_min_size: Integer,
}
impl Default for TargetDataLayout {
@ -60,6 +63,7 @@ impl Default for TargetDataLayout {
(Size::from_bits(128), AbiAndPrefAlign::new(align(128))),
],
instruction_address_space: AddressSpace::DATA,
c_enum_min_size: Integer::I32,
}
}
}
@ -173,6 +177,8 @@ impl TargetDataLayout {
));
}
dl.c_enum_min_size = Integer::from_size(Size::from_bits(target.c_enum_min_bits))?;
Ok(dl)
}
@ -610,6 +616,17 @@ impl Integer {
}
I8
}
fn from_size(size: Size) -> Result<Self, String> {
match size.bits() {
8 => Ok(Integer::I8),
16 => Ok(Integer::I16),
32 => Ok(Integer::I32),
64 => Ok(Integer::I64),
128 => Ok(Integer::I128),
_ => Err(format!("rust does not support integers with {} bits", size.bits())),
}
}
}
/// Fundamental unit of memory access and layout.

2
compiler/rustc_target/src/spec/armebv7r_none_eabi.rs
View File

@ -20,6 +20,8 @@ pub fn target() -> Target {
panic_strategy: PanicStrategy::Abort,
max_atomic_width: Some(32),
emit_debug_gdb_scripts: false,
// GCC and Clang default to 8 for arm-none here
c_enum_min_bits: 8,
..Default::default()
},
}

2
compiler/rustc_target/src/spec/armebv7r_none_eabihf.rs
View File

@ -21,6 +21,8 @@ pub fn target() -> Target {
features: "+vfp3,-d32,-fp16".to_string(),
max_atomic_width: Some(32),
emit_debug_gdb_scripts: false,
// GCC and Clang default to 8 for arm-none here
c_enum_min_bits: 8,
..Default::default()
},
}

1
compiler/rustc_target/src/spec/armv7a_none_eabi.rs
View File

@ -28,6 +28,7 @@ pub fn target() -> Target {
max_atomic_width: Some(64),
panic_strategy: PanicStrategy::Abort,
emit_debug_gdb_scripts: false,
c_enum_min_bits: 8,
..Default::default()
};
Target {

2
compiler/rustc_target/src/spec/armv7a_none_eabihf.rs
View File

@ -19,6 +19,8 @@ pub fn target() -> Target {
max_atomic_width: Some(64),
panic_strategy: PanicStrategy::Abort,
emit_debug_gdb_scripts: false,
// GCC and Clang default to 8 for arm-none here
c_enum_min_bits: 8,
..Default::default()
};
Target {

2
compiler/rustc_target/src/spec/armv7r_none_eabi.rs
View File

@ -19,6 +19,8 @@ pub fn target() -> Target {
panic_strategy: PanicStrategy::Abort,
max_atomic_width: Some(32),
emit_debug_gdb_scripts: false,
// GCC and Clang default to 8 for arm-none here
c_enum_min_bits: 8,
..Default::default()
},
}

2
compiler/rustc_target/src/spec/armv7r_none_eabihf.rs
View File

@ -20,6 +20,8 @@ pub fn target() -> Target {
features: "+vfp3,-d32,-fp16".to_string(),
max_atomic_width: Some(32),
emit_debug_gdb_scripts: false,
// GCC and Clang default to 8 for arm-none here
c_enum_min_bits: 8,
..Default::default()
},
}

2
compiler/rustc_target/src/spec/hexagon_unknown_linux_musl.rs
View File

@ -13,6 +13,8 @@ pub fn target() -> Target {
base.dynamic_linking = true;
base.executables = true;
base.c_enum_min_bits = 8;
Target {
llvm_target: "hexagon-unknown-linux-musl".to_string(),
pointer_width: 32,

12
compiler/rustc_target/src/spec/mod.rs
View File

@ -1336,6 +1336,9 @@ pub struct TargetOptions {
/// If present it's a default value to use for adjusting the C ABI.
pub default_adjusted_cabi: Option<Abi>,
/// Minimum number of bits in #[repr(C)] enum. Defaults to 32.
pub c_enum_min_bits: u64,
}
impl Default for TargetOptions {
@ -1440,6 +1443,7 @@ impl Default for TargetOptions {
split_debuginfo: SplitDebuginfo::Off,
supported_sanitizers: SanitizerSet::empty(),
default_adjusted_cabi: None,
c_enum_min_bits: 32,
}
}
}
@ -1604,6 +1608,12 @@ impl Target {
base.$key_name = s;
}
} );
($key_name:ident, u64) => ( {
let name = (stringify!($key_name)).replace("_", "-");
if let Some(s) = obj.remove_key(&name).and_then(|j| Json::as_u64(&j)) {
base.$key_name = s;
}
} );
($key_name:ident, Option<u32>) => ( {
let name = (stringify!($key_name)).replace("_", "-");
if let Some(s) = obj.remove_key(&name).and_then(|j| Json::as_u64(&j)) {
@ -2017,6 +2027,7 @@ impl Target {
key!(split_debuginfo, SplitDebuginfo)?;
key!(supported_sanitizers, SanitizerSet)?;
key!(default_adjusted_cabi, Option<Abi>)?;
key!(c_enum_min_bits, u64);
if base.is_builtin {
// This can cause unfortunate ICEs later down the line.
@ -2255,6 +2266,7 @@ impl ToJson for Target {
target_option_val!(has_thumb_interworking);
target_option_val!(split_debuginfo);
target_option_val!(supported_sanitizers);
target_option_val!(c_enum_min_bits);
if let Some(abi) = self.default_adjusted_cabi {
d.insert("default-adjusted-cabi".to_string(), Abi::name(abi).to_json());

3
compiler/rustc_target/src/spec/thumb_base.rs
View File

@ -53,6 +53,9 @@ pub fn opts() -> TargetOptions {
// LLVM is eager to trash the link register when calling `noreturn` functions, which
// breaks debugging. Preserve LR by default to prevent that from happening.
frame_pointer: FramePointer::Always,
// ARM supports multiple ABIs for enums, the linux one matches the default of 32 here
// but any arm-none or thumb-none target will be defaulted to 8 on GCC and clang
c_enum_min_bits: 8,
..Default::default()
}
}

34
src/test/ui/layout/thumb-enum.rs Normal file
View File

@ -0,0 +1,34 @@
// compile-flags: --target thumbv8m.main-none-eabihf
// needs-llvm-components: arm
//
// Verify that thumb targets implement the repr(C) for enums correctly.
//
// See #87917
#![feature(never_type, rustc_attrs, no_core, lang_items)]
#![crate_type = "lib"]
#![no_core]
#[lang="sized"]
trait Sized {}
#[rustc_layout(debug)]
#[repr(C)]
enum A { Apple } //~ ERROR: layout_of
#[rustc_layout(debug)]
#[repr(C)]
enum B { Banana = 255, } //~ ERROR: layout_of
#[rustc_layout(debug)]
#[repr(C)]
enum C { Chaenomeles = 256, } //~ ERROR: layout_of
#[rustc_layout(debug)]
#[repr(C)]
enum P { Peach = 0x1000_0000isize, } //~ ERROR: layout_of
const TANGERINE: usize = 0x8100_0000; // hack to get negative numbers without negation operator!
#[rustc_layout(debug)]
#[repr(C)]
enum T { Tangerine = TANGERINE as isize } //~ ERROR: layout_of

442
src/test/ui/layout/thumb-enum.stderr Normal file
View File

@ -0,0 +1,442 @@
error: layout_of(A) = Layout {
fields: Arbitrary {
offsets: [
Size {
raw: 0,
},
],
memory_index: [
0,
],
},
variants: Multiple {
tag: Scalar {
value: Int(
I8,
false,
),
valid_range: 0..=0,
},
tag_encoding: Direct,
tag_field: 0,
variants: [
Layout {
fields: Arbitrary {
offsets: [],
memory_index: [],
},
variants: Single {
index: 0,
},
abi: Aggregate {
sized: true,
},
largest_niche: None,
align: AbiAndPrefAlign {
abi: Align {
pow2: 0,
},
pref: Align {
pow2: 2,
},
},
size: Size {
raw: 1,
},
},
],
},
abi: Scalar(
Scalar {
value: Int(
I8,
false,
),
valid_range: 0..=0,
},
),
largest_niche: Some(
Niche {
offset: Size {
raw: 0,
},
scalar: Scalar {
value: Int(
I8,
false,
),
valid_range: 0..=0,
},
},
),
align: AbiAndPrefAlign {
abi: Align {
pow2: 0,
},
pref: Align {
pow2: 2,
},
},
size: Size {
raw: 1,
},
}
--> $DIR/thumb-enum.rs:16:1
|
LL | enum A { Apple }
| ^^^^^^^^^^^^^^^^
error: layout_of(B) = Layout {
fields: Arbitrary {
offsets: [
Size {
raw: 0,
},
],
memory_index: [
0,
],
},
variants: Multiple {
tag: Scalar {
value: Int(
I8,
false,
),
valid_range: 255..=255,
},
tag_encoding: Direct,
tag_field: 0,
variants: [
Layout {
fields: Arbitrary {
offsets: [],
memory_index: [],
},
variants: Single {
index: 0,
},
abi: Aggregate {
sized: true,
},
largest_niche: None,
align: AbiAndPrefAlign {
abi: Align {
pow2: 0,
},
pref: Align {
pow2: 2,
},
},
size: Size {
raw: 1,
},
},
],
},
abi: Scalar(
Scalar {
value: Int(
I8,
false,
),
valid_range: 255..=255,
},
),
largest_niche: Some(
Niche {
offset: Size {
raw: 0,
},
scalar: Scalar {
value: Int(
I8,
false,
),
valid_range: 255..=255,
},
},
),
align: AbiAndPrefAlign {
abi: Align {
pow2: 0,
},
pref: Align {
pow2: 2,
},
},
size: Size {
raw: 1,
},
}
--> $DIR/thumb-enum.rs:20:1
|
LL | enum B { Banana = 255, }
| ^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(C) = Layout {
fields: Arbitrary {
offsets: [
Size {
raw: 0,
},
],
memory_index: [
0,
],
},
variants: Multiple {
tag: Scalar {
value: Int(
I16,
false,
),
valid_range: 256..=256,
},
tag_encoding: Direct,
tag_field: 0,
variants: [
Layout {
fields: Arbitrary {
offsets: [],
memory_index: [],
},
variants: Single {
index: 0,
},
abi: Aggregate {
sized: true,
},
largest_niche: None,
align: AbiAndPrefAlign {
abi: Align {
pow2: 1,
},
pref: Align {
pow2: 2,
},
},
size: Size {
raw: 2,
},
},
],
},
abi: Scalar(
Scalar {
value: Int(
I16,
false,
),
valid_range: 256..=256,
},
),
largest_niche: Some(
Niche {
offset: Size {
raw: 0,
},
scalar: Scalar {
value: Int(
I16,
false,
),
valid_range: 256..=256,
},
},
),
align: AbiAndPrefAlign {
abi: Align {
pow2: 1,
},
pref: Align {
pow2: 2,
},
},
size: Size {
raw: 2,
},
}
--> $DIR/thumb-enum.rs:24:1
|
LL | enum C { Chaenomeles = 256, }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(P) = Layout {
fields: Arbitrary {
offsets: [
Size {
raw: 0,
},
],
memory_index: [
0,
],
},
variants: Multiple {
tag: Scalar {
value: Int(
I32,
false,
),
valid_range: 268435456..=268435456,
},
tag_encoding: Direct,
tag_field: 0,
variants: [
Layout {
fields: Arbitrary {
offsets: [],
memory_index: [],
},
variants: Single {
index: 0,
},
abi: Aggregate {
sized: true,
},
largest_niche: None,
align: AbiAndPrefAlign {
abi: Align {
pow2: 2,
},
pref: Align {
pow2: 2,
},
},
size: Size {
raw: 4,
},
},
],
},
abi: Scalar(
Scalar {
value: Int(
I32,
false,
),
valid_range: 268435456..=268435456,
},
),
largest_niche: Some(
Niche {
offset: Size {
raw: 0,
},
scalar: Scalar {
value: Int(
I32,
false,
),
valid_range: 268435456..=268435456,
},
},
),
align: AbiAndPrefAlign {
abi: Align {
pow2: 2,
},
pref: Align {
pow2: 2,
},
},
size: Size {
raw: 4,
},
}
--> $DIR/thumb-enum.rs:28:1
|
LL | enum P { Peach = 0x1000_0000isize, }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(T) = Layout {
fields: Arbitrary {
offsets: [
Size {
raw: 0,
},
],
memory_index: [
0,
],
},
variants: Multiple {
tag: Scalar {
value: Int(
I32,
true,
),
valid_range: 2164260864..=2164260864,
},
tag_encoding: Direct,
tag_field: 0,
variants: [
Layout {
fields: Arbitrary {
offsets: [],
memory_index: [],
},
variants: Single {
index: 0,
},
abi: Aggregate {
sized: true,
},
largest_niche: None,
align: AbiAndPrefAlign {
abi: Align {
pow2: 2,
},
pref: Align {
pow2: 2,
},
},
size: Size {
raw: 4,
},
},
],
},
abi: Scalar(
Scalar {
value: Int(
I32,
true,
),
valid_range: 2164260864..=2164260864,
},
),
largest_niche: Some(
Niche {
offset: Size {
raw: 0,
},
scalar: Scalar {
value: Int(
I32,
true,
),
valid_range: 2164260864..=2164260864,
},
},
),
align: AbiAndPrefAlign {
abi: Align {
pow2: 2,
},
pref: Align {
pow2: 2,
},
},
size: Size {
raw: 4,
},
}
--> $DIR/thumb-enum.rs:34:1
|
LL | enum T { Tangerine = TANGERINE as isize }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 5 previous errors