Merge pull request #106 from Yotona/splice

Mostly split and named splice TUs and matched several functions
2025-02-17 05:38:37 +00:00 · 2024-11-06 21:45:37 -05:00 · 2024-11-06 21:45:37 -05:00 · 0a1c3e0cfe
commit 0a1c3e0cfe
parent 014ec19dd9 5ffdae2963
24 changed files with 1184 additions and 26 deletions
--- a/README.md
+++ b/README.md
@ -4,9 +4,9 @@
 [build-url]:https://github.com/TheOnlyZac/sly1/actions/workflows/build.yml
 [build-badge]: https://img.shields.io/github/actions/workflow/status/theonlyzac/sly1/build.yml?branch=main&label=build

-[code-progress-badge]: https://img.shields.io/endpoint?label=code&url=https%3A%2F%2Fprogress.deco.mp%2Fdata%2Fslycooper1%2Fus%2Fall%2F%3Fmode%3Dshield%26measure%3DP2
+[code-progress-badge]: https://img.shields.io/endpoint?label=progress&url=https%3A%2F%2Fprogress.deco.mp%2Fdata%2Fslycooper1%2Fus%2Fall%2F%3Fmode%3Dshield%26measure%3DP2

-[data-progress-badge]: https://img.shields.io/endpoint?label=data&url=https%3A%2F%2Fprogress.deco.mp%2Fdata%2Fslycooper1%2Fus%2Fall%2F%3Fmode%3Dshield%26measure%3Ddata
+<!--[data-progress-badge]: https://img.shields.io/endpoint?label=data&url=https%3A%2F%2Fprogress.deco.mp%2Fdata%2Fslycooper1%2Fus%2Fall%2F%3Fmode%3Dshield%26measure%3Ddata-->

 <!-- Contributors shield -->
 [contributors-url]: https://github.com/theonlyzac/sly1/graphs/contributors
@ -18,14 +18,14 @@

 <!-- Docs shield -->
 [docs-url]: https://theonlyzac.github.io/sly1
-[docs-badge]: https://img.shields.io/badge/docs-doxygen-2C4AA8
+[docs-badge]: https://img.shields.io/badge/docs-github.io-2C4AA8

 <!-- Wiki shield -->
 [wiki-url]: https://slymods.info
 [wiki-badge]: https://img.shields.io/badge/wiki-slymods.info-2C4AA8

 <!-- Shields -->
-[![Build][build-badge]][build-url] ![code-progress-badge] ![data-progress-badge] [![Contributors][contributors-badge]][contributors-url] [![Discord Channel][discord-badge]][discord-url] [![Docs][docs-badge]][docs-url] [![Wiki][wiki-badge]][wiki-url]
+[![Build][build-badge]][build-url] ![code-progress-badge] <!--![data-progress-badge]--> [![Contributors][contributors-badge]][contributors-url] [![Discord Channel][discord-badge]][discord-url] [![Docs][docs-badge]][docs-url] [![Wiki][wiki-badge]][wiki-url]

 [<img src="logo.png" style="margin:7px" align="right" width="33%" alt="Sly 1 Decompilation Logo by Cooper941">][docs-url]

--- a/config/sly1.yaml
+++ b/config/sly1.yaml
@ -56,19 +56,19 @@ segments:
    # Splice sources
    # All .cpp files
    #--------------------------------------------------------
-    - [0x13698, asm, P2/splice/bif] #MARK: P2/splice
-    - [0x19d48, asm, P2/splice/eval]
+    - [0x13698, cpp, P2/splice/bif] #MARK: P2/splice
+    - [0x19d48, cpp, P2/splice/eval]
    - [0x1b328, asm, P2/splice/frame]
-    - [0x1b678, asm, P2/splice/gc]
-    - [0x1be78, asm, P2/splice/method]
-    #- [0x1bf98, asm, P2/splice/pair]
-    - [0x1bf98, asm, P2/splice/proc]
+    - [0x1b678, cpp, P2/splice/gc]
+    - [0x1be78, cpp, P2/splice/method]
+    - [0x1beb8, cpp, P2/splice/pair]
+    - [0x1bf98, cpp, P2/splice/proc]
    - [0x1c008, cpp, P2/splice/ref]
-    - [0x1ca28, asm, P2/splice/serialize]
-    - [0x1cd28, asm, P2/splice/sidebag]
+    - [0x1ca28, cpp, P2/splice/serialize]
+    - [0x1cd28, cpp, P2/splice/sidebag]
    - [0x1cf70, cpp, P2/splice/spliceutils]
-    - [0x1d128, asm, P2/splice/splotheap]
-    - [0x1d508, asm, P2/splice/vecmat]
+    - [0x1d128, cpp, P2/splice/splotheap]
+    - [0x1d508, cpp, P2/splice/vecmat]

    #--------------------------------------------------------
    # P2 sources
@ -328,6 +328,12 @@ segments:
    - [0x118380, rodata] #MARK: rodata
    - [0x1225a0, rodata, P2/cm]
    - [0x141000, rodata] # todo
+    - [0x149FE0, .rodata, P2/splice/bif]
+    - [0x14A200, rodata] #todo: remove line and uncomment next for RefEvalAssert
+    # - [0x14A200, .rodata, P2/splice/eval] 
+    - [0x14A2F0, .rodata, P2/splice/ref]
+    - [0x14A3A0, .rodata, P2/splice/serialize]
+    - [0x14A428, rodata]

    #--------------------------------------------------------
    # Data
--- a/config/symbol_addrs.txt
+++ b/config/symbol_addrs.txt
@ -1,6 +1,8 @@
 _start = 0x100008; // type:func
 _exit = 0x1000B8; // type:func

+__builtin_delete = 0x18d778; // type:func
+memcmp = 0x1F59C4; // type:func

 ////////////////////////////////////////////////////////////////
 // Unknown file
@ -11,6 +13,27 @@ UpdateSave__FP4SAVE = 0x18bdc8; // type:func
 g_save = 0x264A40;


+////////////////////////////////////////////////////////////////
+// P2/splice/method.cpp
+////////////////////////////////////////////////////////////////
+PmethodNew__Fv              = 0x11AE78; // type:func
+
+
+////////////////////////////////////////////////////////////////
+// P2/splice/pair.cpp
+////////////////////////////////////////////////////////////////
+CloneTo__5CPairP5CPairP6CFrame  = 0x11AEB8; // type:func
+PpairNew__Fv                    = 0x11AF28; // type:func
+DeletePair__FP5CPair            = 0x11AF78; // type:func
+
+
+////////////////////////////////////////////////////////////////
+// P2/splice/proc.cpp
+////////////////////////////////////////////////////////////////
+CloneTo__5CProcP5CProcP6CFrame = 0x11af98; // type:func
+PprocNew__Fv = 0x11afc8; // type:func
+
+
 ////////////////////////////////////////////////////////////////
 // P2/splice/spliceutils.cpp
 ////////////////////////////////////////////////////////////////
@ -52,18 +75,268 @@ RefCoerceF32__4CRef = 0x11B9A8; // type:func


 ////////////////////////////////////////////////////////////////
-// P2/vecmat.cpp
+// P2/splice/eval.cpp
 ////////////////////////////////////////////////////////////////
+RefEvalSymbol__FP5CPairP6CFrame = 0x118D48; // type:func
+RefEvalSet__FP5CPairP6CFrame    = 0x118DB8; // type:func
+RefEvalDefine__FP5CPairP6CFrame = 0x118E80; // type:func
+RefEvalAssert__FP5CPairP6CFrame = 0x118F48; // type:func
+RefEvalIf__FP5CPairP6CFrame     = 0x119030; // type:func
+RefEvalOr__FP5CPairP6CFrame     = 0x119128; // type:func
+RefEvalAnd__FP5CPairP6CFrame    = 0x119218; // type:func
+RefEvalCond__FP5CPairP6CFrame   = 0x119310; // type:func
+RefEvalCase__FP5CPairP6CFrame   = 0x1194A8; // type:func
+RefEvalLet__FP5CPairP6CFrame    = 0x1196C8; // type:func
+RefEvalWhile__FP5CPairP6CFrame  = 0x119878; // type:func
+RefEvalLambda__FP5CPairP6CFrame = 0x119970; // type:func
+RefEvalLambdaBody__FP5CPairP6CFrame = 0x119A58; // type:func
+RefEvalBegin__FP5CPairP6CFrame  = 0x119AF8; // type:func
+RefEvalApply__FP5CPairP6CFrame  = 0x119BB0; // type:func
+RefEvalImport__FP5CPairP6CFrame = 0x119FA0; // type:func
+RefEval__FP5CPairP6CFrame       = 0x11A080; // type:func
+
+chzSpliceAssert                 = 0x249200; // size:0x10
+
+////////////////////////////////////////////////////////////////
+// P2/splice/bif.cpp
+////////////////////////////////////////////////////////////////
+RefOpAdd__FiP4CRefP6CFrame      = 0x112698; // type:func
+RefOpSub__FiP4CRefP6CFrame      = 0x112968; // type:func
+RefOpMult__FiP4CRefP6CFrame     = 0x112C38; // type:func
+RefOpDiv__FiP4CRefP6CFrame      = 0x113240; // type:func
+RefOpPrint__FiP4CRefP6CFrame    = 0x113730; // type:func
+RefOpPrintFrame__FiP4CRefP6CFrame = 0x113780; // type:func
+RefOpPrintSidebag__FiP4CRefP6CFrame = 0x1137D0; // type:func
+RefOpIntEqual__FiP4CRefP6CFrame = 0x113820; // type:func
+RefCmp__FP4CRef4CMPK            = 0x113888; // type:func
+RefOpL__FiP4CRefP6CFrame        = 0x1139E8; // type:func
+RefOpLE__FiP4CRefP6CFrame       = 0x113A18; // type:func
+RefOpG__FiP4CRefP6CFrame        = 0x113A48; // type:func
+RefOpGE__FiP4CRefP6CFrame       = 0x113A78; // type:func
+RefOpEqv__FiP4CRefP6CFrame      = 0x113AA8; // type:func
+RefEqualHelper__FP4CRefT0       = 0x113B60; // type:func
+RefOpEqual__FiP4CRefP6CFrame    = 0x113E48; // type:func
+RefOpIsBoolean__FiP4CRefP6CFrame = 0x113E78; // type:func
+RefOpIsNum__FiP4CRefP6CFrame    = 0x113EE0; // type:func
+RefOpIsFloat__FiP4CRefP6CFrame  = 0x113F48; // type:func
+RefOpIsInteger__FiP4CRefP6CFrame = 0x113FB0; // type:func
+RefOpIsSymbol__FiP4CRefP6CFrame = 0x114018; // type:func
+RefOpIsVector__FiP4CRefP6CFrame = 0x114080; // type:func
+RefOpIsMatrix__FiP4CRefP6CFrame = 0x1140E8; // type:func
+RefOpIsClq__FiP4CRefP6CFrame    = 0x114150; // type:func
+RefOpIsLm__FiP4CRefP6CFrame     = 0x1141B8; // type:func
+RefOpIsSmp__FiP4CRefP6CFrame    = 0x114220; // type:func
+RefOpIsList__FiP4CRefP6CFrame   = 0x114288; // type:func
+RefOpIsNull__FiP4CRefP6CFrame   = 0x114300; // type:func
+RefOpIsObject__FiP4CRefP6CFrame = 0x114360; // type:func
+RefOpIsNullObj__FiP4CRefP6CFrame = 0x1143C8; // type:func
+RefOpIsMethod__FiP4CRefP6CFrame = 0x114438; // type:func
+RefOpIsProcedure__FiP4CRefP6CFrame = 0x1144A0; // type:func
+RefOpAreNear__FiP4CRefP6CFrame  = 0x114518; // type:func
+RefOpNot__FiP4CRefP6CFrame      = 0x1145C8; // type:func
+RefOpCons__FiP4CRefP6CFrame     = 0x114638; // type:func
+RefOpCar__FiP4CRefP6CFrame      = 0x1146E0; // type:func
+RefOpCdr__FiP4CRefP6CFrame      = 0x114740; // type:func
+RefOpSetCadr__FiP4CRefP6CFrame4BIFK = 0x1147B8; // type:func
+RefOpSetCar__FiP4CRefP6CFrame   = 0x114858; // type:func
+RefOpSetCdr__FiP4CRefP6CFrame   = 0x114888; // type:func
+RefOpLength__FiP4CRefP6CFrame   = 0x1148B8; // type:func
+RefOpNth__FiP4CRefP6CFrame      = 0x114950; // type:func
+RefOpIsMember__FiP4CRefP6CFrame = 0x1149F0; // type:func
+RefOpList__FiP4CRefP6CFrame     = 0x114B80; // type:func
+RefOpAppend__FiP4CRefP6CFrame   = 0x114BB0; // type:func
+RefOpMap__FiP4CRefP6CFrame      = 0x114D18; // type:func
+RefOpFilter__FiP4CRefP6CFrame   = 0x114F48; // type:func
+RefOpForEach__FiP4CRefP6CFrame  = 0x1151C0; // type:func
+RefOpEval__FiP4CRefP6CFrame     = 0x115398; // type:func
+RefOpVector__FiP4CRefP6CFrame   = 0x115440; // type:func
+RefOpMatrix__FiP4CRefP6CFrame   = 0x115510; // type:func
+RefOpSetMusicRegister__FiP4CRefP6CFrame = 0x1156B0; // type:func
+RefOpClq__FiP4CRefP6CFrame      = 0x115710; // type:func
+RefOpLm__FiP4CRefP6CFrame       = 0x1157E0; // type:func
+RefOpSmp__FiP4CRefP6CFrame      = 0x1158B8; // type:func
+RefOpGetElement__FiP4CRefP6CFrame = 0x1159B8; // type:func
+RefOpRandomSeed__FiP4CRefP6CFrame = 0x115B78; // type:func
+RefOpRandom__FiP4CRefP6CFrame   = 0x115C00; // type:func
+RefUfo__FP4CRef4UFOK            = 0x115CA0; // type:func
+RefOpSqrt__FiP4CRefP6CFrame     = 0x115D48; // type:func
+RefOpSin__FiP4CRefP6CFrame      = 0x115D78; // type:func
+RefOpCos__FiP4CRefP6CFrame      = 0x115DA8; // type:func
+RefOpTan__FiP4CRefP6CFrame      = 0x115DD8; // type:func
+RefOpAsin__FiP4CRefP6CFrame     = 0x115E08; // type:func
+RefOpAcos__FiP4CRefP6CFrame     = 0x115E38; // type:func
+RefOpAtan__FiP4CRefP6CFrame     = 0x115E68; // type:func
+RefOpRadNormalize__FiP4CRefP6CFrame = 0x115E98; // type:func
+RefOpAtan2__FiP4CRefP6CFrame    = 0x115EC8; // type:func
+RefOpVectorDotProduct__FiP4CRefP6CFrame = 0x115F70; // type:func
+RefOpVectorCrossProduct__FiP4CRefP6CFrame = 0x115FF8; // type:func
+RefOpVectorLth__FiP4CRefP6CFrame = 0x116080; // type:func
+RefOpVectorDistance__FiP4CRefP6CFrame = 0x116108; // type:func
+RefOpVectorDistanceSquared__FiP4CRefP6CFrame = 0x1161F8; // type:func
+RefOpVectorNormalize__FiP4CRefP6CFrame = 0x1162D0; // type:func
+RefOpVectorProjectNormal__FiP4CRefP6CFrame  = 0x116400; // type:func
+RefOpVectorProjectTangent__FiP4CRefP6CFrame = 0x116490; // type:func
+RefOpVectorBallisticVelocity__FiP4CRefP6CFrame = 0x116520; // type:func
+RefOpVectorRadianNormal__FiP4CRefP6CFrame = 0x116600; // type:func
+RefOpMatrixTranspose__FiP4CRefP6CFrame = 0x1166C0; // type:func
+RefOpMatrixInvert__FiP4CRefP6CFrame = 0x116740; // type:func
+RefOpMatrixCalculateDmat__FiP4CRefP6CFrame = 0x1167C0; // type:func
+RefOpMatrixInterpolateRotate__FiP4CRefP6CFrame = 0x116840; // type:func
+RefOpMatrixDecomposeToTranslate__FiP4CRefP6CFrame = 0x116978; // type:func
+RefOpMatrixDecomposeToRotate__FiP4CRefP6CFrame = 0x1169E8; // type:func
+RefOpMatrixDecomposeToEuler__FiP4CRefP6CFrame = 0x116A88; // type:func
+RefOpMatrixDecomposeToRadianNormal__FiP4CRefP6CFrame = 0x116B08; // type:func
+RefOpMatrixLookAt__FiP4CRefP6CFrame = 0x116BC8; // type:func
+RefOpMatrixTiltUpright__FiP4CRefP6CFrame = 0x116C80; // type:func
+RefOpClqEvaluate__FiP4CRefP6CFrame = 0x116D20; // type:func
+RefOpClqEvaluateLm__FiP4CRefP6CFrame = 0x116DC8; // type:func
+RefOpClqFit__FiP4CRefP6CFrame   = 0x116EA8; // type:func
+RefOpLmLimit__FiP4CRefP6CFrame  = 0x116FE8; // type:func
+RefOpLmCheck__FiP4CRefP6CFrame  = 0x117080; // type:func
+RefOpFloor__FiP4CRefP6CFrame    = 0x117118; // type:func
+RefOpCeiling__FiP4CRefP6CFrame  = 0x117180; // type:func
+RefOpRound__FiP4CRefP6CFrame    = 0x1171F0; // type:func
+RefOpTruncate__FiP4CRefP6CFrame = 0x117260; // type:func
+RefOpAbs__FiP4CRefP6CFrame      = 0x1172C8; // type:func
+RefOpMaximum__FiP4CRefP6CFrame  = 0x117360; // type:func
+RefOpMinimum__FiP4CRefP6CFrame  = 0x117478; // type:func
+RefOpModulo__FiP4CRefP6CFrame   = 0x117598; // type:func
+RefOpCurrentTime__FiP4CRefP6CFrame = 0x117610; // type:func
+RefOpScheduleCallback__FiP4CRefP6CFrame = 0x117668; // type:func
+RefOpDeferObjectUpdate__FiP4CRefP6CFrame = 0x117880; // type:func
+RefOpObjectOption__FiP4CRefP6CFrame4BIFK = 0x117910; // type:func
+RefOpAddO__FiP4CRefP6CFrame     = 0x117A30; // type:func
+RefOpEnsureO__FiP4CRefP6CFrame  = 0x117A60; // type:func
+RefOpSetO__FiP4CRefP6CFrame     = 0x117A90; // type:func
+RefOpGetO__FiP4CRefP6CFrame     = 0x117AC0; // type:func
+RefPairFromAplo__FiPP2LO        = 0x117AF0; // type:func
+RefOpFindObject__FiP4CRefP6CFrame = 0x117BC8; // type:func
+RefOpFindObjects__FiP4CRefP6CFrame = 0x117C48; // type:func
+RefOpFindNearestObject__FiP4CRefP6CFrame = 0x117D00; // type:func
+RefOpFindNearestObjects__FiP4CRefP6CFrame = 0x117D78; // type:func
+RefOpFindPlayerObject__FiP4CRefP6CFrame = 0x117E20; // type:func
+RefOpFindWorldObject__FiP4CRefP6CFrame = 0x117E78; // type:func
+RefOpFindCameraObject__FiP4CRefP6CFrame = 0x117ED0; // type:func
+RefOpFindClassObjects__FiP4CRefP6CFrame = 0x117F28; // type:func
+RefOpFindObjectsInBoundingBox__FiP4CRefP6CFrame = 0x117FE0; // type:func
+RefOpFindObjectsInBoundingSphere__FiP4CRefP6CFrame = 0x1180C0; // type:func
+RefOpHitTestObjectsImpl__F4BIFKiP4CRefP6CFrame = 0x118198; // type:func
+RefOpHitTestObjects__FiP4CRefP6CFrame = 0x1183B8; // type:func
+RefOpHitTestObjectsFirst__FiP4CRefP6CFrame = 0x118458; // type:func
+RefOpConvertObjectPosition__FiP4CRefP6CFrame = 0x1184F8; // type:func
+RefOpConvertObjectVector__FiP4CRefP6CFrame = 0x118580; // type:func
+RefOpConvertObjectMatrix__FiP4CRefP6CFrame = 0x118608; // type:func
+RefOpNearClipCenter__FiP4CRefP6CFrame = 0x118698; // type:func
+RefOpStartSound__FiP4CRefP6CFrame = 0x118720; // type:func
+RefOpStopSound__FiP4CRefP6CFrame = 0x1187E8; // type:func
+RefOpStartRumble__FiP4CRefP6CFrame = 0x118850; // type:func
+RefOpEmitSmokeCloud__FiP4CRefP6CFrame = 0x1188F0; // type:func
+RefOpPredictAnimationEffect__FiP4CRefP6CFrame = 0x118988; // type:func
+__8VU_FLOATf                    = 0x118CF0; // type:func
+__9VU_VECTORRC6VECTOR           = 0x118D10; // type:func
+__as__6VECTORG9VU_VECTOR        = 0x118D20; // type:func
+__ml__FG8VU_FLOATG9VU_VECTOR    = 0x118D30; // type:func
+
+
+////////////////////////////////////////////////////////////////
+// P2/splice/frame.cpp
+////////////////////////////////////////////////////////////////
+SetSingleParent__6CFrameP6CFrame = 0x11a328; // type:func
+AddParent__6CFrameP6CFrame = 0x11A338; // type:func
+RefAddBinding__6CFrameUiP4CRef = 0x11A358; // type:func
+RefSetBinding__6CFrameUiP4CRef = 0x11A400; // type:func
+FFindBinding__6CFrameUiiP4CRef = 0x11A498; // type:func
+PrefFindBinding__6CFrameUii = 0x11A4D8; // type:func
+CloneTo__6CFrameP6CFrame = 0x11A5B0; // type:func
+PframeNew__Fv = 0x11A630; // type:func
+DeleteFrame__FP6CFrame          = 0x11A670; // type:func
+
+
+////////////////////////////////////////////////////////////////
+// P2/splice/gc.cpp
+////////////////////////////////////////////////////////////////
+__3CGc                          = 0x11A678; // type:func
+_$_3CGc                         = 0x11A680; // type:func
+Startup__3CGc                   = 0x11A6A8; // type:func
+Shutdown__3CGc                  = 0x11A6B8; // type:func
+AddRootFrame__3CGcP6CFrame      = 0x11A6C0; // type:func
+AddRootSidebag__3CGcP8CSidebag  = 0x11A708; // type:func
+PushFrame__3CGcP6CFrame         = 0x11A728; // type:func
+PframePop__3CGc                 = 0x11A748; // type:func
+PushPair__3CGcP5CPair           = 0x11A770; // type:func
+PpairPop__3CGc                  = 0x11A790; // type:func
+PushProc__3CGcP5CProc           = 0x11A7B8; // type:func
+PprocPop__3CGc                  = 0x11A7D8; // type:func
+UpdateRecyclable__3CGc          = 0x11A800; // type:func
+MarkLiveObjects__3CGc           = 0x11A850; // type:func
+Collect__3CGc                   = 0x11AB58; // type:func
+__static_initialization_and_destruction_0 = 0x11ADF8; // type:func
+_GLOBAL_$I$g_gc                 = 0x11AE38; // type:func
+_GLOBAL_$D$g_gc                 = 0x11AE58; // type:func
+
+g_gc                            = 0x259F38; // size:0x2314
+
+
+////////////////////////////////////////////////////////////////
+// P2/splice/sidebag.cpp
+////////////////////////////////////////////////////////////////
+RefAddBinding__8CSidebagiP4CRef = 0x11BD28; // type:func
+RefSetBinding__8CSidebagiP4CRef = 0x11BDD0; // type:func
+FFindBinding__8CSidebagiP4CRef  = 0x11BE90; // type:func
+CloneTo__8CSidebagP8CSidebag    = 0x11BEE0; // type:func
+PsidebagNew__Fv                 = 0x11BF30; // type:func
+
+
+////////////////////////////////////////////////////////////////
+// P2/splice/splotheap.cpp
+////////////////////////////////////////////////////////////////
+Startup__10CSplotheapii         = 0x11C128; // type:func
+Shutdown__10CSplotheap          = 0x11C1D0; // type:func
+PvAllocUnsafe__10CSplotheap     = 0x11C1D8; // type:func
+PvAllocClear__10CSplotheap      = 0x11C240; // type:func
+PsplotLookup__10CSplotheapi     = 0x11C288; // type:func
+UpdateRecyclable__10CSplotheap  = 0x11C2A0; // type:func
+UnmarkAll__10CSplotheap         = 0x11C2B0; // type:func
+FreeGarbage__10CSplotheap       = 0x11C2E8; // type:func
+PvFromPsplot__FP5SPLOT          = 0x11C3B8; // type:func
+PsplotFromPv__FPv               = 0x11C3C0; // type:func
+FIsPvGarbage__FPv               = 0x11C3C8; // type:func
+MarkPvAlive__FPv                = 0x11C3F0; // type:func
+
+g_splotheapPair                 = 0x25C250; // size:0x1C
+g_splotheapFrame                = 0x25C270; // size:0x1C
+g_splotheapUnk1                 = 0x25C290; // size:0x1C
+g_splotheapProc                 = 0x25C2B0; // size:0x1C
+g_splotheapMethod               = 0x25C2D0; // size:0x1C
+
+
+////////////////////////////////////////////////////////////////
+// P2/splice/splotheap.cpp
+////////////////////////////////////////////////////////////////
+PpairSerializeIn__FP18CBinaryInputStream = 0x11BA28; // type:func
+
+
+////////////////////////////////////////////////////////////////
+// P2/splice/vecmat.cpp
+////////////////////////////////////////////////////////////////
+PvectorNew__Fv = 0x11c508; // type:func
 IncrefVector__FP6VECTOR = 0x11c580; // type:func
 DecrefVector__FP6VECTOR = 0x11c5b0; // type:func
+PmatrixNew__Fv = 0x11c618; // type:func
 IncrefMatrix__FP7MATRIX4 = 0x11c690; // type:func
 DecrefMatrix__FP7MATRIX4 = 0x11c6c0; // type:func
+DeleteMatrix__FP7MATRIX4 = 0x11c720; // type:func
+PclqNew__Fv = 0x11c748; // type:func
 IncrefClq__FP3CLQ = 0x11c7c0; // type:func
 DecrefClq__FP3CLQ = 0x11c7f0; // type:func
+PlmNew__Fv = 0x11c858; // type:func
 IncrefLm__FP2LM = 0x11c8d0; // type:func
 DecrefLm__FP2LM = 0x11c900; // type:func
+PsmpNew__Fv = 0x11c968; // type:func
 IncrefSmp__FP3SMP = 0x11c9e0; // type:func
 DecrefSmp__FP3SMP = 0x11ca20; // type:func
+StartupSpliceStructuredTypeFactories__Fv = 0x11ca90; // type:func
+ShutdownSpliceStructuredTypeFactories__Fv = 0x11cbb0; // type:func


 ////////////////////////////////////////////////////////////////
--- a/include/splice/gc.h
+++ b/include/splice/gc.h
@ -6,6 +6,46 @@

 #include "common.h"

-// ...
+class CFrame;
+class CPair;
+class CProc;
+class CSidebag;
+
+class CGc
+{
+private:
+    int m_cpframeRoot;
+    CFrame *m_apframeRoot[256];
+
+    char unk_pad[0x100];
+
+    int m_cpsidebagRoot;
+    CSidebag *m_apsidebagRoot[128];
+    int m_cpframeStack;
+    CFrame *m_apframeStack[512];
+    int m_cppairStack;
+    CPair *m_appairStack[256];
+    int m_cpprocStack;
+    CProc *m_approcStack[1024];
+
+public:
+    CGc();
+    ~CGc();
+    void Startup();
+    void Shutdown();
+    void AddRootFrame(CFrame *pframe);
+    void AddRootSidebag(CSidebag *psidebag);
+    void PushFrame(CFrame *pframe);
+    CFrame *PframePop();
+    void PushPair(CPair *ppair);
+    CPair *PpairPop();
+    void PushProc(CProc *pproc);
+    CProc *PprocPop();
+    void UpdateRecyclable();
+    void MarkLiveObjects();
+    void Collect();
+};
+
+// static CGc g_gc;

 #endif // SPLICE_GC_H
--- a/include/splice/method.h
+++ b/include/splice/method.h
@ -6,14 +6,18 @@

 #include "common.h"

+struct BASIC;
+
 /**
 * @class CMethod
- *
- * @todo Fill in class.
 */
 class CMethod
 {
-    // ...
+    BASIC* m_pbasic;
+    void* m_pfnthunk; //todo: fix type?
+    int m_crefReq;
 };

+static CMethod* PMethodNew();
+
 #endif // SPLICE_METHOD_H
--- a/include/splice/pair.h
+++ b/include/splice/pair.h
@ -5,6 +5,7 @@
 #define SPLICE_PAIR_H

 #include "common.h"
+#include "splice/ref.h"

 /**
 * @class CPair
@ -13,7 +14,13 @@
 */
 class CPair
 {
-    // ...
+    CRef m_ref;
+    CPair* m_ppairNext;
+
+    void CloneTo(CPair* ppairClone, CFrame* pframeClone);
 };

+static CPair* PpairNew(void);
+static void DeletePair(CPair* ppair);
+
 #endif // SPLICE_PAIR_H
--- a/include/splice/proc.h
+++ b/include/splice/proc.h
@ -6,6 +6,9 @@

 #include "common.h"

+class CFrame;
+class CPair;
+
 /**
 * @class CProc
 *
@ -13,7 +16,17 @@
 */
 class CProc
 {
-    // ...
+private:
+    CFrame* m_pframe;
+    CPair* m_ppair;
+    int m_crefReq;
+    int m_fVarArg;
+    CPair* m_ppairCodeExpr;
+
+public:
+    void CloneTo(CProc* pprocClone, CFrame* pframeClone);
 };

+static CProc* PprocNew(void);
+
 #endif // SPLICE_PROC_H
--- a/include/splice/ref.h
+++ b/include/splice/ref.h
@ -5,13 +5,14 @@
 #define SPLICE_REF_H

 #include "common.h"
-#include <splice/pair.h>
 #include <splice/proc.h>
 #include <splice/method.h>
 #include <splice/bif.h>
 #include <basic.h>
 #include <util.h>

+class CPair;
+
 enum TAGK
 {
    TAGK_Nil = -1,
--- a/include/splice/sidebag.h
+++ b/include/splice/sidebag.h
@ -8,6 +8,8 @@

 #include "common.h"

+class CRef;
+
 // todo Find where this struct should be implemented.
 struct SBB
 {
@ -16,7 +18,10 @@ struct SBB
 class CSidebag
 {
 public:
-    //todo
+    CSidebag& RefAddBinding(int, CRef*);
+    CSidebag& RefSetBinding(int, CRef*);
+    bool FFindBinding(int, CRef*);
+    void CloneTo(CSidebag*);

 private:
    int m_csbb;
--- a/include/splice/splotheap.h
+++ b/include/splice/splotheap.h
@ -6,6 +6,45 @@

 #include "common.h"

-// ...
+typedef void (*PFNDELETE)(void *);
+
+struct SPLOT
+{
+    SPLOT *psplotNext;
+    int fAlive;
+};
+
+class CSplotheap
+{
+private:
+    int m_cb;
+    int m_c;
+    byte *m_ab;
+    SPLOT *m_psplotFree;
+    SPLOT *m_psplotAlloc;
+    SPLOT *m_psplotRecyclable;
+    PFNDELETE m_pfndelete;
+
+public:
+    void Startup(int cb, int c);
+    void Shutdown(void);
+    int PvAllocUnsafe(void);
+    void *PvAllocClear();
+    int PsplotLookup(int);
+    void UpdateRecyclable(void);
+    void UnmarkAll(void);
+    void FreeGarbage(void);
+};
+
+extern CSplotheap g_splotheapPair;
+extern CSplotheap g_splotheapFrame;
+extern CSplotheap g_splotheapUnk1;
+extern CSplotheap g_splotheapProc;
+extern CSplotheap g_splotheapMethod;
+
+static void *PvFromPsplot(SPLOT *psplot);
+static SPLOT *PsplotFromPv(void *pv);
+static bool FIsPvGarbage(void *pv);
+static void MarkPvAlive(void *pv);

 #endif // SPLICE_SPLOTHEAP_H
--- a/include/splice/vecmat.h
+++ b/include/splice/vecmat.h
@ -5,6 +5,11 @@
 #define SPLICE_VECMAT_H

 #include "common.h"
+#include <vec.h>
+#include <mat.h>
+#include <util.h>
+
+VECTOR* PvectorNew(void);

 void IncrefVector(VECTOR *pvector);

@ -22,8 +27,14 @@ void IncrefLm(LM *plm);

 void DecrefLm(LM *plm);

+SMP* PsmpNew(void);
+
 void IncrefSmp(SMP *psmp);

 void DecrefSmp(SMP *psmp);

+void StartupSpliceStructuredTypeFactories(void);
+
+void ShutdownSpliceStructuredTypeFactories(void);
+
 #endif // SPLICE_VECMAT_H
--- a/include/tmp.c
+++ b/include/tmp.c
@ -0,0 +1,78 @@
+struct save_struct;
+void DecrementSwHandsOff(SW *);
+void FUN_0018c178(save_struct *, int);
+
+extern BLOT BLOT_00272930;
+
+void SetUiUis(UI *pui, UIS uis)
+{
+    UIS newUis;
+    float uPause;
+    UIS lastUis;
+
+    newUis = uis;
+    if ((uis == UIS_Pausing) && (newUis = pui->uisPlaying, newUis == UIS_Nil))
+    {
+        newUis = uis;
+    }
+    lastUis = pui->uis;
+    if (lastUis == newUis)
+    {
+        return;
+    }
+    if (lastUis == UIS_Splash)
+    {
+    LAB_001e9778:
+        pui->uis = newUis;
+    }
+    else
+    {
+        if (lastUis == UIS_Attract)
+        {
+            g_unkblot10.pvtnote->pfnShowBlot(&g_unkblot10);
+            (*(BLOT_00272930.pvtblot)->pfnHideBlot)(0x272930);
+            (**(code **)(BLOT_00272930.achzDraw[152] + 0x3c))(0x272b98);
+            DecrementSwHandsOff(g_psw);
+            goto LAB_001e9778;
+        }
+        pui->uis = newUis;
+    }
+    pui->tUis = g_clock.tReal;
+    switch (newUis)
+    {
+    case UIS_Splash:
+    if (g_save?.field6_0x18 == 0)
+    {
+        FUN_0018c178(0x264a40, 1);
+    }
+    SetWipeWipes((WIPE *)&g_pwipe, WIPES_Idle);
+    uPause = 1.0;
+    goto LAB_001e9870;
+    case UIS_Attract:
+        SetUiUPause(pui, 1.0);
+        (*(BLOT_00272930.pvtblot)->pfnShowBlot)(0x272930);
+        (**(code **)(BLOT_00272930.achzDraw[152] + 0x38))(0x272b98);
+        IncrementSwHandsOff(g_psw);
+        vibration_flip_on();
+        break;
+    case UIS_Playing:
+        uPause = 1.0;
+        goto LAB_001e9870;
+    case UIS_Pausing:
+        SetUiUPause(pui, 1.0);
+        g_iexcHyst = 0xffffff9c;
+        break;
+    case UIS_Unpausing:
+    case 7:
+        uPause = 0.0;
+    LAB_001e9870:
+        SetUiUPause(pui, uPause);
+        break;
+    case UIS_Wiping:
+        (*(g_lifectr.pvtblot)->pfnHideBlot)(0x26c6c8);
+        (**(code **)(g_lifectr.achzDraw[158] + 0x3c))(0x26c948);
+        (*(g_keyctr.pvtblot)->pfnHideBlot)(0x26cbc8);
+        (**(code **)(g_keyctr.achzDraw[158] + 0x3c))(0x26ce48);
+    }
+    return;
+}
--- a/src/P2/splice/bif.cpp
+++ b/src/P2/splice/bif.cpp
@ -0,0 +1,276 @@
+#include "common.h"
+#include <splice/bif.h>
+#include <splice/ref.h>
+#include <splice/frame.h>
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpAdd__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpSub__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMult__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpDiv__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpPrint__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpPrintFrame__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpPrintSidebag__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIntEqual__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefCmp__FP4CRef4CMPK);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpL__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpLE__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpG__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpGE__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpEqv__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefEqualHelper__FP4CRefT0);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpEqual__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsBoolean__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsNum__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsFloat__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsInteger__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsSymbol__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsVector__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsMatrix__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsClq__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsLm__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsSmp__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsList__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsNull__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsObject__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsNullObj__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsMethod__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsProcedure__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpAreNear__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpNot__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpCons__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpCar__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpCdr__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpSetCadr__FiP4CRefP6CFrame4BIFK);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpSetCar__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpSetCdr__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpLength__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpNth__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpIsMember__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpList__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpAppend__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMap__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpFilter__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpForEach__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpEval__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpVector__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMatrix__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpSetMusicRegister__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpClq__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpLm__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpSmp__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpGetElement__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpRandomSeed__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpRandom__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefUfo__FP4CRef4UFOK);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpSqrt__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpSin__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpCos__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpTan__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpAsin__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpAcos__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpAtan__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpRadNormalize__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpAtan2__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpVectorDotProduct__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpVectorCrossProduct__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpVectorLth__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpVectorDistance__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpVectorDistanceSquared__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpVectorNormalize__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpVectorProjectNormal__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpVectorProjectTangent__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpVectorBallisticVelocity__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpVectorRadianNormal__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMatrixTranspose__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMatrixInvert__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMatrixCalculateDmat__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMatrixInterpolateRotate__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMatrixDecomposeToTranslate__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMatrixDecomposeToRotate__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMatrixDecomposeToEuler__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMatrixDecomposeToRadianNormal__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMatrixLookAt__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMatrixTiltUpright__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpClqEvaluate__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpClqEvaluateLm__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpClqFit__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpLmLimit__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpLmCheck__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpFloor__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpCeiling__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpRound__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpTruncate__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpAbs__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMaximum__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpMinimum__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpModulo__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpCurrentTime__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpScheduleCallback__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpDeferObjectUpdate__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpObjectOption__FiP4CRefP6CFrame4BIFK);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpAddO__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpEnsureO__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpSetO__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpGetO__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefPairFromAplo__FiPP2LO);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpFindObject__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpFindObjects__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpFindNearestObject__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpFindNearestObjects__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpFindPlayerObject__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpFindWorldObject__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpFindCameraObject__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpFindClassObjects__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpFindObjectsInBoundingBox__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpFindObjectsInBoundingSphere__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpHitTestObjectsImpl__F4BIFKiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpHitTestObjects__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpHitTestObjectsFirst__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpConvertObjectPosition__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpConvertObjectVector__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpConvertObjectMatrix__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpNearClipCenter__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpStartSound__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpStopSound__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpStartRumble__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpEmitSmokeCloud__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", RefOpPredictAnimationEffect__FiP4CRefP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", __8VU_FLOATf);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", __9VU_VECTORRC6VECTOR);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", __as__6VECTORG9VU_VECTOR);
+
+INCLUDE_ASM(const s32, "P2/splice/bif", __ml__FG8VU_FLOATG9VU_VECTOR);
--- a/src/P2/splice/eval.cpp
+++ b/src/P2/splice/eval.cpp
@ -0,0 +1,35 @@
+#include "common.h"
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalSymbol__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalSet__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalDefine__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalAssert__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalIf__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalOr__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalAnd__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalCond__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalCase__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalLet__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalWhile__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalLambda__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalLambdaBody__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalBegin__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalApply__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEvalImport__FP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/eval", RefEval__FP5CPairP6CFrame);
--- a/src/P2/splice/gc.cpp
+++ b/src/P2/splice/gc.cpp
@ -0,0 +1,104 @@
+#include "common.h"
+
+#include <splice/gc.h>
+#include <splice/splotheap.h>
+#include <splice/spliceutils.h>
+
+CGc::CGc()
+{
+    return;
+}
+
+CGc::~CGc()
+{
+    return;
+}
+
+void CGc::Startup()
+{
+    m_cpframeRoot = 0;
+    m_cpsidebagRoot = 0;
+}
+
+void CGc::Shutdown() {}
+
+void CGc::AddRootFrame(CFrame *pframe)
+{
+    for (int i = 0; i < m_cpframeRoot; ++i)
+    {
+        if (m_apframeRoot[i] == pframe)
+        {
+            return;
+        }
+    }
+    m_apframeRoot[m_cpframeRoot++] = pframe;
+}
+
+void CGc::AddRootSidebag(CSidebag *psidebag)
+{
+    m_apsidebagRoot[m_cpsidebagRoot++] = psidebag;
+}
+
+void CGc::PushFrame(CFrame *pframe)
+{
+    m_apframeStack[m_cpframeStack++] = pframe;
+}
+
+CFrame *CGc::PframePop()
+{
+    if (m_cpframeStack >= 1)
+    {
+        return m_apframeStack[--m_cpframeStack];
+    }
+    return (CFrame *)nullptr;
+}
+
+void CGc::PushPair(CPair *ppair)
+{
+    m_appairStack[m_cppairStack++] = ppair;
+}
+
+CPair *CGc::PpairPop()
+{
+    if (m_cppairStack >= 1)
+    {
+        return m_appairStack[--m_cppairStack];
+    }
+    return (CPair *)nullptr;
+}
+
+void CGc::PushProc(CProc *pproc)
+{
+    m_approcStack[m_cpprocStack++] = pproc;
+}
+
+CProc *CGc::PprocPop()
+{
+    if (m_cpprocStack >= 1)
+    {
+        return m_approcStack[--m_cpprocStack];
+    }
+    return (CProc *)nullptr;
+}
+
+void CGc::UpdateRecyclable()
+{
+    g_splotheapPair.UpdateRecyclable();
+    g_splotheapFrame.UpdateRecyclable();
+    g_splotheapUnk1.UpdateRecyclable();
+    g_splotheapProc.UpdateRecyclable();
+    g_splotheapMethod.UpdateRecyclable();
+}
+
+INCLUDE_ASM(const s32, "P2/splice/gc", MarkLiveObjects__3CGc);
+
+INCLUDE_ASM(const s32, "P2/splice/gc", Collect__3CGc);
+
+// The functions below are compiler generated and their INCLUDE_ASM can just be removed once g_gc is defined
+// Currently blocked until references to g_gc are resolved
+
+INCLUDE_ASM(const s32, "P2/splice/gc", __static_initialization_and_destruction_0);
+
+INCLUDE_ASM(const s32, "P2/splice/gc", _GLOBAL_$I$g_gc);
+
+INCLUDE_ASM(const s32, "P2/splice/gc", _GLOBAL_$D$g_gc);
--- a/src/P2/splice/method.cpp
+++ b/src/P2/splice/method.cpp
@ -0,0 +1,13 @@
+#include "common.h"
+#include <sce/memset.h>
+#include <splice/method.h>
+#include <splice/splotheap.h>
+
+// todo: matches but blocked by reference in 001c15d8
+INCLUDE_ASM(const s32, "P2/splice/method", PmethodNew__Fv);
+// static CMethod* PMethodNew()
+// {
+//     CMethod* method = (CMethod*)g_splotheapMethod.PvAllocClear();
+//     memset(method, 0, sizeof(CMethod));
+//     return method;
+// }
--- a/src/P2/splice/pair.cpp
+++ b/src/P2/splice/pair.cpp
@ -0,0 +1,7 @@
+#include "common.h"
+
+INCLUDE_ASM(const s32, "P2/splice/pair", CloneTo__5CPairP5CPairP6CFrame);
+
+INCLUDE_ASM(const s32, "P2/splice/pair", PpairNew__Fv);
+
+INCLUDE_ASM(const s32, "P2/splice/pair", DeletePair__FP5CPair);
--- a/src/P2/splice/proc.cpp
+++ b/src/P2/splice/proc.cpp
@ -0,0 +1,25 @@
+#include "common.h"
+#include <sce/memset.h>
+#include <splice/proc.h>
+#include <splice/splotheap.h>
+
+void CProc::CloneTo(CProc *pprocClone, CFrame *pframeClone)
+{
+    if (pframeClone == nullptr)
+    {
+        pframeClone = m_pframe;
+    }
+    pprocClone->m_pframe = pframeClone;
+    pprocClone->m_ppair = m_ppair;
+    pprocClone->m_crefReq = m_crefReq;
+    pprocClone->m_fVarArg = m_fVarArg;
+    pprocClone->m_ppairCodeExpr = m_ppairCodeExpr;
+}
+
+// todo: matches but blocked by references in CRef::CloneTo and RefEvalLambda
+INCLUDE_ASM(const s32, "P2/splice/proc", PprocNew__Fv);
+// static CProc* PprocNew(void) {
+//     CProc* proc = (CProc*)g_splotheapProc.PvAllocClear();
+//     memset(proc, 0, sizeof(CProc));
+//     return proc;
+// }
--- a/src/P2/splice/ref.cpp
+++ b/src/P2/splice/ref.cpp
@ -8,15 +8,85 @@ CRef::CRef()

 INCLUDE_ASM(const s32, "P2/splice/ref", __4CRefRC4CRef);

-INCLUDE_ASM(const s32, "P2/splice/ref", _$_4CRef);
+CRef::~CRef()
+{
+    Decref();
+}

 INCLUDE_ASM(const s32, "P2/splice/ref", __as__4CRefRC4CRef);

+// todo: fix rodata misalignment
 INCLUDE_ASM(const s32, "P2/splice/ref", __eq__4CRefRC4CRef);
+// bool CRef::operator==(const CRef& ref)
+// {
+//   if (m_tagk != ref.m_tagk) {
+//     return false;
+//   }
+//   switch(m_tagk) {
+//     case TAGK_F32:
+//         return m_tag.m_g == ref.m_tag.m_g;
+//     case TAGK_S32:
+//         return m_tag.m_n == ref.m_tag.m_n;
+//     case TAGK_Symid:
+//         return m_tag.m_symid == ref.m_tag.m_symid;
+//     case TAGK_Bifk:
+//         return m_tag.m_bifk == ref.m_tag.m_bifk;
+//     case TAGK_Pair:
+//         return m_tag.m_ppair == ref.m_tag.m_ppair;
+//     case TAGK_Proc:
+//         return m_tag.m_pproc == ref.m_tag.m_pproc;
+//     case TAGK_Method:
+//         return m_tag.m_pmethod == ref.m_tag.m_pmethod;
+//     case TAGK_Basic:
+//         return (!m_tag.m_pbasic && !ref.m_tag.m_pbasic) || (m_tag.m_pbasic && ref.m_tag.m_pbasic);
+//     case TAGK_Matrix:
+//         return memcmp(m_tag.m_pmatrix,ref.m_tag.m_pmatrix, 0x40) == 0;
+//     case TAGK_Lm:
+//         return (m_tag.m_plm->gMin == ref.m_tag.m_plm->gMin) &&
+//                (m_tag.m_plm->gMax == ref.m_tag.m_plm->gMax);
+//     case TAGK_Vector:
+//         return (m_tag.m_pvector->x == ref.m_tag.m_pvector->x) &&
+//                (m_tag.m_pvector->y == ref.m_tag.m_pvector->y) &&
+//                (m_tag.m_pvector->z == ref.m_tag.m_pvector->z);
+//     case TAGK_Clq:
+//         return (m_tag.m_pclq->u == ref.m_tag.m_pclq->u) &&
+//                (m_tag.m_pclq->v == ref.m_tag.m_pclq->v) &&
+//                (m_tag.m_pclq->w == ref.m_tag.m_pclq->w);
+//     case TAGK_Smp:
+//         return (m_tag.m_psmp->svFast == ref.m_tag.m_psmp->svFast) &&
+//                (m_tag.m_psmp->svSlow == ref.m_tag.m_psmp->svSlow) &&
+//                (m_tag.m_psmp->dtFast == ref.m_tag.m_psmp->dtFast);
+//     case TAGK_Bool:
+//         return m_tag.m_bool == ref.m_tag.m_bool;
+//     default:
+//         return true;
+//   }
+// }

 INCLUDE_ASM(const s32, "P2/splice/ref", CloneTo__4CRefP4CRefP6CFrame);

 INCLUDE_ASM(const s32, "P2/splice/ref", Decref__4CRef);
+// void CRef::Decref()
+// {
+//     switch(m_tagk)
+//     {
+//         case TAGK_Vector:
+//             DecrefVector(m_tag.m_pvector);
+//             break;
+//         case TAGK_Matrix:
+//             DecrefMatrix(m_tag.m_pmatrix);
+//             break;
+//         case TAGK_Clq:
+//             DecrefClq(m_tag.m_pclq);
+//             break;
+//         case TAGK_Lm:
+//             DecrefLm(m_tag.m_plm);
+//             break;
+//         case TAGK_Smp:
+//             DecrefSmp(m_tag.m_psmp);
+//             break;
+//     }
+// }

 INCLUDE_ASM(const s32, "P2/splice/ref", Incref__4CRef);
 /* todo: match rodata
--- a/src/P2/splice/serialize.cpp
+++ b/src/P2/splice/serialize.cpp
@ -0,0 +1,3 @@
+#include "common.h"
+
+INCLUDE_ASM(const s32, "P2/splice/serialize", PpairSerializeIn__FP18CBinaryInputStream);
--- a/src/P2/splice/sidebag.cpp
+++ b/src/P2/splice/sidebag.cpp
@ -0,0 +1,11 @@
+#include "common.h"
+
+INCLUDE_ASM(const s32, "P2/splice/sidebag", RefAddBinding__8CSidebagiP4CRef);
+
+INCLUDE_ASM(const s32, "P2/splice/sidebag", RefSetBinding__8CSidebagiP4CRef);
+
+INCLUDE_ASM(const s32, "P2/splice/sidebag", FFindBinding__8CSidebagiP4CRef);
+
+INCLUDE_ASM(const s32, "P2/splice/sidebag", CloneTo__8CSidebagP8CSidebag);
+
+INCLUDE_ASM(const s32, "P2/splice/sidebag", PsidebagNew__Fv);
--- a/src/P2/splice/spliceutils.cpp
+++ b/src/P2/splice/spliceutils.cpp
@ -1,8 +1,37 @@
 #include "common.h"
+#include <splice/frame.h>
+#include <splice/gc.h>
+#include <splice/pair.h>
+#include <splice/splotheap.h>
+#include <splice/vecmat.h>
+
+extern CGc g_gc;

 INCLUDE_ASM(const s32, "P2/splice/spliceutils", StartupSplice__Fv);
+// void StartupSplice(void)
+// {
+//     g_gc.Startup();
+//     g_splotheapPair.Startup(0xc, 0x2000);
+//     g_splotheapPair.m_pfndelete = reinterpret_cast<PFNDELETE>(DeletePair);
+//     g_splotheapFrame.Startup(0x1c, 0x190);
+//     g_splotheapFrame.m_pfndelete = reinterpret_cast<PFNDELETE>(DeleteFrame);
+//     g_splotheapUnk1.Startup(0x10, 0x800);
+//     g_splotheapUnk1.m_pfndelete = func_0011C4E8;
+//     g_splotheapProc.Startup(0x14, 0x800);
+//     StartupSpliceStructuredTypeFactories();
+//     g_splotheapMethod.Startup(0xc,0x80);
+// }

-INCLUDE_ASM(const s32, "P2/splice/spliceutils", ShutdownSplice__Fv);
+void ShutdownSplice(void)
+{
+    g_splotheapPair.Shutdown();
+    g_splotheapFrame.Shutdown();
+    g_splotheapUnk1.Shutdown();
+    g_splotheapProc.Shutdown();
+    ShutdownSpliceStructuredTypeFactories();
+    g_splotheapMethod.Shutdown();
+    g_gc.Shutdown();
+}

 INCLUDE_ASM(const s32, "P2/splice/spliceutils", spliceutils__static_initialization_and_destruction_0);

--- a/src/P2/splice/splotheap.cpp
+++ b/src/P2/splice/splotheap.cpp
@ -0,0 +1,62 @@
+#include "common.h"
+#include <splice/splotheap.h>
+
+INCLUDE_ASM(const s32, "P2/splice/splotheap", Startup__10CSplotheapii);
+
+void CSplotheap::Shutdown(void) {}
+
+INCLUDE_ASM(const s32, "P2/splice/splotheap", PvAllocUnsafe__10CSplotheap);
+
+INCLUDE_ASM(const s32, "P2/splice/splotheap", PvAllocClear__10CSplotheap);
+
+INCLUDE_ASM(const s32, "P2/splice/splotheap", PsplotLookup__10CSplotheapi);
+
+void CSplotheap::UpdateRecyclable(void)
+{
+    m_psplotRecyclable = m_psplotAlloc;
+}
+
+void CSplotheap::UnmarkAll(void)
+{
+    SPLOT *psplot = m_psplotAlloc;
+
+    while (psplot != nullptr)
+    {
+        psplot->fAlive = 0;
+        psplot = psplot->psplotNext;
+    }
+}
+
+INCLUDE_ASM(const s32, "P2/splice/splotheap", FreeGarbage__10CSplotheap);
+
+static void *PvFromPsplot(SPLOT *psplot)
+{
+    return (byte *)psplot + sizeof(SPLOT);
+}
+
+static SPLOT *PsplotFromPv(void *pv)
+{
+    return (SPLOT *)((byte *)pv - sizeof(SPLOT));
+}
+
+// todo: both below functions are matching but blocked by reference in CGc::MarkLiveObjects
+
+INCLUDE_ASM(const s32, "P2/splice/splotheap", FIsPvGarbage__FPv);
+// static bool FIsPvGarbage(void* pv) {
+//     SPLOT* psplot = PsplotFromPv(pv);
+
+//     return psplot->fAlive == 0;
+// }
+
+INCLUDE_ASM(const s32, "P2/splice/splotheap", MarkPvAlive__FPv);
+// static void MarkPvAlive(void* pv) {
+//     SPLOT* psplot = PsplotFromPv(pv);
+
+//     psplot->fAlive = 1;
+// }
+
+INCLUDE_ASM(const s32, "P2/splice/splotheap", func_0011C418);
+
+INCLUDE_ASM(const s32, "P2/splice/splotheap", func_0011C498);
+
+INCLUDE_ASM(const s32, "P2/splice/splotheap", func_0011C4E8);
--- a/src/P2/splice/vecmat.cpp
+++ b/src/P2/splice/vecmat.cpp
@ -0,0 +1,46 @@
+#include "common.h"
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", PvectorNew__Fv);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", IncrefVector__FP6VECTOR);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", DecrefVector__FP6VECTOR);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", func_0011C610);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", PmatrixNew__Fv);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", IncrefMatrix__FP7MATRIX4);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", DecrefMatrix__FP7MATRIX4);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", DeleteMatrix__FP7MATRIX4);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", PclqNew__Fv);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", IncrefClq__FP3CLQ);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", DecrefClq__FP3CLQ);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", func_0011C850);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", PlmNew__Fv);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", IncrefLm__FP2LM);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", DecrefLm__FP2LM);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", func_0011C960);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", PsmpNew__Fv);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", IncrefSmp__FP3SMP);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", DecrefSmp__FP3SMP);
+
+INCLUDE_ASM(const s32, "P2/splice/vecmat", StartupSpliceStructuredTypeFactories__Fv);
+
+void ShutdownSpliceStructuredTypeFactories(void)
+{
+    return;
+}