diff options
Diffstat (limited to 'src')
66 files changed, 218 insertions, 991 deletions
diff --git a/src/libprofiler_builtins/build.rs b/src/libprofiler_builtins/build.rs index 04cd2efe000..8adcff67800 100644 --- a/src/libprofiler_builtins/build.rs +++ b/src/libprofiler_builtins/build.rs @@ -21,7 +21,6 @@ fn main() { "InstrProfilingPlatformLinux.c", "InstrProfilingPlatformOther.c", "InstrProfilingPlatformWindows.c", - "InstrProfilingRuntime.cc", "InstrProfilingUtil.c", "InstrProfilingValue.c", "InstrProfilingWriter.c", @@ -68,10 +67,17 @@ fn main() { let root = env::var_os("RUST_COMPILER_RT_ROOT").unwrap(); let root = Path::new(&root); + let src_root = root.join("lib").join("profile"); for src in profile_sources { - cfg.file(root.join("lib").join("profile").join(src)); + cfg.file(src_root.join(src)); } + // The file was renamed in LLVM 10. + let old_runtime_path = src_root.join("InstrProfilingRuntime.cc"); + let new_runtime_path = src_root.join("InstrProfilingRuntime.cpp"); + cfg.file(if old_runtime_path.exists() { old_runtime_path } else { new_runtime_path }); + + cfg.include(root.join("include")); cfg.warnings(false); cfg.compile("profiler-rt"); } diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs index f07601ed383..50a35fe3dcf 100644 --- a/src/librustc_codegen_llvm/context.rs +++ b/src/librustc_codegen_llvm/context.rs @@ -143,6 +143,10 @@ fn strip_function_ptr_alignment(data_layout: String) -> String { data_layout.replace("-Fi8-", "-") } +fn strip_x86_address_spaces(data_layout: String) -> String { + data_layout.replace("-p270:32:32-p271:32:32-p272:64:64-", "-") +} + pub unsafe fn create_module( tcx: TyCtxt<'_>, llcx: &'ll llvm::Context, @@ -156,6 +160,11 @@ pub unsafe fn create_module( if llvm_util::get_major_version() < 9 { target_data_layout = strip_function_ptr_alignment(target_data_layout); } + if llvm_util::get_major_version() < 10 { + if sess.target.target.arch == "x86" || sess.target.target.arch == "x86_64" { + target_data_layout = strip_x86_address_spaces(target_data_layout); + } + } // Ensure the data-layout values hardcoded remain the defaults. if sess.target.target.options.is_builtin { diff --git a/src/librustc_target/spec/i386_apple_ios.rs b/src/librustc_target/spec/i386_apple_ios.rs index 51eb231a614..a6c1d24fa62 100644 --- a/src/librustc_target/spec/i386_apple_ios.rs +++ b/src/librustc_target/spec/i386_apple_ios.rs @@ -8,7 +8,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128".to_string(), + data_layout: "e-m:o-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + f64:32:64-f80:128-n8:16:32-S128" + .to_string(), arch: "x86".to_string(), target_os: "ios".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/i686_apple_darwin.rs b/src/librustc_target/spec/i686_apple_darwin.rs index 7dfb2ba9921..033b87b110e 100644 --- a/src/librustc_target/spec/i686_apple_darwin.rs +++ b/src/librustc_target/spec/i686_apple_darwin.rs @@ -20,7 +20,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128".to_string(), + data_layout: "e-m:o-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + f64:32:64-f80:128-n8:16:32-S128" + .to_string(), arch: "x86".to_string(), target_os: "macos".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/i686_linux_android.rs b/src/librustc_target/spec/i686_linux_android.rs index 3f73d24ee84..79242f24026 100644 --- a/src/librustc_target/spec/i686_linux_android.rs +++ b/src/librustc_target/spec/i686_linux_android.rs @@ -18,7 +18,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128".to_string(), + data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + f64:32:64-f80:32-n8:16:32-S128" + .to_string(), arch: "x86".to_string(), target_os: "android".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/i686_pc_windows_gnu.rs b/src/librustc_target/spec/i686_pc_windows_gnu.rs index 9056e0765d8..35fbf875731 100644 --- a/src/librustc_target/spec/i686_pc_windows_gnu.rs +++ b/src/librustc_target/spec/i686_pc_windows_gnu.rs @@ -18,7 +18,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32".to_string(), + data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + i64:64-f80:32-n8:16:32-a:0:32-S32" + .to_string(), arch: "x86".to_string(), target_os: "windows".to_string(), target_env: "gnu".to_string(), diff --git a/src/librustc_target/spec/i686_pc_windows_msvc.rs b/src/librustc_target/spec/i686_pc_windows_msvc.rs index b160007e062..ffb66afc761 100644 --- a/src/librustc_target/spec/i686_pc_windows_msvc.rs +++ b/src/librustc_target/spec/i686_pc_windows_msvc.rs @@ -19,7 +19,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32".to_string(), + data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + i64:64-f80:32-n8:16:32-a:0:32-S32" + .to_string(), arch: "x86".to_string(), target_os: "windows".to_string(), target_env: "msvc".to_string(), diff --git a/src/librustc_target/spec/i686_unknown_cloudabi.rs b/src/librustc_target/spec/i686_unknown_cloudabi.rs index f3b40633b40..729b1f68e00 100644 --- a/src/librustc_target/spec/i686_unknown_cloudabi.rs +++ b/src/librustc_target/spec/i686_unknown_cloudabi.rs @@ -13,7 +13,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128".to_string(), + data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + f64:32:64-f80:32-n8:16:32-S128" + .to_string(), arch: "x86".to_string(), target_os: "cloudabi".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/i686_unknown_freebsd.rs b/src/librustc_target/spec/i686_unknown_freebsd.rs index 71f05a140f3..88c944a6cb7 100644 --- a/src/librustc_target/spec/i686_unknown_freebsd.rs +++ b/src/librustc_target/spec/i686_unknown_freebsd.rs @@ -12,7 +12,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128".to_string(), + data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + f64:32:64-f80:32-n8:16:32-S128" + .to_string(), arch: "x86".to_string(), target_os: "freebsd".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/i686_unknown_haiku.rs b/src/librustc_target/spec/i686_unknown_haiku.rs index b807e4eee39..4dc27af30da 100644 --- a/src/librustc_target/spec/i686_unknown_haiku.rs +++ b/src/librustc_target/spec/i686_unknown_haiku.rs @@ -12,7 +12,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128".to_string(), + data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + f64:32:64-f80:32-n8:16:32-S128" + .to_string(), arch: "x86".to_string(), target_os: "haiku".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/i686_unknown_linux_gnu.rs b/src/librustc_target/spec/i686_unknown_linux_gnu.rs index 5875cbf78bf..0d578f22f98 100644 --- a/src/librustc_target/spec/i686_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/i686_unknown_linux_gnu.rs @@ -12,7 +12,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128".to_string(), + data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + f64:32:64-f80:32-n8:16:32-S128" + .to_string(), arch: "x86".to_string(), target_os: "linux".to_string(), target_env: "gnu".to_string(), diff --git a/src/librustc_target/spec/i686_unknown_linux_musl.rs b/src/librustc_target/spec/i686_unknown_linux_musl.rs index 732949034e8..699a0ab45e8 100644 --- a/src/librustc_target/spec/i686_unknown_linux_musl.rs +++ b/src/librustc_target/spec/i686_unknown_linux_musl.rs @@ -27,7 +27,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128".to_string(), + data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + f64:32:64-f80:32-n8:16:32-S128" + .to_string(), arch: "x86".to_string(), target_os: "linux".to_string(), target_env: "musl".to_string(), diff --git a/src/librustc_target/spec/i686_unknown_netbsd.rs b/src/librustc_target/spec/i686_unknown_netbsd.rs index 01d2b2d76a0..88b1ae7d53c 100644 --- a/src/librustc_target/spec/i686_unknown_netbsd.rs +++ b/src/librustc_target/spec/i686_unknown_netbsd.rs @@ -12,7 +12,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128".to_string(), + data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + f64:32:64-f80:32-n8:16:32-S128" + .to_string(), arch: "x86".to_string(), target_os: "netbsd".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/i686_unknown_openbsd.rs b/src/librustc_target/spec/i686_unknown_openbsd.rs index d7c323e0d8a..829cd1ac1a3 100644 --- a/src/librustc_target/spec/i686_unknown_openbsd.rs +++ b/src/librustc_target/spec/i686_unknown_openbsd.rs @@ -13,7 +13,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128".to_string(), + data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + f64:32:64-f80:32-n8:16:32-S128" + .to_string(), arch: "x86".to_string(), target_os: "openbsd".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/i686_unknown_uefi.rs b/src/librustc_target/spec/i686_unknown_uefi.rs index e4b8b667ad0..345590a00be 100644 --- a/src/librustc_target/spec/i686_unknown_uefi.rs +++ b/src/librustc_target/spec/i686_unknown_uefi.rs @@ -86,7 +86,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32".to_string(), + data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + i64:64-f80:32-n8:16:32-a:0:32-S32" + .to_string(), target_os: "uefi".to_string(), target_env: "".to_string(), target_vendor: "unknown".to_string(), diff --git a/src/librustc_target/spec/i686_uwp_windows_gnu.rs b/src/librustc_target/spec/i686_uwp_windows_gnu.rs index 1986474785f..93f396de0a0 100644 --- a/src/librustc_target/spec/i686_uwp_windows_gnu.rs +++ b/src/librustc_target/spec/i686_uwp_windows_gnu.rs @@ -18,7 +18,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32".to_string(), + data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + i64:64-f80:32-n8:16:32-a:0:32-S32" + .to_string(), arch: "x86".to_string(), target_os: "windows".to_string(), target_env: "gnu".to_string(), diff --git a/src/librustc_target/spec/i686_uwp_windows_msvc.rs b/src/librustc_target/spec/i686_uwp_windows_msvc.rs index 5e8e8c2a414..ed2dba53589 100644 --- a/src/librustc_target/spec/i686_uwp_windows_msvc.rs +++ b/src/librustc_target/spec/i686_uwp_windows_msvc.rs @@ -11,7 +11,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32".to_string(), + data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + i64:64-f80:32-n8:16:32-a:0:32-S32" + .to_string(), arch: "x86".to_string(), target_os: "windows".to_string(), target_env: "msvc".to_string(), diff --git a/src/librustc_target/spec/i686_wrs_vxworks.rs b/src/librustc_target/spec/i686_wrs_vxworks.rs index c5f9583a358..f5f66cabb2c 100644 --- a/src/librustc_target/spec/i686_wrs_vxworks.rs +++ b/src/librustc_target/spec/i686_wrs_vxworks.rs @@ -12,7 +12,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128".to_string(), + data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + f64:32:64-f80:32-n8:16:32-S128" + .to_string(), arch: "x86".to_string(), target_os: "vxworks".to_string(), target_env: "gnu".to_string(), diff --git a/src/librustc_target/spec/x86_64_apple_darwin.rs b/src/librustc_target/spec/x86_64_apple_darwin.rs index 002cee44218..e846f42f8f8 100644 --- a/src/librustc_target/spec/x86_64_apple_darwin.rs +++ b/src/librustc_target/spec/x86_64_apple_darwin.rs @@ -20,7 +20,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:o-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: arch.to_string(), target_os: "macos".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_apple_ios.rs b/src/librustc_target/spec/x86_64_apple_ios.rs index f8441f96c98..ca02e2deabc 100644 --- a/src/librustc_target/spec/x86_64_apple_ios.rs +++ b/src/librustc_target/spec/x86_64_apple_ios.rs @@ -8,7 +8,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:o-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "ios".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_apple_ios_macabi.rs b/src/librustc_target/spec/x86_64_apple_ios_macabi.rs index 101d83607d9..5f4f6ade682 100644 --- a/src/librustc_target/spec/x86_64_apple_ios_macabi.rs +++ b/src/librustc_target/spec/x86_64_apple_ios_macabi.rs @@ -8,7 +8,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:o-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "ios".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_fortanix_unknown_sgx.rs b/src/librustc_target/spec/x86_64_fortanix_unknown_sgx.rs index 6105eaef7b0..3e9552ef0cf 100644 --- a/src/librustc_target/spec/x86_64_fortanix_unknown_sgx.rs +++ b/src/librustc_target/spec/x86_64_fortanix_unknown_sgx.rs @@ -81,7 +81,8 @@ pub fn target() -> Result<Target, String> { target_os: "unknown".into(), target_env: "sgx".into(), target_vendor: "fortanix".into(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".into(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .into(), arch: "x86_64".into(), linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld), options: opts, diff --git a/src/librustc_target/spec/x86_64_fuchsia.rs b/src/librustc_target/spec/x86_64_fuchsia.rs index 5b315bb957c..37b6d57366c 100644 --- a/src/librustc_target/spec/x86_64_fuchsia.rs +++ b/src/librustc_target/spec/x86_64_fuchsia.rs @@ -11,7 +11,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "fuchsia".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_linux_android.rs b/src/librustc_target/spec/x86_64_linux_android.rs index c3c6c7bf56f..74097f5bf6f 100644 --- a/src/librustc_target/spec/x86_64_linux_android.rs +++ b/src/librustc_target/spec/x86_64_linux_android.rs @@ -14,7 +14,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "android".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_linux_kernel.rs b/src/librustc_target/spec/x86_64_linux_kernel.rs index a80b021208e..89070c99e39 100644 --- a/src/librustc_target/spec/x86_64_linux_kernel.rs +++ b/src/librustc_target/spec/x86_64_linux_kernel.rs @@ -19,7 +19,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), target_os: "none".to_string(), target_env: "gnu".to_string(), target_vendor: "unknown".to_string(), diff --git a/src/librustc_target/spec/x86_64_pc_windows_gnu.rs b/src/librustc_target/spec/x86_64_pc_windows_gnu.rs index 35e0d55cd04..8f523a3b6c6 100644 --- a/src/librustc_target/spec/x86_64_pc_windows_gnu.rs +++ b/src/librustc_target/spec/x86_64_pc_windows_gnu.rs @@ -11,7 +11,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:w-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "windows".to_string(), target_env: "gnu".to_string(), diff --git a/src/librustc_target/spec/x86_64_pc_windows_msvc.rs b/src/librustc_target/spec/x86_64_pc_windows_msvc.rs index 073d49be5a9..75ff6b97a2e 100644 --- a/src/librustc_target/spec/x86_64_pc_windows_msvc.rs +++ b/src/librustc_target/spec/x86_64_pc_windows_msvc.rs @@ -11,7 +11,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:w-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "windows".to_string(), target_env: "msvc".to_string(), diff --git a/src/librustc_target/spec/x86_64_rumprun_netbsd.rs b/src/librustc_target/spec/x86_64_rumprun_netbsd.rs index d71112b87de..fbade02c556 100644 --- a/src/librustc_target/spec/x86_64_rumprun_netbsd.rs +++ b/src/librustc_target/spec/x86_64_rumprun_netbsd.rs @@ -18,7 +18,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "netbsd".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_sun_solaris.rs b/src/librustc_target/spec/x86_64_sun_solaris.rs index 3bf3f51ae25..53f4df96518 100644 --- a/src/librustc_target/spec/x86_64_sun_solaris.rs +++ b/src/librustc_target/spec/x86_64_sun_solaris.rs @@ -12,7 +12,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "solaris".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_unknown_cloudabi.rs b/src/librustc_target/spec/x86_64_unknown_cloudabi.rs index d48120c5401..dbc5f965020 100644 --- a/src/librustc_target/spec/x86_64_unknown_cloudabi.rs +++ b/src/librustc_target/spec/x86_64_unknown_cloudabi.rs @@ -13,7 +13,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "cloudabi".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_unknown_dragonfly.rs b/src/librustc_target/spec/x86_64_unknown_dragonfly.rs index f55ee696909..fd1871b1a57 100644 --- a/src/librustc_target/spec/x86_64_unknown_dragonfly.rs +++ b/src/librustc_target/spec/x86_64_unknown_dragonfly.rs @@ -12,7 +12,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "dragonfly".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_unknown_freebsd.rs b/src/librustc_target/spec/x86_64_unknown_freebsd.rs index 1d9c5cce3f7..a124f582bf3 100644 --- a/src/librustc_target/spec/x86_64_unknown_freebsd.rs +++ b/src/librustc_target/spec/x86_64_unknown_freebsd.rs @@ -12,7 +12,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "freebsd".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_unknown_haiku.rs b/src/librustc_target/spec/x86_64_unknown_haiku.rs index 4ab15fa4e90..51237697714 100644 --- a/src/librustc_target/spec/x86_64_unknown_haiku.rs +++ b/src/librustc_target/spec/x86_64_unknown_haiku.rs @@ -14,7 +14,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "haiku".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_unknown_hermit.rs b/src/librustc_target/spec/x86_64_unknown_hermit.rs index c9123aae90d..4a526f90ed5 100644 --- a/src/librustc_target/spec/x86_64_unknown_hermit.rs +++ b/src/librustc_target/spec/x86_64_unknown_hermit.rs @@ -12,7 +12,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "hermit".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_unknown_hermit_kernel.rs b/src/librustc_target/spec/x86_64_unknown_hermit_kernel.rs index 0b1c8340b6d..c25cd0809ee 100644 --- a/src/librustc_target/spec/x86_64_unknown_hermit_kernel.rs +++ b/src/librustc_target/spec/x86_64_unknown_hermit_kernel.rs @@ -14,7 +14,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "hermit".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_unknown_l4re_uclibc.rs b/src/librustc_target/spec/x86_64_unknown_l4re_uclibc.rs index e5fdb386ef3..cab19f149a7 100644 --- a/src/librustc_target/spec/x86_64_unknown_l4re_uclibc.rs +++ b/src/librustc_target/spec/x86_64_unknown_l4re_uclibc.rs @@ -10,7 +10,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "l4re".to_string(), target_env: "uclibc".to_string(), diff --git a/src/librustc_target/spec/x86_64_unknown_linux_gnu.rs b/src/librustc_target/spec/x86_64_unknown_linux_gnu.rs index cb279e86f14..29cbb777db5 100644 --- a/src/librustc_target/spec/x86_64_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/x86_64_unknown_linux_gnu.rs @@ -12,7 +12,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "linux".to_string(), target_env: "gnu".to_string(), diff --git a/src/librustc_target/spec/x86_64_unknown_linux_gnux32.rs b/src/librustc_target/spec/x86_64_unknown_linux_gnux32.rs index 0b2d7aacc4d..0a37399e2fa 100644 --- a/src/librustc_target/spec/x86_64_unknown_linux_gnux32.rs +++ b/src/librustc_target/spec/x86_64_unknown_linux_gnux32.rs @@ -16,7 +16,9 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "32".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ + i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "linux".to_string(), target_env: "gnu".to_string(), diff --git a/src/librustc_target/spec/x86_64_unknown_linux_musl.rs b/src/librustc_target/spec/x86_64_unknown_linux_musl.rs index 2e1bc839873..34c628e8f67 100644 --- a/src/librustc_target/spec/x86_64_unknown_linux_musl.rs +++ b/src/librustc_target/spec/x86_64_unknown_linux_musl.rs @@ -12,7 +12,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "linux".to_string(), target_env: "musl".to_string(), diff --git a/src/librustc_target/spec/x86_64_unknown_netbsd.rs b/src/librustc_target/spec/x86_64_unknown_netbsd.rs index b0fad314662..adf09c89c42 100644 --- a/src/librustc_target/spec/x86_64_unknown_netbsd.rs +++ b/src/librustc_target/spec/x86_64_unknown_netbsd.rs @@ -12,7 +12,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "netbsd".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_unknown_openbsd.rs b/src/librustc_target/spec/x86_64_unknown_openbsd.rs index f2abd107122..dbd163db36b 100644 --- a/src/librustc_target/spec/x86_64_unknown_openbsd.rs +++ b/src/librustc_target/spec/x86_64_unknown_openbsd.rs @@ -12,7 +12,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "openbsd".to_string(), target_env: String::new(), diff --git a/src/librustc_target/spec/x86_64_unknown_redox.rs b/src/librustc_target/spec/x86_64_unknown_redox.rs index 8a5af27f13a..3d40bafbe1f 100644 --- a/src/librustc_target/spec/x86_64_unknown_redox.rs +++ b/src/librustc_target/spec/x86_64_unknown_redox.rs @@ -12,7 +12,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "redox".to_string(), target_env: "relibc".to_string(), diff --git a/src/librustc_target/spec/x86_64_unknown_uefi.rs b/src/librustc_target/spec/x86_64_unknown_uefi.rs index 443479f55f0..7660b68aae6 100644 --- a/src/librustc_target/spec/x86_64_unknown_uefi.rs +++ b/src/librustc_target/spec/x86_64_unknown_uefi.rs @@ -38,7 +38,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:w-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), target_os: "uefi".to_string(), target_env: "".to_string(), target_vendor: "unknown".to_string(), diff --git a/src/librustc_target/spec/x86_64_uwp_windows_gnu.rs b/src/librustc_target/spec/x86_64_uwp_windows_gnu.rs index da0c324e486..48366e24a39 100644 --- a/src/librustc_target/spec/x86_64_uwp_windows_gnu.rs +++ b/src/librustc_target/spec/x86_64_uwp_windows_gnu.rs @@ -11,7 +11,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:w-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "windows".to_string(), target_env: "gnu".to_string(), diff --git a/src/librustc_target/spec/x86_64_uwp_windows_msvc.rs b/src/librustc_target/spec/x86_64_uwp_windows_msvc.rs index 40dd52c1591..258df010aae 100644 --- a/src/librustc_target/spec/x86_64_uwp_windows_msvc.rs +++ b/src/librustc_target/spec/x86_64_uwp_windows_msvc.rs @@ -11,7 +11,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:w-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "windows".to_string(), target_env: "msvc".to_string(), diff --git a/src/librustc_target/spec/x86_64_wrs_vxworks.rs b/src/librustc_target/spec/x86_64_wrs_vxworks.rs index 1ab2f3a47c4..f1e27f4d8be 100644 --- a/src/librustc_target/spec/x86_64_wrs_vxworks.rs +++ b/src/librustc_target/spec/x86_64_wrs_vxworks.rs @@ -13,7 +13,8 @@ pub fn target() -> TargetResult { target_endian: "little".to_string(), target_pointer_width: "64".to_string(), target_c_int_width: "32".to_string(), - data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(), + data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + .to_string(), arch: "x86_64".to_string(), target_os: "vxworks".to_string(), target_env: "gnu".to_string(), diff --git a/src/rustllvm/ArchiveWrapper.cpp b/src/rustllvm/ArchiveWrapper.cpp index dd0111d3f2c..678d787571e 100644 --- a/src/rustllvm/ArchiveWrapper.cpp +++ b/src/rustllvm/ArchiveWrapper.cpp @@ -89,7 +89,11 @@ extern "C" void LLVMRustDestroyArchive(LLVMRustArchiveRef RustArchive) { extern "C" LLVMRustArchiveIteratorRef LLVMRustArchiveIteratorNew(LLVMRustArchiveRef RustArchive) { Archive *Archive = RustArchive->getBinary(); +#if LLVM_VERSION_GE(10, 0) + std::unique_ptr<Error> Err = std::make_unique<Error>(Error::success()); +#else std::unique_ptr<Error> Err = llvm::make_unique<Error>(Error::success()); +#endif auto Cur = Archive->child_begin(*Err); if (*Err) { LLVMRustSetLastError(toString(std::move(*Err)).c_str()); diff --git a/src/rustllvm/Linker.cpp b/src/rustllvm/Linker.cpp index 7916721943a..69176f9cb1f 100644 --- a/src/rustllvm/Linker.cpp +++ b/src/rustllvm/Linker.cpp @@ -18,8 +18,7 @@ extern "C" RustLinker* LLVMRustLinkerNew(LLVMModuleRef DstRef) { Module *Dst = unwrap(DstRef); - auto Ret = llvm::make_unique<RustLinker>(*Dst); - return Ret.release(); + return new RustLinker(*Dst); } extern "C" void diff --git a/src/rustllvm/PassWrapper.cpp b/src/rustllvm/PassWrapper.cpp index 6698e5d58be..eaa845a279f 100644 --- a/src/rustllvm/PassWrapper.cpp +++ b/src/rustllvm/PassWrapper.cpp @@ -8,6 +8,7 @@ #include "llvm/Analysis/TargetLibraryInfo.h" #include "llvm/Analysis/TargetTransformInfo.h" #include "llvm/CodeGen/TargetSubtargetInfo.h" +#include "llvm/InitializePasses.h" #include "llvm/IR/AutoUpgrade.h" #include "llvm/IR/AssemblyAnnotationWriter.h" #include "llvm/IR/IntrinsicInst.h" @@ -532,6 +533,18 @@ enum class LLVMRustFileType { ObjectFile, }; +#if LLVM_VERSION_GE(10, 0) +static CodeGenFileType fromRust(LLVMRustFileType Type) { + switch (Type) { + case LLVMRustFileType::AssemblyFile: + return CGFT_AssemblyFile; + case LLVMRustFileType::ObjectFile: + return CGFT_ObjectFile; + default: + report_fatal_error("Bad FileType."); + } +} +#else static TargetMachine::CodeGenFileType fromRust(LLVMRustFileType Type) { switch (Type) { case LLVMRustFileType::AssemblyFile: @@ -542,6 +555,7 @@ static TargetMachine::CodeGenFileType fromRust(LLVMRustFileType Type) { report_fatal_error("Bad FileType."); } } +#endif extern "C" LLVMRustResult LLVMRustWriteOutputFile(LLVMTargetMachineRef Target, LLVMPassManagerRef PMR, @@ -849,7 +863,11 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules, int num_modules, const char **preserved_symbols, int num_symbols) { +#if LLVM_VERSION_GE(10, 0) + auto Ret = std::make_unique<LLVMRustThinLTOData>(); +#else auto Ret = llvm::make_unique<LLVMRustThinLTOData>(); +#endif // Load each module's summary and merge it into one combined index for (int i = 0; i < num_modules; i++) { @@ -944,6 +962,15 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules, ExportedGUIDs.insert(GUID); } } +#if LLVM_VERSION_GE(10, 0) + auto isExported = [&](StringRef ModuleIdentifier, ValueInfo VI) { + const auto &ExportList = Ret->ExportLists.find(ModuleIdentifier); + return (ExportList != Ret->ExportLists.end() && + ExportList->second.count(VI)) || + ExportedGUIDs.count(VI.getGUID()); + }; + thinLTOInternalizeAndPromoteInIndex(Ret->Index, isExported, isPrevailing); +#else auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) { const auto &ExportList = Ret->ExportLists.find(ModuleIdentifier); return (ExportList != Ret->ExportLists.end() && @@ -951,6 +978,7 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules, ExportedGUIDs.count(GUID); }; thinLTOInternalizeAndPromoteInIndex(Ret->Index, isExported); +#endif return Ret.release(); } @@ -1081,7 +1109,11 @@ struct LLVMRustThinLTOBuffer { extern "C" LLVMRustThinLTOBuffer* LLVMRustThinLTOBufferCreate(LLVMModuleRef M) { +#if LLVM_VERSION_GE(10, 0) + auto Ret = std::make_unique<LLVMRustThinLTOBuffer>(); +#else auto Ret = llvm::make_unique<LLVMRustThinLTOBuffer>(); +#endif { raw_string_ostream OS(Ret->data); { diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index 720928e48e3..46e467011b9 100644 --- a/src/rustllvm/RustWrapper.cpp +++ b/src/rustllvm/RustWrapper.cpp @@ -496,9 +496,11 @@ static DINode::DIFlags fromRust(LLVMRustDIFlags Flags) { if (isSet(Flags & LLVMRustDIFlags::FlagAppleBlock)) { Result |= DINode::DIFlags::FlagAppleBlock; } +#if LLVM_VERSION_LT(10, 0) if (isSet(Flags & LLVMRustDIFlags::FlagBlockByrefStruct)) { Result |= DINode::DIFlags::FlagBlockByrefStruct; } +#endif if (isSet(Flags & LLVMRustDIFlags::FlagVirtual)) { Result |= DINode::DIFlags::FlagVirtual; } @@ -825,6 +827,9 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable( llvm::DIGlobalVariableExpression *VarExpr = Builder->createGlobalVariableExpression( unwrapDI<DIDescriptor>(Context), Name, LinkageName, unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), IsLocalToUnit, +#if LLVM_VERSION_GE(10, 0) + /* isDefined */ true, +#endif InitExpr, unwrapDIPtr<MDNode>(Decl), #if LLVM_VERSION_GE(8, 0) /* templateParams */ nullptr, @@ -998,11 +1003,19 @@ inline section_iterator *unwrap(LLVMSectionIteratorRef SI) { extern "C" size_t LLVMRustGetSectionName(LLVMSectionIteratorRef SI, const char **Ptr) { +#if LLVM_VERSION_GE(10, 0) + auto NameOrErr = (*unwrap(SI))->getName(); + if (!NameOrErr) + report_fatal_error(NameOrErr.takeError()); + *Ptr = NameOrErr->data(); + return NameOrErr->size(); +#else StringRef Ret; if (std::error_code EC = (*unwrap(SI))->getName(Ret)) report_fatal_error(EC.message()); *Ptr = Ret.data(); return Ret.size(); +#endif } // LLVMArrayType function does not support 64-bit ElementCount @@ -1253,20 +1266,34 @@ extern "C" LLVMValueRef LLVMRustBuildMemCpy(LLVMBuilderRef B, LLVMValueRef Dst, unsigned DstAlign, LLVMValueRef Src, unsigned SrcAlign, LLVMValueRef Size, bool IsVolatile) { +#if LLVM_VERSION_GE(10, 0) + return wrap(unwrap(B)->CreateMemCpy( + unwrap(Dst), MaybeAlign(DstAlign), + unwrap(Src), MaybeAlign(SrcAlign), + unwrap(Size), IsVolatile)); +#else return wrap(unwrap(B)->CreateMemCpy( unwrap(Dst), DstAlign, unwrap(Src), SrcAlign, unwrap(Size), IsVolatile)); +#endif } extern "C" LLVMValueRef LLVMRustBuildMemMove(LLVMBuilderRef B, LLVMValueRef Dst, unsigned DstAlign, LLVMValueRef Src, unsigned SrcAlign, LLVMValueRef Size, bool IsVolatile) { +#if LLVM_VERSION_GE(10, 0) + return wrap(unwrap(B)->CreateMemMove( + unwrap(Dst), MaybeAlign(DstAlign), + unwrap(Src), MaybeAlign(SrcAlign), + unwrap(Size), IsVolatile)); +#else return wrap(unwrap(B)->CreateMemMove( unwrap(Dst), DstAlign, unwrap(Src), SrcAlign, unwrap(Size), IsVolatile)); +#endif } extern "C" LLVMValueRef @@ -1450,7 +1477,11 @@ struct LLVMRustModuleBuffer { extern "C" LLVMRustModuleBuffer* LLVMRustModuleBufferCreate(LLVMModuleRef M) { +#if LLVM_VERSION_GE(10, 0) + auto Ret = std::make_unique<LLVMRustModuleBuffer>(); +#else auto Ret = llvm::make_unique<LLVMRustModuleBuffer>(); +#endif { raw_string_ostream OS(Ret->data); { diff --git a/src/test/codegen/abi-main-signature-32bit-c-int.rs b/src/test/codegen/abi-main-signature-32bit-c-int.rs index c7aab09edec..a7a4520ff95 100644 --- a/src/test/codegen/abi-main-signature-32bit-c-int.rs +++ b/src/test/codegen/abi-main-signature-32bit-c-int.rs @@ -7,4 +7,4 @@ fn main() { } -// CHECK: define i32 @main(i32, i8**) +// CHECK: define i32 @main(i32{{( %0)?}}, i8**{{( %1)?}}) diff --git a/src/test/codegen/bool-cmp.rs b/src/test/codegen/bool-cmp.rs index 8769a4cb5e1..5090f7c378c 100644 --- a/src/test/codegen/bool-cmp.rs +++ b/src/test/codegen/bool-cmp.rs @@ -10,8 +10,9 @@ use std::cmp::Ordering; // CHECK-LABEL: @cmp_bool #[no_mangle] pub fn cmp_bool(a: bool, b: bool) -> Ordering { +// LLVM 10 produces (zext a) + (sext b), but the final lowering is (zext a) - (zext b). // CHECK: zext i1 -// CHECK: zext i1 -// CHECK: sub nsw +// CHECK: {{z|s}}ext i1 +// CHECK: {{sub|add}} nsw a.cmp(&b) } diff --git a/src/test/codegen/function-arguments.rs b/src/test/codegen/function-arguments.rs index 5c9aa48c0a5..3511c7c5185 100644 --- a/src/test/codegen/function-arguments.rs +++ b/src/test/codegen/function-arguments.rs @@ -73,7 +73,7 @@ pub fn _box(x: Box<i32>) -> Box<i32> { x } -// CHECK: @struct_return(%S* noalias nocapture sret dereferenceable(32)) +// CHECK: @struct_return(%S* noalias nocapture sret dereferenceable(32){{( %0)?}}) #[no_mangle] pub fn struct_return() -> S { S { @@ -117,7 +117,7 @@ pub fn str(_: &[u8]) { pub fn trait_borrow(_: &Drop) { } -// CHECK: @trait_box({}* noalias nonnull align 1, [3 x [[USIZE]]]* noalias readonly align {{.*}} dereferenceable({{.*}})) +// CHECK: @trait_box({}* noalias nonnull align 1{{( %0)?}}, [3 x [[USIZE]]]* noalias readonly align {{.*}} dereferenceable({{.*}}){{( %1)?}}) #[no_mangle] pub fn trait_box(_: Box<Drop>) { } diff --git a/src/test/codegen/intrinsics/prefetch.rs b/src/test/codegen/intrinsics/prefetch.rs index 4cd38e14282..2386fc43007 100644 --- a/src/test/codegen/intrinsics/prefetch.rs +++ b/src/test/codegen/intrinsics/prefetch.rs @@ -9,13 +9,13 @@ use std::intrinsics::{prefetch_read_data, prefetch_write_data, #[no_mangle] pub fn check_prefetch_read_data(data: &[i8]) { unsafe { - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 0, i32 0, i32 1) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 0, i32 0, i32 1) prefetch_read_data(data.as_ptr(), 0); - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 0, i32 1, i32 1) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 0, i32 1, i32 1) prefetch_read_data(data.as_ptr(), 1); - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 0, i32 2, i32 1) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 0, i32 2, i32 1) prefetch_read_data(data.as_ptr(), 2); - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 0, i32 3, i32 1) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 0, i32 3, i32 1) prefetch_read_data(data.as_ptr(), 3); } } @@ -23,13 +23,13 @@ pub fn check_prefetch_read_data(data: &[i8]) { #[no_mangle] pub fn check_prefetch_write_data(data: &[i8]) { unsafe { - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 1, i32 0, i32 1) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 1, i32 0, i32 1) prefetch_write_data(data.as_ptr(), 0); - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 1, i32 1, i32 1) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 1, i32 1, i32 1) prefetch_write_data(data.as_ptr(), 1); - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 1, i32 2, i32 1) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 1, i32 2, i32 1) prefetch_write_data(data.as_ptr(), 2); - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 1, i32 3, i32 1) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 1, i32 3, i32 1) prefetch_write_data(data.as_ptr(), 3); } } @@ -37,13 +37,13 @@ pub fn check_prefetch_write_data(data: &[i8]) { #[no_mangle] pub fn check_prefetch_read_instruction(data: &[i8]) { unsafe { - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 0, i32 0, i32 0) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 0, i32 0, i32 0) prefetch_read_instruction(data.as_ptr(), 0); - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 0, i32 1, i32 0) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 0, i32 1, i32 0) prefetch_read_instruction(data.as_ptr(), 1); - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 0, i32 2, i32 0) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 0, i32 2, i32 0) prefetch_read_instruction(data.as_ptr(), 2); - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 0, i32 3, i32 0) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 0, i32 3, i32 0) prefetch_read_instruction(data.as_ptr(), 3); } } @@ -51,13 +51,13 @@ pub fn check_prefetch_read_instruction(data: &[i8]) { #[no_mangle] pub fn check_prefetch_write_instruction(data: &[i8]) { unsafe { - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 1, i32 0, i32 0) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 1, i32 0, i32 0) prefetch_write_instruction(data.as_ptr(), 0); - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 1, i32 1, i32 0) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 1, i32 1, i32 0) prefetch_write_instruction(data.as_ptr(), 1); - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 1, i32 2, i32 0) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 1, i32 2, i32 0) prefetch_write_instruction(data.as_ptr(), 2); - // CHECK: call void @llvm.prefetch(i8* %{{.*}}, i32 1, i32 3, i32 0) + // CHECK: call void @llvm.prefetch{{.*}}(i8* %{{.*}}, i32 1, i32 3, i32 0) prefetch_write_instruction(data.as_ptr(), 3); } } diff --git a/src/test/codegen/naked-functions.rs b/src/test/codegen/naked-functions.rs index 2050193b61b..5050ed14994 100644 --- a/src/test/codegen/naked-functions.rs +++ b/src/test/codegen/naked-functions.rs @@ -17,7 +17,7 @@ pub fn naked_empty() { // CHECK: Function Attrs: naked #[no_mangle] #[naked] -// CHECK-NEXT: define void @naked_with_args(i{{[0-9]+}}) +// CHECK-NEXT: define void @naked_with_args(i{{[0-9]+( %0)?}}) pub fn naked_with_args(a: isize) { // CHECK-NEXT: {{.+}}: // CHECK-NEXT: %a = alloca i{{[0-9]+}} @@ -36,7 +36,7 @@ pub fn naked_with_return() -> isize { } // CHECK: Function Attrs: naked -// CHECK-NEXT: define i{{[0-9]+}} @naked_with_args_and_return(i{{[0-9]+}}) +// CHECK-NEXT: define i{{[0-9]+}} @naked_with_args_and_return(i{{[0-9]+( %0)?}}) #[no_mangle] #[naked] pub fn naked_with_args_and_return(a: isize) -> isize { diff --git a/src/test/codegen/repeat-trusted-len.rs b/src/test/codegen/repeat-trusted-len.rs index 99f3464c076..8fbe712065b 100644 --- a/src/test/codegen/repeat-trusted-len.rs +++ b/src/test/codegen/repeat-trusted-len.rs @@ -13,6 +13,6 @@ pub fn helper(_: usize) { // CHECK-LABEL: @repeat_take_collect #[no_mangle] pub fn repeat_take_collect() -> Vec<u8> { -// CHECK: call void @llvm.memset.p0i8.[[USIZE]](i8* {{(nonnull )?}}align 1 %{{[0-9]+}}, i8 42, [[USIZE]] 100000, i1 false) +// CHECK: call void @llvm.memset.p0i8.[[USIZE]](i8* {{(nonnull )?}}align 1{{.*}} %{{[0-9]+}}, i8 42, [[USIZE]] 100000, i1 false) iter::repeat(42).take(100000).collect() } diff --git a/src/test/codegen/repr-transparent-sysv64.rs b/src/test/codegen/repr-transparent-sysv64.rs index b71cb14a4ff..886b0dd9e7b 100644 --- a/src/test/codegen/repr-transparent-sysv64.rs +++ b/src/test/codegen/repr-transparent-sysv64.rs @@ -10,7 +10,7 @@ pub struct Rgb8 { r: u8, g: u8, b: u8 } #[repr(transparent)] pub struct Rgb8Wrap(Rgb8); -// CHECK: i24 @test_Rgb8Wrap(i24) +// CHECK: i24 @test_Rgb8Wrap(i24{{( %0)?}}) #[no_mangle] pub extern "sysv64" fn test_Rgb8Wrap(_: Rgb8Wrap) -> Rgb8Wrap { loop {} } @@ -23,6 +23,6 @@ pub union FloatBits { #[repr(transparent)] pub struct SmallUnion(FloatBits); -// CHECK: i32 @test_SmallUnion(i32) +// CHECK: i32 @test_SmallUnion(i32{{( %0)?}}) #[no_mangle] pub extern "sysv64" fn test_SmallUnion(_: SmallUnion) -> SmallUnion { loop {} } diff --git a/src/test/codegen/union-abi.rs b/src/test/codegen/union-abi.rs index 98a9ff9cbe4..afea01e9a2d 100644 --- a/src/test/codegen/union-abi.rs +++ b/src/test/codegen/union-abi.rs @@ -54,7 +54,7 @@ pub fn test_UnionF32F32(_: UnionF32F32) -> UnionF32F32 { loop {} } pub union UnionF32U32{a:f32, b:u32} -// CHECK: define i32 @test_UnionF32U32(i32) +// CHECK: define i32 @test_UnionF32U32(i32{{( %0)?}}) #[no_mangle] pub fn test_UnionF32U32(_: UnionF32U32) -> UnionF32U32 { loop {} } diff --git a/src/test/debuginfo/borrowed-enum-legacy.rs b/src/test/debuginfo/borrowed-enum-legacy.rs deleted file mode 100644 index 9a973ed74e8..00000000000 --- a/src/test/debuginfo/borrowed-enum-legacy.rs +++ /dev/null @@ -1,84 +0,0 @@ -// ignore-tidy-linelength -// min-lldb-version: 310 - -// As long as LLVM 5 and LLVM 6 are supported, we want to test the -// enum debuginfo fallback mode. Once those are desupported, this -// test can be removed, as there is another (non-"legacy") test that -// tests the new mode. -// ignore-llvm-version: 7.0 - 9.9.9 -// ignore-gdb-version: 7.11.90 - 7.12.9 -// ignore-gdb-version: 8.2 - 9.9 - -// compile-flags:-g - -// === GDB TESTS =================================================================================== - -// gdb-command:run - -// gdb-command:print *the_a_ref -// gdbg-check:$1 = {{RUST$ENUM$DISR = TheA, x = 0, y = 8970181431921507452}, {RUST$ENUM$DISR = TheA, [...]}} -// gdbr-check:$1 = borrowed_enum_legacy::ABC::TheA{x: 0, y: 8970181431921507452} - -// gdb-command:print *the_b_ref -// gdbg-check:$2 = {{RUST$ENUM$DISR = TheB, [...]}, {RUST$ENUM$DISR = TheB, __0 = 0, __1 = 286331153, __2 = 286331153}} -// gdbr-check:$2 = borrowed_enum_legacy::ABC::TheB(0, 286331153, 286331153) - -// gdb-command:print *univariant_ref -// gdbg-check:$3 = {{__0 = 4820353753753434}} -// gdbr-check:$3 = borrowed_enum_legacy::Univariant::TheOnlyCase(4820353753753434) - - -// === LLDB TESTS ================================================================================== - -// lldb-command:run - -// lldb-command:print *the_a_ref -// lldbg-check:[...]$0 = TheA { x: 0, y: 8970181431921507452 } -// lldbr-check:(borrowed_enum_legacy::ABC::TheA) *the_a_ref = TheA { borrowed_enum_legacy::ABC::TheA: 0, borrowed_enum_legacy::ABC::TheB: 8970181431921507452 } -// lldb-command:print *the_b_ref -// lldbg-check:[...]$1 = TheB(0, 286331153, 286331153) -// lldbr-check:(borrowed_enum_legacy::ABC::TheB) *the_b_ref = { = 0 = 286331153 = 286331153 } -// lldb-command:print *univariant_ref -// lldbg-check:[...]$2 = TheOnlyCase(4820353753753434) -// lldbr-check:(borrowed_enum_legacy::Univariant) *univariant_ref = { borrowed_enum_legacy::TheOnlyCase = { = 4820353753753434 } } - -#![allow(unused_variables)] -#![feature(omit_gdb_pretty_printer_section)] -#![omit_gdb_pretty_printer_section] - -// The first element is to ensure proper alignment, irrespective of the machines word size. Since -// the size of the discriminant value is machine dependent, this has be taken into account when -// datatype layout should be predictable as in this case. -enum ABC { - TheA { x: i64, y: i64 }, - TheB (i64, i32, i32), -} - -// This is a special case since it does not have the implicit discriminant field. -enum Univariant { - TheOnlyCase(i64) -} - -fn main() { - - // 0b0111110001111100011111000111110001111100011111000111110001111100 = 8970181431921507452 - // 0b01111100011111000111110001111100 = 2088533116 - // 0b0111110001111100 = 31868 - // 0b01111100 = 124 - let the_a = ABC::TheA { x: 0, y: 8970181431921507452 }; - let the_a_ref: &ABC = &the_a; - - // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441 - // 0b00010001000100010001000100010001 = 286331153 - // 0b0001000100010001 = 4369 - // 0b00010001 = 17 - let the_b = ABC::TheB (0, 286331153, 286331153); - let the_b_ref: &ABC = &the_b; - - let univariant = Univariant::TheOnlyCase(4820353753753434); - let univariant_ref: &Univariant = &univariant; - - zzz(); // #break -} - -fn zzz() {()} diff --git a/src/test/debuginfo/generic-enum-with-different-disr-sizes-legacy.rs b/src/test/debuginfo/generic-enum-with-different-disr-sizes-legacy.rs deleted file mode 100644 index 4f17e48c6a4..00000000000 --- a/src/test/debuginfo/generic-enum-with-different-disr-sizes-legacy.rs +++ /dev/null @@ -1,105 +0,0 @@ -// ignore-tidy-linelength -// ignore-lldb: FIXME(#27089) -// min-lldb-version: 310 - -// As long as LLVM 5 and LLVM 6 are supported, we want to test the -// enum debuginfo fallback mode. Once those are desupported, this -// test can be removed, as there is another (non-"legacy") test that -// tests the new mode. -// ignore-llvm-version: 7.0 - 9.9.9 -// ignore-gdb-version: 8.2 - 9.9 - -// compile-flags:-g - -// === GDB TESTS =================================================================================== -// gdb-command:run - -// gdb-command:print eight_bytes1 -// gdbg-check:$1 = {{RUST$ENUM$DISR = Variant1, __0 = 100}, {RUST$ENUM$DISR = Variant1, __0 = 100}} -// gdbr-check:$1 = generic_enum_with_different_disr_sizes_legacy::Enum::Variant1(100) - -// gdb-command:print four_bytes1 -// gdbg-check:$2 = {{RUST$ENUM$DISR = Variant1, __0 = 101}, {RUST$ENUM$DISR = Variant1, __0 = 101}} -// gdbr-check:$2 = generic_enum_with_different_disr_sizes_legacy::Enum::Variant1(101) - -// gdb-command:print two_bytes1 -// gdbg-check:$3 = {{RUST$ENUM$DISR = Variant1, __0 = 102}, {RUST$ENUM$DISR = Variant1, __0 = 102}} -// gdbr-check:$3 = generic_enum_with_different_disr_sizes_legacy::Enum::Variant1(102) - -// gdb-command:print one_byte1 -// gdbg-check:$4 = {{RUST$ENUM$DISR = Variant1, __0 = 65 'A'}, {RUST$ENUM$DISR = Variant1, __0 = 65 'A'}} -// gdbr-check:$4 = generic_enum_with_different_disr_sizes_legacy::Enum::Variant1(65) - - -// gdb-command:print eight_bytes2 -// gdbg-check:$5 = {{RUST$ENUM$DISR = Variant2, __0 = 100}, {RUST$ENUM$DISR = Variant2, __0 = 100}} -// gdbr-check:$5 = generic_enum_with_different_disr_sizes_legacy::Enum::Variant2(100) - -// gdb-command:print four_bytes2 -// gdbg-check:$6 = {{RUST$ENUM$DISR = Variant2, __0 = 101}, {RUST$ENUM$DISR = Variant2, __0 = 101}} -// gdbr-check:$6 = generic_enum_with_different_disr_sizes_legacy::Enum::Variant2(101) - -// gdb-command:print two_bytes2 -// gdbg-check:$7 = {{RUST$ENUM$DISR = Variant2, __0 = 102}, {RUST$ENUM$DISR = Variant2, __0 = 102}} -// gdbr-check:$7 = generic_enum_with_different_disr_sizes_legacy::Enum::Variant2(102) - -// gdb-command:print one_byte2 -// gdbg-check:$8 = {{RUST$ENUM$DISR = Variant2, __0 = 65 'A'}, {RUST$ENUM$DISR = Variant2, __0 = 65 'A'}} -// gdbr-check:$8 = generic_enum_with_different_disr_sizes_legacy::Enum::Variant2(65) - -// gdb-command:continue - -// === LLDB TESTS ================================================================================== -// lldb-command:run - -// lldb-command:print eight_bytes1 -// lldb-check:[...]$0 = Variant1(100) -// lldb-command:print four_bytes1 -// lldb-check:[...]$1 = Variant1(101) -// lldb-command:print two_bytes1 -// lldb-check:[...]$2 = Variant1(102) -// lldb-command:print one_byte1 -// lldb-check:[...]$3 = Variant1('A') - -// lldb-command:print eight_bytes2 -// lldb-check:[...]$4 = Variant2(100) -// lldb-command:print four_bytes2 -// lldb-check:[...]$5 = Variant2(101) -// lldb-command:print two_bytes2 -// lldb-check:[...]$6 = Variant2(102) -// lldb-command:print one_byte2 -// lldb-check:[...]$7 = Variant2('A') - -// lldb-command:continue - -#![allow(unused_variables)] -#![allow(dead_code)] -#![feature(omit_gdb_pretty_printer_section)] -#![omit_gdb_pretty_printer_section] - -// This test case makes sure that we get correct type descriptions for the enum -// discriminant of different instantiations of the same generic enum type where, -// dependending on the generic type parameter(s), the discriminant has a -// different size in memory. - -enum Enum<T> { - Variant1(T), - Variant2(T) -} - -fn main() { - // These are ordered for descending size on purpose - let eight_bytes1 = Enum::Variant1(100.0f64); - let four_bytes1 = Enum::Variant1(101i32); - let two_bytes1 = Enum::Variant1(102i16); - let one_byte1 = Enum::Variant1(65u8); - - let eight_bytes2 = Enum::Variant2(100.0f64); - let four_bytes2 = Enum::Variant2(101i32); - let two_bytes2 = Enum::Variant2(102i16); - let one_byte2 = Enum::Variant2(65u8); - - zzz(); // #break -} - -fn zzz() { () } diff --git a/src/test/debuginfo/generic-struct-style-enum-legacy.rs b/src/test/debuginfo/generic-struct-style-enum-legacy.rs deleted file mode 100644 index 37a875a4188..00000000000 --- a/src/test/debuginfo/generic-struct-style-enum-legacy.rs +++ /dev/null @@ -1,86 +0,0 @@ -// ignore-tidy-linelength -// min-lldb-version: 310 -// ignore-gdb-version: 7.11.90 - 7.12.9 - -// As long as LLVM 5 and LLVM 6 are supported, we want to test the -// enum debuginfo fallback mode. Once those are desupported, this -// test can be removed, as there is another (non-"legacy") test that -// tests the new mode. -// ignore-llvm-version: 7.0 - 9.9.9 -// ignore-gdb-version: 8.2 - 9.9 - -// compile-flags:-g - -// gdb-command:set print union on -// gdb-command:run - -// gdb-command:print case1 -// gdbg-check:$1 = {{RUST$ENUM$DISR = Case1, a = 0, b = 31868, c = 31868, d = 31868, e = 31868}, {RUST$ENUM$DISR = Case1, [...]}, {RUST$ENUM$DISR = Case1, [...]}} -// gdbr-check:$1 = generic_struct_style_enum_legacy::Regular::Case1{a: 0, b: 31868, c: 31868, d: 31868, e: 31868} - -// gdb-command:print case2 -// gdbg-check:$2 = {{RUST$ENUM$DISR = Case2, [...]}, {RUST$ENUM$DISR = Case2, a = 0, b = 286331153, c = 286331153}, {RUST$ENUM$DISR = Case2, [...]}} -// gdbr-check:$2 = generic_struct_style_enum_legacy::Regular::Case2{a: 0, b: 286331153, c: 286331153} - -// gdb-command:print case3 -// gdbg-check:$3 = {{RUST$ENUM$DISR = Case3, [...]}, {RUST$ENUM$DISR = Case3, [...]}, {RUST$ENUM$DISR = Case3, a = 0, b = 6438275382588823897}} -// gdbr-check:$3 = generic_struct_style_enum_legacy::Regular::Case3{a: 0, b: 6438275382588823897} - -// gdb-command:print univariant -// gdbg-check:$4 = {{a = -1}} -// gdbr-check:$4 = generic_struct_style_enum_legacy::Univariant<i32>::TheOnlyCase{a: -1} - - -#![feature(omit_gdb_pretty_printer_section)] -#![omit_gdb_pretty_printer_section] - -use self::Regular::{Case1, Case2, Case3}; -use self::Univariant::TheOnlyCase; - -// NOTE: This is a copy of the non-generic test case. The `Txx` type parameters have to be -// substituted with something of size `xx` bits and the same alignment as an integer type of the -// same size. - -// The first element is to ensure proper alignment, irrespective of the machines word size. Since -// the size of the discriminant value is machine dependent, this has be taken into account when -// datatype layout should be predictable as in this case. -enum Regular<T16, T32, T64> { - Case1 { a: T64, b: T16, c: T16, d: T16, e: T16}, - Case2 { a: T64, b: T32, c: T32}, - Case3 { a: T64, b: T64 } -} - -enum Univariant<T> { - TheOnlyCase { a: T } -} - -fn main() { - - // In order to avoid endianness trouble all of the following test values consist of a single - // repeated byte. This way each interpretation of the union should look the same, no matter if - // this is a big or little endian machine. - - // 0b0111110001111100011111000111110001111100011111000111110001111100 = 8970181431921507452 - // 0b01111100011111000111110001111100 = 2088533116 - // 0b0111110001111100 = 31868 - // 0b01111100 = 124 - let case1: Regular<u16, u32, i64> = Case1 { a: 0, b: 31868, c: 31868, d: 31868, e: 31868 }; - - // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441 - // 0b00010001000100010001000100010001 = 286331153 - // 0b0001000100010001 = 4369 - // 0b00010001 = 17 - let case2: Regular<i16, u32, i64> = Case2 { a: 0, b: 286331153, c: 286331153 }; - - // 0b0101100101011001010110010101100101011001010110010101100101011001 = 6438275382588823897 - // 0b01011001010110010101100101011001 = 1499027801 - // 0b0101100101011001 = 22873 - // 0b01011001 = 89 - let case3: Regular<u16, i32, u64> = Case3 { a: 0, b: 6438275382588823897 }; - - let univariant = TheOnlyCase { a: -1 }; - - zzz(); // #break -} - -fn zzz() {()} diff --git a/src/test/debuginfo/generic-tuple-style-enum-legacy.rs b/src/test/debuginfo/generic-tuple-style-enum-legacy.rs deleted file mode 100644 index 452e90008ea..00000000000 --- a/src/test/debuginfo/generic-tuple-style-enum-legacy.rs +++ /dev/null @@ -1,108 +0,0 @@ -// ignore-tidy-linelength -// min-lldb-version: 310 -// ignore-gdb-version: 7.11.90 - 7.12.9 - -// As long as LLVM 5 and LLVM 6 are supported, we want to test the -// enum debuginfo fallback mode. Once those are desupported, this -// test can be removed, as there is another (non-"legacy") test that -// tests the new mode. -// ignore-llvm-version: 7.0 - 9.9.9 -// ignore-gdb-version: 8.2 - 9.9 - -// compile-flags:-g - -// === GDB TESTS =================================================================================== - -// gdb-command:set print union on -// gdb-command:run - -// gdb-command:print case1 -// gdbg-check:$1 = {{RUST$ENUM$DISR = Case1, __0 = 0, __1 = 31868, __2 = 31868, __3 = 31868, __4 = 31868}, {RUST$ENUM$DISR = Case1, [...]}, {RUST$ENUM$DISR = Case1, [...]}} -// gdbr-check:$1 = generic_tuple_style_enum_legacy::Regular::Case1(0, 31868, 31868, 31868, 31868) - -// gdb-command:print case2 -// gdbg-check:$2 = {{RUST$ENUM$DISR = Case2, [...]}, {RUST$ENUM$DISR = Case2, __0 = 0, __1 = 286331153, __2 = 286331153}, {RUST$ENUM$DISR = Case2, [...]}} -// gdbr-check:$2 = generic_tuple_style_enum_legacy::Regular::Case2(0, 286331153, 286331153) - -// gdb-command:print case3 -// gdbg-check:$3 = {{RUST$ENUM$DISR = Case3, [...]}, {RUST$ENUM$DISR = Case3, [...]}, {RUST$ENUM$DISR = Case3, __0 = 0, __1 = 6438275382588823897}} -// gdbr-check:$3 = generic_tuple_style_enum_legacy::Regular::Case3(0, 6438275382588823897) - -// gdb-command:print univariant -// gdbg-check:$4 = {{__0 = -1}} -// gdbr-check:$4 = generic_tuple_style_enum_legacy::Univariant<i64>::TheOnlyCase(-1) - - -// === LLDB TESTS ================================================================================== - -// lldb-command:run - -// lldb-command:print case1 -// lldbg-check:[...]$0 = Case1(0, 31868, 31868, 31868, 31868) -// lldbr-check:(generic_tuple_style_enum_legacy::Regular<u16, u32, u64>::Case1) case1 = { = 0 = 31868 = 31868 = 31868 = 31868 } - -// lldb-command:print case2 -// lldbg-check:[...]$1 = Case2(0, 286331153, 286331153) -// lldbr-check:(generic_tuple_style_enum_legacy::Regular<i16, i32, i64>::Case2) case2 = Regular<i16, i32, i64>::Case2 { generic_tuple_style_enum_legacy::Regular<i16, i32, i64>::Case1: 0, generic_tuple_style_enum_legacy::Regular<i16, i32, i64>::Case2: 286331153, generic_tuple_style_enum_legacy::Regular<i16, i32, i64>::Case3: 286331153 } - -// lldb-command:print case3 -// lldbg-check:[...]$2 = Case3(0, 6438275382588823897) -// lldbr-check:(generic_tuple_style_enum_legacy::Regular<i16, i32, i64>::Case3) case3 = Regular<i16, i32, i64>::Case3 { generic_tuple_style_enum_legacy::Regular<i16, i32, i64>::Case1: 0, generic_tuple_style_enum_legacy::Regular<i16, i32, i64>::Case2: 6438275382588823897 } - -// lldb-command:print univariant -// lldbg-check:[...]$3 = TheOnlyCase(-1) -// lldbr-check:(generic_tuple_style_enum_legacy::Univariant<i64>) univariant = { generic_tuple_style_enum_legacy::TheOnlyCase = { = -1 } } - -#![feature(omit_gdb_pretty_printer_section)] -#![omit_gdb_pretty_printer_section] - -use self::Regular::{Case1, Case2, Case3}; -use self::Univariant::TheOnlyCase; - -// NOTE: This is a copy of the non-generic test case. The `Txx` type parameters have to be -// substituted with something of size `xx` bits and the same alignment as an integer type of the -// same size. - -// The first element is to ensure proper alignment, irrespective of the machines word size. Since -// the size of the discriminant value is machine dependent, this has be taken into account when -// datatype layout should be predictable as in this case. -enum Regular<T16, T32, T64> { - Case1(T64, T16, T16, T16, T16), - Case2(T64, T32, T32), - Case3(T64, T64) -} - -enum Univariant<T64> { - TheOnlyCase(T64) -} - -fn main() { - - // In order to avoid endianness trouble all of the following test values consist of a single - // repeated byte. This way each interpretation of the union should look the same, no matter if - // this is a big or little endian machine. - - // 0b0111110001111100011111000111110001111100011111000111110001111100 = 8970181431921507452 - // 0b01111100011111000111110001111100 = 2088533116 - // 0b0111110001111100 = 31868 - // 0b01111100 = 124 - let case1: Regular<u16, u32, u64> = Case1(0_u64, 31868_u16, 31868_u16, 31868_u16, 31868_u16); - - // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441 - // 0b00010001000100010001000100010001 = 286331153 - // 0b0001000100010001 = 4369 - // 0b00010001 = 17 - let case2: Regular<i16, i32, i64> = Case2(0_i64, 286331153_i32, 286331153_i32); - - // 0b0101100101011001010110010101100101011001010110010101100101011001 = 6438275382588823897 - // 0b01011001010110010101100101011001 = 1499027801 - // 0b0101100101011001 = 22873 - // 0b01011001 = 89 - let case3: Regular<i16, i32, i64> = Case3(0_i64, 6438275382588823897_i64); - - let univariant = TheOnlyCase(-1_i64); - - zzz(); // #break -} - -fn zzz() { () } diff --git a/src/test/debuginfo/recursive-struct-legacy.rs b/src/test/debuginfo/recursive-struct-legacy.rs deleted file mode 100644 index 99286708ae2..00000000000 --- a/src/test/debuginfo/recursive-struct-legacy.rs +++ /dev/null @@ -1,235 +0,0 @@ -// ignore-tidy-linelength -// ignore-lldb - -// As long as LLVM 5 and LLVM 6 are supported, we want to test the -// enum debuginfo fallback mode. Once those are desupported, this -// test can be removed, as there is another (non-"legacy") test that -// tests the new mode. -// ignore-llvm-version: 7.0 - 9.9.9 -// ignore-gdb-version: 7.11.90 - 7.12.9 -// ignore-gdb-version: 8.2 - 9.9 - -// compile-flags:-g - -// gdb-command:run - -// gdb-command:print stack_unique.value -// gdb-check:$1 = 0 -// gdbg-command:print stack_unique.next.RUST$ENCODED$ENUM$0$Empty.val->value -// gdbr-command:print stack_unique.next.val.value -// gdb-check:$2 = 1 - -// gdbg-command:print unique_unique->value -// gdbr-command:print unique_unique.value -// gdb-check:$3 = 2 -// gdbg-command:print unique_unique->next.RUST$ENCODED$ENUM$0$Empty.val->value -// gdbr-command:print unique_unique.next.val.value -// gdb-check:$4 = 3 - -// gdb-command:print vec_unique[0].value -// gdb-check:$5 = 6.5 -// gdbg-command:print vec_unique[0].next.RUST$ENCODED$ENUM$0$Empty.val->value -// gdbr-command:print vec_unique[0].next.val.value -// gdb-check:$6 = 7.5 - -// gdbg-command:print borrowed_unique->value -// gdbr-command:print borrowed_unique.value -// gdb-check:$7 = 8.5 -// gdbg-command:print borrowed_unique->next.RUST$ENCODED$ENUM$0$Empty.val->value -// gdbr-command:print borrowed_unique.next.val.value -// gdb-check:$8 = 9.5 - -// LONG CYCLE -// gdb-command:print long_cycle1.value -// gdb-check:$9 = 20 -// gdbg-command:print long_cycle1.next->value -// gdbr-command:print long_cycle1.next.value -// gdb-check:$10 = 21 -// gdbg-command:print long_cycle1.next->next->value -// gdbr-command:print long_cycle1.next.next.value -// gdb-check:$11 = 22 -// gdbg-command:print long_cycle1.next->next->next->value -// gdbr-command:print long_cycle1.next.next.next.value -// gdb-check:$12 = 23 - -// gdb-command:print long_cycle2.value -// gdb-check:$13 = 24 -// gdbg-command:print long_cycle2.next->value -// gdbr-command:print long_cycle2.next.value -// gdb-check:$14 = 25 -// gdbg-command:print long_cycle2.next->next->value -// gdbr-command:print long_cycle2.next.next.value -// gdb-check:$15 = 26 - -// gdb-command:print long_cycle3.value -// gdb-check:$16 = 27 -// gdbg-command:print long_cycle3.next->value -// gdbr-command:print long_cycle3.next.value -// gdb-check:$17 = 28 - -// gdb-command:print long_cycle4.value -// gdb-check:$18 = 29.5 - -// gdbg-command:print (*****long_cycle_w_anonymous_types).value -// gdbr-command:print long_cycle_w_anonymous_types.value -// gdb-check:$19 = 30 - -// gdbg-command:print (*****((*****long_cycle_w_anonymous_types).next.RUST$ENCODED$ENUM$0$Empty.val)).value -// gdbr-command:print long_cycle_w_anonymous_types.next.val.value -// gdb-check:$20 = 31 - -// gdb-command:continue - -#![allow(unused_variables)] -#![feature(box_syntax)] -#![feature(omit_gdb_pretty_printer_section)] -#![omit_gdb_pretty_printer_section] - -use self::Opt::{Empty, Val}; - -enum Opt<T> { - Empty, - Val { val: T } -} - -struct UniqueNode<T> { - next: Opt<Box<UniqueNode<T>>>, - value: T -} - -struct LongCycle1<T> { - next: Box<LongCycle2<T>>, - value: T, -} - -struct LongCycle2<T> { - next: Box<LongCycle3<T>>, - value: T, -} - -struct LongCycle3<T> { - next: Box<LongCycle4<T>>, - value: T, -} - -struct LongCycle4<T> { - next: Option<Box<LongCycle1<T>>>, - value: T, -} - -struct LongCycleWithAnonymousTypes { - next: Opt<Box<Box<Box<Box<Box<LongCycleWithAnonymousTypes>>>>>>, - value: usize, -} - -// This test case makes sure that recursive structs are properly described. The Node structs are -// generic so that we can have a new type (that newly needs to be described) for the different -// cases. The potential problem with recursive types is that the DI generation algorithm gets -// trapped in an endless loop. To make sure, we actually test this in the different cases, we have -// to operate on a new type each time, otherwise we would just hit the DI cache for all but the -// first case. - -// The different cases below (stack_*, unique_*, box_*, etc) are set up so that the type description -// algorithm will enter the type reference cycle that is created by a recursive definition from a -// different context each time. - -// The "long cycle" cases are constructed to span a longer, indirect recursion cycle between types. -// The different locals will cause the DI algorithm to enter the type reference cycle at different -// points. - -fn main() { - let stack_unique: UniqueNode<u16> = UniqueNode { - next: Val { - val: box UniqueNode { - next: Empty, - value: 1, - } - }, - value: 0, - }; - - let unique_unique: Box<UniqueNode<u32>> = box UniqueNode { - next: Val { - val: box UniqueNode { - next: Empty, - value: 3, - } - }, - value: 2, - }; - - let vec_unique: [UniqueNode<f32>; 1] = [UniqueNode { - next: Val { - val: box UniqueNode { - next: Empty, - value: 7.5, - } - }, - value: 6.5, - }]; - - let borrowed_unique: &UniqueNode<f64> = &UniqueNode { - next: Val { - val: box UniqueNode { - next: Empty, - value: 9.5, - } - }, - value: 8.5, - }; - - // LONG CYCLE - let long_cycle1: LongCycle1<u16> = LongCycle1 { - next: box LongCycle2 { - next: box LongCycle3 { - next: box LongCycle4 { - next: None, - value: 23, - }, - value: 22, - }, - value: 21 - }, - value: 20 - }; - - let long_cycle2: LongCycle2<u32> = LongCycle2 { - next: box LongCycle3 { - next: box LongCycle4 { - next: None, - value: 26, - }, - value: 25, - }, - value: 24 - }; - - let long_cycle3: LongCycle3<u64> = LongCycle3 { - next: box LongCycle4 { - next: None, - value: 28, - }, - value: 27, - }; - - let long_cycle4: LongCycle4<f32> = LongCycle4 { - next: None, - value: 29.5, - }; - - // It's important that LongCycleWithAnonymousTypes is encountered only at the end of the - // `box` chain. - let long_cycle_w_anonymous_types = box box box box box LongCycleWithAnonymousTypes { - next: Val { - val: box box box box box LongCycleWithAnonymousTypes { - next: Empty, - value: 31, - } - }, - value: 30 - }; - - zzz(); // #break -} - -fn zzz() {()} diff --git a/src/test/debuginfo/struct-style-enum-legacy.rs b/src/test/debuginfo/struct-style-enum-legacy.rs deleted file mode 100644 index 1433493fd5d..00000000000 --- a/src/test/debuginfo/struct-style-enum-legacy.rs +++ /dev/null @@ -1,105 +0,0 @@ -// ignore-tidy-linelength -// min-lldb-version: 310 - -// As long as LLVM 5 and LLVM 6 are supported, we want to test the -// enum debuginfo fallback mode. Once those are desupported, this -// test can be removed, as there is another (non-"legacy") test that -// tests the new mode. -// ignore-llvm-version: 7.0 - 9.9.9 -// ignore-gdb-version: 7.11.90 - 7.12.9 -// ignore-gdb-version: 8.2 - 9.9 - -// compile-flags:-g - -// === GDB TESTS =================================================================================== - -// gdb-command:set print union on -// gdb-command:run - -// gdb-command:print case1 -// gdbg-check:$1 = {{RUST$ENUM$DISR = Case1, a = 0, b = 31868, c = 31868, d = 31868, e = 31868}, {RUST$ENUM$DISR = Case1, [...]}, {RUST$ENUM$DISR = Case1, [...]}} -// gdbr-check:$1 = struct_style_enum_legacy::Regular::Case1{a: 0, b: 31868, c: 31868, d: 31868, e: 31868} - -// gdb-command:print case2 -// gdbg-check:$2 = {{RUST$ENUM$DISR = Case2, [...]}, {RUST$ENUM$DISR = Case2, a = 0, b = 286331153, c = 286331153}, {RUST$ENUM$DISR = Case2, [...]}} -// gdbr-check:$2 = struct_style_enum_legacy::Regular::Case2{a: 0, b: 286331153, c: 286331153} - -// gdb-command:print case3 -// gdbg-check:$3 = {{RUST$ENUM$DISR = Case3, [...]}, {RUST$ENUM$DISR = Case3, [...]}, {RUST$ENUM$DISR = Case3, a = 0, b = 6438275382588823897}} -// gdbr-check:$3 = struct_style_enum_legacy::Regular::Case3{a: 0, b: 6438275382588823897} - -// gdb-command:print univariant -// gdbg-check:$4 = {{a = -1}} -// gdbr-check:$4 = struct_style_enum_legacy::Univariant::TheOnlyCase{a: -1} - - -// === LLDB TESTS ================================================================================== - -// lldb-command:run - -// lldb-command:print case1 -// lldbg-check:[...]$0 = Case1 { a: 0, b: 31868, c: 31868, d: 31868, e: 31868 } -// lldbr-check:(struct_style_enum_legacy::Regular::Case1) case1 = { a = 0 b = 31868 c = 31868 d = 31868 e = 31868 } - -// lldb-command:print case2 -// lldbg-check:[...]$1 = Case2 { a: 0, b: 286331153, c: 286331153 } -// lldbr-check:(struct_style_enum_legacy::Regular::Case2) case2 = Case2 { struct_style_enum_legacy::Regular::Case1: 0, struct_style_enum_legacy::Regular::Case2: 286331153, struct_style_enum_legacy::Regular::Case3: 286331153 } - -// lldb-command:print case3 -// lldbg-check:[...]$2 = Case3 { a: 0, b: 6438275382588823897 } -// lldbr-check:(struct_style_enum_legacy::Regular::Case3) case3 = Case3 { struct_style_enum_legacy::Regular::Case1: 0, struct_style_enum_legacy::Regular::Case2: 6438275382588823897 } - -// lldb-command:print univariant -// lldbg-check:[...]$3 = TheOnlyCase { a: -1 } -// lldbr-check:(struct_style_enum_legacy::Univariant) univariant = Univariant { struct_style_enum_legacy::TheOnlyCase: TheOnlyCase { a: -1 } } - -#![allow(unused_variables)] -#![feature(omit_gdb_pretty_printer_section)] -#![omit_gdb_pretty_printer_section] - -use self::Regular::{Case1, Case2, Case3}; -use self::Univariant::TheOnlyCase; - -// The first element is to ensure proper alignment, irrespective of the machines word size. Since -// the size of the discriminant value is machine dependent, this has be taken into account when -// datatype layout should be predictable as in this case. -enum Regular { - Case1 { a: u64, b: u16, c: u16, d: u16, e: u16}, - Case2 { a: u64, b: u32, c: u32}, - Case3 { a: u64, b: u64 } -} - -enum Univariant { - TheOnlyCase { a: i64 } -} - -fn main() { - - // In order to avoid endianness trouble all of the following test values consist of a single - // repeated byte. This way each interpretation of the union should look the same, no matter if - // this is a big or little endian machine. - - // 0b0111110001111100011111000111110001111100011111000111110001111100 = 8970181431921507452 - // 0b01111100011111000111110001111100 = 2088533116 - // 0b0111110001111100 = 31868 - // 0b01111100 = 124 - let case1 = Case1 { a: 0, b: 31868, c: 31868, d: 31868, e: 31868 }; - - // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441 - // 0b00010001000100010001000100010001 = 286331153 - // 0b0001000100010001 = 4369 - // 0b00010001 = 17 - let case2 = Case2 { a: 0, b: 286331153, c: 286331153 }; - - // 0b0101100101011001010110010101100101011001010110010101100101011001 = 6438275382588823897 - // 0b01011001010110010101100101011001 = 1499027801 - // 0b0101100101011001 = 22873 - // 0b01011001 = 89 - let case3 = Case3 { a: 0, b: 6438275382588823897 }; - - let univariant = TheOnlyCase { a: -1 }; - - zzz(); // #break -} - -fn zzz() {()} diff --git a/src/test/debuginfo/tuple-style-enum-legacy.rs b/src/test/debuginfo/tuple-style-enum-legacy.rs deleted file mode 100644 index ebc8e034438..00000000000 --- a/src/test/debuginfo/tuple-style-enum-legacy.rs +++ /dev/null @@ -1,105 +0,0 @@ -// ignore-tidy-linelength -// min-lldb-version: 310 - -// As long as LLVM 5 and LLVM 6 are supported, we want to test the -// enum debuginfo fallback mode. Once those are desupported, this -// test can be removed, as there is another (non-"legacy") test that -// tests the new mode. -// ignore-llvm-version: 7.0 - 9.9.9 -// ignore-gdb-version: 7.11.90 - 7.12.9 -// ignore-gdb-version: 8.2 - 9.9 - -// compile-flags:-g - -// === GDB TESTS =================================================================================== - -// gdb-command:set print union on -// gdb-command:run - -// gdb-command:print case1 -// gdbg-check:$1 = {{RUST$ENUM$DISR = Case1, __0 = 0, __1 = 31868, __2 = 31868, __3 = 31868, __4 = 31868}, {RUST$ENUM$DISR = Case1, [...]}, {RUST$ENUM$DISR = Case1, [...]}} -// gdbr-check:$1 = tuple_style_enum_legacy::Regular::Case1(0, 31868, 31868, 31868, 31868) - -// gdb-command:print case2 -// gdbg-check:$2 = {{RUST$ENUM$DISR = Case2, [...]}, {RUST$ENUM$DISR = Case2, __0 = 0, __1 = 286331153, __2 = 286331153}, {RUST$ENUM$DISR = Case2, [...]}} -// gdbr-check:$2 = tuple_style_enum_legacy::Regular::Case2(0, 286331153, 286331153) - -// gdb-command:print case3 -// gdbg-check:$3 = {{RUST$ENUM$DISR = Case3, [...]}, {RUST$ENUM$DISR = Case3, [...]}, {RUST$ENUM$DISR = Case3, __0 = 0, __1 = 6438275382588823897}} -// gdbr-check:$3 = tuple_style_enum_legacy::Regular::Case3(0, 6438275382588823897) - -// gdb-command:print univariant -// gdbg-check:$4 = {{__0 = -1}} -// gdbr-check:$4 = tuple_style_enum_legacy::Univariant::TheOnlyCase(-1) - - -// === LLDB TESTS ================================================================================== - -// lldb-command:run - -// lldb-command:print case1 -// lldbg-check:[...]$0 = Case1(0, 31868, 31868, 31868, 31868) -// lldbr-check:(tuple_style_enum_legacy::Regular::Case1) case1 = { = 0 = 31868 = 31868 = 31868 = 31868 } - -// lldb-command:print case2 -// lldbg-check:[...]$1 = Case2(0, 286331153, 286331153) -// lldbr-check:(tuple_style_enum_legacy::Regular::Case2) case2 = Case2 { tuple_style_enum_legacy::Regular::Case1: 0, tuple_style_enum_legacy::Regular::Case2: 286331153, tuple_style_enum_legacy::Regular::Case3: 286331153 } - -// lldb-command:print case3 -// lldbg-check:[...]$2 = Case3(0, 6438275382588823897) -// lldbr-check:(tuple_style_enum_legacy::Regular::Case3) case3 = Case3 { tuple_style_enum_legacy::Regular::Case1: 0, tuple_style_enum_legacy::Regular::Case2: 6438275382588823897 } - -// lldb-command:print univariant -// lldbg-check:[...]$3 = TheOnlyCase(-1) -// lldbr-check:(tuple_style_enum_legacy::Univariant) univariant = { tuple_style_enum_legacy::TheOnlyCase = { = -1 } } - -#![allow(unused_variables)] -#![feature(omit_gdb_pretty_printer_section)] -#![omit_gdb_pretty_printer_section] - -use self::Regular::{Case1, Case2, Case3}; -use self::Univariant::TheOnlyCase; - -// The first element is to ensure proper alignment, irrespective of the machines word size. Since -// the size of the discriminant value is machine dependent, this has be taken into account when -// datatype layout should be predictable as in this case. -enum Regular { - Case1(u64, u16, u16, u16, u16), - Case2(u64, u32, u32), - Case3(u64, u64) -} - -enum Univariant { - TheOnlyCase(i64) -} - -fn main() { - - // In order to avoid endianness trouble all of the following test values consist of a single - // repeated byte. This way each interpretation of the union should look the same, no matter if - // this is a big or little endian machine. - - // 0b0111110001111100011111000111110001111100011111000111110001111100 = 8970181431921507452 - // 0b01111100011111000111110001111100 = 2088533116 - // 0b0111110001111100 = 31868 - // 0b01111100 = 124 - let case1 = Case1(0, 31868, 31868, 31868, 31868); - - // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441 - // 0b00010001000100010001000100010001 = 286331153 - // 0b0001000100010001 = 4369 - // 0b00010001 = 17 - let case2 = Case2(0, 286331153, 286331153); - - // 0b0101100101011001010110010101100101011001010110010101100101011001 = 6438275382588823897 - // 0b01011001010110010101100101011001 = 1499027801 - // 0b0101100101011001 = 22873 - // 0b01011001 = 89 - let case3 = Case3(0, 6438275382588823897); - - let univariant = TheOnlyCase(-1); - - zzz(); // #break -} - -fn zzz() {()} diff --git a/src/test/debuginfo/unique-enum-legacy.rs b/src/test/debuginfo/unique-enum-legacy.rs deleted file mode 100644 index e7c93577528..00000000000 --- a/src/test/debuginfo/unique-enum-legacy.rs +++ /dev/null @@ -1,88 +0,0 @@ -// ignore-tidy-linelength -// min-lldb-version: 310 - -// As long as LLVM 5 and LLVM 6 are supported, we want to test the -// enum debuginfo fallback mode. Once those are desupported, this -// test can be removed, as there is another (non-"legacy") test that -// tests the new mode. -// ignore-llvm-version: 7.0 - 9.9.9 -// ignore-gdb-version: 7.11.90 - 7.12.9 -// ignore-gdb-version: 8.2 - 9.9 - -// compile-flags:-g - -// === GDB TESTS =================================================================================== - -// gdb-command:run - -// gdb-command:print *the_a -// gdbg-check:$1 = {{RUST$ENUM$DISR = TheA, x = 0, y = 8970181431921507452}, {RUST$ENUM$DISR = TheA, [...]}} -// gdbr-check:$1 = unique_enum_legacy::ABC::TheA{x: 0, y: 8970181431921507452} - -// gdb-command:print *the_b -// gdbg-check:$2 = {{RUST$ENUM$DISR = TheB, [...]}, {RUST$ENUM$DISR = TheB, __0 = 0, __1 = 286331153, __2 = 286331153}} -// gdbr-check:$2 = unique_enum_legacy::ABC::TheB(0, 286331153, 286331153) - -// gdb-command:print *univariant -// gdbg-check:$3 = {{__0 = 123234}} -// gdbr-check:$3 = unique_enum_legacy::Univariant::TheOnlyCase(123234) - - -// === LLDB TESTS ================================================================================== - -// lldb-command:run - -// lldb-command:print *the_a -// lldbg-check:[...]$0 = TheA { x: 0, y: 8970181431921507452 } -// lldbr-check:(unique_enum_legacy::ABC::TheA) *the_a = TheA { unique_enum_legacy::ABC::TheA: 0, unique_enum_legacy::ABC::TheB: 8970181431921507452 } - -// lldb-command:print *the_b -// lldbg-check:[...]$1 = TheB(0, 286331153, 286331153) -// lldbr-check:(unique_enum_legacy::ABC::TheB) *the_b = { = 0 = 286331153 = 286331153 } - -// lldb-command:print *univariant -// lldbg-check:[...]$2 = TheOnlyCase(123234) -// lldbr-check:(unique_enum_legacy::Univariant) *univariant = { unique_enum_legacy::TheOnlyCase = { = 123234 } } - -#![allow(unused_variables)] -#![feature(box_syntax)] -#![feature(omit_gdb_pretty_printer_section)] -#![omit_gdb_pretty_printer_section] - -// The first element is to ensure proper alignment, irrespective of the machines word size. Since -// the size of the discriminant value is machine dependent, this has be taken into account when -// datatype layout should be predictable as in this case. -enum ABC { - TheA { x: i64, y: i64 }, - TheB (i64, i32, i32), -} - -// This is a special case since it does not have the implicit discriminant field. -enum Univariant { - TheOnlyCase(i64) -} - -fn main() { - - // In order to avoid endianness trouble all of the following test values consist of a single - // repeated byte. This way each interpretation of the union should look the same, no matter if - // this is a big or little endian machine. - - // 0b0111110001111100011111000111110001111100011111000111110001111100 = 8970181431921507452 - // 0b01111100011111000111110001111100 = 2088533116 - // 0b0111110001111100 = 31868 - // 0b01111100 = 124 - let the_a: Box<_> = box ABC::TheA { x: 0, y: 8970181431921507452 }; - - // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441 - // 0b00010001000100010001000100010001 = 286331153 - // 0b0001000100010001 = 4369 - // 0b00010001 = 17 - let the_b: Box<_> = box ABC::TheB (0, 286331153, 286331153); - - let univariant: Box<_> = box Univariant::TheOnlyCase(123234); - - zzz(); // #break -} - -fn zzz() {()} |