LowLevel/Luma3DS-3GX
Archived
1
0
Fork 0
Code Issues Pull Requests Releases 2 Wiki Activity

Refactor the exception handling code

Browse Source
This commit is contained in:
TuxSH
2016-06-08 21:44:04 +02:00
parent e478908dca
commit ef60c8ea4c
6 changed files with 168 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
exceptions/arm9/source/handlers.h
View File

@@ -6,8 +6,24 @@
*/
#pragma once
#include "types.h"
void FIQHandler(void);
void undefinedInstructionHandler(void);
void dataAbortHandler(void);
void prefetchAbortHandler(void);
void prefetchAbortHandler(void);
typedef struct __attribute__((packed))
{
u32 magic[2];
u16 versionMinor, versionMajor;
u16 processor, core;
u32 type;
u32 totalSize;
u32 registerDumpSize;
u32 codeDumpSize;
u32 stackDumpSize;
u32 additionalDataSize;
} ExceptionDumpHeader;

10
exceptions/arm9/source/handlers.s
View File

@@ -39,14 +39,8 @@ _commonHandler:
msr cpsr_c, r3 @ restore processor mode
mov sp, r6
stmfd sp!, {r2,lr}
mrc p15,0,r3,c5,c0,0 @ dfsr
mrc p15,0,r4,c5,c0,1 @ ifsr
mrc p15,0,r5,c6,c0,0 @ far
stmfd sp!, {r3-r5} @ it's a bit of a mess, but we will fix that later
@ order of saved regs now: dfsr, ifsr, far, cpsr, pc + (2/4/8), r8-r14, r0-r7
stmfd sp!, {r2,lr} @ it's a bit of a mess, but we will fix that later
@ order of saved regs now: cpsr, pc + (2/4/8), r8-r14, r0-r7
mov r0, sp
b mainHandler

81
exceptions/arm9/source/mainHandler.c
View File

@@ -5,60 +5,67 @@
* This is part of Luma3DS, see LICENSE.txt for details
*/
#include "types.h"
#include "i2c.h"
#include "handlers.h"
#define FINAL_BUFFER 0x25000000
#define REG_DUMP_SIZE (4*20)
#define REG_DUMP_SIZE (4*17)
#define CODE_DUMP_SIZE 48
#define OTHER_DATA_SIZE 0
void __attribute__((noreturn)) mainHandler(u32 regs[REG_DUMP_SIZE / 4], u32 type)
{
u32 dump[(40 + REG_DUMP_SIZE + CODE_DUMP_SIZE) / 4];
ExceptionDumpHeader dumpHeader;
dump[0] = 0xDEADC0DE; //Magic
dump[1] = 0xDEADCAFE; //Magic
dump[2] = (1 << 16) | 1; //Dump format version number
dump[3] = 9; //Processor
dump[4] = type; //Exception type
dump[6] = REG_DUMP_SIZE; //Register dump size (r0-r12, sp, lr, pc, cpsr)
dump[7] = CODE_DUMP_SIZE; //Code dump size (10 ARM instructions, up to 20 Thumb instructions).
dump[9] = OTHER_DATA_SIZE; //Other data size
u32 registerDump[REG_DUMP_SIZE / 4];
u8 codeDump[CODE_DUMP_SIZE];
dumpHeader.magic[0] = 0xDEADC0DE;
dumpHeader.magic[1] = 0xDEADCAFE;
dumpHeader.versionMajor = 1;
dumpHeader.versionMinor = 1;
dumpHeader.processor = 9;
dumpHeader.core = 0;
dumpHeader.type = type;
dumpHeader.registerDumpSize = REG_DUMP_SIZE;
dumpHeader.codeDumpSize = CODE_DUMP_SIZE;
dumpHeader.additionalDataSize = 0;
//Dump registers
//Current order of saved regs: dfsr, ifsr, far, cpsr, pc, r8-r14, r0-r7
vu32 *regdump = dump + 10;
//Current order of saved regs: cpsr, pc, r8-r14, r0-r7
u32 cpsr = regs[0];
u32 pc = regs[1] - ((type < 3) ? (((cpsr & 0x20) != 0 && type == 1) ? 2 : 4) : 8);
u32 cpsr = regs[3];
u32 pc = regs[4] - ((type < 3) ? (((cpsr & 0x20) != 0 && type == 1) ? 2 : 4) : 8);
registerDump[15] = pc;
registerDump[16] = cpsr;
for(u32 i = 0; i < 7; i++) registerDump[8 + i] = regs[2 + i];
for(u32 i = 0; i < 8; i++) registerDump[i] = regs[9 + i];
regdump[15] = pc;
regdump[16] = cpsr;
for(u32 i = 0; i < 3; i++) regdump[17 + i] = regs[i];
for(u32 i = 0; i < 7; i++) regdump[8 + i] = regs[5 + i];
for(u32 i = 0; i < 8; i++) regdump[i] = regs[12 + i];
dump[8] = 0x1000 - (regdump[13] & 0xfff); //Stack dump size (max. 0x1000 bytes)
dump[5] = 40 + REG_DUMP_SIZE + CODE_DUMP_SIZE + dump[8] + OTHER_DATA_SIZE; //Total size
dumpHeader.stackDumpSize = 0x1000 - (registerDump[13] & 0xfff);
dumpHeader.totalSize = sizeof(ExceptionDumpHeader) + dumpHeader.registerDumpSize + dumpHeader.codeDumpSize + dumpHeader.stackDumpSize;
//Dump code
u8 *codedump = (u8 *)regdump + dump[6];
vu8 *instr = (vu8 *)pc + ((cpsr & 0x20) ? 2 : 4) - dump[7]; //Doesn't work well on 32-bit Thumb instructions, but it isn't much of a problem
for(u32 i = 0; i < dump[7]; i++)
codedump[i] = instr[i];
//Dump stack
vu32 *sp = (vu32 *)regdump[13];
vu32 *stackdump = (vu32 *)((vu8 *)FINAL_BUFFER + 40 + REG_DUMP_SIZE + CODE_DUMP_SIZE);
for(u32 i = 0; i < dump[8] / 4; i++)
stackdump[i] = sp[i];
vu8 *instr = (vu8 *)pc + ((cpsr & 0x20) ? 2 : 4) - dumpHeader.codeDumpSize; //Doesn't work well on 32-bit Thumb instructions, but it isn't much of a problem
for(u32 i = 0; i < dumpHeader.codeDumpSize; i++)
codeDump[i] = instr[i];
//Copy header (actually optimized by the compiler), register dump and code dump
vu32 *final = (vu32 *)FINAL_BUFFER;
for(u32 i = 0; i < (40 + REG_DUMP_SIZE + CODE_DUMP_SIZE) / 4; i++)
final[i] = dump[i];
*(ExceptionDumpHeader *)final = dumpHeader;
final += sizeof(ExceptionDumpHeader) / 4;
for(u32 i = 0; i < dumpHeader.registerDumpSize / 4; i++)
*final++ = registerDump[i];
for(u32 i = 0; i < dumpHeader.codeDumpSize / 4; i++)
*final++ = *((u32 *)codeDump + i);
//Dump stack in place
vu32 *sp = (vu32 *)registerDump[13];
for(u32 i = 0; i < dumpHeader.stackDumpSize / 4; i++)
*final++ = sp[i];
i2cWriteRegister(I2C_DEV_MCU, 0x20, 1 << 2); //Reboot
while(1);