mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-15 17:09:57 -04:00
77d0c0b84e
The NVN2 front end and the SM86 to Maxwell shader lowering (tools/xlate/AmpereLowering.cs, mesh and task stages, bindless texture pools, BRX jump tables, the NVN2 compute c0 layout) with four translator patches (0017-0020) bring the opening of the game to 58-60 fps on the Vulkan renderer. This round fixes the haze: SM86 IPA is lowered as a plain Maxwell IPA.PASS (texture coordinates were corrected for perspective twice); LDSM, TXD, both F2IP byte forms, HMMA, MOVM and HFMA2.RELU are lowered and spill mode has eight uniform register groups; conditional rendering keeps the newest counter report per address and treats a report as pending until its value is in guest memory, so occlusion tests and the depth clears around the depth copy behave; and the upscaler stand-in decodes the post pass's sRGB picture before writing the linear target. Tensor-core programs keep the stand-in unless NX2NAVI_NATIVE_TENSOR=1, because their lowering does not match the hardware yet. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
682 lines
35 KiB
C
682 lines
35 KiB
C
// NVN proc table. Every name the game's proc loader asks for gets a synthetic host
|
|
// address through hostfn_register before hostfn_seal; nvnBootstrapLoader and nvnDeviceGetProcAddress hand them out.
|
|
// nvnp_<name> is the implementation of one proc: the weak definitions here stop with the proc's name, nvn_api_*.c
|
|
// and nvn_ext.c define the strong ones. The name list is runtime/nvn_procs.inc (tools/gen_nvn_procs.py).
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "cfg.h"
|
|
#include "gfx.h"
|
|
#include "host.h"
|
|
#include "platform/platform.h"
|
|
|
|
// The strong nvnp_nvnDeviceGetProcAddress below replaces the stand-in generated for the same row.
|
|
#define nvnp_nvnDeviceGetProcAddress nvnp_stub_nvnDeviceGetProcAddress
|
|
|
|
#define NVN_PROC(n) void nvnp_##n(Cpu *c);
|
|
#include "nvn_procs.inc"
|
|
#undef NVN_PROC
|
|
|
|
#define NVN_PROC(n) \
|
|
__attribute__((weak)) void nvnp_##n(Cpu *c) { \
|
|
(void)c; \
|
|
rt_fatal("NVN " #n " is not implemented"); \
|
|
}
|
|
#include "nvn_procs.inc"
|
|
#undef NVN_PROC
|
|
#undef nvnp_nvnDeviceGetProcAddress
|
|
void nvnp_nvnDeviceGetProcAddress(Cpu *c);
|
|
|
|
typedef struct { const char *name; uint64_t addr; } Proc;
|
|
|
|
#define NVN_PROC(n) +1
|
|
enum { PROC_COUNT = 0
|
|
#include "nvn_procs.inc"
|
|
};
|
|
#undef NVN_PROC
|
|
|
|
static Proc procs[PROC_COUNT];
|
|
static int nprocs;
|
|
|
|
// Unknown procs (NVN2 names the NVN1-era table lacks): a NVN2 driver has every name the game asks for, so a NULL
|
|
// answer crashes the game at the first call (main+0xc31484 called one). Each unknown name is bound on demand to one
|
|
// of TRAP_COUNT pre-registered traps (the hostfn table is sealed after boot). A trap logs its name and caller on the
|
|
// first call and returns 0 -- a no-op for the setters most of these are; NX2NAVI_NVN_TRAP=fatal stops instead.
|
|
#define TRAP_COUNT 512
|
|
static char trap_name[TRAP_COUNT][96];
|
|
static uint64_t trap_addr[TRAP_COUNT];
|
|
static volatile int32_t trap_called[TRAP_COUNT];
|
|
static int ntraps;
|
|
static void nvn_trap(Cpu *c, int i) {
|
|
if (!plat_xchg32(&trap_called[i], 1) || (cfg_get("NX2NAVI_NVN_TRAP") && !strcmp(cfg_get("NX2NAVI_NVN_TRAP"), "fatal"))) {
|
|
char at[160];
|
|
rt_log("nvn: unimplemented NVN2 proc %s called from %s (x0 %#llx x1 %#llx x2 %#llx x3 %#llx x4 %#llx x5 %#llx): returning 0", trap_name[i],
|
|
ldr_describe(c->x[30], at, sizeof at), (unsigned long long)c->x[0], (unsigned long long)c->x[1],
|
|
(unsigned long long)c->x[2], (unsigned long long)c->x[3], (unsigned long long)c->x[4], (unsigned long long)c->x[5]);
|
|
const char *mode = cfg_get("NX2NAVI_NVN_TRAP");
|
|
if (mode && !strcmp(mode, "fatal")) rt_fatal("nvn: %s is not implemented", trap_name[i]);
|
|
}
|
|
ret_x(c, 0);
|
|
}
|
|
// trap_0 .. trap_511, one per pool slot
|
|
static void trap_0(Cpu *c) { nvn_trap(c, 0); }
|
|
static void trap_1(Cpu *c) { nvn_trap(c, 1); }
|
|
static void trap_2(Cpu *c) { nvn_trap(c, 2); }
|
|
static void trap_3(Cpu *c) { nvn_trap(c, 3); }
|
|
static void trap_4(Cpu *c) { nvn_trap(c, 4); }
|
|
static void trap_5(Cpu *c) { nvn_trap(c, 5); }
|
|
static void trap_6(Cpu *c) { nvn_trap(c, 6); }
|
|
static void trap_7(Cpu *c) { nvn_trap(c, 7); }
|
|
static void trap_8(Cpu *c) { nvn_trap(c, 8); }
|
|
static void trap_9(Cpu *c) { nvn_trap(c, 9); }
|
|
static void trap_10(Cpu *c) { nvn_trap(c, 10); }
|
|
static void trap_11(Cpu *c) { nvn_trap(c, 11); }
|
|
static void trap_12(Cpu *c) { nvn_trap(c, 12); }
|
|
static void trap_13(Cpu *c) { nvn_trap(c, 13); }
|
|
static void trap_14(Cpu *c) { nvn_trap(c, 14); }
|
|
static void trap_15(Cpu *c) { nvn_trap(c, 15); }
|
|
static void trap_16(Cpu *c) { nvn_trap(c, 16); }
|
|
static void trap_17(Cpu *c) { nvn_trap(c, 17); }
|
|
static void trap_18(Cpu *c) { nvn_trap(c, 18); }
|
|
static void trap_19(Cpu *c) { nvn_trap(c, 19); }
|
|
static void trap_20(Cpu *c) { nvn_trap(c, 20); }
|
|
static void trap_21(Cpu *c) { nvn_trap(c, 21); }
|
|
static void trap_22(Cpu *c) { nvn_trap(c, 22); }
|
|
static void trap_23(Cpu *c) { nvn_trap(c, 23); }
|
|
static void trap_24(Cpu *c) { nvn_trap(c, 24); }
|
|
static void trap_25(Cpu *c) { nvn_trap(c, 25); }
|
|
static void trap_26(Cpu *c) { nvn_trap(c, 26); }
|
|
static void trap_27(Cpu *c) { nvn_trap(c, 27); }
|
|
static void trap_28(Cpu *c) { nvn_trap(c, 28); }
|
|
static void trap_29(Cpu *c) { nvn_trap(c, 29); }
|
|
static void trap_30(Cpu *c) { nvn_trap(c, 30); }
|
|
static void trap_31(Cpu *c) { nvn_trap(c, 31); }
|
|
static void trap_32(Cpu *c) { nvn_trap(c, 32); }
|
|
static void trap_33(Cpu *c) { nvn_trap(c, 33); }
|
|
static void trap_34(Cpu *c) { nvn_trap(c, 34); }
|
|
static void trap_35(Cpu *c) { nvn_trap(c, 35); }
|
|
static void trap_36(Cpu *c) { nvn_trap(c, 36); }
|
|
static void trap_37(Cpu *c) { nvn_trap(c, 37); }
|
|
static void trap_38(Cpu *c) { nvn_trap(c, 38); }
|
|
static void trap_39(Cpu *c) { nvn_trap(c, 39); }
|
|
static void trap_40(Cpu *c) { nvn_trap(c, 40); }
|
|
static void trap_41(Cpu *c) { nvn_trap(c, 41); }
|
|
static void trap_42(Cpu *c) { nvn_trap(c, 42); }
|
|
static void trap_43(Cpu *c) { nvn_trap(c, 43); }
|
|
static void trap_44(Cpu *c) { nvn_trap(c, 44); }
|
|
static void trap_45(Cpu *c) { nvn_trap(c, 45); }
|
|
static void trap_46(Cpu *c) { nvn_trap(c, 46); }
|
|
static void trap_47(Cpu *c) { nvn_trap(c, 47); }
|
|
static void trap_48(Cpu *c) { nvn_trap(c, 48); }
|
|
static void trap_49(Cpu *c) { nvn_trap(c, 49); }
|
|
static void trap_50(Cpu *c) { nvn_trap(c, 50); }
|
|
static void trap_51(Cpu *c) { nvn_trap(c, 51); }
|
|
static void trap_52(Cpu *c) { nvn_trap(c, 52); }
|
|
static void trap_53(Cpu *c) { nvn_trap(c, 53); }
|
|
static void trap_54(Cpu *c) { nvn_trap(c, 54); }
|
|
static void trap_55(Cpu *c) { nvn_trap(c, 55); }
|
|
static void trap_56(Cpu *c) { nvn_trap(c, 56); }
|
|
static void trap_57(Cpu *c) { nvn_trap(c, 57); }
|
|
static void trap_58(Cpu *c) { nvn_trap(c, 58); }
|
|
static void trap_59(Cpu *c) { nvn_trap(c, 59); }
|
|
static void trap_60(Cpu *c) { nvn_trap(c, 60); }
|
|
static void trap_61(Cpu *c) { nvn_trap(c, 61); }
|
|
static void trap_62(Cpu *c) { nvn_trap(c, 62); }
|
|
static void trap_63(Cpu *c) { nvn_trap(c, 63); }
|
|
static void trap_64(Cpu *c) { nvn_trap(c, 64); }
|
|
static void trap_65(Cpu *c) { nvn_trap(c, 65); }
|
|
static void trap_66(Cpu *c) { nvn_trap(c, 66); }
|
|
static void trap_67(Cpu *c) { nvn_trap(c, 67); }
|
|
static void trap_68(Cpu *c) { nvn_trap(c, 68); }
|
|
static void trap_69(Cpu *c) { nvn_trap(c, 69); }
|
|
static void trap_70(Cpu *c) { nvn_trap(c, 70); }
|
|
static void trap_71(Cpu *c) { nvn_trap(c, 71); }
|
|
static void trap_72(Cpu *c) { nvn_trap(c, 72); }
|
|
static void trap_73(Cpu *c) { nvn_trap(c, 73); }
|
|
static void trap_74(Cpu *c) { nvn_trap(c, 74); }
|
|
static void trap_75(Cpu *c) { nvn_trap(c, 75); }
|
|
static void trap_76(Cpu *c) { nvn_trap(c, 76); }
|
|
static void trap_77(Cpu *c) { nvn_trap(c, 77); }
|
|
static void trap_78(Cpu *c) { nvn_trap(c, 78); }
|
|
static void trap_79(Cpu *c) { nvn_trap(c, 79); }
|
|
static void trap_80(Cpu *c) { nvn_trap(c, 80); }
|
|
static void trap_81(Cpu *c) { nvn_trap(c, 81); }
|
|
static void trap_82(Cpu *c) { nvn_trap(c, 82); }
|
|
static void trap_83(Cpu *c) { nvn_trap(c, 83); }
|
|
static void trap_84(Cpu *c) { nvn_trap(c, 84); }
|
|
static void trap_85(Cpu *c) { nvn_trap(c, 85); }
|
|
static void trap_86(Cpu *c) { nvn_trap(c, 86); }
|
|
static void trap_87(Cpu *c) { nvn_trap(c, 87); }
|
|
static void trap_88(Cpu *c) { nvn_trap(c, 88); }
|
|
static void trap_89(Cpu *c) { nvn_trap(c, 89); }
|
|
static void trap_90(Cpu *c) { nvn_trap(c, 90); }
|
|
static void trap_91(Cpu *c) { nvn_trap(c, 91); }
|
|
static void trap_92(Cpu *c) { nvn_trap(c, 92); }
|
|
static void trap_93(Cpu *c) { nvn_trap(c, 93); }
|
|
static void trap_94(Cpu *c) { nvn_trap(c, 94); }
|
|
static void trap_95(Cpu *c) { nvn_trap(c, 95); }
|
|
static void trap_96(Cpu *c) { nvn_trap(c, 96); }
|
|
static void trap_97(Cpu *c) { nvn_trap(c, 97); }
|
|
static void trap_98(Cpu *c) { nvn_trap(c, 98); }
|
|
static void trap_99(Cpu *c) { nvn_trap(c, 99); }
|
|
static void trap_100(Cpu *c) { nvn_trap(c, 100); }
|
|
static void trap_101(Cpu *c) { nvn_trap(c, 101); }
|
|
static void trap_102(Cpu *c) { nvn_trap(c, 102); }
|
|
static void trap_103(Cpu *c) { nvn_trap(c, 103); }
|
|
static void trap_104(Cpu *c) { nvn_trap(c, 104); }
|
|
static void trap_105(Cpu *c) { nvn_trap(c, 105); }
|
|
static void trap_106(Cpu *c) { nvn_trap(c, 106); }
|
|
static void trap_107(Cpu *c) { nvn_trap(c, 107); }
|
|
static void trap_108(Cpu *c) { nvn_trap(c, 108); }
|
|
static void trap_109(Cpu *c) { nvn_trap(c, 109); }
|
|
static void trap_110(Cpu *c) { nvn_trap(c, 110); }
|
|
static void trap_111(Cpu *c) { nvn_trap(c, 111); }
|
|
static void trap_112(Cpu *c) { nvn_trap(c, 112); }
|
|
static void trap_113(Cpu *c) { nvn_trap(c, 113); }
|
|
static void trap_114(Cpu *c) { nvn_trap(c, 114); }
|
|
static void trap_115(Cpu *c) { nvn_trap(c, 115); }
|
|
static void trap_116(Cpu *c) { nvn_trap(c, 116); }
|
|
static void trap_117(Cpu *c) { nvn_trap(c, 117); }
|
|
static void trap_118(Cpu *c) { nvn_trap(c, 118); }
|
|
static void trap_119(Cpu *c) { nvn_trap(c, 119); }
|
|
static void trap_120(Cpu *c) { nvn_trap(c, 120); }
|
|
static void trap_121(Cpu *c) { nvn_trap(c, 121); }
|
|
static void trap_122(Cpu *c) { nvn_trap(c, 122); }
|
|
static void trap_123(Cpu *c) { nvn_trap(c, 123); }
|
|
static void trap_124(Cpu *c) { nvn_trap(c, 124); }
|
|
static void trap_125(Cpu *c) { nvn_trap(c, 125); }
|
|
static void trap_126(Cpu *c) { nvn_trap(c, 126); }
|
|
static void trap_127(Cpu *c) { nvn_trap(c, 127); }
|
|
static void trap_128(Cpu *c) { nvn_trap(c, 128); }
|
|
static void trap_129(Cpu *c) { nvn_trap(c, 129); }
|
|
static void trap_130(Cpu *c) { nvn_trap(c, 130); }
|
|
static void trap_131(Cpu *c) { nvn_trap(c, 131); }
|
|
static void trap_132(Cpu *c) { nvn_trap(c, 132); }
|
|
static void trap_133(Cpu *c) { nvn_trap(c, 133); }
|
|
static void trap_134(Cpu *c) { nvn_trap(c, 134); }
|
|
static void trap_135(Cpu *c) { nvn_trap(c, 135); }
|
|
static void trap_136(Cpu *c) { nvn_trap(c, 136); }
|
|
static void trap_137(Cpu *c) { nvn_trap(c, 137); }
|
|
static void trap_138(Cpu *c) { nvn_trap(c, 138); }
|
|
static void trap_139(Cpu *c) { nvn_trap(c, 139); }
|
|
static void trap_140(Cpu *c) { nvn_trap(c, 140); }
|
|
static void trap_141(Cpu *c) { nvn_trap(c, 141); }
|
|
static void trap_142(Cpu *c) { nvn_trap(c, 142); }
|
|
static void trap_143(Cpu *c) { nvn_trap(c, 143); }
|
|
static void trap_144(Cpu *c) { nvn_trap(c, 144); }
|
|
static void trap_145(Cpu *c) { nvn_trap(c, 145); }
|
|
static void trap_146(Cpu *c) { nvn_trap(c, 146); }
|
|
static void trap_147(Cpu *c) { nvn_trap(c, 147); }
|
|
static void trap_148(Cpu *c) { nvn_trap(c, 148); }
|
|
static void trap_149(Cpu *c) { nvn_trap(c, 149); }
|
|
static void trap_150(Cpu *c) { nvn_trap(c, 150); }
|
|
static void trap_151(Cpu *c) { nvn_trap(c, 151); }
|
|
static void trap_152(Cpu *c) { nvn_trap(c, 152); }
|
|
static void trap_153(Cpu *c) { nvn_trap(c, 153); }
|
|
static void trap_154(Cpu *c) { nvn_trap(c, 154); }
|
|
static void trap_155(Cpu *c) { nvn_trap(c, 155); }
|
|
static void trap_156(Cpu *c) { nvn_trap(c, 156); }
|
|
static void trap_157(Cpu *c) { nvn_trap(c, 157); }
|
|
static void trap_158(Cpu *c) { nvn_trap(c, 158); }
|
|
static void trap_159(Cpu *c) { nvn_trap(c, 159); }
|
|
static void trap_160(Cpu *c) { nvn_trap(c, 160); }
|
|
static void trap_161(Cpu *c) { nvn_trap(c, 161); }
|
|
static void trap_162(Cpu *c) { nvn_trap(c, 162); }
|
|
static void trap_163(Cpu *c) { nvn_trap(c, 163); }
|
|
static void trap_164(Cpu *c) { nvn_trap(c, 164); }
|
|
static void trap_165(Cpu *c) { nvn_trap(c, 165); }
|
|
static void trap_166(Cpu *c) { nvn_trap(c, 166); }
|
|
static void trap_167(Cpu *c) { nvn_trap(c, 167); }
|
|
static void trap_168(Cpu *c) { nvn_trap(c, 168); }
|
|
static void trap_169(Cpu *c) { nvn_trap(c, 169); }
|
|
static void trap_170(Cpu *c) { nvn_trap(c, 170); }
|
|
static void trap_171(Cpu *c) { nvn_trap(c, 171); }
|
|
static void trap_172(Cpu *c) { nvn_trap(c, 172); }
|
|
static void trap_173(Cpu *c) { nvn_trap(c, 173); }
|
|
static void trap_174(Cpu *c) { nvn_trap(c, 174); }
|
|
static void trap_175(Cpu *c) { nvn_trap(c, 175); }
|
|
static void trap_176(Cpu *c) { nvn_trap(c, 176); }
|
|
static void trap_177(Cpu *c) { nvn_trap(c, 177); }
|
|
static void trap_178(Cpu *c) { nvn_trap(c, 178); }
|
|
static void trap_179(Cpu *c) { nvn_trap(c, 179); }
|
|
static void trap_180(Cpu *c) { nvn_trap(c, 180); }
|
|
static void trap_181(Cpu *c) { nvn_trap(c, 181); }
|
|
static void trap_182(Cpu *c) { nvn_trap(c, 182); }
|
|
static void trap_183(Cpu *c) { nvn_trap(c, 183); }
|
|
static void trap_184(Cpu *c) { nvn_trap(c, 184); }
|
|
static void trap_185(Cpu *c) { nvn_trap(c, 185); }
|
|
static void trap_186(Cpu *c) { nvn_trap(c, 186); }
|
|
static void trap_187(Cpu *c) { nvn_trap(c, 187); }
|
|
static void trap_188(Cpu *c) { nvn_trap(c, 188); }
|
|
static void trap_189(Cpu *c) { nvn_trap(c, 189); }
|
|
static void trap_190(Cpu *c) { nvn_trap(c, 190); }
|
|
static void trap_191(Cpu *c) { nvn_trap(c, 191); }
|
|
static void trap_192(Cpu *c) { nvn_trap(c, 192); }
|
|
static void trap_193(Cpu *c) { nvn_trap(c, 193); }
|
|
static void trap_194(Cpu *c) { nvn_trap(c, 194); }
|
|
static void trap_195(Cpu *c) { nvn_trap(c, 195); }
|
|
static void trap_196(Cpu *c) { nvn_trap(c, 196); }
|
|
static void trap_197(Cpu *c) { nvn_trap(c, 197); }
|
|
static void trap_198(Cpu *c) { nvn_trap(c, 198); }
|
|
static void trap_199(Cpu *c) { nvn_trap(c, 199); }
|
|
static void trap_200(Cpu *c) { nvn_trap(c, 200); }
|
|
static void trap_201(Cpu *c) { nvn_trap(c, 201); }
|
|
static void trap_202(Cpu *c) { nvn_trap(c, 202); }
|
|
static void trap_203(Cpu *c) { nvn_trap(c, 203); }
|
|
static void trap_204(Cpu *c) { nvn_trap(c, 204); }
|
|
static void trap_205(Cpu *c) { nvn_trap(c, 205); }
|
|
static void trap_206(Cpu *c) { nvn_trap(c, 206); }
|
|
static void trap_207(Cpu *c) { nvn_trap(c, 207); }
|
|
static void trap_208(Cpu *c) { nvn_trap(c, 208); }
|
|
static void trap_209(Cpu *c) { nvn_trap(c, 209); }
|
|
static void trap_210(Cpu *c) { nvn_trap(c, 210); }
|
|
static void trap_211(Cpu *c) { nvn_trap(c, 211); }
|
|
static void trap_212(Cpu *c) { nvn_trap(c, 212); }
|
|
static void trap_213(Cpu *c) { nvn_trap(c, 213); }
|
|
static void trap_214(Cpu *c) { nvn_trap(c, 214); }
|
|
static void trap_215(Cpu *c) { nvn_trap(c, 215); }
|
|
static void trap_216(Cpu *c) { nvn_trap(c, 216); }
|
|
static void trap_217(Cpu *c) { nvn_trap(c, 217); }
|
|
static void trap_218(Cpu *c) { nvn_trap(c, 218); }
|
|
static void trap_219(Cpu *c) { nvn_trap(c, 219); }
|
|
static void trap_220(Cpu *c) { nvn_trap(c, 220); }
|
|
static void trap_221(Cpu *c) { nvn_trap(c, 221); }
|
|
static void trap_222(Cpu *c) { nvn_trap(c, 222); }
|
|
static void trap_223(Cpu *c) { nvn_trap(c, 223); }
|
|
static void trap_224(Cpu *c) { nvn_trap(c, 224); }
|
|
static void trap_225(Cpu *c) { nvn_trap(c, 225); }
|
|
static void trap_226(Cpu *c) { nvn_trap(c, 226); }
|
|
static void trap_227(Cpu *c) { nvn_trap(c, 227); }
|
|
static void trap_228(Cpu *c) { nvn_trap(c, 228); }
|
|
static void trap_229(Cpu *c) { nvn_trap(c, 229); }
|
|
static void trap_230(Cpu *c) { nvn_trap(c, 230); }
|
|
static void trap_231(Cpu *c) { nvn_trap(c, 231); }
|
|
static void trap_232(Cpu *c) { nvn_trap(c, 232); }
|
|
static void trap_233(Cpu *c) { nvn_trap(c, 233); }
|
|
static void trap_234(Cpu *c) { nvn_trap(c, 234); }
|
|
static void trap_235(Cpu *c) { nvn_trap(c, 235); }
|
|
static void trap_236(Cpu *c) { nvn_trap(c, 236); }
|
|
static void trap_237(Cpu *c) { nvn_trap(c, 237); }
|
|
static void trap_238(Cpu *c) { nvn_trap(c, 238); }
|
|
static void trap_239(Cpu *c) { nvn_trap(c, 239); }
|
|
static void trap_240(Cpu *c) { nvn_trap(c, 240); }
|
|
static void trap_241(Cpu *c) { nvn_trap(c, 241); }
|
|
static void trap_242(Cpu *c) { nvn_trap(c, 242); }
|
|
static void trap_243(Cpu *c) { nvn_trap(c, 243); }
|
|
static void trap_244(Cpu *c) { nvn_trap(c, 244); }
|
|
static void trap_245(Cpu *c) { nvn_trap(c, 245); }
|
|
static void trap_246(Cpu *c) { nvn_trap(c, 246); }
|
|
static void trap_247(Cpu *c) { nvn_trap(c, 247); }
|
|
static void trap_248(Cpu *c) { nvn_trap(c, 248); }
|
|
static void trap_249(Cpu *c) { nvn_trap(c, 249); }
|
|
static void trap_250(Cpu *c) { nvn_trap(c, 250); }
|
|
static void trap_251(Cpu *c) { nvn_trap(c, 251); }
|
|
static void trap_252(Cpu *c) { nvn_trap(c, 252); }
|
|
static void trap_253(Cpu *c) { nvn_trap(c, 253); }
|
|
static void trap_254(Cpu *c) { nvn_trap(c, 254); }
|
|
static void trap_255(Cpu *c) { nvn_trap(c, 255); }
|
|
static void trap_256(Cpu *c) { nvn_trap(c, 256); }
|
|
static void trap_257(Cpu *c) { nvn_trap(c, 257); }
|
|
static void trap_258(Cpu *c) { nvn_trap(c, 258); }
|
|
static void trap_259(Cpu *c) { nvn_trap(c, 259); }
|
|
static void trap_260(Cpu *c) { nvn_trap(c, 260); }
|
|
static void trap_261(Cpu *c) { nvn_trap(c, 261); }
|
|
static void trap_262(Cpu *c) { nvn_trap(c, 262); }
|
|
static void trap_263(Cpu *c) { nvn_trap(c, 263); }
|
|
static void trap_264(Cpu *c) { nvn_trap(c, 264); }
|
|
static void trap_265(Cpu *c) { nvn_trap(c, 265); }
|
|
static void trap_266(Cpu *c) { nvn_trap(c, 266); }
|
|
static void trap_267(Cpu *c) { nvn_trap(c, 267); }
|
|
static void trap_268(Cpu *c) { nvn_trap(c, 268); }
|
|
static void trap_269(Cpu *c) { nvn_trap(c, 269); }
|
|
static void trap_270(Cpu *c) { nvn_trap(c, 270); }
|
|
static void trap_271(Cpu *c) { nvn_trap(c, 271); }
|
|
static void trap_272(Cpu *c) { nvn_trap(c, 272); }
|
|
static void trap_273(Cpu *c) { nvn_trap(c, 273); }
|
|
static void trap_274(Cpu *c) { nvn_trap(c, 274); }
|
|
static void trap_275(Cpu *c) { nvn_trap(c, 275); }
|
|
static void trap_276(Cpu *c) { nvn_trap(c, 276); }
|
|
static void trap_277(Cpu *c) { nvn_trap(c, 277); }
|
|
static void trap_278(Cpu *c) { nvn_trap(c, 278); }
|
|
static void trap_279(Cpu *c) { nvn_trap(c, 279); }
|
|
static void trap_280(Cpu *c) { nvn_trap(c, 280); }
|
|
static void trap_281(Cpu *c) { nvn_trap(c, 281); }
|
|
static void trap_282(Cpu *c) { nvn_trap(c, 282); }
|
|
static void trap_283(Cpu *c) { nvn_trap(c, 283); }
|
|
static void trap_284(Cpu *c) { nvn_trap(c, 284); }
|
|
static void trap_285(Cpu *c) { nvn_trap(c, 285); }
|
|
static void trap_286(Cpu *c) { nvn_trap(c, 286); }
|
|
static void trap_287(Cpu *c) { nvn_trap(c, 287); }
|
|
static void trap_288(Cpu *c) { nvn_trap(c, 288); }
|
|
static void trap_289(Cpu *c) { nvn_trap(c, 289); }
|
|
static void trap_290(Cpu *c) { nvn_trap(c, 290); }
|
|
static void trap_291(Cpu *c) { nvn_trap(c, 291); }
|
|
static void trap_292(Cpu *c) { nvn_trap(c, 292); }
|
|
static void trap_293(Cpu *c) { nvn_trap(c, 293); }
|
|
static void trap_294(Cpu *c) { nvn_trap(c, 294); }
|
|
static void trap_295(Cpu *c) { nvn_trap(c, 295); }
|
|
static void trap_296(Cpu *c) { nvn_trap(c, 296); }
|
|
static void trap_297(Cpu *c) { nvn_trap(c, 297); }
|
|
static void trap_298(Cpu *c) { nvn_trap(c, 298); }
|
|
static void trap_299(Cpu *c) { nvn_trap(c, 299); }
|
|
static void trap_300(Cpu *c) { nvn_trap(c, 300); }
|
|
static void trap_301(Cpu *c) { nvn_trap(c, 301); }
|
|
static void trap_302(Cpu *c) { nvn_trap(c, 302); }
|
|
static void trap_303(Cpu *c) { nvn_trap(c, 303); }
|
|
static void trap_304(Cpu *c) { nvn_trap(c, 304); }
|
|
static void trap_305(Cpu *c) { nvn_trap(c, 305); }
|
|
static void trap_306(Cpu *c) { nvn_trap(c, 306); }
|
|
static void trap_307(Cpu *c) { nvn_trap(c, 307); }
|
|
static void trap_308(Cpu *c) { nvn_trap(c, 308); }
|
|
static void trap_309(Cpu *c) { nvn_trap(c, 309); }
|
|
static void trap_310(Cpu *c) { nvn_trap(c, 310); }
|
|
static void trap_311(Cpu *c) { nvn_trap(c, 311); }
|
|
static void trap_312(Cpu *c) { nvn_trap(c, 312); }
|
|
static void trap_313(Cpu *c) { nvn_trap(c, 313); }
|
|
static void trap_314(Cpu *c) { nvn_trap(c, 314); }
|
|
static void trap_315(Cpu *c) { nvn_trap(c, 315); }
|
|
static void trap_316(Cpu *c) { nvn_trap(c, 316); }
|
|
static void trap_317(Cpu *c) { nvn_trap(c, 317); }
|
|
static void trap_318(Cpu *c) { nvn_trap(c, 318); }
|
|
static void trap_319(Cpu *c) { nvn_trap(c, 319); }
|
|
static void trap_320(Cpu *c) { nvn_trap(c, 320); }
|
|
static void trap_321(Cpu *c) { nvn_trap(c, 321); }
|
|
static void trap_322(Cpu *c) { nvn_trap(c, 322); }
|
|
static void trap_323(Cpu *c) { nvn_trap(c, 323); }
|
|
static void trap_324(Cpu *c) { nvn_trap(c, 324); }
|
|
static void trap_325(Cpu *c) { nvn_trap(c, 325); }
|
|
static void trap_326(Cpu *c) { nvn_trap(c, 326); }
|
|
static void trap_327(Cpu *c) { nvn_trap(c, 327); }
|
|
static void trap_328(Cpu *c) { nvn_trap(c, 328); }
|
|
static void trap_329(Cpu *c) { nvn_trap(c, 329); }
|
|
static void trap_330(Cpu *c) { nvn_trap(c, 330); }
|
|
static void trap_331(Cpu *c) { nvn_trap(c, 331); }
|
|
static void trap_332(Cpu *c) { nvn_trap(c, 332); }
|
|
static void trap_333(Cpu *c) { nvn_trap(c, 333); }
|
|
static void trap_334(Cpu *c) { nvn_trap(c, 334); }
|
|
static void trap_335(Cpu *c) { nvn_trap(c, 335); }
|
|
static void trap_336(Cpu *c) { nvn_trap(c, 336); }
|
|
static void trap_337(Cpu *c) { nvn_trap(c, 337); }
|
|
static void trap_338(Cpu *c) { nvn_trap(c, 338); }
|
|
static void trap_339(Cpu *c) { nvn_trap(c, 339); }
|
|
static void trap_340(Cpu *c) { nvn_trap(c, 340); }
|
|
static void trap_341(Cpu *c) { nvn_trap(c, 341); }
|
|
static void trap_342(Cpu *c) { nvn_trap(c, 342); }
|
|
static void trap_343(Cpu *c) { nvn_trap(c, 343); }
|
|
static void trap_344(Cpu *c) { nvn_trap(c, 344); }
|
|
static void trap_345(Cpu *c) { nvn_trap(c, 345); }
|
|
static void trap_346(Cpu *c) { nvn_trap(c, 346); }
|
|
static void trap_347(Cpu *c) { nvn_trap(c, 347); }
|
|
static void trap_348(Cpu *c) { nvn_trap(c, 348); }
|
|
static void trap_349(Cpu *c) { nvn_trap(c, 349); }
|
|
static void trap_350(Cpu *c) { nvn_trap(c, 350); }
|
|
static void trap_351(Cpu *c) { nvn_trap(c, 351); }
|
|
static void trap_352(Cpu *c) { nvn_trap(c, 352); }
|
|
static void trap_353(Cpu *c) { nvn_trap(c, 353); }
|
|
static void trap_354(Cpu *c) { nvn_trap(c, 354); }
|
|
static void trap_355(Cpu *c) { nvn_trap(c, 355); }
|
|
static void trap_356(Cpu *c) { nvn_trap(c, 356); }
|
|
static void trap_357(Cpu *c) { nvn_trap(c, 357); }
|
|
static void trap_358(Cpu *c) { nvn_trap(c, 358); }
|
|
static void trap_359(Cpu *c) { nvn_trap(c, 359); }
|
|
static void trap_360(Cpu *c) { nvn_trap(c, 360); }
|
|
static void trap_361(Cpu *c) { nvn_trap(c, 361); }
|
|
static void trap_362(Cpu *c) { nvn_trap(c, 362); }
|
|
static void trap_363(Cpu *c) { nvn_trap(c, 363); }
|
|
static void trap_364(Cpu *c) { nvn_trap(c, 364); }
|
|
static void trap_365(Cpu *c) { nvn_trap(c, 365); }
|
|
static void trap_366(Cpu *c) { nvn_trap(c, 366); }
|
|
static void trap_367(Cpu *c) { nvn_trap(c, 367); }
|
|
static void trap_368(Cpu *c) { nvn_trap(c, 368); }
|
|
static void trap_369(Cpu *c) { nvn_trap(c, 369); }
|
|
static void trap_370(Cpu *c) { nvn_trap(c, 370); }
|
|
static void trap_371(Cpu *c) { nvn_trap(c, 371); }
|
|
static void trap_372(Cpu *c) { nvn_trap(c, 372); }
|
|
static void trap_373(Cpu *c) { nvn_trap(c, 373); }
|
|
static void trap_374(Cpu *c) { nvn_trap(c, 374); }
|
|
static void trap_375(Cpu *c) { nvn_trap(c, 375); }
|
|
static void trap_376(Cpu *c) { nvn_trap(c, 376); }
|
|
static void trap_377(Cpu *c) { nvn_trap(c, 377); }
|
|
static void trap_378(Cpu *c) { nvn_trap(c, 378); }
|
|
static void trap_379(Cpu *c) { nvn_trap(c, 379); }
|
|
static void trap_380(Cpu *c) { nvn_trap(c, 380); }
|
|
static void trap_381(Cpu *c) { nvn_trap(c, 381); }
|
|
static void trap_382(Cpu *c) { nvn_trap(c, 382); }
|
|
static void trap_383(Cpu *c) { nvn_trap(c, 383); }
|
|
static void trap_384(Cpu *c) { nvn_trap(c, 384); }
|
|
static void trap_385(Cpu *c) { nvn_trap(c, 385); }
|
|
static void trap_386(Cpu *c) { nvn_trap(c, 386); }
|
|
static void trap_387(Cpu *c) { nvn_trap(c, 387); }
|
|
static void trap_388(Cpu *c) { nvn_trap(c, 388); }
|
|
static void trap_389(Cpu *c) { nvn_trap(c, 389); }
|
|
static void trap_390(Cpu *c) { nvn_trap(c, 390); }
|
|
static void trap_391(Cpu *c) { nvn_trap(c, 391); }
|
|
static void trap_392(Cpu *c) { nvn_trap(c, 392); }
|
|
static void trap_393(Cpu *c) { nvn_trap(c, 393); }
|
|
static void trap_394(Cpu *c) { nvn_trap(c, 394); }
|
|
static void trap_395(Cpu *c) { nvn_trap(c, 395); }
|
|
static void trap_396(Cpu *c) { nvn_trap(c, 396); }
|
|
static void trap_397(Cpu *c) { nvn_trap(c, 397); }
|
|
static void trap_398(Cpu *c) { nvn_trap(c, 398); }
|
|
static void trap_399(Cpu *c) { nvn_trap(c, 399); }
|
|
static void trap_400(Cpu *c) { nvn_trap(c, 400); }
|
|
static void trap_401(Cpu *c) { nvn_trap(c, 401); }
|
|
static void trap_402(Cpu *c) { nvn_trap(c, 402); }
|
|
static void trap_403(Cpu *c) { nvn_trap(c, 403); }
|
|
static void trap_404(Cpu *c) { nvn_trap(c, 404); }
|
|
static void trap_405(Cpu *c) { nvn_trap(c, 405); }
|
|
static void trap_406(Cpu *c) { nvn_trap(c, 406); }
|
|
static void trap_407(Cpu *c) { nvn_trap(c, 407); }
|
|
static void trap_408(Cpu *c) { nvn_trap(c, 408); }
|
|
static void trap_409(Cpu *c) { nvn_trap(c, 409); }
|
|
static void trap_410(Cpu *c) { nvn_trap(c, 410); }
|
|
static void trap_411(Cpu *c) { nvn_trap(c, 411); }
|
|
static void trap_412(Cpu *c) { nvn_trap(c, 412); }
|
|
static void trap_413(Cpu *c) { nvn_trap(c, 413); }
|
|
static void trap_414(Cpu *c) { nvn_trap(c, 414); }
|
|
static void trap_415(Cpu *c) { nvn_trap(c, 415); }
|
|
static void trap_416(Cpu *c) { nvn_trap(c, 416); }
|
|
static void trap_417(Cpu *c) { nvn_trap(c, 417); }
|
|
static void trap_418(Cpu *c) { nvn_trap(c, 418); }
|
|
static void trap_419(Cpu *c) { nvn_trap(c, 419); }
|
|
static void trap_420(Cpu *c) { nvn_trap(c, 420); }
|
|
static void trap_421(Cpu *c) { nvn_trap(c, 421); }
|
|
static void trap_422(Cpu *c) { nvn_trap(c, 422); }
|
|
static void trap_423(Cpu *c) { nvn_trap(c, 423); }
|
|
static void trap_424(Cpu *c) { nvn_trap(c, 424); }
|
|
static void trap_425(Cpu *c) { nvn_trap(c, 425); }
|
|
static void trap_426(Cpu *c) { nvn_trap(c, 426); }
|
|
static void trap_427(Cpu *c) { nvn_trap(c, 427); }
|
|
static void trap_428(Cpu *c) { nvn_trap(c, 428); }
|
|
static void trap_429(Cpu *c) { nvn_trap(c, 429); }
|
|
static void trap_430(Cpu *c) { nvn_trap(c, 430); }
|
|
static void trap_431(Cpu *c) { nvn_trap(c, 431); }
|
|
static void trap_432(Cpu *c) { nvn_trap(c, 432); }
|
|
static void trap_433(Cpu *c) { nvn_trap(c, 433); }
|
|
static void trap_434(Cpu *c) { nvn_trap(c, 434); }
|
|
static void trap_435(Cpu *c) { nvn_trap(c, 435); }
|
|
static void trap_436(Cpu *c) { nvn_trap(c, 436); }
|
|
static void trap_437(Cpu *c) { nvn_trap(c, 437); }
|
|
static void trap_438(Cpu *c) { nvn_trap(c, 438); }
|
|
static void trap_439(Cpu *c) { nvn_trap(c, 439); }
|
|
static void trap_440(Cpu *c) { nvn_trap(c, 440); }
|
|
static void trap_441(Cpu *c) { nvn_trap(c, 441); }
|
|
static void trap_442(Cpu *c) { nvn_trap(c, 442); }
|
|
static void trap_443(Cpu *c) { nvn_trap(c, 443); }
|
|
static void trap_444(Cpu *c) { nvn_trap(c, 444); }
|
|
static void trap_445(Cpu *c) { nvn_trap(c, 445); }
|
|
static void trap_446(Cpu *c) { nvn_trap(c, 446); }
|
|
static void trap_447(Cpu *c) { nvn_trap(c, 447); }
|
|
static void trap_448(Cpu *c) { nvn_trap(c, 448); }
|
|
static void trap_449(Cpu *c) { nvn_trap(c, 449); }
|
|
static void trap_450(Cpu *c) { nvn_trap(c, 450); }
|
|
static void trap_451(Cpu *c) { nvn_trap(c, 451); }
|
|
static void trap_452(Cpu *c) { nvn_trap(c, 452); }
|
|
static void trap_453(Cpu *c) { nvn_trap(c, 453); }
|
|
static void trap_454(Cpu *c) { nvn_trap(c, 454); }
|
|
static void trap_455(Cpu *c) { nvn_trap(c, 455); }
|
|
static void trap_456(Cpu *c) { nvn_trap(c, 456); }
|
|
static void trap_457(Cpu *c) { nvn_trap(c, 457); }
|
|
static void trap_458(Cpu *c) { nvn_trap(c, 458); }
|
|
static void trap_459(Cpu *c) { nvn_trap(c, 459); }
|
|
static void trap_460(Cpu *c) { nvn_trap(c, 460); }
|
|
static void trap_461(Cpu *c) { nvn_trap(c, 461); }
|
|
static void trap_462(Cpu *c) { nvn_trap(c, 462); }
|
|
static void trap_463(Cpu *c) { nvn_trap(c, 463); }
|
|
static void trap_464(Cpu *c) { nvn_trap(c, 464); }
|
|
static void trap_465(Cpu *c) { nvn_trap(c, 465); }
|
|
static void trap_466(Cpu *c) { nvn_trap(c, 466); }
|
|
static void trap_467(Cpu *c) { nvn_trap(c, 467); }
|
|
static void trap_468(Cpu *c) { nvn_trap(c, 468); }
|
|
static void trap_469(Cpu *c) { nvn_trap(c, 469); }
|
|
static void trap_470(Cpu *c) { nvn_trap(c, 470); }
|
|
static void trap_471(Cpu *c) { nvn_trap(c, 471); }
|
|
static void trap_472(Cpu *c) { nvn_trap(c, 472); }
|
|
static void trap_473(Cpu *c) { nvn_trap(c, 473); }
|
|
static void trap_474(Cpu *c) { nvn_trap(c, 474); }
|
|
static void trap_475(Cpu *c) { nvn_trap(c, 475); }
|
|
static void trap_476(Cpu *c) { nvn_trap(c, 476); }
|
|
static void trap_477(Cpu *c) { nvn_trap(c, 477); }
|
|
static void trap_478(Cpu *c) { nvn_trap(c, 478); }
|
|
static void trap_479(Cpu *c) { nvn_trap(c, 479); }
|
|
static void trap_480(Cpu *c) { nvn_trap(c, 480); }
|
|
static void trap_481(Cpu *c) { nvn_trap(c, 481); }
|
|
static void trap_482(Cpu *c) { nvn_trap(c, 482); }
|
|
static void trap_483(Cpu *c) { nvn_trap(c, 483); }
|
|
static void trap_484(Cpu *c) { nvn_trap(c, 484); }
|
|
static void trap_485(Cpu *c) { nvn_trap(c, 485); }
|
|
static void trap_486(Cpu *c) { nvn_trap(c, 486); }
|
|
static void trap_487(Cpu *c) { nvn_trap(c, 487); }
|
|
static void trap_488(Cpu *c) { nvn_trap(c, 488); }
|
|
static void trap_489(Cpu *c) { nvn_trap(c, 489); }
|
|
static void trap_490(Cpu *c) { nvn_trap(c, 490); }
|
|
static void trap_491(Cpu *c) { nvn_trap(c, 491); }
|
|
static void trap_492(Cpu *c) { nvn_trap(c, 492); }
|
|
static void trap_493(Cpu *c) { nvn_trap(c, 493); }
|
|
static void trap_494(Cpu *c) { nvn_trap(c, 494); }
|
|
static void trap_495(Cpu *c) { nvn_trap(c, 495); }
|
|
static void trap_496(Cpu *c) { nvn_trap(c, 496); }
|
|
static void trap_497(Cpu *c) { nvn_trap(c, 497); }
|
|
static void trap_498(Cpu *c) { nvn_trap(c, 498); }
|
|
static void trap_499(Cpu *c) { nvn_trap(c, 499); }
|
|
static void trap_500(Cpu *c) { nvn_trap(c, 500); }
|
|
static void trap_501(Cpu *c) { nvn_trap(c, 501); }
|
|
static void trap_502(Cpu *c) { nvn_trap(c, 502); }
|
|
static void trap_503(Cpu *c) { nvn_trap(c, 503); }
|
|
static void trap_504(Cpu *c) { nvn_trap(c, 504); }
|
|
static void trap_505(Cpu *c) { nvn_trap(c, 505); }
|
|
static void trap_506(Cpu *c) { nvn_trap(c, 506); }
|
|
static void trap_507(Cpu *c) { nvn_trap(c, 507); }
|
|
static void trap_508(Cpu *c) { nvn_trap(c, 508); }
|
|
static void trap_509(Cpu *c) { nvn_trap(c, 509); }
|
|
static void trap_510(Cpu *c) { nvn_trap(c, 510); }
|
|
static void trap_511(Cpu *c) { nvn_trap(c, 511); }
|
|
|
|
static int by_name(const void *a, const void *b) { return strcmp(((const Proc *)a)->name, ((const Proc *)b)->name); }
|
|
|
|
void nvn_procs_register(void) {
|
|
if (nprocs) return;
|
|
#define NVN_PROC(n) procs[nprocs++] = (Proc){#n, hostfn_register("nvn:" #n, nvnp_##n)};
|
|
#include "nvn_procs.inc"
|
|
#undef NVN_PROC
|
|
qsort(procs, (size_t)nprocs, sizeof *procs, by_name);
|
|
static const GuestFn traps[TRAP_COUNT] = {
|
|
trap_0, trap_1, trap_2, trap_3, trap_4, trap_5, trap_6, trap_7,
|
|
trap_8, trap_9, trap_10, trap_11, trap_12, trap_13, trap_14, trap_15,
|
|
trap_16, trap_17, trap_18, trap_19, trap_20, trap_21, trap_22, trap_23,
|
|
trap_24, trap_25, trap_26, trap_27, trap_28, trap_29, trap_30, trap_31,
|
|
trap_32, trap_33, trap_34, trap_35, trap_36, trap_37, trap_38, trap_39,
|
|
trap_40, trap_41, trap_42, trap_43, trap_44, trap_45, trap_46, trap_47,
|
|
trap_48, trap_49, trap_50, trap_51, trap_52, trap_53, trap_54, trap_55,
|
|
trap_56, trap_57, trap_58, trap_59, trap_60, trap_61, trap_62, trap_63,
|
|
trap_64, trap_65, trap_66, trap_67, trap_68, trap_69, trap_70, trap_71,
|
|
trap_72, trap_73, trap_74, trap_75, trap_76, trap_77, trap_78, trap_79,
|
|
trap_80, trap_81, trap_82, trap_83, trap_84, trap_85, trap_86, trap_87,
|
|
trap_88, trap_89, trap_90, trap_91, trap_92, trap_93, trap_94, trap_95,
|
|
trap_96, trap_97, trap_98, trap_99, trap_100, trap_101, trap_102, trap_103,
|
|
trap_104, trap_105, trap_106, trap_107, trap_108, trap_109, trap_110, trap_111,
|
|
trap_112, trap_113, trap_114, trap_115, trap_116, trap_117, trap_118, trap_119,
|
|
trap_120, trap_121, trap_122, trap_123, trap_124, trap_125, trap_126, trap_127,
|
|
trap_128, trap_129, trap_130, trap_131, trap_132, trap_133, trap_134, trap_135,
|
|
trap_136, trap_137, trap_138, trap_139, trap_140, trap_141, trap_142, trap_143,
|
|
trap_144, trap_145, trap_146, trap_147, trap_148, trap_149, trap_150, trap_151,
|
|
trap_152, trap_153, trap_154, trap_155, trap_156, trap_157, trap_158, trap_159,
|
|
trap_160, trap_161, trap_162, trap_163, trap_164, trap_165, trap_166, trap_167,
|
|
trap_168, trap_169, trap_170, trap_171, trap_172, trap_173, trap_174, trap_175,
|
|
trap_176, trap_177, trap_178, trap_179, trap_180, trap_181, trap_182, trap_183,
|
|
trap_184, trap_185, trap_186, trap_187, trap_188, trap_189, trap_190, trap_191,
|
|
trap_192, trap_193, trap_194, trap_195, trap_196, trap_197, trap_198, trap_199,
|
|
trap_200, trap_201, trap_202, trap_203, trap_204, trap_205, trap_206, trap_207,
|
|
trap_208, trap_209, trap_210, trap_211, trap_212, trap_213, trap_214, trap_215,
|
|
trap_216, trap_217, trap_218, trap_219, trap_220, trap_221, trap_222, trap_223,
|
|
trap_224, trap_225, trap_226, trap_227, trap_228, trap_229, trap_230, trap_231,
|
|
trap_232, trap_233, trap_234, trap_235, trap_236, trap_237, trap_238, trap_239,
|
|
trap_240, trap_241, trap_242, trap_243, trap_244, trap_245, trap_246, trap_247,
|
|
trap_248, trap_249, trap_250, trap_251, trap_252, trap_253, trap_254, trap_255,
|
|
trap_256, trap_257, trap_258, trap_259, trap_260, trap_261, trap_262, trap_263,
|
|
trap_264, trap_265, trap_266, trap_267, trap_268, trap_269, trap_270, trap_271,
|
|
trap_272, trap_273, trap_274, trap_275, trap_276, trap_277, trap_278, trap_279,
|
|
trap_280, trap_281, trap_282, trap_283, trap_284, trap_285, trap_286, trap_287,
|
|
trap_288, trap_289, trap_290, trap_291, trap_292, trap_293, trap_294, trap_295,
|
|
trap_296, trap_297, trap_298, trap_299, trap_300, trap_301, trap_302, trap_303,
|
|
trap_304, trap_305, trap_306, trap_307, trap_308, trap_309, trap_310, trap_311,
|
|
trap_312, trap_313, trap_314, trap_315, trap_316, trap_317, trap_318, trap_319,
|
|
trap_320, trap_321, trap_322, trap_323, trap_324, trap_325, trap_326, trap_327,
|
|
trap_328, trap_329, trap_330, trap_331, trap_332, trap_333, trap_334, trap_335,
|
|
trap_336, trap_337, trap_338, trap_339, trap_340, trap_341, trap_342, trap_343,
|
|
trap_344, trap_345, trap_346, trap_347, trap_348, trap_349, trap_350, trap_351,
|
|
trap_352, trap_353, trap_354, trap_355, trap_356, trap_357, trap_358, trap_359,
|
|
trap_360, trap_361, trap_362, trap_363, trap_364, trap_365, trap_366, trap_367,
|
|
trap_368, trap_369, trap_370, trap_371, trap_372, trap_373, trap_374, trap_375,
|
|
trap_376, trap_377, trap_378, trap_379, trap_380, trap_381, trap_382, trap_383,
|
|
trap_384, trap_385, trap_386, trap_387, trap_388, trap_389, trap_390, trap_391,
|
|
trap_392, trap_393, trap_394, trap_395, trap_396, trap_397, trap_398, trap_399,
|
|
trap_400, trap_401, trap_402, trap_403, trap_404, trap_405, trap_406, trap_407,
|
|
trap_408, trap_409, trap_410, trap_411, trap_412, trap_413, trap_414, trap_415,
|
|
trap_416, trap_417, trap_418, trap_419, trap_420, trap_421, trap_422, trap_423,
|
|
trap_424, trap_425, trap_426, trap_427, trap_428, trap_429, trap_430, trap_431,
|
|
trap_432, trap_433, trap_434, trap_435, trap_436, trap_437, trap_438, trap_439,
|
|
trap_440, trap_441, trap_442, trap_443, trap_444, trap_445, trap_446, trap_447,
|
|
trap_448, trap_449, trap_450, trap_451, trap_452, trap_453, trap_454, trap_455,
|
|
trap_456, trap_457, trap_458, trap_459, trap_460, trap_461, trap_462, trap_463,
|
|
trap_464, trap_465, trap_466, trap_467, trap_468, trap_469, trap_470, trap_471,
|
|
trap_472, trap_473, trap_474, trap_475, trap_476, trap_477, trap_478, trap_479,
|
|
trap_480, trap_481, trap_482, trap_483, trap_484, trap_485, trap_486, trap_487,
|
|
trap_488, trap_489, trap_490, trap_491, trap_492, trap_493, trap_494, trap_495,
|
|
trap_496, trap_497, trap_498, trap_499, trap_500, trap_501, trap_502, trap_503,
|
|
trap_504, trap_505, trap_506, trap_507, trap_508, trap_509, trap_510, trap_511,
|
|
};
|
|
for (int i = 0; i < TRAP_COUNT; i++) {
|
|
char n[32];
|
|
snprintf(n, sizeof n, "nvn:unknown proc %d", i);
|
|
trap_addr[i] = hostfn_register(strdup(n), traps[i]);
|
|
}
|
|
}
|
|
|
|
uint64_t nvn_proc_address(const char *name) {
|
|
if (!name) return 0;
|
|
const Proc *p = bsearch(&(Proc){name, 0}, procs, (size_t)nprocs, sizeof *procs, by_name);
|
|
if (p) return p->addr;
|
|
// Unknown names get a trap (see nvn_trap), one per distinct name; NULL once the pool is used up.
|
|
static PlatMutex lock = PLAT_MUTEX_INIT;
|
|
plat_mutex_lock(&lock);
|
|
int i;
|
|
for (i = 0; i < ntraps; i++)
|
|
if (!strncmp(trap_name[i], name, sizeof trap_name[i] - 1)) break;
|
|
int fresh = i == ntraps && ntraps < TRAP_COUNT && trap_addr[0];
|
|
if (fresh) strncpy(trap_name[ntraps++], name, sizeof trap_name[0] - 1);
|
|
uint64_t a = i < ntraps ? trap_addr[i] : 0;
|
|
plat_mutex_unlock(&lock);
|
|
if (fresh) rt_log("nvn: no such proc \"%s\": a trap that logs its first call", name);
|
|
else if (!a) rt_log("nvn: no such proc \"%s\", returning NULL", name);
|
|
return a;
|
|
}
|
|
|
|
// PFNNVNGENERICFUNC nvnDeviceGetProcAddress(const NVNdevice *device, const char *name)
|
|
void nvnp_nvnDeviceGetProcAddress(Cpu *c) {
|
|
const char *name = arg_p(c, 1);
|
|
ret_x(c, nvn_proc_address(name));
|
|
}
|