psx 0.1.8

Library for developing homebrew for the Sony PlayStation 1
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

use core::mem::{size_of, transmute};

/// Define a constructor that runs before `main`.
#[macro_export]
macro_rules! ctor {
    (fn $name:ident() { $($body:tt)* }) => {
        #[used]
        #[link_section = ".ctors"]
        #[allow(non_upper_case_globals)]
        static $name: fn() = || {
            $($body)*
        };
    };
}

/// Define a destructor that runs after `main`.
///
/// Since the runtime `panic!`s after `main` returns, this is mostly useful with
/// the `loadable_exe` feature.
#[macro_export]
macro_rules! dtor {
    (fn $name:ident() { $($body:tt)* }) => {
        #[used]
        #[link_section = ".dtors"]
        #[allow(non_upper_case_globals)]
        static $name: fn() = || {
            $($body)*
        };
    };
}

#[cfg(feature = "loadable_exe")]
type RtReturn = ();
#[cfg(not(feature = "loadable_exe"))]
type RtReturn = !;

/// The runtime used by the default linker scripts.
#[no_mangle]
extern "C" fn __start() -> RtReturn {
    // SAFETY: If there is no unmangled function named `main` this causes an error
    // at link-time.
    unsafe {
        #[cfg(not(test))]
        extern "Rust" {
            fn main();
        }
        extern "C" {
            static __ctors_start: usize;
            static __ctors_end: usize;
            static __dtors_start: usize;
            static __dtors_end: usize;
        }
        let start = &__ctors_start as *const usize as usize;
        let end = &__ctors_end as *const usize as usize;
        let ctors_range = end - start;
        let num_ctors = ctors_range / size_of::<usize>();
        for n in 0..num_ctors {
            let ctor_ptr = start + (n * size_of::<usize>());
            let fn_addr = *(ctor_ptr as *const usize);
            let ctor = transmute::<usize, fn()>(fn_addr);
            ctor();
        }
        #[cfg(not(test))]
        main();

        #[cfg(test)]
        crate::main();

        let start = &__dtors_start as *const usize as usize;
        let end = &__dtors_end as *const usize as usize;
        let dtors_range = end - start;
        let num_dtors = dtors_range / size_of::<usize>();
        for n in 0..num_dtors {
            let dtor_ptr = start + (n * size_of::<usize>());
            let fn_addr = *(dtor_ptr as *const usize);
            let dtor = transmute::<usize, fn()>(fn_addr);
            dtor();
        }
    }
    #[cfg(not(feature = "loadable_exe"))]
    panic!("`main` should not return")
}

// Define string-literals to embed in PSEXE header
// Using the same identifier for all regions conveniently makes the crate
// features mutually exclusive
#[cfg(any(
    feature = "NA_region",
    feature = "EU_region",
    feature = "J_region",
    test
))]
macro_rules! as_array {
    ($msg:literal) => {
        // SAFETY: This dereferences a pointer to a literal which has a static lifetime.
        unsafe { *($msg.as_ptr() as *const _) }
    };
}

#[cfg(any(feature = "NA_region", test))]
#[used]
#[no_mangle]
#[doc(hidden)]
#[link_section = ".region"]
pub static _REGION: [u8; 55] = as_array!("Sony Computer Entertainment Inc. for North America area");

#[cfg(feature = "EU_region")]
#[used]
#[no_mangle]
#[doc(hidden)]
#[link_section = ".region"]
pub static _REGION: [u8; 48] = as_array!("Sony Computer Entertainment Inc. for Europe area");

#[cfg(feature = "J_region")]
#[used]
#[no_mangle]
#[doc(hidden)]
#[link_section = ".region"]
pub static _REGION: [u8; 47] = as_array!("Sony Computer Entertainment Inc. for Japan area");