From 87179cdf3fcc18507df808a7bf6063a4470eaee3 Mon Sep 17 00:00:00 2001 From: Ethan Roseman Date: Sun, 25 Sep 2022 00:21:54 +0900 Subject: [PATCH] Shiftability work + splat update (#783) * evt bss + shiftability work * entity BSS * more BSS * another follows_vram * more shift goodz * git subrepo pull --force tools/splat subrepo: subdir: "tools/splat" merged: "9af40c5265" upstream: origin: "https://github.com/ethteck/splat.git" branch: "master" commit: "9af40c5265" git-subrepo: version: "0.4.3" origin: "https://github.com/ingydotnet/git-subrepo" commit: "2f68596" --- include/variables.h | 39 -- src/16F740.c | 20 +- src/16c8e0.c | 35 +- src/17D6A0.c | 22 +- src/181810.c | 16 +- src/18C790.c | 65 +-- src/18F340.c | 18 +- src/196AA0.c | 6 +- src/415D90.c | 245 +++++----- src/actor_api.c | 1 + src/battle_cam.c | 56 +-- src/entity/HeartBlock.c | 4 +- src/entity/ItemBlock.c | 2 + src/entity/SaveBlock.c | 6 + src/entity/Switch.c | 2 + src/evt/demo_api.c | 4 + src/evt/evt.c | 8 +- src/evt/fa4c0_len_3bf0.c | 10 +- src/evt/model_api.c | 4 + src/evt/msg_api.c | 5 + src/evt/player_api.c | 6 +- src/evt/script_list.c | 77 ++++ src/world/action/misc.c | 12 +- src/world/action/slide.c | 16 +- src/world/action/sneaky_parasol.c | 14 +- src/world/action/use_munchlesia.c | 10 +- src/world/action/use_spinning_flower.c | 21 +- tools/splat/.github/workflows/mypy.yml | 2 +- tools/splat/.gitrepo | 4 +- tools/splat/CHANGELOG.md | 12 +- tools/splat/create_config.py | 1 - tools/splat/requirements.txt | 4 +- tools/splat/segtypes/common/asm.py | 4 +- tools/splat/segtypes/common/bss.py | 55 ++- tools/splat/segtypes/common/c.py | 100 ++-- tools/splat/segtypes/common/code.py | 15 - tools/splat/segtypes/common/codesubsegment.py | 154 +++---- tools/splat/segtypes/common/data.py | 435 +++--------------- tools/splat/segtypes/common/group.py | 14 + tools/splat/segtypes/common/hasm.py | 4 +- tools/splat/segtypes/common/rdata.py | 4 +- tools/splat/segtypes/common/rodata.py | 57 +++ tools/splat/segtypes/linker_entry.py | 40 +- tools/splat/segtypes/n64/asm.py | 10 +- tools/splat/segtypes/n64/hasm.py | 10 +- tools/splat/segtypes/psx/asm.py | 6 +- tools/splat/split.py | 29 +- tools/splat/util/compiler.py | 2 +- tools/splat/util/options.py | 9 +- tools/splat/util/symbols.py | 3 - .../asm/nonmatchings/16c8e0/func_8023F088.s | 4 +- .../415D90/btl_state_update_partner_menu.s | 36 +- .../415D90/btl_state_update_peach_menu.s | 4 +- .../415D90/btl_state_update_player_menu.s | 36 +- .../415D90/btl_state_update_twink_menu.s | 4 +- .../asm/nonmatchings/415D90/func_802A11B0.s | 8 +- .../asm/nonmatchings/415D90/func_802A4A54.s | 8 +- ver/us/splat.yaml | 6 +- ver/us/symbol_addrs.txt | 39 -- ver/us/undefined_syms.txt | 373 ++------------- 60 files changed, 898 insertions(+), 1318 deletions(-) diff --git a/include/variables.h b/include/variables.h index 7d2cfd76b8..c804893f2d 100644 --- a/include/variables.h +++ b/include/variables.h @@ -35,18 +35,8 @@ extern s32 gBattleDmaDest; extern ActionCommandStatus gActionCommandStatus; -extern ScriptList gWorldScriptList; -extern ScriptList gBattleScriptList; -extern ScriptList* gCurrentScriptListPtr; - -extern s32 gNumScripts; extern s32 D_802DAC98; -extern s32 gScriptListCount; - -extern s32 gScriptIdList[MAX_SCRIPTS]; -extern s32 gScriptIndexList[MAX_SCRIPTS]; - extern s32 gMoveScriptTable[][4]; extern EntityList gWorldEntityList; @@ -84,16 +74,6 @@ extern HiddenPanelsData gCurrentHiddenPanels; extern BackgroundHeader gBackgroundImage; -extern MessagePrintState* gCurrentPrintContext; -extern s32 D_802DB264; -extern MessagePrintState* D_802DB268; - -extern s32 SaveBlockTutorialPrinterClosed; -extern s32 SaveBlockResultPrinterClosed; -extern MessagePrintState* SaveBlockTutorialPrinter; -extern MessagePrintState* SaveBlockResultPrinter; - -extern Entity* SwitchToLink; extern s32 CreateEntityVarArgBuffer[4]; extern f32 D_800F7B74; @@ -105,10 +85,6 @@ extern AnimatedMeshList* gCurrentAnimMeshListPtr; extern PartnerAnimations gPartnerAnimations[12]; -extern AnimatedModelList gBattleMeshAnimationList; -extern AnimatedModelList gWorldMeshAnimationList; -extern AnimatedModelList* gCurrentMeshAnimationListPtr; - // Triggers extern s16 gTriggerCount; extern TriggerList wTriggerList; @@ -205,15 +181,6 @@ extern Vec3s btl_actorHomePositions[]; extern SaveData gCurrentSaveFile; -extern u32* gMapFlags; -extern s32* gMapVars; - -extern u32 gWorldMapVars[MAX_MAPVARS]; -extern u32 gBattleMapVars[MAX_MAPVARS]; - -extern u32 gWorldMapFlags[MAX_MAPFLAGS]; -extern u32 gBattleMapFlags[MAX_MAPFLAGS]; - extern s32 D_8009A5D0; extern s32 timeFreezeMode; extern s32 D_8009A678; @@ -222,7 +189,6 @@ extern u8 D_800779B0; extern u32 D_80078174; extern u8 D_800A0963; -extern struct EffectInstance* TriggerBlockVanishEffect; extern s32 D_802EA310[]; extern s32 Entity_WoodenCrate_RenderShatteredScript[]; @@ -256,14 +222,9 @@ extern s32 D_802920C0[]; extern s32 D_802920E8[]; extern s32 D_80292110[]; -extern s32 D_8029FBD0; - extern AnimID KoopatrolDisguiseExtraAnims[]; extern AnimID HammerBroDisguiseExtraAnims[]; -//various -extern s32 D_802C05CC; - extern s16 gCurrentCamID; extern HeapNode gSpriteHeapPtr; diff --git a/src/16F740.c b/src/16F740.c index 62090c9295..bc768d58c1 100644 --- a/src/16F740.c +++ b/src/16F740.c @@ -18,16 +18,16 @@ extern s32 D_80281454[]; extern EvtScript D_80284A20[]; extern EvtScript D_80284A30[]; -extern s32 D_8029F240; -extern u8 D_8029F244; -extern s32 D_8029F248; -extern s32 D_8029F24C; -extern s32 D_8029F250; -extern s32 D_8029F254; -extern s32 D_8029F258; -extern s32 D_8029F25C; -extern s32 D_8029F260; -extern s32 D_8029F264; +BSS s32 D_8029F240; +BSS u8 D_8029F244; +BSS s32 D_8029F248; +BSS s32 D_8029F24C; +BSS s32 D_8029F250; +BSS s32 D_8029F254; +BSS s32 D_8029F258; +BSS s32 D_8029F25C; +BSS s32 D_8029F260; +BSS s32 D_8029F264; void btl_merlee_on_start_turn(void) { BattleStatus* battleStatus = &gBattleStatus; diff --git a/src/16c8e0.c b/src/16c8e0.c index 200e7072ac..1b03ac568e 100644 --- a/src/16c8e0.c +++ b/src/16c8e0.c @@ -13,6 +13,23 @@ s16 D_802809F6 = -1; s16 D_802809F8 = 0; u16 D_802809FA = 0; +BSS s32 bSavedPartner; +BSS s32 bSavedOverrideFlags; +BSS s32 D_8029DA38[2]; // unused? +BSS s32 D_8029DA40; +BSS s32 D_8029DA44; +BSS s32 D_8029DA48; +BSS s32 D_8029DA4C; +BSS Camera D_8029DA50[ARRAY_COUNT(gCameras)]; +BSS f32 D_8029EFB0; +BSS f32 D_8029EFB4; +BSS f32 D_8029EFB8; +BSS s32 D_8029EFBC; +BSS s32 D_8029EFC0[10]; +BSS s32 D_8029EFE8[10]; +BSS s32 D_8029F010[10]; +BSS s16 D_8029F038[0x100]; + extern HudScript HES_HPDigit0; extern HudScript HES_HPDigit1; extern HudScript HES_HPDigit2; @@ -78,24 +95,6 @@ EvtScript BtlBringPartnerOut = { EVT_END }; - -extern s32 bSavedPartner; -extern s32 bSavedOverrideFlags; -extern s32 D_8029DA40; -extern s32 D_8029DA44; -extern s32 D_8029DA48; -extern s32 D_8029DA4C; -extern Camera D_8029DA50[ARRAY_COUNT(gCameras)]; -extern f32 D_8029EFB0; -extern f32 D_8029EFB4; -extern f32 D_8029EFB8; -extern s32 D_8029EFBC; -extern s32 D_8029EFC0[10]; -extern s32 D_8029EFE8[10]; -extern s32 D_8029F010[10]; - -extern s16 D_8029F038[0x100]; - extern HudScript HES_HPBar; extern HudScript HES_Item_SmallStarPoint; extern HudScript HES_Item_StarPoint; diff --git a/src/17D6A0.c b/src/17D6A0.c index 77c5e40c78..cab2ffff85 100644 --- a/src/17D6A0.c +++ b/src/17D6A0.c @@ -1115,19 +1115,19 @@ s32 bActorMessages[] = { }; PopupMessage* D_802838F8 = NULL; -// BSS extern s16 D_80159E7E; -extern PopupMessage popupMessages[32]; -extern s16 D_8029F640; -extern s16 D_8029F642; -extern s16 D_8029F644; -extern s16 D_8029F646; -extern s16 D_8029F648; -extern s16 D_8029F64A; -extern s16 D_8029F64C; -extern s16 D_8029F64E; -extern s16 D_8029F650; +// BSS +BSS PopupMessage popupMessages[32]; +BSS s16 D_8029F640; +BSS s16 D_8029F642; +BSS s16 D_8029F644; +BSS s16 D_8029F646; +BSS s16 D_8029F648; +BSS s16 D_8029F64A; +BSS s16 D_8029F64C; +BSS s16 D_8029F64E; +BSS s16 D_8029F650; extern HudScript HES_AButton; extern HudScript HES_AButtonDown; diff --git a/src/181810.c b/src/181810.c index 00d8ca5f44..00cb136d54 100644 --- a/src/181810.c +++ b/src/181810.c @@ -1,13 +1,15 @@ #include "common.h" #include "battle/battle.h" -extern MessagePrintState* gSpeakingActorPrintCtx; -extern MessagePrintState* D_8029FA64; -extern s32 gSpeakingActorPrintIsDone; // unk_08 -extern s32 gSpeakingActorTalkAnim; -extern s32 gSpeakingActorIdleAnim; -extern Actor* gSpeakingActor; -extern ActorPart* gSpeakingActorPart; +BSS char D_8029FA660[0x400]; // unused? + +BSS MessagePrintState* gSpeakingActorPrintCtx; +BSS MessagePrintState* D_8029FA64; +BSS s32 gSpeakingActorPrintIsDone; // unk_08 +BSS s32 gSpeakingActorTalkAnim; +BSS s32 gSpeakingActorIdleAnim; +BSS Actor* gSpeakingActor; +BSS ActorPart* gSpeakingActorPart; ApiStatus ActorSpeak(Evt* script, s32 isInitialCall) { Bytecode* args = script->ptrReadPos; diff --git a/src/18C790.c b/src/18C790.c index 60d4fce383..076676e710 100644 --- a/src/18C790.c +++ b/src/18C790.c @@ -15,39 +15,40 @@ extern HudScript* D_802841C0[3][10]; extern HudScript* D_80284238[3][10]; extern EvtScript D_802842B0; extern EvtScript D_80284880; +extern EvtScript PlayerScriptDispatcher; +extern HudScript HES_ProjectorBeam; -extern s32 D_8029FA88; -extern s32 D_8029FAA8; -extern s32 D_8029FAC4; -extern s32 D_8029FB4C; -extern s32 D_8029FB50; -extern s32 D_8029FB54; -extern s32 D_8029FB6C; -extern s32 D_8029FB70; -extern s32 D_8029FB74; -extern Evt* D_8029FB7C; -extern s32 D_8029FB80; -extern s32 D_8029FB84; +BSS s32 D_8029FA80[4]; +BSS s32 D_8029FA90[3][7]; +BSS s32 D_8029FAE4; // unused? +BSS s32 D_8029FAE8; +BSS s32 D_8029FAEC[23]; // unused? + +BSS s32 D_8029FB48; +BSS s32 D_8029FB4C; +BSS s32 D_8029FB50; +BSS s32 D_8029FB54; +BSS s32 D_8029FB58[2]; // unused? +BSS s32 D_8029FB60[3]; +BSS s32 D_8029FB6C; +BSS s32 D_8029FB70; +BSS s32 D_8029FB74; +BSS s32 D_8029FB78; +BSS Evt* D_8029FB7C; +BSS s32 D_8029FB80; +BSS s32 D_8029FB84; +BSS s32 D_8029FB88; +BSS s32 D_8029FB8C; + +extern HudScript D_802A9F34; +extern HudScript D_802A9F5C; +extern HudScript D_802A9F84; extern HudScript D_802A9F0C; +extern HudScript D_802A9FAC; extern HudScript D_802AA320; extern HudScript D_802AA694; extern HudScript D_802AAA08; extern HudScript D_802AAA30; -extern HudScript HES_ProjectorBeam; -extern EvtScript PlayerScriptDispatcher; - -extern s32 D_8029FA80[4]; -extern s32 D_8029FA90[3][7]; -extern s32 D_8029FAE8; -extern s32 D_8029FB48; -extern s32 D_8029FB60[]; -extern s32 D_8029FB78; -extern s32 D_8029FB88; -extern s32 D_8029FB8C; -extern HudScript D_802A9F34; -extern HudScript D_802A9F5C; -extern HudScript D_802A9F84; -extern HudScript D_802A9FAC; s32* virtual_entity_get_by_index(s32); @@ -421,7 +422,7 @@ void btl_state_update_celebration(void) { } if (is_ability_active(ABILITY_FP_PLUS)) { - id = D_8029FAA8; + id = D_8029FA90[0][6]; hud_element_set_script(id, gItemHudScripts[gItemTable[248].hudElemID].enabled); hud_element_clear_flags(id, HUD_ELEMENT_FLAGS_DISABLED); hud_element_set_scale(id, 0.5f); @@ -490,7 +491,7 @@ void btl_state_update_celebration(void) { } if (is_ability_active(ABILITY_HP_PLUS)) { - id = D_8029FAC4; + id = D_8029FA90[1][6]; hud_element_set_script(id, gItemHudScripts[gItemTable[231].hudElemID].enabled); hud_element_clear_flags(id, HUD_ELEMENT_FLAGS_DISABLED); hud_element_set_scale(id, 0.5f); @@ -601,7 +602,7 @@ void btl_state_update_celebration(void) { hud_element_set_render_pos(id, x, y); } - id = D_8029FA88; + id = D_8029FA80[2]; hud_element_get_render_pos(id, &x, &y); x += 20; hud_element_set_render_pos(id, x, y); @@ -722,7 +723,7 @@ void btl_state_update_celebration(void) { hud_element_set_flags(D_8029FA80[3], HUD_ELEMENT_FLAGS_DISABLED); break; case 2: - hud_element_set_flags(D_8029FA88, HUD_ELEMENT_FLAGS_DISABLED); + hud_element_set_flags(D_8029FA80[2], HUD_ELEMENT_FLAGS_DISABLED); break; } } else { @@ -735,7 +736,7 @@ void btl_state_update_celebration(void) { hud_element_clear_flags(D_8029FA80[3], HUD_ELEMENT_FLAGS_DISABLED); break; case 2: - hud_element_clear_flags(D_8029FA88, HUD_ELEMENT_FLAGS_DISABLED); + hud_element_clear_flags(D_8029FA80[2], HUD_ELEMENT_FLAGS_DISABLED); break; } } diff --git a/src/18F340.c b/src/18F340.c index 0a05381e21..a6ff4195ac 100644 --- a/src/18F340.c +++ b/src/18F340.c @@ -5,15 +5,15 @@ extern HudScript HES_Happy; extern HudScript HES_HPDrain; -extern s32 D_8029FB90; -extern f32 D_8029FB94; -extern EffectInstance* BattleMerleeOrbEffect; -extern EffectInstance* BattleMerleeWaveEffect; -extern s32 D_8029FBA0; -extern s16 D_8029FBA4; -extern s32 D_8029FBA8; -extern s32 D_8029FBAC; -extern s32 D_8029FBB0[]; +BSS s32 D_8029FB90; +BSS f32 D_8029FB94; +BSS EffectInstance* BattleMerleeOrbEffect; +BSS EffectInstance* BattleMerleeWaveEffect; +BSS s32 D_8029FBA0; +BSS s16 D_8029FBA4; +BSS s32 D_8029FBA8; +BSS s32 D_8029FBAC; +BSS s32 D_8029FBB0[3]; void func_80260A60(void) { BattleStatus* battleStatus = &gBattleStatus; diff --git a/src/196AA0.c b/src/196AA0.c index 4448365ca1..dcc6bf979b 100644 --- a/src/196AA0.c +++ b/src/196AA0.c @@ -26,7 +26,11 @@ // TODO: move to src/battle/action_cmd.c extern void* actionCommandDmaTable[23]; -extern s32 D_8029FBC0; + +BSS s32 D_8029FBC0; +BSS s32 D_8029FBC4[3]; // unused? +BSS s32 D_8029FBD0; +BSS s8 D_8029FBD4; void action_command_jump_draw_hud_elements(void); void action_command_hammer_draw_hud_elements(void); diff --git a/src/415D90.c b/src/415D90.c index 09fcdb4341..797a844c4b 100644 --- a/src/415D90.c +++ b/src/415D90.c @@ -252,114 +252,133 @@ s32 D_802AB738[] = { MSG_Menus_Party_Bow, MSG_Menus_Party_Goombaria, MSG_Menus_Party_Twink, MSG_Menus_Party_Peach, 0x00000000 }; -extern s32 D_802ACC60; -extern s32 D_802ACC64; -extern s32 D_802ACC68; -extern s32 D_802ACC6C; -extern s32 D_802ACC70[]; -extern s8 D_802AD000; -extern s8 D_802AD001; -extern s8 D_802AD002; -extern s8 D_802AD003; -extern s8 D_802AD004; -extern s16 D_802AD006; -extern s16 D_802AD008; -extern s16 D_802AD00A; -extern s32 D_802AD010[]; -extern s32 D_802AD028[]; -extern s32 D_802AD040; -extern s32 D_802AD044; -extern s32 D_802AD048; -extern s32 D_802AD04C; -extern s32 D_802AD05C; -extern s32 D_802AD050; -extern s32 D_802AD054; -extern s32 D_802AD058; -extern s32 D_802AD060; -extern s32 D_802AD064; -extern s8 D_802AD068; -extern s8 D_802AD069; -extern s8 D_802AD06A; -extern s8 D_802AD06B; -extern f32 D_802AD06C; -extern f32 D_802AD070; -extern HudScript* main_battle_menu_JumpHudScripts[]; -extern s32 battle_menu_messageIDs[]; -extern s32 main_menu_numOptions; -extern s32 D_802AD0A8; -extern s32 D_802AD0B0; -extern s8 D_802AD0B3; -extern s32 battle_menu_submenuIDs[]; -extern s32 battle_menu_isEnabled[]; -extern s32 battle_menu_isMessageDisabled[]; -extern s32 D_802AD100; -extern s32 D_802AD104; -extern s8 battle_menu_moveState; -extern s8 battle_menu_moveCursorPos; -extern s8 D_802AD10A; -extern s8 D_802AD10B; -extern s8 battle_menu_moveScrollLine; -extern s8 D_802AD10D; -extern s8 D_802AD10E; -extern s8 D_802AD10F; -extern s16 battle_menu_moveScrollOffset; -extern s16 D_802AD112; -extern s16 battle_menu_moveTextColor; -extern s16 battle_menu_moveTextOpacity; -extern s32 battle_menu_moveCursorIcon; -extern s32 battle_menu_moveUpArrowIcon; -extern s32 battle_menu_moveDownArrowIcon; -extern s32 battle_menu_moveOptionIconIDs[24]; -extern s32 battle_menu_moveTitleIcon; -extern s32 battle_menu_moveOptionCostUnitIconIDs[24]; -extern s16 battle_menu_moveX; -extern s16 battle_menu_moveY; -extern s32 battle_menu_moveOptionIndexMap[24]; -extern s32 D_802AD258; -extern HudScript* battle_menu_moveOptionIconScripts[]; -extern s32 battle_menu_moveOptionNames[]; -extern s32 battle_menu_moveOptionDisplayCosts[]; -extern s32 battle_menu_moveOptionDisplayCostReductions[]; -extern s32 battle_menu_moveOptionDisplayCostReductionColors[]; -extern s32 battle_menu_moveOptionBPCosts[]; -extern s32 battle_menu_hasSpiritsMenu; -extern s32 battle_menu_moveOptionCount; -extern s32 D_802AD4A8; -extern s32 battle_menu_moveOptionsEnabled[]; -extern s32 battle_menu_moveOptionDescriptions[24]; -extern s8 battle_menu_moveOptionSortPriorities[]; -extern s8 battle_menu_moveOptionCantUseTypes[]; -extern s32 battle_menu_moveOptionActive; -extern s8 D_802AD604; -extern s8 D_802AD605; -extern s8 D_802AD606; -extern s8 D_802AD607; -extern s8 D_802AD608; -extern s8 D_802AD609; -extern s8 D_802AD60A; -extern s8 D_802AD60B; -extern s16 D_802AD60C; -extern s16 D_802AD60E; -extern s16 D_802AD610; -extern s16 D_802AD612; -extern s8 D_802AD614; -extern s32 D_802AD618; -extern s32 D_802AD61C; -extern s32 D_802AD620; -extern s32 D_802AD624; -extern s32 D_802AD628[]; -extern s16 D_802AD63C; -extern s16 D_802AD63E; -extern HudScript* D_802AD640[]; -extern s32 D_802AD658[]; // msg IDs -extern s32 D_802AD66C; -extern u8 D_802AD66F; -extern s8 D_802AD673; -extern s32 D_802AD678[]; -extern s32 D_802AD690[]; -extern s32 D_802AD6A8[]; -extern s32 D_802AD6C0[]; -extern s32 D_802AD6D4; +BSS s32 D_802ACC60; +BSS s32 D_802ACC64; +BSS s32 D_802ACC68; +BSS s32 D_802ACC6C; +BSS s32 D_802ACC70[24]; +BSS s32 D_802ACCD0; +BSS s32 D_802ACCD4[0xC5]; // unused? +BSS s32 D_802ACFE8; +BSS s32 D_802ACFEC; +BSS s32 D_802ACFF0; +BSS s32 D_802ACFF4; +BSS s32 D_802ACFF8; +BSS s8 D_802ACFFC; +BSS s8 D_802ACFFD; +BSS s16 D_802ACFFE; // unused? +BSS s8 D_802AD000; +BSS s8 D_802AD001; +BSS s8 D_802AD002; +BSS s8 D_802AD003; +BSS s8 D_802AD004; +BSS s16 D_802AD006; +BSS s16 D_802AD008; +BSS s16 D_802AD00A; +BSS s16 D_802AD00C; // unused? +BSS s32 D_802AD010[6]; +BSS s32 D_802AD028[6]; +BSS s32 D_802AD040; +BSS s32 D_802AD044; +BSS s32 D_802AD048; +BSS s32 D_802AD04C; +BSS s32 D_802AD050; +BSS s32 D_802AD054; +BSS s32 D_802AD058; +BSS s32 D_802AD05C; +BSS s32 D_802AD060; +BSS s32 D_802AD064; +BSS s8 D_802AD068; +BSS s8 D_802AD069; +BSS s8 D_802AD06A; +BSS s8 D_802AD06B; +BSS f32 D_802AD06C; +BSS f32 D_802AD070; +BSS s32 D_802AD074; // unused? +BSS HudScript* main_battle_menu_JumpHudScripts[6]; +BSS s32 battle_menu_messageIDs[6]; +BSS s32 D_802AD0A8; +BSS s32 main_menu_numOptions; +BSS s32 D_802AD0B0; +BSS s32 D_802AD0B4; // unused? +BSS s32 battle_menu_submenuIDs[6]; +BSS s32 battle_menu_isEnabled[6]; +BSS s32 battle_menu_isMessageDisabled[6]; +BSS s32 D_802AD100; +BSS s32 D_802AD104; +BSS s8 battle_menu_moveState; +BSS s8 battle_menu_moveCursorPos; +BSS s8 D_802AD10A; +BSS s8 D_802AD10B; +BSS s8 battle_menu_moveScrollLine; +BSS s8 D_802AD10D; +BSS s8 D_802AD10E; +BSS s8 D_802AD10F; +BSS s16 battle_menu_moveScrollOffset; +BSS s16 D_802AD112; +BSS s16 battle_menu_moveTextColor; +BSS s16 battle_menu_moveTextOpacity; +BSS s32 battle_menu_moveCursorIcon; +BSS s32 battle_menu_moveUpArrowIcon; +BSS s32 battle_menu_moveDownArrowIcon; +BSS s32 D_802AD124; // unused? +BSS s32 battle_menu_moveOptionIconIDs[24]; +BSS s32 battle_menu_moveTitleIcon; +BSS s32 D_802AD18C; // unused? +BSS s32 battle_menu_moveOptionCostUnitIconIDs[24]; +BSS s16 battle_menu_moveX; +BSS s16 battle_menu_moveY; +BSS s32 D_802AD1F4; // unused? +BSS s32 battle_menu_moveOptionIndexMap[24]; +BSS s32 D_802AD258; +BSS s32 D_802AD25C; // unused? +BSS HudScript* battle_menu_moveOptionIconScripts[24]; +BSS s32 battle_menu_moveOptionNames[24]; +BSS s32 battle_menu_moveOptionDisplayCosts[24]; +BSS s32 battle_menu_moveOptionDisplayCostReductions[24]; +BSS s32 battle_menu_moveOptionDisplayCostReductionColors[24]; +BSS s32 battle_menu_moveOptionBPCosts[24]; +BSS s32 battle_menu_hasSpiritsMenu; +BSS s32 battle_menu_moveOptionCount; +BSS s32 D_802AD4A8; +BSS s32 D_802AD4AC; // unused? +BSS s32 battle_menu_moveIndices[24]; +BSS s32 battle_menu_moveOptionsEnabled[24]; +BSS s32 battle_menu_moveOptionDescriptions[24]; +BSS s8 battle_menu_moveOptionSortPriorities[24]; +BSS s8 battle_menu_moveOptionCantUseTypes[24]; +BSS s32 battle_menu_moveOptionActive; +BSS s8 D_802AD604; +BSS s8 D_802AD605; +BSS s8 D_802AD606; +BSS s8 D_802AD607; +BSS s8 D_802AD608; +BSS s8 D_802AD609; +BSS s8 D_802AD60A; +BSS s8 D_802AD60B; +BSS s16 D_802AD60C; +BSS s16 D_802AD60E; +BSS s16 D_802AD610; +BSS s16 D_802AD612; +BSS s8 D_802AD614; +BSS s32 D_802AD618; +BSS s32 D_802AD61C; +BSS s32 D_802AD620; +BSS s32 D_802AD624; +BSS s32 D_802AD628[5]; +BSS s16 D_802AD63C; +BSS s16 D_802AD63E; +BSS HudScript* D_802AD640[6]; +BSS s32 D_802AD658[5]; // msg IDs +BSS s32 D_802AD66C; +BSS char D_802AD670[3]; +BSS s8 D_802AD673; +BSS s32 D_802AD674; // unused? +BSS s32 D_802AD678[6]; +BSS s32 D_802AD690[6]; +BSS s32 D_802AD6A8[6]; +BSS s32 D_802AD6C0[5]; +BSS s32 D_802AD6D4; void func_802A3C98(s32 x, s32 y); void func_802A43DC(s32 arg0, s32 x, s32 y); @@ -437,10 +456,10 @@ s32 func_802A11B0(void) { D_802AD064 = 173; D_802AD070 = 0.3f; D_802AD004 = 0; - D_802AD06B = D_802AD0B3; - D_802AD069 = -D_802AD0B3; + D_802AD06B = D_802AD0B0; + D_802AD069 = -D_802AD0B0; D_802AD06A = main_menu_numOptions - 1; - D_802AD06A -= D_802AD0B3; + D_802AD06A -= D_802AD0B0; for (i = 0; i < main_menu_numOptions; i++) { D_802AD010[i] = id = hud_element_create(main_battle_menu_JumpHudScripts[i]); @@ -1803,7 +1822,7 @@ s32 func_802A4A54(void) { } if (D_802AD605 < 0) { - D_802AD605 = D_802AD66F - 1; + D_802AD605 = D_802AD66C - 1; } if (D_802AD66C - 1 < D_802AD605) { D_802AD605 = 0; @@ -2374,7 +2393,7 @@ void btl_state_update_peach_menu(void) { } if (temp_s0_2 != 0) { set_animation(0, 0, 0xA0002); - battleStatus->currentSubmenu = D_802AD0BB[temp_s0_2 - 1]; + battleStatus->currentSubmenu = battle_menu_submenuIDs[temp_s0_2 - 1]; func_802A1030(); D_802ACC60 = 8; D_802ACC6C = 4; diff --git a/src/actor_api.c b/src/actor_api.c index a515ee779d..7202048986 100644 --- a/src/actor_api.c +++ b/src/actor_api.c @@ -2,6 +2,7 @@ #include "effects.h" #include "battle/battle.h" +extern s32 D_8029FBD0; extern s8 D_8029FBD4; s32 count_targets(Actor* actor, s32 targetHomeIndex, s32 targetSelectionFlags) { diff --git a/src/battle_cam.c b/src/battle_cam.c index 0ac4f4dc3e..ffd5ac6bfa 100644 --- a/src/battle_cam.c +++ b/src/battle_cam.c @@ -2,34 +2,34 @@ #include "script_api/battle.h" #define LERP(a, b, alpha) ((a) * (alpha) + (b) * (1.0f-(alpha))) -// battle cam -extern f32 BattleCam_PosX; -extern f32 BattleCam_PosY; -extern f32 BattleCam_PosZ; -extern s16 BattleCam_TargetActor; -extern s16 BattleCam_TargetActorPart; -extern s16 BattleCam_BoomLength; -extern s16 BattleCam_BoomYaw; -extern s16 BattleCam_BoomPitch; -extern s16 BattleCam_BoomZOffset; -extern f32 D_8029F288; -extern f32 BattleCam_InitialBoomLength; -extern f32 BattleCam_InitialBoomYaw; -extern f32 BattleCam_InitialBoomPitch; -extern f32 BattleCam_InitialBoomZOffset; -extern s8 BattleCam_DoneMoving; -extern s16 BattleCam_MoveTimeLeft; -extern s16 BattleCam_MoveTimeTotal; -extern s8 BattleCam_ModeY; -extern s8 BattleCam_ModeX; -extern s8 BattleCam_SetImmediately; -extern s8 BattleCam_UseLinearInterp; -extern s8 D_8029F2A6; -extern s8 D_8029F2A7; -extern f32 BattleCam_InitialPosX; -extern f32 BattleCam_InitialPosY; -extern f32 BattleCam_InitialPosZ; -extern EvtScript* BattleCam_ControlScript; + +static f32 BattleCam_PosX; +static f32 BattleCam_PosY; +static f32 BattleCam_PosZ; +static s16 BattleCam_TargetActor; +static s16 BattleCam_TargetActorPart; +static s16 BattleCam_BoomLength; +static s16 BattleCam_BoomYaw; +static s16 BattleCam_BoomPitch; +static s16 BattleCam_BoomZOffset; +static f32 D_8029F288; +static f32 BattleCam_InitialBoomLength; +static f32 BattleCam_InitialBoomYaw; +static f32 BattleCam_InitialBoomPitch; +static f32 BattleCam_InitialBoomZOffset; +static s8 BattleCam_DoneMoving; +static s16 BattleCam_MoveTimeLeft; +static s16 BattleCam_MoveTimeTotal; +static s8 BattleCam_ModeY; +static s8 BattleCam_ModeX; +static s8 BattleCam_SetImmediately; +static s8 BattleCam_UseLinearInterp; +static s8 D_8029F2A6; +static s8 D_8029F2A7; +static f32 BattleCam_InitialPosX; +static f32 BattleCam_InitialPosY; +static f32 BattleCam_InitialPosZ; +static EvtScript* BattleCam_ControlScript; s8 BattleCam_IsFrozen = FALSE; s32 BattleCam_CurrentPresetID = -1; diff --git a/src/entity/HeartBlock.c b/src/entity/HeartBlock.c index 1e7ced767e..cf2520fe41 100644 --- a/src/entity/HeartBlock.c +++ b/src/entity/HeartBlock.c @@ -3,8 +3,6 @@ #include "ld_addrs.h" #include "entity.h" -extern u32 HeartBlockPrinterClosed; - extern EntityModelScript Entity_HeartBlockContent_RenderScriptIdle; extern EntityModelScript Entity_HeartBlockContent_RenderScriptAfterHit; extern EntityModelScript Entity_HeartBlockContent_RenderScriptHit; @@ -16,6 +14,8 @@ extern Gfx Entity_HeartBlockContent_RenderHeartSleeping[]; extern Gfx Entity_HeartBlockContent_RenderHeartAwake[]; extern Gfx Entity_HeartBlockContent_RenderHeartHappy[]; +BSS u32 HeartBlockPrinterClosed; + f32 entity_HeartBlockContent_get_previous_yaw(HeartBlockContentData* data, s32 lagTime) { s32 bufIdx = data->yawBufferPos - lagTime; if (bufIdx < 0) { diff --git a/src/entity/ItemBlock.c b/src/entity/ItemBlock.c index 8a240e3c5d..6a48b9360e 100644 --- a/src/entity/ItemBlock.c +++ b/src/entity/ItemBlock.c @@ -18,6 +18,8 @@ extern EntityBlueprint Entity_HitGroundedYellowBlock; extern EntityBlueprint Entity_HitFloatingYellowBlock; extern EntityBlueprint Entity_HitRedBlock; +BSS EffectInstance* TriggerBlockVanishEffect; + f32 player_get_camera_facing_angle(void); void entity_inactive_block_hit_init(Entity*); void entity_inactive_block_hit_anim(Entity*); diff --git a/src/entity/SaveBlock.c b/src/entity/SaveBlock.c index fa332ed2f7..fe6b95808a 100644 --- a/src/entity/SaveBlock.c +++ b/src/entity/SaveBlock.c @@ -11,6 +11,11 @@ extern Gfx Entity_SaveBlock_RenderNone[]; extern s32 Entity_SaveBlock_ScriptResume[]; +BSS s32 SaveBlockTutorialPrinterClosed; +BSS s32 SaveBlockResultPrinterClosed; +BSS MessagePrintState* SaveBlockTutorialPrinter; +BSS MessagePrintState* SaveBlockResultPrinter; + void entity_SaveBlock_setupGfx(s32 index) { Gfx* gfxPos = gMasterGfxPos; Entity* entity = get_entity_by_index(index); @@ -149,6 +154,7 @@ EntityScript Entity_SaveBlock_Script = { es_Restart es_End }; + EntityScript Entity_SaveBlock_ScriptResume = { es_Call(entity_SaveBlock_resume_game) es_SetCallback(NULL, 2) diff --git a/src/entity/Switch.c b/src/entity/Switch.c index 873dd05256..bffadf4c28 100644 --- a/src/entity/Switch.c +++ b/src/entity/Switch.c @@ -10,6 +10,8 @@ extern Gfx Entity_RedSwitch_Render[]; extern Gfx Entity_BlueSwitch_Render[]; extern Gfx Entity_GreenStompSwitch_Render[]; +BSS Entity* SwitchToLink; + void entity_GreenStompSwitch_idle(Entity* entity) { PlayerStatus* playerStatus = &gPlayerStatus; SwitchData* data = entity->dataBuf.swtch; diff --git a/src/evt/demo_api.c b/src/evt/demo_api.c index 8ff6128974..d5c12269d8 100644 --- a/src/evt/demo_api.c +++ b/src/evt/demo_api.c @@ -6,6 +6,10 @@ u8 D_802D9D71 = 0xFE; u8 D_802D9D72 = 0x00; u8 D_802D9D73 = 0xFF; +extern s32 D_802DBB60; +extern s32 D_802DBB64; // unused? +extern s32 D_802DBB68; + INCLUDE_ASM(ApiStatus, "evt/demo_api", SetSpriteShading, Evt* script, s32 isInitialCall); ApiStatus EnableSpriteShading(Evt* script, s32 isInitialCall) { diff --git a/src/evt/evt.c b/src/evt/evt.c index 35e17fc521..975b079ca6 100644 --- a/src/evt/evt.c +++ b/src/evt/evt.c @@ -1,5 +1,10 @@ #include "common.h" +extern u32* gMapFlags; +extern s32* gMapVars; + +extern char evtDebugPrintBuffer[0x100]; + Bytecode* evt_find_label(Evt* script, s32 arg1); Bytecode* evt_skip_if(Evt* script); Bytecode* evt_skip_else(Evt* script); @@ -7,9 +12,6 @@ Bytecode* evt_goto_end_case(Evt* script); Bytecode* evt_goto_next_case(Evt* script); Bytecode* evt_goto_end_loop(Evt* script); -// BSS -extern char evtDebugPrintBuffer[]; - f32 evt_fixed_var_to_float(Bytecode scriptVar) { if (scriptVar <= EVT_FIXED_CUTOFF) { return EVT_FIXED_TO_FLOAT(scriptVar); diff --git a/src/evt/fa4c0_len_3bf0.c b/src/evt/fa4c0_len_3bf0.c index 5c2e8e9b41..104234fe95 100644 --- a/src/evt/fa4c0_len_3bf0.c +++ b/src/evt/fa4c0_len_3bf0.c @@ -3,12 +3,14 @@ #include "hud_element.h" #include "world/partners.h" +ApiStatus PollMusicEvents(Evt* script, s32 isInitialCall); AuResult bgm_set_track_volumes(s32 playerIndex, s16 trackVolSet); -static ApiStatus PollMusicEvents(Evt* script, s32 isInitialCall); extern MusicEvent* MusicEventList; +extern s32 D_802DB7D4; // unused? extern Evt* RunningMusicEvents[10]; extern s32 RunningMusicEventIDs[10]; +extern s32 D_802DB828[2]; // unused? extern PopupMenu D_802DB830; s32 MusicEventPollCount = 0; @@ -19,14 +21,14 @@ static EvtScript EVS_MusicEventMonitor = { EVT_END }; -static s32 PollMusicEvents(Evt* script, s32 isInitialCall) { +ApiStatus PollMusicEvents(Evt* script, s32 isInitialCall) { MusicEventTrigger* list; s32 musicEventID, scriptSelector; u32 count; s32 i; bgm_poll_music_events(&list, &count); - + for (i = 0; i < count; i++, list++) { MusicEvent* cur = MusicEventList; musicEventID = (*list & 0xFF0000) >> 0x10; @@ -107,7 +109,7 @@ ApiStatus FadeInMusic(Evt* script, s32 isInitialCall) { s16 fadeStartVolume = evt_get_variable(script, *args++); s16 fadeEndVolume = evt_get_variable(script, *args++); - if (func_8014A964(musicPlayer, songID, variation, fadeTime, fadeStartVolume, fadeEndVolume)) { + if (func_8014A964(musicPlayer, songID, variation, fadeTime, fadeStartVolume, fadeEndVolume)) { return ApiStatus_DONE2; } else { return ApiStatus_BLOCK; diff --git a/src/evt/model_api.c b/src/evt/model_api.c index 06c9e94146..8e8c189244 100644 --- a/src/evt/model_api.c +++ b/src/evt/model_api.c @@ -1,5 +1,9 @@ #include "model.h" +extern AnimatedModelList gBattleMeshAnimationList; +extern AnimatedModelList gWorldMeshAnimationList; +extern AnimatedModelList* gCurrentMeshAnimationListPtr; + void update_animated_models(void) { s32 i; diff --git a/src/evt/msg_api.c b/src/evt/msg_api.c index 5536b544fd..14009299c9 100644 --- a/src/evt/msg_api.c +++ b/src/evt/msg_api.c @@ -2,6 +2,11 @@ extern s32 D_802DAE50; extern s32 D_802DAE54; +extern s32 D_802DAE58[2]; // unused? +extern char D_802DAE60[0x400]; // unused? +extern MessagePrintState* gCurrentPrintContext; +extern s32 D_802DB264; +extern MessagePrintState* D_802DB268; ApiStatus _show_message(Evt* script, s32 isInitialCall, s32 arg2); diff --git a/src/evt/player_api.c b/src/evt/player_api.c index 8f8fa76359..fc0567466b 100644 --- a/src/evt/player_api.c +++ b/src/evt/player_api.c @@ -2,13 +2,15 @@ #include "npc.h" #include "sprite.h" -Npc* playerNpc = (Npc*) 0x802DB270; // TODO: raw ptr, shiftability - +extern Npc playerNpcData; extern u16 D_802DB5B0; +extern s32 D_802DB5B4[3]; // unused extern VirtualEntityList D_802DB5C0; extern VirtualEntityList D_802DB6C0; extern VirtualEntityList* D_802DB7C0; +Npc* playerNpc = &playerNpcData; + void virtual_entity_list_render_world(void); void virtual_entity_list_render_UI(void); diff --git a/src/evt/script_list.c b/src/evt/script_list.c index d1e26c8bae..f3e0f2c584 100644 --- a/src/evt/script_list.c +++ b/src/evt/script_list.c @@ -1,9 +1,86 @@ #include "common.h" +#include "hud_element.h" s32 gStaticScriptCounter = 1; s32 gIsUpdatingScripts = 0; f32 gGlobalTimeSpace = 1.0f; +// script_list +BSS u32* gMapFlags; +BSS s32* gMapVars; +BSS s32 gNumScripts; +BSS s32 D_802DA48C; // unused? +BSS ScriptList gWorldScriptList; +BSS ScriptList gBattleScriptList; +BSS ScriptList* gCurrentScriptListPtr; +BSS s32 D_802DA894; // unused? +BSS s32 gScriptIndexList[MAX_SCRIPTS]; +BSS s32 gScriptIdList[MAX_SCRIPTS]; +BSS s32 gScriptListCount; +BSS s32 D_802DAC9C; // unused? + +// evt +BSS char evtDebugPrintBuffer[0x100]; + +// map_api +BSS struct LavaReset* gLavaResetList; +BSS s32 D_802DADA4; +BSS s32 D_802DADA8[2]; // unused? + +// model_api +BSS AnimatedModelList gBattleMeshAnimationList; +BSS AnimatedModelList gWorldMeshAnimationList; +BSS AnimatedModelList* gCurrentMeshAnimationListPtr; +BSS s32 D_802DAE34[3]; // unused? + +// npc_api +BSS s32 wExtraPartnerID; +BSS s32 wExtraPartnerNpcID; +BSS s32 D_802DAE4C[2]; // unused? + +// msg_api +BSS s32 D_802DAE50; +BSS s32 D_802DAE54; +BSS s32 D_802DAE58[2]; // unused? +BSS char D_802DAE60[0x400]; // unused? +BSS MessagePrintState* gCurrentPrintContext; +BSS s32 D_802DB264; +BSS MessagePrintState* D_802DB268; +BSS s32 D_802DB26C; // unused? + +// player_api +BSS Npc playerNpcData; +BSS u16 D_802DB5B0; +BSS s32 D_802DB5B4[3]; // unused +BSS VirtualEntityList D_802DB5C0; +BSS VirtualEntityList D_802DB6C0; +BSS VirtualEntityList* D_802DB7C0; +BSS s32 D_802DB7C4[3]; // unused + +// fa4c0_len_3bf0 +BSS MusicEvent* MusicEventList; +BSS s32 D_802DB7D4; // unused? +BSS Evt* RunningMusicEvents[10]; +BSS s32 RunningMusicEventIDs[10]; +BSS s32 D_802DB828[2]; // unused? +BSS PopupMenu D_802DB830; + +// demo_api +BSS s32 D_802DBB60; +BSS s32 D_802DBB64; // unused? +BSS s32 D_802DBB68; +BSS s32 D_802DB8B6C; // unused? +BSS char D_802DBB70[0x100]; + +// why is this at the end? com section vs bss? +BSS u32 gWorldMapFlags[MAX_MAPFLAGS]; +BSS s32 DoorModelsSwingCW[3]; +BSS PushBlockGrid* D_802DBC88[8]; +BSS u32 gWorldMapVars[MAX_MAPVARS]; +BSS u32 gBattleMapVars[MAX_MAPVARS]; +BSS s32 DoorModelsSwingCCW[3]; +BSS u32 gBattleMapFlags[MAX_MAPFLAGS]; + void sort_scripts(void) { s32 temp_a0; s32 temp_a1; diff --git a/src/world/action/misc.c b/src/world/action/misc.c index 7036088d73..6f3f0bfe05 100644 --- a/src/world/action/misc.c +++ b/src/world/action/misc.c @@ -2,6 +2,8 @@ #include "world/actions.h" #include "world/partner/goombario.h" +BSS f32 D_802B6770_E27C80; + s32 action_update_ride(void) { PartnerActionStatus* partnerActionStatus = &gPartnerActionStatus; PlayerStatus* playerStatus = &gPlayerStatus; @@ -19,7 +21,7 @@ s32 action_update_ride(void) { playerStatus->pitch = 0.0f; } - if (playerStatus->animFlags & PA_FLAGS_400000) { + if (playerStatus->animFlags & PA_FLAGS_400000) { if (partnerActionStatus->actingPartner == PARTNER_LAKILESTER) { return func_802BD100_317020(oldFlags); } @@ -33,8 +35,6 @@ s32 action_update_ride(void) { #endif } -extern f32 D_802B6770_E27C80; - void action_update_state_23(void) { PlayerStatus* playerStatus = &gPlayerStatus; f32 hitDirZ; @@ -80,7 +80,7 @@ void action_update_state_23(void) { miscTempVariable = sinTheta * miscTempVariable; sin_cos_rad(DEG_TO_RAD(D_802B6770_E27C80), &sinTheta, &cosTheta); - + playerXOffset = sinTheta * miscTempVariable; playerZOffset = cosTheta * miscTempVariable; @@ -91,7 +91,7 @@ void action_update_state_23(void) { } playerXOffset = playerOffsetTempVar; } - + if (fabs(playerZOffset) < 0.1) { playerOffsetTempVar = 0.1f; if (playerZOffset < 0.0f) { @@ -99,7 +99,7 @@ void action_update_state_23(void) { } playerZOffset = playerOffsetTempVar; } - + playerStatus->position.x += playerXOffset; playerStatus->position.z -= playerZOffset; outX = playerStatus->position.x; diff --git a/src/world/action/slide.c b/src/world/action/slide.c index f8428d4e7e..124b76edfc 100644 --- a/src/world/action/slide.c +++ b/src/world/action/slide.c @@ -1,13 +1,13 @@ #include "common.h" -static f32 SlideAcceleration; -static f32 MaxSlideAccel; -static f32 MaxSlideVelocity; -static f32 SlideLaunchSpeed; -static f32 D_802B6790; -static f32 D_802B6794; -static f32 D_802B6798; -static s32 D_802B679C; +BSS f32 SlideAcceleration; +BSS f32 MaxSlideAccel; +BSS f32 MaxSlideVelocity; +BSS f32 SlideLaunchSpeed; +BSS f32 D_802B6790; +BSS f32 D_802B6794; +BSS f32 D_802B6798; +BSS s32 D_802B679C; enum { SUBSTATE_SLIDING = 0, diff --git a/src/world/action/sneaky_parasol.c b/src/world/action/sneaky_parasol.c index 21b95feaef..5fcde98884 100644 --- a/src/world/action/sneaky_parasol.c +++ b/src/world/action/sneaky_parasol.c @@ -26,7 +26,7 @@ enum { SUBSTATE_DISGUISE_FINISH_SPIN = 7, SUBSTATE_DISGUISE_DONE = 8, SUBSTATE_REVERT_INIT = 20, // begin undisguise process - SUBSTATE_REVERT_WAIT_FOR_ANGLE = 21, + SUBSTATE_REVERT_WAIT_FOR_ANGLE = 21, SUBSTATE_SPIN_DOWN = 22, SUBSTATE_FINISH_SPIN = 23, SUBSTATE_REVERT_DONE = 24, @@ -35,7 +35,7 @@ enum { SUBSTATE_BLOCKED = 50, // cant raise parasol due to collisions with world }; -extern TransformationData ParasolTransformation; +BSS TransformationData ParasolTransformation; void parasol_update_spin(void); @@ -88,7 +88,7 @@ void action_update_parasol(void) { playerStatus->unk_C2 = 0; playerStatus->currentSpeed = 0; playerStatus->pitch = 0; - + if (playerStatus->spriteFacingAngle >= 90 && playerStatus->spriteFacingAngle < 270) { phi_f4 = 2; } else { @@ -346,13 +346,13 @@ void action_update_parasol(void) { } if (transformation->disguiseTime <= 10 && transformation->disguiseTime & 1) { f64 tempX, tempZ; - + fx_sparkles(FX_SPARKLES_3, transformation->position.x - 8, transformation->position.y + 50, transformation->position.z, 2); - + /* TODO something like: angle = DEG_TO_RAD((cam->currentYaw + playerStatus->spriteFacingAngle) - 90); @@ -360,8 +360,8 @@ void action_update_parasol(void) { transformation->position.z -= (10.0 * cos_rad(angle)); */ - angle = DEG_TO_RAD((cam->currentYaw + playerStatus->spriteFacingAngle) - 90); - + angle = DEG_TO_RAD((cam->currentYaw + playerStatus->spriteFacingAngle) - 90); + tempX = transformation->position.x; tempX += 10.0 * sin_rad(angle); transformation->position.x = tempX; diff --git a/src/world/action/use_munchlesia.c b/src/world/action/use_munchlesia.c index 0f22e29385..9921308c44 100644 --- a/src/world/action/use_munchlesia.c +++ b/src/world/action/use_munchlesia.c @@ -1,10 +1,10 @@ #include "common.h" -extern f32 Munchlesia_LaunchVelocity; -extern f32 Munchlesia_LateralVelocity; -extern f32 Munchlesia_LaunchAccel; -extern f32 Munchlesia_LaunchYaw; -extern s32 D_802B62E0; +BSS f32 Munchlesia_LaunchVelocity; +BSS f32 Munchlesia_LateralVelocity; +BSS f32 Munchlesia_LaunchAccel; +BSS f32 Munchlesia_LaunchYaw; +BSS s32 D_802B62E0; enum { SUBSTATE_INIT = 0, diff --git a/src/world/action/use_spinning_flower.c b/src/world/action/use_spinning_flower.c index d5e9581435..a803e55f6d 100644 --- a/src/world/action/use_spinning_flower.c +++ b/src/world/action/use_spinning_flower.c @@ -1,15 +1,16 @@ #include "common.h" -extern s32 SpinningFlower_EntityIndex; -extern f32 D_802B6ED4; -extern f32 D_802B6ED8; -extern f32 D_802B6EDC; -extern f32 D_802B6EE0; -extern f32 D_802B6EE4; -extern f32 D_802B6EE8; -extern f32 SpinningFlower_AngleToCenter; -extern f32 D_802B6EF0; -extern f32 D_802B6EF4; +BSS s32 SpinningFlower_EntityIndex; +BSS f32 D_802B6ED4; +BSS f32 D_802B6ED8; +BSS f32 D_802B6EDC; +BSS f32 D_802B6EE0; +BSS f32 D_802B6EE4; +BSS f32 D_802B6EE8; +BSS f32 SpinningFlower_AngleToCenter; +BSS f32 D_802B6EF0; +BSS f32 D_802B6EF4; + extern s16 D_802BCE30; extern s16 D_802BCE32; extern s16 D_802BCE34; diff --git a/tools/splat/.github/workflows/mypy.yml b/tools/splat/.github/workflows/mypy.yml index 1896b3b7f2..d5bb1fa083 100644 --- a/tools/splat/.github/workflows/mypy.yml +++ b/tools/splat/.github/workflows/mypy.yml @@ -23,4 +23,4 @@ jobs: - name: mypy run: mypy --show-column-numbers --hide-error-context . - name: black - run: black . + run: black --check . diff --git a/tools/splat/.gitrepo b/tools/splat/.gitrepo index 65bc3e3d4f..15f648dcff 100644 --- a/tools/splat/.gitrepo +++ b/tools/splat/.gitrepo @@ -6,7 +6,7 @@ [subrepo] remote = https://github.com/ethteck/splat.git branch = master - commit = 6c02ec5ecdc1c742ce8ad6cd57480ad65bc802cd - parent = c09278de7a93519feec010692b0be377d5e860de + commit = 9af40c526558452a14b113c3d44b0382d038d65c + parent = 268eb8e88164dcb3858634f62d9f33f8f41407c1 method = merge cmdver = 0.4.3 diff --git a/tools/splat/CHANGELOG.md b/tools/splat/CHANGELOG.md index 81ad1fb905..95317e657d 100644 --- a/tools/splat/CHANGELOG.md +++ b/tools/splat/CHANGELOG.md @@ -1,6 +1,16 @@ # splat Release Notes -### 0.10.0: The Linker Script Update +## 0.11.0: Spimdisasm Returns + +Spimdisasm now handles data (data, rodata, bss) disassembly in splat! This includes a few changes in behavior: + +* Rodata will be migrated to c files' asm function files when a .rodata subsegment is used that corresponds with an identically-named c file. Some symbols may not be automatically migrated to functions when it is not clear if they belong to the function itself (an example of which being const arrays). In this case, the `partial_migration` option can be enabled for the given .rodata subsegment and splat will create .s files for these unmigrated rodata symbols. These files can then be included in your c files, or you can go ahead and migrate these symbols to c and disable the `partial_migration` feature. + +* BSS can now be disassembled as well, and the size of a code segment's bss section can be specified with the `bss_size` option. This option will tell splat how large the bss section is in bytes so BSS can properly be handled during disassembly. For bss subsegments, the rom address will of course not change, but the vram address should still be specified. This currently can only be done in the dict form of segment representation, rather than the list form. + +Thanks again to [AngheloAlf](https://github.com/AngheloAlf) for adding this functionality and continuing to improve splat's disassembler. + +## 0.10.0: The Linker Script Update Linker scripts splat produces are now capable of being shift-friendly. Rom addresses will automatically shift, and ram addresses will still be hard-coded unless the new segment option `follows_vram` is specified. The value of this option should be the name of a segment (a) that this segment (b) should follow in memory. If a grows or shrinks, b's start address will also do so to accommodate it. diff --git a/tools/splat/create_config.py b/tools/splat/create_config.py index fb16441d0d..edf55a7668 100755 --- a/tools/splat/create_config.py +++ b/tools/splat/create_config.py @@ -36,7 +36,6 @@ options: # undefined_syms_auto: True # undefined_syms_auto_path: undefined_syms_auto.txt # symbol_addrs_path: symbol_addrs.txt - # undefined_syms_path: undefined_syms.txt # asm_path: asm # src_path: src # build_path: build diff --git a/tools/splat/requirements.txt b/tools/splat/requirements.txt index f23d08d46f..bf8ff7e63b 100644 --- a/tools/splat/requirements.txt +++ b/tools/splat/requirements.txt @@ -2,8 +2,8 @@ PyYAML pylibyaml pypng colorama -spimdisasm>=1.2.1 -rabbitizer +spimdisasm>=1.5.3 +rabbitizer>=1.2.0 pygfxd tqdm intervaltree diff --git a/tools/splat/segtypes/common/asm.py b/tools/splat/segtypes/common/asm.py index b8aa69462e..8641bd3749 100644 --- a/tools/splat/segtypes/common/asm.py +++ b/tools/splat/segtypes/common/asm.py @@ -21,7 +21,7 @@ class CommonSegAsm(CommonSegCodeSubsegment): return [] def split(self, rom_bytes: bytes): - if not self.rom_start == self.rom_end: + if not self.rom_start == self.rom_end and self.spim_section is not None: out_path = self.out_path() if out_path: out_path.parent.mkdir(parents=True, exist_ok=True) @@ -31,4 +31,4 @@ class CommonSegAsm(CommonSegCodeSubsegment): with open(out_path, "w", newline="\n") as f: for line in self.get_file_header(): f.write(line + "\n") - f.write(self.text_section.disassemble()) + f.write(self.spim_section.disassemble()) diff --git a/tools/splat/segtypes/common/bss.py b/tools/splat/segtypes/common/bss.py index 195409aca8..b03f7e5083 100644 --- a/tools/splat/segtypes/common/bss.py +++ b/tools/splat/segtypes/common/bss.py @@ -1,28 +1,51 @@ +import spimdisasm +from typing import List + from segtypes.common.data import CommonSegData from segtypes.linker_entry import LinkerEntry -from util import options, log - -from typing import List +from util import options, symbols class CommonSegBss(CommonSegData): def get_linker_section(self) -> str: return ".bss" - def scan(self, rom_bytes: bytes): - pass + def disassemble_data(self, rom_bytes: bytes): + assert isinstance(self.rom_start, int) + assert isinstance(self.rom_end, int) - def split(self, rom_bytes: bytes): - pass + segment_rom_start = self.get_most_parent().rom_start + assert isinstance(segment_rom_start, int) - def get_linker_entries(self) -> "List[LinkerEntry]": - - if self.sibling: - path = self.sibling.out_path() + next_subsegment = self.parent.get_next_subsegment_for_ram(self.vram_start) + if next_subsegment is None: + bss_end = self.get_most_parent().vram_end + assert isinstance(bss_end, int) else: - path = self.out_path() + bss_end = next_subsegment.vram_start - if path: - return [LinkerEntry(self, [path], path, self.get_linker_section())] - else: - return [] + self.spim_section = spimdisasm.mips.sections.SectionBss( + symbols.spim_context, + self.rom_start, + self.rom_end, + self.vram_start, + bss_end, + self.name, + segment_rom_start, + self.get_exclusive_ram_id(), + ) + + for symbol_list in self.seg_symbols.values(): + symbols.add_symbol_to_spim_section(self.spim_section, symbol_list[0]) + + for sym in symbols.all_symbols: + if sym.user_declared: + symbols.add_symbol_to_spim_section(self.spim_section, sym) + + self.spim_section.analyze() + self.spim_section.setCommentOffset(self.rom_start) + + for spim_sym in self.spim_section.symbolList: + symbols.create_symbol_from_spim_symbol( + self.get_most_parent(), spim_sym.contextSym + ) diff --git a/tools/splat/segtypes/common/c.py b/tools/splat/segtypes/common/c.py index 1cdac143de..8d2e0d8036 100644 --- a/tools/splat/segtypes/common/c.py +++ b/tools/splat/segtypes/common/c.py @@ -1,11 +1,11 @@ from segtypes.common.codesubsegment import CommonSegCodeSubsegment from segtypes.common.group import CommonSegGroup +from segtypes.common.rodata import CommonSegRodata from typing import Optional, Set import os import re from pathlib import Path import spimdisasm -import rabbitizer from util import log, options from util.compiler import GCC, SN64 @@ -134,8 +134,10 @@ class CommonSegC(CommonSegCodeSubsegment): self.create_c_file(asm_out_dir, c_path) is_new_c_file = True - for func in self.text_section.symbolList: + assert self.spim_section is not None + for func in self.spim_section.symbolList: assert func.vram is not None + assert isinstance(func, spimdisasm.mips.symbols.SymbolFunction) func_sym = self.get_symbol( func.vram, in_segment=True, type="func", local_only=True ) @@ -166,7 +168,7 @@ class CommonSegC(CommonSegCodeSubsegment): break def create_c_asm_file( - self, func: spimdisasm.mips.symbols.SymbolBase, out_dir, func_sym: Symbol + self, func: spimdisasm.mips.symbols.SymbolFunction, out_dir, func_sym: Symbol ): outpath = Path(os.path.join(out_dir, self.name, func_sym.name + ".s")) assert func.vram is not None @@ -175,53 +177,67 @@ class CommonSegC(CommonSegCodeSubsegment): if outpath.exists() and not func_sym.extract: return - out_lines = [] - - if options.asm_inc_header(): - out_lines.extend(options.asm_inc_header().split("\n")) - - if self.parent and isinstance(self.parent, CommonSegGroup): - if ( - options.get_migrate_rodata_to_functions() - and func.vram in self.parent.rodata_syms - ): - func_rodata = list( - {s for s in self.parent.rodata_syms[func.vram] if s.disasm_str} - ) - func_rodata.sort(key=lambda s: s.vram_start) - - if len(func_rodata) > 0: - rsub = self.parent.get_subsegment_for_ram(func_rodata[0].vram_start) - if rsub and rsub.type != "rodata": - out_lines.append(".section .rodata") - - for sym in func_rodata: - if sym.extract and sym.disasm_str: - out_lines.append("") - out_lines.append( - f"{options.get_asm_data_macro()} {sym.name}" - ) - out_lines.extend( - sym.disasm_str.replace("\n\n", "\n").split("\n") - ) - - out_lines.append("") - out_lines.append(".section .text") - out_lines.append("") - - out_lines.append(func.disassemble()) - outpath.parent.mkdir(parents=True, exist_ok=True) with open(outpath, "w", newline="\n") as f: - newline_sep = options.c_newline() - f.write(newline_sep.join(out_lines)) + if options.asm_inc_header(): + f.write(options.c_newline().join(options.asm_inc_header().split("\n"))) + + if self.parent and isinstance(self.parent, CommonSegGroup): + if ( + options.get_migrate_rodata_to_functions() + and func.vram in self.parent.rodata_syms + ): + func_rodata = list({s for s in self.parent.rodata_syms[func.vram]}) + func_rodata.sort(key=lambda s: s.vram_start) + + rdata_list = [] + late_rodata_list = [] + late_rodata_size = 0 + + processed_rodata_segments = set() + for func_rodata_symbol in func_rodata: + rsub = self.parent.get_subsegment_for_ram( + func_rodata_symbol.vram_start + ) + + if rsub is not None and isinstance(rsub, CommonSegRodata): + if ( + rsub in processed_rodata_segments + or rsub.spim_section is None + ): + continue + + assert isinstance( + rsub.spim_section, + spimdisasm.mips.sections.SectionRodata, + ) + ( + rdata_list_aux, + late_rodata_list_aux, + late_rodata_size_aux, + ) = spimdisasm.mips.FilesHandlers.getRdataAndLateRodataForFunctionFromSection( + func, rsub.spim_section + ) + rdata_list += rdata_list_aux + late_rodata_list += late_rodata_list_aux + late_rodata_size += late_rodata_size_aux + + processed_rodata_segments.add(rsub) + spimdisasm.mips.FilesHandlers.writeFunctionRodataToFile( + f, func, rdata_list, late_rodata_list, late_rodata_size + ) + + f.write(func.disassemble()) + self.log(f"Disassembled {func_sym.name} to {outpath}") def create_c_file(self, asm_out_dir, c_path): + assert self.spim_section is not None + c_lines = self.get_c_preamble() - for func in self.text_section.symbolList: + for func in self.spim_section.symbolList: assert isinstance(func, spimdisasm.mips.symbols.SymbolFunction) # Terrible hack to "auto-decompile" empty functions diff --git a/tools/splat/segtypes/common/code.py b/tools/splat/segtypes/common/code.py index 837caaeef2..6c6cade960 100644 --- a/tools/splat/segtypes/common/code.py +++ b/tools/splat/segtypes/common/code.py @@ -67,21 +67,6 @@ class CommonSegCode(CommonSegGroup): else: return None - # def ram_to_rom(self, ram_addr: int) -> Optional[int]: - # size_no_bss = self.vram_start + self.size - - # # Do not return a rom address if this is a BSS symbol - # if ram_addr > size_no_bss: - # return None - - # if not self.contains_vram(ram_addr) and ram_addr != self.vram_end: - # return None - - # if self.vram_start is not None and isinstance(self.rom_start, int): - # return self.rom_start + ram_addr - self.vram_start - # else: - # return None - # Prepare symbol for migration to the function def check_rodata_sym(self, func_addr: int, sym: Symbol): if self.section_boundaries[".rodata"].is_complete(): diff --git a/tools/splat/segtypes/common/codesubsegment.py b/tools/splat/segtypes/common/codesubsegment.py index da6b4d548a..a2b69f98d6 100644 --- a/tools/splat/segtypes/common/codesubsegment.py +++ b/tools/splat/segtypes/common/codesubsegment.py @@ -1,39 +1,55 @@ +from typing import Optional from util import options from segtypes.common.code import CommonSegCode import spimdisasm -import rabbitizer from segtypes.segment import Segment -from util.symbols import Symbol +from segtypes import segment from util import symbols # abstract class for c, asm, data, etc class CommonSegCodeSubsegment(Segment): - double_mnemonics = [ - rabbitizer.InstrId.cpu_ldc1, - rabbitizer.InstrId.cpu_sdc1, - ] - word_mnemonics = [ - rabbitizer.InstrId.cpu_addiu, - rabbitizer.InstrId.cpu_sw, - rabbitizer.InstrId.cpu_lw, - ] - float_mnemonics = [ - rabbitizer.InstrId.cpu_lwc1, - rabbitizer.InstrId.cpu_swc1, - ] - short_mnemonics = [ - rabbitizer.InstrId.cpu_addiu, - rabbitizer.InstrId.cpu_lh, - rabbitizer.InstrId.cpu_sh, - rabbitizer.InstrId.cpu_lhu, - ] - byte_mnemonics = [ - rabbitizer.InstrId.cpu_lb, - rabbitizer.InstrId.cpu_sb, - rabbitizer.InstrId.cpu_lbu, - ] + def __init__( + self, + rom_start, + rom_end, + type, + name, + vram_start, + extract, + given_subalign, + exclusive_ram_id, + given_dir, + symbol_name_format, + symbol_name_format_no_rom, + args, + yaml, + ): + vram = segment.parse_segment_vram(yaml) + if vram is not None: + vram_start = vram + self.partial_migration: bool = ( + yaml.get("partial_migration", False) if isinstance(yaml, dict) else False + ) + + super().__init__( + rom_start, + rom_end, + type, + name, + vram_start, + extract, + given_subalign, + exclusive_ram_id=exclusive_ram_id, + given_dir=given_dir, + symbol_name_format=symbol_name_format, + symbol_name_format_no_rom=symbol_name_format_no_rom, + args=args, + yaml=yaml, + ) + + self.spim_section: Optional[spimdisasm.mips.sections.SectionBase] = None @property def needs_symbols(self) -> bool: @@ -43,30 +59,36 @@ class CommonSegCodeSubsegment(Segment): return ".text" def scan_code(self, rom_bytes, is_asm=False): - self.text_section = spimdisasm.mips.sections.SectionText( + assert isinstance(self.rom_start, int) + assert isinstance(self.rom_end, int) + + segment_rom_start = self.get_most_parent().rom_start + assert isinstance(segment_rom_start, int) + + self.spim_section = spimdisasm.mips.sections.SectionText( symbols.spim_context, self.rom_start, self.rom_end, self.vram_start, self.name, rom_bytes, - self.get_most_parent().rom_start, + segment_rom_start, self.get_exclusive_ram_id(), ) for symbol_list in self.seg_symbols.values(): - symbols.add_symbol_to_spim_section(self.text_section, symbol_list[0]) + symbols.add_symbol_to_spim_section(self.spim_section, symbol_list[0]) for sym in symbols.all_symbols: if sym.user_declared: - symbols.add_symbol_to_spim_section(self.text_section, sym) + symbols.add_symbol_to_spim_section(self.spim_section, sym) - self.text_section.isHandwritten = is_asm + self.spim_section.isHandwritten = is_asm - self.text_section.analyze() - self.text_section.setCommentOffset(self.rom_start) + self.spim_section.analyze() + self.spim_section.setCommentOffset(self.rom_start) - for func in self.text_section.symbolList: + for func in self.spim_section.symbolList: assert isinstance(func, spimdisasm.mips.symbols.SymbolFunction) self.process_insns(func) @@ -78,7 +100,7 @@ class CommonSegCodeSubsegment(Segment): jtbl_label_vram, True, type="jtbl_label", define=True ) sym.type = "jtbl_label" - symbols.add_symbol_to_spim_section(self.text_section, sym) + symbols.add_symbol_to_spim_section(self.spim_section, sym) def process_insns( self, @@ -87,6 +109,7 @@ class CommonSegCodeSubsegment(Segment): assert isinstance(self.parent, CommonSegCode) assert func_spim.vram is not None assert func_spim.vramEnd is not None + assert self.spim_section is not None self.parent: CommonSegCode = self.parent symbols.create_symbol_from_spim_symbol( @@ -95,7 +118,7 @@ class CommonSegCodeSubsegment(Segment): # Gather symbols found by spimdisasm and create those symbols in splat's side for referenced_vram in func_spim.instrAnalyzer.referencedVrams: - context_sym = self.text_section.getSymbol( + context_sym = self.spim_section.getSymbol( referenced_vram, tryPlusOffset=False ) if context_sym is not None: @@ -116,7 +139,7 @@ class CommonSegCodeSubsegment(Segment): if instr_offset in func_spim.instrAnalyzer.symbolInstrOffset: sym_address = func_spim.instrAnalyzer.symbolInstrOffset[instr_offset] - context_sym = self.text_section.getSymbol( + context_sym = self.spim_section.getSymbol( sym_address, tryPlusOffset=False ) if context_sym is not None: @@ -124,68 +147,41 @@ class CommonSegCodeSubsegment(Segment): self.get_most_parent(), context_sym ) - if any( - insn.uniqueId in mnemonics - for mnemonics in ( - self.double_mnemonics, - self.word_mnemonics, - self.float_mnemonics, - self.short_mnemonics, - self.byte_mnemonics, - ) - ): - self.update_access_mnemonic(sym, insn) - if self.parent: self.parent.check_rodata_sym(func_spim.vram, sym) - def update_access_mnemonic(self, sym: Symbol, insn: rabbitizer.Instruction): - if not sym.access_mnemonic: - sym.access_mnemonic = insn.uniqueId - elif sym.access_mnemonic in self.double_mnemonics: - return - elif ( - sym.access_mnemonic in self.float_mnemonics - and insn.uniqueId in self.double_mnemonics - ): - sym.access_mnemonic = insn.uniqueId - elif sym.access_mnemonic == rabbitizer.InstrId.cpu_addiu: - sym.access_mnemonic = insn.uniqueId - elif sym.access_mnemonic in self.short_mnemonics: - return - elif sym.access_mnemonic in self.byte_mnemonics: - return - else: - sym.access_mnemonic = insn.uniqueId - def print_file_boundaries(self): - if not options.find_file_boundaries(): + if not options.find_file_boundaries() or not self.spim_section: return - for in_file_offset in self.text_section.fileBoundaries: + assert isinstance(self.rom_start, int) + + for in_file_offset in self.spim_section.fileBoundaries: if (in_file_offset % 16) != 0: continue if not self.parent.reported_file_split: self.parent.reported_file_split = True - # Look up for the last function in this boundary - func_addr = 0 - for func in self.text_section.symbolList: - funcOffset = func.inFileOffset - self.text_section.inFileOffset - if in_file_offset == funcOffset: + # Look up for the last symbol in this boundary + sym_addr = 0 + for sym in self.spim_section.symbolList: + symOffset = sym.inFileOffset - self.spim_section.inFileOffset + if in_file_offset == symOffset: break - func_addr = func.vram + sym_addr = sym.vram print( - f"Segment {self.name}, function at vram {func_addr:X} ends with extra nops, indicating a likely file split." + f"\nSegment {self.name}, symbol at vram {sym_addr:X} ends with extra nops, indicating a likely file split." ) print( "File split suggestions for this segment will follow in config yaml format:" ) - print(f" - [0x{self.rom_start+in_file_offset:X}, asm]") + print(f" - [0x{self.rom_start+in_file_offset:X}, {self.type}]") def gather_jumptable_labels(self, rom_bytes): + assert isinstance(self.rom_start, int) + # TODO: use the seg_symbols for this # jumptables = [j.type == "jtbl" for j in self.seg_symbols] for jumptable in self.parent.jumptables: @@ -213,4 +209,4 @@ class CommonSegCodeSubsegment(Segment): ) def should_split(self) -> bool: - return self.extract and options.mode_active("code") + return self.extract and (self.partial_migration or options.mode_active("code")) diff --git a/tools/splat/segtypes/common/data.py b/tools/splat/segtypes/common/data.py index 07e625bb48..6fc2d2a489 100644 --- a/tools/splat/segtypes/common/data.py +++ b/tools/splat/segtypes/common/data.py @@ -1,11 +1,10 @@ -from segtypes.common.code import CommonSegCode +import spimdisasm + from segtypes.common.codesubsegment import CommonSegCodeSubsegment from segtypes.common.group import CommonSegGroup from pathlib import Path -from typing import List, Optional -import rabbitizer -from util.symbols import Symbol -from util import floats, options +from typing import Optional +from util import options, symbols class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup): @@ -25,21 +24,31 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup): CommonSegGroup.scan(self, rom_bytes) if super().should_scan(): - self.file_text = self.disassemble_data(rom_bytes) - else: - self.file_text = None + self.disassemble_data(rom_bytes) def split(self, rom_bytes: bytes): - CommonSegGroup.split(self, rom_bytes) + super().split(rom_bytes) - if not self.type.startswith(".") and self.file_text: + if ( + not self.type.startswith(".") + and self.spim_section + and self.should_self_split() + ): path = self.out_path() if path: path.parent.mkdir(parents=True, exist_ok=True) + self.print_file_boundaries() + with open(path, "w", newline="\n") as f: - f.write(self.file_text) + f.write('.include "macro.inc"\n\n') + f.write(f".section {self.get_linker_section()}\n\n") + + f.write(self.spim_section.disassemble()) + + def should_self_split(self) -> bool: + return options.mode_active("data") def should_split(self) -> bool: return True @@ -56,374 +65,50 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup): def get_linker_entries(self): return CommonSegCodeSubsegment.get_linker_entries(self) - # Check symbols marked as jump tables to be valid - def check_jtbls(self, rom_bytes, syms: List[Symbol]): - endianness = options.get_endianess() - - for i, sym in enumerate(syms): - if sym.type == "jtbl": - start = self.get_most_parent().ram_to_rom(syms[i].vram_start) - assert isinstance(start, int) - end = self.get_most_parent().ram_to_rom(syms[i + 1].vram_start) - sym_bytes = rom_bytes[start:end] - - b = 0 - last_bits = 0 - while b < len(sym_bytes): - bits = int.from_bytes(sym_bytes[b : b + 4], endianness) - - if ( - last_bits != 0 - and bits != 0 - and abs(last_bits - bits) > 0x100000 - ): - new_sym_rom_start = start + b - new_sym_ram_start = self.get_most_parent().rom_to_ram( - new_sym_rom_start - ) - assert sym.rom is not None - assert new_sym_ram_start is not None - sym.given_size = new_sym_rom_start - sym.rom - - # It turns out this isn't a valid jump table, so create a new symbol where it breaks - syms.insert( - i + 1, - self.create_symbol( - new_sym_ram_start, True, define=True, local_only=True - ), - ) - return False - - if bits != 0: - last_bits = bits - b += 4 - - return True - - def get_symbols(self, rom_bytes) -> List[Symbol]: - symset = set() - endian = options.get_endianess() - - # Find inter-data symbols - assert isinstance(self.rom_start, int) and isinstance(self.rom_end, int) - for i in range(self.rom_start, self.rom_end, 4): - bits = int.from_bytes(rom_bytes[i : i + 4], endian) - if self.contains_vram(bits): - symset.add( - self.create_symbol( - bits, in_segment=True, define=True, local_only=True - ) - ) - - for symbol_addr in self.seg_symbols: - for symbol in self.seg_symbols[symbol_addr]: - if not symbol.dead and self.contains_vram(symbol.vram_start): - symset.add(symbol) - - ret: List[Symbol] = list(symset) - ret.sort(key=lambda s: s.vram_start) - - # Ensure we start at the beginning - if len(ret) == 0 or ret[0].vram_start != self.vram_start: - ret.insert( - 0, - self.create_symbol( - self.vram_start, in_segment=True, define=True, local_only=True - ), - ) - - # Make a dummy symbol here that marks the end of the previous symbol's disasm range - assert self.vram_end is not None - ret.append(Symbol(self.vram_end)) - - while True: - valid = self.check_jtbls(rom_bytes, ret) - if valid: - break - - return ret - - def are_null(chars): - for b in chars: - if b != "\x00": - return False - return True - - @staticmethod - def is_valid_ascii(bytes): - null_char = "\x00" - valid_chars = ( - "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890[]():%!#=-_ " - ) - invalid_chars = "" - duplicate_limit = 10 - - last_char = 0 - true_end = None - consecutive_duplicates = 0 - valid_count = 0 - - if len(bytes) <= 4 or bytes[0] == 0: - return False - - try: - chars = bytes.decode("EUC-JP") - except: - return False - - if len(chars) <= 4: - return False - - for i, c in enumerate(chars): - # Ensure null bytes are only at the end of ascii strings - # TODO: if we find null bytes in the middle, break this into multiple strings ? - if c == null_char: - if true_end is None: - if CommonSegData.are_null(chars[i:]): - true_end = i - else: - pass - # return False - - # Ensure we're not seeing a ton of the same character in a row - if last_char == c: - consecutive_duplicates += 1 - if consecutive_duplicates >= duplicate_limit and last_char != null_char: - return False - else: - consecutive_duplicates = 0 - - if c in valid_chars: - valid_count += 1 - elif c in invalid_chars: - return False - - last_char = c - - # Ensure the number of valid characters is sufficient - if true_end is not None: - # If there are more than 16 null chars at the end, something is afoot - if len(chars) - true_end > 16: - return False - end = true_end - else: - end = len(chars) - - valid_ratio = valid_count / end - if valid_ratio >= 0.75: - return True - - return False - - # TODO if we see a new function's jtbl, split it - def is_valid_jtbl(self, sym: Symbol, bytes) -> bool: - min_jtbl_len = 16 - - if len(bytes) % 4 != 0: - return False - - # Jump tables must have at least 3 labels - if len(bytes) < min_jtbl_len: - return False - - most_parent = self.get_most_parent() - assert isinstance(most_parent, CommonSegCode) - - # Grab the first word and see if its value is an address within a function - word = int.from_bytes(bytes[0:4], options.get_endianess()) - jtbl_func: Optional[Symbol] = self.get_most_parent().get_func_for_addr(word) - - if not jtbl_func: - return False - - # A label of a jump table shouldn't point to the start of the function - if word == jtbl_func.vram_start: - return False - - for i in range(4, len(bytes), 4): - word = int.from_bytes(bytes[i : i + 4], options.get_endianess()) - - # If the word doesn't contain an address in the current function, this isn't a valid jump table - if not jtbl_func.contains_vram(word): - # Allow jump tables that are of a minimum length and end in 0s - if i < min_jtbl_len or any(b != 0 for b in bytes[i:]): - return False - - # A label of a jump table shouldn't point to the start of the function - if word == jtbl_func.vram_start: - return False - - # Mark this symbol as a jump table and record the jump table for later - sym.type = "jtbl" - most_parent.jumptables[sym.vram_start] = ( - jtbl_func.vram_start, - jtbl_func.vram_end, - ) - return True - - def disassemble_symbol(self, sym_bytes, sym_type): - endian = options.get_endianess() - if sym_type == "jtbl": - sym_str = ".word " - else: - sym_str = f".{sym_type} " - - if sym_type == "double": - slen = 8 - elif sym_type == "short": - slen = 2 - elif sym_type == "byte": - slen = 1 - else: - slen = 4 - - if sym_type == "ascii": - try: - ascii_str = sym_bytes.decode("EUC-JP") - # ascii_str = ascii_str.rstrip("\x00") - ascii_str = ascii_str.replace("\\", "\\\\") # escape back slashes - ascii_str = ascii_str.replace('"', '\\"') # escape quotes - ascii_str = ascii_str.replace("\x00", "\\0") - ascii_str = ascii_str.replace("\n", "\\n") - - sym_str += f'"{ascii_str}"' - return sym_str - except: - return self.disassemble_symbol(sym_bytes, "word") - - i = 0 - while i < len(sym_bytes): - adv_amt = min(slen, len(sym_bytes) - i) - bits = int.from_bytes(sym_bytes[i : i + adv_amt], endian) - - if sym_type == "jtbl": - if bits == 0: - byte_str = "0" - else: - sym = self.get_symbol(bits, True) - if sym is not None: - byte_str = sym.name - else: - byte_str = f"0x{bits:X}" - elif slen == 4 and bits >= 0x80000000: - sym = self.get_symbol(bits, reference=True) - if sym and sym.type not in ["label", "jtbl"]: - byte_str = sym.name - else: - byte_str = "0x{0:0{1}X}".format(bits, 2 * slen) - else: - byte_str = "0x{0:0{1}X}".format(bits, 2 * slen) - - if sym_type in ["float", "double"]: - if sym_type == "float": - float_str = floats.format_f32_imm(bits) - else: - float_str = floats.format_f64_imm(bits) - - # Fall back to .word if we see weird float values - # TODO: cut the symbol in half maybe where we see the first nan or something - if "e-" in float_str or "nan" in float_str: - return self.disassemble_symbol(sym_bytes, "word") - else: - byte_str = float_str - - sym_str += byte_str - - i += adv_amt - - if i < len(sym_bytes): - sym_str += ", " - - return sym_str - def disassemble_data(self, rom_bytes): - rodata_encountered = "rodata" in self.type - ret = '.include "macro.inc"\n\n' - ret += f".section {self.get_linker_section()}" + assert isinstance(self.rom_start, int) + assert isinstance(self.rom_end, int) - if self.size == 0: - return None + segment_rom_start = self.get_most_parent().rom_start + assert isinstance(segment_rom_start, int) - syms = self.get_symbols(rom_bytes) + self.spim_section = spimdisasm.mips.sections.SectionData( + symbols.spim_context, + self.rom_start, + self.rom_end, + self.vram_start, + self.name, + rom_bytes, + segment_rom_start, + self.get_exclusive_ram_id(), + ) - for i in range(len(syms) - 1): - mnemonic = syms[i].access_mnemonic - sym = self.create_symbol( - syms[i].vram_start, in_segment=True, define=True, local_only=True + for symbol_list in self.seg_symbols.values(): + symbols.add_symbol_to_spim_section(self.spim_section, symbol_list[0]) + + for sym in symbols.all_symbols: + if sym.user_declared: + symbols.add_symbol_to_spim_section(self.spim_section, sym) + + self.spim_section.analyze() + self.spim_section.setCommentOffset(self.rom_start) + + rodata_encountered = False + + for symbol in self.spim_section.symbolList: + symbols.create_symbol_from_spim_symbol( + self.get_most_parent(), symbol.contextSym ) - dis_start = self.get_most_parent().ram_to_rom(syms[i].vram_start) - dis_end = self.get_most_parent().ram_to_rom(syms[i + 1].vram_start) - assert dis_start is not None and dis_end is not None - sym_len = dis_end - dis_start - - if self.type == "bss": - disasm_str = f".space 0x{sym_len:X}" - else: - sym_bytes = rom_bytes[dis_start:dis_end] - - # Checking if the mnemonic is addiu may be too picky - we'll see - if ( - self.is_valid_ascii(sym_bytes) - and mnemonic == rabbitizer.InstrId.cpu_addiu - ): - stype = "ascii" - elif sym.type == "jtbl": - stype = "jtbl" - elif self.is_valid_jtbl(sym, sym_bytes): - stype = "jtbl" - elif ( - len(sym_bytes) % 8 == 0 - and mnemonic in CommonSegCodeSubsegment.double_mnemonics - ): - stype = "double" - elif ( - len(sym_bytes) % 4 == 0 - and mnemonic in CommonSegCodeSubsegment.float_mnemonics - ): - stype = "float" - elif ( - len(sym_bytes) % 4 == 0 - and sym.vram_start % 4 == 0 - and ( - mnemonic in CommonSegCodeSubsegment.word_mnemonics - or not mnemonic - ) - ): - stype = "word" - elif ( - len(sym_bytes) % 2 == 0 - and sym.vram_start % 2 == 0 - and ( - mnemonic in CommonSegCodeSubsegment.short_mnemonics - or not mnemonic - ) - ): - stype = "short" - else: - stype = "byte" - - # If we're starting from a weird place, make sure our container size is correct - if dis_start % 4 != 0 and stype != "byte" and sym_len > 1: - stype = "short" - if dis_start % 2 != 0: - stype = "byte" - - # Hint to the user that we are now in the .rodata section and no longer in the .data section (assuming rodata follows data) - if ( - not rodata_encountered - and stype == "jtbl" - and self.get_most_parent().rodata_follows_data - ): + # Hint to the user that we are now in the .rodata section and no longer in the .data section (assuming rodata follows data) + if not rodata_encountered and self.get_most_parent().rodata_follows_data: + if symbol.contextSym.isJumpTable(): rodata_encountered = True - ret += "\n\n\n.section .rodata" - - disasm_str = self.disassemble_symbol(sym_bytes, stype) - - sym.disasm_str = disasm_str - name_str = f"\n\n{options.get_asm_data_macro()} {sym.name}\n" - ret += name_str + disasm_str - - ret += "\n" - - return ret + print( + f"Data segment {self.name}, symbol at vram {symbol.contextSym.vram:X} is a jumptable, indicating the start of the rodata section _may_ be near here." + ) + print( + f"Please note the real start of the rodata section may be way before this point." + ) + if symbol.contextSym.vromAddress is not None: + print(f" - [0x{symbol.contextSym.vromAddress:X}, rodata]") diff --git a/tools/splat/segtypes/common/group.py b/tools/splat/segtypes/common/group.py index f53feea0aa..da044c7a38 100644 --- a/tools/splat/segtypes/common/group.py +++ b/tools/splat/segtypes/common/group.py @@ -129,3 +129,17 @@ class CommonSegGroup(CommonSegment): if sub.contains_vram(addr): return sub return None + + def get_next_subsegment_for_ram(self, addr: int) -> Optional[Segment]: + """ + Returns the first subsegment which comes after the specified address, + or None in case this address belongs to the last subsegment of this group + """ + + for sub in self.subsegments: + if sub.vram_start == "auto": + continue + assert isinstance(sub.vram_start, int) + if sub.vram_start > addr: + return sub + return None diff --git a/tools/splat/segtypes/common/hasm.py b/tools/splat/segtypes/common/hasm.py index e8dcf17698..e0087f7629 100644 --- a/tools/splat/segtypes/common/hasm.py +++ b/tools/splat/segtypes/common/hasm.py @@ -3,7 +3,7 @@ from segtypes.common.asm import CommonSegAsm class CommonSegHasm(CommonSegAsm): def split(self, rom_bytes: bytes): - if not self.rom_start == self.rom_end: + if not self.rom_start == self.rom_end and self.spim_section is not None: out_path = self.out_path() if out_path and not out_path.exists(): out_path.parent.mkdir(parents=True, exist_ok=True) @@ -13,4 +13,4 @@ class CommonSegHasm(CommonSegAsm): with open(out_path, "w", newline="\n") as f: for line in self.get_file_header(): f.write(line + "\n") - f.write(self.text_section.disassemble()) + f.write(self.spim_section.disassemble()) diff --git a/tools/splat/segtypes/common/rdata.py b/tools/splat/segtypes/common/rdata.py index 9c0ee300ce..37adbef22e 100644 --- a/tools/splat/segtypes/common/rdata.py +++ b/tools/splat/segtypes/common/rdata.py @@ -1,6 +1,6 @@ -from segtypes.common.data import CommonSegData +from segtypes.common.rodata import CommonSegRodata -class CommonSegRdata(CommonSegData): +class CommonSegRdata(CommonSegRodata): def get_linker_section(self) -> str: return ".rdata" diff --git a/tools/splat/segtypes/common/rodata.py b/tools/splat/segtypes/common/rodata.py index be08cba5d3..b8df8877ff 100644 --- a/tools/splat/segtypes/common/rodata.py +++ b/tools/splat/segtypes/common/rodata.py @@ -1,6 +1,63 @@ +import spimdisasm + from segtypes.common.data import CommonSegData +from util import symbols, options class CommonSegRodata(CommonSegData): def get_linker_section(self) -> str: return ".rodata" + + def disassemble_data(self, rom_bytes): + assert isinstance(self.rom_start, int) + assert isinstance(self.rom_end, int) + + segment_rom_start = self.get_most_parent().rom_start + assert isinstance(segment_rom_start, int) + + self.spim_section = spimdisasm.mips.sections.SectionRodata( + symbols.spim_context, + self.rom_start, + self.rom_end, + self.vram_start, + self.name, + rom_bytes, + segment_rom_start, + self.get_exclusive_ram_id(), + ) + + for symbol_list in self.seg_symbols.values(): + symbols.add_symbol_to_spim_section(self.spim_section, symbol_list[0]) + + for sym in symbols.all_symbols: + if sym.user_declared: + symbols.add_symbol_to_spim_section(self.spim_section, sym) + + self.spim_section.analyze() + self.spim_section.setCommentOffset(self.rom_start) + + for symbol in self.spim_section.symbolList: + symbols.create_symbol_from_spim_symbol( + self.get_most_parent(), symbol.contextSym + ) + + def split(self, rom_bytes: bytes): + # Disassemble the file itself + super().split(rom_bytes) + + if options.get_migrate_rodata_to_functions(): + if self.spim_section and ( + not self.type.startswith(".") or self.partial_migration + ): + path_folder = options.get_data_path() / self.dir + path_folder.parent.mkdir(parents=True, exist_ok=True) + + for rodataSym in self.spim_section.symbolList: + if not rodataSym.isRdata(): + continue + + path = path_folder / f"{rodataSym.getName()}.s" + with open(path, "w", newline="\n") as f: + f.write('.include "macro.inc"\n\n') + f.write(".section .rodata\n\n") + f.write(rodataSym.disassemble()) diff --git a/tools/splat/segtypes/linker_entry.py b/tools/splat/segtypes/linker_entry.py index 6d53808015..aee5358841 100644 --- a/tools/splat/segtypes/linker_entry.py +++ b/tools/splat/segtypes/linker_entry.py @@ -207,9 +207,17 @@ class LinkerWriter: # Create new linker section for BSS if entering_bss or leaving_bss: # If this is the last entry of its type, add the END marker for the section we're ending - if entry in last_seen_sections and section_labels[entry.section_type].started: + if ( + entry in last_seen_sections + and section_labels[entry.section_type].started + ): + seg_name_section = to_cname( + f"{seg_name}{last_seen_sections[entry].upper()}" + ) + self._write_symbol(f"{seg_name_section}_END", ".") self._write_symbol( - f"{seg_name}{last_seen_sections[entry].upper()}_END", "." + f"{seg_name_section}_SIZE", + f"ABSOLUTE({seg_name_section}_END - {seg_name_section}_START)", ) section_labels[last_seen_sections[entry]].ended = True @@ -231,15 +239,25 @@ class LinkerWriter: # If this is the last entry of its type, add the END marker for the section we're ending if entry in last_seen_sections: - self._write_symbol(f"{seg_name}{cur_section.upper()}_END", ".") + seg_name_section = to_cname(f"{seg_name}{cur_section.upper()}") + self._write_symbol(f"{seg_name_section}_END", ".") + self._write_symbol( + f"{seg_name_section}_SIZE", + f"ABSOLUTE({seg_name_section}_END - {seg_name_section}_START)", + ) section_labels[cur_section].ended = True prev_section = cur_section # End all un-ended sections for section in section_labels.values(): - if (section.started and not section.ended): - self._write_symbol(f"{seg_name}_{section.name.upper()}_END", ".") + if section.started and not section.ended: + seg_name_section = to_cname(f"{seg_name}{section.name.upper()}") + self._write_symbol(f"{seg_name_section}_END", ".") + self._write_symbol( + f"{seg_name_section}_SIZE", + f"ABSOLUTE({seg_name_section}_END - {seg_name_section}_START)", + ) all_bss = all(e.section == ".bss" for e in entries) self._end_segment(segment, next_segment, all_bss) @@ -304,7 +322,11 @@ class LinkerWriter: if segment.follows_vram_segment: vram_str = get_segment_cname(segment.follows_vram_segment) + "_VRAM_END " else: - vram_str = f"0x{segment.vram_start:X} " if isinstance(segment.vram_start, int) else "" + vram_str = ( + f"0x{segment.vram_start:X} " + if isinstance(segment.vram_start, int) + else "" + ) name = get_segment_cname(segment) @@ -319,7 +341,11 @@ class LinkerWriter: if segment.follows_vram_segment: vram_str = get_segment_cname(segment.follows_vram_segment) + "_VRAM_END " else: - vram_str = f"0x{segment.vram_start:X} " if isinstance(segment.vram_start, int) else "" + vram_str = ( + f"0x{segment.vram_start:X} " + if isinstance(segment.vram_start, int) + else "" + ) name = get_segment_cname(segment) + "_bss" diff --git a/tools/splat/segtypes/n64/asm.py b/tools/splat/segtypes/n64/asm.py index 898ca36b0d..77bbb5aa77 100644 --- a/tools/splat/segtypes/n64/asm.py +++ b/tools/splat/segtypes/n64/asm.py @@ -10,11 +10,13 @@ class N64SegAsm(CommonSegAsm): ret.append('.include "macro.inc"') ret.append("") - ret.append("# assembler directives") - ret.append(".set noat # allow manual use of $at") - ret.append(".set noreorder # don't insert nops after branches") + ret.append("/* assembler directives */") + ret.append(".set noat /* allow manual use of $at */") + ret.append(".set noreorder /* don't insert nops after branches */") if options.get_add_set_gp_64(): - ret.append(".set gp=64 # allow use of 64-bit general purpose registers") + ret.append( + ".set gp=64 /* allow use of 64-bit general purpose registers */" + ) ret.append("") preamble = options.get_generated_s_preamble() if preamble: diff --git a/tools/splat/segtypes/n64/hasm.py b/tools/splat/segtypes/n64/hasm.py index a271075f66..2502112013 100644 --- a/tools/splat/segtypes/n64/hasm.py +++ b/tools/splat/segtypes/n64/hasm.py @@ -10,11 +10,13 @@ class N64SegHasm(CommonSegHasm): ret.append('.include "macro.inc"') ret.append("") - ret.append("# assembler directives") - ret.append(".set noat # allow manual use of $at") - ret.append(".set noreorder # don't insert nops after branches") + ret.append("/* assembler directives */") + ret.append(".set noat /* allow manual use of $at */") + ret.append(".set noreorder /* don't insert nops after branches */") if options.get_add_set_gp_64(): - ret.append(".set gp=64 # allow use of 64-bit general purpose registers") + ret.append( + ".set gp=64 /* allow use of 64-bit general purpose registers */" + ) ret.append("") preamble = options.get_generated_s_preamble() if preamble: diff --git a/tools/splat/segtypes/psx/asm.py b/tools/splat/segtypes/psx/asm.py index 6a8c92eb52..50ae4972d6 100644 --- a/tools/splat/segtypes/psx/asm.py +++ b/tools/splat/segtypes/psx/asm.py @@ -12,9 +12,9 @@ class PsxSegAsm(CommonSegAsm): ret.append('.include "macro.inc"') ret.append("") - ret.append("# assembler directives") - ret.append(".set noat # allow manual use of $at") - ret.append(".set noreorder # don't insert nops after branches") + ret.append("/* assembler directives */") + ret.append(".set noat /* allow manual use of $at */") + ret.append(".set noreorder /* don't insert nops after branches */") ret.append("") preamble = options.get_generated_s_preamble() if preamble: diff --git a/tools/splat/split.py b/tools/splat/split.py index d76ee7f225..1612ef4a55 100755 --- a/tools/splat/split.py +++ b/tools/splat/split.py @@ -20,7 +20,7 @@ from util.symbols import Symbol from intervaltree import Interval, IntervalTree -VERSION = "0.10.0" +VERSION = "0.11.0" parser = argparse.ArgumentParser( description="Split a rom given a rom, a config, and output directory" @@ -457,6 +457,33 @@ def main(config_path, base_dir, target_path, modes, verbose, use_cache=True): with open(options.get_cache_path(), "wb") as f4: pickle.dump(cache, f4) + if options.dump_symbols(): + from pathlib import Path + + splat_hidden_folder = Path(".splat/") + splat_hidden_folder.mkdir(exist_ok=True) + + with open(splat_hidden_folder / "splat_symbols.csv", "w") as f: + f.write( + "vram_start,given_name,name,type,given_size,size,rom,defined,user_declared,referenced,dead,extract\n" + ) + for s in sorted(symbols.all_symbols, key=lambda x: x.vram_start): + f.write(f"{s.vram_start:X},{s.given_name},{s.name},{s.type},") + if s.given_size is not None: + f.write(f"0x{s.given_size:X},") + else: + f.write(f"None,") + f.write(f"{s.size},") + if s.rom is not None: + f.write(f"0x{s.rom:X},") + else: + f.write(f"None,") + f.write( + f"{s.defined},{s.user_declared},{s.referenced},{s.dead},{s.extract}\n" + ) + + symbols.spim_context.saveContextToFile(splat_hidden_folder / "spim_context.csv") + if __name__ == "__main__": args = parser.parse_args() diff --git a/tools/splat/util/compiler.py b/tools/splat/util/compiler.py index 3af478428c..e2ab5333f3 100644 --- a/tools/splat/util/compiler.py +++ b/tools/splat/util/compiler.py @@ -13,7 +13,7 @@ class Compiler: GCC = Compiler( "GCC", - asm_inc_header=".set noat # allow manual use of $at\n.set noreorder # don't insert nops after branches\n\n", + asm_inc_header=".set noat /* allow manual use of $at */\n.set noreorder /* don't insert nops after branches */\n\n", ) SN64 = Compiler( diff --git a/tools/splat/util/options.py b/tools/splat/util/options.py index 5272f9503c..fa3b93ccca 100644 --- a/tools/splat/util/options.py +++ b/tools/splat/util/options.py @@ -51,6 +51,10 @@ def verbose() -> bool: return opts.get("verbose", False) +def dump_symbols() -> bool: + return opts.get("dump_symbols", False) + + ################################################################################ # Global options # @@ -305,11 +309,6 @@ def find_file_boundaries() -> bool: return opts.get("find_file_boundaries", True) -# Determines the maximum number of instructions to attempt to match hi/lo pairs for symbols when disassembling -def hi_lo_max_distance() -> int: - return opts.get("hi_lo_max_distance", 6) - - # Determines whether to attempt to automatically migrate rodata into functions (only works in certain circumstances) def get_migrate_rodata_to_functions() -> bool: return opts.get("migrate_rodata_to_functions", True) diff --git a/tools/splat/util/symbols.py b/tools/splat/util/symbols.py index dfabf3034a..e97fc2af57 100644 --- a/tools/splat/util/symbols.py +++ b/tools/splat/util/symbols.py @@ -1,6 +1,5 @@ from typing import Dict, List, Optional, TYPE_CHECKING, Set import spimdisasm -import rabbitizer import tqdm # circular import @@ -373,8 +372,6 @@ class Symbol: self.type = type self.given_size = given_size self.given_name = given_name - self.access_mnemonic: Optional[rabbitizer.Enum] = None - self.disasm_str: Optional[str] = None self.dead: bool = False self.extract: bool = True self.user_declared: bool = False diff --git a/ver/us/asm/nonmatchings/16c8e0/func_8023F088.s b/ver/us/asm/nonmatchings/16c8e0/func_8023F088.s index 2b2fe75e72..e096e6c7ae 100644 --- a/ver/us/asm/nonmatchings/16c8e0/func_8023F088.s +++ b/ver/us/asm/nonmatchings/16c8e0/func_8023F088.s @@ -51,8 +51,8 @@ glabel func_8023F088 /* 16DA20 8023F140 0000902D */ daddu $s2, $zero, $zero /* 16DA24 8023F144 0280182D */ daddu $v1, $s4, $zero /* 16DA28 8023F148 0040902D */ daddu $s2, $v0, $zero -/* 16DA2C 8023F14C 3C02802A */ lui $v0, %hi(D_8029F236) -/* 16DA30 8023F150 2442F236 */ addiu $v0, $v0, %lo(D_8029F236) +/* 16DA2C 8023F14C 3C02802A */ lui $v0, %hi(D_8029F038+0x1FE) +/* 16DA30 8023F150 2442F236 */ addiu $v0, $v0, %lo(D_8029F038+0x1FE) .L8023F154: /* 16DA34 8023F154 A4430000 */ sh $v1, ($v0) /* 16DA38 8023F158 2652FFFF */ addiu $s2, $s2, -1 diff --git a/ver/us/asm/nonmatchings/415D90/btl_state_update_partner_menu.s b/ver/us/asm/nonmatchings/415D90/btl_state_update_partner_menu.s index 73388efcb2..d9dcd2b448 100644 --- a/ver/us/asm/nonmatchings/415D90/btl_state_update_partner_menu.s +++ b/ver/us/asm/nonmatchings/415D90/btl_state_update_partner_menu.s @@ -279,8 +279,8 @@ glabel btl_state_update_partner_menu /* 41D358 802A85C8 8C63B590 */ lw $v1, %lo(battle_menu_PartnerMoveHudScripts)($v1) /* 41D35C 802A85CC 8EC20018 */ lw $v0, 0x18($s6) /* 41D360 802A85D0 24050006 */ addiu $a1, $zero, 6 -/* 41D364 802A85D4 3C01802B */ lui $at, %hi(D_802AD0BC) -/* 41D368 802A85D8 AC25D0BC */ sw $a1, %lo(D_802AD0BC)($at) +/* 41D364 802A85D4 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x4) +/* 41D368 802A85D8 AC25D0BC */ sw $a1, %lo(battle_menu_submenuIDs+0x4)($at) /* 41D36C 802A85DC AE700004 */ sw $s0, 4($s3) /* 41D370 802A85E0 AFC20004 */ sw $v0, 4($fp) /* 41D374 802A85E4 AE430004 */ sw $v1, 4($s2) @@ -331,8 +331,8 @@ glabel btl_state_update_partner_menu /* 41D41C 802A868C 8EC5002C */ lw $a1, 0x2c($s6) /* 41D420 802A8690 96830070 */ lhu $v1, 0x70($s4) /* 41D424 802A8694 24020001 */ addiu $v0, $zero, 1 -/* 41D428 802A8698 3C01802B */ lui $at, %hi(D_802AD0C0) -/* 41D42C 802A869C AC27D0C0 */ sw $a3, %lo(D_802AD0C0)($at) +/* 41D428 802A8698 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x8) +/* 41D42C 802A869C AC27D0C0 */ sw $a3, %lo(battle_menu_submenuIDs+0x8)($at) /* 41D430 802A86A0 AE620008 */ sw $v0, 8($s3) /* 41D434 802A86A4 AEA00008 */ sw $zero, 8($s5) /* 41D438 802A86A8 30630800 */ andi $v1, $v1, 0x800 @@ -431,9 +431,9 @@ glabel btl_state_update_partner_menu /* 41D58C 802A87FC 8063D06B */ lb $v1, %lo(D_802AD06B)($v1) /* 41D590 802A8800 00431021 */ addu $v0, $v0, $v1 /* 41D594 802A8804 00021080 */ sll $v0, $v0, 2 -/* 41D598 802A8808 3C01802B */ lui $at, %hi(D_802AD0BB) +/* 41D598 802A8808 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x3) /* 41D59C 802A880C 00220821 */ addu $at, $at, $v0 -/* 41D5A0 802A8810 9022D0BB */ lbu $v0, %lo(D_802AD0BB)($at) +/* 41D5A0 802A8810 9022D0BB */ lbu $v0, %lo(battle_menu_submenuIDs+0x3)($at) /* 41D5A4 802A8814 0C0A842E */ jal func_802A10B8 /* 41D5A8 802A8818 A282005C */ sb $v0, 0x5c($s4) /* 41D5AC 802A881C 080AA5DD */ j .L802A9774 @@ -463,9 +463,9 @@ glabel btl_state_update_partner_menu /* 41D600 802A8870 0000282D */ daddu $a1, $zero, $zero /* 41D604 802A8874 2602FFFF */ addiu $v0, $s0, -1 /* 41D608 802A8878 00021080 */ sll $v0, $v0, 2 -/* 41D60C 802A887C 3C01802B */ lui $at, %hi(D_802AD0BB) +/* 41D60C 802A887C 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x3) /* 41D610 802A8880 00220821 */ addu $at, $at, $v0 -/* 41D614 802A8884 9022D0BB */ lbu $v0, %lo(D_802AD0BB)($at) +/* 41D614 802A8884 9022D0BB */ lbu $v0, %lo(battle_menu_submenuIDs+0x3)($at) /* 41D618 802A8888 A282004A */ sb $v0, 0x4a($s4) /* 41D61C 802A888C 8283004A */ lb $v1, 0x4a($s4) /* 41D620 802A8890 24050007 */ addiu $a1, $zero, 7 @@ -769,9 +769,9 @@ glabel btl_state_update_partner_menu /* 41DA5C 802A8CCC 8282004B */ lb $v0, 0x4b($s4) /* 41DA60 802A8CD0 A2830178 */ sb $v1, 0x178($s4) /* 41DA64 802A8CD4 00021080 */ sll $v0, $v0, 2 -/* 41DA68 802A8CD8 3C01802B */ lui $at, %hi(D_802AD4B2) +/* 41DA68 802A8CD8 3C01802B */ lui $at, %hi(battle_menu_moveIndices+0x2) /* 41DA6C 802A8CDC 00220821 */ addu $at, $at, $v0 -/* 41DA70 802A8CE0 9422D4B2 */ lhu $v0, %lo(D_802AD4B2)($at) +/* 41DA70 802A8CE0 9422D4B2 */ lhu $v0, %lo(battle_menu_moveIndices+0x2)($at) /* 41DA74 802A8CE4 A682017C */ sh $v0, 0x17c($s4) /* 41DA78 802A8CE8 00021400 */ sll $v0, $v0, 0x10 /* 41DA7C 802A8CEC 00021403 */ sra $v0, $v0, 0x10 @@ -781,8 +781,8 @@ glabel btl_state_update_partner_menu /* 41DA8C 802A8CFC 3C018009 */ lui $at, %hi(gMoveTable + 0x4) /* 41DA90 802A8D00 00230821 */ addu $at, $at, $v1 /* 41DA94 802A8D04 8C23F064 */ lw $v1, %lo(gMoveTable + 0x4)($at) -/* 41DA98 802A8D08 3C02802B */ lui $v0, %hi(D_802AD603) -/* 41DA9C 802A8D0C 9042D603 */ lbu $v0, %lo(D_802AD603)($v0) +/* 41DA98 802A8D08 3C02802B */ lui $v0, %hi(battle_menu_moveOptionActive + 0x3) +/* 41DA9C 802A8D0C 9042D603 */ lbu $v0, %lo(battle_menu_moveOptionActive + 0x3)($v0) /* 41DAA0 802A8D10 24040011 */ addiu $a0, $zero, 0x11 /* 41DAA4 802A8D14 A282005D */ sb $v0, 0x5d($s4) /* 41DAA8 802A8D18 2402000E */ addiu $v0, $zero, 0xe @@ -1239,9 +1239,9 @@ glabel btl_state_update_partner_menu /* 41E12C 802A939C 24020002 */ addiu $v0, $zero, 2 .L802A93A0: /* 41E130 802A93A0 00021080 */ sll $v0, $v0, 2 -/* 41E134 802A93A4 3C01802B */ lui $at, %hi(D_802AD4B3) +/* 41E134 802A93A4 3C01802B */ lui $at, %hi(battle_menu_moveIndices+0x3) /* 41E138 802A93A8 00220821 */ addu $at, $at, $v0 -/* 41E13C 802A93AC 9022D4B3 */ lbu $v0, %lo(D_802AD4B3)($at) +/* 41E13C 802A93AC 9022D4B3 */ lbu $v0, %lo(battle_menu_moveIndices+0x3)($at) /* 41E140 802A93B0 0C0A89F4 */ jal func_802A27D0 /* 41E144 802A93B4 A282004B */ sb $v0, 0x4b($s4) /* 41E148 802A93B8 0C0A840C */ jal func_802A1030 @@ -1288,8 +1288,8 @@ glabel btl_state_update_partner_menu /* 41E1E4 802A9454 3C058009 */ lui $a1, %hi(gMoveTable + 0x4) /* 41E1E8 802A9458 00A22821 */ addu $a1, $a1, $v0 /* 41E1EC 802A945C 8CA5F064 */ lw $a1, %lo(gMoveTable + 0x4)($a1) -/* 41E1F0 802A9460 3C02802B */ lui $v0, %hi(D_802AD603) -/* 41E1F4 802A9464 9042D603 */ lbu $v0, %lo(D_802AD603)($v0) +/* 41E1F0 802A9460 3C02802B */ lui $v0, %hi(battle_menu_moveOptionActive + 0x3) +/* 41E1F4 802A9464 9042D603 */ lbu $v0, %lo(battle_menu_moveOptionActive + 0x3)($v0) /* 41E1F8 802A9468 00031E00 */ sll $v1, $v1, 0x18 /* 41E1FC 802A946C 00031E03 */ sra $v1, $v1, 0x18 /* 41E200 802A9470 A683017A */ sh $v1, 0x17a($s4) @@ -1419,9 +1419,9 @@ glabel btl_state_update_partner_menu /* 41E3D0 802A9640 24020002 */ addiu $v0, $zero, 2 .L802A9644: /* 41E3D4 802A9644 00031080 */ sll $v0, $v1, 2 -/* 41E3D8 802A9648 3C01802B */ lui $at, %hi(D_802AD67B) +/* 41E3D8 802A9648 3C01802B */ lui $at, %hi(D_802AD678 + 0x3) /* 41E3DC 802A964C 00220821 */ addu $at, $at, $v0 -/* 41E3E0 802A9650 9022D67B */ lbu $v0, %lo(D_802AD67B)($at) +/* 41E3E0 802A9650 9022D67B */ lbu $v0, %lo(D_802AD678 + 0x3)($at) /* 41E3E4 802A9654 A2830063 */ sb $v1, 0x63($s4) /* 41E3E8 802A9658 A282004A */ sb $v0, 0x4a($s4) /* 41E3EC 802A965C 8283004A */ lb $v1, 0x4a($s4) diff --git a/ver/us/asm/nonmatchings/415D90/btl_state_update_peach_menu.s b/ver/us/asm/nonmatchings/415D90/btl_state_update_peach_menu.s index 1f5201bddc..72ffb160e0 100644 --- a/ver/us/asm/nonmatchings/415D90/btl_state_update_peach_menu.s +++ b/ver/us/asm/nonmatchings/415D90/btl_state_update_peach_menu.s @@ -272,9 +272,9 @@ glabel btl_state_update_peach_menu /* 41ECB4 802A9F24 34C60002 */ ori $a2, $a2, 2 /* 41ECB8 802A9F28 2602FFFF */ addiu $v0, $s0, -1 /* 41ECBC 802A9F2C 00021080 */ sll $v0, $v0, 2 -/* 41ECC0 802A9F30 3C01802B */ lui $at, %hi(D_802AD0BB) +/* 41ECC0 802A9F30 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x3) /* 41ECC4 802A9F34 00220821 */ addu $at, $at, $v0 -/* 41ECC8 802A9F38 9022D0BB */ lbu $v0, %lo(D_802AD0BB)($at) +/* 41ECC8 802A9F38 9022D0BB */ lbu $v0, %lo(battle_menu_submenuIDs+0x3)($at) /* 41ECCC 802A9F3C 0C0A840C */ jal func_802A1030 /* 41ECD0 802A9F40 A2420048 */ sb $v0, 0x48($s2) /* 41ECD4 802A9F44 24020008 */ addiu $v0, $zero, 8 diff --git a/ver/us/asm/nonmatchings/415D90/btl_state_update_player_menu.s b/ver/us/asm/nonmatchings/415D90/btl_state_update_player_menu.s index cc986b1469..d0841c1bb5 100644 --- a/ver/us/asm/nonmatchings/415D90/btl_state_update_player_menu.s +++ b/ver/us/asm/nonmatchings/415D90/btl_state_update_player_menu.s @@ -602,9 +602,9 @@ glabel btl_state_update_player_menu /* 41AFC0 802A6230 8063D06B */ lb $v1, %lo(D_802AD06B)($v1) /* 41AFC4 802A6234 00431021 */ addu $v0, $v0, $v1 /* 41AFC8 802A6238 00021080 */ sll $v0, $v0, 2 -/* 41AFCC 802A623C 3C01802B */ lui $at, %hi(D_802AD0BB) +/* 41AFCC 802A623C 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x3) /* 41AFD0 802A6240 00220821 */ addu $at, $at, $v0 -/* 41AFD4 802A6244 9022D0BB */ lbu $v0, %lo(D_802AD0BB)($at) +/* 41AFD4 802A6244 9022D0BB */ lbu $v0, %lo(battle_menu_submenuIDs+0x3)($at) /* 41AFD8 802A6248 0C0A842E */ jal func_802A10B8 /* 41AFDC 802A624C A2C2004C */ sb $v0, 0x4c($s6) /* 41AFE0 802A6250 080A9F71 */ j .L802A7DC4 @@ -637,9 +637,9 @@ glabel btl_state_update_player_menu /* 41B044 802A62B4 34C60004 */ ori $a2, $a2, 4 /* 41B048 802A62B8 2602FFFF */ addiu $v0, $s0, -1 /* 41B04C 802A62BC 00021080 */ sll $v0, $v0, 2 -/* 41B050 802A62C0 3C01802B */ lui $at, %hi(D_802AD0BB) +/* 41B050 802A62C0 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x3) /* 41B054 802A62C4 00220821 */ addu $at, $at, $v0 -/* 41B058 802A62C8 9022D0BB */ lbu $v0, %lo(D_802AD0BB)($at) +/* 41B058 802A62C8 9022D0BB */ lbu $v0, %lo(battle_menu_submenuIDs+0x3)($at) /* 41B05C 802A62CC 0000982D */ daddu $s3, $zero, $zero /* 41B060 802A62D0 A2C20048 */ sb $v0, 0x48($s6) /* 41B064 802A62D4 A2C2004C */ sb $v0, 0x4c($s6) @@ -1148,9 +1148,9 @@ glabel btl_state_update_player_menu /* 41B77C 802A69EC 24020001 */ addiu $v0, $zero, 1 .L802A69F0: /* 41B780 802A69F0 00021080 */ sll $v0, $v0, 2 -/* 41B784 802A69F4 3C01802B */ lui $at, %hi(D_802AD4B3) +/* 41B784 802A69F4 3C01802B */ lui $at, %hi(battle_menu_moveIndices+0x3) /* 41B788 802A69F8 00220821 */ addu $at, $at, $v0 -/* 41B78C 802A69FC 9022D4B3 */ lbu $v0, %lo(D_802AD4B3)($at) +/* 41B78C 802A69FC 9022D4B3 */ lbu $v0, %lo(battle_menu_moveIndices+0x3)($at) /* 41B790 802A6A00 82C30048 */ lb $v1, 0x48($s6) /* 41B794 802A6A04 A2C20049 */ sb $v0, 0x49($s6) /* 41B798 802A6A08 00021600 */ sll $v0, $v0, 0x18 @@ -1159,24 +1159,24 @@ glabel btl_state_update_player_menu /* 41B7A4 802A6A14 904201DE */ lbu $v0, 0x1de($v0) /* 41B7A8 802A6A18 14600004 */ bnez $v1, .L802A6A2C /* 41B7AC 802A6A1C A6C2017C */ sh $v0, 0x17c($s6) -/* 41B7B0 802A6A20 3C02802B */ lui $v0, %hi(D_802AD603) -/* 41B7B4 802A6A24 9042D603 */ lbu $v0, %lo(D_802AD603)($v0) +/* 41B7B0 802A6A20 3C02802B */ lui $v0, %hi(battle_menu_moveOptionActive + 0x3) +/* 41B7B4 802A6A24 9042D603 */ lbu $v0, %lo(battle_menu_moveOptionActive + 0x3)($v0) /* 41B7B8 802A6A28 A2C2004D */ sb $v0, 0x4d($s6) .L802A6A2C: /* 41B7BC 802A6A2C 82C30048 */ lb $v1, 0x48($s6) /* 41B7C0 802A6A30 24020001 */ addiu $v0, $zero, 1 /* 41B7C4 802A6A34 14620004 */ bne $v1, $v0, .L802A6A48 /* 41B7C8 802A6A38 00000000 */ nop -/* 41B7CC 802A6A3C 3C02802B */ lui $v0, %hi(D_802AD603) -/* 41B7D0 802A6A40 9042D603 */ lbu $v0, %lo(D_802AD603)($v0) +/* 41B7CC 802A6A3C 3C02802B */ lui $v0, %hi(battle_menu_moveOptionActive + 0x3) +/* 41B7D0 802A6A40 9042D603 */ lbu $v0, %lo(battle_menu_moveOptionActive + 0x3)($v0) /* 41B7D4 802A6A44 A2C2004E */ sb $v0, 0x4e($s6) .L802A6A48: /* 41B7D8 802A6A48 82C40048 */ lb $a0, 0x48($s6) /* 41B7DC 802A6A4C 24020002 */ addiu $v0, $zero, 2 /* 41B7E0 802A6A50 14820007 */ bne $a0, $v0, .L802A6A70 /* 41B7E4 802A6A54 0080182D */ daddu $v1, $a0, $zero -/* 41B7E8 802A6A58 3C02802B */ lui $v0, %hi(D_802AD603) -/* 41B7EC 802A6A5C 9042D603 */ lbu $v0, %lo(D_802AD603)($v0) +/* 41B7E8 802A6A58 3C02802B */ lui $v0, %hi(battle_menu_moveOptionActive + 0x3) +/* 41B7EC 802A6A5C 9042D603 */ lbu $v0, %lo(battle_menu_moveOptionActive + 0x3)($v0) /* 41B7F0 802A6A60 14640003 */ bne $v1, $a0, .L802A6A70 /* 41B7F4 802A6A64 A2C2004F */ sb $v0, 0x4f($s6) /* 41B7F8 802A6A68 080A9FE1 */ j .L802A7F84 @@ -1921,11 +1921,11 @@ glabel btl_state_update_player_menu /* 41C280 802A74F0 24020001 */ addiu $v0, $zero, 1 .L802A74F4: /* 41C284 802A74F4 00021080 */ sll $v0, $v0, 2 -/* 41C288 802A74F8 3C01802B */ lui $at, %hi(D_802AD4B3) +/* 41C288 802A74F8 3C01802B */ lui $at, %hi(battle_menu_moveIndices+0x3) /* 41C28C 802A74FC 00220821 */ addu $at, $at, $v0 -/* 41C290 802A7500 9022D4B3 */ lbu $v0, %lo(D_802AD4B3)($at) -/* 41C294 802A7504 3C03802B */ lui $v1, %hi(D_802AD603) -/* 41C298 802A7508 9063D603 */ lbu $v1, %lo(D_802AD603)($v1) +/* 41C290 802A7500 9022D4B3 */ lbu $v0, %lo(battle_menu_moveIndices+0x3)($at) +/* 41C294 802A7504 3C03802B */ lui $v1, %hi(battle_menu_moveOptionActive + 0x3) +/* 41C298 802A7508 9063D603 */ lbu $v1, %lo(battle_menu_moveOptionActive + 0x3)($v1) /* 41C29C 802A750C A2C20049 */ sb $v0, 0x49($s6) /* 41C2A0 802A7510 0C0A89F4 */ jal func_802A27D0 /* 41C2A4 802A7514 A2C30052 */ sb $v1, 0x52($s6) @@ -2429,9 +2429,9 @@ glabel btl_state_update_player_menu /* 41C9C8 802A7C38 24020001 */ addiu $v0, $zero, 1 .L802A7C3C: /* 41C9CC 802A7C3C 00031080 */ sll $v0, $v1, 2 -/* 41C9D0 802A7C40 3C01802B */ lui $at, %hi(D_802AD67B) +/* 41C9D0 802A7C40 3C01802B */ lui $at, %hi(D_802AD678 + 0x3) /* 41C9D4 802A7C44 00220821 */ addu $at, $at, $v0 -/* 41C9D8 802A7C48 9022D67B */ lbu $v0, %lo(D_802AD67B)($at) +/* 41C9D8 802A7C48 9022D67B */ lbu $v0, %lo(D_802AD678 + 0x3)($at) /* 41C9DC 802A7C4C A2C30053 */ sb $v1, 0x53($s6) /* 41C9E0 802A7C50 A2C20048 */ sb $v0, 0x48($s6) /* 41C9E4 802A7C54 82C30048 */ lb $v1, 0x48($s6) diff --git a/ver/us/asm/nonmatchings/415D90/btl_state_update_twink_menu.s b/ver/us/asm/nonmatchings/415D90/btl_state_update_twink_menu.s index 78c90f5a6b..d0133749d7 100644 --- a/ver/us/asm/nonmatchings/415D90/btl_state_update_twink_menu.s +++ b/ver/us/asm/nonmatchings/415D90/btl_state_update_twink_menu.s @@ -308,9 +308,9 @@ glabel btl_state_update_twink_menu /* 41F29C 802AA50C 34C60008 */ ori $a2, $a2, 8 /* 41F2A0 802AA510 2602FFFF */ addiu $v0, $s0, -1 /* 41F2A4 802AA514 00021080 */ sll $v0, $v0, 2 -/* 41F2A8 802AA518 3C01802B */ lui $at, %hi(D_802AD0BB) +/* 41F2A8 802AA518 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x3) /* 41F2AC 802AA51C 00220821 */ addu $at, $at, $v0 -/* 41F2B0 802AA520 9022D0BB */ lbu $v0, %lo(D_802AD0BB)($at) +/* 41F2B0 802AA520 9022D0BB */ lbu $v0, %lo(battle_menu_submenuIDs+0x3)($at) /* 41F2B4 802AA524 0C0A840C */ jal func_802A1030 /* 41F2B8 802AA528 A2420048 */ sb $v0, 0x48($s2) /* 41F2BC 802AA52C 24020008 */ addiu $v0, $zero, 8 diff --git a/ver/us/asm/nonmatchings/415D90/func_802A11B0.s b/ver/us/asm/nonmatchings/415D90/func_802A11B0.s index 2af3464cd9..58674de529 100644 --- a/ver/us/asm/nonmatchings/415D90/func_802A11B0.s +++ b/ver/us/asm/nonmatchings/415D90/func_802A11B0.s @@ -67,8 +67,8 @@ glabel func_802A11B0 /* 416028 802A1298 3C013E99 */ lui $at, 0x3e99 /* 41602C 802A129C 3421999A */ ori $at, $at, 0x999a /* 416030 802A12A0 44810000 */ mtc1 $at, $f0 -/* 416034 802A12A4 3C04802B */ lui $a0, %hi(D_802AD0B3) -/* 416038 802A12A8 9084D0B3 */ lbu $a0, %lo(D_802AD0B3)($a0) +/* 416034 802A12A4 3C04802B */ lui $a0, %hi(D_802AD0B0+0x3) +/* 416038 802A12A8 9084D0B3 */ lbu $a0, %lo(D_802AD0B0+0x3)($a0) /* 41603C 802A12AC 3C05802B */ lui $a1, %hi(main_menu_numOptions) /* 416040 802A12B0 24A5D0AC */ addiu $a1, $a1, %lo(main_menu_numOptions) /* 416044 802A12B4 3C01802B */ lui $at, %hi(D_802AD064) @@ -567,9 +567,9 @@ glabel func_802A11B0 /* 4167D4 802A1A44 82430000 */ lb $v1, ($s2) /* 4167D8 802A1A48 00431021 */ addu $v0, $v0, $v1 /* 4167DC 802A1A4C 00021080 */ sll $v0, $v0, 2 -/* 4167E0 802A1A50 3C03802B */ lui $v1, %hi(D_802AD0EB) +/* 4167E0 802A1A50 3C03802B */ lui $v1, %hi(battle_menu_isMessageDisabled+0x3) /* 4167E4 802A1A54 00621821 */ addu $v1, $v1, $v0 -/* 4167E8 802A1A58 9063D0EB */ lbu $v1, %lo(D_802AD0EB)($v1) +/* 4167E8 802A1A58 9063D0EB */ lbu $v1, %lo(battle_menu_isMessageDisabled+0x3)($v1) /* 4167EC 802A1A5C 24020064 */ addiu $v0, $zero, 0x64 /* 4167F0 802A1A60 A2020000 */ sb $v0, ($s0) /* 4167F4 802A1A64 3C01802B */ lui $at, %hi(D_802AD068) diff --git a/ver/us/asm/nonmatchings/415D90/func_802A4A54.s b/ver/us/asm/nonmatchings/415D90/func_802A4A54.s index f651852d97..20dc0b1c1f 100644 --- a/ver/us/asm/nonmatchings/415D90/func_802A4A54.s +++ b/ver/us/asm/nonmatchings/415D90/func_802A4A54.s @@ -253,8 +253,8 @@ glabel func_802A4A54 /* 419B88 802A4DF8 82020000 */ lb $v0, ($s0) /* 419B8C 802A4DFC 04410005 */ bgez $v0, .L802A4E14 /* 419B90 802A4E00 00000000 */ nop -/* 419B94 802A4E04 3C02802B */ lui $v0, %hi(D_802AD66F) -/* 419B98 802A4E08 9042D66F */ lbu $v0, %lo(D_802AD66F)($v0) +/* 419B94 802A4E04 3C02802B */ lui $v0, %hi(D_802AD66C + 0x3) +/* 419B98 802A4E08 9042D66F */ lbu $v0, %lo(D_802AD66C + 0x3)($v0) /* 419B9C 802A4E0C 2442FFFF */ addiu $v0, $v0, -1 /* 419BA0 802A4E10 A2020000 */ sb $v0, ($s0) .L802A4E14: @@ -333,9 +333,9 @@ glabel func_802A4A54 /* 419CAC 802A4F1C 2404021D */ addiu $a0, $zero, 0x21d /* 419CB0 802A4F20 82020000 */ lb $v0, ($s0) /* 419CB4 802A4F24 00021080 */ sll $v0, $v0, 2 -/* 419CB8 802A4F28 3C03802B */ lui $v1, %hi(D_802AD6AA) +/* 419CB8 802A4F28 3C03802B */ lui $v1, %hi(D_802AD6A8 + 0x2) /* 419CBC 802A4F2C 00621821 */ addu $v1, $v1, $v0 -/* 419CC0 802A4F30 9463D6AA */ lhu $v1, %lo(D_802AD6AA)($v1) +/* 419CC0 802A4F30 9463D6AA */ lhu $v1, %lo(D_802AD6A8 + 0x2)($v1) /* 419CC4 802A4F34 24020028 */ addiu $v0, $zero, 0x28 /* 419CC8 802A4F38 3C01802B */ lui $at, %hi(D_802AD604) /* 419CCC 802A4F3C A022D604 */ sb $v0, %lo(D_802AD604)($at) diff --git a/ver/us/splat.yaml b/ver/us/splat.yaml index 91b13a2865..d6f1c3f507 100644 --- a/ver/us/splat.yaml +++ b/ver/us/splat.yaml @@ -869,7 +869,7 @@ segments: type: code start: 0xFEE30 vram: 0x802DBD40 - # follows_vram: evt + follows_vram: evt subsegments: - [0x0FEE30, c, sprite] - [0x101B90, c, 101b90_len_8f0] @@ -925,6 +925,7 @@ segments: type: code start: 0x10CC10 vram: 0x802EB3D0 + follows_vram: entity subsegments: - [0x10CC10, data] # font width data - type: group @@ -1185,7 +1186,7 @@ segments: - [0x1776B0, c, battle_cam] - [0x17D6A0, c, 17D6A0] - [0x17FEB0, c] - - [0x181810, c] + - [0x181810, c, 181810] - [0x182B30, c, 182B30] - [0x18C790, c, 18C790] - [0x18F340, c, 18F340] @@ -2402,6 +2403,7 @@ segments: - type: code start: 0x316A70 vram: 0x80200080 + follows_vram: 3169F0 subsegments: - [0x316A70, c, 316a70] - type: code diff --git a/ver/us/symbol_addrs.txt b/ver/us/symbol_addrs.txt index 3d2bdbe2fc..de42b46db4 100644 --- a/ver/us/symbol_addrs.txt +++ b/ver/us/symbol_addrs.txt @@ -26647,7 +26647,6 @@ gPauseBadgesNumItems = 0x80270384; // type:data D_80270388 = 0x80270388; // type:data gPauseBadgesCurrentScrollPos = 0x8027038C; // type:data gPauseBadgesTargetScrollPos = 0x80270390; // type:data -D_80270394 = 0x80270394; // type:data gPauseBadgesTargetScrollIndex = 0x80270394; // type:data gPauseBadgesLevel = 0x80270398; // type:data gPauseBadgesCurrentTab = 0x8027039C; // type:data @@ -26655,13 +26654,10 @@ gPauseBadgesBShowNotEnoughBP = 0x802703A0; // type:data gPauseBadgesShowNotEnoughBP = 0x802703A0; // type:data D_802703A4 = 0x802703A4; // type:data gPauseBadgesIconIDs = 0x802703A8; // type:data -D_802703FC = 0x802703FC; // type:data gPauseItemsItemIDs = 0x80270400; // type:data gPauseItemsCurrentPage = 0x802704C8; // type:data D_802704CC = 0x802704CC; // type:data gPauseItemsPages = 0x802704D0; // type:data -D_802704D1 = 0x802704D1; // type:data -D_802704D2 = 0x802704D2; // type:data gPauseItemsSelectedIndex = 0x802705C0; // type:data D_802705C4 = 0x802705C4; // type:data gPauseItemsSelectedItem = 0x802705C8; // type:data @@ -26673,7 +26669,6 @@ gPauseItemsTargetScrollIndex = 0x802705DC; // type:data gPauseItemsLevel = 0x802705E0; // type:data gPauseItemsCurrentTab = 0x802705E4; // type:data gPauseItemsIconIDs = 0x802705E8; // type:data -D_80270634 = 0x80270634; // type:data gPausePartnersIconIDs = 0x80270640; // type:data gPausePartnersSpriteIDs = 0x80270660; // type:data gPausePartnersPartnerIdx = 0x80270680; // type:data @@ -26757,7 +26752,6 @@ D_80294440 = 0x80294440; // type:data D_80294460 = 0x80294460; // type:data D_802944A0 = 0x802944A0; // type:data bSavedPartner = 0x8029DA30; // type:data -D_8029DA33 = 0x8029DA33; // type:data bSavedOverrideFlags = 0x8029DA34; // type:data D_8029DA40 = 0x8029DA40; // type:data D_8029DA44 = 0x8029DA44; // type:data @@ -26772,7 +26766,6 @@ D_8029EFC0 = 0x8029EFC0; // type:data D_8029EFE8 = 0x8029EFE8; // type:data D_8029F010 = 0x8029F010; // type:data D_8029F038 = 0x8029F038; // type:data -D_8029F236 = 0x8029F236; // type:data D_8029F240 = 0x8029F240; // type:data D_8029F244 = 0x8029F244; // type:data D_8029F248 = 0x8029F248; // type:data @@ -26828,10 +26821,7 @@ gSpeakingActorIdleAnim = 0x8029FA70; // gSpeakingActor = 0x8029FA74; // gSpeakingActorPart = 0x8029FA78; // D_8029FA80 = 0x8029FA80; // type:data -D_8029FA88 = 0x8029FA88; // type:data D_8029FA90 = 0x8029FA90; // type:data -D_8029FAA8 = 0x8029FAA8; // type:data -D_8029FAC4 = 0x8029FAC4; // type:data D_8029FAE8 = 0x8029FAE8; // type:data D_8029FB48 = 0x8029FB48; // type:data D_8029FB4C = 0x8029FB4C; // type:data @@ -27018,11 +27008,7 @@ battle_menu_messageIDs = 0x802AD090; // type:data D_802AD0A8 = 0x802AD0A8; // type:data main_menu_numOptions = 0x802AD0AC; // type:data D_802AD0B0 = 0x802AD0B0; // type:data -D_802AD0B3 = 0x802AD0B3; // type:data battle_menu_submenuIDs = 0x802AD0B8; // type:data -D_802AD0BB = 0x802AD0BB; // type:data -D_802AD0BC = 0x802AD0BC; // type:data -D_802AD0C0 = 0x802AD0C0; // type:data battle_menu_isEnabled = 0x802AD0D0; // type:data battle_menu_isMessageDisabled = 0x802AD0E8; // type:data D_802AD0EB = 0x802AD0EB; // type:data @@ -27058,11 +27044,8 @@ battle_menu_moveOptionDisplayCostReductionColors = 0x802AD3E0; // type:data battle_menu_moveOptionBPCosts = 0x802AD440; // type:data battle_menu_hasSpiritsMenu = 0x802AD4A0; // type:data battle_menu_moveOptionCount = 0x802AD4A4; // type:data -D_802AD4A7 = 0x802AD4A7; // type:data D_802AD4A8 = 0x802AD4A8; // type:data battle_menu_moveIndices = 0x802AD4B0; // type:data -D_802AD4B2 = 0x802AD4B2; // type:data -D_802AD4B3 = 0x802AD4B3; // type:data battle_menu_moveOptionsEnabled = 0x802AD510; // type:data battle_menu_moveOptionDescriptions = 0x802AD570; // type:data battle_menu_moveOptionSortPriorities = 0x802AD5D0; // type:data @@ -27092,36 +27075,21 @@ D_802AD63E = 0x802AD63E; // type:data D_802AD640 = 0x802AD640; // type:data D_802AD658 = 0x802AD658; // type:data D_802AD66C = 0x802AD66C; // type:data -D_802AD66F = 0x802AD66F; // type:data D_802AD670 = 0x802AD670; // type:data -D_802AD673 = 0x802AD673; // type:data D_802AD678 = 0x802AD678; // type:data -D_802AD67B = 0x802AD67B; // type:data D_802AD690 = 0x802AD690; // type:data D_802AD6A8 = 0x802AD6A8; // type:data -D_802AD6AA = 0x802AD6AA; // type:data D_802AD6C0 = 0x802AD6C0; // type:data D_802AD6D4 = 0x802AD6D4; // type:data -D_802B6240 = 0x802B6240; // type:data -D_802B62B0 = 0x802B62B0; // type:data Munchlesia_LaunchVelocity = 0x802B62D0; // type:data Munchlesia_LateralVelocity = 0x802B62D4; // type:data Munchlesia_LaunchAccel = 0x802B62D8; // type:data Munchlesia_LaunchYaw = 0x802B62DC; // type:data D_802B62E0 = 0x802B62E0; // type:data -D_802B6730 = 0x802B6730; // type:data -D_802B6780 = 0x802B6780; // type:data -D_802B6784 = 0x802B6784; // type:data -D_802B6788 = 0x802B6788; // type:data -D_802B678C = 0x802B678C; // type:data D_802B6790 = 0x802B6790; // type:data D_802B6794 = 0x802B6794; // type:data D_802B6798 = 0x802B6798; // type:data D_802B679C = 0x802B679C; // type:data -D_802B68B0 = 0x802B68B0; // type:data -D_802B68B4 = 0x802B68B4; // type:data -D_802B68B8 = 0x802B68B8; // type:data -D_802B68BC = 0x802B68BC; // type:data ParasolTransformation = 0x802B6E80; // type:data SpinningFlower_EntityIndex = 0x802B6ED0; // type:data D_802B6ED4 = 0x802B6ED4; // type:data @@ -27156,7 +27124,6 @@ D_802BFEF0 = 0x802BFEF0; // type:data D_802BFEFC = 0x802BFEFC; // type:data D_802BFF30 = 0x802BFF30; // type:data D_802C0000 = 0x802C0000; // type:data -D_802C05CC = 0x802C05CC; // type:data D_802D9D80 = 0x802D9D80; // type:data gMapFlags = 0x802DA480; // gMapVars = 0x802DA484; // @@ -27230,7 +27197,6 @@ D_802E9170 = 0x802E9170; // type:data D_802E91F0 = 0x802E91F0; // type:data D_802E9270 = 0x802E9270; // type:data D_802E92B0 = 0x802E92B0; // type:data -D_802E99DC = 0x802E99DC; // type:data D_802E9E54 = 0x802E9E54; // type:data D_802E9E80 = 0x802E9E80; // type:data Entity_InertYellowBlock = 0x802EA07C; // type:data @@ -27245,9 +27211,7 @@ D_802EA728 = 0x802EA728; // type:data D_802EA744 = 0x802EA744; // type:data D_802EA760 = 0x802EA760; // type:data Entity_HeartBlockContent = 0x802EA7BC; // type:data -D_802EA862 = 0x802EA862; // type:data D_802EA870 = 0x802EA870; // type:data -D_802EA871 = 0x802EA871; // type:data Entity_SuperBlockContent = 0x802EA934; // type:data D_802EAAE0 = 0x802EAAE0; // type:data D_802EAB30 = 0x802EAB30; // type:data @@ -27328,7 +27292,6 @@ D_A6000000 = 0xA6000000; // type:data D_B0000000 = 0xB0000000; // type:data D_B0000008 = 0xB0000008; // type:data D_B0000010 = 0xB0000010; // type:data -D_D9FCFFFF = 0xD9FCFFFF; // type:data D_E0002760 = 0xE0002760; // type:data D_E0002788 = 0xE0002788; // type:data D_E00027B0 = 0xE00027B0; // type:data @@ -27952,11 +27915,9 @@ D_E0200724 = 0xE0200724; // type:data D_E0200728 = 0xE0200728; // type:data D_E020072C = 0xE020072C; // type:data D_E0200730 = 0xE0200730; // type:data -D_E1000010 = 0xE1000010; // type:data D_E7000008 = 0xE7000008; // type:data D_E8000008 = 0xE8000008; // type:data D_F0000008 = 0xF0000008; // type:data -D_F1FFFFFF = 0xF1FFFFFF; // type:data D_F5000007 = 0xF5000007; // type:data D_F79DDD0F = 0xF79DDD0F; // type:data D_FA000028 = 0xFA000028; // type:data diff --git a/ver/us/undefined_syms.txt b/ver/us/undefined_syms.txt index 38bd27ebea..fed61f93d4 100644 --- a/ver/us/undefined_syms.txt +++ b/ver/us/undefined_syms.txt @@ -20,24 +20,20 @@ D_A6000000 = 0xA6000000; D_B0000000 = 0xB0000000; D_B0000008 = 0xB0000008; D_B0000010 = 0xB0000010; -D_D9FCFFFF = 0xD9FCFFFF; -D_E1000010 = 0xE1000010; D_E7000008 = 0xE7000008; D_E8000008 = 0xE8000008; D_F0000008 = 0xF0000008; -D_F1FFFFFF = 0xF1FFFFFF; D_F5000007 = 0xF5000007; -D_F79DDD0F = 0xF79DDD0F; D_FA000028 = 0xFA000028; D_FD100008 = 0xFD100008; -D_7599F6D8 = 0x7599F6D8; - // Obfuscation symbols obfuscated_battle_heap_create = battle_heap_create - 0xFEFFFFF; obfuscated_general_heap_create = general_heap_create - 0xFEFEFEF; obfuscated_load_engine_data = load_engine_data - 0x315; obfuscated_create_audio_system = create_audio_system - 0x7B; +D_7599F6D8 = 0x7599F6D8; +D_F79DDD0F = 0xF79DDD0F; fx_sun_undeclared = fx_sun; @@ -342,14 +338,31 @@ osTvType = 0x80000300; osRomBase = 0x80000308; osMemSize = 0x80000318; gBackgroundImage = 0x80200000; +D_80200000 = 0x80200000; +D_8000030C = 0x8000030C; +D_8000031C = 0x8000031C; +D_800A08C0 = 0x800A08C0; + +// effect tlb stuff +D_80197000 = 0x80197000; +D_801A6000 = 0x801A6000; + +// heap stuff +D_801A7000 = 0x801A7000; +AuHeapBase = 0x801AA000; +heap_collisionHead = 0x80268000; +heap_generalHead = 0x802FB800; +gSpriteHeapPtr = 0x8034F800; +heap_battleHead = 0x803DA800; + +D_80210000 = 0x80210000; func_80242040_8B20B0 = 0x80242040; spiked_goomba = 0x8021B0AC; paragoomba = 0x8021CD00; -D_802C05CC = 0x802C05CC; D_802442D0 = 0x802442D0; D_802AB513 = 0x802AB513; -D_802E99DC = 0x802E99DC; + D_80247AF0_CCB300 = 0x80247AF0; D_802491C0_CA70E0 = 0x802491C0; D_80246568_C8C018 = 0x80246568; @@ -362,16 +375,9 @@ D_803B5000 = 0x803B5000; D_802EF0D0 = 0x802EF0D0; D_800FBB60 = 0x800FBB60; D_800FBBE0 = 0x800FBBE0; -D_80200000 = 0x80200000; -D_8000030C = 0x8000030C; -D_8000031C = 0x8000031C; -D_800A08C0 = 0x800A08C0; -D_80164000 = 0x80164000; -D_80197000 = 0x80197000; -D_801A6000 = 0x801A6000; -D_801A7000 = 0x801A7000; -AuHeapBase = 0x801AA000; -D_80210000 = 0x80210000; + +D_80164000 = 0x80164000; // display contexts, part of bss3 + D_8022AD80_4C3F70 = 0x8022AD80; D_8022ADD0 = 0x8022ADD0; D_8022B550 = 0x8022B550; @@ -792,121 +798,10 @@ D_80262A70 = 0x80262A70; mac_01_LetterDelivery_SavedNpcAnim = 0x80262C34; D_80262C38 = 0x80262C38; D_80262F68 = 0x80262F68; -heap_collisionHead = 0x80268000; -D_8027037C = 0x8027037C; -D_80270388 = 0x80270388; -D_80270394 = 0x80270394; -D_802703FC = 0x802703FC; -D_802704D1 = 0x802704D1; -D_802704D2 = 0x802704D2; -D_802705C4 = 0x802705C4; -D_802705D0 = 0x802705D0; -D_80270634 = 0x80270634; -bMarioHideAnims = 0x80283370; -bSavedPartner = 0x8029DA30; -D_8029DA33 = 0x8029DA33; -bSavedOverrideFlags = 0x8029DA34; -D_8029DA40 = 0x8029DA40; -D_8029DA44 = 0x8029DA44; -D_8029DA48 = 0x8029DA48; -D_8029DA4C = 0x8029DA4C; -D_8029DA50 = 0x8029DA50; -D_8029EFB0 = 0x8029EFB0; -D_8029EFB4 = 0x8029EFB4; -D_8029EFB8 = 0x8029EFB8; -D_8029EFBC = 0x8029EFBC; -D_8029EFC0 = 0x8029EFC0; -D_8029EFE8 = 0x8029EFE8; -D_8029F010 = 0x8029F010; -D_8029F038 = 0x8029F038; -D_8029F236 = 0x8029F236; -D_8029F240 = 0x8029F240; -D_8029F244 = 0x8029F244; -D_8029F248 = 0x8029F248; -D_8029F24C = 0x8029F24C; -D_8029F250 = 0x8029F250; -D_8029F254 = 0x8029F254; -D_8029F258 = 0x8029F258; -D_8029F25C = 0x8029F25C; -D_8029F260 = 0x8029F260; -D_8029F264 = 0x8029F264; -BattleCam_PosX = 0x8029F270; -BattleCam_PosY = 0x8029F274; -BattleCam_PosZ = 0x8029F278; -BattleCam_TargetActor = 0x8029F27C; -BattleCam_TargetActorPart = 0x8029F27E; -BattleCam_BoomLength = 0x8029F280; -BattleCam_BoomYaw = 0x8029F282; -BattleCam_BoomPitch = 0x8029F284; -BattleCam_BoomZOffset = 0x8029F286; -D_8029F288 = 0x8029F288; -BattleCam_InitialBoomLength = 0x8029F28C; -BattleCam_InitialBoomYaw = 0x8029F290; -BattleCam_InitialBoomPitch = 0x8029F294; -BattleCam_InitialBoomZOffset = 0x8029F298; -BattleCam_DoneMoving = 0x8029F29C; -BattleCam_MoveTimeLeft = 0x8029F29E; -BattleCam_MoveTimeTotal = 0x8029F2A0; -BattleCam_ModeY = 0x8029F2A2; -BattleCam_ModeX = 0x8029F2A3; -BattleCam_SetImmediately = 0x8029F2A4; -BattleCam_UseLinearInterp = 0x8029F2A5; -D_8029F2A6 = 0x8029F2A6; -D_8029F2A7 = 0x8029F2A7; -BattleCam_InitialPosX = 0x8029F2A8; -BattleCam_InitialPosY = 0x8029F2AC; -BattleCam_InitialPosZ = 0x8029F2B0; -BattleCam_ControlScript = 0x8029F2B4; -popupMessages = 0x8029F2C0; -D_8029F640 = 0x8029F640; -D_8029F642 = 0x8029F642; -D_8029F644 = 0x8029F644; -D_8029F646 = 0x8029F646; -D_8029F648 = 0x8029F648; -D_8029F64A = 0x8029F64A; -D_8029F64C = 0x8029F64C; -D_8029F64E = 0x8029F64E; -D_8029F650 = 0x8029F650; -gSpeakingActorPrintCtx = 0x8029FA60; -D_8029FA64 = 0x8029FA64; -gSpeakingActorPrintIsDone = 0x8029FA68; -gSpeakingActorTalkAnim = 0x8029FA6C; -gSpeakingActorIdleAnim = 0x8029FA70; -gSpeakingActor = 0x8029FA74; -gSpeakingActorPart = 0x8029FA78; -D_8029FA80 = 0x8029FA80; -D_8029FA88 = 0x8029FA88; -D_8029FA90 = 0x8029FA90; -D_8029FAA8 = 0x8029FAA8; -D_8029FAC4 = 0x8029FAC4; -D_8029FAE8 = 0x8029FAE8; -D_8029FB48 = 0x8029FB48; -D_8029FB4C = 0x8029FB4C; -D_8029FB50 = 0x8029FB50; -D_8029FB54 = 0x8029FB54; -D_8029FB60 = 0x8029FB60; -D_8029FB6C = 0x8029FB6C; -D_8029FB70 = 0x8029FB70; -D_8029FB74 = 0x8029FB74; -D_8029FB78 = 0x8029FB78; -D_8029FB7C = 0x8029FB7C; -D_8029FB80 = 0x8029FB80; -D_8029FB84 = 0x8029FB84; -D_8029FB88 = 0x8029FB88; -D_8029FB8C = 0x8029FB8C; -D_8029FB90 = 0x8029FB90; -D_8029FB94 = 0x8029FB94; -BattleMerleeOrbEffect = 0x8029FB98; -BattleMerleeWaveEffect = 0x8029FB9C; -D_8029FBA0 = 0x8029FBA0; -D_8029FBA4 = 0x8029FBA4; -D_8029FBA8 = 0x8029FBA8; -D_8029FBAC = 0x8029FBAC; -D_8029FBB0 = 0x8029FBB0; -D_8029FBC0 = 0x8029FBC0; -D_8029FBD0 = 0x8029FBD0; -D_8029FBD4 = 0x8029FBD4; + +// more bss for 16c8e0's segment gActionCommandStatus = 0x8029FBE0; + D_802A19B0 = 0x802A19B0; D_802A19C0 = 0x802A19C0; D_802A1A90 = 0x802A1A90; @@ -956,223 +851,16 @@ D_802AA320 = 0x802AA320; D_802AA694 = 0x802AA694; D_802AAA08 = 0x802AAA08; D_802AAA30 = 0x802AAA30; -D_802ACC60 = 0x802ACC60; -D_802ACC64 = 0x802ACC64; -D_802ACC68 = 0x802ACC68; -D_802ACC6C = 0x802ACC6C; -D_802ACC70 = 0x802ACC70; -D_802ACCD0 = 0x802ACCD0; -D_802ACFE8 = 0x802ACFE8; -D_802ACFEC = 0x802ACFEC; -D_802ACFF0 = 0x802ACFF0; -D_802ACFF4 = 0x802ACFF4; -D_802ACFFC = 0x802ACFFC; -D_802ACFFD = 0x802ACFFD; -D_802AD000 = 0x802AD000; -D_802AD001 = 0x802AD001; -D_802AD002 = 0x802AD002; -D_802AD003 = 0x802AD003; -D_802AD004 = 0x802AD004; -D_802AD006 = 0x802AD006; -D_802AD008 = 0x802AD008; -D_802AD00A = 0x802AD00A; -D_802AD010 = 0x802AD010; -D_802AD028 = 0x802AD028; -D_802AD040 = 0x802AD040; -D_802AD044 = 0x802AD044; -D_802AD048 = 0x802AD048; -D_802AD04C = 0x802AD04C; -D_802AD050 = 0x802AD050; -D_802AD054 = 0x802AD054; -D_802AD058 = 0x802AD058; -D_802AD05C = 0x802AD05C; -D_802AD060 = 0x802AD060; -D_802AD064 = 0x802AD064; -D_802AD068 = 0x802AD068; -D_802AD069 = 0x802AD069; -D_802AD06A = 0x802AD06A; -D_802AD06B = 0x802AD06B; -D_802AD06C = 0x802AD06C; -D_802AD070 = 0x802AD070; -main_battle_menu_JumpHudScripts = 0x802AD078; -battle_menu_messageIDs = 0x802AD090; -D_802AD0A8 = 0x802AD0A8; -main_menu_numOptions = 0x802AD0AC; -D_802AD0B0 = 0x802AD0B0; -D_802AD0B3 = 0x802AD0B3; -battle_menu_submenuIDs = 0x802AD0B8; -D_802AD0BB = 0x802AD0BB; -D_802AD0BC = 0x802AD0BC; -D_802AD0C0 = 0x802AD0C0; -battle_menu_isEnabled = 0x802AD0D0; -battle_menu_isMessageDisabled = 0x802AD0E8; -D_802AD0EB = 0x802AD0EB; -D_802AD100 = 0x802AD100; -D_802AD104 = 0x802AD104; -battle_menu_moveState = 0x802AD108; -battle_menu_moveCursorPos = 0x802AD109; -D_802AD10A = 0x802AD10A; -D_802AD10B = 0x802AD10B; -battle_menu_moveScrollLine = 0x802AD10C; -D_802AD10D = 0x802AD10D; -D_802AD10E = 0x802AD10E; -D_802AD10F = 0x802AD10F; -battle_menu_moveScrollOffset = 0x802AD110; -D_802AD112 = 0x802AD112; -battle_menu_moveTextColor = 0x802AD114; -battle_menu_moveTextOpacity = 0x802AD116; -battle_menu_moveCursorIcon = 0x802AD118; -battle_menu_moveUpArrowIcon = 0x802AD11C; -battle_menu_moveDownArrowIcon = 0x802AD120; -battle_menu_moveOptionIconIDs = 0x802AD128; -battle_menu_moveTitleIcon = 0x802AD188; -battle_menu_moveOptionCostUnitIconIDs = 0x802AD190; -battle_menu_moveX = 0x802AD1F0; -battle_menu_moveY = 0x802AD1F2; -battle_menu_moveOptionIndexMap = 0x802AD1F8; -D_802AD258 = 0x802AD258; -battle_menu_moveOptionIconScripts = 0x802AD260; -battle_menu_moveOptionNames = 0x802AD2C0; -battle_menu_moveOptionDisplayCosts = 0x802AD320; -battle_menu_moveOptionDisplayCostReductions = 0x802AD380; -battle_menu_moveOptionDisplayCostReductionColors = 0x802AD3E0; -battle_menu_moveOptionBPCosts = 0x802AD440; -battle_menu_hasSpiritsMenu = 0x802AD4A0; -battle_menu_moveOptionCount = 0x802AD4A4; -D_802AD4A7 = 0x802AD4A7; -D_802AD4A8 = 0x802AD4A8; -battle_menu_moveIndices = 0x802AD4B0; -D_802AD4B2 = 0x802AD4B2; -D_802AD4B3 = 0x802AD4B3; -battle_menu_moveOptionsEnabled = 0x802AD510; -battle_menu_moveOptionDescriptions = 0x802AD570; -battle_menu_moveOptionSortPriorities = 0x802AD5D0; -battle_menu_moveOptionCantUseTypes = 0x802AD5E8; -battle_menu_moveOptionActive = 0x802AD600; -D_802AD603 = 0x802AD603; -D_802AD604 = 0x802AD604; -D_802AD605 = 0x802AD605; -D_802AD606 = 0x802AD606; -D_802AD607 = 0x802AD607; -D_802AD608 = 0x802AD608; -D_802AD609 = 0x802AD609; -D_802AD60A = 0x802AD60A; -D_802AD60B = 0x802AD60B; -D_802AD60C = 0x802AD60C; -D_802AD60E = 0x802AD60E; -D_802AD610 = 0x802AD610; -D_802AD612 = 0x802AD612; -D_802AD614 = 0x802AD614; -D_802AD618 = 0x802AD618; -D_802AD61C = 0x802AD61C; -D_802AD620 = 0x802AD620; -D_802AD624 = 0x802AD624; -D_802AD628 = 0x802AD628; -D_802AD63C = 0x802AD63C; -D_802AD63E = 0x802AD63E; -D_802AD640 = 0x802AD640; -D_802AD658 = 0x802AD658; -D_802AD66C = 0x802AD66C; -D_802AD66F = 0x802AD66F; -D_802AD670 = 0x802AD670; -D_802AD673 = 0x802AD673; -D_802AD678 = 0x802AD678; -D_802AD67B = 0x802AD67B; -D_802AD690 = 0x802AD690; -D_802AD6A8 = 0x802AD6A8; -D_802AD6AA = 0x802AD6AA; -D_802AD6C0 = 0x802AD6C0; -D_802AD6D4 = 0x802AD6D4; -D_802B6240 = 0x802B6240; -D_802B62B0 = 0x802B62B0; -Munchlesia_LaunchVelocity = 0x802B62D0; -Munchlesia_LateralVelocity = 0x802B62D4; -Munchlesia_LaunchAccel = 0x802B62D8; -Munchlesia_LaunchYaw = 0x802B62DC; -D_802B62E0 = 0x802B62E0; -D_802B6730 = 0x802B6730; -D_802B6770_E27C80 = 0x802B6770; -D_802B6780 = 0x802B6780; -D_802B6784 = 0x802B6784; -D_802B6788 = 0x802B6788; -D_802B678C = 0x802B678C; -D_802B6790 = 0x802B6790; -D_802B6794 = 0x802B6794; -D_802B6798 = 0x802B6798; -D_802B679C = 0x802B679C; -D_802B68B0 = 0x802B68B0; -D_802B68B4 = 0x802B68B4; -D_802B68B8 = 0x802B68B8; -D_802B68BC = 0x802B68BC; -ParasolTransformation = 0x802B6E80; D_802B6E90_E2A300 = 0x802B6E90; -SpinningFlower_EntityIndex = 0x802B6ED0; -D_802B6ED4 = 0x802B6ED4; -D_802B6ED8 = 0x802B6ED8; -D_802B6EDC = 0x802B6EDC; -D_802B6EE0 = 0x802B6EE0; -D_802B6EE4 = 0x802B6EE4; -D_802B6EE8 = 0x802B6EE8; -SpinningFlower_AngleToCenter = 0x802B6EEC; -D_802B6EF0 = 0x802B6EF0; -D_802B6EF4 = 0x802B6EF4; + mdl_clearRenderTasks = 0x802B7E00; D_802C0000 = 0x802C0000; -D_802C05CC = 0x802C05CC; -gMapFlags = 0x802DA480; -gMapVars = 0x802DA484; -gNumScripts = 0x802DA488; -gWorldScriptList = 0x802DA490; -gBattleScriptList = 0x802DA690; -gCurrentScriptListPtr = 0x802DA890; -gScriptIndexList = 0x802DA898; -gScriptIdList = 0x802DAA98; -gScriptListCount = 0x802DAC98; -evtDebugPrintBuffer = 0x802DACA0; -gLavaResetList = 0x802DADA0; -D_802DADA4 = 0x802DADA4; -gBattleMeshAnimationList = 0x802DADB0; -gWorldMeshAnimationList = 0x802DADF0; -gCurrentMeshAnimationListPtr = 0x802DAE30; -wExtraPartnerID = 0x802DAE40; -wExtraPartnerNpcID = 0x802DAE44; -D_802DAE50 = 0x802DAE50; -D_802DAE54 = 0x802DAE54; -gCurrentPrintContext = 0x802DB260; -D_802DB264 = 0x802DB264; -D_802DB268 = 0x802DB268; -D_802DB5B0 = 0x802DB5B0; -D_802DB5C0 = 0x802DB5C0; -D_802DB6C0 = 0x802DB6C0; -D_802DB7C0 = 0x802DB7C0; -MusicEventList = 0x802DB7D0; -RunningMusicEvents = 0x802DB7D8; -RunningMusicEventIDs = 0x802DB800; -D_802DB830 = 0x802DB830; -D_802DBB60 = 0x802DBB60; -D_802DBB68 = 0x802DBB68; -gWorldMapFlags = 0x802DBC70; -DoorModelsSwingCW = 0x802DBC7C; -D_802DBC88 = 0x802DBC88; -gWorldMapVars = 0x802DBCA8; -gBattleMapVars = 0x802DBCE8; -DoorModelsSwingCCW = 0x802DBD28; -gBattleMapFlags = 0x802DBD34; -SaveBlockTutorialPrinterClosed = 0x802EB390; -SaveBlockResultPrinterClosed = 0x802EB394; -SaveBlockTutorialPrinter = 0x802EB398; -SaveBlockResultPrinter = 0x802EB39C; -SwitchToLink = 0x802EB3A0; -TriggerBlockVanishEffect = 0x802EB3B0; -HeartBlockPrinterClosed = 0x802EB3C0; D_802ED970 = 0x802ED970; D_802EE8D0 = 0x802EE8D0; D_802F39D0 = 0x802F39D0; D_802F4560 = 0x802F4560; -heap_generalHead = 0x802FB800; -gSpriteHeapPtr = 0x8034F800; -heap_battleHead = 0x803DA800; + D_802465D0_kzn_02 = 0x802465D0; D_80247420_kzn_03 = 0x80247420; D_80248380_kzn_19 = 0x80248380; @@ -1190,8 +878,5 @@ D_80246560_kkj_19 = 0x80246560; end_01_CreditsProjMatrices = 0x8024B9D0; end_01_CreditsDataPtr = 0x8024A2C4; D_80242568_filemenu = 0x80242568; -D_802EA871 = 0x802EA871; -D_802EA862 = 0x802EA862; -D_802EA862 = 0x802EA862; D_80243390_omo_12 = 0x80243390; D_8024F580_hos_05 = 0x8024F580;