void Debugger::updateCallFrameAndPauseIfNeeded(CallFrame* callFrame) { updateCallFrame(callFrame); pauseIfNeeded(callFrame); if (!isStepping()) m_currentCallFrame = 0; }
LRESULT CDebugCommandsView::OnViewPCButton(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/) { if (g_Reg != NULL && isStepping()) { ShowAddress(g_Reg->m_PROGRAM_COUNTER, TRUE); } return FALSE; }
void Debugger::registerCodeBlock(CodeBlock* codeBlock) { // FIXME: We should never have to jettison a code block (due to pending breakpoints // or stepping mode) that is being registered. operationOptimize() should have // prevented the optimizing of such code blocks in the first place. Find a way to // express this with greater clarity in the code. See <https://webkit.org/b131771>. applyBreakpoints(codeBlock); if (isStepping()) codeBlock->setSteppingMode(CodeBlock::SteppingModeEnabled); }
LRESULT CEditReg64::OnChar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) { if (!isStepping()) { goto canceled; } char charCode = (char)wParam; if (!isxdigit(charCode) && charCode != ' ') { if (!isalnum(charCode)) { goto unhandled; } goto canceled; } if (isalpha(charCode) && !isupper(charCode)) { SendMessage(uMsg, toupper(wParam), lParam); goto canceled; } char text[20]; GetWindowText(text, 20); int textLen = strlen(text); if (textLen >= 17) { int selStart, selEnd; GetSel(selStart, selEnd); if (selEnd - selStart == 0) { goto canceled; } } if (charCode == ' ' && strchr(text, ' ') != NULL) { goto canceled; } unhandled: bHandled = FALSE; return 0; canceled: bHandled = TRUE; return 0; }
void Debugger::willExecuteProgram(CallFrame* callFrame) { if (m_isPaused) return; PauseReasonDeclaration reason(*this, PausedAtStartOfProgram); // FIXME: This check for whether we're debugging a worker thread is a workaround // for https://bugs.webkit.org/show_bug.cgi?id=102637. Remove it when we rework // the debugger implementation to not require callbacks. if (!m_isInWorkerThread) updateCallFrameAndPauseIfNeeded(callFrame); else if (isStepping()) updateCallFrame(callFrame); }
void Debugger::updateCallFrame(CallFrame* callFrame, CallFrameUpdateAction action) { if (!callFrame) { m_currentCallFrame = nullptr; return; } updateCallFrameInternal(callFrame); if (action == AttemptPause) pauseIfNeeded(callFrame); if (!isStepping()) m_currentCallFrame = nullptr; }
LRESULT CDebugCommandsView::OnPCChanged(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) { if (!m_Attached) { return 0; } if (m_bIgnorePCChange) { m_bIgnorePCChange = false; return 0; } if (g_Reg != NULL && isStepping()) { g_Reg->m_PROGRAM_COUNTER = m_PCEdit.GetValue(); } return 0; }
// Highlight command list items & draw branch arrows LRESULT CDebugCommandsView::OnCustomDrawList(NMHDR* pNMHDR) { NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(pNMHDR); DWORD drawStage = pLVCD->nmcd.dwDrawStage; switch (drawStage) { case CDDS_PREPAINT: return (CDRF_NOTIFYITEMDRAW | CDRF_NOTIFYPOSTPAINT); case CDDS_ITEMPREPAINT: return CDRF_NOTIFYSUBITEMDRAW; case (CDDS_ITEMPREPAINT | CDDS_SUBITEM): break; case CDDS_POSTPAINT: DrawBranchArrows(pLVCD->nmcd.hdc); return CDRF_DODEFAULT; default: return CDRF_DODEFAULT; } uint32_t nItem = (uint32_t)pLVCD->nmcd.dwItemSpec; uint32_t nSubItem = pLVCD->iSubItem; uint32_t address = m_StartAddress + (nItem * 4); uint32_t pc = (g_Reg != NULL) ? g_Reg->m_PROGRAM_COUNTER : 0; OPCODE pcOpcode; if (g_MMU != NULL) { g_MMU->LW_VAddr(pc, pcOpcode.Hex); } else { pcOpcode.Hex = 0; } if (nSubItem == CCommandList::COL_ARROWS) { return CDRF_DODEFAULT; } if (nSubItem == CCommandList::COL_ADDRESS) // addr { CBreakpoints::BPSTATE bpState = m_Breakpoints->ExecutionBPExists(address); if (bpState == CBreakpoints::BP_SET) { // breakpoint pLVCD->clrTextBk = RGB(0x44, 0x00, 0x00); pLVCD->clrText = (address == pc && isDebugging()) ? RGB(0xFF, 0xFF, 0x00) : // breakpoint & current pc RGB(0xFF, 0xCC, 0xCC); } else if (bpState == CBreakpoints::BP_SET_TEMP) { // breakpoint pLVCD->clrTextBk = RGB(0x66, 0x44, 0x00); pLVCD->clrText = (address == pc && isDebugging()) ? RGB(0xFF, 0xFF, 0x00) : // breakpoint & current pc RGB(0xFF, 0xEE, 0xCC); } else if (address == pc && isStepping()) { // pc pLVCD->clrTextBk = RGB(0x88, 0x88, 0x88); pLVCD->clrText = RGB(0xFF, 0xFF, 0); } else { //default pLVCD->clrTextBk = RGB(0xEE, 0xEE, 0xEE); pLVCD->clrText = RGB(0x44, 0x44, 0x44); } return CDRF_DODEFAULT; } // (nSubItem == 1 || nSubItem == 2) // cmd & args COpInfo OpInfo; OPCODE& OpCode = OpInfo.m_OpCode; bool bAddrOkay = false; if (AddressSafe(address)) { bAddrOkay = g_MMU->LW_VAddr(address, OpCode.Hex); } struct { COLORREF bg; COLORREF fg; } colors; if (!bAddrOkay) { colors = { 0xFFFFFF, 0xFF0000 }; } else if (address == pc && isStepping()) { colors = { 0xFFFFAA, 0x222200 }; } else if (IsOpEdited(address)) { colors = { 0xFFEEFF, 0xFF00FF }; } else if (OpInfo.IsStackAlloc()) { colors = { 0xCCDDFF, 0x001144 }; } else if (OpInfo.IsStackFree()) { colors = { 0xFFDDDD, 0x440000 }; } else if (OpInfo.IsNOP()) { colors = { 0xFFFFFF, 0x888888 }; } else if (OpInfo.IsJump()) { colors = { 0xEEFFEE, 0x006600 }; } else if (OpInfo.IsBranch()) { colors = { 0xFFFFFF, 0x337700 }; } else { colors = { 0xFFFFFF, 0x0000000 }; } // Gray annotations if (nSubItem == CCommandList::COL_SYMBOL) { if (m_bvAnnotatedLines[nItem]) { colors.fg = 0x666666; } } pLVCD->clrTextBk = _byteswap_ulong(colors.bg) >> 8; pLVCD->clrText = _byteswap_ulong(colors.fg) >> 8; if (!isStepping()) { return CDRF_DODEFAULT; } // color register usage // todo localise to temp register context (dont look before/after jumps and frame shifts) COLORREF clrUsedRegister = RGB(0xF5, 0xF0, 0xFF); // light purple COLORREF clrAffectedRegister = RGB(0xFF, 0xF0, 0xFF); // light pink int pcUsedRegA = 0, pcUsedRegB = 0, pcChangedReg = 0; int curUsedRegA = 0, curUsedRegB = 0, curChangedReg = 0; if (pcOpcode.op == R4300i_SPECIAL) { pcUsedRegA = pcOpcode.rs; pcUsedRegB = pcOpcode.rt; pcChangedReg = pcOpcode.rd; } else { pcUsedRegA = pcOpcode.rs; pcChangedReg = pcOpcode.rt; } if (OpCode.op == R4300i_SPECIAL) { curUsedRegA = OpCode.rs; curUsedRegB = OpCode.rt; curChangedReg = OpCode.rd; } else { curUsedRegA = OpCode.rs; curChangedReg = OpCode.rt; } if (address < pc) { if (curChangedReg != 0 && (pcUsedRegA == curChangedReg || pcUsedRegB == curChangedReg)) { pLVCD->clrTextBk = clrUsedRegister; } } else if (address > pc) { if (pcChangedReg != 0 && (curUsedRegA == pcChangedReg || curUsedRegB == pcChangedReg)) { pLVCD->clrTextBk = clrAffectedRegister; } } return CDRF_DODEFAULT; }
LRESULT CDebugCommandsView::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) { g_Settings->RegisterChangeCB(Debugger_WaitingForStep, this, (CSettings::SettingChangedFunc)StaticWaitingForStepChanged); g_Settings->RegisterChangeCB(Debugger_SteppingOps, this, (CSettings::SettingChangedFunc)StaticSteppingOpsChanged); m_CommandList.Attach(GetDlgItem(IDC_CMD_LIST)); m_BreakpointList.Attach(GetDlgItem(IDC_BP_LIST)); m_AddressEdit.Attach(GetDlgItem(IDC_ADDR_EDIT)); m_PCEdit.Attach(GetDlgItem(IDC_PC_EDIT)); m_ViewPCButton.Attach(GetDlgItem(IDC_VIEWPC_BTN)); m_StepButton.Attach(GetDlgItem(IDC_STEP_BTN)); m_StepOverButton.Attach(GetDlgItem(IDC_STEPOVER_BTN)); m_SkipButton.Attach(GetDlgItem(IDC_SKIP_BTN)); m_GoButton.Attach(GetDlgItem(IDC_GO_BTN)); m_RegisterTabs.Attach(GetDlgItem(IDC_REG_TABS)); m_Scrollbar.Attach(GetDlgItem(IDC_SCRL_BAR)); m_BackButton.Attach(GetDlgItem(IDC_BACK_BTN)); m_ForwardButton.Attach(GetDlgItem(IDC_FORWARD_BTN)); m_OpEdit.Attach(GetDlgItem(IDC_OP_EDIT)); DlgResize_Init(false, true); DlgToolTip_Init(); GetWindowRect(&m_DefaultWindowRect); // Setup address input m_AddressEdit.SetDisplayType(CEditNumber32::DisplayHex); m_AddressEdit.SetLimitText(8); // Setup PC register input m_PCEdit.SetDisplayType(CEditNumber32::DisplayHex); m_PCEdit.SetLimitText(8); m_bIgnorePCChange = true; m_PCEdit.SetValue(0x80000180, false, true); // Setup View PC button m_ViewPCButton.EnableWindow(FALSE); m_StepButton.EnableWindow(FALSE); m_StepOverButton.EnableWindow(FALSE); m_SkipButton.EnableWindow(FALSE); m_GoButton.EnableWindow(FALSE); // Setup breakpoint list m_BreakpointList.ModifyStyle(NULL, LBS_NOTIFY); RefreshBreakpointList(); // Setup list scrollbar m_Scrollbar.SetScrollRange(0, 100, FALSE); m_Scrollbar.SetScrollPos(50, TRUE); // Setup history buttons ToggleHistoryButtons(); // Op editor m_OpEdit.SetCommandsWindow(this); m_bIgnoreAddrChange = true; m_AddressEdit.SetValue(0x80000000, false, true); ShowAddress(0x80000000, TRUE); if (isStepping()) { m_ViewPCButton.EnableWindow(TRUE); m_StepButton.EnableWindow(TRUE); m_StepOverButton.EnableWindow(TRUE); m_SkipButton.EnableWindow(TRUE); m_GoButton.EnableWindow(TRUE); } _this = this; DWORD dwThreadID = ::GetCurrentThreadId(); hWinMessageHook = SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)HookProc, NULL, dwThreadID); WindowCreated(); m_Attached = true; return TRUE; }
void CDebugCommandsView::ShowAddress(uint32_t address, bool top) { if (top == TRUE) { m_StartAddress = address; if (!isStepping()) { // Disable buttons m_ViewPCButton.EnableWindow(FALSE); m_StepButton.EnableWindow(FALSE); m_StepOverButton.EnableWindow(FALSE); m_SkipButton.EnableWindow(FALSE); m_GoButton.EnableWindow(FALSE); m_RegisterTabs.SetColorsEnabled(false); } } else { bool bOutOfView = address < m_StartAddress || address > m_StartAddress + (m_CommandListRows - 1) * 4; if (bOutOfView) { m_StartAddress = address; m_bIgnoreAddrChange = true; m_AddressEdit.SetValue(address, false, true); } if (m_History.size() == 0 || m_History[m_HistoryIndex] != m_StartAddress) { HistoryPushState(); } m_bIgnorePCChange = true; m_PCEdit.SetValue(g_Reg->m_PROGRAM_COUNTER, false, true); // Enable buttons m_ViewPCButton.EnableWindow(TRUE); m_StepButton.EnableWindow(TRUE); m_StepOverButton.EnableWindow(TRUE); m_SkipButton.EnableWindow(TRUE); m_GoButton.EnableWindow(TRUE); m_RegisterTabs.SetColorsEnabled(true); } m_CommandList.SetRedraw(FALSE); m_CommandList.DeleteAllItems(); ClearBranchArrows(); m_bvAnnotatedLines.clear(); CSymbols::EnterCriticalSection(); for (int i = 0; i < m_CommandListRows; i++) { uint32_t opAddr = m_StartAddress + i * 4; m_CommandList.AddItem(i, CCommandList::COL_ARROWS, " "); char addrStr[9]; sprintf(addrStr, "%08X", opAddr); m_CommandList.AddItem(i, CCommandList::COL_ADDRESS, addrStr); COpInfo OpInfo; OPCODE& OpCode = OpInfo.m_OpCode; bool bAddrOkay = false; if (AddressSafe(opAddr)) { bAddrOkay = g_MMU->LW_VAddr(opAddr, OpCode.Hex); } if (!bAddrOkay) { m_CommandList.AddItem(i, CCommandList::COL_COMMAND, "***"); m_bvAnnotatedLines.push_back(false); continue; } char* command = (char*)R4300iOpcodeName(OpCode.Hex, opAddr); char* cmdName = strtok((char*)command, "\t"); char* cmdArgs = strtok(NULL, "\t"); // Show subroutine symbol name for JAL target if (OpCode.op == R4300i_JAL) { uint32_t targetAddr = (0x80000000 | (OpCode.target << 2)); // todo move symbols management to CDebuggerUI const char* targetSymbolName = CSymbols::GetNameByAddress(targetAddr); if (targetSymbolName != NULL) { cmdArgs = (char*)targetSymbolName; } } // Detect reads and writes to mapped registers, cart header data, etc const char* annotation = NULL; bool bLoadStoreAnnotation = false; if (OpInfo.IsLoadStoreCommand()) { for (int offset = -4; offset > -24; offset -= 4) { if (!AddressSafe(opAddr + offset)) { break; } OPCODE OpCodeTest; bAddrOkay = g_MMU->LW_VAddr(opAddr + offset, OpCodeTest.Hex); if (!bAddrOkay) { break; } if (OpCodeTest.op != R4300i_LUI) { continue; } if (OpCodeTest.rt != OpCode.rs) { continue; } uint32_t memAddr = (OpCodeTest.immediate << 16) + (short)OpCode.offset; annotation = CSymbols::GetNameByAddress(memAddr); if (annotation == NULL) { annotation = GetDataAddressNotes(memAddr); } break; } } if (annotation == NULL) { annotation = GetCodeAddressNotes(opAddr); } else { bLoadStoreAnnotation = true; } m_CommandList.AddItem(i, CCommandList::COL_COMMAND, cmdName); m_CommandList.AddItem(i, CCommandList::COL_PARAMETERS, cmdArgs); // Show routine symbol name for this address const char* routineSymbolName = CSymbols::GetNameByAddress(opAddr); if (routineSymbolName != NULL) { m_CommandList.AddItem(i, CCommandList::COL_SYMBOL, routineSymbolName); m_bvAnnotatedLines.push_back(false); } else if (annotation != NULL) { const char* annotationFormat = bLoadStoreAnnotation ? "// (%s)" : "// %s"; m_CommandList.AddItem(i, CCommandList::COL_SYMBOL, stdstr_f(annotationFormat, annotation).c_str()); m_bvAnnotatedLines.push_back(true); } else { m_bvAnnotatedLines.push_back(false); } // Add arrow for branch instruction if (OpInfo.IsBranch()) { int startPos = i; int endPos = startPos + (int16_t)OpCode.offset + 1; AddBranchArrow(startPos, endPos); } // Branch arrow for close J if (OpCode.op == R4300i_J) { uint32_t target = (OpCode.target << 2); int dist = target - (opAddr & 0x3FFFFFF); if (abs(dist) < 0x10000) { int startPos = i; int endPos = startPos + (dist / 4); AddBranchArrow(startPos, endPos); } } } CSymbols::LeaveCriticalSection(); if (!top) // update registers when called via breakpoint/stepping { m_RegisterTabs.RefreshEdits(); } RefreshBreakpointList(); m_CommandList.SetRedraw(TRUE); }
// Called from the interpreter core at the beginning of every CPU step void CDebuggerUI::CPUStepStarted() { if (isStepping() && bCPULoggingEnabled()) { Debug_RefreshCPULogWindow(); } uint32_t pc = g_Reg->m_PROGRAM_COUNTER; COpInfo opInfo(R4300iOp::m_Opcode); if (opInfo.IsStoreCommand()) { uint32_t memoryAddress = opInfo.GetLoadStoreAddress(); if (m_Breakpoints->MemLockExists(memoryAddress, opInfo.NumBytesToStore())) { // Memory is locked, skip op g_Settings->SaveBool(Debugger_SkipOp, true); return; } } m_ScriptSystem->HookCPUExec()->InvokeByAddressInRange(pc); if (SkipOp()) { return; } m_ScriptSystem->HookCPUExecOpcode()->InvokeByAddressInRange_MaskedOpcode(pc, R4300iOp::m_Opcode.Hex); if (SkipOp()) { return; } m_ScriptSystem->HookCPUGPRValue()->InvokeByAddressInRange_GPRValue(pc); if (SkipOp()) { return; } // Memory events, pi cart -> ram dma if (opInfo.IsLoadStoreCommand()) // Read and write instructions { uint32_t memoryAddress = opInfo.GetLoadStoreAddress(); if (opInfo.IsLoadCommand()) // Read instructions { m_ScriptSystem->HookCPURead()->InvokeByAddressInRange(memoryAddress); if (SkipOp()) { return; } } else // Write instructions { m_ScriptSystem->HookCPUWrite()->InvokeByAddressInRange(memoryAddress); if (SkipOp()) { return; } if (memoryAddress == 0xA460000C) // PI_WR_LEN_REG { HandleCartToRamDMA(); } } } if (CDebugSettings::ExceptionBreakpoints() != 0) { if (pc == 0x80000000 || pc == 0x80000080 || pc == 0xA0000100 || pc == 0x80000180) { HandleCPUException(); } } if (m_Breakpoints->HaveAnyGPRWriteBP()) { int nReg = 0; opInfo.WritesGPR(&nReg); if (nReg != 0 && m_Breakpoints->HaveGPRWriteBP(nReg)) { g_Settings->SaveBool(Debugger_SteppingOps, true); } } if (m_Breakpoints->HaveAnyGPRReadBP()) { int nReg1 = 0, nReg2 = 0; opInfo.ReadsGPR(&nReg1, &nReg2); if ((nReg1 != 0 && m_Breakpoints->HaveGPRReadBP(nReg1)) || (nReg2 != 0 && m_Breakpoints->HaveGPRReadBP(nReg2))) { g_Settings->SaveBool(Debugger_SteppingOps, true); } } if (m_Breakpoints->HaveHIWriteBP() && opInfo.WritesHI() || m_Breakpoints->HaveLOWriteBP() && opInfo.WritesLO() || m_Breakpoints->HaveHIReadBP() && opInfo.ReadsHI() || m_Breakpoints->HaveLOReadBP() && opInfo.ReadsLO()) { g_Settings->SaveBool(Debugger_SteppingOps, true); } }
void Debugger::registerCodeBlock(CodeBlock* codeBlock) { applyBreakpoints(codeBlock); if (isStepping()) codeBlock->setSteppingMode(CodeBlock::SteppingModeEnabled); }
void CRegisterTabs::RegisterChanged(HWND hDlg, TAB_ID srcTabId, WPARAM wParam) { if (g_Reg == NULL || !isStepping()) { return; } WORD ctrlId = LOWORD(wParam); CWindow editCtrl = ::GetDlgItem(hDlg, ctrlId); char text[20]; editCtrl.GetWindowText(text, 20); if (srcTabId == TabGPR) { uint64_t value = CEditReg64::ParseValue(text); if (ctrlId == IDC_HI_EDIT) { g_Reg->m_HI.UDW = value; } else if (ctrlId == IDC_LO_EDIT) { g_Reg->m_LO.UDW = value; } else { int nReg = GetCtrlRegNum(ctrlId, GPREditIds); g_Reg->m_GPR[nReg].UDW = value; } return; } uint32_t value = strtoul(text, NULL, 16); sprintf(text, "%08X", value); editCtrl.SetWindowText(text); // reformat text if (srcTabId == TabFPR) { if (ctrlId == IDC_FCSR_EDIT) { g_Reg->m_FPCR[31] = value; return; } int nReg = GetCtrlRegNum(ctrlId, FPREditIds); *(uint32_t*)g_Reg->m_FPR_S[nReg] = value; return; } switch (ctrlId) { case IDC_COP0_0_EDIT: g_Reg->INDEX_REGISTER = value; break; case IDC_COP0_1_EDIT: g_Reg->RANDOM_REGISTER = value; break; case IDC_COP0_2_EDIT: g_Reg->ENTRYLO0_REGISTER = value; break; case IDC_COP0_3_EDIT: g_Reg->ENTRYLO1_REGISTER = value; break; case IDC_COP0_4_EDIT: g_Reg->CONTEXT_REGISTER = value; break; case IDC_COP0_5_EDIT: g_Reg->PAGE_MASK_REGISTER = value; break; case IDC_COP0_6_EDIT: g_Reg->WIRED_REGISTER = value; break; case IDC_COP0_7_EDIT: g_Reg->BAD_VADDR_REGISTER = value; break; case IDC_COP0_8_EDIT: g_Reg->COUNT_REGISTER = value; break; case IDC_COP0_9_EDIT: g_Reg->ENTRYHI_REGISTER = value; break; case IDC_COP0_10_EDIT: g_Reg->COMPARE_REGISTER = value; break; case IDC_COP0_11_EDIT: g_Reg->STATUS_REGISTER = value; break; case IDC_COP0_12_EDIT: g_Reg->CAUSE_REGISTER = value; break; case IDC_COP0_13_EDIT: g_Reg->EPC_REGISTER = value; break; case IDC_COP0_14_EDIT: g_Reg->CONFIG_REGISTER = value; break; case IDC_COP0_15_EDIT: g_Reg->TAGLO_REGISTER = value; break; case IDC_COP0_16_EDIT: g_Reg->TAGHI_REGISTER = value; break; case IDC_COP0_17_EDIT: g_Reg->ERROREPC_REGISTER = value; break; case IDC_COP0_18_EDIT: g_Reg->FAKE_CAUSE_REGISTER = value; break; case IDC_RDRAM00_EDIT: g_Reg->RDRAM_CONFIG_REG = value; break; // or device_type case IDC_RDRAM04_EDIT: g_Reg->RDRAM_DEVICE_ID_REG = value; break; case IDC_RDRAM08_EDIT: g_Reg->RDRAM_DELAY_REG = value; break; case IDC_RDRAM0C_EDIT: g_Reg->RDRAM_MODE_REG = value; break; case IDC_RDRAM10_EDIT: g_Reg->RDRAM_REF_INTERVAL_REG = value; break; case IDC_RDRAM14_EDIT: g_Reg->RDRAM_REF_ROW_REG = value; break; case IDC_RDRAM18_EDIT: g_Reg->RDRAM_RAS_INTERVAL_REG = value; break; case IDC_RDRAM1C_EDIT: g_Reg->RDRAM_MIN_INTERVAL_REG = value; break; case IDC_RDRAM20_EDIT: g_Reg->RDRAM_ADDR_SELECT_REG = value; break; case IDC_RDRAM24_EDIT: g_Reg->RDRAM_DEVICE_MANUF_REG = value; break; case IDC_SP00_EDIT: g_Reg->SP_MEM_ADDR_REG = value; break; case IDC_SP04_EDIT: g_Reg->SP_DRAM_ADDR_REG = value; break; case IDC_SP08_EDIT: g_Reg->SP_RD_LEN_REG = value; break; case IDC_SP0C_EDIT: g_Reg->SP_WR_LEN_REG = value; break; case IDC_SP10_EDIT: g_Reg->SP_STATUS_REG = value; break; case IDC_SP14_EDIT: g_Reg->SP_DMA_FULL_REG = value; break; case IDC_SP18_EDIT: g_Reg->SP_DMA_BUSY_REG = value; break; case IDC_SP1C_EDIT: g_Reg->SP_SEMAPHORE_REG = value; break; case IDC_SP_PC_EDIT: g_Reg->SP_PC_REG = value; break; case IDC_DPC00_EDIT: g_Reg->DPC_START_REG = value; break; case IDC_DPC04_EDIT: g_Reg->DPC_END_REG = value; break; case IDC_DPC08_EDIT: g_Reg->DPC_CURRENT_REG = value; break; case IDC_DPC0C_EDIT: g_Reg->DPC_STATUS_REG = value; break; case IDC_DPC10_EDIT: g_Reg->DPC_CLOCK_REG = value; break; case IDC_DPC14_EDIT: g_Reg->DPC_BUFBUSY_REG = value; break; case IDC_DPC18_EDIT: g_Reg->DPC_PIPEBUSY_REG = value; break; case IDC_DPC1C_EDIT: g_Reg->DPC_TMEM_REG = value; break; case IDC_MI00_EDIT: g_Reg->MI_INIT_MODE_REG = value; break; // or MI_MODE ? case IDC_MI04_EDIT: g_Reg->MI_VERSION_REG = value; break; // or MI_NOOP ? case IDC_MI08_EDIT: g_Reg->MI_INTR_REG = value; break; // or MI_INTR ? case IDC_MI0C_EDIT: g_Reg->MI_INTR_MASK_REG = value; break; // or MI_INTR_MASK ? case IDC_VI00_EDIT: g_Reg->VI_STATUS_REG = value; break; case IDC_VI04_EDIT: g_Reg->VI_ORIGIN_REG = value; break; case IDC_VI08_EDIT: g_Reg->VI_WIDTH_REG = value; break; case IDC_VI0C_EDIT: g_Reg->VI_INTR_REG = value; break; case IDC_VI10_EDIT: g_Reg->VI_CURRENT_REG = value; break; case IDC_VI14_EDIT: g_Reg->VI_BURST_REG = value; break; case IDC_VI18_EDIT: g_Reg->VI_V_SYNC_REG = value; break; case IDC_VI1C_EDIT: g_Reg->VI_H_SYNC_REG = value; break; case IDC_VI20_EDIT: g_Reg->VI_LEAP_REG = value; break; case IDC_VI24_EDIT: g_Reg->VI_H_START_REG = value; break; case IDC_VI28_EDIT: g_Reg->VI_V_START_REG = value; break; case IDC_VI2C_EDIT: g_Reg->VI_V_BURST_REG = value; break; case IDC_VI30_EDIT: g_Reg->VI_X_SCALE_REG = value; break; case IDC_VI34_EDIT: g_Reg->VI_Y_SCALE_REG = value; break; case IDC_AI00_EDIT: g_Reg->AI_DRAM_ADDR_REG = value; break; case IDC_AI04_EDIT: g_Reg->AI_LEN_REG = value; break; case IDC_AI08_EDIT: g_Reg->AI_CONTROL_REG = value; break; case IDC_AI0C_EDIT: g_Reg->AI_STATUS_REG = value; break; case IDC_AI10_EDIT: g_Reg->AI_DACRATE_REG = value; break; case IDC_AI14_EDIT: g_Reg->AI_BITRATE_REG = value; break; case IDC_PI00_EDIT: g_Reg->PI_DRAM_ADDR_REG = value; break; case IDC_PI04_EDIT: g_Reg->PI_CART_ADDR_REG = value; break; case IDC_PI08_EDIT: g_Reg->PI_RD_LEN_REG = value; break; case IDC_PI0C_EDIT: g_Reg->PI_WR_LEN_REG = value; break; case IDC_PI10_EDIT: g_Reg->PI_STATUS_REG = value; break; case IDC_PI14_EDIT: g_Reg->PI_BSD_DOM1_LAT_REG = value; break; case IDC_PI18_EDIT: g_Reg->PI_BSD_DOM1_PWD_REG = value; break; case IDC_PI1C_EDIT: g_Reg->PI_BSD_DOM1_PGS_REG = value; break; case IDC_PI20_EDIT: g_Reg->PI_BSD_DOM1_RLS_REG = value; break; case IDC_PI24_EDIT: g_Reg->PI_BSD_DOM2_LAT_REG = value; break; case IDC_PI28_EDIT: g_Reg->PI_BSD_DOM2_PWD_REG = value; break; case IDC_PI2C_EDIT: g_Reg->PI_BSD_DOM2_PGS_REG = value; break; case IDC_PI30_EDIT: g_Reg->PI_BSD_DOM2_RLS_REG = value; break; case IDC_RI00_EDIT: g_Reg->RI_MODE_REG = value; break; case IDC_RI04_EDIT: g_Reg->RI_CONFIG_REG = value; break; case IDC_RI08_EDIT: g_Reg->RI_CURRENT_LOAD_REG = value; break; case IDC_RI0C_EDIT: g_Reg->RI_SELECT_REG = value; break; case IDC_RI10_EDIT: g_Reg->RI_REFRESH_REG = value; break; case IDC_RI14_EDIT: g_Reg->RI_LATENCY_REG = value; break; case IDC_RI18_EDIT: g_Reg->RI_RERROR_REG = value; break; case IDC_RI1C_EDIT: g_Reg->RI_WERROR_REG = value; break; case IDC_SI00_EDIT: g_Reg->SI_DRAM_ADDR_REG = value; break; case IDC_SI04_EDIT: g_Reg->SI_PIF_ADDR_RD64B_REG = value; break; case IDC_SI08_EDIT: g_Reg->SI_PIF_ADDR_WR64B_REG = value; break; case IDC_SI0C_EDIT: g_Reg->SI_STATUS_REG = value; break; case IDC_DD00_EDIT: g_Reg->ASIC_DATA = value; break; case IDC_DD04_EDIT: g_Reg->ASIC_MISC_REG = value; break; case IDC_DD08_EDIT: g_Reg->ASIC_STATUS = value; break; case IDC_DD0C_EDIT: g_Reg->ASIC_CUR_TK = value; break; case IDC_DD10_EDIT: g_Reg->ASIC_BM_STATUS = value; break; case IDC_DD14_EDIT: g_Reg->ASIC_ERR_SECTOR = value; break; case IDC_DD18_EDIT: g_Reg->ASIC_SEQ_STATUS = value; break; case IDC_DD1C_EDIT: g_Reg->ASIC_CUR_SECTOR = value; break; case IDC_DD20_EDIT: g_Reg->ASIC_HARD_RESET = value; break; case IDC_DD24_EDIT: g_Reg->ASIC_C1_S0 = value; break; case IDC_DD28_EDIT: g_Reg->ASIC_HOST_SECBYTE = value; break; case IDC_DD2C_EDIT: g_Reg->ASIC_C1_S2 = value; break; case IDC_DD30_EDIT: g_Reg->ASIC_SEC_BYTE = value; break; case IDC_DD34_EDIT: g_Reg->ASIC_C1_S4 = value; break; case IDC_DD38_EDIT: g_Reg->ASIC_C1_S6 = value; break; case IDC_DD3C_EDIT: g_Reg->ASIC_CUR_ADDR = value; break; case IDC_DD40_EDIT: g_Reg->ASIC_ID_REG = value; break; case IDC_DD44_EDIT: g_Reg->ASIC_TEST_REG = value; break; case IDC_DD48_EDIT: g_Reg->ASIC_TEST_PIN_SEL = value; break; } }