Remove legacy debuginfo tests
These are no longer relevant, as our minimum supported version is LLVM 7.
This commit is contained in:
Nikita Popov
parent
00daf2dabc
commit
b27b1d8efc
|
|
@ -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() {()}
|
||||
|
|
@ -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() { () }
|
||||
|
|
@ -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() {()}
|
||||
|
|
@ -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() { () }
|
||||
|
|
@ -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() {()}
|
||||
|
|
@ -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() {()}
|
||||
|
|
@ -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() {()}
|
||||
|
|
@ -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() {()}
|
||||
Loading…
Reference in New Issue