[AVR] Add AVR platform support

Author: shepmaster

src/bootstrap/native.rs

@@ -92,6 +92,7 @@ pub fn llvm(build: &Build, target: &str) {
        .profile(profile)
        .define("LLVM_ENABLE_ASSERTIONS", assertions)
        .define("LLVM_TARGETS_TO_BUILD", llvm_targets)
+       .define("LLVM_EXPERIMENTAL_TARGETS_TO_BUILD", "AVR")
        .define("LLVM_INCLUDE_EXAMPLES", "OFF")
        .define("LLVM_INCLUDE_TESTS", "OFF")
        .define("LLVM_INCLUDE_DOCS", "OFF")

src/librustc/ich/impls_syntax.rs

@@ -67,6 +67,8 @@ impl_stable_hash_for!(enum ::syntax::abi::Abi {
     PtxKernel,
     Msp430Interrupt,
     X86Interrupt,
+    AvrInterrupt,
+    AvrNonBlockingInterrupt,
     Rust,
     C,
     System,

src/librustc_back/target/avr_atmel_none.rs

@@ -0,0 +1,32 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use LinkerFlavor;
+use target::{Target, TargetOptions, TargetResult};
+
+pub fn target() -> TargetResult {
+    Ok(Target {
+        llvm_target: "avr-atmel-none".to_string(),
+        target_endian: "little".to_string(),
+        target_pointer_width: "16".to_string(),
+        data_layout: "e-p:16:16:16-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-n8".to_string(),
+        arch: "avr".to_string(),
+        linker_flavor: LinkerFlavor::Gcc,
+        target_os: "none".to_string(),
+        target_env: "gnu".to_string(),
+        target_vendor: "unknown".to_string(),
+        options: TargetOptions {
+            // jemalloc is not supported on 16-bit targets.
+            exe_allocation_crate: "alloc_system".to_string(),
+            lib_allocation_crate: "alloc_system".to_string(),
+            .. super::none_base::opts()
+        },
+    })
+}

src/librustc_back/target/mod.rs

@@ -62,6 +62,7 @@ mod emscripten_base;
 mod freebsd_base;
 mod haiku_base;
 mod linux_base;
+mod none_base;
 mod linux_musl_base;
 mod openbsd_base;
 mod netbsd_base;
@@ -201,6 +202,8 @@ supported_targets! {
     ("armv7-apple-ios", armv7_apple_ios),
     ("armv7s-apple-ios", armv7s_apple_ios),
 
+    ("avr-atmel-none", avr_atmel_none),
+
     ("x86_64-sun-solaris", x86_64_sun_solaris),
     ("sparcv9-sun-solaris", sparcv9_sun_solaris),
 
@@ -239,7 +242,7 @@ pub struct Target {
     /// Vendor name to use for conditional compilation.
     pub target_vendor: String,
     /// Architecture to use for ABI considerations. Valid options: "x86",
-    /// "x86_64", "arm", "aarch64", "mips", "powerpc", and "powerpc64".
+    /// "x86_64", "arm", "avr", "aarch64", "mips", "powerpc", and "powerpc64".
     pub arch: String,
     /// [Data layout](http://llvm.org/docs/LangRef.html#data-layout) to pass to LLVM.
     pub data_layout: String,

src/librustc_back/target/none_base.rs

@@ -0,0 +1,38 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use LinkerFlavor;
+use std::default::Default;
+use target::{LinkArgs, TargetOptions};
+
+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: true,
+        .. Default::default()
+    }
+}

src/librustc_llvm/build.rs

@@ -93,7 +93,7 @@ fn main() {
     let is_crossed = target != host;
 
     let optional_components =
-        ["x86", "arm", "aarch64", "mips", "powerpc", "pnacl", "systemz", "jsbackend", "msp430",
+        ["x86", "arm", "aarch64", "avr", "mips", "powerpc", "pnacl", "systemz", "jsbackend", "msp430",
          "sparc", "nvptx"];
 
     // FIXME: surely we don't need all these components, right? Stuff like mcjit

src/librustc_llvm/ffi.rs

@@ -54,6 +54,8 @@ pub enum CallConv {
     X86_64_Win64 = 79,
     X86_VectorCall = 80,
     X86_Intr = 83,
+    AvrNonBlockingInterrupt = 84,
+    AvrInterrupt = 85,
 }
 
 /// LLVMRustLinkage

src/librustc_llvm/lib.rs

@@ -334,6 +334,12 @@ pub fn initialize_available_targets() {
                  LLVMInitializeARMTargetMC,
                  LLVMInitializeARMAsmPrinter,
                  LLVMInitializeARMAsmParser);
+    init_target!(llvm_component = "avr",
+                 LLVMInitializeAVRTargetInfo,
+                 LLVMInitializeAVRTarget,
+                 LLVMInitializeAVRTargetMC,
+                 LLVMInitializeAVRAsmPrinter,
+                 LLVMInitializeAVRAsmParser);
     init_target!(llvm_component = "aarch64",
                  LLVMInitializeAArch64TargetInfo,
                  LLVMInitializeAArch64Target,

src/librustc_trans/abi.rs

@@ -18,6 +18,7 @@ use cabi_x86_64;
 use cabi_x86_win64;
 use cabi_arm;
 use cabi_aarch64;
+use cabi_avr;
 use cabi_powerpc;
 use cabi_powerpc64;
 use cabi_s390x;
@@ -649,6 +650,8 @@ impl<'a, 'tcx> FnType<'tcx> {
             PtxKernel => llvm::PtxKernel,
             Msp430Interrupt => llvm::Msp430Intr,
             X86Interrupt => llvm::X86_Intr,
+            AvrInterrupt => llvm::AvrInterrupt,
+            AvrNonBlockingInterrupt => llvm::AvrNonBlockingInterrupt,
 
             // These API constants ought to be more specific...
             Cdecl => llvm::CCallConv,
@@ -883,6 +886,7 @@ impl<'a, 'tcx> FnType<'tcx> {
                 cabi_x86_64::compute_abi_info(ccx, self);
             },
             "aarch64" => cabi_aarch64::compute_abi_info(ccx, self),
+            "avr" => cabi_avr::compute_abi_info(ccx, self),
             "arm" => cabi_arm::compute_abi_info(ccx, self),
             "mips" => cabi_mips::compute_abi_info(ccx, self),
             "mips64" => cabi_mips64::compute_abi_info(ccx, self),

src/librustc_trans/cabi_avr.rs

@@ -0,0 +1,44 @@
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(non_upper_case_globals)]
+
+use abi::{FnType, ArgType, LayoutExt};
+use context::CrateContext;
+
+fn classify_ret_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ret: &mut ArgType<'tcx>) {
+    if ret.layout.is_aggregate()  {
+        ret.extend_integer_width_to(8); // Is 8 correct?
+    } else {
+        ret.make_indirect(ccx);
+    }
+}
+
+fn classify_arg_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, arg: &mut ArgType<'tcx>) {
+    if arg.layout.is_aggregate() {
+        arg.extend_integer_width_to(8);
+    } else {
+        arg.make_indirect(ccx);
+    }
+}
+
+pub fn compute_abi_info<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fty: &mut FnType<'tcx>) {
+    if !fty.ret.is_ignore() {
+        classify_ret_ty(ccx, &mut fty.ret);
+    }
+
+    for arg in &mut fty.args {
+        if arg.is_ignore() {
+            continue;
+        }
+
+        classify_arg_ty(ccx, arg);
+    }
+}

src/librustc_trans/lib.rs

@@ -96,6 +96,7 @@ mod base;
 mod builder;
 mod cabi_aarch64;
 mod cabi_arm;
+mod cabi_avr;
 mod cabi_asmjs;
 mod cabi_mips;
 mod cabi_mips64;

src/libstd/env.rs

@@ -733,6 +733,7 @@ pub mod consts {
     /// - x86_64
     /// - arm
     /// - aarch64
+    /// - avr
     /// - mips
     /// - mips64
     /// - powerpc
@@ -845,6 +846,11 @@ mod arch {
     pub const ARCH: &'static str = "aarch64";
 }
 
+#[cfg(target_arch = "avr")]
+mod arch {
+    pub const ARCH: &'static str = "avr";
+}
+
 #[cfg(target_arch = "mips")]
 mod arch {
     pub const ARCH: &'static str = "mips";

src/libsyntax/abi.rs

@@ -26,6 +26,8 @@ pub enum Abi {
     PtxKernel,
     Msp430Interrupt,
     X86Interrupt,
+    AvrInterrupt,
+    AvrNonBlockingInterrupt,
 
     // Multiplatform / generic ABIs
     Rust,
@@ -61,6 +63,8 @@ const AbiDatas: &'static [AbiData] = &[
     AbiData {abi: Abi::PtxKernel, name: "ptx-kernel", generic: false },
     AbiData {abi: Abi::Msp430Interrupt, name: "msp430-interrupt", generic: false },
     AbiData {abi: Abi::X86Interrupt, name: "x86-interrupt", generic: false },
+    AbiData {abi: Abi::AvrInterrupt, name: "avr-interrupt", generic: false },
+    AbiData {abi: Abi::AvrNonBlockingInterrupt, name: "avr-non-blocking-interrupt", generic: false },
 
     // Cross-platform ABIs
     AbiData {abi: Abi::Rust, name: "Rust", generic: true },

src/libsyntax/feature_gate.rs

@@ -334,7 +334,6 @@ declare_features! (
     // `extern "x86-interrupt" fn()`
     (active, abi_x86_interrupt, "1.17.0", Some(40180)),
 
-
     // Allows the `catch {...}` expression
     (active, catch_expr, "1.17.0", Some(31436)),
 
@@ -355,6 +354,9 @@ declare_features! (
 
     // Allows use of the :vis macro fragment specifier
     (active, macro_vis_matcher, "1.18.0", Some(41022)),
+
+    // `extern "avr-interrupt" fn()`
+    (active, abi_avr_interrupt, "1.18.0", Some(000)),
 );
 
 declare_features! (
@@ -1075,6 +1077,10 @@ impl<'a> PostExpansionVisitor<'a> {
             Abi::X86Interrupt => {
                 gate_feature_post!(&self, abi_x86_interrupt, span,
                                    "x86-interrupt ABI is experimental and subject to change");
+            }
+            Abi::AvrInterrupt | Abi::AvrNonBlockingInterrupt => {
+                gate_feature_post!(&self, abi_avr_interrupt, span,
+                                   "avr-interrupt and avr-non-blocking-interrupt ABIs are experimental and subject to change");
             },
             // Stable
             Abi::Cdecl |

src/rustllvm/PassWrapper.cpp

@@ -117,6 +117,12 @@ extern "C" void LLVMRustAddPass(LLVMPassManagerRef PMR, LLVMPassRef RustPass) {
 #define SUBTARGET_AARCH64
 #endif
 
+#ifdef LLVM_COMPONENT_AVR
+#define SUBTARGET_AVR SUBTARGET(AVR)
+#else
+#define SUBTARGET_AVR
+#endif
+
 #ifdef LLVM_COMPONENT_MIPS
 #define SUBTARGET_MIPS SUBTARGET(Mips)
 #else
@@ -151,6 +157,7 @@ extern "C" void LLVMRustAddPass(LLVMPassManagerRef PMR, LLVMPassRef RustPass) {
   SUBTARGET_X86                                                                \
   SUBTARGET_ARM                                                                \
   SUBTARGET_AARCH64                                                            \
+  SUBTARGET_AVR                                                                \
   SUBTARGET_MIPS                                                               \
   SUBTARGET_PPC                                                                \
   SUBTARGET_SYSTEMZ                                                            \

src/tools/compiletest/src/util.rs

@@ -23,6 +23,7 @@ const OS_TABLE: &'static [(&'static str, &'static str)] = &[
     ("linux", "linux"),
     ("mingw32", "windows"),
     ("netbsd", "netbsd"),
+    ("none", "none"),
     ("openbsd", "openbsd"),
     ("win32", "windows"),
     ("windows", "windows"),
@@ -35,6 +36,7 @@ const ARCH_TABLE: &'static [(&'static str, &'static str)] = &[
     ("amd64", "x86_64"),
     ("arm", "arm"),
     ("arm64", "aarch64"),
+    ("avr", "avr"),
     ("hexagon", "hexagon"),
     ("i386", "x86"),
     ("i586", "x86"),