mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #74941 - dylanmckay:replace-broken-avr-unknown-unknown-target, r=oli-obk

Browse Source 
[AVR] Replace broken 'avr-unknown-unknown' target with 'avr-unknown-gnu-atmega328' target

The `avr-unknown-unknown` target has never worked correctly, always trying to invoke
the host linker and failing. It aimed to be a mirror of AVR-GCC's
default handling of the `avr-unknown-unknown' triple (assume bare
minimum chip features, silently skip linking runtime libraries, etc).
This behaviour is broken-by-default as it will cause a miscompiled executable
when flashed.

This patch improves the AVR builtin target specifications to instead
expose only a 'avr-unknown-gnu-atmega328' target. This target system is
`gnu`, as it uses the AVR-GCC frontend along with avr-binutils. The
target triple ABI is 'atmega328'.

In the future, it should be possible to replace the dependency on
AVR-GCC and binutils by using the in-progress AVR LLD and compiler-rt support.
Perhaps at that point it would make sense to add an
'avr-unknown-unknown-atmega328' target as a better default when
implemented.

There is no current intention to add in-tree AVR target specifications for other
AVR microcontrollers - this one can serve as a reference implementation
for other devices via `rustc --print target-spec-json
avr-unknown-gnu-atmega328p`.

There should be no users of the existing 'avr-unknown-unknown' Rust
target as a custom target specification JSON has always been
recommended, and the avr-unknown-unknown target could never pass the
linking step anyway.
This commit is contained in:
bors 2020-08-27 15:48:56 +00:00
commit 3d0c847d33
9 changed files with 62 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
library/panic_unwind/src/lib.rs
View File

@ -65,7 +65,7 @@
// - os=none ("bare metal" targets)
// - os=uefi
// - nvptx64-nvidia-cuda
// - avr-unknown-unknown
// - arch=avr
#[path = "dummy.rs"]
mod real_imp;
}

2
library/std/build.rs
View File

@ -83,7 +83,7 @@ fn main() {
// - os=none ("bare metal" targets)
// - mipsel-sony-psp
// - nvptx64-nvidia-cuda
// - avr-unknown-unknown
// - arch=avr
// - tvos (aarch64-apple-tvos, x86_64-apple-tvos)
// - uefi (x86_64-unknown-uefi, i686-unknown-uefi)
// - JSON targets

2
src/doc/rustc/src/platform-support.md
View File

@ -165,7 +165,7 @@ target | std | host | notes
`armv7-wrs-vxworks-eabihf` | ? | |
`armv7a-none-eabihf` | * | | ARM Cortex-A, hardfloat
`armv7s-apple-ios` | ✓[^apple] | |
`avr-unknown-unknown` | ? | | AVR
`avr-unknown-gnu-atmega328` | ✗ | | AVR. Requires `-Z build-std=core`
`hexagon-unknown-linux-musl` | ? | |
`i386-apple-ios` | ✓[^apple] | | 32-bit x86 iOS
`i686-apple-darwin` | ✓ | ✓ | 32-bit OSX (10.7+, Lion+)

51
src/librustc_target/spec/avr_gnu_base.rs Normal file
View File

@ -0,0 +1,51 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
/// A base target for AVR devices using the GNU toolchain.
///
/// Requires GNU avr-gcc and avr-binutils on the host system.
pub fn target(target_cpu: String) -> TargetResult {
Ok(Target {
arch: "avr".to_string(),
data_layout: "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8".to_string(),
llvm_target: "avr-unknown-unknown".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "16".to_string(),
linker_flavor: LinkerFlavor::Gcc,
target_os: "unknown".to_string(),
target_env: "".to_string(),
target_vendor: "unknown".to_string(),
target_c_int_width: 16.to_string(),
options: TargetOptions {
cpu: target_cpu.clone(),
exe_suffix: ".elf".to_string(),
linker: Some("avr-gcc".to_owned()),
dynamic_linking: false,
executables: true,
linker_is_gnu: true,
has_rpath: false,
position_independent_executables: false,
eh_frame_header: false,
pre_link_args: vec![(
LinkerFlavor::Gcc,
vec![
format!("-mmcu={}", target_cpu),
// We want to be able to strip as much executable code as possible
// from the linker command line, and this flag indicates to the
// linker that it can avoid linking in dynamic libraries that don't
// actually satisfy any symbols up to that point (as with many other
// resolutions the linker does). This option only applies to all
// following libraries so we're sure to pass it as one of the first
// arguments.
"-Wl,--as-needed".to_string(),
],
)]
.into_iter()
.collect(),
late_link_args: vec![(LinkerFlavor::Gcc, vec!["-lgcc".to_owned()])]
.into_iter()
.collect(),
..TargetOptions::default()
},
})
}

5
src/librustc_target/spec/avr_unknown_gnu_atmega328.rs Normal file
View File

@ -0,0 +1,5 @@
use crate::spec::TargetResult;
pub fn target() -> TargetResult {
super::avr_gnu_base::target("atmega328".to_owned())
}

17
src/librustc_target/spec/avr_unknown_unknown.rs
View File

@ -1,17 +0,0 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
llvm_target: "avr-unknown-unknown".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "16".to_string(),
data_layout: "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8".to_string(),
arch: "avr".to_string(),
linker_flavor: LinkerFlavor::Gcc,
target_os: "unknown".to_string(),
target_env: "".to_string(),
target_vendor: "unknown".to_string(),
target_c_int_width: 16.to_string(),
options: super::freestanding_base::opts(),
})
}

31
src/librustc_target/spec/freestanding_base.rs
View File

@ -1,31 +0,0 @@
use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions};
use std::default::Default;
pub fn opts() -> TargetOptions {
let mut args = LinkArgs::new();
args.insert(
LinkerFlavor::Gcc,
vec![
// We want to be able to strip as much executable code as possible
// from the linker command line, and this flag indicates to the
// linker that it can avoid linking in dynamic libraries that don't
// actually satisfy any symbols up to that point (as with many other
// resolutions the linker does). This option only applies to all
// following libraries so we're sure to pass it as one of the first
// arguments.
"-Wl,--as-needed".to_string(),
],
);
TargetOptions {
dynamic_linking: false,
executables: true,
linker_is_gnu: true,
has_rpath: false,
pre_link_args: args,
position_independent_executables: false,
eh_frame_header: false,
..Default::default()
}
}

4
src/librustc_target/spec/mod.rs
View File

@ -51,10 +51,10 @@
mod apple_base;
mod apple_sdk_base;
mod arm_base;
mod avr_gnu_base;
mod cloudabi_base;
mod dragonfly_base;
mod freebsd_base;
mod freestanding_base;
mod fuchsia_base;
mod haiku_base;
mod hermit_base;
@ -581,7 +581,7 @@ fn $module() {
("aarch64-fuchsia", aarch64_fuchsia),
("x86_64-fuchsia", x86_64_fuchsia),
("avr-unknown-unknown", avr_unknown_unknown),
("avr-unknown-gnu-atmega328", avr_unknown_gnu_atmega328),
("x86_64-unknown-l4re-uclibc", x86_64_unknown_l4re_uclibc),

2
src/test/codegen/avr/avr-func-addrspace.rs
View File

@ -1,4 +1,4 @@
// compile-flags: -O --target=avr-unknown-unknown --crate-type=rlib
// compile-flags: -O --target=avr-unknown-gnu-atmega328 --crate-type=rlib
// needs-llvm-components: avr
// This test validates that function pointers can be stored in global variables