diff --git a/src/libpanic_unwind/seh.rs b/src/libpanic_unwind/seh.rs index d6298a38a2601..832a0aff71be1 100644 --- a/src/libpanic_unwind/seh.rs +++ b/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; diff --git a/src/librustc_target/spec/mod.rs b/src/librustc_target/spec/mod.rs index 2514909ba75f3..3c68b5a7ab116 100644 --- a/src/librustc_target/spec/mod.rs +++ b/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), diff --git a/src/librustc_target/spec/thumbv7a_pc_windows_msvc.rs b/src/librustc_target/spec/thumbv7a_pc_windows_msvc.rs new file mode 100644 index 0000000000000..dab10ca241ebc --- /dev/null +++ b/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 or the MIT license +// , 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 + } + }) +} diff --git a/src/libstd/sys/windows/backtrace/mod.rs b/src/libstd/sys/windows/backtrace/mod.rs index 70de4a6f2b617..cfa9e7b7c25b3 100644 --- a/src/libstd/sys/windows/backtrace/mod.rs +++ b/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; diff --git a/src/libstd/sys/windows/c.rs b/src/libstd/sys/windows/c.rs index 4c64322a6dce3..f4bd9c22bb93f 100644 --- a/src/libstd/sys/windows/c.rs +++ b/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")]