dyncast 0.1.0

Downcasting made easy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! Specialized form of [generic-statics](https://github.com/cynecx/generic-statics/).
//! The static allocation for each generic static instantiation is hardcoded
//! (64 bytes blocks with 16 byte alignment).

use std::{any::TypeId, marker::PhantomData};

struct Inspect<T>(PhantomData<T>);

impl<T> Inspect<T> {
    const IS_VALID: bool = {
        assert!(std::mem::size_of::<*const ()>() <= 8);
        assert!(std::mem::size_of::<T>() <= 64);
        assert!(std::mem::align_of::<T>() <= 16);
        true
    };
}

/// # Safety
/// `T` must be a bit zeroable type.
#[inline(never)]
#[must_use]
pub unsafe fn generic_static<T: 'static>() -> &'static T {
    assert!(Inspect::<T>::IS_VALID);

    #[allow(unused_assignments)]
    let mut addr: *const () = std::ptr::null();

    // HACK: We have to "use" the generic `T` in some way to force the compiler to emit every
    // instatiation of this function, otherwise rustc might be smart and merge instantiations.
    let type_id = TypeId::of::<T> as *const ();

    #[cfg(all(
        target_arch = "aarch64",
        any(target_os = "macos", target_os = "ios", target_os = "tvos")
    ))]
    unsafe {
        std::arch::asm!(
            "/* {type_id} */",
            "adrp {x}, 1f@PAGE",
            "add {x}, {x}, 1f@PAGEOFF",
            ".pushsection __DATA,__data",
            ".p2align 4, 0",
            "1: .zero 64",
            ".popsection",
            type_id = in(reg) type_id,
            x = out(reg) addr,
            options(nostack)
        );
    }

    #[cfg(all(
        target_arch = "aarch64",
        any(target_os = "none", target_os = "linux", target_os = "freebsd")
    ))]
    unsafe {
        std::arch::asm!(
            "/* {type_id} */",
            "adrp {x}, 1f",
            "add {x}, {x}, :lo12:1f",
            ".pushsection .bss.generic_statics,\"aw\",@nobits",
            ".p2align 4, 0",
            "1: .zero 64",
            ".popsection",
            type_id = in(reg) type_id,
            x = out(reg) addr,
            options(nostack)
        );
    }

    #[cfg(all(
        target_arch = "x86_64",
        any(target_os = "macos", target_os = "ios", target_os = "tvos")
    ))]
    unsafe {
        std::arch::asm!(
            "/* {type_id} */",
            "lea {x}, [rip + 1f]",
            ".pushsection __DATA,__data",
            ".p2align 4, 0",
            "1: .zero 64",
            ".popsection",
            type_id = in(reg) type_id,
            x = out(reg) addr,
            options(nostack)
        );
    }

    #[cfg(all(
        target_arch = "x86_64",
        any(target_os = "none", target_os = "linux", target_os = "freebsd")
    ))]
    unsafe {
        std::arch::asm!(
            "/* {type_id} */",
            "lea {x}, [rip + 1f]",
            ".pushsection .bss.generic_statics,\"aw\",@nobits",
            ".p2align 4, 0",
            "1: .zero 64",
            ".popsection",
            type_id = in(reg) type_id,
            x = out(reg) addr,
            options(nostack)
        );
    }

    #[cfg(all(target_arch = "x86_64", target_os = "windows"))]
    unsafe {
        std::arch::asm!(
            "/* {type_id} */",
            "lea {x}, [rip + 1f]",
            ".pushsection .bss.generic_statics,\"bw\"",
            ".p2align 4, 0",
            "1: .zero 64",
            ".popsection",
            type_id = in(reg) type_id,
            x = out(reg) addr,
            options(nostack)
        );
    }

    // In case this is run on targets we don't really support.
    assert!(!addr.is_null(), "unsupported platform");

    unsafe { &*addr.cast::<T>() }
}