From f2cead396f68cce4d6d960847782ab11e43f2d08 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 13:14:36 +0100 Subject: [PATCH 01/22] Update to LLVM 10 --- src/llvm-project | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/llvm-project b/src/llvm-project index 2cb41005ed5c4..3fae5396f2985 160000 --- a/src/llvm-project +++ b/src/llvm-project @@ -1 +1 @@ -Subproject commit 2cb41005ed5c4747b10d2bf01d8779d3bb4ae32d +Subproject commit 3fae5396f2985780f365809538f4e9f6d59d5261 From baf89f53a8a14d12818105a60cb3eb88c92491a5 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 14:02:22 +0100 Subject: [PATCH 02/22] Explicitly include InitializePasses.h --- src/rustllvm/PassWrapper.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/rustllvm/PassWrapper.cpp b/src/rustllvm/PassWrapper.cpp index 6698e5d58be2f..c7c468c2c77c2 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" From d420140976a7a63d8d6c7ea2a31ff7fce353c2c6 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 14:05:34 +0100 Subject: [PATCH 03/22] CodeGenFileType moved outside TargetMachine --- src/rustllvm/PassWrapper.cpp | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/rustllvm/PassWrapper.cpp b/src/rustllvm/PassWrapper.cpp index c7c468c2c77c2..4491bb5fcce50 100644 --- a/src/rustllvm/PassWrapper.cpp +++ b/src/rustllvm/PassWrapper.cpp @@ -533,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: @@ -543,6 +555,7 @@ static TargetMachine::CodeGenFileType fromRust(LLVMRustFileType Type) { report_fatal_error("Bad FileType."); } } +#endif extern "C" LLVMRustResult LLVMRustWriteOutputFile(LLVMTargetMachineRef Target, LLVMPassManagerRef PMR, From 01f4ea9d5e28f740a305c6276966febae58cebf9 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 14:08:25 +0100 Subject: [PATCH 04/22] Replace llvm::make_unique() with std::make_unique() --- src/rustllvm/ArchiveWrapper.cpp | 2 +- src/rustllvm/Linker.cpp | 2 +- src/rustllvm/PassWrapper.cpp | 4 ++-- src/rustllvm/RustWrapper.cpp | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/rustllvm/ArchiveWrapper.cpp b/src/rustllvm/ArchiveWrapper.cpp index dd0111d3f2c83..e0d24358e1f31 100644 --- a/src/rustllvm/ArchiveWrapper.cpp +++ b/src/rustllvm/ArchiveWrapper.cpp @@ -89,7 +89,7 @@ extern "C" void LLVMRustDestroyArchive(LLVMRustArchiveRef RustArchive) { extern "C" LLVMRustArchiveIteratorRef LLVMRustArchiveIteratorNew(LLVMRustArchiveRef RustArchive) { Archive *Archive = RustArchive->getBinary(); - std::unique_ptr Err = llvm::make_unique(Error::success()); + std::unique_ptr Err = std::make_unique(Error::success()); 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 7916721943a5f..6de93734bb242 100644 --- a/src/rustllvm/Linker.cpp +++ b/src/rustllvm/Linker.cpp @@ -18,7 +18,7 @@ extern "C" RustLinker* LLVMRustLinkerNew(LLVMModuleRef DstRef) { Module *Dst = unwrap(DstRef); - auto Ret = llvm::make_unique(*Dst); + auto Ret = std::make_unique(*Dst); return Ret.release(); } diff --git a/src/rustllvm/PassWrapper.cpp b/src/rustllvm/PassWrapper.cpp index 4491bb5fcce50..97e4548c80c74 100644 --- a/src/rustllvm/PassWrapper.cpp +++ b/src/rustllvm/PassWrapper.cpp @@ -863,7 +863,7 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules, int num_modules, const char **preserved_symbols, int num_symbols) { - auto Ret = llvm::make_unique(); + auto Ret = std::make_unique(); // Load each module's summary and merge it into one combined index for (int i = 0; i < num_modules; i++) { @@ -1095,7 +1095,7 @@ struct LLVMRustThinLTOBuffer { extern "C" LLVMRustThinLTOBuffer* LLVMRustThinLTOBufferCreate(LLVMModuleRef M) { - auto Ret = llvm::make_unique(); + auto Ret = std::make_unique(); { raw_string_ostream OS(Ret->data); { diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index 720928e48e382..97b326f65b441 100644 --- a/src/rustllvm/RustWrapper.cpp +++ b/src/rustllvm/RustWrapper.cpp @@ -1450,7 +1450,7 @@ struct LLVMRustModuleBuffer { extern "C" LLVMRustModuleBuffer* LLVMRustModuleBufferCreate(LLVMModuleRef M) { - auto Ret = llvm::make_unique(); + auto Ret = std::make_unique(); { raw_string_ostream OS(Ret->data); { From 90145379f2507db22707cbfecb68221d028536a1 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 14:14:31 +0100 Subject: [PATCH 05/22] Update thinLTOInternalizeAndPromoteInIndex() usage --- src/rustllvm/PassWrapper.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/rustllvm/PassWrapper.cpp b/src/rustllvm/PassWrapper.cpp index 97e4548c80c74..5e8733a8f5aeb 100644 --- a/src/rustllvm/PassWrapper.cpp +++ b/src/rustllvm/PassWrapper.cpp @@ -958,6 +958,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() && @@ -965,6 +974,7 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules, ExportedGUIDs.count(GUID); }; thinLTOInternalizeAndPromoteInIndex(Ret->Index, isExported); +#endif return Ret.release(); } From 5a89c82fa6cdc6fb42c1449f5751f634dc628177 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 14:17:11 +0100 Subject: [PATCH 06/22] Don't handle removed FlagBlockByrefStruct --- src/rustllvm/RustWrapper.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index 97b326f65b441..1a9e98265ac12 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; } From 8aaf90a6ab0c06f3dd174d3fa738b50e262fe3e5 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 14:23:53 +0100 Subject: [PATCH 07/22] Pass isDefined parameter to createGlobalVariableExpression() --- src/rustllvm/RustWrapper.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index 1a9e98265ac12..5e9f24e49dc35 100644 --- a/src/rustllvm/RustWrapper.cpp +++ b/src/rustllvm/RustWrapper.cpp @@ -827,6 +827,9 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable( llvm::DIGlobalVariableExpression *VarExpr = Builder->createGlobalVariableExpression( unwrapDI(Context), Name, LinkageName, unwrapDI(File), LineNo, unwrapDI(Ty), IsLocalToUnit, +#if LLVM_VERSION_GE(10, 0) + /* isDefined */ true, +#endif InitExpr, unwrapDIPtr(Decl), #if LLVM_VERSION_GE(8, 0) /* templateParams */ nullptr, From 15bd7d95cc6e1e3ebafc75df02e601c52a273a07 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 14:28:56 +0100 Subject: [PATCH 08/22] Handle switch to Expected for section name --- src/rustllvm/RustWrapper.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index 5e9f24e49dc35..7e183ee28fb60 100644 --- a/src/rustllvm/RustWrapper.cpp +++ b/src/rustllvm/RustWrapper.cpp @@ -1003,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 From f4ecb7006ed494f58e8fbf6f4efe4f63ffae86cd Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 14:32:01 +0100 Subject: [PATCH 09/22] Switch to using MaybeAlign APIs The integer versions are deprecated --- src/rustllvm/RustWrapper.cpp | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index 7e183ee28fb60..30733e581205f 100644 --- a/src/rustllvm/RustWrapper.cpp +++ b/src/rustllvm/RustWrapper.cpp @@ -1266,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 From bfedf38e457fa2cc8a2295600ed148f26daf7a0c Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 15:18:53 +0100 Subject: [PATCH 10/22] Auto-upgrade data layouts for X86 address spaces --- src/librustc_codegen_llvm/context.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs index 827516f76a164..2212fa83cbcdc 100644 --- a/src/librustc_codegen_llvm/context.rs +++ b/src/librustc_codegen_llvm/context.rs @@ -143,6 +143,18 @@ 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-", "-") +} + +fn add_x86_address_spaces(mut data_layout: String) -> String { + let address_spaces = "-p270:32:32-p271:32:32-p272:64:64"; + if !data_layout.contains(address_spaces) { + data_layout.insert_str("e-m:X".len(), address_spaces); + } + data_layout +} + pub unsafe fn create_module( tcx: TyCtxt<'_>, llcx: &'ll llvm::Context, @@ -156,6 +168,13 @@ pub unsafe fn create_module( if llvm_util::get_major_version() < 9 { target_data_layout = strip_function_ptr_alignment(target_data_layout); } + if sess.target.target.arch == "x86" || sess.target.target.arch == "x86_64" { + if llvm_util::get_major_version() < 10 { + target_data_layout = strip_x86_address_spaces(target_data_layout); + } else { + target_data_layout = add_x86_address_spaces(target_data_layout); + } + } // Ensure the data-layout values hardcoded remain the defaults. if sess.target.target.options.is_builtin { From 924deff565ed013e259f24a1394364a441fe9e87 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 15:46:46 +0100 Subject: [PATCH 11/22] Update submodule reference (my fork for now) --- .gitmodules | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitmodules b/.gitmodules index 31db0772cfb6b..80b2f05309d37 100644 --- a/.gitmodules +++ b/.gitmodules @@ -39,8 +39,8 @@ url = https://github.com/rust-lang/edition-guide.git [submodule "src/llvm-project"] path = src/llvm-project - url = https://github.com/rust-lang/llvm-project.git - branch = rustc/9.0-2019-09-19 + url = https://github.com/nikic/llvm-project.git + branch = rustc/10.0-2019-12-31 [submodule "src/doc/embedded-book"] path = src/doc/embedded-book url = https://github.com/rust-embedded/book.git From 50ef80e93a8c5e9897b995a20dc8bc558c984335 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 15:52:17 +0100 Subject: [PATCH 12/22] Update bool-cmp.rs codegen --- src/test/codegen/bool-cmp.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/test/codegen/bool-cmp.rs b/src/test/codegen/bool-cmp.rs index 8769a4cb5e189..5090f7c378c36 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) } From 1971813de6ccd25c563ee87ee9d63cf357fc2701 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 16:05:11 +0100 Subject: [PATCH 13/22] Update codegen tests with unnamed arguments --- src/test/codegen/abi-main-signature-32bit-c-int.rs | 2 +- src/test/codegen/function-arguments.rs | 4 ++-- src/test/codegen/naked-functions.rs | 4 ++-- src/test/codegen/repr-transparent-sysv64.rs | 4 ++-- src/test/codegen/union-abi.rs | 2 +- 5 files changed, 8 insertions(+), 8 deletions(-) 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 c7aab09edec71..a7a4520ff9545 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/function-arguments.rs b/src/test/codegen/function-arguments.rs index 5c9aa48c0a5d6..3511c7c5185ee 100644 --- a/src/test/codegen/function-arguments.rs +++ b/src/test/codegen/function-arguments.rs @@ -73,7 +73,7 @@ pub fn _box(x: Box) -> Box { 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) { } diff --git a/src/test/codegen/naked-functions.rs b/src/test/codegen/naked-functions.rs index 2050193b61b54..5050ed1499414 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/repr-transparent-sysv64.rs b/src/test/codegen/repr-transparent-sysv64.rs index b71cb14a4ff08..886b0dd9e7b08 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 98a9ff9cbe441..afea01e9a2d03 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 {} } From f39df60bc4a400595583d0c643345444493d73b1 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 16:07:44 +0100 Subject: [PATCH 14/22] Handle extra attributes in repeat-trusted-len.rs test --- src/test/codegen/repeat-trusted-len.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/codegen/repeat-trusted-len.rs b/src/test/codegen/repeat-trusted-len.rs index 99f3464c0768d..8fbe712065bde 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 { -// 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() } From 10decc6deac2ddf8c92b6ef79f3157323c492acb Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 31 Dec 2019 16:09:14 +0100 Subject: [PATCH 15/22] Account for pointer type suffix in prefetch test --- src/test/codegen/intrinsics/prefetch.rs | 32 ++++++++++++------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/src/test/codegen/intrinsics/prefetch.rs b/src/test/codegen/intrinsics/prefetch.rs index 4cd38e142824a..2386fc43007a2 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); } } From 1b15b7ff142afeedae1e93ffc4360d52d4177c45 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Fri, 3 Jan 2020 20:21:54 +0100 Subject: [PATCH 16/22] Update LLVM submodule with new patches --- .gitmodules | 2 +- src/llvm-project | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitmodules b/.gitmodules index 80b2f05309d37..8d3c924224ef9 100644 --- a/.gitmodules +++ b/.gitmodules @@ -40,7 +40,7 @@ [submodule "src/llvm-project"] path = src/llvm-project url = https://github.com/nikic/llvm-project.git - branch = rustc/10.0-2019-12-31 + branch = rustc/10.0-2020-01-03 [submodule "src/doc/embedded-book"] path = src/doc/embedded-book url = https://github.com/rust-embedded/book.git diff --git a/src/llvm-project b/src/llvm-project index 3fae5396f2985..cc35e64b7428d 160000 --- a/src/llvm-project +++ b/src/llvm-project @@ -1 +1 @@ -Subproject commit 3fae5396f2985780f365809538f4e9f6d59d5261 +Subproject commit cc35e64b7428df942c6b5043d191d8607f2d0caa From 326fc7b43463b47a57d1f1020893468c6c1f316b Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Fri, 3 Jan 2020 20:25:49 +0100 Subject: [PATCH 17/22] Add back llvm::make_unique uses for older versions --- src/rustllvm/ArchiveWrapper.cpp | 4 ++++ src/rustllvm/Linker.cpp | 3 +-- src/rustllvm/PassWrapper.cpp | 8 ++++++++ src/rustllvm/RustWrapper.cpp | 4 ++++ 4 files changed, 17 insertions(+), 2 deletions(-) diff --git a/src/rustllvm/ArchiveWrapper.cpp b/src/rustllvm/ArchiveWrapper.cpp index e0d24358e1f31..678d787571ed7 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 Err = std::make_unique(Error::success()); +#else + std::unique_ptr Err = llvm::make_unique(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 6de93734bb242..69176f9cb1f6d 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 = std::make_unique(*Dst); - return Ret.release(); + return new RustLinker(*Dst); } extern "C" void diff --git a/src/rustllvm/PassWrapper.cpp b/src/rustllvm/PassWrapper.cpp index 5e8733a8f5aeb..eaa845a279fe8 100644 --- a/src/rustllvm/PassWrapper.cpp +++ b/src/rustllvm/PassWrapper.cpp @@ -863,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(); +#else + auto Ret = llvm::make_unique(); +#endif // Load each module's summary and merge it into one combined index for (int i = 0; i < num_modules; i++) { @@ -1105,7 +1109,11 @@ struct LLVMRustThinLTOBuffer { extern "C" LLVMRustThinLTOBuffer* LLVMRustThinLTOBufferCreate(LLVMModuleRef M) { +#if LLVM_VERSION_GE(10, 0) auto Ret = std::make_unique(); +#else + auto Ret = llvm::make_unique(); +#endif { raw_string_ostream OS(Ret->data); { diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index 30733e581205f..46e467011b91a 100644 --- a/src/rustllvm/RustWrapper.cpp +++ b/src/rustllvm/RustWrapper.cpp @@ -1477,7 +1477,11 @@ struct LLVMRustModuleBuffer { extern "C" LLVMRustModuleBuffer* LLVMRustModuleBufferCreate(LLVMModuleRef M) { +#if LLVM_VERSION_GE(10, 0) auto Ret = std::make_unique(); +#else + auto Ret = llvm::make_unique(); +#endif { raw_string_ostream OS(Ret->data); { From a1823926ce969226a09d598da876d2709749f110 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Fri, 3 Jan 2020 20:35:25 +0100 Subject: [PATCH 18/22] Handle p:32:32 in X86 data layout upgrade This matches the autoupgrade in LLVM more closely. --- src/librustc_codegen_llvm/context.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs index 2212fa83cbcdc..927532404eea3 100644 --- a/src/librustc_codegen_llvm/context.rs +++ b/src/librustc_codegen_llvm/context.rs @@ -149,8 +149,12 @@ fn strip_x86_address_spaces(data_layout: String) -> String { fn add_x86_address_spaces(mut data_layout: String) -> String { let address_spaces = "-p270:32:32-p271:32:32-p272:64:64"; - if !data_layout.contains(address_spaces) { - data_layout.insert_str("e-m:X".len(), address_spaces); + if !data_layout.contains(address_spaces) && data_layout.starts_with("e-m:") { + let mut insert_pos = "e-m:?".len(); + if data_layout[insert_pos..].starts_with("-p:32:32") { + insert_pos += "-p:32:32".len(); + } + data_layout.insert_str(insert_pos, address_spaces); } data_layout } From a05ec58d3b9d08f01193cbae485e903b4699c5c2 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Fri, 3 Jan 2020 22:33:18 +0100 Subject: [PATCH 19/22] Temporarily ignore codegen test that regressed :( --- src/test/codegen/issue-45222.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test/codegen/issue-45222.rs b/src/test/codegen/issue-45222.rs index 7aadc8a095498..7c626573d4ee6 100644 --- a/src/test/codegen/issue-45222.rs +++ b/src/test/codegen/issue-45222.rs @@ -1,5 +1,6 @@ // compile-flags: -O // ignore-debug: the debug assertions get in the way +// ignore-test: Codegen regression in LLVM 10 #![crate_type = "lib"] From d6773bf804ee8042550567f9eb175c539e10bc7e Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Fri, 3 Jan 2020 22:49:41 +0100 Subject: [PATCH 20/22] Remove legacy debuginfo tests These are no longer relevant, as our minimum supported version is LLVM 7. --- src/test/debuginfo/borrowed-enum-legacy.rs | 84 ------- ...c-enum-with-different-disr-sizes-legacy.rs | 105 -------- .../generic-struct-style-enum-legacy.rs | 86 ------- .../generic-tuple-style-enum-legacy.rs | 108 -------- src/test/debuginfo/recursive-struct-legacy.rs | 235 ------------------ .../debuginfo/struct-style-enum-legacy.rs | 105 -------- src/test/debuginfo/tuple-style-enum-legacy.rs | 105 -------- src/test/debuginfo/unique-enum-legacy.rs | 88 ------- 8 files changed, 916 deletions(-) delete mode 100644 src/test/debuginfo/borrowed-enum-legacy.rs delete mode 100644 src/test/debuginfo/generic-enum-with-different-disr-sizes-legacy.rs delete mode 100644 src/test/debuginfo/generic-struct-style-enum-legacy.rs delete mode 100644 src/test/debuginfo/generic-tuple-style-enum-legacy.rs delete mode 100644 src/test/debuginfo/recursive-struct-legacy.rs delete mode 100644 src/test/debuginfo/struct-style-enum-legacy.rs delete mode 100644 src/test/debuginfo/tuple-style-enum-legacy.rs delete mode 100644 src/test/debuginfo/unique-enum-legacy.rs diff --git a/src/test/debuginfo/borrowed-enum-legacy.rs b/src/test/debuginfo/borrowed-enum-legacy.rs deleted file mode 100644 index 9a973ed74e867..0000000000000 --- 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 4f17e48c6a437..0000000000000 --- 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 { - 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 37a875a4188c1..0000000000000 --- 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::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 { - 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 { - 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 = Case1 { a: 0, b: 31868, c: 31868, d: 31868, e: 31868 }; - - // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441 - // 0b00010001000100010001000100010001 = 286331153 - // 0b0001000100010001 = 4369 - // 0b00010001 = 17 - let case2: Regular = Case2 { a: 0, b: 286331153, c: 286331153 }; - - // 0b0101100101011001010110010101100101011001010110010101100101011001 = 6438275382588823897 - // 0b01011001010110010101100101011001 = 1499027801 - // 0b0101100101011001 = 22873 - // 0b01011001 = 89 - let case3: Regular = 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 452e90008ea60..0000000000000 --- 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::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::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::Case2) case2 = Regular::Case2 { generic_tuple_style_enum_legacy::Regular::Case1: 0, generic_tuple_style_enum_legacy::Regular::Case2: 286331153, generic_tuple_style_enum_legacy::Regular::Case3: 286331153 } - -// lldb-command:print case3 -// lldbg-check:[...]$2 = Case3(0, 6438275382588823897) -// lldbr-check:(generic_tuple_style_enum_legacy::Regular::Case3) case3 = Regular::Case3 { generic_tuple_style_enum_legacy::Regular::Case1: 0, generic_tuple_style_enum_legacy::Regular::Case2: 6438275382588823897 } - -// lldb-command:print univariant -// lldbg-check:[...]$3 = TheOnlyCase(-1) -// lldbr-check:(generic_tuple_style_enum_legacy::Univariant) 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 { - Case1(T64, T16, T16, T16, T16), - Case2(T64, T32, T32), - Case3(T64, T64) -} - -enum Univariant { - 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 = Case1(0_u64, 31868_u16, 31868_u16, 31868_u16, 31868_u16); - - // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441 - // 0b00010001000100010001000100010001 = 286331153 - // 0b0001000100010001 = 4369 - // 0b00010001 = 17 - let case2: Regular = Case2(0_i64, 286331153_i32, 286331153_i32); - - // 0b0101100101011001010110010101100101011001010110010101100101011001 = 6438275382588823897 - // 0b01011001010110010101100101011001 = 1499027801 - // 0b0101100101011001 = 22873 - // 0b01011001 = 89 - let case3: Regular = 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 99286708ae243..0000000000000 --- 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 { - Empty, - Val { val: T } -} - -struct UniqueNode { - next: Opt>>, - value: T -} - -struct LongCycle1 { - next: Box>, - value: T, -} - -struct LongCycle2 { - next: Box>, - value: T, -} - -struct LongCycle3 { - next: Box>, - value: T, -} - -struct LongCycle4 { - next: Option>>, - value: T, -} - -struct LongCycleWithAnonymousTypes { - next: Opt>>>>>, - 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 = UniqueNode { - next: Val { - val: box UniqueNode { - next: Empty, - value: 1, - } - }, - value: 0, - }; - - let unique_unique: Box> = box UniqueNode { - next: Val { - val: box UniqueNode { - next: Empty, - value: 3, - } - }, - value: 2, - }; - - let vec_unique: [UniqueNode; 1] = [UniqueNode { - next: Val { - val: box UniqueNode { - next: Empty, - value: 7.5, - } - }, - value: 6.5, - }]; - - let borrowed_unique: &UniqueNode = &UniqueNode { - next: Val { - val: box UniqueNode { - next: Empty, - value: 9.5, - } - }, - value: 8.5, - }; - - // LONG CYCLE - let long_cycle1: LongCycle1 = LongCycle1 { - next: box LongCycle2 { - next: box LongCycle3 { - next: box LongCycle4 { - next: None, - value: 23, - }, - value: 22, - }, - value: 21 - }, - value: 20 - }; - - let long_cycle2: LongCycle2 = LongCycle2 { - next: box LongCycle3 { - next: box LongCycle4 { - next: None, - value: 26, - }, - value: 25, - }, - value: 24 - }; - - let long_cycle3: LongCycle3 = LongCycle3 { - next: box LongCycle4 { - next: None, - value: 28, - }, - value: 27, - }; - - let long_cycle4: LongCycle4 = 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 1433493fd5d0f..0000000000000 --- 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 ebc8e03443881..0000000000000 --- 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 e7c9357752897..0000000000000 --- 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() {()} From b2da2a163a49652481f5a818d8cacb79b450dde1 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Sat, 4 Jan 2020 00:13:25 +0100 Subject: [PATCH 21/22] Add include path when compiling profiler runtime InstrProfData.inc has been moved to include/ --- src/libprofiler_builtins/build.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/libprofiler_builtins/build.rs b/src/libprofiler_builtins/build.rs index 04cd2efe00093..852b7aac3590b 100644 --- a/src/libprofiler_builtins/build.rs +++ b/src/libprofiler_builtins/build.rs @@ -72,6 +72,7 @@ fn main() { cfg.file(root.join("lib").join("profile").join(src)); } + cfg.include(root.join("include")); cfg.warnings(false); cfg.compile("profiler-rt"); } From 26bf1681b41b187fa00a26d402d0e3c7186c480c Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Sat, 4 Jan 2020 00:19:37 +0100 Subject: [PATCH 22/22] Handle changed InstrProfilingRuntime path --- src/libprofiler_builtins/build.rs | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/libprofiler_builtins/build.rs b/src/libprofiler_builtins/build.rs index 852b7aac3590b..8adcff67800fe 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,16 @@ 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");