VirtualBox

source: vbox/trunk/src/VBox/Debugger/testcase/tstDBGCStubs.cpp@ 100594

Last change on this file since 100594 was 98103, checked in by vboxsync, 23 months ago

Copyright year updates by scm.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 25.1 KB
Line 
1/* $Id: tstDBGCStubs.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2/** @file
3 * DBGC Testcase - Command Parser, VMM Stub Functions.
4 */
5
6/*
7 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28#include <VBox/err.h>
29#include <VBox/vmm/vmapi.h>
30#include <iprt/string.h>
31
32
33
34#include <VBox/vmm/dbgf.h>
35#include <VBox/vmm/dbgfflowtrace.h>
36VMMR3DECL(PDBGFADDRESS) DBGFR3AddrFromFlat(PUVM pUVM, PDBGFADDRESS pAddress, RTGCUINTPTR FlatPtr)
37{
38 return NULL;
39}
40
41VMMR3DECL(int) DBGFR3AddrFromSelOff(PUVM pUVM, VMCPUID idCpu, PDBGFADDRESS pAddress, RTSEL Sel, RTUINTPTR off)
42{
43 /* bad:bad -> provke error during parsing. */
44 if (Sel == 0xbad && off == 0xbad)
45 return VERR_OUT_OF_SELECTOR_BOUNDS;
46
47 /* real mode conversion. */
48 pAddress->FlatPtr = (uint32_t)(Sel << 4) | off;
49 pAddress->fFlags |= DBGFADDRESS_FLAGS_FLAT;
50 pAddress->Sel = DBGF_SEL_FLAT;
51 pAddress->off = pAddress->FlatPtr;
52 return VINF_SUCCESS;
53}
54
55VMMR3DECL(int) DBGFR3AddrToPhys(PUVM pUVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, PRTGCPHYS pGCPhys)
56{
57 return VERR_INTERNAL_ERROR;
58}
59
60VMMR3DECL(int) DBGFR3Attach(PUVM pUVM)
61{
62 return VERR_INTERNAL_ERROR;
63}
64
65VMMR3DECL(int) DBGFR3BpClear(PUVM pUVM, RTUINT iBp)
66{
67 return VERR_INTERNAL_ERROR;
68}
69VMMR3DECL(int) DBGFR3BpDisable(PUVM pUVM, RTUINT iBp)
70{
71 return VERR_INTERNAL_ERROR;
72}
73VMMR3DECL(int) DBGFR3BpEnable(PUVM pUVM, RTUINT iBp)
74{
75 return VERR_INTERNAL_ERROR;
76}
77VMMR3DECL(int) DBGFR3BpEnum(PUVM pUVM, PFNDBGFBPENUM pfnCallback, void *pvUser)
78{
79 return VERR_INTERNAL_ERROR;
80}
81VMMR3DECL(int) DBGFR3BpSetInt3(PUVM pUVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, uint64_t iHitTrigger, uint64_t iHitDisable, PRTUINT piBp)
82{
83 return VERR_INTERNAL_ERROR;
84}
85VMMR3DECL(int) DBGFR3BpSetReg(PUVM pUVM, PCDBGFADDRESS pAddress, uint64_t iHitTrigger, uint64_t iHitDisable,
86 uint8_t fType, uint8_t cb, PRTUINT piBp)
87{
88 return VERR_INTERNAL_ERROR;
89}
90VMMR3DECL(int) DBGFR3BpSetREM(PUVM pUVM, PCDBGFADDRESS pAddress, uint64_t iHitTrigger, uint64_t iHitDisable, PRTUINT piBp)
91{
92 return VERR_INTERNAL_ERROR;
93}
94VMMR3DECL(int) DBGFR3QueryWaitable(PUVM pUVM)
95{
96 return VINF_SUCCESS;
97}
98VMMR3DECL(int) DBGFR3Detach(PUVM pUVM)
99{
100 return VERR_INTERNAL_ERROR;
101}
102VMMR3DECL(int) DBGFR3DisasInstrEx(PUVM pUVM, VMCPUID idCpu, RTSEL Sel, RTGCPTR GCPtr, uint32_t fFlags,
103 char *pszOutput, uint32_t cchOutput, uint32_t *pcbInstr)
104{
105 return VERR_INTERNAL_ERROR;
106}
107VMMR3DECL(int) DBGFR3EventWait(PUVM pUVM, RTMSINTERVAL cMillies, PDBGFEVENT pEvent)
108{
109 return VERR_INTERNAL_ERROR;
110}
111VMMR3DECL(int) DBGFR3EventConfigEx(PUVM pUVM, PCDBGFEVENTCONFIG paConfigs, size_t cConfigs)
112{
113 return VERR_INTERNAL_ERROR;
114}
115VMMR3DECL(int) DBGFR3InterruptConfigEx(PUVM pUVM, PCDBGFINTERRUPTCONFIG paConfigs, size_t cConfigs)
116{
117 return VERR_INTERNAL_ERROR;
118}
119
120VMMR3DECL(int) DBGFR3Halt(PUVM pUVM, VMCPUID idCpu)
121{
122 return VERR_INTERNAL_ERROR;
123}
124VMMR3DECL(int) DBGFR3Info(PUVM pUVM, const char *pszName, const char *pszArgs, PCDBGFINFOHLP pHlp)
125{
126 return VERR_INTERNAL_ERROR;
127}
128VMMR3DECL(int) DBGFR3InfoEx(PUVM pUVM, VMCPUID idCpu, const char *pszName, const char *pszArgs, PCDBGFINFOHLP pHlp)
129{
130 return VERR_INTERNAL_ERROR;
131}
132VMMR3DECL(void) DBGFR3InfoGenericGetOptError(PCDBGFINFOHLP pHlp, int rc, union RTGETOPTUNION *pValueUnion, struct RTGETOPTSTATE *pState)
133{
134}
135VMMR3DECL(bool) DBGFR3IsHalted(PUVM pUVM, VMCPUID idCpu)
136{
137 return true;
138}
139VMMR3DECL(int) DBGFR3LogModifyDestinations(PUVM pUVM, const char *pszDestSettings)
140{
141 return VERR_INTERNAL_ERROR;
142}
143VMMR3DECL(int) DBGFR3LogModifyFlags(PUVM pUVM, const char *pszFlagSettings)
144{
145 return VERR_INTERNAL_ERROR;
146}
147VMMR3DECL(int) DBGFR3LogModifyGroups(PUVM pUVM, const char *pszGroupSettings)
148{
149 return VERR_INTERNAL_ERROR;
150}
151VMMR3DECL(RTDBGCFG) DBGFR3AsGetConfig(PUVM pUVM)
152{
153 return NIL_RTDBGCFG;
154}
155VMMR3DECL(int) DBGFR3AsLoadImage(PUVM pUVM, RTDBGAS hAS, const char *pszFilename, const char *pszModName, RTLDRARCH enmArch,
156 PCDBGFADDRESS pModAddress, RTDBGSEGIDX iModSeg, uint32_t fFlags)
157{
158 return VERR_INTERNAL_ERROR;
159}
160VMMR3DECL(int) DBGFR3AsLoadMap(PUVM pUVM, RTDBGAS hAS, const char *pszFilename, const char *pszModName, PCDBGFADDRESS pModAddress, RTDBGSEGIDX iModSeg, RTGCUINTPTR uSubtrahend, uint32_t fFlags)
161{
162 return VERR_INTERNAL_ERROR;
163}
164VMMR3DECL(int) DBGFR3AsUnlinkModuleByName(PUVM pUVM, RTDBGAS hDbgAs, const char *pszModName)
165{
166 return VERR_INTERNAL_ERROR;
167}
168VMMR3DECL(RTDBGAS) DBGFR3AsResolveAndRetain(PUVM pUVM, RTDBGAS hAlias)
169{
170 return NIL_RTDBGAS;
171}
172VMMR3DECL(int) DBGFR3AsLineByAddr(PUVM pUVM, RTDBGAS hDbgAs, PCDBGFADDRESS pAddress,
173 PRTGCINTPTR poffDisp, PRTDBGLINE pLine, PRTDBGMOD phMod)
174{
175 return VERR_DBG_LINE_NOT_FOUND;
176}
177VMMR3DECL(int) DBGFR3Resume(PUVM pUVM, VMCPUID idCpu)
178{
179 return VERR_INTERNAL_ERROR;
180}
181VMMR3DECL(int) DBGFR3StackWalkBegin(PUVM pUVM, VMCPUID idCpu, DBGFCODETYPE enmCodeType, PCDBGFSTACKFRAME *ppFirstFrame)
182{
183 return VERR_INTERNAL_ERROR;
184}
185VMMR3DECL(PCDBGFSTACKFRAME) DBGFR3StackWalkNext(PCDBGFSTACKFRAME pCurrent)
186{
187 return NULL;
188}
189VMMR3DECL(void) DBGFR3StackWalkEnd(PCDBGFSTACKFRAME pFirstFrame)
190{
191}
192VMMR3DECL(int) DBGFR3StepEx(PUVM pUVM, VMCPUID idCpu, uint32_t fFlags, PCDBGFADDRESS pStopPcAddr,
193 PCDBGFADDRESS pStopPopAddr, RTGCUINTPTR cbStopPop, uint32_t cMaxSteps)
194{
195 return VERR_INTERNAL_ERROR;
196}
197VMMR3DECL(int) DBGFR3AsSymbolByAddr(PUVM pUVM, RTDBGAS hDbgAs, PCDBGFADDRESS pAddress, uint32_t fFlags, PRTGCINTPTR poffDisplacement, PRTDBGSYMBOL pSymbol, PRTDBGMOD phMod)
198{
199 return VERR_INTERNAL_ERROR;
200}
201VMMR3DECL(PRTDBGSYMBOL) DBGFR3AsSymbolByAddrA(PUVM pUVM, RTDBGAS hDbgAs, PCDBGFADDRESS pAddress, uint32_t fFlags,
202 PRTGCINTPTR poffDisp, PRTDBGMOD phMod)
203{
204 return NULL;
205}
206VMMR3DECL(int) DBGFR3AsSymbolByName(PUVM pUVM, RTDBGAS hDbgAs, const char *pszSymbol, PRTDBGSYMBOL pSymbol, PRTDBGMOD phMod)
207{
208 return VERR_INTERNAL_ERROR;
209}
210VMMR3DECL(int) DBGFR3AsLinkModule(PUVM pUVM, RTDBGAS hDbgAs, RTDBGMOD hMod, PCDBGFADDRESS pModAddress, RTDBGSEGIDX iModSeg, uint32_t fFlags)
211{
212 return VERR_INTERNAL_ERROR;
213}
214VMMR3DECL(int) DBGFR3ModInMem(PUVM pUVM, PCDBGFADDRESS pImageAddr, uint32_t fFlags, const char *pszName, const char *pszFilename,
215 RTLDRARCH enmArch, uint32_t cbImage, PRTDBGMOD phDbgMod, PRTERRINFO pErrInfo)
216{
217 return VERR_INTERNAL_ERROR;
218}
219VMMR3DECL(int) DBGFR3MemScan(PUVM pUVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, RTGCUINTPTR cbRange, RTGCUINTPTR uAlign, const void *pabNeedle, size_t cbNeedle, PDBGFADDRESS pHitAddress)
220{
221 return VERR_INTERNAL_ERROR;
222}
223VMMR3DECL(int) DBGFR3MemRead(PUVM pUVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, void *pvBuf, size_t cbRead)
224{
225 return VERR_INTERNAL_ERROR;
226}
227VMMR3DECL(int) DBGFR3MemReadString(PUVM pUVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, char *pszBuf, size_t cchBuf)
228{
229 return VERR_INTERNAL_ERROR;
230}
231VMMR3DECL(int) DBGFR3MemWrite(PUVM pUVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, const void *pvBuf, size_t cbRead)
232{
233 return VERR_INTERNAL_ERROR;
234}
235VMMDECL(int) DBGFR3PagingDumpEx(PUVM pUVM, VMCPUID idCpu, uint32_t fFlags, uint64_t cr3, uint64_t u64FirstAddr,
236 uint64_t u64LastAddr, uint32_t cMaxDepth, PCDBGFINFOHLP pHlp)
237{
238 return VERR_INTERNAL_ERROR;
239}
240VMMR3DECL(int) DBGFR3RegNmValidate(PUVM pUVM, VMCPUID idDefCpu, const char *pszReg)
241{
242 if ( !strcmp(pszReg, "ah")
243 || !strcmp(pszReg, "ax")
244 || !strcmp(pszReg, "eax")
245 || !strcmp(pszReg, "rax"))
246 return VINF_SUCCESS;
247 return VERR_DBGF_REGISTER_NOT_FOUND;
248}
249VMMR3DECL(const char *) DBGFR3RegCpuName(PUVM pUVM, DBGFREG enmReg, DBGFREGVALTYPE enmType)
250{
251 return NULL;
252}
253VMMR3DECL(int) DBGFR3RegCpuQueryU8( PUVM pUVM, VMCPUID idCpu, DBGFREG enmReg, uint8_t *pu8)
254{
255 return VERR_INTERNAL_ERROR;
256}
257VMMR3DECL(int) DBGFR3RegCpuQueryU16( PUVM pUVM, VMCPUID idCpu, DBGFREG enmReg, uint16_t *pu16)
258{
259 return VERR_INTERNAL_ERROR;
260}
261VMMR3DECL(int) DBGFR3RegCpuQueryU32( PUVM pUVM, VMCPUID idCpu, DBGFREG enmReg, uint32_t *pu32)
262{
263 return VERR_INTERNAL_ERROR;
264}
265VMMR3DECL(int) DBGFR3RegCpuQueryU64( PUVM pUVM, VMCPUID idCpu, DBGFREG enmReg, uint64_t *pu64)
266{
267 return VERR_INTERNAL_ERROR;
268}
269VMMR3DECL(int) DBGFR3RegCpuQueryXdtr(PUVM pUVM, VMCPUID idCpu, DBGFREG enmReg, uint64_t *pu64Base, uint16_t *pu16Limit)
270{
271 return VERR_INTERNAL_ERROR;
272}
273VMMR3DECL(int) DBGFR3RegNmQuery(PUVM pUVM, VMCPUID idDefCpu, const char *pszReg, PDBGFREGVAL pValue, PDBGFREGVALTYPE penmType)
274{
275 if (idDefCpu == 0 || idDefCpu == DBGFREG_HYPER_VMCPUID)
276 {
277 if (!strcmp(pszReg, "ah"))
278 {
279 pValue->u16 = 0xf0;
280 *penmType = DBGFREGVALTYPE_U8;
281 return VINF_SUCCESS;
282 }
283 if (!strcmp(pszReg, "ax"))
284 {
285 pValue->u16 = 0xbabe;
286 *penmType = DBGFREGVALTYPE_U16;
287 return VINF_SUCCESS;
288 }
289 if (!strcmp(pszReg, "eax"))
290 {
291 pValue->u32 = 0xcafebabe;
292 *penmType = DBGFREGVALTYPE_U32;
293 return VINF_SUCCESS;
294 }
295 if (!strcmp(pszReg, "rax"))
296 {
297 pValue->u64 = UINT64_C(0x00beef00feedface);
298 *penmType = DBGFREGVALTYPE_U32;
299 return VINF_SUCCESS;
300 }
301 }
302 return VERR_DBGF_REGISTER_NOT_FOUND;
303}
304VMMR3DECL(int) DBGFR3RegPrintf(PUVM pUVM, VMCPUID idCpu, char *pszBuf, size_t cbBuf, const char *pszFormat, ...)
305{
306 return VERR_INTERNAL_ERROR;
307}
308VMMDECL(ssize_t) DBGFR3RegFormatValue(char *pszBuf, size_t cbBuf, PCDBGFREGVAL pValue, DBGFREGVALTYPE enmType, bool fSpecial)
309{
310 return VERR_INTERNAL_ERROR;
311}
312VMMR3DECL(int) DBGFR3RegNmSet(PUVM pUVM, VMCPUID idDefCpu, const char *pszReg, PCDBGFREGVAL pValue, DBGFREGVALTYPE enmType)
313{
314 return VERR_INTERNAL_ERROR;
315}
316
317VMMR3DECL(PDBGFADDRESS) DBGFR3AddrFromPhys(PUVM pUVM, PDBGFADDRESS pAddress, RTGCPHYS PhysAddr)
318{
319 return NULL;
320}
321VMMR3DECL(int) DBGFR3AddrToHostPhys(PUVM pUVM, VMCPUID idCpu, PDBGFADDRESS pAddress, PRTHCPHYS pHCPhys)
322{
323 return VERR_INTERNAL_ERROR;
324}
325VMMR3DECL(int) DBGFR3AddrToVolatileR3Ptr(PUVM pUVM, VMCPUID idCpu, PDBGFADDRESS pAddress, bool fReadOnly, void **ppvR3Ptr)
326{
327 return VERR_INTERNAL_ERROR;
328}
329
330VMMR3DECL(int) DBGFR3OSRegister(PUVM pUVM, PCDBGFOSREG pReg)
331{
332 return VERR_INTERNAL_ERROR;
333}
334VMMR3DECL(int) DBGFR3OSDetect(PUVM pUVM, char *pszName, size_t cchName)
335{
336 return VERR_INTERNAL_ERROR;
337}
338VMMR3DECL(int) DBGFR3OSQueryNameAndVersion(PUVM pUVM, char *pszName, size_t cchName, char *pszVersion, size_t cchVersion)
339{
340 return VERR_INTERNAL_ERROR;
341}
342VMMR3DECL(void *) DBGFR3OSQueryInterface(PUVM pUVM, DBGFOSINTERFACE enmIf)
343{
344 return NULL;
345}
346
347VMMR3DECL(int) DBGFR3SelQueryInfo(PUVM pUVM, VMCPUID idCpu, RTSEL Sel, uint32_t fFlags, PDBGFSELINFO pSelInfo)
348{
349 return VERR_INTERNAL_ERROR;
350}
351
352VMMR3DECL(CPUMMODE) DBGFR3CpuGetMode(PUVM pUVM, VMCPUID idCpu)
353{
354 return CPUMMODE_INVALID;
355}
356VMMR3DECL(VMCPUID) DBGFR3CpuGetCount(PUVM pUVM)
357{
358 return 1;
359}
360VMMR3DECL(bool) DBGFR3CpuIsIn64BitCode(PUVM pUVM, VMCPUID idCpu)
361{
362 return false;
363}
364VMMR3DECL(bool) DBGFR3CpuIsInV86Code(PUVM pUVM, VMCPUID idCpu)
365{
366 return false;
367}
368
369VMMR3DECL(int) DBGFR3CoreWrite(PUVM pUVM, const char *pszFilename, bool fReplaceFile)
370{
371 return VERR_INTERNAL_ERROR;
372}
373
374VMMR3DECL(int) DBGFR3PlugInLoad(PUVM pUVM, const char *pszPlugIn, char *pszActual, size_t cbActual, PRTERRINFO pErrInfo)
375{
376 return VERR_INTERNAL_ERROR;
377}
378VMMR3DECL(int) DBGFR3PlugInUnload(PUVM pUVM, const char *pszName)
379{
380 return VERR_INTERNAL_ERROR;
381}
382VMMR3DECL(void) DBGFR3PlugInLoadAll(PUVM pUVM)
383{
384}
385VMMR3DECL(int) DBGFR3TypeRegister( PUVM pUVM, uint32_t cTypes, PCDBGFTYPEREG paTypes)
386{
387 return VERR_INTERNAL_ERROR;
388}
389VMMR3DECL(int) DBGFR3TypeDeregister(PUVM pUVM, const char *pszType)
390{
391 return VERR_INTERNAL_ERROR;
392}
393VMMR3DECL(int) DBGFR3TypeQueryReg( PUVM pUVM, const char *pszType, PCDBGFTYPEREG *ppTypeReg)
394{
395 return VERR_INTERNAL_ERROR;
396}
397VMMR3DECL(int) DBGFR3TypeQuerySize( PUVM pUVM, const char *pszType, size_t *pcbType)
398{
399 return VERR_INTERNAL_ERROR;
400}
401VMMR3DECL(int) DBGFR3TypeSetSize( PUVM pUVM, const char *pszType, size_t cbType)
402{
403 return VERR_INTERNAL_ERROR;
404}
405VMMR3DECL(int) DBGFR3TypeDumpEx( PUVM pUVM, const char *pszType, uint32_t fFlags,
406 uint32_t cLvlMax, PFNDBGFR3TYPEDUMP pfnDump, void *pvUser)
407{
408 return VERR_INTERNAL_ERROR;
409}
410VMMR3DECL(int) DBGFR3TypeQueryValByType(PUVM pUVM, PCDBGFADDRESS pAddress, const char *pszType,
411 PDBGFTYPEVAL *ppVal)
412{
413 return VERR_INTERNAL_ERROR;
414}
415VMMR3DECL(void) DBGFR3TypeValFree(PDBGFTYPEVAL pVal)
416{
417}
418VMMR3DECL(int) DBGFR3TypeValDumpEx(PUVM pUVM, PCDBGFADDRESS pAddress, const char *pszType, uint32_t fFlags,
419 uint32_t cLvlMax, FNDBGFR3TYPEVALDUMP pfnDump, void *pvUser)
420{
421 return VERR_INTERNAL_ERROR;
422}
423
424VMMR3DECL(int) DBGFR3FlowCreate(PUVM pUVM, VMCPUID idCpu, PDBGFADDRESS pAddressStart, uint32_t cbDisasmMax,
425 uint32_t fFlagsFlow, uint32_t fFlagsDisasm, PDBGFFLOW phFlow)
426{
427 return VERR_INTERNAL_ERROR;
428}
429VMMR3DECL(uint32_t) DBGFR3FlowRetain(DBGFFLOW hFlow)
430{
431 return 0;
432}
433VMMR3DECL(uint32_t) DBGFR3FlowRelease(DBGFFLOW hFlow)
434{
435 return 0;
436}
437VMMR3DECL(int) DBGFR3FlowQueryStartBb(DBGFFLOW hFlow, PDBGFFLOWBB phFlowBb)
438{
439 return VERR_INTERNAL_ERROR;
440}
441VMMR3DECL(int) DBGFR3FlowQueryBbByAddress(DBGFFLOW hFlow, PDBGFADDRESS pAddr, PDBGFFLOWBB phFlowBb)
442{
443 return VERR_INTERNAL_ERROR;
444}
445VMMR3DECL(int) DBGFR3FlowQueryBranchTblByAddress(DBGFFLOW hFlow, PDBGFADDRESS pAddr, PDBGFFLOWBRANCHTBL phFlowBranchTbl)
446{
447 return VERR_INTERNAL_ERROR;
448}
449VMMR3DECL(uint32_t) DBGFR3FlowGetBbCount(DBGFFLOW hFlow)
450{
451 return 0;
452}
453VMMR3DECL(uint32_t) DBGFR3FlowGetBranchTblCount(DBGFFLOW hFlow)
454{
455 return 0;
456}
457VMMR3DECL(uint32_t) DBGFR3FlowBbRetain(DBGFFLOWBB hFlowBb)
458{
459 return 0;
460}
461VMMR3DECL(uint32_t) DBGFR3FlowBbRelease(DBGFFLOWBB hFlowBb)
462{
463 return 0;
464}
465VMMR3DECL(PDBGFADDRESS) DBGFR3FlowBbGetStartAddress(DBGFFLOWBB hFlowBb, PDBGFADDRESS pAddrStart)
466{
467 return NULL;
468}
469VMMR3DECL(PDBGFADDRESS) DBGFR3FlowBbGetEndAddress(DBGFFLOWBB hFlowBb, PDBGFADDRESS pAddrEnd)
470{
471 return NULL;
472}
473VMMR3DECL(PDBGFADDRESS) DBGFR3FlowBbGetBranchAddress(DBGFFLOWBB hFlowBb, PDBGFADDRESS pAddrTarget)
474{
475 return NULL;
476}
477VMMR3DECL(PDBGFADDRESS) DBGFR3FlowBbGetFollowingAddress(DBGFFLOWBB hFlowBb, PDBGFADDRESS pAddrFollow)
478{
479 return NULL;
480}
481VMMR3DECL(DBGFFLOWBBENDTYPE) DBGFR3FlowBbGetType(DBGFFLOWBB hFlowBb)
482{
483 return DBGFFLOWBBENDTYPE_INVALID;
484}
485VMMR3DECL(uint32_t) DBGFR3FlowBbGetInstrCount(DBGFFLOWBB hFlowBb)
486{
487 return 0;
488}
489VMMR3DECL(uint32_t) DBGFR3FlowBbGetFlags(DBGFFLOWBB hFlowBb)
490{
491 return 0;
492}
493VMMR3DECL(int) DBGFR3FlowBbQueryBranchTbl(DBGFFLOWBB hFlowBb, PDBGFFLOWBRANCHTBL phBranchTbl)
494{
495 return VERR_INTERNAL_ERROR;
496}
497VMMR3DECL(int) DBGFR3FlowBbQueryError(DBGFFLOWBB hFlowBb, const char **ppszErr)
498{
499 return VERR_INTERNAL_ERROR;
500}
501VMMR3DECL(int) DBGFR3FlowBbQueryInstr(DBGFFLOWBB hFlowBb, uint32_t idxInstr, PDBGFADDRESS pAddrInstr,
502 uint32_t *pcbInstr, const char **ppszInstr)
503{
504 return VERR_INTERNAL_ERROR;
505}
506VMMR3DECL(int) DBGFR3FlowBbQuerySuccessors(DBGFFLOWBB hFlowBb, PDBGFFLOWBB phFlowBbFollow,
507 PDBGFFLOWBB phFlowBbTarget)
508{
509 return VERR_INTERNAL_ERROR;
510}
511VMMR3DECL(uint32_t) DBGFR3FlowBbGetRefBbCount(DBGFFLOWBB hFlowBb)
512{
513 return 0;
514}
515VMMR3DECL(int) DBGFR3FlowBbGetRefBb(DBGFFLOWBB hFlowBb, PDBGFFLOWBB pahFlowBbRef, uint32_t cRef)
516{
517 return VERR_INTERNAL_ERROR;
518}
519VMMR3DECL(uint32_t) DBGFR3FlowBranchTblRetain(DBGFFLOWBRANCHTBL hFlowBranchTbl)
520{
521 return 0;
522}
523VMMR3DECL(uint32_t) DBGFR3FlowBranchTblRelease(DBGFFLOWBRANCHTBL hFlowBranchTbl)
524{
525 return 0;
526}
527VMMR3DECL(uint32_t) DBGFR3FlowBranchTblGetSlots(DBGFFLOWBRANCHTBL hFlowBranchTbl)
528{
529 return 0;
530}
531VMMR3DECL(PDBGFADDRESS) DBGFR3FlowBranchTblGetStartAddress(DBGFFLOWBRANCHTBL hFlowBranchTbl, PDBGFADDRESS pAddrStart)
532{
533 return NULL;
534}
535VMMR3DECL(PDBGFADDRESS) DBGFR3FlowBranchTblGetAddrAtSlot(DBGFFLOWBRANCHTBL hFlowBranchTbl, uint32_t idxSlot, PDBGFADDRESS pAddrSlot)
536{
537 return NULL;
538}
539VMMR3DECL(int) DBGFR3FlowBranchTblQueryAddresses(DBGFFLOWBRANCHTBL hFlowBranchTbl, PDBGFADDRESS paAddrs, uint32_t cAddrs)
540{
541 return VERR_INTERNAL_ERROR;
542}
543VMMR3DECL(int) DBGFR3FlowItCreate(DBGFFLOW hFlow, DBGFFLOWITORDER enmOrder, PDBGFFLOWIT phFlowIt)
544{
545 return VERR_INTERNAL_ERROR;
546}
547VMMR3DECL(void) DBGFR3FlowItDestroy(DBGFFLOWIT hFlowIt)
548{
549}
550VMMR3DECL(DBGFFLOWBB) DBGFR3FlowItNext(DBGFFLOWIT hFlowIt)
551{
552 return NULL;
553}
554VMMR3DECL(int) DBGFR3FlowItReset(DBGFFLOWIT hFlowIt)
555{
556 return VERR_INTERNAL_ERROR;
557}
558VMMR3DECL(int) DBGFR3FlowBranchTblItCreate(DBGFFLOW hFlow, DBGFFLOWITORDER enmOrder, PDBGFFLOWBRANCHTBLIT phFlowBranchTblIt)
559{
560 return VERR_INTERNAL_ERROR;
561}
562VMMR3DECL(void) DBGFR3FlowBranchTblItDestroy(DBGFFLOWBRANCHTBLIT hFlowBranchTblIt)
563{
564}
565VMMR3DECL(DBGFFLOWBRANCHTBL) DBGFR3FlowBranchTblItNext(DBGFFLOWBRANCHTBLIT hFlowBranchTblIt)
566{
567 return NULL;
568}
569VMMR3DECL(int) DBGFR3FlowBranchTblItReset(DBGFFLOWBRANCHTBLIT hFlowBranchTblIt)
570{
571 return VERR_INTERNAL_ERROR;
572}
573VMMR3DECL(int) DBGFR3FlowTraceModCreateFromFlowGraph(PUVM pUVM, VMCPUID idCpu, DBGFFLOW hFlow,
574 DBGFFLOWTRACEPROBE hFlowTraceProbeCommon,
575 DBGFFLOWTRACEPROBE hFlowTraceProbeEntry,
576 DBGFFLOWTRACEPROBE hFlowTraceProbeRegular,
577 DBGFFLOWTRACEPROBE hFlowTraceProbeExit,
578 PDBGFFLOWTRACEMOD phFlowTraceMod)
579{
580 return VERR_INTERNAL_ERROR;
581}
582VMMR3DECL(uint32_t) DBGFR3FlowTraceModRetain(DBGFFLOWTRACEMOD hFlowTraceMod)
583{
584 return 0;
585}
586VMMR3DECL(uint32_t) DBGFR3FlowTraceModRelease(DBGFFLOWTRACEMOD hFlowTraceMod)
587{
588 return 0;
589}
590VMMR3DECL(int) DBGFR3FlowTraceModEnable(DBGFFLOWTRACEMOD hFlowTraceMod, uint32_t cHits, uint32_t cRecordsMax)
591{
592 return VERR_INTERNAL_ERROR;
593}
594VMMR3DECL(int) DBGFR3FlowTraceModDisable(DBGFFLOWTRACEMOD hFlowTraceMod)
595{
596 return VERR_INTERNAL_ERROR;
597}
598VMMR3DECL(int) DBGFR3FlowTraceModQueryReport(DBGFFLOWTRACEMOD hFlowTraceMod,
599 PDBGFFLOWTRACEREPORT phFlowTraceReport)
600{
601 return VERR_INTERNAL_ERROR;
602}
603VMMR3DECL(int) DBGFR3FlowTraceModClear(DBGFFLOWTRACEMOD hFlowTraceMod)
604{
605 return VERR_INTERNAL_ERROR;
606}
607VMMR3DECL(int) DBGFR3FlowTraceModAddProbe(DBGFFLOWTRACEMOD hFlowTraceMod, PCDBGFADDRESS pAddrProbe,
608 DBGFFLOWTRACEPROBE hFlowTraceProbe, uint32_t fFlags)
609{
610 return VERR_INTERNAL_ERROR;
611}
612VMMR3DECL(int) DBGFR3FlowTraceProbeCreate(PUVM pUVM, const char *pszDescr, PDBGFFLOWTRACEPROBE phFlowTraceProbe)
613{
614 return VERR_INTERNAL_ERROR;
615}
616VMMR3DECL(uint32_t) DBGFR3FlowTraceProbeRetain(DBGFFLOWTRACEPROBE hFlowTraceProbe)
617{
618 return 0;
619}
620VMMR3DECL(uint32_t) DBGFR3FlowTraceProbeRelease(DBGFFLOWTRACEPROBE hFlowTraceProbe)
621{
622 return 0;
623}
624VMMR3DECL(int) DBGFR3FlowTraceProbeEntriesAdd(DBGFFLOWTRACEPROBE hFlowTraceProbe,
625 PCDBGFFLOWTRACEPROBEENTRY paEntries, uint32_t cEntries)
626{
627 return VERR_INTERNAL_ERROR;
628}
629VMMR3DECL(uint32_t) DBGFR3FlowTraceReportRetain(DBGFFLOWTRACEREPORT hFlowTraceReport)
630{
631 return 0;
632}
633VMMR3DECL(uint32_t) DBGFR3FlowTraceReportRelease(DBGFFLOWTRACEREPORT hFlowTraceReport)
634{
635 return 0;
636}
637VMMR3DECL(uint32_t) DBGFR3FlowTraceReportGetRecordCount(DBGFFLOWTRACEREPORT hFlowTraceReport)
638{
639 return 0;
640}
641VMMR3DECL(int) DBGFR3FlowTraceReportQueryRecord(DBGFFLOWTRACEREPORT hFlowTraceReport, uint32_t idxRec, PDBGFFLOWTRACERECORD phFlowTraceRec)
642{
643 return VERR_INTERNAL_ERROR;
644}
645VMMR3DECL(int) DBGFR3FlowTraceReportQueryFiltered(DBGFFLOWTRACEREPORT hFlowTraceReport, uint32_t fFlags,
646 PDBGFFLOWTRACEREPORTFILTER paFilters, uint32_t cFilters,
647 DBGFFLOWTRACEREPORTFILTEROP enmOp,
648 PDBGFFLOWTRACEREPORT phFlowTraceReportFiltered)
649{
650 return VERR_INTERNAL_ERROR;
651}
652VMMR3DECL(int) DBGFR3FlowTraceReportEnumRecords(DBGFFLOWTRACEREPORT hFlowTraceReport,
653 PFNDBGFFLOWTRACEREPORTENUMCLBK pfnEnum,
654 void *pvUser)
655{
656 return VERR_INTERNAL_ERROR;
657}
658VMMR3DECL(uint32_t) DBGFR3FlowTraceRecordRetain(DBGFFLOWTRACERECORD hFlowTraceRecord)
659{
660 return 0;
661}
662VMMR3DECL(uint32_t) DBGFR3FlowTraceRecordRelease(DBGFFLOWTRACERECORD hFlowTraceRecord)
663{
664 return 0;
665}
666VMMR3DECL(uint64_t) DBGFR3FlowTraceRecordGetSeqNo(DBGFFLOWTRACERECORD hFlowTraceRecord)
667{
668 return 0;
669}
670VMMR3DECL(uint64_t) DBGFR3FlowTraceRecordGetTimestamp(DBGFFLOWTRACERECORD hFlowTraceRecord)
671{
672 return 0;
673}
674VMMR3DECL(PDBGFADDRESS) DBGFR3FlowTraceRecordGetAddr(DBGFFLOWTRACERECORD hFlowTraceRecord, PDBGFADDRESS pAddr)
675{
676 return NULL;
677}
678VMMR3DECL(DBGFFLOWTRACEPROBE) DBGFR3FlowTraceRecordGetProbe(DBGFFLOWTRACERECORD hFlowTraceRecord)
679{
680 return NULL;
681}
682VMMR3DECL(uint32_t) DBGFR3FlowTraceRecordGetValCount(DBGFFLOWTRACERECORD hFlowTraceRecord)
683{
684 return 0;
685}
686VMMR3DECL(PCDBGFFLOWTRACEPROBEVAL) DBGFR3FlowTraceRecordGetVals(DBGFFLOWTRACERECORD hFlowTraceRecord)
687{
688 return NULL;
689}
690VMMR3DECL(PCDBGFFLOWTRACEPROBEVAL) DBGFR3FlowTraceRecordGetValsCommon(DBGFFLOWTRACERECORD hFlowTraceRecord)
691{
692 return NULL;
693}
694VMMR3DECL(VMCPUID) DBGFR3FlowTraceRecordGetCpuId(DBGFFLOWTRACERECORD hFlowTraceRecord)
695{
696 return 0;
697}
698
699VMMR3DECL(int) DBGFR3FormatBugCheck(PUVM pUVM, char *pszDetails, size_t cbDetails,
700 uint64_t uP0, uint64_t uP1, uint64_t uP2, uint64_t uP3, uint64_t uP4)
701{
702 pszDetails[0] = '\0';
703 return VERR_INTERNAL_ERROR;
704}
705
706VMMR3DECL(PDBGFADDRESS) DBGFR3AddrAdd(PDBGFADDRESS pAddress, RTGCUINTPTR uAddend)
707{
708 RT_NOREF(uAddend);
709 return pAddress;
710}
711
712#include <VBox/vmm/cfgm.h>
713VMMR3DECL(int) CFGMR3ValidateConfig(PCFGMNODE pNode, const char *pszNode,
714 const char *pszValidValues, const char *pszValidNodes,
715 const char *pszWho, uint32_t uInstance)
716{
717 return VINF_SUCCESS;
718}
719
720VMMR3DECL(PCFGMNODE) CFGMR3GetRootU(PUVM pUVM)
721{
722 return NULL;
723}
724
725VMMR3DECL(PCFGMNODE) CFGMR3GetChild(PCFGMNODE pNode, const char *pszPath)
726{
727 return NULL;
728}
729
730VMMR3DECL(int) CFGMR3QueryString(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString)
731{
732 *pszString = '\0';
733 return VINF_SUCCESS;
734}
735
736VMMR3DECL(int) CFGMR3QueryStringDef(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString, const char *pszDef)
737{
738 *pszString = '\0';
739 return VINF_SUCCESS;
740}
741
742
743
744//////////////////////////////////////////////////////////////////////////
745// The rest should eventually be replaced by DBGF calls and eliminated. //
746/////////////////////////////////////////////////////////////////////////
747
748
749#include <VBox/vmm/cpum.h>
750
751VMMDECL(uint64_t) CPUMGetGuestCR3(PCVMCPU pVCpu)
752{
753 return 0;
754}
755
756VMMDECL(uint64_t) CPUMGetGuestCR4(PCVMCPU pVCpu)
757{
758 return 0;
759}
760
761VMMDECL(RTSEL) CPUMGetGuestCS(PCVMCPU pVCpu)
762{
763 return 0;
764}
765
766VMMDECL(uint32_t) CPUMGetGuestEIP(PCVMCPU pVCpu)
767{
768 return 0;
769}
770
771VMMDECL(uint64_t) CPUMGetGuestRIP(PCVMCPU pVCpu)
772{
773 return 0;
774}
775
776VMMDECL(RTGCPTR) CPUMGetGuestIDTR(PCVMCPU pVCpu, uint16_t *pcbLimit)
777{
778 return 0;
779}
780
781VMMDECL(CPUMMODE) CPUMGetGuestMode(PVMCPU pVCpu)
782{
783 return CPUMMODE_INVALID;
784}
785
786VMMDECL(PCPUMCTX) CPUMQueryGuestCtxPtr(PVMCPU pVCpu)
787{
788 return NULL;
789}
790
791VMMDECL(bool) CPUMIsGuestIn64BitCode(PVMCPU pVCpu)
792{
793 return false;
794}
795
796VMMDECL(uint32_t) CPUMGetGuestEFlags(PCVMCPU pVCpu)
797{
798 return 2;
799}
800
801#include <VBox/vmm/hm.h>
802VMMR3DECL(bool) HMR3IsEnabled(PUVM pUVM)
803{
804 return true;
805}
806
807
808#include <VBox/vmm/nem.h>
809VMMR3DECL(bool) NEMR3IsEnabled(PUVM pUVM)
810{
811 return true;
812}
813
814
815#include <VBox/vmm/pgm.h>
816
817VMMDECL(RTHCPHYS) PGMGetHyperCR3(PVMCPU pVCpu)
818{
819 return 0;
820}
821
822VMMDECL(PGMMODE) PGMGetShadowMode(PVMCPU pVCpu)
823{
824 return PGMMODE_INVALID;
825}
826
827VMMR3DECL(int) PGMR3DbgR3Ptr2GCPhys(PUVM pUVM, RTR3PTR R3Ptr, PRTGCPHYS pGCPhys)
828{
829 return VERR_INTERNAL_ERROR;
830}
831
832VMMR3DECL(int) PGMR3DbgR3Ptr2HCPhys(PUVM pUVM, RTR3PTR R3Ptr, PRTHCPHYS pHCPhys)
833{
834 return VERR_INTERNAL_ERROR;
835}
836VMMR3DECL(int) PGMR3DbgHCPhys2GCPhys(PUVM pUVM, RTHCPHYS HCPhys, PRTGCPHYS pGCPhys)
837{
838 return VERR_INTERNAL_ERROR;
839}
840
841
842#include <VBox/vmm/vmm.h>
843
844VMMR3DECL(PVMCPU) VMMR3GetCpuByIdU(PUVM pUVM, RTCPUID idCpu)
845{
846 return NULL;
847}
848
849VMMR3DECL(PCVMMR3VTABLE) VMMR3GetVTable(void)
850{
851 return NULL;
852}
853
854VMMR3DECL(PVM) VMR3GetVM(PUVM pUVM)
855{
856 return NULL;
857}
858
859VMMR3DECL(VMSTATE) VMR3GetStateU(PUVM pUVM)
860{
861 return VMSTATE_DESTROYING;
862}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette