VirtualBox

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

Last change on this file since 78403 was 76553, checked in by vboxsync, 6 years ago

scm --update-copyright-year

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