dbgas.cpp@ 72778

Last change on this file since 72778 was 69111, checked in by vboxsync, 7 years ago
(C) year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 56.1 KB

Line
1	/* $Id: dbgas.cpp 69111 2017-10-17 14:26:02Z vboxsync $ */
2	/** @file
3	* IPRT - Debug Address Space.
4	*/
5
6	/*
7	* Copyright (C) 2009-2017 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	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#include <iprt/dbg.h>
32	#include "internal/iprt.h"
33
34	#include <iprt/asm.h>
35	#include <iprt/avl.h>
36	#include <iprt/assert.h>
37	#include <iprt/err.h>
38	#include <iprt/mem.h>
39	#include <iprt/param.h>
40	#include <iprt/string.h>
41	#include <iprt/semaphore.h>
42	#include "internal/magics.h"
43
44
45	/*********************************************************************************************************************************
46	* Structures and Typedefs *
47	*********************************************************************************************************************************/
48	/** Pointer to a module table entry. */
49	typedef struct RTDBGASMOD *PRTDBGASMOD;
50	/** Pointer to an address space mapping node. */
51	typedef struct RTDBGASMAP *PRTDBGASMAP;
52	/** Pointer to a name head. */
53	typedef struct RTDBGASNAME *PRTDBGASNAME;
54
55	/**
56	* Module entry.
57	*/
58	typedef struct RTDBGASMOD
59	{
60	/** Node core, the module handle is the key. */
61	AVLPVNODECORE Core;
62	/** Pointer to the first mapping of the module or a segment within it. */
63	PRTDBGASMAP pMapHead;
64	/** Pointer to the next module with an identical name. */
65	PRTDBGASMOD pNextName;
66	/** The index into RTDBGASINT::papModules. */
67	uint32_t iOrdinal;
68	} RTDBGASMOD;
69
70	/**
71	* An address space mapping, either of a full module or a segment.
72	*/
73	typedef struct RTDBGASMAP
74	{
75	/** The AVL node core. Contains the address range. */
76	AVLRUINTPTRNODECORE Core;
77	/** Pointer to the next mapping of the module. */
78	PRTDBGASMAP pNext;
79	/** Pointer to the module. */
80	PRTDBGASMOD pMod;
81	/** Which segment in the module.
82	* This is NIL_RTDBGSEGIDX when the entire module is mapped. */
83	RTDBGSEGIDX iSeg;
84	} RTDBGASMAP;
85
86	/**
87	* Name in the address space.
88	*/
89	typedef struct RTDBGASNAME
90	{
91	/** The string space node core.*/
92	RTSTRSPACECORE StrCore;
93	/** The list of nodes */
94	PRTDBGASMOD pHead;
95	} RTDBGASNAME;
96
97	/**
98	* Debug address space instance.
99	*/
100	typedef struct RTDBGASINT
101	{
102	/** Magic value (RTDBGAS_MAGIC). */
103	uint32_t u32Magic;
104	/** The number of reference to this address space. */
105	uint32_t volatile cRefs;
106	/** Handle of the read-write lock. */
107	RTSEMRW hLock;
108	/** Number of modules in the module address space. */
109	uint32_t cModules;
110	/** Pointer to the module table.
111	* The valid array length is given by cModules. */
112	PRTDBGASMOD *papModules;
113	/** AVL tree translating module handles to module entries. */
114	AVLPVTREE ModTree;
115	/** AVL tree mapping addresses to modules. */
116	AVLRUINTPTRTREE MapTree;
117	/** Names of the modules in the name space. */
118	RTSTRSPACE NameSpace;
119	/** The first address the AS. */
120	RTUINTPTR FirstAddr;
121	/** The last address in the AS. */
122	RTUINTPTR LastAddr;
123	/** The name of the address space. (variable length) */
124	char szName[1];
125	} RTDBGASINT;
126	/** Pointer to an a debug address space instance. */
127	typedef RTDBGASINT *PRTDBGASINT;
128
129
130	/*********************************************************************************************************************************
131	* Defined Constants And Macros *
132	*********************************************************************************************************************************/
133	/** Validates an address space handle and returns rc if not valid. */
134	#define RTDBGAS_VALID_RETURN_RC(pDbgAs, rc) \
135	do { \
136	AssertPtrReturn((pDbgAs), (rc)); \
137	AssertReturn((pDbgAs)->u32Magic == RTDBGAS_MAGIC, (rc)); \
138	AssertReturn((pDbgAs)->cRefs > 0, (rc)); \
139	} while (0)
140
141	/** Locks the address space for reading. */
142	#define RTDBGAS_LOCK_READ(pDbgAs) \
143	do { \
144	int rcLock = RTSemRWRequestRead((pDbgAs)->hLock, RT_INDEFINITE_WAIT); \
145	AssertRC(rcLock); \
146	} while (0)
147
148	/** Unlocks the address space after reading. */
149	#define RTDBGAS_UNLOCK_READ(pDbgAs) \
150	do { \
151	int rcLock = RTSemRWReleaseRead((pDbgAs)->hLock); \
152	AssertRC(rcLock); \
153	} while (0)
154
155	/** Locks the address space for writing. */
156	#define RTDBGAS_LOCK_WRITE(pDbgAs) \
157	do { \
158	int rcLock = RTSemRWRequestWrite((pDbgAs)->hLock, RT_INDEFINITE_WAIT); \
159	AssertRC(rcLock); \
160	} while (0)
161
162	/** Unlocks the address space after writing. */
163	#define RTDBGAS_UNLOCK_WRITE(pDbgAs) \
164	do { \
165	int rcLock = RTSemRWReleaseWrite((pDbgAs)->hLock); \
166	AssertRC(rcLock); \
167	} while (0)
168
169
170	/*********************************************************************************************************************************
171	* Internal Functions *
172	*********************************************************************************************************************************/
173	static void rtDbgAsModuleUnlinkMod(PRTDBGASINT pDbgAs, PRTDBGASMOD pMod);
174	static void rtDbgAsModuleUnlinkByMap(PRTDBGASINT pDbgAs, PRTDBGASMAP pMap);
175
176
177	/**
178	* Creates an empty address space.
179	*
180	* @returns IPRT status code.
181	*
182	* @param phDbgAs Where to store the address space handle on success.
183	* @param FirstAddr The first address in the address space.
184	* @param LastAddr The last address in the address space.
185	* @param pszName The name of the address space.
186	*/
187	RTDECL(int) RTDbgAsCreate(PRTDBGAS phDbgAs, RTUINTPTR FirstAddr, RTUINTPTR LastAddr, const char *pszName)
188	{
189	/*
190	* Input validation.
191	*/
192	AssertPtrReturn(phDbgAs, VERR_INVALID_POINTER);
193	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
194	AssertReturn(FirstAddr < LastAddr, VERR_INVALID_PARAMETER);
195
196	/*
197	* Allocate memory for the instance data.
198	*/
199	size_t cchName = strlen(pszName);
200	PRTDBGASINT pDbgAs = (PRTDBGASINT)RTMemAllocVar(RT_OFFSETOF(RTDBGASINT, szName[cchName + 1]));
201	if (!pDbgAs)
202	return VERR_NO_MEMORY;
203
204	/* initialize it. */
205	pDbgAs->u32Magic = RTDBGAS_MAGIC;
206	pDbgAs->cRefs = 1;
207	pDbgAs->hLock = NIL_RTSEMRW;
208	pDbgAs->cModules = 0;
209	pDbgAs->papModules = NULL;
210	pDbgAs->ModTree = NULL;
211	pDbgAs->MapTree = NULL;
212	pDbgAs->NameSpace = NULL;
213	pDbgAs->FirstAddr = FirstAddr;
214	pDbgAs->LastAddr = LastAddr;
215	memcpy(pDbgAs->szName, pszName, cchName + 1);
216	int rc = RTSemRWCreate(&pDbgAs->hLock);
217	if (RT_SUCCESS(rc))
218	{
219	*phDbgAs = pDbgAs;
220	return VINF_SUCCESS;
221	}
222
223	pDbgAs->u32Magic = 0;
224	RTMemFree(pDbgAs);
225	return rc;
226	}
227	RT_EXPORT_SYMBOL(RTDbgAsCreate);
228
229
230	/**
231	* Variant of RTDbgAsCreate that takes a name format string.
232	*
233	* @returns IPRT status code.
234	*
235	* @param phDbgAs Where to store the address space handle on success.
236	* @param FirstAddr The first address in the address space.
237	* @param LastAddr The last address in the address space.
238	* @param pszNameFmt The name format of the address space.
239	* @param va Format arguments.
240	*/
241	RTDECL(int) RTDbgAsCreateV(PRTDBGAS phDbgAs, RTUINTPTR FirstAddr, RTUINTPTR LastAddr, const char *pszNameFmt, va_list va)
242	{
243	AssertPtrReturn(pszNameFmt, VERR_INVALID_POINTER);
244
245	char *pszName;
246	RTStrAPrintfV(&pszName, pszNameFmt, va);
247	if (!pszName)
248	return VERR_NO_MEMORY;
249
250	int rc = RTDbgAsCreate(phDbgAs, FirstAddr, LastAddr, pszName);
251
252	RTStrFree(pszName);
253	return rc;
254	}
255	RT_EXPORT_SYMBOL(RTDbgAsCreateV);
256
257
258	/**
259	* Variant of RTDbgAsCreate that takes a name format string.
260	*
261	* @returns IPRT status code.
262	*
263	* @param phDbgAs Where to store the address space handle on success.
264	* @param FirstAddr The first address in the address space.
265	* @param LastAddr The last address in the address space.
266	* @param pszNameFmt The name format of the address space.
267	* @param ... Format arguments.
268	*/
269	RTDECL(int) RTDbgAsCreateF(PRTDBGAS phDbgAs, RTUINTPTR FirstAddr, RTUINTPTR LastAddr, const char *pszNameFmt, ...)
270	{
271	va_list va;
272	va_start(va, pszNameFmt);
273	int rc = RTDbgAsCreateV(phDbgAs, FirstAddr, LastAddr, pszNameFmt, va);
274	va_end(va);
275	return rc;
276	}
277	RT_EXPORT_SYMBOL(RTDbgAsCreateF);
278
279
280	/**
281	* Callback used by RTDbgAsDestroy to free all mapping nodes.
282	*
283	* @returns 0
284	* @param pNode The map node.
285	* @param pvUser NULL.
286	*/
287	static DECLCALLBACK(int) rtDbgAsDestroyMapCallback(PAVLRUINTPTRNODECORE pNode, void *pvUser)
288	{
289	RTMemFree(pNode);
290	NOREF(pvUser);
291	return 0;
292	}
293
294
295	/**
296	* Callback used by RTDbgAsDestroy to free all name space nodes.
297	*
298	* @returns 0
299	* @param pStr The name node.
300	* @param pvUser NULL.
301	*/
302	static DECLCALLBACK(int) rtDbgAsDestroyNameCallback(PRTSTRSPACECORE pStr, void *pvUser)
303	{
304	RTMemFree(pStr);
305	NOREF(pvUser);
306	return 0;
307	}
308
309
310	/**
311	* Destroys the address space.
312	*
313	* This means unlinking all the modules it currently contains, potentially
314	* causing some or all of them to be destroyed as they are managed by
315	* reference counting.
316	*
317	* @param pDbgAs The address space instance to be destroyed.
318	*/
319	static void rtDbgAsDestroy(PRTDBGASINT pDbgAs)
320	{
321	/*
322	* Mark the address space invalid and release all the modules.
323	*/
324	ASMAtomicWriteU32(&pDbgAs->u32Magic, ~RTDBGAS_MAGIC);
325
326	RTAvlrUIntPtrDestroy(&pDbgAs->MapTree, rtDbgAsDestroyMapCallback, NULL);
327	RTStrSpaceDestroy(&pDbgAs->NameSpace, rtDbgAsDestroyNameCallback, NULL);
328
329	uint32_t i = pDbgAs->cModules;
330	while (i-- > 0)
331	{
332	PRTDBGASMOD pMod = pDbgAs->papModules[i];
333	AssertPtr(pMod);
334	if (VALID_PTR(pMod))
335	{
336	Assert(pMod->iOrdinal == i);
337	RTDbgModRelease((RTDBGMOD)pMod->Core.Key);
338	pMod->Core.Key = NIL_RTDBGMOD;
339	pMod->iOrdinal = UINT32_MAX;
340	RTMemFree(pMod);
341	}
342	pDbgAs->papModules[i] = NULL;
343	}
344	RTSemRWDestroy(pDbgAs->hLock);
345	pDbgAs->hLock = NIL_RTSEMRW;
346	RTMemFree(pDbgAs->papModules);
347	pDbgAs->papModules = NULL;
348
349	RTMemFree(pDbgAs);
350	}
351
352
353	/**
354	* Retains another reference to the address space.
355	*
356	* @returns New reference count, UINT32_MAX on invalid handle (asserted).
357	*
358	* @param hDbgAs The address space handle.
359	*
360	* @remarks Will not take any locks.
361	*/
362	RTDECL(uint32_t) RTDbgAsRetain(RTDBGAS hDbgAs)
363	{
364	PRTDBGASINT pDbgAs = hDbgAs;
365	RTDBGAS_VALID_RETURN_RC(pDbgAs, UINT32_MAX);
366	return ASMAtomicIncU32(&pDbgAs->cRefs);
367	}
368	RT_EXPORT_SYMBOL(RTDbgAsRetain);
369
370
371	/**
372	* Release a reference to the address space.
373	*
374	* When the reference count reaches zero, the address space is destroyed.
375	* That means unlinking all the modules it currently contains, potentially
376	* causing some or all of them to be destroyed as they are managed by
377	* reference counting.
378	*
379	* @returns New reference count, UINT32_MAX on invalid handle (asserted).
380	*
381	* @param hDbgAs The address space handle. The NIL handle is quietly
382	* ignored and 0 is returned.
383	*
384	* @remarks Will not take any locks.
385	*/
386	RTDECL(uint32_t) RTDbgAsRelease(RTDBGAS hDbgAs)
387	{
388	if (hDbgAs == NIL_RTDBGAS)
389	return 0;
390	PRTDBGASINT pDbgAs = hDbgAs;
391	RTDBGAS_VALID_RETURN_RC(pDbgAs, UINT32_MAX);
392
393	uint32_t cRefs = ASMAtomicDecU32(&pDbgAs->cRefs);
394	if (!cRefs)
395	rtDbgAsDestroy(pDbgAs);
396	return cRefs;
397	}
398	RT_EXPORT_SYMBOL(RTDbgAsRelease);
399
400
401	RTDECL(int) RTDbgAsLockExcl(RTDBGAS hDbgAs)
402	{
403	PRTDBGASINT pDbgAs = hDbgAs;
404	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
405	RTDBGAS_LOCK_WRITE(pDbgAs);
406	return VINF_SUCCESS;
407	}
408	RT_EXPORT_SYMBOL(RTDbgAsLockExcl);
409
410
411	RTDECL(int) RTDbgAsUnlockExcl(RTDBGAS hDbgAs)
412	{
413	PRTDBGASINT pDbgAs = hDbgAs;
414	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
415	RTDBGAS_UNLOCK_WRITE(pDbgAs);
416	return VINF_SUCCESS;
417	}
418	RT_EXPORT_SYMBOL(RTDbgAsUnlockExcl);
419
420
421	/**
422	* Gets the name of an address space.
423	*
424	* @returns read only address space name.
425	* NULL if hDbgAs is invalid.
426	*
427	* @param hDbgAs The address space handle.
428	*
429	* @remarks Will not take any locks.
430	*/
431	RTDECL(const char *) RTDbgAsName(RTDBGAS hDbgAs)
432	{
433	PRTDBGASINT pDbgAs = hDbgAs;
434	RTDBGAS_VALID_RETURN_RC(pDbgAs, NULL);
435	return pDbgAs->szName;
436	}
437	RT_EXPORT_SYMBOL(RTDbgAsName);
438
439
440	/**
441	* Gets the first address in an address space.
442	*
443	* @returns The address.
444	* 0 if hDbgAs is invalid.
445	*
446	* @param hDbgAs The address space handle.
447	*
448	* @remarks Will not take any locks.
449	*/
450	RTDECL(RTUINTPTR) RTDbgAsFirstAddr(RTDBGAS hDbgAs)
451	{
452	PRTDBGASINT pDbgAs = hDbgAs;
453	RTDBGAS_VALID_RETURN_RC(pDbgAs, 0);
454	return pDbgAs->FirstAddr;
455	}
456	RT_EXPORT_SYMBOL(RTDbgAsFirstAddr);
457
458
459	/**
460	* Gets the last address in an address space.
461	*
462	* @returns The address.
463	* 0 if hDbgAs is invalid.
464	*
465	* @param hDbgAs The address space handle.
466	*
467	* @remarks Will not take any locks.
468	*/
469	RTDECL(RTUINTPTR) RTDbgAsLastAddr(RTDBGAS hDbgAs)
470	{
471	PRTDBGASINT pDbgAs = hDbgAs;
472	RTDBGAS_VALID_RETURN_RC(pDbgAs, 0);
473	return pDbgAs->LastAddr;
474	}
475	RT_EXPORT_SYMBOL(RTDbgAsLastAddr);
476
477	/**
478	* Gets the number of modules in the address space.
479	*
480	* This can be used together with RTDbgAsModuleByIndex
481	* to enumerate the modules.
482	*
483	* @returns The number of modules.
484	*
485	* @param hDbgAs The address space handle.
486	*
487	* @remarks Will not take any locks.
488	*/
489	RTDECL(uint32_t) RTDbgAsModuleCount(RTDBGAS hDbgAs)
490	{
491	PRTDBGASINT pDbgAs = hDbgAs;
492	RTDBGAS_VALID_RETURN_RC(pDbgAs, 0);
493	return pDbgAs->cModules;
494	}
495	RT_EXPORT_SYMBOL(RTDbgAsModuleCount);
496
497
498	/**
499	* Common worker for RTDbgAsModuleLink and RTDbgAsModuleLinkSeg.
500	*
501	* @returns IPRT status code.
502	* @param pDbgAs Pointer to the address space instance data.
503	* @param hDbgMod The module to link.
504	* @param iSeg The segment to link or NIL if all.
505	* @param Addr The address we're linking it at.
506	* @param cb The size of what we're linking.
507	* @param pszName The name of the module.
508	* @param fFlags See RTDBGASLINK_FLAGS_*.
509	*
510	* @remarks The caller must have locked the address space for writing.
511	*/
512	int rtDbgAsModuleLinkCommon(PRTDBGASINT pDbgAs, RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg,
513	RTUINTPTR Addr, RTUINTPTR cb, const char *pszName, uint32_t fFlags)
514	{
515	/*
516	* Check that the requested space is undisputed.
517	*/
518	for (;;)
519	{
520	PRTDBGASMAP pAdjMod = (PRTDBGASMAP)RTAvlrUIntPtrGetBestFit(&pDbgAs->MapTree, Addr, false /* fAbove */);
521	if ( pAdjMod
522	&& pAdjMod->Core.KeyLast >= Addr)
523	{
524	if (!(fFlags & RTDBGASLINK_FLAGS_REPLACE))
525	return VERR_ADDRESS_CONFLICT;
526	rtDbgAsModuleUnlinkByMap(pDbgAs, pAdjMod);
527	continue;
528	}
529	pAdjMod = (PRTDBGASMAP)RTAvlrUIntPtrGetBestFit(&pDbgAs->MapTree, Addr, true /* fAbove */);
530	if ( pAdjMod
531	&& pAdjMod->Core.Key <= Addr + cb - 1)
532	{
533	if (!(fFlags & RTDBGASLINK_FLAGS_REPLACE))
534	return VERR_ADDRESS_CONFLICT;
535	rtDbgAsModuleUnlinkByMap(pDbgAs, pAdjMod);
536	continue;
537	}
538	break;
539	}
540
541	/*
542	* First, create or find the module table entry.
543	*/
544	PRTDBGASMOD pMod = (PRTDBGASMOD)RTAvlPVGet(&pDbgAs->ModTree, hDbgMod);
545	if (!pMod)
546	{
547	/*
548	* Ok, we need a new entry. Grow the table if necessary.
549	*/
550	if (!(pDbgAs->cModules % 32))
551	{
552	void pvNew = RTMemRealloc(pDbgAs->papModules, sizeof(pDbgAs->papModules[0]) (pDbgAs->cModules + 32));
553	if (!pvNew)
554	return VERR_NO_MEMORY;
555	pDbgAs->papModules = (PRTDBGASMOD *)pvNew;
556	}
557	pMod = (PRTDBGASMOD)RTMemAlloc(sizeof(*pMod));
558	if (!pMod)
559	return VERR_NO_MEMORY;
560	pMod->Core.Key = hDbgMod;
561	pMod->pMapHead = NULL;
562	pMod->pNextName = NULL;
563	if (RT_UNLIKELY(!RTAvlPVInsert(&pDbgAs->ModTree, &pMod->Core)))
564	{
565	AssertFailed();
566	pDbgAs->cModules--;
567	RTMemFree(pMod);
568	return VERR_INTERNAL_ERROR;
569	}
570	pMod->iOrdinal = pDbgAs->cModules;
571	pDbgAs->papModules[pDbgAs->cModules] = pMod;
572	pDbgAs->cModules++;
573	RTDbgModRetain(hDbgMod);
574
575	/*
576	* Add it to the name space.
577	*/
578	PRTDBGASNAME pName = (PRTDBGASNAME)RTStrSpaceGet(&pDbgAs->NameSpace, pszName);
579	if (!pName)
580	{
581	size_t cchName = strlen(pszName);
582	pName = (PRTDBGASNAME)RTMemAlloc(sizeof(*pName) + cchName + 1);
583	if (!pName)
584	{
585	RTDbgModRelease(hDbgMod);
586	pDbgAs->cModules--;
587	RTAvlPVRemove(&pDbgAs->ModTree, hDbgMod);
588	RTMemFree(pMod);
589	return VERR_NO_MEMORY;
590	}
591	pName->StrCore.cchString = cchName;
592	pName->StrCore.pszString = (char *)memcpy(pName + 1, pszName, cchName + 1);
593	pName->pHead = pMod;
594	if (!RTStrSpaceInsert(&pDbgAs->NameSpace, &pName->StrCore))
595	AssertFailed();
596	}
597	else
598	{
599	/* quick, but unfair. */
600	pMod->pNextName = pName->pHead;
601	pName->pHead = pMod;
602	}
603	}
604
605	/*
606	* Create a mapping node.
607	*/
608	int rc;
609	PRTDBGASMAP pMap = (PRTDBGASMAP)RTMemAlloc(sizeof(*pMap));
610	if (pMap)
611	{
612	pMap->Core.Key = Addr;
613	pMap->Core.KeyLast = Addr + cb - 1;
614	pMap->pMod = pMod;
615	pMap->iSeg = iSeg;
616	if (RTAvlrUIntPtrInsert(&pDbgAs->MapTree, &pMap->Core))
617	{
618	PRTDBGASMAP *pp = &pMod->pMapHead;
619	while (pp && (pp)->Core.Key < Addr)
620	pp = &(*pp)->pNext;
621	pMap->pNext = *pp;
622	*pp = pMap;
623	return VINF_SUCCESS;
624	}
625
626	AssertFailed();
627	RTMemFree(pMap);
628	rc = VERR_ADDRESS_CONFLICT;
629	}
630	else
631	rc = VERR_NO_MEMORY;
632
633	/*
634	* Unlink the module if this was the only mapping.
635	*/
636	if (!pMod->pMapHead)
637	rtDbgAsModuleUnlinkMod(pDbgAs, pMod);
638	return rc;
639	}
640
641
642	/**
643	* Links a module into the address space at the give address.
644	*
645	* The size of the mapping is determined using RTDbgModImageSize().
646	*
647	* @returns IPRT status code.
648	* @retval VERR_OUT_OF_RANGE if the specified address will put the module
649	* outside the address space.
650	* @retval VERR_ADDRESS_CONFLICT if the mapping clashes with existing mappings.
651	*
652	* @param hDbgAs The address space handle.
653	* @param hDbgMod The module handle of the module to be linked in.
654	* @param ImageAddr The address to link the module at.
655	* @param fFlags See RTDBGASLINK_FLAGS_*.
656	*/
657	RTDECL(int) RTDbgAsModuleLink(RTDBGAS hDbgAs, RTDBGMOD hDbgMod, RTUINTPTR ImageAddr, uint32_t fFlags)
658	{
659	/*
660	* Validate input.
661	*/
662	PRTDBGASINT pDbgAs = hDbgAs;
663	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
664	const char *pszName = RTDbgModName(hDbgMod);
665	if (!pszName)
666	return VERR_INVALID_HANDLE;
667	RTUINTPTR cb = RTDbgModImageSize(hDbgMod);
668	if (!cb)
669	return VERR_OUT_OF_RANGE;
670	if ( ImageAddr < pDbgAs->FirstAddr
671	\|\| ImageAddr > pDbgAs->LastAddr
672	\|\| ImageAddr + cb - 1 < pDbgAs->FirstAddr
673	\|\| ImageAddr + cb - 1 > pDbgAs->LastAddr
674	\|\| ImageAddr + cb - 1 < ImageAddr)
675	return VERR_OUT_OF_RANGE;
676	AssertReturn(!(fFlags & ~RTDBGASLINK_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
677
678	/*
679	* Invoke worker common with RTDbgAsModuleLinkSeg.
680	*/
681	RTDBGAS_LOCK_WRITE(pDbgAs);
682	int rc = rtDbgAsModuleLinkCommon(pDbgAs, hDbgMod, NIL_RTDBGSEGIDX, ImageAddr, cb, pszName, fFlags);
683	RTDBGAS_UNLOCK_WRITE(pDbgAs);
684	return rc;
685	}
686	RT_EXPORT_SYMBOL(RTDbgAsModuleLink);
687
688
689	/**
690	* Links a segment into the address space at the give address.
691	*
692	* The size of the mapping is determined using RTDbgModSegmentSize().
693	*
694	* @returns IPRT status code.
695	* @retval VERR_OUT_OF_RANGE if the specified address will put the module
696	* outside the address space.
697	* @retval VERR_ADDRESS_CONFLICT if the mapping clashes with existing mappings.
698	*
699	* @param hDbgAs The address space handle.
700	* @param hDbgMod The module handle.
701	* @param iSeg The segment number (0-based) of the segment to be
702	* linked in.
703	* @param SegAddr The address to link the segment at.
704	* @param fFlags See RTDBGASLINK_FLAGS_*.
705	*/
706	RTDECL(int) RTDbgAsModuleLinkSeg(RTDBGAS hDbgAs, RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg, RTUINTPTR SegAddr, uint32_t fFlags)
707	{
708	/*
709	* Validate input.
710	*/
711	PRTDBGASINT pDbgAs = hDbgAs;
712	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
713	const char *pszName = RTDbgModName(hDbgMod);
714	if (!pszName)
715	return VERR_INVALID_HANDLE;
716	RTUINTPTR cb = RTDbgModSegmentSize(hDbgMod, iSeg);
717	if (!cb)
718	return VERR_OUT_OF_RANGE;
719	if ( SegAddr < pDbgAs->FirstAddr
720	\|\| SegAddr > pDbgAs->LastAddr
721	\|\| SegAddr + cb - 1 < pDbgAs->FirstAddr
722	\|\| SegAddr + cb - 1 > pDbgAs->LastAddr
723	\|\| SegAddr + cb - 1 < SegAddr)
724	return VERR_OUT_OF_RANGE;
725	AssertReturn(!(fFlags & ~RTDBGASLINK_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
726
727	/*
728	* Invoke worker common with RTDbgAsModuleLinkSeg.
729	*/
730	RTDBGAS_LOCK_WRITE(pDbgAs);
731	int rc = rtDbgAsModuleLinkCommon(pDbgAs, hDbgMod, iSeg, SegAddr, cb, pszName, fFlags);
732	RTDBGAS_UNLOCK_WRITE(pDbgAs);
733	return rc;
734	}
735	RT_EXPORT_SYMBOL(RTDbgAsModuleLinkSeg);
736
737
738	/**
739	* Worker for RTDbgAsModuleUnlink, RTDbgAsModuleUnlinkByAddr and rtDbgAsModuleLinkCommon.
740	*
741	* @param pDbgAs Pointer to the address space instance data.
742	* @param pMod The module to unlink.
743	*
744	* @remarks The caller must have locked the address space for writing.
745	*/
746	static void rtDbgAsModuleUnlinkMod(PRTDBGASINT pDbgAs, PRTDBGASMOD pMod)
747	{
748	Assert(!pMod->pMapHead);
749
750	/*
751	* Unlink it from the name.
752	*/
753	const char *pszName = RTDbgModName((RTDBGMOD)pMod->Core.Key);
754	PRTDBGASNAME pName = (PRTDBGASNAME)RTStrSpaceGet(&pDbgAs->NameSpace, pszName);
755	AssertReturnVoid(pName);
756
757	if (pName->pHead == pMod)
758	pName->pHead = pMod->pNextName;
759	else
760	for (PRTDBGASMOD pCur = pName->pHead; pCur; pCur = pCur->pNextName)
761	if (pCur->pNextName == pMod)
762	{
763	pCur->pNextName = pMod->pNextName;
764	break;
765	}
766	pMod->pNextName = NULL;
767
768	/*
769	* Free the name if this was the last reference to it.
770	*/
771	if (!pName->pHead)
772	{
773	pName = (PRTDBGASNAME)RTStrSpaceRemove(&pDbgAs->NameSpace, pName->StrCore.pszString);
774	Assert(pName);
775	RTMemFree(pName);
776	}
777
778	/*
779	* Remove it from the module handle tree.
780	*/
781	PAVLPVNODECORE pNode = RTAvlPVRemove(&pDbgAs->ModTree, pMod->Core.Key);
782	Assert(pNode == &pMod->Core); NOREF(pNode);
783
784	/*
785	* Remove it from the module table by replacing it by the last entry.
786	*/
787	pDbgAs->cModules--;
788	uint32_t iMod = pMod->iOrdinal;
789	Assert(iMod <= pDbgAs->cModules);
790	if (iMod != pDbgAs->cModules)
791	{
792	PRTDBGASMOD pTailMod = pDbgAs->papModules[pDbgAs->cModules];
793	pTailMod->iOrdinal = iMod;
794	pDbgAs->papModules[iMod] = pTailMod;
795	}
796	pMod->iOrdinal = UINT32_MAX;
797
798	/*
799	* Free it.
800	*/
801	RTMemFree(pMod);
802	}
803
804
805	/**
806	* Worker for RTDbgAsModuleUnlink and RTDbgAsModuleUnlinkByAddr.
807	*
808	* @param pDbgAs Pointer to the address space instance data.
809	* @param pMap The map to unlink and free.
810	*
811	* @remarks The caller must have locked the address space for writing.
812	*/
813	static void rtDbgAsModuleUnlinkMap(PRTDBGASINT pDbgAs, PRTDBGASMAP pMap)
814	{
815	/* remove from the tree */
816	PAVLRUINTPTRNODECORE pNode = RTAvlrUIntPtrRemove(&pDbgAs->MapTree, pMap->Core.Key);
817	Assert(pNode == &pMap->Core); NOREF(pNode);
818
819	/* unlink */
820	PRTDBGASMOD pMod = pMap->pMod;
821	if (pMod->pMapHead == pMap)
822	pMod->pMapHead = pMap->pNext;
823	else
824	{
825	bool fFound = false;
826	for (PRTDBGASMAP pCur = pMod->pMapHead; pCur; pCur = pCur->pNext)
827	if (pCur->pNext == pMap)
828	{
829	pCur->pNext = pMap->pNext;
830	fFound = true;
831	break;
832	}
833	Assert(fFound);
834	}
835
836	/* free it */
837	pMap->Core.Key = pMap->Core.KeyLast = 0;
838	pMap->pNext = NULL;
839	pMap->pMod = NULL;
840	RTMemFree(pMap);
841	}
842
843
844	/**
845	* Worker for RTDbgAsModuleUnlinkByAddr and rtDbgAsModuleLinkCommon that
846	* unlinks a single mapping and releases the module if it's the last one.
847	*
848	* @param pDbgAs The address space instance.
849	* @param pMap The mapping to unlink.
850	*
851	* @remarks The caller must have locked the address space for writing.
852	*/
853	static void rtDbgAsModuleUnlinkByMap(PRTDBGASINT pDbgAs, PRTDBGASMAP pMap)
854	{
855	/*
856	* Unlink it from the address space.
857	* Unlink the module as well if it's the last mapping it has.
858	*/
859	PRTDBGASMOD pMod = pMap->pMod;
860	rtDbgAsModuleUnlinkMap(pDbgAs, pMap);
861	if (!pMod->pMapHead)
862	rtDbgAsModuleUnlinkMod(pDbgAs, pMod);
863	}
864
865
866	/**
867	* Unlinks all the mappings of a module from the address space.
868	*
869	* @returns IPRT status code.
870	* @retval VERR_NOT_FOUND if the module wasn't found.
871	*
872	* @param hDbgAs The address space handle.
873	* @param hDbgMod The module handle of the module to be unlinked.
874	*/
875	RTDECL(int) RTDbgAsModuleUnlink(RTDBGAS hDbgAs, RTDBGMOD hDbgMod)
876	{
877	/*
878	* Validate input.
879	*/
880	PRTDBGASINT pDbgAs = hDbgAs;
881	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
882	if (hDbgMod == NIL_RTDBGMOD)
883	return VINF_SUCCESS;
884
885	RTDBGAS_LOCK_WRITE(pDbgAs);
886	PRTDBGASMOD pMod = (PRTDBGASMOD)RTAvlPVGet(&pDbgAs->ModTree, hDbgMod);
887	if (!pMod)
888	{
889	RTDBGAS_UNLOCK_WRITE(pDbgAs);
890	return VERR_NOT_FOUND;
891	}
892
893	/*
894	* Unmap all everything and release the module.
895	*/
896	while (pMod->pMapHead)
897	rtDbgAsModuleUnlinkMap(pDbgAs, pMod->pMapHead);
898	rtDbgAsModuleUnlinkMod(pDbgAs, pMod);
899
900	RTDBGAS_UNLOCK_WRITE(pDbgAs);
901	return VINF_SUCCESS;
902	}
903	RT_EXPORT_SYMBOL(RTDbgAsModuleUnlink);
904
905
906	/**
907	* Unlinks the mapping at the specified address.
908	*
909	* @returns IPRT status code.
910	* @retval VERR_NOT_FOUND if no module or segment is mapped at that address.
911	*
912	* @param hDbgAs The address space handle.
913	* @param Addr The address within the mapping to be unlinked.
914	*/
915	RTDECL(int) RTDbgAsModuleUnlinkByAddr(RTDBGAS hDbgAs, RTUINTPTR Addr)
916	{
917	/*
918	* Validate input.
919	*/
920	PRTDBGASINT pDbgAs = hDbgAs;
921	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
922
923	RTDBGAS_LOCK_WRITE(pDbgAs);
924	PRTDBGASMAP pMap = (PRTDBGASMAP)RTAvlrUIntPtrRangeGet(&pDbgAs->MapTree, Addr);
925	if (!pMap)
926	{
927	RTDBGAS_UNLOCK_WRITE(pDbgAs);
928	return VERR_NOT_FOUND;
929	}
930
931	/*
932	* Hand it to
933	*/
934	rtDbgAsModuleUnlinkByMap(pDbgAs, pMap);
935
936	RTDBGAS_UNLOCK_WRITE(pDbgAs);
937	return VINF_SUCCESS;
938	}
939	RT_EXPORT_SYMBOL(RTDbgAsModuleUnlinkByAddr);
940
941
942	/**
943	* Get a the handle of a module in the address space by is index.
944	*
945	* @returns A retained handle to the specified module. The caller must release
946	* the returned reference.
947	* NIL_RTDBGMOD if invalid index or handle.
948	*
949	* @param hDbgAs The address space handle.
950	* @param iModule The index of the module to get.
951	*
952	* @remarks The module indexes may change after calls to RTDbgAsModuleLink,
953	* RTDbgAsModuleLinkSeg, RTDbgAsModuleUnlink and
954	* RTDbgAsModuleUnlinkByAddr.
955	*/
956	RTDECL(RTDBGMOD) RTDbgAsModuleByIndex(RTDBGAS hDbgAs, uint32_t iModule)
957	{
958	/*
959	* Validate input.
960	*/
961	PRTDBGASINT pDbgAs = hDbgAs;
962	RTDBGAS_VALID_RETURN_RC(pDbgAs, NIL_RTDBGMOD);
963
964	RTDBGAS_LOCK_READ(pDbgAs);
965	if (iModule >= pDbgAs->cModules)
966	{
967	RTDBGAS_UNLOCK_READ(pDbgAs);
968	return NIL_RTDBGMOD;
969	}
970
971	/*
972	* Get, retain and return it.
973	*/
974	RTDBGMOD hMod = (RTDBGMOD)pDbgAs->papModules[iModule]->Core.Key;
975	RTDbgModRetain(hMod);
976
977	RTDBGAS_UNLOCK_READ(pDbgAs);
978	return hMod;
979	}
980	RT_EXPORT_SYMBOL(RTDbgAsModuleByIndex);
981
982
983	/**
984	* Queries mapping module information by handle.
985	*
986	* @returns IPRT status code.
987	* @retval VERR_NOT_FOUND if no mapping was found at the specified address.
988	*
989	* @param hDbgAs The address space handle.
990	* @param Addr Address within the mapping of the module or segment.
991	* @param phMod Where to the return the retained module handle.
992	* Optional.
993	* @param pAddr Where to return the base address of the mapping.
994	* Optional.
995	* @param piSeg Where to return the segment index. This is set to
996	* NIL if the entire module is mapped as a single
997	* mapping. Optional.
998	*/
999	RTDECL(int) RTDbgAsModuleByAddr(RTDBGAS hDbgAs, RTUINTPTR Addr, PRTDBGMOD phMod, PRTUINTPTR pAddr, PRTDBGSEGIDX piSeg)
1000	{
1001	/*
1002	* Validate input.
1003	*/
1004	PRTDBGASINT pDbgAs = hDbgAs;
1005	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
1006
1007	RTDBGAS_LOCK_READ(pDbgAs);
1008	PRTDBGASMAP pMap = (PRTDBGASMAP)RTAvlrUIntPtrRangeGet(&pDbgAs->MapTree, Addr);
1009	if (!pMap)
1010	{
1011	RTDBGAS_UNLOCK_READ(pDbgAs);
1012	return VERR_NOT_FOUND;
1013	}
1014
1015	/*
1016	* Set up the return values.
1017	*/
1018	if (phMod)
1019	{
1020	RTDBGMOD hMod = (RTDBGMOD)pMap->pMod->Core.Key;
1021	RTDbgModRetain(hMod);
1022	*phMod = hMod;
1023	}
1024	if (pAddr)
1025	*pAddr = pMap->Core.Key;
1026	if (piSeg)
1027	*piSeg = pMap->iSeg;
1028
1029	RTDBGAS_UNLOCK_READ(pDbgAs);
1030	return VINF_SUCCESS;
1031	}
1032	RT_EXPORT_SYMBOL(RTDbgAsModuleByAddr);
1033
1034
1035	/**
1036	* Queries mapping module information by name.
1037	*
1038	* @returns IPRT status code.
1039	* @retval VERR_NOT_FOUND if no mapping was found at the specified address.
1040	* @retval VERR_OUT_OF_RANGE if the name index was out of range.
1041	*
1042	* @param hDbgAs The address space handle.
1043	* @param pszName The module name.
1044	* @param iName There can be more than one module by the same name
1045	* in an address space. This argument indicates which
1046	* is meant. (0 based)
1047	* @param phMod Where to the return the retained module handle.
1048	*/
1049	RTDECL(int) RTDbgAsModuleByName(RTDBGAS hDbgAs, const char *pszName, uint32_t iName, PRTDBGMOD phMod)
1050	{
1051	/*
1052	* Validate input.
1053	*/
1054	PRTDBGASINT pDbgAs = hDbgAs;
1055	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
1056	AssertPtrReturn(phMod, VERR_INVALID_POINTER);
1057
1058	RTDBGAS_LOCK_READ(pDbgAs);
1059	PRTDBGASNAME pName = (PRTDBGASNAME)RTStrSpaceGet(&pDbgAs->NameSpace, pszName);
1060	if (!pName)
1061	{
1062	RTDBGAS_UNLOCK_READ(pDbgAs);
1063	return VERR_NOT_FOUND;
1064	}
1065
1066	PRTDBGASMOD pMod = pName->pHead;
1067	while (iName-- > 0)
1068	{
1069	pMod = pMod->pNextName;
1070	if (!pMod)
1071	{
1072	RTDBGAS_UNLOCK_READ(pDbgAs);
1073	return VERR_OUT_OF_RANGE;
1074	}
1075	}
1076
1077	/*
1078	* Get, retain and return it.
1079	*/
1080	RTDBGMOD hMod = (RTDBGMOD)pMod->Core.Key;
1081	RTDbgModRetain(hMod);
1082	*phMod = hMod;
1083
1084	RTDBGAS_UNLOCK_READ(pDbgAs);
1085	return VINF_SUCCESS;
1086	}
1087	RT_EXPORT_SYMBOL(RTDbgAsModuleByName);
1088
1089
1090	/**
1091	* Queries mapping information for a module given by index.
1092	*
1093	* @returns IRPT status code.
1094	* @retval VERR_INVALID_HANDLE if hDbgAs is invalid.
1095	* @retval VERR_OUT_OF_RANGE if the name index was out of range.
1096	* @retval VINF_BUFFER_OVERFLOW if the array is too small and the returned
1097	* information is incomplete.
1098	*
1099	* @param hDbgAs The address space handle.
1100	* @param iModule The index of the module to get.
1101	* @param paMappings Where to return the mapping information. The buffer
1102	* size is given by *pcMappings.
1103	* @param pcMappings IN: Size of the paMappings array. OUT: The number of
1104	* entries returned.
1105	* @param fFlags Flags for reserved for future use. MBZ.
1106	*
1107	* @remarks See remarks for RTDbgAsModuleByIndex regarding the volatility of the
1108	* iModule parameter.
1109	*/
1110	RTDECL(int) RTDbgAsModuleQueryMapByIndex(RTDBGAS hDbgAs, uint32_t iModule, PRTDBGASMAPINFO paMappings, uint32_t *pcMappings, uint32_t fFlags)
1111	{
1112	/*
1113	* Validate input.
1114	*/
1115	uint32_t const cMappings = *pcMappings;
1116	PRTDBGASINT pDbgAs = hDbgAs;
1117	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
1118	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
1119
1120	RTDBGAS_LOCK_READ(pDbgAs);
1121	if (iModule >= pDbgAs->cModules)
1122	{
1123	RTDBGAS_UNLOCK_READ(pDbgAs);
1124	return VERR_OUT_OF_RANGE;
1125	}
1126
1127	/*
1128	* Copy the mapping information about the module.
1129	*/
1130	int rc = VINF_SUCCESS;
1131	PRTDBGASMAP pMap = pDbgAs->papModules[iModule]->pMapHead;
1132	uint32_t cMaps = 0;
1133	while (pMap)
1134	{
1135	if (cMaps >= cMappings)
1136	{
1137	rc = VINF_BUFFER_OVERFLOW;
1138	break;
1139	}
1140	paMappings[cMaps].Address = pMap->Core.Key;
1141	paMappings[cMaps].iSeg = pMap->iSeg;
1142	cMaps++;
1143	pMap = pMap->pNext;
1144	}
1145
1146	RTDBGAS_UNLOCK_READ(pDbgAs);
1147	*pcMappings = cMaps;
1148	return rc;
1149	}
1150	RT_EXPORT_SYMBOL(RTDbgAsModuleQueryMapByIndex);
1151
1152
1153	/**
1154	* Internal worker that looks up and retains a module.
1155	*
1156	* @returns Module handle, NIL_RTDBGMOD if not found.
1157	* @param pDbgAs The address space instance data.
1158	* @param Addr Address within the module.
1159	* @param piSeg where to return the segment index.
1160	* @param poffSeg Where to return the segment offset.
1161	* @param pMapAddr The mapping address (RTDBGASMAP::Core.Key).
1162	*/
1163	DECLINLINE(RTDBGMOD) rtDbgAsModuleByAddr(PRTDBGASINT pDbgAs, RTUINTPTR Addr, PRTDBGSEGIDX piSeg, PRTUINTPTR poffSeg, PRTUINTPTR pMapAddr)
1164	{
1165	RTDBGMOD hMod = NIL_RTDBGMOD;
1166
1167	RTDBGAS_LOCK_READ(pDbgAs);
1168	PRTDBGASMAP pMap = (PRTDBGASMAP)RTAvlrUIntPtrRangeGet(&pDbgAs->MapTree, Addr);
1169	if (pMap)
1170	{
1171	hMod = (RTDBGMOD)pMap->pMod->Core.Key;
1172	RTDbgModRetain(hMod);
1173	*piSeg = pMap->iSeg != NIL_RTDBGSEGIDX ? pMap->iSeg : RTDBGSEGIDX_RVA;
1174	*poffSeg = Addr - pMap->Core.Key;
1175	if (pMapAddr)
1176	*pMapAddr = pMap->Core.Key;
1177	}
1178	RTDBGAS_UNLOCK_READ(pDbgAs);
1179
1180	return hMod;
1181	}
1182
1183
1184	/**
1185	* Adjusts the address to correspond to the mapping of the module/segment.
1186	*
1187	* @param pAddr The address to adjust (in/out).
1188	* @param iSeg The related segment.
1189	* @param hDbgMod The module handle.
1190	* @param MapAddr The mapping address.
1191	* @param iMapSeg The segment that's mapped, NIL_RTDBGSEGIDX or
1192	* RTDBGSEGIDX_RVA if the whole module is mapped here.
1193	*/
1194	DECLINLINE(void) rtDbgAsAdjustAddressByMapping(PRTUINTPTR pAddr, RTDBGSEGIDX iSeg,
1195	RTDBGMOD hDbgMod, RTUINTPTR MapAddr, RTDBGSEGIDX iMapSeg)
1196	{
1197	if (iSeg == RTDBGSEGIDX_ABS)
1198	return;
1199
1200	if (iSeg == RTDBGSEGIDX_RVA)
1201	{
1202	if ( iMapSeg == RTDBGSEGIDX_RVA
1203	\|\| iMapSeg == NIL_RTDBGSEGIDX)
1204	*pAddr += MapAddr;
1205	else
1206	{
1207	RTUINTPTR SegRva = RTDbgModSegmentRva(hDbgMod, iMapSeg);
1208	AssertReturnVoid(SegRva != RTUINTPTR_MAX);
1209	AssertMsg(SegRva <= pAddr, ("SegRva=%RTptr pAddr=%RTptr\n", SegRva, *pAddr));
1210	*pAddr += MapAddr - SegRva;
1211	}
1212	}
1213	else
1214	{
1215	if ( iMapSeg != RTDBGSEGIDX_RVA
1216	&& iMapSeg != NIL_RTDBGSEGIDX)
1217	{
1218	Assert(iMapSeg == iSeg);
1219	*pAddr += MapAddr;
1220	}
1221	else
1222	{
1223	RTUINTPTR SegRva = RTDbgModSegmentRva(hDbgMod, iSeg);
1224	AssertReturnVoid(SegRva != RTUINTPTR_MAX);
1225	*pAddr += MapAddr + SegRva;
1226	}
1227	}
1228	}
1229
1230
1231	/**
1232	* Adjusts the symbol value to correspond to the mapping of the module/segment.
1233	*
1234	* @param pSymbol The returned symbol info.
1235	* @param hDbgMod The module handle.
1236	* @param MapAddr The mapping address.
1237	* @param iMapSeg The segment that's mapped, NIL_RTDBGSEGIDX if the
1238	* whole module is mapped here.
1239	*/
1240	DECLINLINE(void) rtDbgAsAdjustSymbolValue(PRTDBGSYMBOL pSymbol, RTDBGMOD hDbgMod, RTUINTPTR MapAddr, RTDBGSEGIDX iMapSeg)
1241	{
1242	Assert(pSymbol->iSeg != NIL_RTDBGSEGIDX);
1243	Assert(pSymbol->offSeg == pSymbol->Value);
1244	rtDbgAsAdjustAddressByMapping(&pSymbol->Value, pSymbol->iSeg, hDbgMod, MapAddr, iMapSeg);
1245	}
1246
1247
1248	/**
1249	* Adjusts the line number address to correspond to the mapping of the module/segment.
1250	*
1251	* @param pLine The returned line number info.
1252	* @param hDbgMod The module handle.
1253	* @param MapAddr The mapping address.
1254	* @param iMapSeg The segment that's mapped, NIL_RTDBGSEGIDX if the
1255	* whole module is mapped here.
1256	*/
1257	DECLINLINE(void) rtDbgAsAdjustLineAddress(PRTDBGLINE pLine, RTDBGMOD hDbgMod, RTUINTPTR MapAddr, RTDBGSEGIDX iMapSeg)
1258	{
1259	Assert(pLine->iSeg != NIL_RTDBGSEGIDX);
1260	Assert(pLine->offSeg == pLine->Address);
1261	rtDbgAsAdjustAddressByMapping(&pLine->Address, pLine->iSeg, hDbgMod, MapAddr, iMapSeg);
1262	}
1263
1264
1265	/**
1266	* Adds a symbol to a module in the address space.
1267	*
1268	* @returns IPRT status code. See RTDbgModSymbolAdd for more specific ones.
1269	* @retval VERR_INVALID_HANDLE if hDbgAs is invalid.
1270	* @retval VERR_NOT_FOUND if no module was found at the specified address.
1271	* @retval VERR_NOT_SUPPORTED if the module interpret doesn't support adding
1272	* custom symbols.
1273	*
1274	* @param hDbgAs The address space handle.
1275	* @param pszSymbol The symbol name.
1276	* @param Addr The address of the symbol.
1277	* @param cb The size of the symbol.
1278	* @param fFlags Symbol flags.
1279	* @param piOrdinal Where to return the symbol ordinal on success. If
1280	* the interpreter doesn't do ordinals, this will be set to
1281	* UINT32_MAX. Optional
1282	*/
1283	RTDECL(int) RTDbgAsSymbolAdd(RTDBGAS hDbgAs, const char pszSymbol, RTUINTPTR Addr, RTUINTPTR cb, uint32_t fFlags, uint32_t piOrdinal)
1284	{
1285	/*
1286	* Validate input and resolve the address.
1287	*/
1288	PRTDBGASINT pDbgAs = hDbgAs;
1289	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
1290
1291	RTDBGSEGIDX iSeg = NIL_RTDBGSEGIDX; /* shut up gcc */
1292	RTUINTPTR offSeg = 0;
1293	RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg, NULL);
1294	if (hMod == NIL_RTDBGMOD)
1295	return VERR_NOT_FOUND;
1296
1297	/*
1298	* Forward the call.
1299	*/
1300	int rc = RTDbgModSymbolAdd(hMod, pszSymbol, iSeg, offSeg, cb, fFlags, piOrdinal);
1301	RTDbgModRelease(hMod);
1302	return rc;
1303	}
1304	RT_EXPORT_SYMBOL(RTDbgAsSymbolAdd);
1305
1306
1307	/**
1308	* Creates a snapshot of the module table on the temporary heap.
1309	*
1310	* The caller must release all the module handles before freeing the table
1311	* using RTMemTmpFree.
1312	*
1313	* @returns Module table snaphot.
1314	* @param pDbgAs The address space instance data.
1315	* @param pcModules Where to return the number of modules.
1316	*/
1317	static PRTDBGMOD rtDbgAsSnapshotModuleTable(PRTDBGASINT pDbgAs, uint32_t *pcModules)
1318	{
1319	RTDBGAS_LOCK_READ(pDbgAs);
1320
1321	uint32_t iMod = *pcModules = pDbgAs->cModules;
1322	PRTDBGMOD pahModules = (PRTDBGMOD)RTMemTmpAlloc(sizeof(pahModules[0]) * RT_MAX(iMod, 1));
1323	if (pahModules)
1324	{
1325	while (iMod-- > 0)
1326	{
1327	RTDBGMOD hMod = (RTDBGMOD)pDbgAs->papModules[iMod]->Core.Key;
1328	pahModules[iMod] = hMod;
1329	RTDbgModRetain(hMod);
1330	}
1331	}
1332
1333	RTDBGAS_UNLOCK_READ(pDbgAs);
1334	return pahModules;
1335	}
1336
1337
1338	/**
1339	* Query a symbol by address.
1340	*
1341	* @returns IPRT status code. See RTDbgModSymbolAddr for more specific ones.
1342	* @retval VERR_INVALID_HANDLE if hDbgAs is invalid.
1343	* @retval VERR_NOT_FOUND if the address couldn't be mapped to a module.
1344	* @retval VERR_INVALID_PARAMETER if incorrect flags.
1345	*
1346	* @param hDbgAs The address space handle.
1347	* @param Addr The address which closest symbol is requested.
1348	* @param fFlags Symbol search flags, see RTDBGSYMADDR_FLAGS_XXX.
1349	* @param poffDisp Where to return the distance between the symbol and
1350	* address. Optional.
1351	* @param pSymbol Where to return the symbol info.
1352	* @param phMod Where to return the module handle. Optional.
1353	*/
1354	RTDECL(int) RTDbgAsSymbolByAddr(RTDBGAS hDbgAs, RTUINTPTR Addr, uint32_t fFlags,
1355	PRTINTPTR poffDisp, PRTDBGSYMBOL pSymbol, PRTDBGMOD phMod)
1356	{
1357	/*
1358	* Validate input and resolve the address.
1359	*/
1360	PRTDBGASINT pDbgAs = hDbgAs;
1361	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
1362	if (phMod)
1363	*phMod = NIL_RTDBGMOD;
1364
1365	RTDBGSEGIDX iSeg = NIL_RTDBGSEGIDX; /* shut up gcc */
1366	RTUINTPTR offSeg = 0;
1367	RTUINTPTR MapAddr = 0;
1368	RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg, &MapAddr);
1369	if (hMod == NIL_RTDBGMOD)
1370	{
1371	/*
1372	* Check for absolute symbols. Requires iterating all modules.
1373	*/
1374	uint32_t cModules;
1375	PRTDBGMOD pahModules = rtDbgAsSnapshotModuleTable(pDbgAs, &cModules);
1376	if (!pahModules)
1377	return VERR_NO_TMP_MEMORY;
1378
1379	int rc;
1380	RTINTPTR offBestDisp = RTINTPTR_MAX;
1381	uint32_t iBest = UINT32_MAX;
1382	for (uint32_t i = 0; i < cModules; i++)
1383	{
1384	RTINTPTR offDisp;
1385	rc = RTDbgModSymbolByAddr(pahModules[i], RTDBGSEGIDX_ABS, Addr, fFlags, &offDisp, pSymbol);
1386	if (RT_SUCCESS(rc) && RT_ABS(offDisp) < offBestDisp)
1387	{
1388	offBestDisp = RT_ABS(offDisp);
1389	iBest = i;
1390	}
1391	}
1392
1393	if (iBest == UINT32_MAX)
1394	rc = VERR_NOT_FOUND;
1395	else
1396	{
1397	hMod = pahModules[iBest];
1398	rc = RTDbgModSymbolByAddr(hMod, RTDBGSEGIDX_ABS, Addr, fFlags, poffDisp, pSymbol);
1399	if (RT_SUCCESS(rc))
1400	{
1401	rtDbgAsAdjustSymbolValue(pSymbol, hMod, MapAddr, iSeg);
1402	if (phMod)
1403	RTDbgModRetain(*phMod = hMod);
1404	}
1405	}
1406
1407	for (uint32_t i = 0; i < cModules; i++)
1408	RTDbgModRelease(pahModules[i]);
1409	RTMemTmpFree(pahModules);
1410	return rc;
1411	}
1412
1413	/*
1414	* Forward the call.
1415	*/
1416	int rc = RTDbgModSymbolByAddr(hMod, iSeg, offSeg, fFlags, poffDisp, pSymbol);
1417	if (RT_SUCCESS(rc))
1418	rtDbgAsAdjustSymbolValue(pSymbol, hMod, MapAddr, iSeg);
1419	if (phMod)
1420	*phMod = hMod;
1421	else
1422	RTDbgModRelease(hMod);
1423	return rc;
1424	}
1425	RT_EXPORT_SYMBOL(RTDbgAsSymbolByAddr);
1426
1427
1428	/**
1429	* Query a symbol by address.
1430	*
1431	* @returns IPRT status code. See RTDbgModSymbolAddrA for more specific ones.
1432	* @retval VERR_INVALID_HANDLE if hDbgAs is invalid.
1433	* @retval VERR_NOT_FOUND if the address couldn't be mapped to a module.
1434	* @retval VERR_INVALID_PARAMETER if incorrect flags.
1435	*
1436	* @param hDbgAs The address space handle.
1437	* @param Addr The address which closest symbol is requested.
1438	* @param fFlags Symbol search flags, see RTDBGSYMADDR_FLAGS_XXX.
1439	* @param poffDisp Where to return the distance between the symbol
1440	* and address. Optional.
1441	* @param ppSymInfo Where to return the pointer to the allocated symbol
1442	* info. Always set. Free with RTDbgSymbolFree.
1443	* @param phMod Where to return the module handle. Optional.
1444	*/
1445	RTDECL(int) RTDbgAsSymbolByAddrA(RTDBGAS hDbgAs, RTUINTPTR Addr, uint32_t fFlags,
1446	PRTINTPTR poffDisp, PRTDBGSYMBOL *ppSymInfo, PRTDBGMOD phMod)
1447	{
1448	/*
1449	* Validate input and resolve the address.
1450	*/
1451	PRTDBGASINT pDbgAs = hDbgAs;
1452	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
1453
1454	RTDBGSEGIDX iSeg = NIL_RTDBGSEGIDX;
1455	RTUINTPTR offSeg = 0;
1456	RTUINTPTR MapAddr = 0;
1457	RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg, &MapAddr);
1458	if (hMod == NIL_RTDBGMOD)
1459	{
1460	if (phMod)
1461	*phMod = NIL_RTDBGMOD;
1462	return VERR_NOT_FOUND;
1463	}
1464
1465	/*
1466	* Forward the call.
1467	*/
1468	int rc = RTDbgModSymbolByAddrA(hMod, iSeg, offSeg, fFlags, poffDisp, ppSymInfo);
1469	if (RT_SUCCESS(rc))
1470	rtDbgAsAdjustSymbolValue(*ppSymInfo, hMod, MapAddr, iSeg);
1471	if (phMod)
1472	*phMod = hMod;
1473	else
1474	RTDbgModRelease(hMod);
1475	return rc;
1476	}
1477	RT_EXPORT_SYMBOL(RTDbgAsSymbolByAddrA);
1478
1479
1480	/**
1481	* Attempts to find a mapping of the specified symbol/module and
1482	* adjust it's Value field accordingly.
1483	*
1484	* @returns true / false success indicator.
1485	* @param pDbgAs The address space.
1486	* @param hDbgMod The module handle.
1487	* @param pSymbol The symbol info.
1488	*/
1489	static bool rtDbgAsFindMappingAndAdjustSymbolValue(PRTDBGASINT pDbgAs, RTDBGMOD hDbgMod, PRTDBGSYMBOL pSymbol)
1490	{
1491	/*
1492	* Absolute segments needs no fixing.
1493	*/
1494	RTDBGSEGIDX const iSeg = pSymbol->iSeg;
1495	if (iSeg == RTDBGSEGIDX_ABS)
1496	return true;
1497
1498	RTDBGAS_LOCK_READ(pDbgAs);
1499
1500	/*
1501	* Lookup up the module by it's handle and iterate the mappings looking for one
1502	* that either encompasses the entire module or the segment in question.
1503	*/
1504	PRTDBGASMOD pMod = (PRTDBGASMOD)RTAvlPVGet(&pDbgAs->ModTree, hDbgMod);
1505	if (pMod)
1506	{
1507	for (PRTDBGASMAP pMap = pMod->pMapHead; pMap; pMap = pMap->pNext)
1508	{
1509	/* Exact segment match or full-mapping. */
1510	if ( iSeg == pMap->iSeg
1511	\|\| pMap->iSeg == NIL_RTDBGSEGIDX)
1512	{
1513	RTUINTPTR MapAddr = pMap->Core.Key;
1514	RTDBGSEGIDX iMapSeg = pMap->iSeg;
1515
1516	RTDBGAS_UNLOCK_READ(pDbgAs);
1517	rtDbgAsAdjustSymbolValue(pSymbol, hDbgMod, MapAddr, iMapSeg);
1518	return true;
1519	}
1520
1521	/* Symbol uses RVA and the mapping doesn't, see if it's in the mapped segment. */
1522	if (iSeg == RTDBGSEGIDX_RVA)
1523	{
1524	Assert(pMap->iSeg != NIL_RTDBGSEGIDX);
1525	RTUINTPTR SegRva = RTDbgModSegmentRva(hDbgMod, pMap->iSeg);
1526	Assert(SegRva != RTUINTPTR_MAX);
1527	RTUINTPTR cbSeg = RTDbgModSegmentSize(hDbgMod, pMap->iSeg);
1528	if (SegRva - pSymbol->Value < cbSeg)
1529	{
1530	RTUINTPTR MapAddr = pMap->Core.Key;
1531	RTDBGSEGIDX iMapSeg = pMap->iSeg;
1532
1533	RTDBGAS_UNLOCK_READ(pDbgAs);
1534	rtDbgAsAdjustSymbolValue(pSymbol, hDbgMod, MapAddr, iMapSeg);
1535	return true;
1536	}
1537	}
1538	}
1539	}
1540	/* else: Unmapped while we were searching. */
1541
1542	RTDBGAS_UNLOCK_READ(pDbgAs);
1543	return false;
1544	}
1545
1546
1547	/**
1548	* Query a symbol by name.
1549	*
1550	* @returns IPRT status code.
1551	* @retval VERR_SYMBOL_NOT_FOUND if not found.
1552	*
1553	* @param hDbgAs The address space handle.
1554	* @param pszSymbol The symbol name. It is possible to limit the scope
1555	* of the search by prefixing the symbol with a module
1556	* name pattern followed by a bang (!) character.
1557	* RTStrSimplePatternNMatch is used for the matching.
1558	* @param pSymbol Where to return the symbol info.
1559	* @param phMod Where to return the module handle. Optional.
1560	*/
1561	RTDECL(int) RTDbgAsSymbolByName(RTDBGAS hDbgAs, const char *pszSymbol, PRTDBGSYMBOL pSymbol, PRTDBGMOD phMod)
1562	{
1563	/*
1564	* Validate input.
1565	*/
1566	PRTDBGASINT pDbgAs = hDbgAs;
1567	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
1568	AssertPtrReturn(pszSymbol, VERR_INVALID_POINTER);
1569	AssertPtrReturn(pSymbol, VERR_INVALID_POINTER);
1570
1571	/*
1572	* Look for module pattern.
1573	*/
1574	const char *pachModPat = NULL;
1575	size_t cchModPat = 0;
1576	const char *pszBang = strchr(pszSymbol, '!');
1577	if (pszBang)
1578	{
1579	pachModPat = pszSymbol;
1580	cchModPat = pszBang - pszSymbol;
1581	pszSymbol = pszBang + 1;
1582	if (!*pszSymbol)
1583	return VERR_DBG_SYMBOL_NAME_OUT_OF_RANGE;
1584	/* Note! Zero length module -> no pattern -> escape for symbol with '!'. */
1585	}
1586
1587	/*
1588	* Iterate the modules, looking for the symbol.
1589	*/
1590	uint32_t cModules;
1591	PRTDBGMOD pahModules = rtDbgAsSnapshotModuleTable(pDbgAs, &cModules);
1592	if (!pahModules)
1593	return VERR_NO_TMP_MEMORY;
1594
1595	for (uint32_t i = 0; i < cModules; i++)
1596	{
1597	if ( cchModPat == 0
1598	\|\| RTStrSimplePatternNMatch(pachModPat, cchModPat, RTDbgModName(pahModules[i]), RTSTR_MAX))
1599	{
1600	int rc = RTDbgModSymbolByName(pahModules[i], pszSymbol, pSymbol);
1601	if (RT_SUCCESS(rc))
1602	{
1603	if (rtDbgAsFindMappingAndAdjustSymbolValue(pDbgAs, pahModules[i], pSymbol))
1604	{
1605	if (phMod)
1606	RTDbgModRetain(*phMod = pahModules[i]);
1607	for (; i < cModules; i++)
1608	RTDbgModRelease(pahModules[i]);
1609	RTMemTmpFree(pahModules);
1610	return rc;
1611	}
1612	}
1613	}
1614	RTDbgModRelease(pahModules[i]);
1615	}
1616
1617	RTMemTmpFree(pahModules);
1618	return VERR_SYMBOL_NOT_FOUND;
1619	}
1620	RT_EXPORT_SYMBOL(RTDbgAsSymbolByName);
1621
1622
1623	/**
1624	* Query a symbol by name, allocating the returned symbol structure.
1625	*
1626	* @returns IPRT status code.
1627	* @retval VERR_SYMBOL_NOT_FOUND if not found.
1628	*
1629	* @param hDbgAs The address space handle.
1630	* @param pszSymbol The symbol name. See RTDbgAsSymbolByName for more.
1631	* @param ppSymbol Where to return the pointer to the allocated
1632	* symbol info. Always set. Free with RTDbgSymbolFree.
1633	* @param phMod Where to return the module handle. Optional.
1634	*/
1635	RTDECL(int) RTDbgAsSymbolByNameA(RTDBGAS hDbgAs, const char pszSymbol, PRTDBGSYMBOL ppSymbol, PRTDBGMOD phMod)
1636	{
1637	/*
1638	* Validate input.
1639	*/
1640	AssertPtrReturn(ppSymbol, VERR_INVALID_POINTER);
1641	*ppSymbol = NULL;
1642	PRTDBGASINT pDbgAs = hDbgAs;
1643	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
1644	AssertPtrReturn(pszSymbol, VERR_INVALID_POINTER);
1645
1646	/*
1647	* Look for module pattern.
1648	*/
1649	const char *pachModPat = NULL;
1650	size_t cchModPat = 0;
1651	const char *pszBang = strchr(pszSymbol, '!');
1652	if (pszBang)
1653	{
1654	pachModPat = pszSymbol;
1655	cchModPat = pszBang - pszSymbol;
1656	pszSymbol = pszBang + 1;
1657	if (!*pszSymbol)
1658	return VERR_DBG_SYMBOL_NAME_OUT_OF_RANGE;
1659	/* Note! Zero length module -> no pattern -> escape for symbol with '!'. */
1660	}
1661
1662	/*
1663	* Iterate the modules, looking for the symbol.
1664	*/
1665	uint32_t cModules;
1666	PRTDBGMOD pahModules = rtDbgAsSnapshotModuleTable(pDbgAs, &cModules);
1667	if (!pahModules)
1668	return VERR_NO_TMP_MEMORY;
1669
1670	for (uint32_t i = 0; i < cModules; i++)
1671	{
1672	if ( cchModPat == 0
1673	\|\| RTStrSimplePatternNMatch(pachModPat, cchModPat, RTDbgModName(pahModules[i]), RTSTR_MAX))
1674	{
1675	int rc = RTDbgModSymbolByNameA(pahModules[i], pszSymbol, ppSymbol);
1676	if (RT_SUCCESS(rc))
1677	{
1678	if (rtDbgAsFindMappingAndAdjustSymbolValue(pDbgAs, pahModules[i], *ppSymbol))
1679	{
1680	if (phMod)
1681	RTDbgModRetain(*phMod = pahModules[i]);
1682	for (; i < cModules; i++)
1683	RTDbgModRelease(pahModules[i]);
1684	RTMemTmpFree(pahModules);
1685	return rc;
1686	}
1687	}
1688	}
1689	RTDbgModRelease(pahModules[i]);
1690	}
1691
1692	RTMemTmpFree(pahModules);
1693	return VERR_SYMBOL_NOT_FOUND;
1694	}
1695	RT_EXPORT_SYMBOL(RTDbgAsSymbolByNameA);
1696
1697
1698	/**
1699	* Adds a line number to a module in the address space.
1700	*
1701	* @returns IPRT status code. See RTDbgModSymbolAdd for more specific ones.
1702	* @retval VERR_INVALID_HANDLE if hDbgAs is invalid.
1703	* @retval VERR_NOT_FOUND if no module was found at the specified address.
1704	* @retval VERR_NOT_SUPPORTED if the module interpret doesn't support adding
1705	* custom symbols.
1706	*
1707	* @param hDbgAs The address space handle.
1708	* @param pszFile The file name.
1709	* @param uLineNo The line number.
1710	* @param Addr The address of the symbol.
1711	* @param piOrdinal Where to return the line number ordinal on success.
1712	* If the interpreter doesn't do ordinals, this will be
1713	* set to UINT32_MAX. Optional.
1714	*/
1715	RTDECL(int) RTDbgAsLineAdd(RTDBGAS hDbgAs, const char pszFile, uint32_t uLineNo, RTUINTPTR Addr, uint32_t piOrdinal)
1716	{
1717	/*
1718	* Validate input and resolve the address.
1719	*/
1720	PRTDBGASINT pDbgAs = hDbgAs;
1721	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
1722
1723	RTDBGSEGIDX iSeg = NIL_RTDBGSEGIDX; /* shut up gcc */
1724	RTUINTPTR offSeg = 0; /* ditto */
1725	RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg, NULL);
1726	if (hMod == NIL_RTDBGMOD)
1727	return VERR_NOT_FOUND;
1728
1729	/*
1730	* Forward the call.
1731	*/
1732	int rc = RTDbgModLineAdd(hMod, pszFile, uLineNo, iSeg, offSeg, piOrdinal);
1733	RTDbgModRelease(hMod);
1734	return rc;
1735	}
1736	RT_EXPORT_SYMBOL(RTDbgAsLineAdd);
1737
1738
1739	RTDECL(int) RTDbgAsLineByAddr(RTDBGAS hDbgAs, RTUINTPTR Addr, PRTINTPTR poffDisp, PRTDBGLINE pLine, PRTDBGMOD phMod)
1740	{
1741	/*
1742	* Validate input and resolve the address.
1743	*/
1744	PRTDBGASINT pDbgAs = hDbgAs;
1745	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
1746
1747	RTDBGSEGIDX iSeg = NIL_RTDBGSEGIDX; /* shut up gcc */
1748	RTUINTPTR offSeg = 0;
1749	RTUINTPTR MapAddr = 0;
1750	RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg, &MapAddr);
1751	if (hMod == NIL_RTDBGMOD)
1752	return VERR_NOT_FOUND;
1753
1754	/*
1755	* Forward the call.
1756	*/
1757	int rc = RTDbgModLineByAddr(hMod, iSeg, offSeg, poffDisp, pLine);
1758	if (RT_SUCCESS(rc))
1759	{
1760	rtDbgAsAdjustLineAddress(pLine, hMod, MapAddr, iSeg);
1761	if (phMod)
1762	*phMod = hMod;
1763	else
1764	RTDbgModRelease(hMod);
1765	}
1766	else
1767	RTDbgModRelease(hMod);
1768	return rc;
1769	}
1770	RT_EXPORT_SYMBOL(RTDbgAsLineByAddr);
1771
1772
1773	RTDECL(int) RTDbgAsLineByAddrA(RTDBGAS hDbgAs, RTUINTPTR Addr, PRTINTPTR poffDisp, PRTDBGLINE *ppLine, PRTDBGMOD phMod)
1774	{
1775	/*
1776	* Validate input and resolve the address.
1777	*/
1778	PRTDBGASINT pDbgAs = hDbgAs;
1779	RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
1780
1781	RTDBGSEGIDX iSeg = NIL_RTDBGSEGIDX; /* shut up gcc */
1782	RTUINTPTR offSeg = 0;
1783	RTUINTPTR MapAddr = 0;
1784	RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg, &MapAddr);
1785	if (hMod == NIL_RTDBGMOD)
1786	return VERR_NOT_FOUND;
1787
1788	/*
1789	* Forward the call.
1790	*/
1791	int rc = RTDbgModLineByAddrA(hMod, iSeg, offSeg, poffDisp, ppLine);
1792	if (RT_SUCCESS(rc))
1793	{
1794	rtDbgAsAdjustLineAddress(*ppLine, hMod, MapAddr, iSeg);
1795	if (phMod)
1796	*phMod = hMod;
1797	else
1798	RTDbgModRelease(hMod);
1799	}
1800	else
1801	RTDbgModRelease(hMod);
1802	return rc;
1803	}
1804	RT_EXPORT_SYMBOL(RTDbgAsLineByAddrA);
1805

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/common/dbg/dbgas.cpp@ 72778

Download in other formats: