Auto merge of #74941 - dylanmckay:replace-broken-avr-unknown-unknown-…

…target, r=oli-obk

[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.

library/panic_unwind/src/lib.rs

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

library/std/build.rs

@@ -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

src/doc/rustc/src/platform-support.md

@@ -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+)

src/librustc_target/spec/avr_gnu_base.rs

@@ -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()
+        },
+    })
+}

src/librustc_target/spec/avr_unknown_gnu_atmega328.rs

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

src/librustc_target/spec/mod.rs

@@ -51,10 +51,10 @@ mod android_base;
 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 @@ supported_targets! {
     ("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),
 

src/test/codegen/avr/avr-func-addrspace.rs

@@ -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