shape-jit 0.3.2

Tiered JIT compiler (Cranelift) for the Shape virtual machine
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

// ============================================================================
// Vector Intrinsics
// ============================================================================
//
// Per ADR-006 §2.7.5, the JIT-FFI boundary carries raw `u64` plus a parallel
// `NativeKind` companion stamped at JIT compile time from the call signature.
// These extern "C" entry-points retain the raw `u64` ABI shape so the
// Cranelift call sites in the JIT codegen don't need to change today.
//
// **Phase-2c surface (ADR-006 §2.7.4): vector intrinsics rebuild.** The
// pre-bulldozer bodies decoded `&[ValueWord]` argument arrays via tag-bit
// dispatch (`as_any_array()`, `as_f64_slice()`, etc.) and dispatched to
// `shape_runtime::intrinsics::vector::intrinsic_vec_*` /
// `intrinsics::matrix::intrinsic_*` free functions. Both pieces are deleted:
// `ValueWord` is gone post-strict-typing, and the runtime now exposes vector
// / matrix intrinsics only as `ModuleExports` (`__intrinsic_vec_abs`, etc.)
// with kind-threaded `&[KindedSlot]` body shims that themselves return a
// deferred error in Phase 1.B (mirroring `multi_table::functions::align_tables`
// at `crates/shape-runtime/src/multi_table/functions.rs:30`).
//
// The kind-threaded rebuild (per-position `NativeKind` flowing from the
// JIT-emitted call signature into a `KindedSlot` carrier the runtime
// `__intrinsic_vec_*` body consumes) lands in Phase 2c. Until then every
// entry-point surface-and-stops per W10 playbook §5.

use super::super::context::JITContext;

#[inline]
fn vector_intrinsic_phase_2c() -> ! {
    todo!("phase-2c — see ADR-006 §2.7.4: vector intrinsics rebuild")
}

pub extern "C" fn jit_intrinsic_vec_abs(_ctx: *mut JITContext, _arg_bits: u64) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_vec_sqrt(_ctx: *mut JITContext, _arg_bits: u64) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_vec_ln(_ctx: *mut JITContext, _arg_bits: u64) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_vec_exp(_ctx: *mut JITContext, _arg_bits: u64) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_vec_add(
    _ctx: *mut JITContext,
    _a_bits: u64,
    _b_bits: u64,
) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_vec_sub(
    _ctx: *mut JITContext,
    _a_bits: u64,
    _b_bits: u64,
) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_vec_mul(
    _ctx: *mut JITContext,
    _a_bits: u64,
    _b_bits: u64,
) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_vec_div(
    _ctx: *mut JITContext,
    _a_bits: u64,
    _b_bits: u64,
) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_vec_max(
    _ctx: *mut JITContext,
    _a_bits: u64,
    _b_bits: u64,
) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_vec_min(
    _ctx: *mut JITContext,
    _a_bits: u64,
    _b_bits: u64,
) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_matmul_vec(
    _ctx: *mut JITContext,
    _a_bits: u64,
    _b_bits: u64,
) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_matmul_mat(
    _ctx: *mut JITContext,
    _a_bits: u64,
    _b_bits: u64,
) -> u64 {
    vector_intrinsic_phase_2c()
}

// ===== R5.4D: Matrix/Vec arithmetic intrinsics (unwired) =====
//
// Same Phase-2c surface as the rest of the family; tracked under the same
// rebuild ticket per ADR-006 §2.7.4.

pub extern "C" fn jit_intrinsic_vec_add_i64(
    _ctx: *mut JITContext,
    _a_bits: u64,
    _b_bits: u64,
) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_mat_add(
    _ctx: *mut JITContext,
    _a_bits: u64,
    _b_bits: u64,
) -> u64 {
    vector_intrinsic_phase_2c()
}

pub extern "C" fn jit_intrinsic_mat_sub(
    _ctx: *mut JITContext,
    _a_bits: u64,
    _b_bits: u64,
) -> u64 {
    vector_intrinsic_phase_2c()
}