Add target thumbv7a-pc-windows-msvc

src/libpanic_unwind/seh.rs

@@ -119,7 +119,7 @@ mod imp {
  }
 }
 
-#[cfg(target_arch = "x86_64")]
+#[cfg(any(target_arch = "x86_64", target_arch = "arm"))]
 #[macro_use]
 mod imp {
  pub type ptr_t = u32;

src/librustc_target/spec/mod.rs

@@ -386,6 +386,7 @@ supported_targets! {
  ("x86_64-pc-windows-msvc", x86_64_pc_windows_msvc),
  ("i686-pc-windows-msvc", i686_pc_windows_msvc),
  ("i586-pc-windows-msvc", i586_pc_windows_msvc),
+ ("thumbv7a-pc-windows-msvc", thumbv7a_pc_windows_msvc),
 
  ("asmjs-unknown-emscripten", asmjs_unknown_emscripten),
  ("wasm32-unknown-emscripten", wasm32_unknown_emscripten),

src/librustc_target/spec/thumbv7a_pc_windows_msvc.rs

@@ -0,0 +1,50 @@
+// Copyright 2018 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 spec::{LinkerFlavor, Target, TargetOptions, TargetResult, PanicStrategy};
+
+pub fn target() -> TargetResult {
+ let mut base = super::windows_msvc_base::opts();
+
+ // Prevent error LNK2013: BRANCH24(T) fixup overflow
+ // The LBR optimization tries to eliminate branch islands,
+ // but if the displacement is larger than can fit
+ // in the instruction, this error will occur. The linker
+ // should be smart enough to insert branch islands only
+ // where necessary, but this is not the observed behavior.
+ // Disabling the LBR optimization works around the issue.
+ base.pre_link_args.get_mut(&LinkerFlavor::Msvc).unwrap().push(
+ "/OPT:NOLBR".to_string());
+
+ // FIXME(jordanrh): use PanicStrategy::Unwind when SEH is
+ // implemented for windows/arm in LLVM
+ base.panic_strategy = PanicStrategy::Abort;
+
+ Ok(Target {
+ llvm_target: "thumbv7a-pc-windows-msvc".to_string(),
+ target_endian: "little".to_string(),
+ target_pointer_width: "32".to_string(),
+ target_c_int_width: "32".to_string(),
+ data_layout: "e-m:w-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+ arch: "arm".to_string(),
+ target_os: "windows".to_string(),
+ target_env: "msvc".to_string(),
+ target_vendor: "pc".to_string(),
+ linker_flavor: LinkerFlavor::Msvc,
+
+ options: TargetOptions {
+ features: "+vfp3,+neon".to_string(),
+ cpu: "generic".to_string(),
+ max_atomic_width: Some(64),
+ abi_blacklist: super::arm_base::abi_blacklist(),
+ .. base
+ }
+ })
+}

src/libstd/sys/windows/backtrace/mod.rs

@@ -248,6 +248,17 @@ impl StackFrame for c::STACKFRAME_EX {
  c::IMAGE_FILE_MACHINE_AMD64
  }
 
+ #[cfg(target_arch = "arm")]
+ fn init(&mut self, ctx: &c::CONTEXT) -> c::DWORD {
+ self.AddrPC.Offset = ctx.Pc as u64;
+ self.AddrPC.Mode = c::ADDRESS_MODE::AddrModeFlat;
+ self.AddrStack.Offset = ctx.Sp as u64;
+ self.AddrStack.Mode = c::ADDRESS_MODE::AddrModeFlat;
+ self.AddrFrame.Offset = ctx.R11 as u64;
+ self.AddrFrame.Mode = c::ADDRESS_MODE::AddrModeFlat;
+ c::IMAGE_FILE_MACHINE_ARMNT
+ }
+
  #[cfg(target_arch = "aarch64")]
  fn init(&mut self, ctx: &c::CONTEXT) -> c::DWORD {
  self.AddrPC.Offset = ctx.Pc as u64;
@@ -291,6 +302,17 @@ impl StackFrame for c::STACKFRAME64 {
  c::IMAGE_FILE_MACHINE_AMD64
  }
 
+ #[cfg(target_arch = "arm")]
+ fn init(&mut self, ctx: &c::CONTEXT) -> c::DWORD {
+ self.AddrPC.Offset = ctx.Pc as u64;
+ self.AddrPC.Mode = c::ADDRESS_MODE::AddrModeFlat;
+ self.AddrStack.Offset = ctx.Sp as u64;
+ self.AddrStack.Mode = c::ADDRESS_MODE::AddrModeFlat;
+ self.AddrFrame.Offset = ctx.R11 as u64;
+ self.AddrFrame.Mode = c::ADDRESS_MODE::AddrModeFlat;
+ c::IMAGE_FILE_MACHINE_ARMNT
+ }
+
  #[cfg(target_arch = "aarch64")]
  fn init(&mut self, ctx: &c::CONTEXT) -> c::DWORD {
  self.AddrPC.Offset = ctx.Pc as u64;

src/libstd/sys/windows/c.rs

@@ -114,6 +114,11 @@ pub const SECURITY_SQOS_PRESENT: DWORD = 0x00100000;
 
 pub const FIONBIO: c_ulong = 0x8004667e;
 
+#[cfg(target_arch = "arm")]
+const ARM_MAX_BREAKPOINTS: usize = 8;
+#[cfg(target_arch = "arm")]
+const ARM_MAX_WATCHPOINTS: usize = 1;
+
 #[repr(C)]
 #[derive(Copy)]
 pub struct WIN32_FIND_DATAW {
@@ -283,6 +288,9 @@ pub const IMAGE_FILE_MACHINE_AMD64: DWORD = 0x8664;
 #[cfg(target_arch = "aarch64")]
 #[cfg(feature = "backtrace")]
 pub const IMAGE_FILE_MACHINE_ARM64: DWORD = 0xAA64;
+#[cfg(target_arch = "arm")]
+#[cfg(feature = "backtrace")]
+pub const IMAGE_FILE_MACHINE_ARMNT: DWORD = 0x01c4;
 
 pub const EXCEPTION_CONTINUE_SEARCH: LONG = 0;
 pub const EXCEPTION_STACK_OVERFLOW: DWORD = 0xc00000fd;
@@ -789,12 +797,44 @@ pub struct FLOATING_SAVE_AREA {
  _Dummy: [u8; 512] // FIXME: Fill this out
 }
 
+#[cfg(target_arch = "arm")]
+#[repr(C)]
+pub struct CONTEXT {
+ pub ContextFlags: ULONG,
+ pub R0: ULONG,
+ pub R1: ULONG,
+ pub R2: ULONG,
+ pub R3: ULONG,
+ pub R4: ULONG,
+ pub R5: ULONG,
+ pub R6: ULONG,
+ pub R7: ULONG,
+ pub R8: ULONG,
+ pub R9: ULONG,
+ pub R10: ULONG,
+ pub R11: ULONG,
+ pub R12: ULONG,
+ pub Sp: ULONG,
+ pub Lr: ULONG,
+ pub Pc: ULONG,
+ pub Cpsr: ULONG,
+ pub Fpscr: ULONG,
+ pub Padding: ULONG,
+ pub D: [u64; 32],
+ pub Bvr: [ULONG; ARM_MAX_BREAKPOINTS],
+ pub Bcr: [ULONG; ARM_MAX_BREAKPOINTS],
+ pub Wvr: [ULONG; ARM_MAX_WATCHPOINTS],
+ pub Wcr: [ULONG; ARM_MAX_WATCHPOINTS],
+ pub Padding2: [ULONG; 2]
+}
+
 // FIXME(#43348): This structure is used for backtrace only, and a fake
 // definition is provided here only to allow rustdoc to pass type-check. This
 // will not appear in the final documentation. This should be also defined for
 // other architectures supported by Windows such as ARM, and for historical
 // interest, maybe MIPS and PowerPC as well.
-#[cfg(all(rustdoc, not(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64"))))]
+#[cfg(all(rustdoc, not(any(target_arch = "x86_64", target_arch = "x86",
+ target_arch = "aarch64", target_arch = "arm"))))]
 pub enum CONTEXT {}
 
 #[cfg(target_arch = "aarch64")]