1 #![feature(no_core, lang_items, never_type, linkage, extern_types, thread_local)]
3 #![allow(dead_code, non_camel_case_types)]
5 extern crate mini_core
;
8 use mini_core
::libc
::*;
10 unsafe extern "C" fn my_puts(s
: *const i8) {
17 panic(stringify
!(! $e
));
22 macro_rules
! assert_eq
{
23 ($l
:expr
, $r
: expr
) => {
25 panic(stringify
!($l
!= $r
));
30 #[lang = "termination"]
32 fn report(self) -> i32;
35 impl Termination
for () {
36 fn report(self) -> i32 {
38 NUM
= 6 * 7 + 1 + (1u8 == 1u8) as u8; // 44
39 assert_eq
!(*NUM_REF
as i32, 44);
46 fn object_safe(&self);
49 impl SomeTrait
for &'
static str {
50 fn object_safe(&self) {
52 puts(*self as *const str as *const i8);
59 inner
: NoisyDropInner
,
62 struct NoisyDropInner
;
64 impl Drop
for NoisyDrop
{
67 puts(self.text
as *const str as *const i8);
72 impl Drop
for NoisyDropInner
{
75 puts("Inner got dropped!\0" as *const str as *const i8);
80 impl SomeTrait
for NoisyDrop
{
81 fn object_safe(&self) {}
91 fn start
<T
: Termination
+ '
static>(
94 argv
: *const *const u8,
97 unsafe { puts(*argv as *const i8); }
98 unsafe { puts(*((argv as usize + intrinsics::size_of::<*const u8>()) as *const *const i8)); }
99 unsafe { puts(*((argv as usize + 2 * intrinsics::size_of::<*const u8>()) as *const *const i8)); }
102 main().report() as isize
105 static mut NUM
: u8 = 6 * 7;
106 static NUM_REF
: &'
static u8 = unsafe { &NUM }
;
108 struct Unique
<T
: ?Sized
> {
110 _marker
: PhantomData
<T
>,
113 impl<T
: ?Sized
, U
: ?Sized
> CoerceUnsized
<Unique
<U
>> for Unique
<T
> where T
: Unsize
<U
> {}
115 unsafe fn zeroed
<T
>() -> T
{
116 let mut uninit
= MaybeUninit { uninit: () }
;
117 intrinsics
::write_bytes(&mut uninit
.value
.value
as *mut T
, 0, 1);
121 fn take_f32(_f
: f32) {}
122 fn take_unique(_u
: Unique
<()>) {}
124 fn return_u128_pair() -> (u128
, u128
) {
128 fn call_return_u128_pair() {
134 pointer
: 0 as *const (),
135 _marker
: PhantomData
,
139 call_return_u128_pair();
141 let slice
= &[0, 1] as &[i32];
142 let slice_ptr
= slice
as *const [i32] as *const i32;
144 assert_eq
!(slice_ptr
as usize % 4, 0);
149 printf("Hello %s\n\0" as *const str as *const i8, "printf\0" as *const str as *const i8);
151 let hello
: &[u8] = b
"Hello\0" as &[u8; 6];
152 let ptr
: *const i8 = hello
as *const [u8] as *const i8;
155 let world
: Box
<&str> = box "World!\0";
156 puts(*world
as *const str as *const i8);
157 world
as Box
<dyn SomeTrait
>;
159 assert_eq
!(intrinsics
::bitreverse(0b10101000u8), 0b00010101u8);
161 assert_eq
!(intrinsics
::bswap(0xabu8), 0xabu8);
162 assert_eq
!(intrinsics
::bswap(0xddccu16), 0xccddu16);
163 assert_eq
!(intrinsics
::bswap(0xffee_ddccu32), 0xccdd_eeffu32);
164 assert_eq
!(intrinsics
::bswap(0x1234_5678_ffee_ddccu64), 0xccdd_eeff_7856_3412u64);
166 assert_eq
!(intrinsics
::size_of_val(hello
) as u8, 6);
168 let chars
= &['C'
, 'h'
, 'a'
, 'r'
, 's'
];
169 let chars
= chars
as &[char];
170 assert_eq
!(intrinsics
::size_of_val(chars
) as u8, 4 * 5);
172 let a
: &dyn SomeTrait
= &"abc\0";
175 assert_eq
!(intrinsics
::size_of_val(a
) as u8, 16);
176 assert_eq
!(intrinsics
::size_of_val(&0u32) as u8, 4);
178 assert_eq
!(intrinsics
::min_align_of
::<u16>() as u8, 2);
179 assert_eq
!(intrinsics
::min_align_of_val(&a
) as u8, intrinsics
::min_align_of
::<&str>() as u8);
181 assert
!(!intrinsics
::needs_drop
::<u8>());
182 assert
!(intrinsics
::needs_drop
::<NoisyDrop
>());
185 pointer
: 0 as *const &str,
186 _marker
: PhantomData
,
187 } as Unique
<dyn SomeTrait
>;
189 struct MyDst
<T
: ?Sized
>(T
);
191 intrinsics
::size_of_val(&MyDst([0u8; 4]) as &MyDst
<[u8]>);
198 unsafe fn uninitialized
<T
>() -> T
{
199 MaybeUninit { uninit: () }
.value
.value
202 zeroed
::<(u8, u8)>();
203 #[allow(unreachable_code)]
208 uninitialized
::<Foo
>();
213 let _
= box NoisyDrop
{
214 text
: "Boxed outer got dropped!\0",
215 inner
: NoisyDropInner
,
216 } as Box
<dyn SomeTrait
>;
218 const FUNC_REF
: Option
<fn()> = Some(main
);
221 None
=> assert
!(false),
224 match Ordering
::Less
{
225 Ordering
::Less
=> {}
,
229 [NoisyDropInner
, NoisyDropInner
];
231 let x
= &[0u32, 42u32] as &[u32];
233 [] => assert_eq
!(0u32, 1),
234 [_
, ref y @
..] => assert_eq
!(&x
[1] as *const u32 as usize, &y
[0] as *const u32 as usize),
237 assert_eq
!(((|()| 42u8) as fn(()) -> u8)(()), 42);
239 #[cfg(not(any(jit, windows)))]
242 #[linkage = "extern_weak"]
243 static ABC
: *const u8;
248 #[linkage = "extern_weak"]
249 static ABC
: *const u8;
253 unsafe { assert_eq!(ABC as usize, 0); }
256 &mut (|| Some(0 as *const ())) as &mut dyn FnMut() -> Option
<*const ()>;
259 assert_eq
!(f
as u8, 255);
261 assert_eq
!(f2
as i8, -128);
262 assert_eq
!(f2
as u8, 0);
265 assert_eq
!(1u128 << amount
, 1);
267 static ANOTHER_STATIC
: &u8 = &A_STATIC
;
268 assert_eq
!(*ANOTHER_STATIC
, 42);
270 check_niche_behavior();
276 struct ExternTypeWrapper
{
280 let nullptr
= 0 as *const ();
281 let extern_nullptr
= nullptr
as *const ExternTypeWrapper
;
282 extern_nullptr
as *const ();
283 let slice_ptr
= &[] as *const [u8];
284 slice_ptr
as *const u8;
286 let repeat
= [Some(42); 2];
287 assert_eq
!(repeat
[0], Some(42));
288 assert_eq
!(repeat
[1], Some(42));
290 from_decimal_string();
292 #[cfg(not(any(jit, windows)))]
295 #[cfg(all(not(jit), target_arch = "x86_64", target_os = "linux"))]
300 // Both statics have a reference that points to the same anonymous allocation.
301 static REF1
: &u8 = &42;
302 static REF2
: &u8 = REF1
;
303 assert_eq
!(*REF1
, *REF2
);
306 #[cfg(all(not(jit), target_arch = "x86_64", target_os = "linux"))]
308 fn global_asm_test();
311 #[cfg(all(not(jit), target_arch = "x86_64", target_os = "linux"))]
314 .global global_asm_test
316 // comment that would normally be removed by LLVM
330 type pthread_t
= c_ulong
;
333 struct pthread_attr_t
{
337 #[link(name = "pthread")]
339 fn pthread_attr_init(attr
: *mut pthread_attr_t
) -> c_int
;
342 native
: *mut pthread_t
,
343 attr
: *const pthread_attr_t
,
344 f
: extern "C" fn(_
: *mut c_void
) -> *mut c_void
,
350 value
: *mut *mut c_void
356 static mut TLS
: u8 = 42;
359 extern "C" fn mutate_tls(_
: *mut c_void
) -> *mut c_void
{
367 let mut attr
: pthread_attr_t
= zeroed();
368 let mut thread
: pthread_t
= 0;
372 if pthread_attr_init(&mut attr
) != 0 {
376 if pthread_create(&mut thread
, &attr
, mutate_tls
, 0 as *mut c_void
) != 0 {
380 let mut res
= 0 as *mut c_void
;
381 pthread_join(thread
, &mut res
);
383 // TLS of main thread must not have been changed by the other thread.
386 puts("TLS works!\n\0" as *const str as *const i8);
390 // Copied ui/issues/issue-61696.rs
392 pub enum Infallible {}
394 // The check that the `bool` field of `V1` is encoding a "niche variant"
395 // (i.e. not `V1`, so `V3` or `V4`) used to be mathematically incorrect,
396 // causing valid `V1` values to be interpreted as other variants.
399 V2 { f: Infallible }
,
404 // Computing the discriminant used to be done using the niche type (here `u8`,
405 // from the `bool` field of `V1`), overflowing for variants with large enough
406 // indices (`V3` and `V4`), causing them to be interpreted as other variants.
410 /*_00*/ _01(X
), _02(X
), _03(X
), _04(X
), _05(X
), _06(X
), _07(X
),
411 _08(X
), _09(X
), _0A(X
), _0B(X
), _0C(X
), _0D(X
), _0E(X
), _0F(X
),
412 _10(X
), _11(X
), _12(X
), _13(X
), _14(X
), _15(X
), _16(X
), _17(X
),
413 _18(X
), _19(X
), _1A(X
), _1B(X
), _1C(X
), _1D(X
), _1E(X
), _1F(X
),
414 _20(X
), _21(X
), _22(X
), _23(X
), _24(X
), _25(X
), _26(X
), _27(X
),
415 _28(X
), _29(X
), _2A(X
), _2B(X
), _2C(X
), _2D(X
), _2E(X
), _2F(X
),
416 _30(X
), _31(X
), _32(X
), _33(X
), _34(X
), _35(X
), _36(X
), _37(X
),
417 _38(X
), _39(X
), _3A(X
), _3B(X
), _3C(X
), _3D(X
), _3E(X
), _3F(X
),
418 _40(X
), _41(X
), _42(X
), _43(X
), _44(X
), _45(X
), _46(X
), _47(X
),
419 _48(X
), _49(X
), _4A(X
), _4B(X
), _4C(X
), _4D(X
), _4E(X
), _4F(X
),
420 _50(X
), _51(X
), _52(X
), _53(X
), _54(X
), _55(X
), _56(X
), _57(X
),
421 _58(X
), _59(X
), _5A(X
), _5B(X
), _5C(X
), _5D(X
), _5E(X
), _5F(X
),
422 _60(X
), _61(X
), _62(X
), _63(X
), _64(X
), _65(X
), _66(X
), _67(X
),
423 _68(X
), _69(X
), _6A(X
), _6B(X
), _6C(X
), _6D(X
), _6E(X
), _6F(X
),
424 _70(X
), _71(X
), _72(X
), _73(X
), _74(X
), _75(X
), _76(X
), _77(X
),
425 _78(X
), _79(X
), _7A(X
), _7B(X
), _7C(X
), _7D(X
), _7E(X
), _7F(X
),
426 _80(X
), _81(X
), _82(X
), _83(X
), _84(X
), _85(X
), _86(X
), _87(X
),
427 _88(X
), _89(X
), _8A(X
), _8B(X
), _8C(X
), _8D(X
), _8E(X
), _8F(X
),
428 _90(X
), _91(X
), _92(X
), _93(X
), _94(X
), _95(X
), _96(X
), _97(X
),
429 _98(X
), _99(X
), _9A(X
), _9B(X
), _9C(X
), _9D(X
), _9E(X
), _9F(X
),
430 _A0(X
), _A1(X
), _A2(X
), _A3(X
), _A4(X
), _A5(X
), _A6(X
), _A7(X
),
431 _A8(X
), _A9(X
), _AA(X
), _AB(X
), _AC(X
), _AD(X
), _AE(X
), _AF(X
),
432 _B0(X
), _B1(X
), _B2(X
), _B3(X
), _B4(X
), _B5(X
), _B6(X
), _B7(X
),
433 _B8(X
), _B9(X
), _BA(X
), _BB(X
), _BC(X
), _BD(X
), _BE(X
), _BF(X
),
434 _C0(X
), _C1(X
), _C2(X
), _C3(X
), _C4(X
), _C5(X
), _C6(X
), _C7(X
),
435 _C8(X
), _C9(X
), _CA(X
), _CB(X
), _CC(X
), _CD(X
), _CE(X
), _CF(X
),
436 _D0(X
), _D1(X
), _D2(X
), _D3(X
), _D4(X
), _D5(X
), _D6(X
), _D7(X
),
437 _D8(X
), _D9(X
), _DA(X
), _DB(X
), _DC(X
), _DD(X
), _DE(X
), _DF(X
),
438 _E0(X
), _E1(X
), _E2(X
), _E3(X
), _E4(X
), _E5(X
), _E6(X
), _E7(X
),
439 _E8(X
), _E9(X
), _EA(X
), _EB(X
), _EC(X
), _ED(X
), _EE(X
), _EF(X
),
440 _F0(X
), _F1(X
), _F2(X
), _F3(X
), _F4(X
), _F5(X
), _F6(X
), _F7(X
),
441 _F8(X
), _F9(X
), _FA(X
), _FB(X
), _FC(X
), _FD(X
), _FE(X
), _FF(X
),
447 fn check_niche_behavior () {
448 if let E1
::V2 { .. }
= (E1
::V1 { f: true }
) {
452 if let E2
::V1 { .. }
= E2
::V3
::<Infallible
> {
457 fn from_decimal_string() {
461 take_multiplier_ref(&multiplier
);
471 fn take_multiplier_ref(_multiplier
: &u128
) {}
473 fn unreachable() -> ! {