rpms/rust
3
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' into epel7

Browse Source
This commit is contained in:
Josh Stone 2017-11-27 21:19:29 -08:00
commit 077dd32c31
8 changed files with 134 additions and 665 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.gitignore vendored
View File

@ -83,3 +83,11 @@
/rust-1.20.0-powerpc64-unknown-linux-gnu.tar.xz
/rust-1.20.0-s390x-unknown-linux-gnu.tar.xz
/rust-1.20.0-x86_64-unknown-linux-gnu.tar.xz
/rustc-1.22.1-src.tar.xz
/rust-1.21.0-aarch64-unknown-linux-gnu.tar.xz
/rust-1.21.0-armv7-unknown-linux-gnueabihf.tar.xz
/rust-1.21.0-i686-unknown-linux-gnu.tar.xz
/rust-1.21.0-powerpc64le-unknown-linux-gnu.tar.xz
/rust-1.21.0-powerpc64-unknown-linux-gnu.tar.xz
/rust-1.21.0-s390x-unknown-linux-gnu.tar.xz
/rust-1.21.0-x86_64-unknown-linux-gnu.tar.xz

405
rust-1.21.0-44066-ppc64-struct-abi.patch
View File

@ -1,405 +0,0 @@
From bc3a71ed00af01855b0ae8908ae271b83eca34f6 Mon Sep 17 00:00:00 2001
From: bors <bors@rust-lang.org>
Date: Sat, 2 Sep 2017 19:46:51 +0000
Subject: [PATCH] Auto merge of #44066 - cuviper:powerpc64-extern-abi,
r=alexcrichton
powerpc64: improve extern struct ABI
These fixes all have to do with the 64-bit PowerPC ELF ABI for big-endian
targets. The ELF v2 ABI for powerpc64le already worked well.
- Return after marking return aggregates indirect. Fixes #42757.
- Pass one-member float aggregates as direct argument values.
- Aggregate arguments less than 64-bit must be written in the least-
significant bits of the parameter space.
- Larger aggregates are instead padded at the tail.
(i.e. filling MSBs, padding the remaining LSBs.)
New tests were also added for the single-float aggregate, and a 3-byte
aggregate to check that it's filled into LSBs. Overall, at least these
formerly-failing tests now pass on powerpc64:
- run-make/extern-fn-struct-passing-abi
- run-make/extern-fn-with-packed-struct
- run-pass/extern-pass-TwoU16s.rs
- run-pass/extern-pass-TwoU8s.rs
- run-pass/struct-return.rs
---
src/librustc_trans/cabi_powerpc64.rs | 64 +++++++++++++++++-----
src/librustc_trans/cabi_x86.rs | 41 ++++++++++++--
.../run-make/extern-fn-struct-passing-abi/test.c | 32 ++++++++++-
.../run-make/extern-fn-struct-passing-abi/test.rs | 27 +++++++++
.../run-make/extern-fn-with-packed-struct/test.c | 5 ++
.../run-make/extern-fn-with-packed-struct/test.rs | 26 +--------
6 files changed, 151 insertions(+), 44 deletions(-)
diff --git a/src/librustc_trans/cabi_powerpc64.rs b/src/librustc_trans/cabi_powerpc64.rs
index 5c695387236f..fb5472eb6ae1 100644
--- a/src/librustc_trans/cabi_powerpc64.rs
+++ b/src/librustc_trans/cabi_powerpc64.rs
@@ -14,14 +14,26 @@
use abi::{FnType, ArgType, LayoutExt, Reg, RegKind, Uniform};
use context::CrateContext;
+use rustc::ty::layout;
-fn is_homogeneous_aggregate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, arg: &mut ArgType<'tcx>)
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum ABI {
+ ELFv1, // original ABI used for powerpc64 (big-endian)
+ ELFv2, // newer ABI used for powerpc64le
+}
+use self::ABI::*;
+
+fn is_homogeneous_aggregate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
+ arg: &mut ArgType<'tcx>,
+ abi: ABI)
-> Option<Uniform> {
arg.layout.homogeneous_aggregate(ccx).and_then(|unit| {
let size = arg.layout.size(ccx);
- // Ensure we have at most eight uniquely addressable members.
- if size > unit.size.checked_mul(8, ccx).unwrap() {
+ // ELFv1 only passes one-member aggregates transparently.
+ // ELFv2 passes up to eight uniquely addressable members.
+ if (abi == ELFv1 && size > unit.size)
+ || size > unit.size.checked_mul(8, ccx).unwrap() {
return None;
}
@@ -42,21 +54,23 @@ fn is_homogeneous_aggregate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, arg: &mut Ar
})
}
-fn classify_ret_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ret: &mut ArgType<'tcx>) {
+fn classify_ret_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ret: &mut ArgType<'tcx>, abi: ABI) {
if !ret.layout.is_aggregate() {
ret.extend_integer_width_to(64);
return;
}
- // The PowerPC64 big endian ABI doesn't return aggregates in registers
- if ccx.sess().target.target.target_endian == "big" {
+ // The ELFv1 ABI doesn't return aggregates in registers
+ if abi == ELFv1 {
ret.make_indirect(ccx);
+ return;
}
- if let Some(uniform) = is_homogeneous_aggregate(ccx, ret) {
+ if let Some(uniform) = is_homogeneous_aggregate(ccx, ret, abi) {
ret.cast_to(ccx, uniform);
return;
}
+
let size = ret.layout.size(ccx);
let bits = size.bits();
if bits <= 128 {
@@ -80,31 +94,55 @@ fn classify_ret_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ret: &mut ArgType<'tc
ret.make_indirect(ccx);
}
-fn classify_arg_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, arg: &mut ArgType<'tcx>) {
+fn classify_arg_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, arg: &mut ArgType<'tcx>, abi: ABI) {
if !arg.layout.is_aggregate() {
arg.extend_integer_width_to(64);
return;
}
- if let Some(uniform) = is_homogeneous_aggregate(ccx, arg) {
+ if let Some(uniform) = is_homogeneous_aggregate(ccx, arg, abi) {
arg.cast_to(ccx, uniform);
return;
}
- let total = arg.layout.size(ccx);
+ let size = arg.layout.size(ccx);
+ let (unit, total) = match abi {
+ ELFv1 => {
+ // In ELFv1, aggregates smaller than a doubleword should appear in
+ // the least-significant bits of the parameter doubleword. The rest
+ // should be padded at their tail to fill out multiple doublewords.
+ if size.bits() <= 64 {
+ (Reg { kind: RegKind::Integer, size }, size)
+ } else {
+ let align = layout::Align::from_bits(64, 64).unwrap();
+ (Reg::i64(), size.abi_align(align))
+ }
+ },
+ ELFv2 => {
+ // In ELFv2, we can just cast directly.
+ (Reg::i64(), size)
+ },
+ };
+
arg.cast_to(ccx, Uniform {
- unit: Reg::i64(),
+ unit,
total
});
}
pub fn compute_abi_info<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fty: &mut FnType<'tcx>) {
+ let abi = match ccx.sess().target.target.target_endian.as_str() {
+ "big" => ELFv1,
+ "little" => ELFv2,
+ _ => unimplemented!(),
+ };
+
if !fty.ret.is_ignore() {
- classify_ret_ty(ccx, &mut fty.ret);
+ classify_ret_ty(ccx, &mut fty.ret, abi);
}
for arg in &mut fty.args {
if arg.is_ignore() { continue; }
- classify_arg_ty(ccx, arg);
+ classify_arg_ty(ccx, arg, abi);
}
}
diff --git a/src/librustc_trans/cabi_x86.rs b/src/librustc_trans/cabi_x86.rs
index 8b024b8c97fa..49634d6e78ce 100644
--- a/src/librustc_trans/cabi_x86.rs
+++ b/src/librustc_trans/cabi_x86.rs
@@ -11,12 +11,30 @@
use abi::{ArgAttribute, FnType, LayoutExt, Reg, RegKind};
use common::CrateContext;
+use rustc::ty::layout::{self, Layout, TyLayout};
+
#[derive(PartialEq)]
pub enum Flavor {
General,
Fastcall
}
+fn is_single_fp_element<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
+ layout: TyLayout<'tcx>) -> bool {
+ match *layout {
+ Layout::Scalar { value: layout::F32, .. } |
+ Layout::Scalar { value: layout::F64, .. } => true,
+ Layout::Univariant { .. } => {
+ if layout.field_count() == 1 {
+ is_single_fp_element(ccx, layout.field(ccx, 0))
+ } else {
+ false
+ }
+ }
+ _ => false
+ }
+}
+
pub fn compute_abi_info<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
fty: &mut FnType<'tcx>,
flavor: Flavor) {
@@ -33,12 +51,23 @@ pub fn compute_abi_info<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
if t.options.is_like_osx || t.options.is_like_windows
|| t.options.is_like_openbsd {
let size = fty.ret.layout.size(ccx);
- match size.bytes() {
- 1 => fty.ret.cast_to(ccx, Reg::i8()),
- 2 => fty.ret.cast_to(ccx, Reg::i16()),
- 4 => fty.ret.cast_to(ccx, Reg::i32()),
- 8 => fty.ret.cast_to(ccx, Reg::i64()),
- _ => fty.ret.make_indirect(ccx)
+
+ // According to Clang, everyone but MSVC returns single-element
+ // float aggregates directly in a floating-point register.
+ if !t.options.is_like_msvc && is_single_fp_element(ccx, fty.ret.layout) {
+ match size.bytes() {
+ 4 => fty.ret.cast_to(ccx, Reg::f32()),
+ 8 => fty.ret.cast_to(ccx, Reg::f64()),
+ _ => fty.ret.make_indirect(ccx)
+ }
+ } else {
+ match size.bytes() {
+ 1 => fty.ret.cast_to(ccx, Reg::i8()),
+ 2 => fty.ret.cast_to(ccx, Reg::i16()),
+ 4 => fty.ret.cast_to(ccx, Reg::i32()),
+ 8 => fty.ret.cast_to(ccx, Reg::i64()),
+ _ => fty.ret.make_indirect(ccx)
+ }
}
} else {
fty.ret.make_indirect(ccx);
diff --git a/src/test/run-make/extern-fn-struct-passing-abi/test.c b/src/test/run-make/extern-fn-struct-passing-abi/test.c
index 44a940a17a98..25cd6da10b8f 100644
--- a/src/test/run-make/extern-fn-struct-passing-abi/test.c
+++ b/src/test/run-make/extern-fn-struct-passing-abi/test.c
@@ -43,6 +43,16 @@ struct FloatPoint {
double y;
};
+struct FloatOne {
+ double x;
+};
+
+struct IntOdd {
+ int8_t a;
+ int8_t b;
+ int8_t c;
+};
+
// System V x86_64 ABI:
// a, b, c, d, e should be in registers
// s should be byval pointer
@@ -283,7 +293,7 @@ struct Huge huge_struct(struct Huge s) {
// p should be in registers
// return should be in registers
//
-// Win64 ABI:
+// Win64 ABI and 64-bit PowerPC ELFv1 ABI:
// p should be a byval pointer
// return should be in a hidden sret pointer
struct FloatPoint float_point(struct FloatPoint p) {
@@ -292,3 +302,23 @@ struct FloatPoint float_point(struct FloatPoint p) {
return p;
}
+
+// 64-bit PowerPC ELFv1 ABI:
+// f1 should be in a register
+// return should be in a hidden sret pointer
+struct FloatOne float_one(struct FloatOne f1) {
+ assert(f1.x == 7.);
+
+ return f1;
+}
+
+// 64-bit PowerPC ELFv1 ABI:
+// i should be in the least-significant bits of a register
+// return should be in a hidden sret pointer
+struct IntOdd int_odd(struct IntOdd i) {
+ assert(i.a == 1);
+ assert(i.b == 2);
+ assert(i.c == 3);
+
+ return i;
+}
diff --git a/src/test/run-make/extern-fn-struct-passing-abi/test.rs b/src/test/run-make/extern-fn-struct-passing-abi/test.rs
index aaae7ae4fb49..54a4f868eb4e 100644
--- a/src/test/run-make/extern-fn-struct-passing-abi/test.rs
+++ b/src/test/run-make/extern-fn-struct-passing-abi/test.rs
@@ -53,6 +53,20 @@ struct FloatPoint {
y: f64
}
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(C)]
+struct FloatOne {
+ x: f64,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(C)]
+struct IntOdd {
+ a: i8,
+ b: i8,
+ c: i8,
+}
+
#[link(name = "test", kind = "static")]
extern {
fn byval_rect(a: i32, b: i32, c: i32, d: i32, e: i32, s: Rect);
@@ -83,6 +97,10 @@ extern {
fn huge_struct(s: Huge) -> Huge;
fn float_point(p: FloatPoint) -> FloatPoint;
+
+ fn float_one(f: FloatOne) -> FloatOne;
+
+ fn int_odd(i: IntOdd) -> IntOdd;
}
fn main() {
@@ -91,6 +109,8 @@ fn main() {
let u = FloatRect { a: 3489, b: 3490, c: 8. };
let v = Huge { a: 5647, b: 5648, c: 5649, d: 5650, e: 5651 };
let p = FloatPoint { x: 5., y: -3. };
+ let f1 = FloatOne { x: 7. };
+ let i = IntOdd { a: 1, b: 2, c: 3 };
unsafe {
byval_rect(1, 2, 3, 4, 5, s);
@@ -113,5 +133,12 @@ fn main() {
assert_eq!(sret_byval_struct(1, 2, 3, 4, s), t);
assert_eq!(sret_split_struct(1, 2, s), t);
assert_eq!(float_point(p), p);
+ assert_eq!(int_odd(i), i);
+
+ // MSVC/GCC/Clang are not consistent in the ABI of single-float aggregates.
+ // x86_64: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82028
+ // i686: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82041
+ #[cfg(not(all(windows, target_env = "gnu")))]
+ assert_eq!(float_one(f1), f1);
}
}
diff --git a/src/test/run-make/extern-fn-with-packed-struct/test.c b/src/test/run-make/extern-fn-with-packed-struct/test.c
index 506954fca461..4124e202c1dd 100644
--- a/src/test/run-make/extern-fn-with-packed-struct/test.c
+++ b/src/test/run-make/extern-fn-with-packed-struct/test.c
@@ -1,6 +1,8 @@
// ignore-license
// Pragma needed cause of gcc bug on windows: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52991
+#include <assert.h>
+
#ifdef _MSC_VER
#pragma pack(push,1)
struct Foo {
@@ -18,5 +20,8 @@ struct __attribute__((packed)) Foo {
#endif
struct Foo foo(struct Foo foo) {
+ assert(foo.a == 1);
+ assert(foo.b == 2);
+ assert(foo.c == 3);
return foo;
}
diff --git a/src/test/run-make/extern-fn-with-packed-struct/test.rs b/src/test/run-make/extern-fn-with-packed-struct/test.rs
index 9e81636e3670..d2540ad61542 100644
--- a/src/test/run-make/extern-fn-with-packed-struct/test.rs
+++ b/src/test/run-make/extern-fn-with-packed-struct/test.rs
@@ -8,36 +8,14 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::fmt;
-
-#[repr(packed)]
-#[derive(Copy, Clone)]
+#[repr(C, packed)]
+#[derive(Copy, Clone, Debug, PartialEq)]
struct Foo {
a: i8,
b: i16,
c: i8
}
-impl PartialEq for Foo {
- fn eq(&self, other: &Foo) -> bool {
- self.a == other.a && self.b == other.b && self.c == other.c
- }
-}
-
-impl fmt::Debug for Foo {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let a = self.a;
- let b = self.b;
- let c = self.c;
-
- f.debug_struct("Foo")
- .field("a", &a)
- .field("b", &b)
- .field("c", &c)
- .finish()
- }
-}
-
#[link(name = "test", kind = "static")]
extern {
fn foo(f: Foo) -> Foo;
--
2.13.5

28
rust-1.21.0-44203-exclude-compiler-rt-test.patch
View File

@ -1,28 +0,0 @@
From 35f8a2065b7d17d39481a75cefa739df7a061084 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Wed, 30 Aug 2017 18:20:59 -0700
Subject: [PATCH] rustbuild: update the rust-src filter for compiler-rt
We wanted `src/compiler-rt/test` filtered from the `rust-src` package,
but that path is now `src/libcompiler_builtins/compiler-rt/test`. This
saves over half of the installed rust-src size. (50MB -> 22MB)
---
src/bootstrap/dist.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/bootstrap/dist.rs b/src/bootstrap/dist.rs
index 746f85a9d59d..05d59e7d5956 100644
--- a/src/bootstrap/dist.rs
+++ b/src/bootstrap/dist.rs
@@ -754,7 +754,7 @@ impl Step for Src {
"src/libprofiler_builtins",
];
let std_src_dirs_exclude = [
- "src/compiler-rt/test",
+ "src/libcompiler_builtins/compiler-rt/test",
"src/jemalloc/test/unit",
];
--
2.13.5

210
rust-1.21.0-44440-s390x-global-align.patch
View File

@ -1,210 +0,0 @@
From 0f5ee28213a73733e6811b176c89ecececfe9cbc Mon Sep 17 00:00:00 2001
From: bors <bors@rust-lang.org>
Date: Mon, 11 Sep 2017 12:53:21 +0000
Subject: [PATCH] Auto merge of #44440 - cuviper:min_global_align,
r=japaric
Add `TargetOptions::min_global_align`, with s390x at 16-bit
The SystemZ `LALR` instruction provides PC-relative addressing for globals,
but only to *even* addresses, so other compilers make sure that such
globals are always 2-byte aligned. In Clang, this is modeled with
`TargetInfo::MinGlobalAlign`, and `TargetOptions::min_global_align` now
serves the same purpose for rustc.
In Clang, the only targets that set this are SystemZ, Lanai, and NVPTX, and
the latter two don't have targets in rust master.
Fixes #44411.
r? @eddyb
---
src/librustc_back/target/mod.rs | 6 ++++
.../target/s390x_unknown_linux_gnu.rs | 1 +
src/librustc_trans/consts.rs | 24 ++++++++++++--
src/test/run-make/min-global-align/Makefile | 22 +++++++++++++
.../run-make/min-global-align/min_global_align.rs | 38 ++++++++++++++++++++++
5 files changed, 89 insertions(+), 2 deletions(-)
create mode 100644 src/test/run-make/min-global-align/Makefile
create mode 100644 src/test/run-make/min-global-align/min_global_align.rs
diff --git a/src/librustc_back/target/mod.rs b/src/librustc_back/target/mod.rs
index 130e1b695dbd..301cf3f8c820 100644
--- a/src/librustc_back/target/mod.rs
+++ b/src/librustc_back/target/mod.rs
@@ -425,6 +425,9 @@ pub struct TargetOptions {
/// Whether or not stack probes (__rust_probestack) are enabled
pub stack_probes: bool,
+
+ /// The minimum alignment for global symbols.
+ pub min_global_align: Option<u64>,
}
impl Default for TargetOptions {
@@ -486,6 +489,7 @@ impl Default for TargetOptions {
crt_static_default: false,
crt_static_respected: false,
stack_probes: false,
+ min_global_align: None,
}
}
}
@@ -724,6 +728,7 @@ impl Target {
key!(crt_static_default, bool);
key!(crt_static_respected, bool);
key!(stack_probes, bool);
+ key!(min_global_align, Option<u64>);
if let Some(array) = obj.find("abi-blacklist").and_then(Json::as_array) {
for name in array.iter().filter_map(|abi| abi.as_string()) {
@@ -914,6 +919,7 @@ impl ToJson for Target {
target_option_val!(crt_static_default);
target_option_val!(crt_static_respected);
target_option_val!(stack_probes);
+ target_option_val!(min_global_align);
if default.abi_blacklist != self.options.abi_blacklist {
d.insert("abi-blacklist".to_string(), self.options.abi_blacklist.iter()
diff --git a/src/librustc_back/target/s390x_unknown_linux_gnu.rs b/src/librustc_back/target/s390x_unknown_linux_gnu.rs
index 78a6bb7933d9..aad9effacd44 100644
--- a/src/librustc_back/target/s390x_unknown_linux_gnu.rs
+++ b/src/librustc_back/target/s390x_unknown_linux_gnu.rs
@@ -22,6 +22,7 @@ pub fn target() -> TargetResult {
base.max_atomic_width = Some(64);
// see #36994
base.exe_allocation_crate = None;
+ base.min_global_align = Some(16);
Ok(Target {
llvm_target: "s390x-unknown-linux-gnu".to_string(),
diff --git a/src/librustc_trans/consts.rs b/src/librustc_trans/consts.rs
index 310cd6fe9559..f7f9b9386841 100644
--- a/src/librustc_trans/consts.rs
+++ b/src/librustc_trans/consts.rs
@@ -26,6 +26,7 @@ use rustc::ty;
use rustc::hir;
+use std::cmp;
use std::ffi::{CStr, CString};
use syntax::ast;
use syntax::attr;
@@ -42,6 +43,25 @@ pub fn bitcast(val: ValueRef, ty: Type) -> ValueRef {
}
}
+fn set_global_alignment(ccx: &CrateContext,
+ gv: ValueRef,
+ mut align: machine::llalign) {
+ // The target may require greater alignment for globals than the type does.
+ // Note: GCC and Clang also allow `__attribute__((aligned))` on variables,
+ // which can force it to be smaller. Rust doesn't support this yet.
+ if let Some(min) = ccx.sess().target.target.options.min_global_align {
+ match ty::layout::Align::from_bits(min, min) {
+ Ok(min) => align = cmp::max(align, min.abi() as machine::llalign),
+ Err(err) => {
+ ccx.sess().err(&format!("invalid minimum global alignment: {}", err));
+ }
+ }
+ }
+ unsafe {
+ llvm::LLVMSetAlignment(gv, align);
+ }
+}
+
pub fn addr_of_mut(ccx: &CrateContext,
cv: ValueRef,
align: machine::llalign,
@@ -53,7 +73,7 @@ pub fn addr_of_mut(ccx: &CrateContext,
bug!("symbol `{}` is already defined", name);
});
llvm::LLVMSetInitializer(gv, cv);
- llvm::LLVMSetAlignment(gv, align);
+ set_global_alignment(ccx, gv, align);
llvm::LLVMRustSetLinkage(gv, llvm::Linkage::InternalLinkage);
SetUnnamedAddr(gv, true);
gv
@@ -271,7 +291,7 @@ pub fn trans_static<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
ccx.statics_to_rauw().borrow_mut().push((g, new_g));
new_g
};
- llvm::LLVMSetAlignment(g, ccx.align_of(ty));
+ set_global_alignment(ccx, g, ccx.align_of(ty));
llvm::LLVMSetInitializer(g, v);
// As an optimization, all shared statics which do not have interior
diff --git a/src/test/run-make/min-global-align/Makefile b/src/test/run-make/min-global-align/Makefile
new file mode 100644
index 000000000000..2eacc36f380d
--- /dev/null
+++ b/src/test/run-make/min-global-align/Makefile
@@ -0,0 +1,22 @@
+-include ../tools.mk
+
+# This tests ensure that global variables respect the target minimum alignment.
+# The three bools `STATIC_BOOL`, `STATIC_MUT_BOOL`, and `CONST_BOOL` all have
+# type-alignment of 1, but some targets require greater global alignment.
+
+SRC = min_global_align.rs
+LL = $(TMPDIR)/min_global_align.ll
+
+all:
+ifeq ($(UNAME),Linux)
+# Most targets are happy with default alignment -- take i686 for example.
+ifeq ($(filter x86,$(LLVM_COMPONENTS)),x86)
+ $(RUSTC) --target=i686-unknown-linux-gnu --emit=llvm-ir $(SRC)
+ [ "$$(grep -c 'align 1' "$(LL)")" -eq "3" ]
+endif
+# SystemZ requires even alignment for PC-relative addressing.
+ifeq ($(filter systemz,$(LLVM_COMPONENTS)),systemz)
+ $(RUSTC) --target=s390x-unknown-linux-gnu --emit=llvm-ir $(SRC)
+ [ "$$(grep -c 'align 2' "$(LL)")" -eq "3" ]
+endif
+endif
diff --git a/src/test/run-make/min-global-align/min_global_align.rs b/src/test/run-make/min-global-align/min_global_align.rs
new file mode 100644
index 000000000000..3d4f9001a747
--- /dev/null
+++ b/src/test/run-make/min-global-align/min_global_align.rs
@@ -0,0 +1,38 @@
+// Copyright 2017 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.
+
+#![feature(no_core, lang_items)]
+#![crate_type="rlib"]
+#![no_core]
+
+pub static STATIC_BOOL: bool = true;
+
+pub static mut STATIC_MUT_BOOL: bool = true;
+
+const CONST_BOOL: bool = true;
+pub static CONST_BOOL_REF: &'static bool = &CONST_BOOL;
+
+
+#[lang = "sized"]
+trait Sized {}
+
+#[lang = "copy"]
+trait Copy {}
+
+#[lang = "freeze"]
+trait Freeze {}
+
+#[lang = "sync"]
+trait Sync {}
+impl Sync for bool {}
+impl Sync for &'static bool {}
+
+#[lang="drop_in_place"]
+pub unsafe fn drop_in_place<T: ?Sized>(_: *mut T) { }
--
2.13.5

93
rust-1.22.0-45566-option-checking.patch Normal file
View File

@ -0,0 +1,93 @@
commit 75277c72c0c6f603bb258383ad74d3082dc4a720 (from c1a0b6d9eb888ded9a7204db0d67d62b1cdc9944)
Merge: c1a0b6d9eb88 19714f55ee70
Author: bors <bors@rust-lang.org>
Date: Sat Oct 28 07:08:52 2017 +0000
Auto merge of #45566 - cuviper:option-checking, r=alexcrichton
configure.py: fix --disable-option-checking and extra config paths
- indexing 'option-checking' out of `known_args` had a type error
- when option checking is disabled, don't error on duplicate args, just take the last
- add config.toml stubs for datadir, infodir, and localstatedir (which were already accepted, but broken)
---
This fixes a regression from 1.21 to beta, when the configure script was rewritten in python.
diff --git a/config.toml.example b/config.toml.example
index 261fe2053879..df0142b8d46d 100644
--- a/config.toml.example
+++ b/config.toml.example
@@ -203,6 +203,16 @@
# Where to install man pages in `prefix` above
#mandir = "share/man"
+# Where to install data in `prefix` above (currently unused)
+#datadir = "share"
+
+# Where to install additional info in `prefix` above (currently unused)
+#infodir = "share/info"
+
+# Where to install local state (currently unused)
+# If this is a relative path, it will get installed in `prefix` above
+#localstatedir = "/var/lib"
+
# =============================================================================
# Options for compiling Rust code itself
# =============================================================================
diff --git a/src/bootstrap/config.rs b/src/bootstrap/config.rs
index 66e5efcea4e8..33c7141e7044 100644
--- a/src/bootstrap/config.rs
+++ b/src/bootstrap/config.rs
@@ -207,6 +207,11 @@ struct Install {
bindir: Option<String>,
libdir: Option<String>,
mandir: Option<String>,
+
+ // standard paths, currently unused
+ datadir: Option<String>,
+ infodir: Option<String>,
+ localstatedir: Option<String>,
}
/// TOML representation of how the LLVM build is configured.
diff --git a/src/bootstrap/configure.py b/src/bootstrap/configure.py
index 42425a164a20..579422c97993 100755
--- a/src/bootstrap/configure.py
+++ b/src/bootstrap/configure.py
@@ -225,7 +225,12 @@ while i < len(sys.argv):
unknown_args.append(arg)
p("")
-if 'option-checking' not in known_args or known_args['option-checking'][1]:
+# Note: here and a few other places, we use [-1] to apply the *last* value
+# passed. But if option-checking is enabled, then the known_args loop will
+# also assert that options are only passed once.
+option_checking = ('option-checking' not in known_args
+ or known_args['option-checking'][-1][1])
+if option_checking:
if len(unknown_args) > 0:
err("Option '" + unknown_args[0] + "' is not recognized")
if len(need_value_args) > 0:
@@ -238,7 +243,7 @@ config = {}
def build():
if 'build' in known_args:
- return known_args['build'][0][1]
+ return known_args['build'][-1][1]
return bootstrap.default_build_triple()
@@ -276,9 +281,9 @@ for key in known_args:
# Ensure each option is only passed once
arr = known_args[key]
- if len(arr) > 1:
+ if option_checking and len(arr) > 1:
err("Option '{}' provided more than once".format(key))
- option, value = arr[0]
+ option, value = arr[-1]
# If we have a clear avenue to set our value in rustbuild, do so
if option.rustbuild is not None:

37
rust.spec
View File

@ -8,10 +8,10 @@
# To bootstrap from scratch, set the channel and date from src/stage0.txt
# e.g. 1.10.0 wants rustc: 1.9.0-2016-05-24
# or nightly wants some beta-YYYY-MM-DD
%global bootstrap_rust 1.20.0
%global bootstrap_cargo 0.21.0
%global bootstrap_rust 1.21.0
%global bootstrap_cargo 0.22.0
%global bootstrap_channel %{bootstrap_rust}
%global bootstrap_date 2017-08-31
%global bootstrap_date 2017-10-12
# Only the specified arches will use bootstrap binaries.
#global bootstrap_arches %%{rust_arches}
@ -47,7 +47,7 @@
Name: rust
Version: 1.21.0
Version: 1.22.1
Release: 1%{?dist}
Summary: The Rust Programming Language
License: (ASL 2.0 or MIT) and (BSD and ISC and MIT)
@ -62,9 +62,7 @@ ExclusiveArch: %{rust_arches}
%endif
Source0: https://static.rust-lang.org/dist/%{rustc_package}.tar.xz
Patch1: rust-1.21.0-44203-exclude-compiler-rt-test.patch
Patch2: rust-1.21.0-44066-ppc64-struct-abi.patch
Patch3: rust-1.21.0-44440-s390x-global-align.patch
Patch1: rust-1.22.0-45566-option-checking.patch
# Get the Rust triple for any arch.
%{lua: function rust_triple(arch)
@ -128,6 +126,11 @@ Provides: bundled(llvm) = 4.0
%else
%if 0%{?epel}
%global llvm llvm3.9
%endif
%if 0%{?fedora} >= 28
%global llvm llvm4.0
%endif
%if %defined llvm
%global llvm_root %{_libdir}/%{llvm}
%else
%global llvm llvm
@ -310,9 +313,8 @@ sed -i.ffi -e '$a #[link(name = "ffi")] extern {}' \
src/librustc_llvm/lib.rs
%endif
%patch1 -p1 -b .compiler-rt
%patch2 -p1 -b .ppc64-struct-abi
%patch3 -p1 -b .s390x-global-align
%global _default_patch_fuzz 1
%patch1 -p1 -b .option-checking
# The configure macro will modify some autoconf-related files, which upsets
# cargo when it tries to verify checksums in those files. If we just truncate
@ -332,6 +334,14 @@ find src/vendor -name .cargo-checksum.json \
%global common_libdir %{_prefix}/lib
%global rustlibdir %{common_libdir}/rustlib
%ifarch %{arm}
# full debuginfo is exhausting memory; just do libstd for now
# https://github.com/rust-lang/rust/issues/45854
%define enable_debuginfo --enable-debuginfo --enable-debuginfo-only-std --disable-debuginfo-lines
%else
%define enable_debuginfo --enable-debuginfo --disable-debuginfo-only-std --disable-debuginfo-lines
%endif
%configure --disable-option-checking \
--libdir=%{common_libdir} \
--build=%{rust_triple} --host=%{rust_triple} --target=%{rust_triple} \
@ -340,9 +350,7 @@ find src/vendor -name .cargo-checksum.json \
%{!?with_llvm_static: --enable-llvm-link-shared } } \
--disable-jemalloc \
--disable-rpath \
--disable-debuginfo-lines \
--disable-debuginfo-only-std \
--enable-debuginfo \
%{enable_debuginfo} \
--enable-vendor \
--release-channel=%{channel}
@ -471,6 +479,9 @@ rm -f %{buildroot}%{rustlibdir}/etc/lldb_*.py*
%changelog
* Thu Nov 23 2017 Josh Stone <jistone@redhat.com> - 1.22.1-1
- Update to 1.22.1.
* Thu Oct 12 2017 Josh Stone <jistone@redhat.com> - 1.21.0-1
- Update to 1.21.0.

2
sources
View File

@ -1 +1 @@
SHA512 (rustc-1.21.0-src.tar.xz) = 63b5c247ef7028c59bb246b96cb9917476d6d13cf68b37956e290248a1e53de3e4dbfad1dcae3c5c2cacc73c9dd212c50e45902c7d913fadeaac81db630bc951
SHA512 (rustc-1.22.1-src.tar.xz) = 9e97af1cc539ebf6ddb564f35dc11f3275ec09d834afc1ddfe4e09e22430a777af9260a79c625d2c5ed941a847c529d91de465ce1c228bd6af37dcda74e60bee

16
sources-bootstrap
View File

@ -1,8 +1,8 @@
SHA512 (rustc-1.21.0-src.tar.xz) = 63b5c247ef7028c59bb246b96cb9917476d6d13cf68b37956e290248a1e53de3e4dbfad1dcae3c5c2cacc73c9dd212c50e45902c7d913fadeaac81db630bc951
SHA512 (rust-1.20.0-aarch64-unknown-linux-gnu.tar.xz) = 23ac0086fa10c46eb2d607fc70dcb35b9858440b20030c4e688ec7d83e1d2798c46dd931914e2b555b6d846220bc678ea769a5e9b366b8fd12d9e57b4962ca3a
SHA512 (rust-1.20.0-armv7-unknown-linux-gnueabihf.tar.xz) = ca041644fd78d399e81a8dad9b5d5b401a2d8426eaf1e4ed02a2c5415b0a1caefadbc9716fefd6fd01aedde4fae15fc0357375d43a803714a88d65643b8ab5d1
SHA512 (rust-1.20.0-i686-unknown-linux-gnu.tar.xz) = fdd3e039589feba8a1f3ab2aa0d92bfe87a05d0e1697c5ea981577628e89715d3790a747408cb0d52fc48605c3faf6b59548e6237bdfc0505f8090b23a63a89b
SHA512 (rust-1.20.0-powerpc64le-unknown-linux-gnu.tar.xz) = 2ccb9b686bc6e52dfe906ee9c807564b7a87839340b6b3de9862d53182d68044b892f6eea5606a9c6e04538a1aa3d8e2c17c73480bbfe317c1edb294e1b937a4
SHA512 (rust-1.20.0-powerpc64-unknown-linux-gnu.tar.xz) = cd25a99e9f4331d458639887db8e3011ca9eb0907bb8a9f948353042658344338b170326c3931f4cca66dde2375611eeaae536f9b08a8f3cc4b75eef9220a8b5
SHA512 (rust-1.20.0-s390x-unknown-linux-gnu.tar.xz) = 60e051bc917c46fcec0816f1a7bbaee40a781af3f9061c8d3d257fc380321994737cc95383686032b7264e42b75d0ac71c7727875ec97672e6776329915bffb6
SHA512 (rust-1.20.0-x86_64-unknown-linux-gnu.tar.xz) = 5e397b1d3f7ef2ef7f11a7d48ad309f17220751246d5bf3e7301cca1c1a81864be49a7b78e122bb3bc66938971b73c8db443ba9e969880544e61af4061a5d96e
SHA512 (rustc-1.22.1-src.tar.xz) = 9e97af1cc539ebf6ddb564f35dc11f3275ec09d834afc1ddfe4e09e22430a777af9260a79c625d2c5ed941a847c529d91de465ce1c228bd6af37dcda74e60bee
SHA512 (rust-1.21.0-aarch64-unknown-linux-gnu.tar.xz) = 045ce63c791677c4965ceb09b9c69ee28c2d5a1e46cbd83b4470756172c8cbfbb8887a7077d467b6559d17eee193b62e3d9ac4d0f4dac20bfde26bf55bfa216a
SHA512 (rust-1.21.0-armv7-unknown-linux-gnueabihf.tar.xz) = ee355311a3a581d95f206ed48f362a99af695b6816b7858eeac64b6529fec00b2a8ee5c3a84d57a4417d254455c9ade1c1199926fab09b7f30b888115d9e4397
SHA512 (rust-1.21.0-i686-unknown-linux-gnu.tar.xz) = 686791d299c353282bddc6e190b8befb23a93f266ab7404397d1378a69156f75a0e5ab156ceef83d60a33e510dec989ee1f37710037995a7bd790c0cdc6aad2d
SHA512 (rust-1.21.0-powerpc64le-unknown-linux-gnu.tar.xz) = 836e09f762d4c07abf3c7ae7ac77eaf4acefb18d5e7f45fa1fdb2a7fe22fad405ab5ef625ee377bc89fe4b602dac45c3a34697e813ba83e70cf693ff1ca19b92
SHA512 (rust-1.21.0-powerpc64-unknown-linux-gnu.tar.xz) = 1ff4614234809bfb000afa3b44f46e9874916fb88ae35a7492befcba8ad95e6a2e0a17e62dd0d2165892eb115730dc32af5e761ec37ea738c9c19f57a1dc62d3
SHA512 (rust-1.21.0-s390x-unknown-linux-gnu.tar.xz) = 2d35ea709f08897c170e2f6b6ab55cdba1d5f8d558533407adac9d5b825f2dddf3e0b992ae8c89b37802e203a6b7bf963dc75e4a8c2d943e48fae97d9e9f7268
SHA512 (rust-1.21.0-x86_64-unknown-linux-gnu.tar.xz) = 555235fb1c6e819b064c93771c03538e693420c2eb6883997e29b7449e88c8dba23de136369e28b744c3920b861a26812e1df155f32acced76927c81381f54d1