lang/rust: Update to 1.34.1

- Add stdsimd patches from D19940 to attempt to unbreak powerpc64, armv{6,7} [1]

Changes:	https://blog.rust-lang.org/2019/04/25/Rust-1.34.1.html
PR:		237507 [1]
Submitted by:	mikael.urankar@gmail.com [1]
Reviewed by:	jbeich [1]
Tested by:	pkubaj (stdsimd patches with 1.34.0 on powerpc64) [1]
With hat:	rust
Differential Revision:	https://reviews.freebsd.org/D19940 [1]

6 files changed, 173 insertions, 4 deletions

diff --git a/lang/rust/Makefile b/lang/rust/Makefile
index 6ffbce55165b..cee2fd287416 100644
--- a/lang/rust/Makefile
+++ b/lang/rust/Makefile
@@ -2,7 +2,7 @@
 # $FreeBSD$
 
 PORTNAME=	rust
-PORTVERSION?=	1.34.0
+PORTVERSION?=	1.34.1
 PORTREVISION?=	0
 CATEGORIES=	lang
 MASTER_SITES=	http://static.rust-lang.org/dist/:src \
diff --git a/lang/rust/distinfo b/lang/rust/distinfo
index e1373b9dafb1..0414dcc1bbba 100644
--- a/lang/rust/distinfo
+++ b/lang/rust/distinfo
@@ -1,6 +1,6 @@
-TIMESTAMP = 1555004553
-SHA256 (rust/rustc-1.34.0-src.tar.xz) = a510b3b7ceca370a4b395065039b2a70297e3fb4103b7ff67b1eff771fd98504
-SIZE (rust/rustc-1.34.0-src.tar.xz) = 95055768
+TIMESTAMP = 1556213482
+SHA256 (rust/rustc-1.34.1-src.tar.xz) = e0efb1e6aba0d4900de57bd2db64e32e7c5b440a95a675d5303839c9a2c3328f
+SIZE (rust/rustc-1.34.1-src.tar.xz) = 95048260
 SHA256 (rust/2019-02-28/rustc-1.33.0-aarch64-unknown-freebsd.tar.gz) = 142c3419b0df1bacf97bf6ed6d2d3bcb37a6439b5bf11f258178edac6e3053b3
 SIZE (rust/2019-02-28/rustc-1.33.0-aarch64-unknown-freebsd.tar.gz) = 64575877
 SHA256 (rust/2019-02-28/rust-std-1.33.0-aarch64-unknown-freebsd.tar.gz) = bbb2ec53d4fcade7002665d4c9c64740ddc14a07d3726555c7a2ffe01b07fd9e
diff --git a/lang/rust/files/patch-src_stdsimd_crates_std__detect_src_detect_os_freebsd_arm.rs b/lang/rust/files/patch-src_stdsimd_crates_std__detect_src_detect_os_freebsd_arm.rs
new file mode 100644
index 000000000000..e04640b9d926
--- /dev/null
+++ b/lang/rust/files/patch-src_stdsimd_crates_std__detect_src_detect_os_freebsd_arm.rs
@@ -0,0 +1,30 @@
+--- src/stdsimd/crates/std_detect/src/detect/os/freebsd/arm.rs.orig	2019-04-25 17:33:21 UTC
++++ src/stdsimd/crates/std_detect/src/detect/os/freebsd/arm.rs
+@@ -0,0 +1,27 @@
++//! Run-time feature detection for ARM on FreeBSD
++
++use crate::detect::{Feature, cache};
++use super::{auxvec};
++
++/// Performs run-time feature detection.
++#[inline]
++pub fn check_for(x: Feature) -> bool {
++    cache::test(x as u32, detect_features)
++}
++
++/// Try to read the features from the auxiliary vector
++fn detect_features() -> cache::Initializer {
++    let mut value = cache::Initializer::default();
++    let enable_feature = |value: &mut cache::Initializer, f, enable| {
++        if enable {
++            value.set(f as u32);
++        }
++    };
++
++    if let Ok(auxv) = auxvec::auxv() {
++        enable_feature(&mut value, Feature::neon, auxv.hwcap & 0x00001000 != 0);
++        enable_feature(&mut value, Feature::pmull, auxv.hwcap2 & 0x00000002 != 0);
++        return value;
++    }
++    value
++}
diff --git a/lang/rust/files/patch-src_stdsimd_crates_std__detect_src_detect_os_freebsd_auxvec.rs b/lang/rust/files/patch-src_stdsimd_crates_std__detect_src_detect_os_freebsd_auxvec.rs
new file mode 100644
index 000000000000..eb6071036db4
--- /dev/null
+++ b/lang/rust/files/patch-src_stdsimd_crates_std__detect_src_detect_os_freebsd_auxvec.rs
@@ -0,0 +1,89 @@
+--- src/stdsimd/crates/std_detect/src/detect/os/freebsd/auxvec.rs.orig	2019-04-25 17:33:21 UTC
++++ src/stdsimd/crates/std_detect/src/detect/os/freebsd/auxvec.rs
+@@ -0,0 +1,86 @@
++//! Parses ELF auxiliary vectors.
++#![cfg_attr(any(target_arch = "arm", target_arch = "powerpc64"), allow(dead_code))]
++
++/// Key to access the CPU Hardware capabilities bitfield.
++pub(crate) const AT_HWCAP: usize = 25;
++/// Key to access the CPU Hardware capabilities 2 bitfield.
++pub(crate) const AT_HWCAP2: usize = 26;
++
++/// Cache HWCAP bitfields of the ELF Auxiliary Vector.
++///
++/// If an entry cannot be read all the bits in the bitfield are set to zero.
++/// This should be interpreted as all the features being disabled.
++#[derive(Debug, Copy, Clone)]
++pub(crate) struct AuxVec {
++    pub hwcap: usize,
++    pub hwcap2: usize,
++}
++
++/// ELF Auxiliary Vector
++///
++/// The auxiliary vector is a memory region in a running ELF program's stack
++/// composed of (key: usize, value: usize) pairs.
++///
++/// The keys used in the aux vector are platform dependent. For FreeBSD, they are
++/// defined in [sys/elf_common.h][elf_common_h]. The hardware capabilities of a given
++/// CPU can be queried with the  `AT_HWCAP` and `AT_HWCAP2` keys.
++///
++/// Note that run-time feature detection is not invoked for features that can
++/// be detected at compile-time.
++///
++/// [elf_common.h]: https://svnweb.freebsd.org/base/release/12.0.0/sys/sys/elf_common.h?revision=341707
++pub(crate) fn auxv() -> Result<AuxVec, ()> {
++    if let Ok(hwcap) = archauxv(AT_HWCAP) {
++        if let Ok(hwcap2) = archauxv(AT_HWCAP2) {
++            if hwcap != 0 && hwcap2 != 0 {
++                return Ok(AuxVec { hwcap, hwcap2 });
++            }
++        }
++    }
++    Err(())
++}
++
++/// Tries to read the `key` from the auxiliary vector.
++fn archauxv(key: usize) -> Result<usize, ()> {
++    use mem;
++
++    #[derive (Copy, Clone)]
++    #[repr(C)]
++    pub struct Elf_Auxinfo {
++        pub a_type: usize,
++        pub a_un: unnamed,
++    }
++    #[derive (Copy, Clone)]
++    #[repr(C)]
++    pub union unnamed {
++        pub a_val: libc::c_long,
++        pub a_ptr: *mut libc::c_void,
++        pub a_fcn: Option<unsafe extern "C" fn() -> ()>,
++    }
++
++    let mut auxv: [Elf_Auxinfo; 27] =
++        [Elf_Auxinfo{a_type: 0, a_un: unnamed{a_val: 0,},}; 27];
++
++    let mut len: libc::c_uint = mem::size_of_val(&auxv) as libc::c_uint;
++
++    unsafe {
++        let mut mib = [libc::CTL_KERN, libc::KERN_PROC, libc::KERN_PROC_AUXV, libc::getpid()];
++    
++        let ret = libc::sysctl(mib.as_mut_ptr(),
++                       mib.len() as u32,
++                       &mut auxv as *mut _ as *mut _,
++                       &mut len as *mut _ as *mut _,
++                       0 as *mut libc::c_void,
++                       0,
++                );
++    
++        if ret != -1 {
++            for i in 0..auxv.len() {
++                if auxv[i].a_type == key {
++                    return Ok(auxv[i].a_un.a_val as usize);
++                }
++            }
++        }
++    }
++    return Ok(0);
++}
diff --git a/lang/rust/files/patch-src_stdsimd_crates_std__detect_src_detect_os_freebsd_mod.rs b/lang/rust/files/patch-src_stdsimd_crates_std__detect_src_detect_os_freebsd_mod.rs
new file mode 100644
index 000000000000..45050d142a1f
--- /dev/null
+++ b/lang/rust/files/patch-src_stdsimd_crates_std__detect_src_detect_os_freebsd_mod.rs
@@ -0,0 +1,20 @@
+--- src/stdsimd/crates/std_detect/src/detect/os/freebsd/mod.rs.orig	2019-04-24 21:07:30 UTC
++++ src/stdsimd/crates/std_detect/src/detect/os/freebsd/mod.rs
+@@ -1,9 +1,17 @@
+ //! Run-time feature detection on FreeBSD
+ 
++mod auxvec;
++
+ cfg_if! {
+     if #[cfg(target_arch = "aarch64")] {
+         mod aarch64;
+         pub use self::aarch64::check_for;
++    } else if #[cfg(target_arch = "arm")] {
++        mod arm;
++        pub use self::arm::check_for;
++    } else if #[cfg(target_arch = "powerpc64")] {
++        mod powerpc;
++        pub use self::powerpc::check_for;
+     } else {
+         use arch::detect::Feature;
+         /// Performs run-time feature detection.
diff --git a/lang/rust/files/patch-src_stdsimd_crates_std__detect_src_detect_os_freebsd_powerpc.rs b/lang/rust/files/patch-src_stdsimd_crates_std__detect_src_detect_os_freebsd_powerpc.rs
new file mode 100644
index 000000000000..352ba56708f0
--- /dev/null
+++ b/lang/rust/files/patch-src_stdsimd_crates_std__detect_src_detect_os_freebsd_powerpc.rs
@@ -0,0 +1,30 @@
+--- src/stdsimd/crates/std_detect/src/detect/os/freebsd/powerpc.rs.orig	2019-04-25 17:33:21 UTC
++++ src/stdsimd/crates/std_detect/src/detect/os/freebsd/powerpc.rs
+@@ -0,0 +1,27 @@
++//! Run-time feature detection for PowerPC on FreeBSD.
++
++use crate::detect::{Feature, cache};
++use super::{auxvec};
++
++/// Performs run-time feature detection.
++#[inline]
++pub fn check_for(x: Feature) -> bool {
++    cache::test(x as u32, detect_features)
++}
++
++fn detect_features() -> cache::Initializer {
++    let mut value = cache::Initializer::default();
++    let enable_feature = |value: &mut cache::Initializer, f, enable| {
++        if enable {
++            value.set(f as u32);
++        }
++    };
++
++    if let Ok(auxv) = auxvec::auxv() {
++        enable_feature(&mut value, Feature::altivec, auxv.hwcap & 0x10000000 != 0);
++        enable_feature(&mut value, Feature::vsx, auxv.hwcap & 0x00000080 != 0);
++        enable_feature(&mut value, Feature::power8, auxv.hwcap2 & 0x80000000 != 0);
++        return value;
++    }
++    value
++}