Changeset 35625 in vbox for trunk/src/VBox/Debugger
- Timestamp:
- Jan 19, 2011 11:17:34 AM (14 years ago)
- svn:sync-xref-src-repo-rev:
- 69526
- Location:
- trunk/src/VBox/Debugger
- Files:
-
- 7 edited
-
DBGCBuiltInSymbols.cpp (modified) (3 diffs)
-
DBGCCmdHlp.cpp (modified) (3 diffs)
-
DBGCEmulateCodeView.cpp (modified) (4 diffs)
-
DBGCInternal.h (modified) (1 diff)
-
DBGCOps.cpp (modified) (2 diffs)
-
DBGConsole.cpp (modified) (3 diffs)
-
testcase/tstDBGCStubs.cpp (modified) (2 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/Debugger/DBGCBuiltInSymbols.cpp
r35346 r35625 20 20 *******************************************************************************/ 21 21 #define LOG_GROUP LOG_GROUP_DBGC 22 #include <VBox/dbg.h>23 #include <VBox/vmm/dbgf.h>24 #include <VBox/vmm/vm.h>25 #include <VBox/vmm/vmm.h>26 #include <VBox/vmm/mm.h>27 #include <VBox/vmm/pgm.h>28 #include <VBox/vmm/selm.h>29 #include <VBox/dis.h>30 #include <VBox/param.h>31 #include <VBox/err.h>32 #include <VBox/log.h>33 34 #include <iprt/alloc.h>35 #include <iprt/alloca.h>36 #include <iprt/string.h>37 #include <iprt/assert.h>38 #include <iprt/ctype.h>39 40 #include <stdlib.h>41 #include <stdio.h>42 43 22 #include "DBGCInternal.h" 44 45 46 /*******************************************************************************47 * Internal Functions *48 *******************************************************************************/49 static DECLCALLBACK(int) dbgcSymGetReg(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, DBGCVARTYPE enmType, PDBGCVAR pResult);50 static DECLCALLBACK(int) dbgcSymSetReg(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, PCDBGCVAR pValue);51 52 53 /*******************************************************************************54 * Global Variables *55 *******************************************************************************/56 /** Register symbol uUser value.57 * @{58 */59 /** If set the register set is the hypervisor and not the guest one. */60 #define SYMREG_FLAGS_HYPER RT_BIT(20)61 /** If set a far conversion of the value will use the high 16 bit for the selector.62 * If clear the low 16 bit will be used. */63 #define SYMREG_FLAGS_HIGH_SEL RT_BIT(21)64 /** The shift value to calc the size of a register symbol from the uUser value. */65 #define SYMREG_SIZE_SHIFT (24)66 /** Get the offset */67 #define SYMREG_OFFSET(uUser) (uUser & ((1 << 20) - 1))68 /** Get the size. */69 #define SYMREG_SIZE(uUser) ((uUser >> SYMREG_SIZE_SHIFT) & 0xff)70 /** 1 byte. */71 #define SYMREG_SIZE_1 ( 1 << SYMREG_SIZE_SHIFT)72 /** 2 byte. */73 #define SYMREG_SIZE_2 ( 2 << SYMREG_SIZE_SHIFT)74 /** 4 byte. */75 #define SYMREG_SIZE_4 ( 4 << SYMREG_SIZE_SHIFT)76 /** 6 byte. */77 #define SYMREG_SIZE_6 ( 6 << SYMREG_SIZE_SHIFT)78 /** 8 byte. */79 #define SYMREG_SIZE_8 ( 8 << SYMREG_SIZE_SHIFT)80 /** 10 bytes. */81 #define SYMREG_SIZE_10 (10 << SYMREG_SIZE_SHIFT)82 /** 12 byte. */83 #define SYMREG_SIZE_12 (12 << SYMREG_SIZE_SHIFT)84 /** 16 byte. */85 #define SYMREG_SIZE_16 (16 << SYMREG_SIZE_SHIFT)86 /** @} */87 88 /** Builtin Symbols.89 * ASSUMES little endian register representation!90 */91 static const DBGCSYM g_aSyms[] =92 {93 { "rax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, rax) | SYMREG_SIZE_8 },94 { "eax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) | SYMREG_SIZE_4 },95 { "ax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) | SYMREG_SIZE_2 },96 { "al", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) | SYMREG_SIZE_1 },97 { "ah", dbgcSymGetReg, dbgcSymSetReg, (offsetof(CPUMCTX, eax) + 1)| SYMREG_SIZE_1 },98 99 { "rbx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, rbx) | SYMREG_SIZE_8 },100 { "ebx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) | SYMREG_SIZE_4 },101 { "bx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) | SYMREG_SIZE_2 },102 { "bl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) | SYMREG_SIZE_1 },103 { "bh", dbgcSymGetReg, dbgcSymSetReg, (offsetof(CPUMCTX, ebx) + 1)| SYMREG_SIZE_1 },104 105 { "rcx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_8 },106 { "ecx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_4 },107 { "cx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_2 },108 { "cl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_1 },109 { "ch", dbgcSymGetReg, dbgcSymSetReg, (offsetof(CPUMCTX, ecx) + 1)| SYMREG_SIZE_1 },110 111 { "rdx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, rdx) | SYMREG_SIZE_8 },112 { "edx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) | SYMREG_SIZE_4 },113 { "dx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) | SYMREG_SIZE_2 },114 { "dl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) | SYMREG_SIZE_1 },115 { "dh", dbgcSymGetReg, dbgcSymSetReg, (offsetof(CPUMCTX, edx) + 1)| SYMREG_SIZE_1 },116 117 { "rdi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, rdi) | SYMREG_SIZE_8 },118 { "edi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) | SYMREG_SIZE_4 },119 { "di", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) | SYMREG_SIZE_2 },120 { "dil", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) | SYMREG_SIZE_1 },121 122 { "rsi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, rsi) | SYMREG_SIZE_8 },123 { "esi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) | SYMREG_SIZE_4 },124 { "si", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) | SYMREG_SIZE_2 },125 { "sil", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) | SYMREG_SIZE_1 },126 127 { "rbp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, rbp) | SYMREG_SIZE_8 },128 { "ebp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) | SYMREG_SIZE_4 },129 { "bp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) | SYMREG_SIZE_2 },130 { "bpl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) | SYMREG_SIZE_1 },131 132 { "rsp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, rsp) | SYMREG_SIZE_8 },133 { "esp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) | SYMREG_SIZE_4 },134 { "sp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) | SYMREG_SIZE_2 },135 { "spl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) | SYMREG_SIZE_1 },136 137 { "r8", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r8) | SYMREG_SIZE_8 },138 { "r9", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r9) | SYMREG_SIZE_8 },139 { "r10", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r10) | SYMREG_SIZE_8 },140 { "r11", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r11) | SYMREG_SIZE_8 },141 { "r12", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r12) | SYMREG_SIZE_8 },142 { "r13", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r13) | SYMREG_SIZE_8 },143 { "r14", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r14) | SYMREG_SIZE_8 },144 { "r15", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r15) | SYMREG_SIZE_8 },145 146 { "r8d", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r8) | SYMREG_SIZE_4 },147 { "r9d", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r9) | SYMREG_SIZE_4 },148 { "r10d", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r10) | SYMREG_SIZE_4 },149 { "r11d", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r11) | SYMREG_SIZE_4 },150 { "r12d", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r12) | SYMREG_SIZE_4 },151 { "r13d", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r13) | SYMREG_SIZE_4 },152 { "r14d", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r14) | SYMREG_SIZE_4 },153 { "r15d", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r15) | SYMREG_SIZE_4 },154 155 { "r8w", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r8) | SYMREG_SIZE_2 },156 { "r9w", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r9) | SYMREG_SIZE_2 },157 { "r10w", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r10) | SYMREG_SIZE_2 },158 { "r11w", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r11) | SYMREG_SIZE_2 },159 { "r12w", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r12) | SYMREG_SIZE_2 },160 { "r13w", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r13) | SYMREG_SIZE_2 },161 { "r14w", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r14) | SYMREG_SIZE_2 },162 { "r15w", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r15) | SYMREG_SIZE_2 },163 164 { "r8b", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r8) | SYMREG_SIZE_1 },165 { "r9b", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r9) | SYMREG_SIZE_1 },166 { "r10b", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r10) | SYMREG_SIZE_1 },167 { "r11b", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r11) | SYMREG_SIZE_1 },168 { "r12b", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r12) | SYMREG_SIZE_1 },169 { "r13b", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r13) | SYMREG_SIZE_1 },170 { "r14b", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r14) | SYMREG_SIZE_1 },171 { "r15b", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, r15) | SYMREG_SIZE_1 },172 173 { "rip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, rip) | SYMREG_SIZE_8 },174 { "eip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eip) | SYMREG_SIZE_4 },175 { "ip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eip) | SYMREG_SIZE_2 },176 177 { "rfl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, rflags) | SYMREG_SIZE_8 },178 { "rflags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, rflags) | SYMREG_SIZE_8 },179 { "efl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_4 },180 { "eflags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_4 },181 { "fl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_2 },182 { "flags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_2 },183 184 { "cs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cs) | SYMREG_SIZE_2 },185 { "ds", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ds) | SYMREG_SIZE_2 },186 { "es", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, es) | SYMREG_SIZE_2 },187 { "fs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, fs) | SYMREG_SIZE_2 },188 { "gs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gs) | SYMREG_SIZE_2 },189 { "ss", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ss) | SYMREG_SIZE_2 },190 191 { "cr0", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr0) | SYMREG_SIZE_8 },192 { "cr2", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr2) | SYMREG_SIZE_8 },193 { "cr3", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr3) | SYMREG_SIZE_8 },194 { "cr4", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr4) | SYMREG_SIZE_8 },195 196 { "tr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, tr) | SYMREG_SIZE_2 },197 { "ldtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ldtr) | SYMREG_SIZE_2 },198 199 { "gdtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr) | SYMREG_SIZE_10 },200 { "gdtr.limit", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr.cbGdt)| SYMREG_SIZE_2 },201 { "gdtr.base", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr.pGdt)| SYMREG_SIZE_8 },202 203 { "idtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr) | SYMREG_SIZE_10 },204 { "idtr.limit", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr.cbIdt)| SYMREG_SIZE_2 },205 { "idtr.base", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr.pIdt)| SYMREG_SIZE_8 },206 207 /* hypervisor */208 209 {".eax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },210 {".ax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },211 {".al", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) | SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },212 {".ah", dbgcSymGetReg, dbgcSymSetReg, (offsetof(CPUMCTX, eax) + 1)| SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },213 214 {".ebx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },215 {".bx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },216 {".bl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) | SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },217 {".bh", dbgcSymGetReg, dbgcSymSetReg, (offsetof(CPUMCTX, ebx) + 1)| SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },218 219 {".ecx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },220 {".cx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },221 {".cl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },222 {".ch", dbgcSymGetReg, dbgcSymSetReg, (offsetof(CPUMCTX, ecx) + 1)| SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },223 224 {".edx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },225 {".dx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },226 {".dl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) | SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },227 {".dh", dbgcSymGetReg, dbgcSymSetReg, (offsetof(CPUMCTX, edx) + 1)| SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },228 229 {".edi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },230 {".di", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },231 232 {".esi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },233 {".si", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },234 235 {".ebp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },236 {".bp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },237 238 {".esp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },239 {".sp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },240 241 {".eip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eip) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },242 {".ip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eip) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },243 244 {".efl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },245 {".eflags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },246 {".fl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },247 {".flags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },248 249 {".cs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cs) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },250 {".ds", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ds) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },251 {".es", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, es) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },252 {".fs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, fs) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },253 {".gs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gs) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },254 {".ss", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ss) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },255 256 {".cr0", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr0) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },257 {".cr2", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr2) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },258 {".cr3", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr3) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },259 {".cr4", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr4) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },260 261 {".tr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, tr) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },262 {".ldtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ldtr) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },263 264 {".gdtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr) | SYMREG_SIZE_10 | SYMREG_FLAGS_HYPER },265 {".gdtr.limit", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr.cbGdt)| SYMREG_SIZE_2| SYMREG_FLAGS_HYPER },266 {".gdtr.base", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr.pGdt)| SYMREG_SIZE_8 | SYMREG_FLAGS_HYPER },267 268 {".idtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr) | SYMREG_SIZE_10 | SYMREG_FLAGS_HYPER },269 {".idtr.limit", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr.cbIdt)| SYMREG_SIZE_2| SYMREG_FLAGS_HYPER },270 {".idtr.base", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr.pIdt)| SYMREG_SIZE_8 | SYMREG_FLAGS_HYPER },271 272 };273 23 274 24 275 25 276 26 /** 277 * Get builtin registersymbol.27 * Finds a builtin symbol. 278 28 * 279 * The uUser is special for these symbol descriptors. See the SYMREG_* \#defines.280 *281 * @returns 0 on success.282 * @returns VBox evaluation / parsing error code on failure.283 * The caller does the bitching.284 * @param pSymDesc Pointer to the symbol descriptor.285 * @param pCmdHlp Pointer to the command callback structure.286 * @param enmType The result type.287 * @param pResult Where to store the result.288 */289 static DECLCALLBACK(int) dbgcSymGetReg(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, DBGCVARTYPE enmType, PDBGCVAR pResult)290 {291 LogFlow(("dbgcSymSetReg: pSymDesc->pszName=%d\n", pSymDesc->pszName));292 293 /*294 * pVM is required.295 */296 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);297 Assert(pDbgc->pVM);298 299 /*300 * Get the right CPU context.301 */302 PVMCPU pVCpu = VMMGetCpuById(pDbgc->pVM, pDbgc->idCpu);303 PCPUMCTX pCtx;304 int rc;305 if (!(pSymDesc->uUser & SYMREG_FLAGS_HYPER))306 {307 pCtx = CPUMQueryGuestCtxPtr(pVCpu);308 rc = VINF_SUCCESS;309 }310 else311 rc = CPUMQueryHyperCtxPtr(pVCpu, &pCtx);312 if (RT_FAILURE(rc))313 return rc;314 315 /*316 * Get the value.317 */318 void *pvValue = (char *)pCtx + SYMREG_OFFSET(pSymDesc->uUser);319 uint64_t u64;320 switch (SYMREG_SIZE(pSymDesc->uUser))321 {322 case 1: u64 = *(uint8_t *)pvValue; break;323 case 2: u64 = *(uint16_t *)pvValue; break;324 case 4: u64 = *(uint32_t *)pvValue; break;325 case 6: u64 = *(uint32_t *)pvValue | ((uint64_t)*(uint16_t *)((char *)pvValue + sizeof(uint32_t)) << 32); break;326 case 8: u64 = *(uint64_t *)pvValue; break;327 default:328 return VERR_PARSE_NOT_IMPLEMENTED;329 }330 331 /*332 * Construct the desired result.333 */334 if (enmType == DBGCVAR_TYPE_ANY)335 enmType = DBGCVAR_TYPE_NUMBER;336 pResult->pDesc = NULL;337 pResult->pNext = NULL;338 pResult->enmType = enmType;339 pResult->enmRangeType = DBGCVAR_RANGE_NONE;340 pResult->u64Range = 0;341 342 switch (enmType)343 {344 case DBGCVAR_TYPE_GC_FLAT:345 pResult->u.GCFlat = (RTGCPTR)u64;346 break;347 348 case DBGCVAR_TYPE_GC_FAR:349 switch (SYMREG_SIZE(pSymDesc->uUser))350 {351 case 4:352 if (!(pSymDesc->uUser & SYMREG_FLAGS_HIGH_SEL))353 {354 pResult->u.GCFar.off = (uint16_t)u64;355 pResult->u.GCFar.sel = (uint16_t)(u64 >> 16);356 }357 else358 {359 pResult->u.GCFar.sel = (uint16_t)u64;360 pResult->u.GCFar.off = (uint16_t)(u64 >> 16);361 }362 break;363 case 6:364 if (!(pSymDesc->uUser & SYMREG_FLAGS_HIGH_SEL))365 {366 pResult->u.GCFar.off = (uint32_t)u64;367 pResult->u.GCFar.sel = (uint16_t)(u64 >> 32);368 }369 else370 {371 pResult->u.GCFar.sel = (uint32_t)u64;372 pResult->u.GCFar.off = (uint16_t)(u64 >> 32);373 }374 break;375 376 default:377 return VERR_PARSE_BAD_RESULT_TYPE;378 }379 break;380 381 case DBGCVAR_TYPE_GC_PHYS:382 pResult->u.GCPhys = (RTGCPHYS)u64;383 break;384 385 case DBGCVAR_TYPE_HC_FLAT:386 pResult->u.pvHCFlat = (void *)(uintptr_t)u64;387 break;388 389 case DBGCVAR_TYPE_HC_FAR:390 switch (SYMREG_SIZE(pSymDesc->uUser))391 {392 case 4:393 if (!(pSymDesc->uUser & SYMREG_FLAGS_HIGH_SEL))394 {395 pResult->u.HCFar.off = (uint16_t)u64;396 pResult->u.HCFar.sel = (uint16_t)(u64 >> 16);397 }398 else399 {400 pResult->u.HCFar.sel = (uint16_t)u64;401 pResult->u.HCFar.off = (uint16_t)(u64 >> 16);402 }403 break;404 case 6:405 if (!(pSymDesc->uUser & SYMREG_FLAGS_HIGH_SEL))406 {407 pResult->u.HCFar.off = (uint32_t)u64;408 pResult->u.HCFar.sel = (uint16_t)(u64 >> 32);409 }410 else411 {412 pResult->u.HCFar.sel = (uint32_t)u64;413 pResult->u.HCFar.off = (uint16_t)(u64 >> 32);414 }415 break;416 417 default:418 return VERR_PARSE_BAD_RESULT_TYPE;419 }420 break;421 422 case DBGCVAR_TYPE_HC_PHYS:423 pResult->u.GCPhys = (RTGCPHYS)u64;424 break;425 426 case DBGCVAR_TYPE_NUMBER:427 pResult->u.u64Number = u64;428 break;429 430 case DBGCVAR_TYPE_STRING:431 case DBGCVAR_TYPE_UNKNOWN:432 default:433 return VERR_PARSE_BAD_RESULT_TYPE;434 435 }436 437 return 0;438 }439 440 441 /**442 * Set builtin register symbol.443 *444 * The uUser is special for these symbol descriptors. See the SYMREG_* #defines.445 *446 * @returns 0 on success.447 * @returns VBox evaluation / parsing error code on failure.448 * The caller does the bitching.449 * @param pSymDesc Pointer to the symbol descriptor.450 * @param pCmdHlp Pointer to the command callback structure.451 * @param pValue The value to assign the symbol.452 */453 static DECLCALLBACK(int) dbgcSymSetReg(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, PCDBGCVAR pValue)454 {455 LogFlow(("dbgcSymSetReg: pSymDesc->pszName=%d\n", pSymDesc->pszName));456 457 /*458 * pVM is required.459 */460 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);461 Assert(pDbgc->pVM);462 463 /*464 * Get the right CPU context.465 */466 PVMCPU pVCpu = VMMGetCpuById(pDbgc->pVM, pDbgc->idCpu);467 PCPUMCTX pCtx;468 int rc;469 if (!(pSymDesc->uUser & SYMREG_FLAGS_HYPER))470 {471 pCtx = CPUMQueryGuestCtxPtr(pVCpu);472 rc = VINF_SUCCESS;473 }474 else475 rc = CPUMQueryHyperCtxPtr(pVCpu, &pCtx);476 if (RT_FAILURE(rc))477 return rc;478 479 /*480 * Check the new value.481 */482 if (pValue->enmType != DBGCVAR_TYPE_NUMBER)483 return VERR_PARSE_ARGUMENT_TYPE_MISMATCH;484 485 /*486 * Set the value.487 */488 void *pvValue = (char *)pCtx + SYMREG_OFFSET(pSymDesc->uUser);489 switch (SYMREG_SIZE(pSymDesc->uUser))490 {491 case 1:492 *(uint8_t *)pvValue = (uint8_t)pValue->u.u64Number;493 break;494 case 2:495 *(uint16_t *)pvValue = (uint16_t)pValue->u.u64Number;496 break;497 case 4:498 *(uint32_t *)pvValue = (uint32_t)pValue->u.u64Number;499 break;500 case 6:501 *(uint32_t *)pvValue = (uint32_t)pValue->u.u64Number;502 ((uint16_t *)pvValue)[3] = (uint16_t)(pValue->u.u64Number >> 32);503 break;504 case 8:505 *(uint64_t *)pvValue = pValue->u.u64Number;506 break;507 default:508 return VERR_PARSE_NOT_IMPLEMENTED;509 }510 511 return VINF_SUCCESS;512 }513 514 515 /**516 * Finds a builtin symbol.517 29 * @returns Pointer to symbol descriptor on success. 518 30 * @returns NULL on failure. … … 522 34 PCDBGCSYM dbgcLookupRegisterSymbol(PDBGC pDbgc, const char *pszSymbol) 523 35 { 524 for (unsigned iSym = 0; iSym < RT_ELEMENTS(g_aSyms); iSym++)525 if (!strcmp(pszSymbol, g_aSyms[iSym].pszName))526 return &g_aSyms[iSym];527 528 36 /** @todo externally registered symbols. */ 529 37 NOREF(pDbgc); … … 531 39 } 532 40 41 -
trunk/src/VBox/Debugger/DBGCCmdHlp.cpp
r35346 r35625 729 729 730 730 /** 731 * Converts a DBGC variable to a number. 732 * 733 * @returns VBox status code. 734 * @param pCmdHlp Pointer to the command callback structure. 735 * @param pVar The variable to convert. 736 * @param pu64Number Where to store the number value. 737 */ 738 static DECLCALLBACK(int) dbgcHlpVarToNumber(PDBGCCMDHLP pCmdHlp, PCDBGCVAR pVar, uint64_t *pu64Number) 739 { 740 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp); 741 NOREF(pDbgc); 742 743 uint64_t u64Number; 744 switch (pVar->enmType) 745 { 746 case DBGCVAR_TYPE_GC_FLAT: 747 u64Number = pVar->u.GCFlat; 748 break; 749 case DBGCVAR_TYPE_GC_PHYS: 750 u64Number = pVar->u.GCPhys; 751 break; 752 case DBGCVAR_TYPE_HC_FLAT: 753 u64Number = (uintptr_t)pVar->u.pvHCFlat; 754 break; 755 case DBGCVAR_TYPE_HC_PHYS: 756 u64Number = (uintptr_t)pVar->u.HCPhys; 757 break; 758 case DBGCVAR_TYPE_NUMBER: 759 u64Number = (uintptr_t)pVar->u.u64Number; 760 return VINF_SUCCESS; 761 case DBGCVAR_TYPE_HC_FAR: 762 u64Number = (uintptr_t)pVar->u.HCFar.off; 763 break; 764 case DBGCVAR_TYPE_GC_FAR: 765 u64Number = (uintptr_t)pVar->u.GCFar.off; 766 break; 767 case DBGCVAR_TYPE_SYMBOL: 768 case DBGCVAR_TYPE_STRING: 769 return VERR_PARSE_INCORRECT_ARG_TYPE; /** @todo better error code! */ 770 default: 771 return VERR_PARSE_INCORRECT_ARG_TYPE; 772 } 773 *pu64Number = u64Number; 774 return VINF_SUCCESS; 775 } 776 777 778 /** 731 779 * Converts a DBGC variable to a boolean. 732 780 * … … 816 864 817 865 /** 866 * @interface_method_impl{DBGCCMDHLP,pfnVarConvert} 867 */ 868 static DECLCALLBACK(int) dbgcHlpVarConvert(PDBGCCMDHLP pCmdHlp, PCDBGCVAR pInVar, DBGCVARTYPE enmToType, bool fConvSyms, 869 PDBGCVAR pResult) 870 { 871 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp); 872 DBGCVAR const InVar = *pInVar; /* if pInVar == pResult */ 873 PCDBGCVAR pArg = &InVar; /* lazy bird, clean up later */ 874 DBGFADDRESS Address; 875 int rc; 876 877 Assert(pDbgc->pVM); 878 879 *pResult = InVar; 880 switch (InVar.enmType) 881 { 882 case DBGCVAR_TYPE_GC_FLAT: 883 switch (enmToType) 884 { 885 case DBGCVAR_TYPE_GC_FLAT: 886 return VINF_SUCCESS; 887 888 case DBGCVAR_TYPE_GC_FAR: 889 return VERR_PARSE_INCORRECT_ARG_TYPE; 890 891 case DBGCVAR_TYPE_GC_PHYS: 892 pResult->enmType = DBGCVAR_TYPE_GC_PHYS; 893 rc = DBGFR3AddrToPhys(pDbgc->pVM, pDbgc->idCpu, 894 DBGFR3AddrFromFlat(pDbgc->pVM, &Address, pArg->u.GCFlat), 895 &pResult->u.GCPhys); 896 if (RT_SUCCESS(rc)) 897 return VINF_SUCCESS; 898 return VERR_PARSE_CONVERSION_FAILED; 899 900 case DBGCVAR_TYPE_HC_FLAT: 901 pResult->enmType = DBGCVAR_TYPE_HC_FLAT; 902 rc = DBGFR3AddrToVolatileR3Ptr(pDbgc->pVM, pDbgc->idCpu, 903 DBGFR3AddrFromFlat(pDbgc->pVM, &Address, pArg->u.GCFlat), 904 false /*fReadOnly */, 905 &pResult->u.pvHCFlat); 906 if (RT_SUCCESS(rc)) 907 return VINF_SUCCESS; 908 return VERR_PARSE_CONVERSION_FAILED; 909 910 case DBGCVAR_TYPE_HC_FAR: 911 return VERR_INVALID_PARAMETER; 912 913 case DBGCVAR_TYPE_HC_PHYS: 914 pResult->enmType = DBGCVAR_TYPE_HC_PHYS; 915 rc = DBGFR3AddrToHostPhys(pDbgc->pVM, pDbgc->idCpu, 916 DBGFR3AddrFromFlat(pDbgc->pVM, &Address, pArg->u.GCFlat), 917 &pResult->u.GCPhys); 918 if (RT_SUCCESS(rc)) 919 return VINF_SUCCESS; 920 return VERR_PARSE_CONVERSION_FAILED; 921 922 case DBGCVAR_TYPE_NUMBER: 923 pResult->enmType = enmToType; 924 pResult->u.u64Number = InVar.u.GCFlat; 925 return VINF_SUCCESS; 926 927 case DBGCVAR_TYPE_STRING: 928 case DBGCVAR_TYPE_SYMBOL: 929 return VERR_PARSE_INCORRECT_ARG_TYPE; 930 931 case DBGCVAR_TYPE_UNKNOWN: 932 case DBGCVAR_TYPE_ANY: 933 break; 934 } 935 break; 936 937 case DBGCVAR_TYPE_GC_FAR: 938 switch (enmToType) 939 { 940 case DBGCVAR_TYPE_GC_FLAT: 941 rc = DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off); 942 if (RT_SUCCESS(rc)) 943 { 944 pResult->enmType = DBGCVAR_TYPE_GC_FLAT; 945 pResult->u.GCFlat = Address.FlatPtr; 946 return VINF_SUCCESS; 947 } 948 return VERR_PARSE_CONVERSION_FAILED; 949 950 case DBGCVAR_TYPE_GC_FAR: 951 return VINF_SUCCESS; 952 953 case DBGCVAR_TYPE_GC_PHYS: 954 rc = DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off); 955 if (RT_SUCCESS(rc)) 956 { 957 pResult->enmType = DBGCVAR_TYPE_GC_PHYS; 958 rc = DBGFR3AddrToPhys(pDbgc->pVM, pDbgc->idCpu, &Address, &pResult->u.GCPhys); 959 if (RT_SUCCESS(rc)) 960 return VINF_SUCCESS; 961 } 962 return VERR_PARSE_CONVERSION_FAILED; 963 964 case DBGCVAR_TYPE_HC_FLAT: 965 rc = DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off); 966 if (RT_SUCCESS(rc)) 967 { 968 pResult->enmType = DBGCVAR_TYPE_HC_FLAT; 969 rc = DBGFR3AddrToVolatileR3Ptr(pDbgc->pVM, pDbgc->idCpu, &Address, 970 false /*fReadOnly*/, &pResult->u.pvHCFlat); 971 if (RT_SUCCESS(rc)) 972 return VINF_SUCCESS; 973 } 974 return VERR_PARSE_CONVERSION_FAILED; 975 976 case DBGCVAR_TYPE_HC_FAR: 977 return VERR_PARSE_INCORRECT_ARG_TYPE; 978 979 case DBGCVAR_TYPE_HC_PHYS: 980 rc = DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off); 981 if (RT_SUCCESS(rc)) 982 { 983 pResult->enmType = DBGCVAR_TYPE_HC_PHYS; 984 rc = DBGFR3AddrToHostPhys(pDbgc->pVM, pDbgc->idCpu, &Address, &pResult->u.GCPhys); 985 if (RT_SUCCESS(rc)) 986 return VINF_SUCCESS; 987 } 988 return VERR_PARSE_CONVERSION_FAILED; 989 990 case DBGCVAR_TYPE_NUMBER: 991 pResult->enmType = enmToType; 992 pResult->u.u64Number = InVar.u.GCFar.off; 993 return VINF_SUCCESS; 994 995 case DBGCVAR_TYPE_STRING: 996 case DBGCVAR_TYPE_SYMBOL: 997 return VERR_PARSE_INCORRECT_ARG_TYPE; 998 999 case DBGCVAR_TYPE_UNKNOWN: 1000 case DBGCVAR_TYPE_ANY: 1001 break; 1002 } 1003 break; 1004 1005 case DBGCVAR_TYPE_GC_PHYS: 1006 switch (enmToType) 1007 { 1008 case DBGCVAR_TYPE_GC_FLAT: 1009 //rc = MMR3PhysGCPhys2GCVirtEx(pDbgc->pVM, pResult->u.GCPhys, ..., &pResult->u.GCFlat); - yea, sure. 1010 return VERR_PARSE_INCORRECT_ARG_TYPE; 1011 1012 case DBGCVAR_TYPE_GC_FAR: 1013 return VERR_PARSE_INCORRECT_ARG_TYPE; 1014 1015 case DBGCVAR_TYPE_GC_PHYS: 1016 return VINF_SUCCESS; 1017 1018 case DBGCVAR_TYPE_HC_FLAT: 1019 pResult->enmType = DBGCVAR_TYPE_HC_FLAT; 1020 rc = DBGFR3AddrToVolatileR3Ptr(pDbgc->pVM, pDbgc->idCpu, 1021 DBGFR3AddrFromPhys(pDbgc->pVM, &Address, pArg->u.GCPhys), 1022 false /*fReadOnly */, 1023 &pResult->u.pvHCFlat); 1024 if (RT_SUCCESS(rc)) 1025 return VINF_SUCCESS; 1026 return VERR_PARSE_CONVERSION_FAILED; 1027 1028 case DBGCVAR_TYPE_HC_FAR: 1029 return VERR_PARSE_INCORRECT_ARG_TYPE; 1030 1031 case DBGCVAR_TYPE_HC_PHYS: 1032 pResult->enmType = DBGCVAR_TYPE_HC_PHYS; 1033 rc = DBGFR3AddrToHostPhys(pDbgc->pVM, pDbgc->idCpu, 1034 DBGFR3AddrFromPhys(pDbgc->pVM, &Address, pArg->u.GCPhys), 1035 &pResult->u.HCPhys); 1036 if (RT_SUCCESS(rc)) 1037 return VINF_SUCCESS; 1038 return VERR_PARSE_CONVERSION_FAILED; 1039 1040 case DBGCVAR_TYPE_NUMBER: 1041 pResult->enmType = enmToType; 1042 pResult->u.u64Number = InVar.u.GCPhys; 1043 return VINF_SUCCESS; 1044 1045 case DBGCVAR_TYPE_STRING: 1046 case DBGCVAR_TYPE_SYMBOL: 1047 return VERR_PARSE_INCORRECT_ARG_TYPE; 1048 1049 case DBGCVAR_TYPE_UNKNOWN: 1050 case DBGCVAR_TYPE_ANY: 1051 break; 1052 } 1053 break; 1054 1055 case DBGCVAR_TYPE_HC_FLAT: 1056 switch (enmToType) 1057 { 1058 case DBGCVAR_TYPE_GC_FLAT: 1059 return VERR_PARSE_INCORRECT_ARG_TYPE; 1060 1061 case DBGCVAR_TYPE_GC_FAR: 1062 return VERR_PARSE_INCORRECT_ARG_TYPE; 1063 1064 case DBGCVAR_TYPE_GC_PHYS: 1065 pResult->enmType = DBGCVAR_TYPE_GC_PHYS; 1066 rc = PGMR3DbgR3Ptr2GCPhys(pDbgc->pVM, pArg->u.pvHCFlat, &pResult->u.GCPhys); 1067 if (RT_SUCCESS(rc)) 1068 return VINF_SUCCESS; 1069 /** @todo more memory types! */ 1070 return VERR_PARSE_CONVERSION_FAILED; 1071 1072 case DBGCVAR_TYPE_HC_FLAT: 1073 return VINF_SUCCESS; 1074 1075 case DBGCVAR_TYPE_HC_FAR: 1076 return VERR_PARSE_INCORRECT_ARG_TYPE; 1077 1078 case DBGCVAR_TYPE_HC_PHYS: 1079 pResult->enmType = DBGCVAR_TYPE_HC_PHYS; 1080 rc = PGMR3DbgR3Ptr2HCPhys(pDbgc->pVM, pArg->u.pvHCFlat, &pResult->u.HCPhys); 1081 if (RT_SUCCESS(rc)) 1082 return VINF_SUCCESS; 1083 /** @todo more memory types! */ 1084 return VERR_PARSE_CONVERSION_FAILED; 1085 1086 case DBGCVAR_TYPE_NUMBER: 1087 pResult->enmType = enmToType; 1088 pResult->u.u64Number = (uintptr_t)InVar.u.pvHCFlat; 1089 return VINF_SUCCESS; 1090 1091 case DBGCVAR_TYPE_STRING: 1092 case DBGCVAR_TYPE_SYMBOL: 1093 return VERR_PARSE_INCORRECT_ARG_TYPE; 1094 1095 case DBGCVAR_TYPE_UNKNOWN: 1096 case DBGCVAR_TYPE_ANY: 1097 break; 1098 } 1099 break; 1100 1101 case DBGCVAR_TYPE_HC_FAR: 1102 switch (enmToType) 1103 { 1104 case DBGCVAR_TYPE_GC_FLAT: 1105 return VERR_PARSE_INCORRECT_ARG_TYPE; 1106 1107 case DBGCVAR_TYPE_GC_FAR: 1108 return VERR_PARSE_INCORRECT_ARG_TYPE; 1109 1110 case DBGCVAR_TYPE_GC_PHYS: 1111 return VERR_PARSE_INCORRECT_ARG_TYPE; 1112 1113 case DBGCVAR_TYPE_HC_FLAT: 1114 return VERR_PARSE_INCORRECT_ARG_TYPE; 1115 1116 case DBGCVAR_TYPE_HC_FAR: 1117 return VINF_SUCCESS; 1118 1119 case DBGCVAR_TYPE_HC_PHYS: 1120 return VERR_PARSE_INCORRECT_ARG_TYPE; 1121 1122 case DBGCVAR_TYPE_NUMBER: 1123 pResult->enmType = enmToType; 1124 pResult->u.u64Number = (uintptr_t)InVar.u.HCFar.off; 1125 return VINF_SUCCESS; 1126 1127 case DBGCVAR_TYPE_STRING: 1128 case DBGCVAR_TYPE_SYMBOL: 1129 return VERR_PARSE_INCORRECT_ARG_TYPE; 1130 1131 case DBGCVAR_TYPE_UNKNOWN: 1132 case DBGCVAR_TYPE_ANY: 1133 break; 1134 } 1135 break; 1136 1137 case DBGCVAR_TYPE_HC_PHYS: 1138 switch (enmToType) 1139 { 1140 case DBGCVAR_TYPE_GC_FLAT: 1141 return VERR_PARSE_INCORRECT_ARG_TYPE; 1142 1143 case DBGCVAR_TYPE_GC_FAR: 1144 return VERR_PARSE_INCORRECT_ARG_TYPE; 1145 1146 case DBGCVAR_TYPE_GC_PHYS: 1147 pResult->enmType = DBGCVAR_TYPE_GC_PHYS; 1148 rc = PGMR3DbgHCPhys2GCPhys(pDbgc->pVM, pArg->u.HCPhys, &pResult->u.GCPhys); 1149 if (RT_SUCCESS(rc)) 1150 return VINF_SUCCESS; 1151 return VERR_PARSE_CONVERSION_FAILED; 1152 1153 case DBGCVAR_TYPE_HC_FLAT: 1154 return VERR_PARSE_INCORRECT_ARG_TYPE; 1155 1156 case DBGCVAR_TYPE_HC_FAR: 1157 return VERR_PARSE_INCORRECT_ARG_TYPE; 1158 1159 case DBGCVAR_TYPE_HC_PHYS: 1160 return VINF_SUCCESS; 1161 1162 case DBGCVAR_TYPE_NUMBER: 1163 pResult->enmType = enmToType; 1164 pResult->u.u64Number = InVar.u.HCPhys; 1165 return VINF_SUCCESS; 1166 1167 case DBGCVAR_TYPE_STRING: 1168 case DBGCVAR_TYPE_SYMBOL: 1169 return VERR_PARSE_INCORRECT_ARG_TYPE; 1170 1171 case DBGCVAR_TYPE_UNKNOWN: 1172 case DBGCVAR_TYPE_ANY: 1173 break; 1174 } 1175 break; 1176 1177 case DBGCVAR_TYPE_NUMBER: 1178 switch (enmToType) 1179 { 1180 case DBGCVAR_TYPE_GC_FLAT: 1181 pResult->enmType = DBGCVAR_TYPE_GC_FLAT; 1182 pResult->u.GCFlat = (RTGCPTR)InVar.u.u64Number; 1183 return VERR_PARSE_INCORRECT_ARG_TYPE; 1184 1185 case DBGCVAR_TYPE_GC_FAR: 1186 return VERR_PARSE_INCORRECT_ARG_TYPE; 1187 1188 case DBGCVAR_TYPE_GC_PHYS: 1189 pResult->enmType = DBGCVAR_TYPE_GC_PHYS; 1190 pResult->u.GCPhys = (RTGCPHYS)InVar.u.u64Number; 1191 return VERR_PARSE_INCORRECT_ARG_TYPE; 1192 1193 case DBGCVAR_TYPE_HC_FLAT: 1194 pResult->enmType = DBGCVAR_TYPE_HC_FLAT; 1195 pResult->u.pvHCFlat = (void *)(uintptr_t)InVar.u.u64Number; 1196 return VERR_PARSE_INCORRECT_ARG_TYPE; 1197 1198 case DBGCVAR_TYPE_HC_FAR: 1199 return VERR_PARSE_INCORRECT_ARG_TYPE; 1200 1201 case DBGCVAR_TYPE_HC_PHYS: 1202 pResult->enmType = DBGCVAR_TYPE_HC_PHYS; 1203 pResult->u.HCPhys = (RTHCPHYS)InVar.u.u64Number; 1204 return VINF_SUCCESS; 1205 1206 case DBGCVAR_TYPE_NUMBER: 1207 return VINF_SUCCESS; 1208 1209 case DBGCVAR_TYPE_STRING: 1210 case DBGCVAR_TYPE_SYMBOL: 1211 return VERR_PARSE_INCORRECT_ARG_TYPE; 1212 1213 case DBGCVAR_TYPE_UNKNOWN: 1214 case DBGCVAR_TYPE_ANY: 1215 break; 1216 } 1217 break; 1218 1219 case DBGCVAR_TYPE_SYMBOL: 1220 case DBGCVAR_TYPE_STRING: 1221 switch (enmToType) 1222 { 1223 case DBGCVAR_TYPE_GC_FLAT: 1224 case DBGCVAR_TYPE_GC_FAR: 1225 case DBGCVAR_TYPE_GC_PHYS: 1226 case DBGCVAR_TYPE_HC_FLAT: 1227 case DBGCVAR_TYPE_HC_FAR: 1228 case DBGCVAR_TYPE_HC_PHYS: 1229 case DBGCVAR_TYPE_NUMBER: 1230 if (fConvSyms) 1231 return dbgcSymbolGet(pDbgc, InVar.u.pszString, enmToType, pResult); 1232 return VERR_PARSE_INCORRECT_ARG_TYPE; 1233 1234 case DBGCVAR_TYPE_STRING: 1235 case DBGCVAR_TYPE_SYMBOL: 1236 pResult->enmType = enmToType; 1237 return VINF_SUCCESS; 1238 1239 case DBGCVAR_TYPE_UNKNOWN: 1240 case DBGCVAR_TYPE_ANY: 1241 break; 1242 } 1243 break; 1244 1245 case DBGCVAR_TYPE_UNKNOWN: 1246 case DBGCVAR_TYPE_ANY: 1247 break; 1248 } 1249 1250 AssertMsgFailed(("f=%d t=%d\n", InVar.enmType, enmToType)); 1251 return VERR_INVALID_PARAMETER; 1252 } 1253 1254 1255 /** 818 1256 * Info helper callback wrapper - print formatted string. 819 1257 * … … 882 1320 pDbgc->CmdHlp.pfnFailV = dbgcHlpFailV; 883 1321 pDbgc->CmdHlp.pfnVarToDbgfAddr = dbgcHlpVarToDbgfAddr; 1322 pDbgc->CmdHlp.pfnVarToNumber = dbgcHlpVarToNumber; 884 1323 pDbgc->CmdHlp.pfnVarToBool = dbgcHlpVarToBool; 885 1324 pDbgc->CmdHlp.pfnVarGetRange = dbgcHlpVarGetRange; 1325 pDbgc->CmdHlp.pfnVarConvert = dbgcHlpVarConvert; 886 1326 pDbgc->CmdHlp.pfnGetDbgfOutputHlp = dbgcHlpGetDbgfOutputHlp; 887 1327 } -
trunk/src/VBox/Debugger/DBGCEmulateCodeView.cpp
r35614 r35625 1340 1340 { 1341 1341 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp); 1342 1343 Assert(cArgs != 0); /* handled by caller */ 1344 1345 /* 1346 * cArgs == 1: Show the register. 1347 * cArgs == 2: Modify the register. 1348 */ 1349 if ( cArgs == 1 1350 || cArgs == 2) 1351 { 1352 /* locate the register symbol. */ 1353 const char *pszReg = paArgs[0].u.pszString; 1354 if ( *pszPrefix 1355 && pszReg[0] != *pszPrefix) 1356 { 1357 /* prepend the prefix. */ 1358 char *psz = (char *)alloca(strlen(pszReg) + 2); 1359 psz[0] = *pszPrefix; 1360 strcpy(psz + 1, paArgs[0].u.pszString); 1361 pszReg = psz; 1362 } 1363 PCDBGCSYM pSym = dbgcLookupRegisterSymbol(pDbgc, pszReg); 1364 if (!pSym) 1365 return pCmdHlp->pfnVBoxError(pCmdHlp, VERR_INVALID_PARAMETER /* VERR_DBGC_INVALID_REGISTER */, "Invalid register name '%s'.\n", pszReg); 1366 1367 /* show the register */ 1368 if (cArgs == 1) 1369 { 1370 DBGCVAR Var; 1371 memset(&Var, 0, sizeof(Var)); 1372 int rc = pSym->pfnGet(pSym, pCmdHlp, DBGCVAR_TYPE_NUMBER, &Var); 1342 Assert(cArgs == 1 || cArgs == 2); /* cArgs == 0 is handled by the caller */ 1343 if ( paArgs[0].enmType != DBGCVAR_TYPE_STRING 1344 && paArgs[0].enmType != DBGCVAR_TYPE_SYMBOL) 1345 return DBGCCmdHlpPrintf(pCmdHlp, "internal error: The parser doesn't do its job properly yet.. Try drop the '@' or/and quote the register name\n"); 1346 1347 /* 1348 * Parse the register name and kind. 1349 */ 1350 const char *pszReg = paArgs[0].u.pszString; 1351 if (*pszReg == '@') 1352 pszReg++; 1353 VMCPUID idCpu = pDbgc->idCpu; 1354 if (*pszPrefix) 1355 idCpu |= DBGFREG_HYPER_VMCPUID; 1356 if (*pszReg == '.') 1357 { 1358 pszReg++; 1359 idCpu |= DBGFREG_HYPER_VMCPUID; 1360 } 1361 const char * const pszActualPrefix = idCpu & DBGFREG_HYPER_VMCPUID ? "." : ""; 1362 1363 /* 1364 * Query the register type & value (the setter needs the type). 1365 */ 1366 DBGFREGVALTYPE enmType; 1367 DBGFREGVAL Value; 1368 int rc = DBGFR3RegNmQuery(pVM, idCpu, pszReg, &Value, &enmType); 1369 if (RT_FAILURE(rc)) 1370 { 1371 if (rc == VERR_DBGF_REGISTER_NOT_FOUND) 1372 return DBGCCmdHlpVBoxError(pCmdHlp, VERR_INVALID_PARAMETER, "Unknown register: '%s%s'.\n", 1373 pszActualPrefix, pszReg); 1374 return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3RegNmQuery failed querying '%s%s': %Rrc.\n", 1375 pszActualPrefix, pszReg, rc); 1376 } 1377 if (cArgs == 1) 1378 { 1379 /* 1380 * Show the register. 1381 */ 1382 char szValue[160]; 1383 rc = DBGFR3RegFormatValue(szValue, sizeof(szValue), &Value, enmType, true /*fSpecial*/); 1384 if (RT_SUCCESS(rc)) 1385 rc = DBGCCmdHlpPrintf(pCmdHlp, "%s%s=%s\n", pszActualPrefix, pszReg, szValue); 1386 else 1387 rc = DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3RegFormatValue failed: %Rrc.\n", rc); 1388 } 1389 else if (cArgs == 2) 1390 { 1391 /* 1392 * Modify the register. 1393 */ 1394 if ( paArgs[1].enmType == DBGCVAR_TYPE_STRING 1395 || paArgs[1].enmType == DBGCVAR_TYPE_SYMBOL) 1396 return DBGCCmdHlpPrintf(pCmdHlp, "internal error: The parser doesn't do its job properly on the 2nd argument yet...\n"); 1397 if (enmType != DBGFREGVALTYPE_DTR) 1398 { 1399 enmType = DBGFREGVALTYPE_U64; 1400 rc = DBGCCmdHlpVarToNumber(pCmdHlp, &paArgs[1], &Value.u64); 1401 } 1402 else 1403 { 1404 enmType = DBGFREGVALTYPE_DTR; 1405 rc = DBGCCmdHlpVarToNumber(pCmdHlp, &paArgs[1], &Value.dtr.u64Base); 1406 if (RT_SUCCESS(rc) && paArgs[1].enmRangeType != DBGCVAR_RANGE_NONE) 1407 Value.dtr.u32Limit = (uint32_t)paArgs[1].u64Range; 1408 } 1409 if (RT_SUCCESS(rc)) 1410 { 1411 rc = DBGFR3RegNmSet(pVM, idCpu, pszReg, &Value, enmType); 1373 1412 if (RT_FAILURE(rc)) 1374 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Failed getting value for register '%s'.\n", pszReg); 1375 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%s=%Dv\n", pszReg, &Var); 1376 } 1377 1378 /* change the register */ 1379 int rc = pSym->pfnSet(pSym, pCmdHlp, &paArgs[1]); 1380 if (RT_FAILURE(rc)) 1381 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Failed setting value for register '%s'.\n", pszReg); 1382 return VINF_SUCCESS; 1383 } 1384 1385 1386 NOREF(pCmd); NOREF(paArgs); NOREF(pResult); 1387 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Huh? cArgs=%d Expected 0, 1 or 2!\n", cArgs); 1413 rc = DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3RegNmSet failed settings '%s%s': %Rrc\n", 1414 pszActualPrefix, pszReg, rc); 1415 } 1416 else 1417 rc = DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3RegFormatValue failed: %Rrc.\n", rc); 1418 } 1419 else 1420 { 1421 NOREF(pCmd); NOREF(paArgs); NOREF(pResult); 1422 rc = DBGCCmdHlpPrintf(pCmdHlp, "Huh? cArgs=%d Expected 0, 1 or 2!\n", cArgs); 1423 } 1424 return rc; 1388 1425 } 1389 1426 … … 1449 1486 "dr0=%016VR{dr0} dr1=%016VR{dr1} dr2=%016VR{dr2} dr3=%016VR{dr3}\n" 1450 1487 "dr6=%016VR{dr6} dr7=%016VR{dr7}\n" 1451 "gdtr=%016VR{gdtr_base}:%04VR{gdtr_lim it} idtr=%016VR{idtr_base}:%04VR{idtr_limit} rflags=%08VR{rflags}\n"1488 "gdtr=%016VR{gdtr_base}:%04VR{gdtr_lim} idtr=%016VR{idtr_base}:%04VR{idtr_lim} rflags=%08VR{rflags}\n" 1452 1489 "ldtr={%04VR{ldtr} base=%016VR{ldtr_base} limit=%08VR{ldtr_lim} flags=%08VR{ldtr_attr}}\n" 1453 1490 "tr ={%04VR{tr} base=%016VR{tr_base} limit=%08VR{tr_lim} flags=%08VR{tr_attr}}\n" … … 1472 1509 "gs={%04VR{gs} base=%08VR{gs_base} limit=%08VR{gs_lim} flags=%04VR{gs_attr}} cr3=%08VR{cr0} cr4=%08VR{cr0}\n" 1473 1510 "ss={%04VR{ss} base=%08VR{ss_base} limit=%08VR{ss_lim} flags=%04VR{ss_attr}} cr8=%08VR{cr8}\n" 1474 "gdtr=%08VR{gdtr_base}:%04VR{gdtr_lim it} idtr=%08VR{idtr_base}:%04VR{idtr_limit} eflags=%08VR{eflags}\n"1511 "gdtr=%08VR{gdtr_base}:%04VR{gdtr_lim} idtr=%08VR{idtr_base}:%04VR{idtr_lim} eflags=%08VR{eflags}\n" 1475 1512 "ldtr={%04VR{ldtr} base=%08VR{ldtr_base} limit=%08VR{ldtr_lim} flags=%04VR{ldtr_attr}}\n" 1476 1513 "tr ={%04VR{tr} base=%08VR{tr_base} limit=%08VR{tr_lim} flags=%04VR{tr_attr}}\n" … … 1532 1569 ".gs={%04VR{gs} base=%08VR{gs_base} limit=%08VR{gs_lim} flags=%04VR{gs_attr}}\n" 1533 1570 ".ss={%04VR{ss} base=%08VR{ss_base} limit=%08VR{ss_lim} flags=%04VR{ss_attr}}\n" 1534 ".gdtr=%08VR{gdtr_base}:%04VR{gdtr_lim it} .idtr=%08VR{idtr_base}:%04VR{idtr_limit} .eflags=%08VR{eflags}\n"1571 ".gdtr=%08VR{gdtr_base}:%04VR{gdtr_lim} .idtr=%08VR{idtr_base}:%04VR{idtr_lim} .eflags=%08VR{eflags}\n" 1535 1572 ".ldtr={%04VR{ldtr} base=%08VR{ldtr_base} limit=%08VR{ldtr_lim} flags=%04VR{ldtr_attr}}\n" 1536 1573 ".tr ={%04VR{tr} base=%08VR{tr_base} limit=%08VR{tr_lim} flags=%04VR{tr_attr}}\n" -
trunk/src/VBox/Debugger/DBGCInternal.h
r33540 r35625 404 404 PCDBGCCMD dbgcRoutineLookup(PDBGC pDbgc, const char *pachName, size_t cchName, bool fExternal); 405 405 406 DECLCALLBACK(int) dbgcOpRegister(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult); 406 407 DECLCALLBACK(int) dbgcOpAddrFlat(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult); 407 408 DECLCALLBACK(int) dbgcOpAddrHost(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult); -
trunk/src/VBox/Debugger/DBGCOps.cpp
r35513 r35625 53 53 static DECLCALLBACK(int) dbgcOpBitwiseNot(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult); 54 54 static DECLCALLBACK(int) dbgcOpVar(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult); 55 static DECLCALLBACK(int) dbgcOpRegister(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);56 55 57 56 static DECLCALLBACK(int) dbgcOpAddrFar(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult); … … 481 480 * @param pResult Where to store the result. 482 481 */ 483 staticDECLCALLBACK(int) dbgcOpRegister(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)482 DECLCALLBACK(int) dbgcOpRegister(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult) 484 483 { 485 484 LogFlow(("dbgcOpRegister: %s\n", pArg->u.pszString)); -
trunk/src/VBox/Debugger/DBGConsole.cpp
r35346 r35625 207 207 int dbgcSymbolGet(PDBGC pDbgc, const char *pszSymbol, DBGCVARTYPE enmType, PDBGCVAR pResult) 208 208 { 209 int rc; 210 209 211 /* 210 212 * Builtin? 211 213 */ 212 PCDBGCSYM 214 PCDBGCSYM pSymDesc = dbgcLookupRegisterSymbol(pDbgc, pszSymbol); 213 215 if (pSymDesc) 214 216 { … … 218 220 } 219 221 222 /* 223 * A typical register? (Guest only) 224 */ 225 static const char s_szSixLetterRegisters[] = 226 "rflags;eflags;" 227 ; 228 static const char s_szThreeLetterRegisters[] = 229 "eax;rax;" "r10;" "r8d;r8w;r8b;" "cr0;" "dr0;" 230 "ebx;rbx;" "r11;" "r9d;r9w;r8b;" "dr1;" 231 "ecx;rcx;" "r12;" "cr2;" "dr2;" 232 "edx;rdx;" "r13;" "cr3;" "dr3;" 233 "edi;rdi;dil;" "r14;" "cr4;" "dr4;" 234 "esi;rsi;sil;" "r15;" "cr8;" 235 "ebp;rbp;" 236 "esp;rsp;" "dr6;" 237 "rip;eip;" "dr7;" 238 "efl;" 239 ; 240 static const char s_szTwoLetterRegisters[] = 241 "ax;al;ah;" "r8;" 242 "bx;bl;bh;" "r9;" 243 "cx;cl;ch;" "cs;" 244 "dx;dl;dh;" "ds;" 245 "di;" "es;" 246 "si;" "fs;" 247 "bp;" "gs;" 248 "sp;" "ss;" 249 "ip;" 250 ; 251 size_t const cchSymbol = strlen(pszSymbol); 252 if ( (cchSymbol == 2 && strstr(s_szTwoLetterRegisters, pszSymbol)) 253 || (cchSymbol == 3 && strstr(s_szThreeLetterRegisters, pszSymbol)) 254 || (cchSymbol == 6 && strstr(s_szSixLetterRegisters, pszSymbol))) 255 { 256 if (!strchr(pszSymbol, ';')) 257 { 258 DBGCVAR Var; 259 DBGCVAR_INIT_STRING(&Var, pszSymbol); 260 rc = dbgcOpRegister(pDbgc, &Var, pResult); 261 if (RT_SUCCESS(rc)) 262 return DBGCCmdHlpConvert(&pDbgc->CmdHlp, &Var, enmType, false /*fConvSyms*/, pResult); 263 } 264 } 220 265 221 266 /* … … 224 269 /** @todo resolve symbols using PDM. */ 225 270 226 227 271 /* 228 272 * Ask the debug info manager. 229 273 */ 230 274 RTDBGSYMBOL Symbol; 231 intrc = DBGFR3AsSymbolByName(pDbgc->pVM, pDbgc->hDbgAs, pszSymbol, &Symbol, NULL);275 rc = DBGFR3AsSymbolByName(pDbgc->pVM, pDbgc->hDbgAs, pszSymbol, &Symbol, NULL); 232 276 if (RT_SUCCESS(rc)) 233 277 { -
trunk/src/VBox/Debugger/testcase/tstDBGCStubs.cpp
r35614 r35625 214 214 return VERR_INTERNAL_ERROR; 215 215 } 216 VMMDECL(ssize_t) DBGFR3RegFormatValue(char *pszBuf, size_t cbBuf, PCDBGFREGVAL pValue, DBGFREGVALTYPE enmType, bool fSpecial) 217 { 218 return VERR_INTERNAL_ERROR; 219 } 220 VMMR3DECL(int) DBGFR3RegNmSet(PVM pVM, VMCPUID idDefCpu, const char *pszReg, PCDBGFREGVAL pValue, DBGFREGVALTYPE enmType) 221 { 222 return VERR_INTERNAL_ERROR; 223 } 216 224 217 225 VMMR3DECL(PDBGFADDRESS) DBGFR3AddrFromPhys(PVM pVM, PDBGFADDRESS pAddress, RTGCPHYS PhysAddr) … … 356 364 return VERR_INTERNAL_ERROR; 357 365 } 366 VMMR3DECL(int) PGMR3DbgHCPhys2GCPhys(PVM pVM, RTHCPHYS HCPhys, PRTGCPHYS pGCPhys) 367 { 368 return VERR_INTERNAL_ERROR; 369 } 358 370 359 371
Note:
See TracChangeset
for help on using the changeset viewer.
