dbgmodcodeview.cpp

Last change on this file was 106061, checked in by vboxsync, 3 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 157.7 KB

Line
1	/* $Id: dbgmodcodeview.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* IPRT - Debug Module Reader For Microsoft CodeView and COFF.
4	*
5	* Based on the following documentation (plus guess work and googling):
6	*
7	* - "Tools Interface Standard (TIS) Formats Specification for Windows",
8	* dated February 1993, version 1.0.
9	*
10	* - "Visual C++ 5.0 Symbolic Debug Information Specification" chapter of
11	* SPECS.CHM from MSDN Library October 2001.
12	*
13	* - "High Level Languages Debug Table Documentation", aka HLLDBG.HTML, aka
14	* IBMHLL.HTML, last changed 1996-07-08.
15	*
16	* Testcases using RTLdrFlt:
17	* - VBoxPcBios.sym at 0xf0000.
18	* - NT4 kernel PE image (coff syms).
19	*/
20
21	/*
22	* Copyright (C) 2013-2024 Oracle and/or its affiliates.
23	*
24	* This file is part of VirtualBox base platform packages, as
25	* available from https://www.virtualbox.org.
26	*
27	* This program is free software; you can redistribute it and/or
28	* modify it under the terms of the GNU General Public License
29	* as published by the Free Software Foundation, in version 3 of the
30	* License.
31	*
32	* This program is distributed in the hope that it will be useful, but
33	* WITHOUT ANY WARRANTY; without even the implied warranty of
34	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
35	* General Public License for more details.
36	*
37	* You should have received a copy of the GNU General Public License
38	* along with this program; if not, see <https://www.gnu.org/licenses>.
39	*
40	* The contents of this file may alternatively be used under the terms
41	* of the Common Development and Distribution License Version 1.0
42	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
43	* in the VirtualBox distribution, in which case the provisions of the
44	* CDDL are applicable instead of those of the GPL.
45	*
46	* You may elect to license modified versions of this file under the
47	* terms and conditions of either the GPL or the CDDL or both.
48	*
49	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
50	*/
51
52
53	/*********************************************************************************************************************************
54	* Header Files *
55	*********************************************************************************************************************************/
56	#define LOG_GROUP RTLOGGROUP_DBG
57	#include <iprt/dbg.h>
58	#include "internal/iprt.h"
59
60	#include <iprt/alloca.h>
61	#include <iprt/asm.h>
62	#include <iprt/assert.h>
63	#include <iprt/err.h>
64	#include <iprt/file.h>
65	#include <iprt/fsvfs.h>
66	#include <iprt/latin1.h>
67	#include <iprt/log.h>
68	#include <iprt/mem.h>
69	#include <iprt/param.h>
70	#include <iprt/path.h>
71	#include <iprt/sort.h>
72	#include <iprt/string.h>
73	#include <iprt/strcache.h>
74	#include <iprt/vfs.h>
75	#include "internal/dbgmod.h"
76	#include "internal/magics.h"
77
78	#include <iprt/formats/codeview.h>
79	#include <iprt/formats/pecoff.h>
80
81
82	/*********************************************************************************************************************************
83	* Structures and Typedefs *
84	*********************************************************************************************************************************/
85	/**
86	* File type.
87	*/
88	typedef enum RTCVFILETYPE
89	{
90	RTCVFILETYPE_INVALID = 0,
91	/** Executable image. */
92	RTCVFILETYPE_IMAGE,
93	/** A DBG-file with a IMAGE_SEPARATE_DEBUG_HEADER. */
94	RTCVFILETYPE_DBG,
95	/** A PDB file. */
96	RTCVFILETYPE_PDB,
97	/** Some other kind of file with CV at the end. */
98	RTCVFILETYPE_OTHER_AT_END,
99	/** The end of the valid values. */
100	RTCVFILETYPE_END,
101	/** Type blowup. */
102	RTCVFILETYPE_32BIT_HACK = 0x7fffffff
103	} RTCVFILETYPE;
104
105
106	/**
107	* CodeView debug info reader instance.
108	*/
109	typedef struct RTDBGMODCV
110	{
111	/** Using a container for managing the debug info. */
112	RTDBGMOD hCnt;
113
114	/** @name Codeview details
115	* @{ */
116	/** The code view magic (used as format indicator). */
117	uint32_t u32CvMagic;
118	/** The offset of the CV debug info in the file. */
119	uint32_t offBase;
120	/** The size of the CV debug info. */
121	uint32_t cbDbgInfo;
122	/** The offset of the subsection directory (relative to offBase). */
123	uint32_t offDir;
124	/** @} */
125
126	/** @name COFF details.
127	* @{ */
128	/** Offset of the COFF header. */
129	uint32_t offCoffDbgInfo;
130	/** The size of the COFF debug info. */
131	uint32_t cbCoffDbgInfo;
132	/** The COFF debug info header. */
133	IMAGE_COFF_SYMBOLS_HEADER CoffHdr;
134	/** @} */
135
136	/** @name External PDB (v2) with a DBG file.
137	* @{ */
138	/** The resolved PDB path (RTStrFree). */
139	char *pszPdbFilename;
140	/** The PDB VFS. This is only valid between rtDbgModCvOpenPdb20Callback()
141	* and the end of rtDbgModCv_TryOpen(). */
142	RTVFS hVfsPdb;
143	/** @} */
144
145	/** The file type. */
146	RTCVFILETYPE enmType;
147	/** The file handle (if external). */
148	RTFILE hFile;
149	/** Pointer to the module (no reference retained). */
150	PRTDBGMODINT pMod;
151
152	/** The image size, if we know it. This is 0 if we don't know it. */
153	uint32_t cbImage;
154
155	/** Indicates that we've loaded segments into the container already. */
156	bool fHaveLoadedSegments;
157	/** Alternative address translation method for DOS frames. */
158	bool fHaveDosFrames;
159
160	/** @name Codeview Parsing state.
161	* @{ */
162	/** Number of directory entries. */
163	uint32_t cDirEnts;
164	/** The directory (converted to 32-bit). */
165	PRTCVDIRENT32 paDirEnts;
166	/** Current debugging style when parsing modules. */
167	uint16_t uCurStyle;
168	/** Current debugging style version (HLL only). */
169	uint16_t uCurStyleVer;
170
171	/** The segment map (if present). */
172	PRTCVSEGMAP pSegMap;
173	/** Segment names. */
174	char *pszzSegNames;
175	/** The size of the segment names. */
176	uint32_t cbSegNames;
177
178	/** Size of the block pchSrcStrings points to. */
179	size_t cbSrcStrings;
180	/** Buffer space allocated for the source string table. */
181	size_t cbSrcStringsAlloc;
182	/** Copy of the last CV8 source string table. */
183	char *pchSrcStrings;
184
185	/** The size of the current source information table. */
186	size_t cbSrcInfo;
187	/** Buffer space allocated for the source information table. */
188	size_t cbSrcInfoAlloc;
189	/** Copy of the last CV8 source information table. */
190	uint8_t *pbSrcInfo;
191
192	/** @} */
193
194	} RTDBGMODCV;
195	/** Pointer to a codeview debug info reader instance. */
196	typedef RTDBGMODCV *PRTDBGMODCV;
197	/** Pointer to a const codeview debug info reader instance. */
198	typedef RTDBGMODCV *PCRTDBGMODCV;
199
200
201
202	/**
203	* Subsection callback.
204	*
205	* @returns IPRT status code.
206	* @param pThis The CodeView debug info reader instance.
207	* @param pvSubSect Pointer to the subsection data.
208	* @param cbSubSect The size of the subsection data.
209	* @param pDirEnt The directory entry.
210	*/
211	typedef DECLCALLBACKTYPE(int, FNDBGMODCVSUBSECTCALLBACK,(PRTDBGMODCV pThis, void const *pvSubSect, size_t cbSubSect,
212	PCRTCVDIRENT32 pDirEnt));
213	/** Pointer to a subsection callback. */
214	typedef FNDBGMODCVSUBSECTCALLBACK *PFNDBGMODCVSUBSECTCALLBACK;
215
216
217
218	/*********************************************************************************************************************************
219	* Defined Constants And Macros *
220	*********************************************************************************************************************************/
221	/** Light weight assert + return w/ fixed status code. */
222	#define RTDBGMODCV_CHECK_RET_BF(a_Expr, a_LogArgs) \
223	do { \
224	if (!(a_Expr)) \
225	{ \
226	Log(("RTDbgCv: Check failed on line %d: " #a_Expr "\n", __LINE__)); \
227	Log(a_LogArgs); \
228	/AssertFailed();/ \
229	return VERR_CV_BAD_FORMAT; \
230	} \
231	} while (0)
232
233
234	/** Light weight assert + return w/ fixed status code. */
235	#define RTDBGMODCV_CHECK_NOMSG_RET_BF(a_Expr) \
236	do { \
237	if (!(a_Expr)) \
238	{ \
239	Log(("RTDbgCv: Check failed on line %d: " #a_Expr "\n", __LINE__)); \
240	/AssertFailed();/ \
241	return VERR_CV_BAD_FORMAT; \
242	} \
243	} while (0)
244
245
246
247	/*********************************************************************************************************************************
248	* Internal Functions *
249	*********************************************************************************************************************************/
250	static int rtDbgModPdb_CommonOpenWorker(PRTDBGMODCV pThis, const char *pszFilename, RTVFS hVfsPdb, RTDBGCFG hDbgCfg);
251
252
253
254	/**
255	* Reads CodeView information.
256	*
257	* @returns IPRT status code.
258	* @param pThis The CodeView reader instance.
259	* @param off The offset to start reading at, relative to the
260	* CodeView base header.
261	* @param pvBuf The buffer to read into.
262	* @param cb How many bytes to read.
263	*/
264	static int rtDbgModCvReadAt(PRTDBGMODCV pThis, uint32_t off, void *pvBuf, size_t cb)
265	{
266	int rc;
267	if (pThis->hFile == NIL_RTFILE)
268	rc = pThis->pMod->pImgVt->pfnReadAt(pThis->pMod, UINT32_MAX, off + pThis->offBase, pvBuf, cb);
269	else
270	rc = RTFileReadAt(pThis->hFile, off + pThis->offBase, pvBuf, cb, NULL);
271	return rc;
272	}
273
274
275	/**
276	* Reads CodeView information into an allocated buffer.
277	*
278	* @returns IPRT status code.
279	* @param pThis The CodeView reader instance.
280	* @param off The offset to start reading at, relative to the
281	* CodeView base header.
282	* @param ppvBuf Where to return the allocated buffer on success.
283	* @param cb How many bytes to read.
284	*/
285	static int rtDbgModCvReadAtAlloc(PRTDBGMODCV pThis, uint32_t off, void **ppvBuf, size_t cb)
286	{
287	int rc;
288	void pvBuf = ppvBuf = RTMemAlloc(cb);
289	if (pvBuf)
290	{
291	if (pThis->hFile == NIL_RTFILE)
292	rc = pThis->pMod->pImgVt->pfnReadAt(pThis->pMod, UINT32_MAX, off + pThis->offBase, pvBuf, cb);
293	else
294	rc = RTFileReadAt(pThis->hFile, off + pThis->offBase, pvBuf, cb, NULL);
295	if (RT_SUCCESS(rc))
296	return VINF_SUCCESS;
297
298	RTMemFree(pvBuf);
299	*ppvBuf = NULL;
300	}
301	else
302	rc = VERR_NO_MEMORY;
303	return rc;
304	}
305
306
307	#ifdef LOG_ENABLED
308	/**
309	* Gets a name string for a subsection type.
310	*
311	* @returns Section name (read only).
312	* @param uSubSectType The subsection type.
313	*/
314	static const char *rtDbgModCvGetSubSectionName(uint16_t uSubSectType)
315	{
316	switch (uSubSectType)
317	{
318	case kCvSst_OldModule: return "sstOldModule";
319	case kCvSst_OldPublic: return "sstOldPublic";
320	case kCvSst_OldTypes: return "sstOldTypes";
321	case kCvSst_OldSymbols: return "sstOldSymbols";
322	case kCvSst_OldSrcLines: return "sstOldSrcLines";
323	case kCvSst_OldLibraries: return "sstOldLibraries";
324	case kCvSst_OldImports: return "sstOldImports";
325	case kCvSst_OldCompacted: return "sstOldCompacted";
326	case kCvSst_OldSrcLnSeg: return "sstOldSrcLnSeg";
327	case kCvSst_OldSrcLines3: return "sstOldSrcLines3";
328
329	case kCvSst_Module: return "sstModule";
330	case kCvSst_Types: return "sstTypes";
331	case kCvSst_Public: return "sstPublic";
332	case kCvSst_PublicSym: return "sstPublicSym";
333	case kCvSst_Symbols: return "sstSymbols";
334	case kCvSst_AlignSym: return "sstAlignSym";
335	case kCvSst_SrcLnSeg: return "sstSrcLnSeg";
336	case kCvSst_SrcModule: return "sstSrcModule";
337	case kCvSst_Libraries: return "sstLibraries";
338	case kCvSst_GlobalSym: return "sstGlobalSym";
339	case kCvSst_GlobalPub: return "sstGlobalPub";
340	case kCvSst_GlobalTypes: return "sstGlobalTypes";
341	case kCvSst_MPC: return "sstMPC";
342	case kCvSst_SegMap: return "sstSegMap";
343	case kCvSst_SegName: return "sstSegName";
344	case kCvSst_PreComp: return "sstPreComp";
345	case kCvSst_PreCompMap: return "sstPreCompMap";
346	case kCvSst_OffsetMap16: return "sstOffsetMap16";
347	case kCvSst_OffsetMap32: return "sstOffsetMap32";
348	case kCvSst_FileIndex: return "sstFileIndex";
349	case kCvSst_StaticSym: return "sstStaticSym";
350	}
351	static char s_sz[32];
352	RTStrPrintf(s_sz, sizeof(s_sz), "Unknown%#x", uSubSectType);
353	return s_sz;
354	}
355	#endif /* LOG_ENABLED */
356
357
358	#ifdef LOG_ENABLED
359	/**
360	* Gets a name string for a symbol type.
361	*
362	* @returns symbol type name (read only).
363	* @param enmSymType The symbol type to name.
364	*/
365	static const char *rtDbgModCvSsSymTypeName(RTCVSYMTYPE enmSymType)
366	{
367	switch (enmSymType)
368	{
369	# define CASE_RET_STR(Name) case kCvSymType_##Name: return #Name;
370	CASE_RET_STR(Compile);
371	CASE_RET_STR(Register);
372	CASE_RET_STR(Constant);
373	CASE_RET_STR(UDT);
374	CASE_RET_STR(SSearch);
375	CASE_RET_STR(End);
376	CASE_RET_STR(Skip);
377	CASE_RET_STR(CVReserve);
378	CASE_RET_STR(ObjName);
379	CASE_RET_STR(EndArg);
380	CASE_RET_STR(CobolUDT);
381	CASE_RET_STR(ManyReg);
382	CASE_RET_STR(Return);
383	CASE_RET_STR(EntryThis);
384	CASE_RET_STR(BpRel16);
385	CASE_RET_STR(LData16);
386	CASE_RET_STR(GData16);
387	CASE_RET_STR(Pub16);
388	CASE_RET_STR(LProc16);
389	CASE_RET_STR(GProc16);
390	CASE_RET_STR(Thunk16);
391	CASE_RET_STR(BLock16);
392	CASE_RET_STR(With16);
393	CASE_RET_STR(Label16);
394	CASE_RET_STR(CExModel16);
395	CASE_RET_STR(VftPath16);
396	CASE_RET_STR(RegRel16);
397	CASE_RET_STR(BpRel32);
398	CASE_RET_STR(LData32);
399	CASE_RET_STR(GData32);
400	CASE_RET_STR(Pub32);
401	CASE_RET_STR(LProc32);
402	CASE_RET_STR(GProc32);
403	CASE_RET_STR(Thunk32);
404	CASE_RET_STR(Block32);
405	CASE_RET_STR(With32);
406	CASE_RET_STR(Label32);
407	CASE_RET_STR(CExModel32);
408	CASE_RET_STR(VftPath32);
409	CASE_RET_STR(RegRel32);
410	CASE_RET_STR(LThread32);
411	CASE_RET_STR(GThread32);
412	CASE_RET_STR(LProcMips);
413	CASE_RET_STR(GProcMips);
414	CASE_RET_STR(ProcRef);
415	CASE_RET_STR(DataRef);
416	CASE_RET_STR(Align);
417	CASE_RET_STR(LProcRef);
418	CASE_RET_STR(V2_Register);
419	CASE_RET_STR(V2_Constant);
420	CASE_RET_STR(V2_Udt);
421	CASE_RET_STR(V2_CobolUdt);
422	CASE_RET_STR(V2_ManyReg);
423	CASE_RET_STR(V2_BpRel);
424	CASE_RET_STR(V2_LData);
425	CASE_RET_STR(V2_GData);
426	CASE_RET_STR(V2_Pub);
427	CASE_RET_STR(V2_LProc);
428	CASE_RET_STR(V2_GProc);
429	CASE_RET_STR(V2_VftTable);
430	CASE_RET_STR(V2_RegRel);
431	CASE_RET_STR(V2_LThread);
432	CASE_RET_STR(V2_GThread);
433	CASE_RET_STR(V2_LProcMips);
434	CASE_RET_STR(V2_GProcMips);
435	CASE_RET_STR(V2_FrameInfo);
436	CASE_RET_STR(V2_Compliand);
437	CASE_RET_STR(V3_Compliand);
438	CASE_RET_STR(V3_Thunk);
439	CASE_RET_STR(V3_Block);
440	CASE_RET_STR(V3_Unknown_1104);
441	CASE_RET_STR(V3_Label);
442	CASE_RET_STR(V3_Register);
443	CASE_RET_STR(V3_Constant);
444	CASE_RET_STR(V3_Udt);
445	CASE_RET_STR(V3_Unknown_1109);
446	CASE_RET_STR(V3_Unknown_110a);
447	CASE_RET_STR(V3_BpRel);
448	CASE_RET_STR(V3_LData);
449	CASE_RET_STR(V3_GData);
450	CASE_RET_STR(V3_Pub);
451	CASE_RET_STR(V3_LProc);
452	CASE_RET_STR(V3_GProc);
453	CASE_RET_STR(V3_RegRel);
454	CASE_RET_STR(V3_LThread);
455	CASE_RET_STR(V3_GThread);
456	CASE_RET_STR(V3_Unknown_1114);
457	CASE_RET_STR(V3_Unknown_1115);
458	CASE_RET_STR(V3_MSTool);
459	CASE_RET_STR(V3_ProcRef);
460	CASE_RET_STR(V3_LProcRef);
461	CASE_RET_STR(V3_Unknown_1128);
462	CASE_RET_STR(V3_SectInfo);
463	CASE_RET_STR(V3_SubSectInfo);
464	CASE_RET_STR(V3_Entrypoint);
465	CASE_RET_STR(V3_Unknown_1139);
466	CASE_RET_STR(V3_SecuCookie);
467	CASE_RET_STR(V3_Unknown_113b);
468	CASE_RET_STR(V3_MsToolInfo);
469	CASE_RET_STR(V3_MsToolEnv);
470	CASE_RET_STR(VS2013_Local);
471	CASE_RET_STR(VS2013_FpOff);
472	CASE_RET_STR(VS2013_LProc32);
473	CASE_RET_STR(VS2013_GProc32);
474	#undef CASE_RET_STR
475	case kCvSymType_EndOfValues: break;
476	}
477	return "<unknown type>";
478	}
479	#endif /* LOG_ENABLED */
480
481
482	/**
483	* Adds a string to the g_hDbgModStrCache after sanitizing it.
484	*
485	* IPRT only deals with UTF-8 strings, so the string will be forced to UTF-8
486	* encoding. Also, codeview generally have length prefixed
487	*
488	* @returns String cached copy of the string.
489	* @param pch The string to copy to the cache.
490	* @param cch The length of the string. RTSTR_MAX if zero
491	* terminated.
492	*/
493	static const char rtDbgModCvAddSanitizedStringToCache(const char pch, size_t cch)
494	{
495	/*
496	* If the string is valid UTF-8 and or the right length, we're good.
497	* This is usually the case.
498	*/
499	const char *pszRet;
500	int rc;
501	if (cch != RTSTR_MAX)
502	rc = RTStrValidateEncodingEx(pch, cch, RTSTR_VALIDATE_ENCODING_EXACT_LENGTH);
503	else
504	rc = RTStrValidateEncodingEx(pch, cch, 0);
505	if (RT_SUCCESS(rc))
506	pszRet = RTStrCacheEnterN(g_hDbgModStrCache, pch, cch);
507	else
508	{
509	/*
510	* Need to sanitize the string, so make a copy of it.
511	*/
512	char pszCopy = (char )RTMemDupEx(pch, cch, 1);
513	AssertPtrReturn(pszCopy, NULL);
514
515	/* Deal with anyembedded zero chars. */
516	char *psz = RTStrEnd(pszCopy, cch);
517	while (psz)
518	{
519	*psz = '_';
520	psz = RTStrEnd(psz, cch - (psz - pszCopy));
521	}
522
523	/* Force valid UTF-8 encoding. */
524	RTStrPurgeEncoding(pszCopy);
525	Assert(strlen(pszCopy) == cch);
526
527	/* Enter it into the cache and free the temp copy. */
528	pszRet = RTStrCacheEnterN(g_hDbgModStrCache, pszCopy, cch);
529	RTMemFree(pszCopy);
530	}
531	return pszRet;
532	}
533
534
535	/**
536	* Translates a codeview segment and offset into our segment layout.
537	*
538	* @returns
539	* @param pThis .
540	* @param piSeg .
541	* @param poff .
542	*/
543	DECLINLINE(int) rtDbgModCvAdjustSegAndOffset(PRTDBGMODCV pThis, uint32_t piSeg, uint64_t poff)
544	{
545	uint32_t iSeg = *piSeg;
546	if (iSeg == 0)
547	iSeg = RTDBGSEGIDX_ABS;
548	else if (pThis->pSegMap)
549	{
550	if (pThis->fHaveDosFrames)
551	{
552	if ( iSeg > pThis->pSegMap->Hdr.cSegs
553	\|\| iSeg == 0)
554	return VERR_CV_BAD_FORMAT;
555	if (*poff <= pThis->pSegMap->aDescs[iSeg - 1].cb + pThis->pSegMap->aDescs[iSeg - 1].off)
556	*poff -= pThis->pSegMap->aDescs[iSeg - 1].off;
557	else
558	{
559	/* Workaround for VGABIOS where _DATA symbols like vgafont8 are
560	reported in the VGAROM segment. */
561	uint64_t uAddrSym = *poff + ((uint32_t)pThis->pSegMap->aDescs[iSeg - 1].iFrame << 4);
562	uint16_t j = pThis->pSegMap->Hdr.cSegs;
563	while (j-- > 0)
564	{
565	uint64_t uAddrFirst = (uint64_t)pThis->pSegMap->aDescs[j].off
566	+ ((uint32_t)pThis->pSegMap->aDescs[j].iFrame << 4);
567	if (uAddrSym - uAddrFirst < pThis->pSegMap->aDescs[j].cb)
568	{
569	Log(("CV addr fix: %04x:%08x -> %04x:%08x\n", iSeg, *poff, j + 1, uAddrSym - uAddrFirst));
570	*poff = uAddrSym - uAddrFirst;
571	iSeg = j + 1;
572	break;
573	}
574	}
575	if (j == UINT16_MAX)
576	return VERR_CV_BAD_FORMAT;
577	}
578	}
579	else
580	{
581	if ( iSeg > pThis->pSegMap->Hdr.cSegs
582	\|\| iSeg == 0
583	\|\| *poff > pThis->pSegMap->aDescs[iSeg - 1].cb)
584	return VERR_CV_BAD_FORMAT;
585	*poff += pThis->pSegMap->aDescs[iSeg - 1].off;
586	}
587	if (pThis->pSegMap->aDescs[iSeg - 1].fFlags & RTCVSEGMAPDESC_F_ABS)
588	iSeg = RTDBGSEGIDX_ABS;
589	else
590	iSeg = pThis->pSegMap->aDescs[iSeg - 1].iGroup;
591	}
592	*piSeg = iSeg;
593	return VINF_SUCCESS;
594	}
595
596
597	/**
598	* Adds a symbol to the container.
599	*
600	* @returns IPRT status code
601	* @param pThis The CodeView debug info reader instance.
602	* @param iSeg Segment number.
603	* @param off Offset into the segment
604	* @param pchName The symbol name (not necessarily terminated).
605	* @param cchName The symbol name length.
606	* @param fFlags Flags reserved for future exploits, MBZ.
607	* @param cbSym Symbol size, 0 if not available.
608	*/
609	static int rtDbgModCvAddSymbol(PRTDBGMODCV pThis, uint32_t iSeg, uint64_t off, const char *pchName,
610	uint32_t cchName, uint32_t fFlags, uint32_t cbSym)
611	{
612	RT_NOREF_PV(fFlags);
613	const char *pszName = rtDbgModCvAddSanitizedStringToCache(pchName, cchName);
614	int rc;
615	if (pszName)
616	{
617	#if 1
618	Log2(("CV Sym: %04x:%08x %.*s\n", iSeg, off, cchName, pchName));
619	rc = rtDbgModCvAdjustSegAndOffset(pThis, &iSeg, &off);
620	if (RT_SUCCESS(rc))
621	{
622	rc = RTDbgModSymbolAdd(pThis->hCnt, pszName, iSeg, off, cbSym, RTDBGSYMBOLADD_F_ADJUST_SIZES_ON_CONFLICT, NULL);
623
624	/* Simple duplicate symbol mangling, just to get more details. */
625	if (rc == VERR_DBG_DUPLICATE_SYMBOL && cchName < _2K)
626	{
627	char szTmpName[_2K + 96];
628	memcpy(szTmpName, pszName, cchName);
629	szTmpName[cchName] = '_';
630	for (uint32_t i = 1; i < 32; i++)
631	{
632	RTStrFormatU32(&szTmpName[cchName + 1], 80, i, 10, 0, 0, 0);
633	rc = RTDbgModSymbolAdd(pThis->hCnt, szTmpName, iSeg, off, cbSym, 0 /fFlags/, NULL);
634	if (rc != VERR_DBG_DUPLICATE_SYMBOL)
635	break;
636	}
637
638	}
639	else if (rc == VERR_DBG_ADDRESS_CONFLICT && cbSym)
640	rc = RTDbgModSymbolAdd(pThis->hCnt, pszName, iSeg, off, cbSym,
641	RTDBGSYMBOLADD_F_REPLACE_SAME_ADDR \| RTDBGSYMBOLADD_F_ADJUST_SIZES_ON_CONFLICT, NULL);
642
643	Log(("Symbol: %04x:%08x %.*s [%Rrc]\n", iSeg, off, cchName, pchName, rc));
644	if (rc == VERR_DBG_ADDRESS_CONFLICT \|\| rc == VERR_DBG_DUPLICATE_SYMBOL)
645	rc = VINF_SUCCESS;
646	}
647	else
648	Log(("Invalid segment index/offset %#06x:%08x for symbol %.*s\n", iSeg, off, cchName, pchName));
649
650	#else
651	Log(("Symbol: %04x:%08x %.*s\n", iSeg, off, cchName, pchName));
652	rc = VINF_SUCCESS;
653	#endif
654	RTStrCacheRelease(g_hDbgModStrCache, pszName);
655	}
656	else
657	rc = VERR_NO_STR_MEMORY;
658	return rc;
659	}
660
661	/**
662	* Validates the a length prefixed string (aka pascal string).
663	*
664	* @returns String length if valid, UINT16_MAX if invalid.
665	* @param cchString The string length.
666	* @param pchString The string to validate.
667	* @param pvRec The pointer to the record containing the string.
668	* @param cbRec The record length.
669	*/
670	static uint16_t rtDbgModCvValidatePascalString(uint8_t cchString, const char pchString, void const pvRec, uint16_t cbRec)
671	{
672	size_t offStrMember = (uintptr_t)pchString - (uintptr_t)pvRec;
673	AssertReturn(offStrMember <= cbRec, UINT16_MAX);
674	cbRec -= (uint16_t)offStrMember;
675	AssertReturn(cchString <= cbRec, UINT16_MAX);
676
677	int rc = RTStrValidateEncodingEx(pchString, cchString, RTSTR_VALIDATE_ENCODING_EXACT_LENGTH);
678	AssertRCReturn(rc, UINT16_MAX);
679
680	return cchString;
681	}
682
683
684	/**
685	* Validates the a zero terminated string.
686	*
687	* @returns String length if valid, UINT16_MAX if invalid.
688	* @param pszString The string to validate.
689	* @param pvRec The pointer to the record containing the string.
690	* @param cbRec The record length.
691	*/
692	static uint16_t rtDbgModCvValidateZeroString(const char pszString, void const pvRec, uint16_t cbRec)
693	{
694	size_t offStrMember = (uintptr_t)pszString - (uintptr_t)pvRec;
695	AssertReturn(offStrMember < _1K, UINT16_MAX);
696	AssertReturn(offStrMember <= cbRec, UINT16_MAX);
697	cbRec -= (uint16_t)offStrMember;
698
699	const char *pchEnd = RTStrEnd(pszString, cbRec);
700	AssertReturn(pchEnd, UINT16_MAX);
701
702	int rc = RTStrValidateEncoding(pszString);
703	AssertRCReturn(rc, UINT16_MAX);
704
705	return (uint16_t)(pchEnd - pszString);
706	}
707
708
709	/**
710	* Parses a CV4 symbol table, adding symbols to the container.
711	*
712	* @returns IPRT status code
713	* @param pThis The CodeView debug info reader instance.
714	* @param pvSymTab The symbol table.
715	* @param cbSymTab The size of the symbol table.
716	* @param fFlags Flags reserved for future exploits, MBZ.
717	*/
718	static int rtDbgModCvSsProcessV4PlusSymTab(PRTDBGMODCV pThis, void const *pvSymTab, size_t cbSymTab, uint32_t fFlags)
719	{
720	int rc = VINF_SUCCESS;
721	RTCPTRUNION uCursor;
722	uCursor.pv = pvSymTab;
723
724	RT_NOREF_PV(fFlags);
725
726	while (cbSymTab > 0 && RT_SUCCESS(rc))
727	{
728	uint8_t const * const pbRecStart = uCursor.pu8;
729	uint16_t cbRec = *uCursor.pu16++;
730	if (cbRec >= 2)
731	{
732	uint16_t uSymType = *uCursor.pu16++;
733
734	Log3((" %p: uSymType=%#06x LB %#x %s\n",
735	pbRecStart - (uint8_t *)pvSymTab, uSymType, cbRec, rtDbgModCvSsSymTypeName((RTCVSYMTYPE)uSymType)));
736	RTDBGMODCV_CHECK_RET_BF(cbRec >= 2 && cbRec <= cbSymTab, ("cbRec=%#x cbSymTab=%#x\n", cbRec, cbSymTab));
737
738	switch (uSymType)
739	{
740	case kCvSymType_LData16:
741	case kCvSymType_GData16:
742	case kCvSymType_Pub16:
743	{
744	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbRec > 2 + 2+2+2+1);
745	uint16_t off = *uCursor.pu16++;
746	uint16_t iSeg = *uCursor.pu16++;
747	/uint16_t iType = */ uCursor.pu16++;
748	uint8_t cchName = *uCursor.pu8++;
749	RTDBGMODCV_CHECK_NOMSG_RET_BF(cchName > 0);
750	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbRec >= 2 + 2+2+2+1 + cchName);
751
752	rc = rtDbgModCvAddSymbol(pThis, iSeg, off, uCursor.pch, cchName, 0, 0);
753	break;
754	}
755
756	case kCvSymType_LData32:
757	case kCvSymType_GData32:
758	case kCvSymType_Pub32:
759	{
760	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbRec > 2 + 4+2+2+1);
761	uint32_t off = *uCursor.pu32++;
762	uint16_t iSeg = *uCursor.pu16++;
763	/uint16_t iType = */ uCursor.pu16++;
764	uint8_t cchName = *uCursor.pu8++;
765	RTDBGMODCV_CHECK_NOMSG_RET_BF(cchName > 0);
766	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbRec >= 2 + 4+2+2+1 + cchName);
767
768	rc = rtDbgModCvAddSymbol(pThis, iSeg, off, uCursor.pch, cchName, 0, 0);
769	break;
770	}
771
772	case kCvSymType_LProc16:
773	case kCvSymType_GProc16:
774	{
775	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbRec > 2 + 4+4+4+2+2+2+2+2+2+1+1);
776	/uint32_t uParent = */ uCursor.pu32++;
777	/uint32_t uEnd = */ uCursor.pu32++;
778	/uint32_t uNext = */ uCursor.pu32++;
779	uint16_t cbProc = *uCursor.pu16++;
780	/uint16_t offDebugStart = */ uCursor.pu16++;
781	/uint16_t offDebugEnd = */ uCursor.pu16++;
782	uint16_t off = *uCursor.pu16++;
783	uint16_t iSeg = *uCursor.pu16++;
784	/uint16_t iProcType = */ uCursor.pu16++;
785	/uint8_t fbType = */ uCursor.pu8++;
786	uint8_t cchName = *uCursor.pu8++;
787	RTDBGMODCV_CHECK_NOMSG_RET_BF(cchName > 0);
788	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbRec >= 2 + 4+4+4+2+2+2+2+2+2+1+1 + cchName);
789
790	rc = rtDbgModCvAddSymbol(pThis, iSeg, off, uCursor.pch, cchName, 0, cbProc);
791	break;
792	}
793
794	case kCvSymType_LProc32:
795	case kCvSymType_GProc32:
796	{
797	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbRec > 2 + 4+4+4+4+4+4+4+2+2+1+1);
798	/uint32_t uParent = */ uCursor.pu32++;
799	/uint32_t uEnd = */ uCursor.pu32++;
800	/uint32_t uNext = */ uCursor.pu32++;
801	/uint32_t cbProc = */ uCursor.pu32++;
802	/uint32_t offDebugStart = */ uCursor.pu32++;
803	/uint32_t offDebugEnd = */ uCursor.pu32++;
804	uint32_t off = *uCursor.pu32++;
805	uint16_t iSeg = *uCursor.pu16++;
806	/uint16_t iProcType = */ uCursor.pu16++;
807	/uint8_t fbType = */ uCursor.pu8++;
808	uint8_t cchName = *uCursor.pu8++;
809	RTDBGMODCV_CHECK_NOMSG_RET_BF(cchName > 0);
810	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbRec >= 2 + 4+4+4+4+4+4+4+2+2+1+1 + cchName);
811
812	rc = rtDbgModCvAddSymbol(pThis, iSeg, off, uCursor.pch, cchName, 0, 0);
813	break;
814	}
815
816	case kCvSymType_V2_Pub:
817	case kCvSymType_V2_LData:
818	case kCvSymType_V2_GData:
819	{
820	PCRTCVSYMV2TYPEDNAME pData = (PCRTCVSYMV2TYPEDNAME)uCursor.pv;
821	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbRec >= 2 + RT_UOFFSETOF(RTCVSYMV2TYPEDNAME, achName));
822	uint16_t const cchName = rtDbgModCvValidatePascalString(pData->cchName, pData->achName, pData, cbRec);
823	if (cchName != UINT16_MAX && cchName > 0)
824	rc = rtDbgModCvAddSymbol(pThis, pData->iSection, pData->offSection, pData->achName, cchName, 0, 0);
825	else
826	Log3((" cchName=%#x sec:off=%#x:%#x %.*Rhxs\n",
827	cchName, pData->iSection, pData->offSection, cbRec, pData));
828	break;
829	}
830
831	case kCvSymType_V3_Label:
832	{
833	PCRTCVSYMV3LABEL pLabel = (PCRTCVSYMV3LABEL)uCursor.pv;
834	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbRec >= 2 + sizeof(*pLabel));
835	uint16_t cchName = rtDbgModCvValidateZeroString(pLabel->szName, pLabel, cbRec);
836	if (cchName != UINT16_MAX && cchName > 0)
837	rc = rtDbgModCvAddSymbol(pThis, pLabel->iSection, pLabel->offSection, pLabel->szName, cchName, 0, 0);
838	else
839	Log3((" cchName=%#x sec:off=%#x:%#x %.*Rhxs\n",
840	cchName, pLabel->iSection, pLabel->offSection, cbRec, pLabel));
841	break;
842	}
843
844	case kCvSymType_V3_LData:
845	case kCvSymType_V3_GData:
846	case kCvSymType_V3_Pub:
847	{
848	PCRTCVSYMV3TYPEDNAME pData = (PCRTCVSYMV3TYPEDNAME)uCursor.pv;
849	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbRec >= sizeof(*pData));
850	uint16_t cchName = rtDbgModCvValidateZeroString(pData->szName, pData, cbRec);
851	if (cchName != UINT16_MAX && cchName > 0)
852	rc = rtDbgModCvAddSymbol(pThis, pData->iSection, pData->offSection, pData->szName, cchName, 0, 0);
853	else
854	Log3((" cchName=%#x sec:off=%#x:%#x idType=%#x %.*Rhxs\n",
855	cchName, pData->iSection, pData->offSection, pData->idType, cbRec, pData));
856	break;
857	}
858
859	case kCvSymType_V3_LProc:
860	case kCvSymType_V3_GProc:
861	{
862	PCRTCVSYMV3PROC pProc = (PCRTCVSYMV3PROC)uCursor.pv;
863	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbRec >= sizeof(*pProc));
864	uint16_t cchName = rtDbgModCvValidateZeroString(pProc->szName, pProc, cbRec);
865	if (cchName != UINT16_MAX && cchName > 0)
866	rc = rtDbgModCvAddSymbol(pThis, pProc->iSection, pProc->offSection, pProc->szName, cchName,
867	0, pProc->cbProc);
868	else
869	Log3((" cchName=%#x sec:off=%#x:%#x LB %#x\n",
870	cchName, pProc->iSection, pProc->offSection, pProc->cbProc));
871	break;
872	}
873
874	}
875	}
876	/else: shorter records can be used for alignment, I guess. /
877
878	/* next */
879	uCursor.pu8 = pbRecStart + cbRec + 2;
880	cbSymTab -= cbRec + 2;
881	}
882	return rc;
883	}
884
885
886	/**
887	* Makes a copy of the CV8 source string table.
888	*
889	* It will be references in a subsequent source information table, and again by
890	* line number tables thru that.
891	*
892	* @returns IPRT status code
893	* @param pThis The CodeView debug info reader instance.
894	* @param pvSrcStrings The source string table.
895	* @param cbSrcStrings The size of the source strings.
896	* @param fFlags Flags reserved for future exploits, MBZ.
897	*/
898	static int rtDbgModCvSsProcessV8SrcStrings(PRTDBGMODCV pThis, void const *pvSrcStrings, size_t cbSrcStrings, uint32_t fFlags)
899	{
900	RT_NOREF_PV(fFlags);
901
902	if (pThis->cbSrcStrings)
903	Log(("\n!!More than one source file string table for this module!!\n\n"));
904
905	if (cbSrcStrings >= pThis->cbSrcStringsAlloc)
906	{
907	void *pvNew = RTMemRealloc(pThis->pchSrcStrings, cbSrcStrings + 1);
908	AssertReturn(pvNew, VERR_NO_MEMORY);
909	pThis->pchSrcStrings = (char *)pvNew;
910	pThis->cbSrcStringsAlloc = cbSrcStrings + 1;
911	}
912	memcpy(pThis->pchSrcStrings, pvSrcStrings, cbSrcStrings);
913	pThis->pchSrcStrings[cbSrcStrings] = '\0';
914	pThis->cbSrcStrings = cbSrcStrings;
915	Log2((" saved %#x bytes of CV8 source strings\n", cbSrcStrings));
916
917	if (LogIs3Enabled())
918	{
919	size_t iFile = 0;
920	size_t off = pThis->pchSrcStrings[0] != '\0' ? 0 : 1;
921	while (off < cbSrcStrings)
922	{
923	size_t cch = strlen(&pThis->pchSrcStrings[off]);
924	Log3((" %010zx #%03zu: %s\n", off, iFile, &pThis->pchSrcStrings[off]));
925	off += cch + 1;
926	iFile++;
927	}
928	}
929
930	return VINF_SUCCESS;
931	}
932
933
934	/**
935	* Makes a copy of the CV8 source information table.
936	*
937	* It will be references in subsequent line number tables.
938	*
939	* @returns IPRT status code
940	* @param pThis The CodeView debug info reader instance.
941	* @param pvSrcInfo The source information table.
942	* @param cbSrcInfo The size of the source information table (bytes).
943	* @param fFlags Flags reserved for future exploits, MBZ.
944	*/
945	static int rtDbgModCvSsProcessV8SrcInfo(PRTDBGMODCV pThis, void const *pvSrcInfo, size_t cbSrcInfo, uint32_t fFlags)
946	{
947	RT_NOREF_PV(fFlags);
948
949	if (pThis->cbSrcInfo)
950	Log(("\n!!More than one source file info table for this module!!\n\n"));
951
952	if (cbSrcInfo + sizeof(RTCV8SRCINFO) > pThis->cbSrcInfoAlloc)
953	{
954	void *pvNew = RTMemRealloc(pThis->pbSrcInfo, cbSrcInfo + sizeof(RTCV8SRCINFO));
955	AssertReturn(pvNew, VERR_NO_MEMORY);
956	pThis->pbSrcInfo = (uint8_t *)pvNew;
957	pThis->cbSrcInfoAlloc = cbSrcInfo + sizeof(RTCV8SRCINFO);
958	}
959	memcpy(pThis->pbSrcInfo, pvSrcInfo, cbSrcInfo);
960	memset(&pThis->pbSrcInfo[cbSrcInfo], 0, sizeof(RTCV8SRCINFO));
961	pThis->cbSrcInfo = cbSrcInfo;
962	Log2((" saved %#x bytes of CV8 source file info\n", cbSrcInfo));
963	return VINF_SUCCESS;
964	}
965
966
967	/**
968	* Makes a copy of the CV8 source string table.
969	*
970	* It will be references in subsequent line number tables.
971	*
972	* @returns IPRT status code
973	* @param pThis The CodeView debug info reader instance.
974	* @param pvSectLines The section source line table.
975	* @param cbSectLines The size of the section source line table.
976	* @param fFlags Flags reserved for future exploits, MBZ.
977	*/
978	static int rtDbgModCvSsProcessV8SectLines(PRTDBGMODCV pThis, void const *pvSectLines, size_t cbSectLines, uint32_t fFlags)
979	{
980	RT_NOREF_PV(fFlags);
981
982	/*
983	* Starts with header.
984	*/
985	PCRTCV8LINESHDR pHdr = (PCRTCV8LINESHDR)pvSectLines;
986	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbSectLines >= sizeof(*pHdr));
987	cbSectLines -= sizeof(*pHdr);
988	Log2(("RTDbgModCv: seg #%u, off %#x LB %#x \n", pHdr->iSection, pHdr->offSection, pHdr->cbSectionCovered));
989
990	RTCPTRUNION uCursor;
991	uCursor.pv = pHdr + 1;
992	while (cbSectLines > 0)
993	{
994	/* Source file header. */
995	PCRTCV8LINESSRCMAP pSrcHdr = (PCRTCV8LINESSRCMAP)uCursor.pv;
996	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbSectLines >= sizeof(*pSrcHdr));
997	RTDBGMODCV_CHECK_NOMSG_RET_BF(pSrcHdr->cb == pSrcHdr->cLines * sizeof(RTCV8LINEPAIR) + sizeof(RTCV8LINESSRCMAP));
998	RTDBGMODCV_CHECK_RET_BF(!(pSrcHdr->offSourceInfo & 3), ("offSourceInfo=%#x\n", pSrcHdr->offSourceInfo));
999	if (pSrcHdr->offSourceInfo + sizeof(uint32_t) <= pThis->cbSrcInfo)
1000	{
1001	PCRTCV8SRCINFO pSrcInfo = (PCRTCV8SRCINFO)&pThis->pbSrcInfo[pSrcHdr->offSourceInfo];
1002	const char *pszName = pSrcInfo->offSourceName < pThis->cbSrcStrings
1003	? &pThis->pchSrcStrings[pSrcInfo->offSourceName] : "unknown.c";
1004	pszName = rtDbgModCvAddSanitizedStringToCache(pszName, RTSTR_MAX);
1005	Log2(("RTDbgModCv: #%u lines, %#x bytes, %#x=%s\n", pSrcHdr->cLines, pSrcHdr->cb, pSrcInfo->offSourceName, pszName));
1006
1007	if (pszName)
1008	{
1009	/* Process the line/offset pairs. */
1010	uint32_t cLeft = pSrcHdr->cLines;
1011	PCRTCV8LINEPAIR pPair = (PCRTCV8LINEPAIR)(pSrcHdr + 1);
1012	while (cLeft-- > 0)
1013	{
1014	uint32_t idxSeg = pHdr->iSection;
1015	uint64_t off = pPair->offSection + pHdr->offSection;
1016	int rc = rtDbgModCvAdjustSegAndOffset(pThis, &idxSeg, &off);
1017	if (RT_SUCCESS(rc))
1018	rc = RTDbgModLineAdd(pThis->hCnt, pszName, pPair->uLineNumber, idxSeg, off, NULL);
1019	if (RT_SUCCESS(rc))
1020	Log3(("RTDbgModCv: %#x:%#010llx %0u\n", idxSeg, off, pPair->uLineNumber));
1021	else
1022	Log(( "RTDbgModCv: %#x:%#010llx %0u - rc=%Rrc!! (org: idxSeg=%#x off=%#x)\n",
1023	idxSeg, off, pPair->uLineNumber, rc, pHdr->iSection, pPair->offSection));
1024
1025	/* next */
1026	pPair++;
1027	}
1028	Assert((uintptr_t)pPair - (uintptr_t)pSrcHdr == pSrcHdr->cb);
1029	}
1030	}
1031	else
1032	Log(("RTDbgModCv: offSourceInfo=%#x cbSrcInfo=%#x!\n", pSrcHdr->offSourceInfo, pThis->cbSrcInfo));
1033
1034	/* next */
1035	cbSectLines -= pSrcHdr->cb;
1036	uCursor.pu8 += pSrcHdr->cb;
1037	}
1038
1039	return VINF_SUCCESS;
1040	}
1041
1042
1043
1044	/**
1045	* Parses a CV8 symbol table, adding symbols to the container.
1046	*
1047	* @returns IPRT status code
1048	* @param pThis The CodeView debug info reader instance.
1049	* @param pvSymTab The symbol table.
1050	* @param cbSymTab The size of the symbol table.
1051	* @param fFlags Flags reserved for future exploits, MBZ.
1052	*/
1053	static int rtDbgModCvSsProcessV8SymTab(PRTDBGMODCV pThis, void const *pvSymTab, size_t cbSymTab, uint32_t fFlags)
1054	{
1055	size_t const cbSymTabSaved = cbSymTab;
1056	int rc = VINF_SUCCESS;
1057
1058	/*
1059	* First pass looks for source information and source strings tables.
1060	* Microsoft puts the 0xf3 and 0xf4 last, usually with 0xf4 first.
1061	*
1062	* We ASSUME one string and one info table per module!
1063	*/
1064	RTCPTRUNION uCursor;
1065	uCursor.pv = pvSymTab;
1066	for (;;)
1067	{
1068	RTDBGMODCV_CHECK_RET_BF(cbSymTab > sizeof(RTCV8SYMBOLSBLOCK), ("cbSymTab=%zu\n", cbSymTab));
1069	PCRTCV8SYMBOLSBLOCK pBlockHdr = (PCRTCV8SYMBOLSBLOCK)uCursor.pv;
1070	Log3((" %p: pass #1 uType=%#04x LB %#x\n", (uint8_t )pBlockHdr - (uint8_t )pvSymTab, pBlockHdr->uType, pBlockHdr->cb));
1071	RTDBGMODCV_CHECK_RET_BF(pBlockHdr->cb <= cbSymTab - sizeof(RTCV8SYMBOLSBLOCK),
1072	("cb=%#u cbSymTab=%zu\n", pBlockHdr->cb, cbSymTab));
1073
1074	switch (pBlockHdr->uType)
1075	{
1076	case RTCV8SYMBLOCK_TYPE_SRC_STR:
1077	rc = rtDbgModCvSsProcessV8SrcStrings(pThis, pBlockHdr + 1, pBlockHdr->cb, fFlags);
1078	break;
1079
1080	case RTCV8SYMBLOCK_TYPE_SRC_INFO:
1081	rc = rtDbgModCvSsProcessV8SrcInfo(pThis, pBlockHdr + 1, pBlockHdr->cb, fFlags);
1082	break;
1083
1084	case RTCV8SYMBLOCK_TYPE_SECT_LINES:
1085	case RTCV8SYMBLOCK_TYPE_SYMBOLS:
1086	break;
1087	default:
1088	Log(("rtDbgModCvSsProcessV8SymTab: Unknown block type %#x (LB %#x)\n", pBlockHdr->uType, pBlockHdr->cb));
1089	break;
1090	}
1091	uint32_t cbAligned = RT_ALIGN_32(sizeof(*pBlockHdr) + pBlockHdr->cb, 4);
1092	if (RT_SUCCESS(rc) && cbSymTab > cbAligned)
1093	{
1094	uCursor.pu8 += cbAligned;
1095	cbSymTab -= cbAligned;
1096	}
1097	else
1098	break;
1099	}
1100
1101	/*
1102	* Log the source info now that we've gathered both it and the strings.
1103	*/
1104	if (LogIs3Enabled() && pThis->cbSrcInfo)
1105	{
1106	Log3((" Source file info table:\n"));
1107	size_t iFile = 0;
1108	size_t off = 0;
1109	while (off + 4 <= pThis->cbSrcInfo)
1110	{
1111	PCRTCV8SRCINFO pSrcInfo = (PCRTCV8SRCINFO)&pThis->pbSrcInfo[off];
1112	#ifdef LOG_ENABLED
1113	const char *pszName = pSrcInfo->offSourceName < pThis->cbSrcStrings
1114	? &pThis->pchSrcStrings[pSrcInfo->offSourceName] : "out-of-bounds.c!";
1115	if (pSrcInfo->uDigestType == RTCV8SRCINFO_DIGEST_TYPE_MD5)
1116	Log3((" %010zx #%03zu: %RTuuid %#x=%s\n", off, iFile, &pSrcInfo->Digest.md5, pSrcInfo->offSourceName, pszName));
1117	else if (pSrcInfo->uDigestType == RTCV8SRCINFO_DIGEST_TYPE_NONE)
1118	Log3((" %010zx #%03zu: <none> %#x=%s\n", off, iFile, pSrcInfo->offSourceName, pszName));
1119	else
1120	Log3((" %010zx #%03zu: !%#x! %#x=%s\n", off, iFile, pSrcInfo->uDigestType, pSrcInfo->offSourceName, pszName));
1121	#endif
1122	off += pSrcInfo->uDigestType == RTCV8SRCINFO_DIGEST_TYPE_MD5 ? sizeof(*pSrcInfo) : 8;
1123	iFile++;
1124	}
1125	}
1126
1127	/*
1128	* Second pass, process symbols and line numbers.
1129	*/
1130	uCursor.pv = pvSymTab;
1131	cbSymTab = cbSymTabSaved;
1132	for (;;)
1133	{
1134	RTDBGMODCV_CHECK_RET_BF(cbSymTab > sizeof(RTCV8SYMBOLSBLOCK), ("cbSymTab=%zu\n", cbSymTab));
1135	PCRTCV8SYMBOLSBLOCK pBlockHdr = (PCRTCV8SYMBOLSBLOCK)uCursor.pv;
1136	Log3((" %p: pass #2 uType=%#04x LB %#x\n", (uint8_t )pBlockHdr - (uint8_t )pvSymTab, pBlockHdr->uType, pBlockHdr->cb));
1137	RTDBGMODCV_CHECK_RET_BF(pBlockHdr->cb <= cbSymTab - sizeof(RTCV8SYMBOLSBLOCK),
1138	("cb=%#u cbSymTab=%zu\n", pBlockHdr->cb, cbSymTab));
1139
1140	switch (pBlockHdr->uType)
1141	{
1142	case RTCV8SYMBLOCK_TYPE_SYMBOLS:
1143	rc = rtDbgModCvSsProcessV4PlusSymTab(pThis, pBlockHdr + 1, pBlockHdr->cb, fFlags);
1144	break;
1145
1146	case RTCV8SYMBLOCK_TYPE_SECT_LINES:
1147	rc = rtDbgModCvSsProcessV8SectLines(pThis, pBlockHdr + 1, pBlockHdr->cb, fFlags);
1148	break;
1149
1150	case RTCV8SYMBLOCK_TYPE_SRC_INFO:
1151	case RTCV8SYMBLOCK_TYPE_SRC_STR:
1152	break;
1153	default:
1154	Log(("rtDbgModCvSsProcessV8SymTab: Unknown block type %#x (LB %#x)\n", pBlockHdr->uType, pBlockHdr->cb));
1155	break;
1156	}
1157	uint32_t cbAligned = RT_ALIGN_32(sizeof(*pBlockHdr) + pBlockHdr->cb, 4);
1158	if (RT_SUCCESS(rc) && cbSymTab > cbAligned)
1159	{
1160	uCursor.pu8 += cbAligned;
1161	cbSymTab -= cbAligned;
1162	}
1163	else
1164	break;
1165	}
1166	return rc;
1167	}
1168
1169
1170	/** @callback_method_impl{FNDBGMODCVSUBSECTCALLBACK,
1171	* Parses kCvSst_GlobalPub\, kCvSst_GlobalSym and kCvSst_StaticSym subsections\,
1172	* adding symbols it finds to the container.} */
1173	static DECLCALLBACK(int)
1174	rtDbgModCvSs_GlobalPub_GlobalSym_StaticSym(PRTDBGMODCV pThis, void const *pvSubSect, size_t cbSubSect, PCRTCVDIRENT32 pDirEnt)
1175	{
1176	PCRTCVGLOBALSYMTABHDR pHdr = (PCRTCVGLOBALSYMTABHDR)pvSubSect;
1177	RT_NOREF_PV(pDirEnt);
1178
1179	/*
1180	* Quick data validation.
1181	*/
1182	Log2(("RTDbgModCv: %s: uSymHash=%#x uAddrHash=%#x cbSymbols=%#x cbSymHash=%#x cbAddrHash=%#x\n",
1183	rtDbgModCvGetSubSectionName(pDirEnt->uSubSectType), pHdr->uSymHash,
1184	pHdr->uAddrHash, pHdr->cbSymbols, pHdr->cbSymHash, pHdr->cbAddrHash));
1185	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbSubSect >= sizeof(RTCVGLOBALSYMTABHDR));
1186	RTDBGMODCV_CHECK_NOMSG_RET_BF((uint64_t)pHdr->cbSymbols + pHdr->cbSymHash + pHdr->cbAddrHash <= cbSubSect - sizeof(*pHdr));
1187	RTDBGMODCV_CHECK_NOMSG_RET_BF(pHdr->uSymHash < 0x20);
1188	RTDBGMODCV_CHECK_NOMSG_RET_BF(pHdr->uAddrHash < 0x20);
1189	if (!pHdr->cbSymbols)
1190	return VINF_SUCCESS;
1191
1192	/*
1193	* Parse the symbols.
1194	*/
1195	return rtDbgModCvSsProcessV4PlusSymTab(pThis, pHdr + 1, pHdr->cbSymbols, 0);
1196	}
1197
1198
1199	/** @callback_method_impl{FNDBGMODCVSUBSECTCALLBACK,
1200	* Parses kCvSst_Module subsection\, storing the debugging style in pThis.} */
1201	static DECLCALLBACK(int)
1202	rtDbgModCvSs_Module(PRTDBGMODCV pThis, void const *pvSubSect, size_t cbSubSect, PCRTCVDIRENT32 pDirEnt)
1203	{
1204	RT_NOREF_PV(pDirEnt);
1205
1206	RTCPTRUNION uCursor;
1207	uCursor.pv = pvSubSect;
1208	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbSubSect >= 2 + 2 + 2 + 2 + 0 + 1);
1209	uint16_t iOverlay = *uCursor.pu16++; NOREF(iOverlay);
1210	uint16_t iLib = *uCursor.pu16++; NOREF(iLib);
1211	uint16_t cSegs = *uCursor.pu16++;
1212	pThis->uCurStyle = *uCursor.pu16++;
1213	if (pThis->uCurStyle == 0)
1214	pThis->uCurStyle = RT_MAKE_U16('C', 'V');
1215	pThis->uCurStyleVer = 0;
1216	pThis->cbSrcInfo = 0;
1217	pThis->cbSrcStrings = 0;
1218	uint8_t cchName = uCursor.pu8[cSegs * 12];
1219	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbSubSect >= 2 + 2 + 2 + 2 + cSegs * 12U + 1 + cchName);
1220
1221	#ifdef LOG_ENABLED
1222	const char pchName = (const char )&uCursor.pu8[cSegs * 12 + 1];
1223	Log2(("RTDbgModCv: Module: iOverlay=%#x iLib=%#x cSegs=%#x Style=%c%c (%#x) %.*s\n", iOverlay, iLib, cSegs,
1224	RT_BYTE1(pThis->uCurStyle), RT_BYTE2(pThis->uCurStyle), pThis->uCurStyle, cchName, pchName));
1225	#endif
1226	RTDBGMODCV_CHECK_NOMSG_RET_BF(pThis->uCurStyle == RT_MAKE_U16('C', 'V'));
1227
1228	#ifdef LOG_ENABLED
1229	PCRTCVMODSEGINFO32 paSegs = (PCRTCVMODSEGINFO32)uCursor.pv;
1230	for (uint16_t iSeg = 0; iSeg < cSegs; iSeg++)
1231	Log2((" #%02u: %04x:%08x LB %08x\n", iSeg, paSegs[iSeg].iSeg, paSegs[iSeg].off, paSegs[iSeg].cb));
1232	#endif
1233
1234	return VINF_SUCCESS;
1235	}
1236
1237
1238	/** @callback_method_impl{FNDBGMODCVSUBSECTCALLBACK,
1239	* Parses kCvSst_Symbols\, kCvSst_PublicSym and kCvSst_AlignSym subsections\,
1240	* adding symbols it finds to the container.} */
1241	static DECLCALLBACK(int)
1242	rtDbgModCvSs_Symbols_PublicSym_AlignSym(PRTDBGMODCV pThis, void const *pvSubSect, size_t cbSubSect, PCRTCVDIRENT32 pDirEnt)
1243	{
1244	RT_NOREF_PV(pDirEnt);
1245	RTDBGMODCV_CHECK_NOMSG_RET_BF(pThis->uCurStyle == RT_MAKE_U16('C', 'V'));
1246	RTDBGMODCV_CHECK_NOMSG_RET_BF(cbSubSect >= 8);
1247
1248	uint32_t u32Signature = (uint32_t const )pvSubSect;
1249	RTDBGMODCV_CHECK_RET_BF(u32Signature == RTCVSYMBOLS_SIGNATURE_CV4 \|\| u32Signature == RTCVSYMBOLS_SIGNATURE_CV8,
1250	("%#x, expected %#x\n", u32Signature, RTCVSYMBOLS_SIGNATURE_CV4));
1251	if (u32Signature == RTCVSYMBOLS_SIGNATURE_CV8)
1252	return rtDbgModCvSsProcessV8SymTab(pThis, (uint8_t const *)pvSubSect + 4, cbSubSect - 4, 0);
1253	return rtDbgModCvSsProcessV4PlusSymTab(pThis, (uint8_t const *)pvSubSect + 4, cbSubSect - 4, 0);
1254	}
1255
1256
1257	/** @callback_method_impl{FNDBGMODCVSUBSECTCALLBACK,
1258	* Parses kCvSst_SrcModule adding line numbers it finds to the container.}
1259	*/
1260	static DECLCALLBACK(int)
1261	rtDbgModCvSs_SrcModule(PRTDBGMODCV pThis, void const *pvSubSect, size_t cbSubSect, PCRTCVDIRENT32 pDirEnt)
1262	{
1263	RT_NOREF_PV(pDirEnt);
1264	Log(("rtDbgModCvSs_SrcModule: uCurStyle=%#x\n%.*Rhxd\n", pThis->uCurStyle, cbSubSect, pvSubSect));
1265
1266	/* Check the header. */
1267	PCRTCVSRCMODULE pHdr = (PCRTCVSRCMODULE)pvSubSect;
1268	AssertReturn(cbSubSect >= RT_UOFFSETOF(RTCVSRCMODULE, aoffSrcFiles), VERR_CV_BAD_FORMAT);
1269	size_t cbHdr = sizeof(RTCVSRCMODULE)
1270	+ pHdr->cFiles * sizeof(uint32_t)
1271	+ pHdr->cSegs * sizeof(uint32_t) * 2
1272	+ pHdr->cSegs * sizeof(uint16_t);
1273	Log2(("RTDbgModCv: SrcModule: cFiles=%u cSegs=%u\n", pHdr->cFiles, pHdr->cFiles));
1274	RTDBGMODCV_CHECK_RET_BF(cbSubSect >= cbHdr, ("cbSubSect=%#x cbHdr=%zx\n", cbSubSect, cbHdr));
1275	#ifdef LOG_ENABLED
1276	if (LogIs2Enabled())
1277	{
1278	for (uint32_t i = 0; i < pHdr->cFiles; i++)
1279	Log2(("RTDbgModCv: source file #%u: %#x\n", i, pHdr->aoffSrcFiles[i]));
1280	PCRTCVSRCRANGE paSegRanges = (PCRTCVSRCRANGE)&pHdr->aoffSrcFiles[pHdr->cFiles];
1281	uint16_t const paidxSegs = (uint16_t const )&paSegRanges[pHdr->cSegs];
1282	for (uint32_t i = 0; i < pHdr->cSegs; i++)
1283	Log2(("RTDbgModCv: seg #%u: %#010x-%#010x\n", paidxSegs[i], paSegRanges[i].offStart, paSegRanges[i].offEnd));
1284	}
1285	#endif
1286
1287	/*
1288	* Work over the source files.
1289	*/
1290	for (uint32_t i = 0; i < pHdr->cFiles; i++)
1291	{
1292	uint32_t const offSrcFile = pHdr->aoffSrcFiles[i];
1293	RTDBGMODCV_CHECK_RET_BF(cbSubSect - RT_UOFFSETOF(RTCVSRCFILE, aoffSrcLines) >= offSrcFile,
1294	("cbSubSect=%#x (- %#x) aoffSrcFiles[%u]=%#x\n",
1295	cbSubSect, RT_UOFFSETOF(RTCVSRCFILE, aoffSrcLines), i, offSrcFile));
1296	PCRTCVSRCFILE pSrcFile = (PCRTCVSRCFILE)((uint8_t const *)pvSubSect + offSrcFile);
1297	size_t cbSrcFileHdr = RT_UOFFSETOF_DYN(RTCVSRCFILE, aoffSrcLines[pSrcFile->cSegs])
1298	+ sizeof(RTCVSRCRANGE) * pSrcFile->cSegs
1299	+ sizeof(uint8_t);
1300	RTDBGMODCV_CHECK_RET_BF(cbSubSect >= offSrcFile + cbSrcFileHdr && cbSubSect > cbSrcFileHdr,
1301	("cbSubSect=%#x aoffSrcFiles[%u]=%#x cbSrcFileHdr=%#x\n", cbSubSect, offSrcFile, i, cbSrcFileHdr));
1302	PCRTCVSRCRANGE paSegRanges = (PCRTCVSRCRANGE)&pSrcFile->aoffSrcLines[pSrcFile->cSegs];
1303	uint8_t const pcchName = (uint8_t const )&paSegRanges[pSrcFile->cSegs]; /** @todo TIS NB09 docs say 16-bit length... */
1304	const char pchName = (const char )(pcchName + 1);
1305	RTDBGMODCV_CHECK_RET_BF(cbSubSect >= offSrcFile + cbSrcFileHdr + *pcchName,
1306	("cbSubSect=%#x offSrcFile=%#x cbSubSect=%#x *pcchName=%#x\n",
1307	cbSubSect, offSrcFile, cbSubSect, *pcchName));
1308	Log2(("RTDbgModCv: source file #%u/%#x: cSegs=%#x '%.s'\n", i, offSrcFile, pSrcFile->cSegs, pcchName, pchName));
1309	const char pszName = rtDbgModCvAddSanitizedStringToCache(pchName, pcchName);
1310
1311	/*
1312	* Work the segments this source file contributes code to.
1313	*/
1314	for (uint32_t iSeg = 0; iSeg < pSrcFile->cSegs; iSeg++)
1315	{
1316	uint32_t const offSrcLine = pSrcFile->aoffSrcLines[iSeg];
1317	RTDBGMODCV_CHECK_RET_BF(cbSubSect - RT_UOFFSETOF(RTCVSRCLINE, aoffLines) >= offSrcLine,
1318	("cbSubSect=%#x (- %#x) aoffSrcFiles[%u]=%#x\n",
1319	cbSubSect, RT_UOFFSETOF(RTCVSRCLINE, aoffLines), iSeg, offSrcLine));
1320	PCRTCVSRCLINE pSrcLine = (PCRTCVSRCLINE)((uint8_t const *)pvSubSect + offSrcLine);
1321	size_t cbSrcLine = RT_UOFFSETOF_DYN(RTCVSRCLINE, aoffLines[pSrcLine->cPairs])
1322	+ pSrcLine->cPairs * sizeof(uint16_t);
1323	RTDBGMODCV_CHECK_RET_BF(cbSubSect >= offSrcLine + cbSrcLine,
1324	("cbSubSect=%#x aoffSrcFiles[%u]=%#x cbSrcLine=%#x\n",
1325	cbSubSect, iSeg, offSrcLine, cbSrcLine));
1326	uint16_t const paiLines = (uint16_t const )&pSrcLine->aoffLines[pSrcLine->cPairs];
1327	Log2(("RTDbgModCv: seg #%u, %u pairs (off %#x)\n", pSrcLine->idxSeg, pSrcLine->cPairs, offSrcLine));
1328	for (uint32_t iPair = 0; iPair < pSrcLine->cPairs; iPair++)
1329	{
1330
1331	uint32_t idxSeg = pSrcLine->idxSeg;
1332	uint64_t off = pSrcLine->aoffLines[iPair];
1333	int rc = rtDbgModCvAdjustSegAndOffset(pThis, &idxSeg, &off);
1334	if (RT_SUCCESS(rc))
1335	rc = RTDbgModLineAdd(pThis->hCnt, pszName, paiLines[iPair], idxSeg, off, NULL);
1336	if (RT_SUCCESS(rc))
1337	Log3(("RTDbgModCv: %#x:%#010llx %0u\n", idxSeg, off, paiLines[iPair]));
1338	/* Note! Wlink produces the sstSrcModule subsections from LINNUM records, however the
1339	CVGenLines() function assumes there is only one segment contributing to the
1340	line numbers. So, when we do assembly that jumps between segments, it emits
1341	the wrong addresses for some line numbers and we end up here, typically with
1342	VERR_DBG_ADDRESS_CONFLICT. */
1343	else
1344	Log(( "RTDbgModCv: %#x:%#010llx %0u - rc=%Rrc!! (org: idxSeg=%#x off=%#x)\n",
1345	idxSeg, off, paiLines[iPair], rc, pSrcLine->idxSeg, pSrcLine->aoffLines[iPair]));
1346	}
1347	}
1348	}
1349
1350	return VINF_SUCCESS;
1351	}
1352
1353
1354	/**
1355	* Processes a freshly loaded raw segment (section) map.
1356	*
1357	* This is used by both CV and PDB module types.
1358	*/
1359	static int rtDbgModCvProcessSegmentMap(PRTDBGMODCV pThis)
1360	{
1361	/* Use local pointers to avoid lots of indirection and typing. */
1362	PCRTCVSEGMAPHDR pHdr = &pThis->pSegMap->Hdr;
1363	PRTCVSEGMAPDESC paDescs = &pThis->pSegMap->aDescs[0];
1364
1365	/*
1366	* If there are only logical segments, assume a direct mapping.
1367	* PE images, like the NT4 kernel, does it like this.
1368	*/
1369	bool const fNoGroups = pHdr->cSegs == pHdr->cLogSegs;
1370
1371	/*
1372	* The PE image has an extra section/segment for the headers, the others
1373	* doesn't. PE images doesn't have DOS frames. So, figure the image type now.
1374	*/
1375	RTLDRFMT enmImgFmt = RTLDRFMT_INVALID;
1376	if (pThis->pMod->pImgVt)
1377	enmImgFmt = pThis->pMod->pImgVt->pfnGetFormat(pThis->pMod);
1378
1379	/*
1380	* Validate and display it all.
1381	*/
1382	Log2(("RTDbgModCv: SegMap: cSegs=%#x cLogSegs=%#x (cbSegNames=%#x)\n", pHdr->cSegs, pHdr->cLogSegs, pThis->cbSegNames));
1383	RTDBGMODCV_CHECK_NOMSG_RET_BF(pHdr->cSegs >= pHdr->cLogSegs);
1384
1385	Log2(("Logical segment descriptors: %u\n", pHdr->cLogSegs));
1386
1387	bool fHaveDosFrames = false;
1388	for (uint32_t i = 0; i < pHdr->cSegs; i++)
1389	{
1390	if (i == pHdr->cLogSegs)
1391	Log2(("Group/Physical descriptors: %u\n", pHdr->cSegs - pHdr->cLogSegs));
1392	char szFlags[16];
1393	memset(szFlags, '-', sizeof(szFlags));
1394	if (paDescs[i].fFlags & RTCVSEGMAPDESC_F_READ)
1395	szFlags[0] = 'R';
1396	if (paDescs[i].fFlags & RTCVSEGMAPDESC_F_WRITE)
1397	szFlags[1] = 'W';
1398	if (paDescs[i].fFlags & RTCVSEGMAPDESC_F_EXECUTE)
1399	szFlags[2] = 'X';
1400	if (paDescs[i].fFlags & RTCVSEGMAPDESC_F_32BIT)
1401	szFlags[3] = '3', szFlags[4] = '2';
1402	if (paDescs[i].fFlags & RTCVSEGMAPDESC_F_SEL)
1403	szFlags[5] = 'S';
1404	if (paDescs[i].fFlags & RTCVSEGMAPDESC_F_ABS)
1405	szFlags[6] = 'A';
1406	if (paDescs[i].fFlags & RTCVSEGMAPDESC_F_GROUP)
1407	szFlags[7] = 'G';
1408	szFlags[8] = '\0';
1409	if (paDescs[i].fFlags & RTCVSEGMAPDESC_F_RESERVED)
1410	szFlags[8] = '!', szFlags[9] = '\0';
1411	Log2((" #%02u: %#010x LB %#010x flags=%#06x ovl=%#06x group=%#06x frame=%#06x iSegName=%#06x iClassName=%#06x %s\n",
1412	i < pHdr->cLogSegs ? i : i - pHdr->cLogSegs, paDescs[i].off, paDescs[i].cb, paDescs[i].fFlags, paDescs[i].iOverlay,
1413	paDescs[i].iGroup, paDescs[i].iFrame, paDescs[i].offSegName, paDescs[i].offClassName, szFlags));
1414
1415	RTDBGMODCV_CHECK_NOMSG_RET_BF(paDescs[i].offSegName == UINT16_MAX \|\| paDescs[i].offSegName < pThis->cbSegNames);
1416	RTDBGMODCV_CHECK_NOMSG_RET_BF(paDescs[i].offClassName == UINT16_MAX \|\| paDescs[i].offClassName < pThis->cbSegNames);
1417	const char *pszName = paDescs[i].offSegName != UINT16_MAX
1418	? pThis->pszzSegNames + paDescs[i].offSegName
1419	: NULL;
1420	const char *pszClass = paDescs[i].offClassName != UINT16_MAX
1421	? pThis->pszzSegNames + paDescs[i].offClassName
1422	: NULL;
1423	if (pszName \|\| pszClass)
1424	Log2((" pszName=%s pszClass=%s\n", pszName, pszClass));
1425
1426	/* Validate the group link. */
1427	RTDBGMODCV_CHECK_NOMSG_RET_BF(paDescs[i].iGroup == 0 \|\| !(paDescs[i].fFlags & RTCVSEGMAPDESC_F_GROUP));
1428	RTDBGMODCV_CHECK_NOMSG_RET_BF( paDescs[i].iGroup == 0
1429	\|\| ( paDescs[i].iGroup >= pHdr->cLogSegs
1430	&& paDescs[i].iGroup < pHdr->cSegs));
1431	RTDBGMODCV_CHECK_NOMSG_RET_BF( paDescs[i].iGroup == 0
1432	\|\| (paDescs[paDescs[i].iGroup].fFlags & RTCVSEGMAPDESC_F_GROUP));
1433	RTDBGMODCV_CHECK_NOMSG_RET_BF(!(paDescs[i].fFlags & RTCVSEGMAPDESC_F_GROUP) \|\| paDescs[i].off == 0); /* assumed below */
1434
1435	if (fNoGroups)
1436	{
1437	RTDBGMODCV_CHECK_NOMSG_RET_BF(paDescs[i].iGroup == 0);
1438	if ( !fHaveDosFrames
1439	&& paDescs[i].iFrame != 0
1440	&& (paDescs[i].fFlags & (RTCVSEGMAPDESC_F_SEL \| RTCVSEGMAPDESC_F_ABS))
1441	&& paDescs[i].iOverlay == 0
1442	&& enmImgFmt != RTLDRFMT_PE
1443	&& pThis->enmType != RTCVFILETYPE_DBG
1444	&& pThis->enmType != RTCVFILETYPE_PDB)
1445	fHaveDosFrames = true; /* BIOS, only groups with frames. */
1446	}
1447	}
1448
1449	/*
1450	* Further valiations based on fHaveDosFrames or not.
1451	*/
1452	if (fNoGroups)
1453	{
1454	if (fHaveDosFrames)
1455	for (uint32_t i = 0; i < pHdr->cSegs; i++)
1456	{
1457	RTDBGMODCV_CHECK_NOMSG_RET_BF(paDescs[i].iOverlay == 0);
1458	RTDBGMODCV_CHECK_NOMSG_RET_BF( (paDescs[i].fFlags & (RTCVSEGMAPDESC_F_SEL \| RTCVSEGMAPDESC_F_ABS))
1459	== RTCVSEGMAPDESC_F_SEL
1460	\|\| (paDescs[i].fFlags & (RTCVSEGMAPDESC_F_SEL \| RTCVSEGMAPDESC_F_ABS))
1461	== RTCVSEGMAPDESC_F_ABS);
1462	RTDBGMODCV_CHECK_NOMSG_RET_BF(!(paDescs[i].fFlags & RTCVSEGMAPDESC_F_ABS));
1463	}
1464	else
1465	for (uint32_t i = 0; i < pHdr->cSegs; i++)
1466	RTDBGMODCV_CHECK_NOMSG_RET_BF(paDescs[i].off == 0);
1467	}
1468
1469	/*
1470	* Modify the groups index to be the loader segment index instead, also
1471	* add the segments to the container if we haven't done that already.
1472	*/
1473
1474	/* Guess work: Group can be implicit if used. Observed Visual C++ v1.5,
1475	omitting the CODE group. */
1476	const char *pszGroup0 = NULL;
1477	uint64_t cbGroup0 = 0;
1478	if (!fNoGroups && !fHaveDosFrames)
1479	{
1480	for (uint32_t i = 0; i < pHdr->cSegs; i++)
1481	if ( !(paDescs[i].fFlags & (RTCVSEGMAPDESC_F_GROUP \| RTCVSEGMAPDESC_F_ABS))
1482	&& paDescs[i].iGroup == 0)
1483	{
1484	if (pszGroup0 == NULL && paDescs[i].offClassName != UINT16_MAX)
1485	pszGroup0 = pThis->pszzSegNames + paDescs[i].offClassName;
1486	uint64_t offEnd = (uint64_t)paDescs[i].off + paDescs[i].cb;
1487	if (offEnd > cbGroup0)
1488	cbGroup0 = offEnd;
1489	}
1490	}
1491
1492	/* Add the segments.
1493	Note! The RVAs derived from this exercise are all wrong. :-/
1494	Note! We don't have an image loader, so we cannot add any fake sections. */
1495	/** @todo Try see if we can figure something out from the frame value later. */
1496	if (!pThis->fHaveLoadedSegments)
1497	{
1498	int rc = VINF_SUCCESS;
1499	uint16_t iSeg = 0;
1500	if (!fHaveDosFrames)
1501	{
1502	Assert(!pThis->pMod->pImgVt); Assert(pThis->enmType != RTCVFILETYPE_DBG);
1503	uint64_t uRva = 0;
1504	if (cbGroup0 && !fNoGroups)
1505	{
1506	rc = RTDbgModSegmentAdd(pThis->hCnt, 0, cbGroup0, pszGroup0 ? pszGroup0 : "Seg00", 0 /fFlags/, NULL);
1507	uRva += cbGroup0;
1508	iSeg++;
1509	}
1510
1511	for (uint32_t i = 0; RT_SUCCESS(rc) && i < pHdr->cSegs; i++)
1512	if ((paDescs[i].fFlags & RTCVSEGMAPDESC_F_GROUP) \|\| fNoGroups)
1513	{
1514	char szName[16];
1515	char *pszName = szName;
1516	if (paDescs[i].offSegName != UINT16_MAX)
1517	pszName = pThis->pszzSegNames + paDescs[i].offSegName;
1518	else
1519	RTStrPrintf(szName, sizeof(szName), "Seg%02u", iSeg);
1520	rc = RTDbgModSegmentAdd(pThis->hCnt, uRva, paDescs[i].cb, pszName, 0 /fFlags/, NULL);
1521	uRva += paDescs[i].cb;
1522	iSeg++;
1523	}
1524	}
1525	else
1526	{
1527	/* The map is not sorted by RVA, very annoying, but I'm countering
1528	by being lazy and slow about it. :-) Btw. this is the BIOS case. */
1529	Assert(fNoGroups);
1530	#if 1 /** @todo need more inputs */
1531
1532	/* Figure image base address. */
1533	uint64_t uImageBase = UINT64_MAX;
1534	for (uint32_t i = 0; RT_SUCCESS(rc) && i < pHdr->cSegs; i++)
1535	{
1536	uint64_t uAddr = (uint64_t)paDescs[i].off + ((uint32_t)paDescs[i].iFrame << 4);
1537	if (uAddr < uImageBase)
1538	uImageBase = uAddr;
1539	}
1540
1541	/* Add the segments. */
1542	uint64_t uMinAddr = uImageBase;
1543	for (uint32_t i = 0; RT_SUCCESS(rc) && i < pHdr->cSegs; i++)
1544	{
1545	/* Figure out the next one. */
1546	uint16_t cOverlaps = 0;
1547	uint16_t iBest = UINT16_MAX;
1548	uint64_t uBestAddr = UINT64_MAX;
1549	for (uint16_t j = 0; j < pHdr->cSegs; j++)
1550	{
1551	uint64_t uAddr = (uint64_t)paDescs[j].off + ((uint32_t)paDescs[j].iFrame << 4);
1552	if (uAddr >= uMinAddr && uAddr < uBestAddr)
1553	{
1554	uBestAddr = uAddr;
1555	iBest = j;
1556	}
1557	else if (uAddr == uBestAddr)
1558	{
1559	cOverlaps++;
1560	if (paDescs[j].cb > paDescs[iBest].cb)
1561	{
1562	uBestAddr = uAddr;
1563	iBest = j;
1564	}
1565	}
1566	}
1567	if (iBest == UINT16_MAX && RT_SUCCESS(rc))
1568	{
1569	rc = VERR_CV_IPE;
1570	break;
1571	}
1572
1573	/* Add it. */
1574	char szName[16];
1575	char *pszName = szName;
1576	if (paDescs[iBest].offSegName != UINT16_MAX)
1577	pszName = pThis->pszzSegNames + paDescs[iBest].offSegName;
1578	else
1579	RTStrPrintf(szName, sizeof(szName), "Seg%02u", iSeg);
1580	RTDBGSEGIDX idxDbgSeg = NIL_RTDBGSEGIDX;
1581	rc = RTDbgModSegmentAdd(pThis->hCnt, uBestAddr - uImageBase, paDescs[iBest].cb, pszName, 0 /fFlags/, &idxDbgSeg);
1582	Log(("CV: %#010x LB %#010x %s uRVA=%#010x iBest=%u cOverlaps=%u [idxDbgSeg=%#x iSeg=%#x]\n",
1583	uBestAddr, paDescs[iBest].cb, szName, uBestAddr - uImageBase, iBest, cOverlaps, idxDbgSeg, idxDbgSeg));
1584
1585	/* Update translations. */
1586	paDescs[iBest].iGroup = iSeg;
1587	if (cOverlaps > 0)
1588	{
1589	for (uint16_t j = 0; j < pHdr->cSegs; j++)
1590	if ((uint64_t)paDescs[j].off + ((uint32_t)paDescs[j].iFrame << 4) == uBestAddr)
1591	paDescs[iBest].iGroup = iSeg;
1592	i += cOverlaps;
1593	}
1594
1595	/* Advance. */
1596	uMinAddr = uBestAddr + 1;
1597	iSeg++;
1598	}
1599
1600	pThis->fHaveDosFrames = true;
1601	#else
1602	uint32_t iFrameFirst = UINT32_MAX;
1603	uint16_t iSeg = 0;
1604	uint32_t iFrameMin = 0;
1605	do
1606	{
1607	/* Find next frame. */
1608	uint32_t iFrame = UINT32_MAX;
1609	for (uint16_t j = 0; j < pHdr->cSegs; j++)
1610	if (paDescs[j].iFrame >= iFrameMin && paDescs[j].iFrame < iFrame)
1611	iFrame = paDescs[j].iFrame;
1612	if (iFrame == UINT32_MAX)
1613	break;
1614
1615	/* Figure the frame span. */
1616	uint32_t offFirst = UINT32_MAX;
1617	uint64_t offEnd = 0;
1618	for (uint16_t j = 0; j < pHdr->cSegs; j++)
1619	if (paDescs[j].iFrame == iFrame)
1620	{
1621	uint64_t offThisEnd = paDescs[j].off + paDescs[j].cb;
1622	if (offThisEnd > offEnd)
1623	offEnd = offThisEnd;
1624	if (paDescs[j].off < offFirst)
1625	offFirst = paDescs[j].off;
1626	}
1627
1628	if (offFirst < offEnd)
1629	{
1630	/* Add it. */
1631	char szName[16];
1632	RTStrPrintf(szName, sizeof(szName), "Frame_%04x", iFrame);
1633	Log(("CV: %s offEnd=%#x offFirst=%#x\n", szName, offEnd, offFirst));
1634	if (iFrameFirst == UINT32_MAX)
1635	iFrameFirst = iFrame;
1636	rc = RTDbgModSegmentAdd(pThis->hCnt, (iFrame - iFrameFirst) << 4, offEnd, szName, 0 /fFlags/, NULL);
1637
1638	/* Translation updates. */
1639	for (uint16_t j = 0; j < pHdr->cSegs; j++)
1640	if (paDescs[j].iFrame == iFrame)
1641	{
1642	paDescs[j].iGroup = iSeg;
1643	paDescs[j].off = 0;
1644	paDescs[j].cb = offEnd > UINT32_MAX ? UINT32_MAX : (uint32_t)offEnd;
1645	}
1646
1647	iSeg++;
1648	}
1649
1650	iFrameMin = iFrame + 1;
1651	} while (RT_SUCCESS(rc));
1652	#endif
1653	}
1654
1655	if (RT_FAILURE(rc))
1656	{
1657	Log(("RTDbgModCv: %Rrc while adding segments from SegMap\n", rc));
1658	return rc;
1659	}
1660
1661	pThis->fHaveLoadedSegments = true;
1662
1663	/* Skip the stuff below if we have DOS frames since we did it all above. */
1664	if (fHaveDosFrames)
1665	return VINF_SUCCESS;
1666	}
1667
1668	/* Pass one: Fixate the group segment indexes. */
1669	uint16_t iSeg0 = enmImgFmt == RTLDRFMT_PE \|\| pThis->enmType == RTCVFILETYPE_DBG \|\| pThis->enmType == RTCVFILETYPE_PDB ? 1 : 0;
1670	uint16_t iSeg = iSeg0 + (cbGroup0 > 0); /** @todo probably wrong... */
1671	for (uint32_t i = 0; i < pHdr->cSegs; i++)
1672	if (paDescs[i].fFlags & RTCVSEGMAPDESC_F_ABS)
1673	paDescs[i].iGroup = (uint16_t)(RTDBGSEGIDX_ABS & UINT16_MAX);
1674	else if ((paDescs[i].fFlags & RTCVSEGMAPDESC_F_GROUP) \|\| fNoGroups)
1675	paDescs[i].iGroup = iSeg++;
1676
1677	/* Pass two: Resolve group references in to segment indexes. */
1678	Log2(("Mapped segments (both kinds):\n"));
1679	for (uint32_t i = 0; i < pHdr->cSegs; i++)
1680	{
1681	if (!fNoGroups && !(paDescs[i].fFlags & (RTCVSEGMAPDESC_F_GROUP \| RTCVSEGMAPDESC_F_ABS)))
1682	paDescs[i].iGroup = paDescs[i].iGroup == 0 ? iSeg0 : paDescs[paDescs[i].iGroup].iGroup;
1683
1684	Log2((" #%02u: %#010x LB %#010x -> %#06x (flags=%#06x ovl=%#06x frame=%#06x)\n",
1685	i, paDescs[i].off, paDescs[i].cb, paDescs[i].iGroup,
1686	paDescs[i].fFlags, paDescs[i].iOverlay, paDescs[i].iFrame));
1687	}
1688
1689	return VINF_SUCCESS;
1690	}
1691
1692
1693	/**
1694	* Loads and processes the segment map.
1695	*/
1696	static int rtDbgModCvLoadSegmentMap(PRTDBGMODCV pThis)
1697	{
1698	/*
1699	* Search for the segment map and segment names. They will be at the end of the directory.
1700	*/
1701	uint32_t iSegMap = UINT32_MAX;
1702	uint32_t iSegNames = UINT32_MAX;
1703	uint32_t i = pThis->cDirEnts;
1704	while (i-- > 0)
1705	{
1706	if ( pThis->paDirEnts[i].iMod != 0xffff
1707	&& pThis->paDirEnts[i].iMod != 0x0000)
1708	break;
1709	if (pThis->paDirEnts[i].uSubSectType == kCvSst_SegMap)
1710	iSegMap = i;
1711	else if (pThis->paDirEnts[i].uSubSectType == kCvSst_SegName)
1712	iSegNames = i;
1713	}
1714	if (iSegMap == UINT32_MAX)
1715	{
1716	Log(("RTDbgModCv: No segment map present, using segment indexes as is then...\n"));
1717	return VINF_SUCCESS;
1718	}
1719	RTDBGMODCV_CHECK_RET_BF(pThis->paDirEnts[iSegMap].cb >= sizeof(RTCVSEGMAPHDR),
1720	("Bad sstSegMap entry: cb=%#x\n", pThis->paDirEnts[iSegMap].cb));
1721	RTDBGMODCV_CHECK_NOMSG_RET_BF(iSegNames == UINT32_MAX \|\| pThis->paDirEnts[iSegNames].cb > 0);
1722
1723	/*
1724	* Read them into memory.
1725	*/
1726	int rc = rtDbgModCvReadAtAlloc(pThis, pThis->paDirEnts[iSegMap].off, (void **)&pThis->pSegMap,
1727	pThis->paDirEnts[iSegMap].cb);
1728	if (iSegNames != UINT32_MAX && RT_SUCCESS(rc))
1729	{
1730	pThis->cbSegNames = pThis->paDirEnts[iSegNames].cb;
1731	rc = rtDbgModCvReadAtAlloc(pThis, pThis->paDirEnts[iSegNames].off, (void **)&pThis->pszzSegNames,
1732	pThis->paDirEnts[iSegNames].cb);
1733	}
1734	if (RT_FAILURE(rc))
1735	return rc;
1736	RTDBGMODCV_CHECK_NOMSG_RET_BF(!pThis->pszzSegNames \|\| !pThis->pszzSegNames[pThis->cbSegNames - 1]); /* must be terminated */
1737	RTDBGMODCV_CHECK_RET_BF(pThis->paDirEnts[iSegMap].cb >= RT_UOFFSETOF_DYN(RTCVSEGMAP, aDescs[pThis->pSegMap->Hdr.cSegs]),
1738	("SegMap is out of bounds: cbSubSect=%#x cSegs=%#x\n",
1739	pThis->paDirEnts[iSegMap].cb, pThis->pSegMap->Hdr.cSegs));
1740
1741	/*
1742	* Join paths with the PDB handling.
1743	*/
1744	return rtDbgModCvProcessSegmentMap(pThis);
1745	}
1746
1747
1748
1749
1750	/**
1751	* @callback_method_impl{PFNRTSORTCMP,
1752	* Used by rtDbgModCvLoadDirectory to sort the directory.}
1753	*/
1754	static DECLCALLBACK(int) rtDbgModCvDirEntCmp(void const pvElement1, void const pvElement2, void *pvUser)
1755	{
1756	PRTCVDIRENT32 pEntry1 = (PRTCVDIRENT32)pvElement1;
1757	PRTCVDIRENT32 pEntry2 = (PRTCVDIRENT32)pvElement2;
1758	if (pEntry1->iMod < pEntry2->iMod)
1759	return -1;
1760	if (pEntry1->iMod > pEntry2->iMod)
1761	return 1;
1762	if (pEntry1->uSubSectType < pEntry2->uSubSectType)
1763	return -1;
1764	if (pEntry1->uSubSectType > pEntry2->uSubSectType)
1765	return 1;
1766
1767	RT_NOREF_PV(pvUser);
1768	return 0;
1769	}
1770
1771
1772	/**
1773	* Loads the directory into memory (RTDBGMODCV::paDirEnts and
1774	* RTDBGMODCV::cDirEnts).
1775	*
1776	* Converting old format version into the newer format to simplifying the code
1777	* using the directory.
1778	*
1779	*
1780	* @returns IPRT status code. (May leave with paDirEnts allocated on failure.)
1781	* @param pThis The CV reader instance.
1782	*/
1783	static int rtDbgModCvLoadDirectory(PRTDBGMODCV pThis)
1784	{
1785	/*
1786	* Read in the CV directory.
1787	*/
1788	int rc;
1789	if ( pThis->u32CvMagic == RTCVHDR_MAGIC_NB00
1790	\|\| pThis->u32CvMagic == RTCVHDR_MAGIC_NB02)
1791	{
1792	/*
1793	* 16-bit type.
1794	*/
1795	RTCVDIRHDR16 DirHdr;
1796	rc = rtDbgModCvReadAt(pThis, pThis->offDir, &DirHdr, sizeof(DirHdr));
1797	if (RT_SUCCESS(rc))
1798	{
1799	if (DirHdr.cEntries > 2 && DirHdr.cEntries < _64K - 32U)
1800	{
1801	pThis->cDirEnts = DirHdr.cEntries;
1802	pThis->paDirEnts = (PRTCVDIRENT32)RTMemAlloc(DirHdr.cEntries * sizeof(pThis->paDirEnts[0]));
1803	if (pThis->paDirEnts)
1804	{
1805	rc = rtDbgModCvReadAt(pThis, pThis->offDir + sizeof(DirHdr),
1806	pThis->paDirEnts, DirHdr.cEntries * sizeof(RTCVDIRENT16));
1807	if (RT_SUCCESS(rc))
1808	{
1809	/* Convert the entries (from the end). */
1810	uint32_t cLeft = DirHdr.cEntries;
1811	RTCVDIRENT32 volatile *pDst = pThis->paDirEnts + cLeft;
1812	RTCVDIRENT16 volatile pSrc = (RTCVDIRENT16 volatile )pThis->paDirEnts + cLeft;
1813	while (cLeft--)
1814	{
1815	pDst--;
1816	pSrc--;
1817
1818	pDst->cb = pSrc->cb;
1819	pDst->off = RT_MAKE_U32(pSrc->offLow, pSrc->offHigh);
1820	pDst->iMod = pSrc->iMod;
1821	pDst->uSubSectType = pSrc->uSubSectType;
1822	}
1823	}
1824	}
1825	else
1826	rc = VERR_NO_MEMORY;
1827	}
1828	else
1829	{
1830	Log(("Old CV directory count is out of considered valid range: %#x\n", DirHdr.cEntries));
1831	rc = VERR_CV_BAD_FORMAT;
1832	}
1833	}
1834	}
1835	else
1836	{
1837	/*
1838	* 32-bit type (reading too much for NB04 is no problem).
1839	*
1840	* Note! The watcom linker (v1.9) seems to overwrite the directory
1841	* header and more under some conditions. So, if this code fails
1842	* you might be so lucky as to have reproduce that issue...
1843	*/
1844	RTCVDIRHDR32EX DirHdr;
1845	rc = rtDbgModCvReadAt(pThis, pThis->offDir, &DirHdr, sizeof(DirHdr));
1846	if (RT_SUCCESS(rc))
1847	{
1848	if ( DirHdr.Core.cbHdr != sizeof(DirHdr.Core)
1849	&& DirHdr.Core.cbHdr != sizeof(DirHdr))
1850	{
1851	Log(("Unexpected CV directory size: %#x [wlink screwup?]\n", DirHdr.Core.cbHdr));
1852	rc = VERR_CV_BAD_FORMAT;
1853	}
1854	if ( DirHdr.Core.cbHdr == sizeof(DirHdr)
1855	&& ( DirHdr.offNextDir != 0
1856	\|\| DirHdr.fFlags != 0) )
1857	{
1858	Log(("Extended CV directory headers fields are not zero: fFlags=%#x offNextDir=%#x [wlink screwup?]\n",
1859	DirHdr.fFlags, DirHdr.offNextDir));
1860	rc = VERR_CV_BAD_FORMAT;
1861	}
1862	if (DirHdr.Core.cbEntry != sizeof(RTCVDIRENT32))
1863	{
1864	Log(("Unexpected CV directory entry size: %#x (expected %#x) [wlink screwup?]\n", DirHdr.Core.cbEntry, sizeof(RTCVDIRENT32)));
1865	rc = VERR_CV_BAD_FORMAT;
1866	}
1867	if (DirHdr.Core.cEntries < 2 \|\| DirHdr.Core.cEntries >= _512K)
1868	{
1869	Log(("CV directory count is out of considered valid range: %#x [wlink screwup?]\n", DirHdr.Core.cEntries));
1870	rc = VERR_CV_BAD_FORMAT;
1871	}
1872	if (RT_SUCCESS(rc))
1873	{
1874	pThis->cDirEnts = DirHdr.Core.cEntries;
1875	pThis->paDirEnts = (PRTCVDIRENT32)RTMemAlloc(DirHdr.Core.cEntries * sizeof(pThis->paDirEnts[0]));
1876	if (pThis->paDirEnts)
1877	rc = rtDbgModCvReadAt(pThis, pThis->offDir + DirHdr.Core.cbHdr,
1878	pThis->paDirEnts, DirHdr.Core.cEntries * sizeof(RTCVDIRENT32));
1879	else
1880	rc = VERR_NO_MEMORY;
1881	}
1882	}
1883	}
1884
1885	if (RT_SUCCESS(rc))
1886	{
1887	uint32_t const cbDbgInfo = pThis->cbDbgInfo;
1888	uint32_t const cDirEnts = pThis->cDirEnts;
1889
1890	/*
1891	* Just sort the directory in a way we like, no need to make
1892	* complicated demands on the linker output.
1893	*/
1894	RTSortShell(pThis->paDirEnts, cDirEnts, sizeof(pThis->paDirEnts[0]), rtDbgModCvDirEntCmp, NULL);
1895
1896	/*
1897	* Basic info validation.
1898	*/
1899	uint16_t cGlobalMods = 0;
1900	uint16_t cNormalMods = 0;
1901	uint16_t iModLast = 0;
1902	Log2(("RTDbgModCv: %u (%#x) directory entries:\n", cDirEnts, cDirEnts));
1903	for (uint32_t i = 0; i < cDirEnts; i++)
1904	{
1905	PCRTCVDIRENT32 pDirEnt = &pThis->paDirEnts[i];
1906	Log2((" #%04u mod=%#06x sst=%#06x at %#010x LB %#07x %s\n",
1907	i, pDirEnt->iMod, pDirEnt->uSubSectType, pDirEnt->off, pDirEnt->cb,
1908	rtDbgModCvGetSubSectionName(pDirEnt->uSubSectType)));
1909
1910	if ( pDirEnt->off >= cbDbgInfo
1911	\|\| pDirEnt->cb >= cbDbgInfo
1912	\|\| pDirEnt->off + pDirEnt->cb > cbDbgInfo)
1913	{
1914	Log(("CV directory entry #%u is out of bounds: %#x LB %#x, max %#x\n", i, pDirEnt->off, pDirEnt->cb, cbDbgInfo));
1915	rc = VERR_CV_BAD_FORMAT;
1916	}
1917	if ( pDirEnt->iMod == 0
1918	&& pThis->u32CvMagic != RTCVHDR_MAGIC_NB04
1919	&& pThis->u32CvMagic != RTCVHDR_MAGIC_NB02
1920	&& pThis->u32CvMagic != RTCVHDR_MAGIC_NB00)
1921	{
1922	Log(("CV directory entry #%u uses module index 0 (uSubSectType=%#x)\n", i, pDirEnt->uSubSectType));
1923	rc = VERR_CV_BAD_FORMAT;
1924	}
1925	if (pDirEnt->iMod == 0 \|\| pDirEnt->iMod == 0xffff)
1926	cGlobalMods++;
1927	else
1928	{
1929	if (pDirEnt->iMod > iModLast)
1930	{
1931	if ( pDirEnt->uSubSectType != kCvSst_Module
1932	&& pDirEnt->uSubSectType != kCvSst_OldModule)
1933	{
1934	Log(("CV directory entry #%u: expected module subsection first, found %s (%#x)\n",
1935	i, rtDbgModCvGetSubSectionName(pDirEnt->uSubSectType), pDirEnt->uSubSectType));
1936	rc = VERR_CV_BAD_FORMAT;
1937	}
1938	if (pDirEnt->iMod != iModLast + 1)
1939	{
1940	Log(("CV directory entry #%u: skips from mod %#x to %#x modules\n", i, iModLast, pDirEnt->iMod));
1941	rc = VERR_CV_BAD_FORMAT;
1942	}
1943	iModLast = pDirEnt->iMod;
1944	}
1945	cNormalMods++;
1946	}
1947	}
1948	if (cGlobalMods == 0)
1949	{
1950	Log(("CV directory contains no global modules\n"));
1951	rc = VERR_CV_BAD_FORMAT;
1952	}
1953	if (RT_SUCCESS(rc))
1954	{
1955	Log(("CV dir stats: %u total, %u normal, %u special, iModLast=%#x (%u)\n",
1956	cDirEnts, cNormalMods, cGlobalMods, iModLast, iModLast));
1957
1958	#if 0 /* skip this stuff */
1959	/*
1960	* Validate the directory ordering.
1961	*/
1962	uint16_t i = 0;
1963
1964	/* Normal modules. */
1965	if (pThis->enmDirOrder != RTCVDIRORDER_BY_SST_MOD)
1966	{
1967	uint16_t iEndNormalMods = cNormalMods + (pThis->enmDirOrder == RTCVDIRORDER_BY_MOD_0 ? cGlobalMods : 0);
1968	while (i < iEndNormalMods)
1969	{
1970	if (pThis->paDirEnts[i].iMod == 0 \|\| pThis->paDirEnts[i].iMod == 0xffff)
1971	{
1972	Log(("CV directory entry #%u: Unexpected global module entry.\n", i));
1973	rc = VERR_CV_BAD_FORMAT;
1974	}
1975	i++;
1976	}
1977	}
1978	else
1979	{
1980	uint32_t fSeen = RT_BIT_32(kCvSst_Module - kCvSst_Module)
1981	\| RT_BIT_32(kCvSst_Libraries - kCvSst_Module)
1982	\| RT_BIT_32(kCvSst_GlobalSym - kCvSst_Module)
1983	\| RT_BIT_32(kCvSst_GlobalPub - kCvSst_Module)
1984	\| RT_BIT_32(kCvSst_GlobalTypes - kCvSst_Module)
1985	\| RT_BIT_32(kCvSst_SegName - kCvSst_Module)
1986	\| RT_BIT_32(kCvSst_SegMap - kCvSst_Module)
1987	\| RT_BIT_32(kCvSst_StaticSym - kCvSst_Module)
1988	\| RT_BIT_32(kCvSst_FileIndex - kCvSst_Module)
1989	\| RT_BIT_32(kCvSst_MPC - kCvSst_Module);
1990	uint16_t iMod = 0;
1991	uint16_t uSst = kCvSst_Module;
1992	while (i < cNormalMods)
1993	{
1994	PCRTCVDIRENT32 pDirEnt = &pThis->paDirEnts[i];
1995	if ( pDirEnt->iMod > iMod
1996	\|\| pDirEnt->iMod == iMod) /* wlink subjected to MSVC 2010 /Z7 files with multiple .debug$S. */
1997	{
1998	if (pDirEnt->uSubSectType != uSst)
1999	{
2000	Log(("CV directory entry #%u: Expected %s (%#x), found %s (%#x).\n",
2001	i, rtDbgModCvGetSubSectionName(uSst), uSst,
2002	rtDbgModCvGetSubSectionName(pDirEnt->uSubSectType), pDirEnt->uSubSectType));
2003	rc = VERR_CV_BAD_FORMAT;
2004	}
2005	}
2006	else
2007	{
2008	uint32_t iBit = pDirEnt->uSubSectType - kCvSst_Module;
2009	if (iBit >= 32U \|\| (fSeen & RT_BIT_32(iBit)))
2010	{
2011	Log(("CV directory entry #%u: SST %s (%#x) has already been seen or is for globals.\n",
2012	i, rtDbgModCvGetSubSectionName(pDirEnt->uSubSectType), pDirEnt->uSubSectType));
2013	rc = VERR_CV_BAD_FORMAT;
2014	}
2015	fSeen \|= RT_BIT_32(iBit);
2016	}
2017
2018	uSst = pDirEnt->uSubSectType;
2019	iMod = pDirEnt->iMod;
2020	i++;
2021	}
2022	}
2023
2024	/* New style with special modules at the end. */
2025	if (pThis->enmDirOrder != RTCVDIRORDER_BY_MOD_0)
2026	while (i < cDirEnts)
2027	{
2028	if (pThis->paDirEnts[i].iMod != 0 && pThis->paDirEnts[i].iMod != 0xffff)
2029	{
2030	Log(("CV directory entry #%u: Expected global module entry, not %#x.\n", i,
2031	pThis->paDirEnts[i].iMod));
2032	rc = VERR_CV_BAD_FORMAT;
2033	}
2034	i++;
2035	}
2036	#endif
2037	}
2038	}
2039
2040	return rc;
2041	}
2042
2043
2044	static int rtDbgModCvLoadCodeViewInfo(PRTDBGMODCV pThis)
2045	{
2046	/*
2047	* Load the directory, the segment map (if any) and then scan for segments
2048	* if necessary.
2049	*/
2050	int rc = rtDbgModCvLoadDirectory(pThis);
2051	if (RT_SUCCESS(rc))
2052	rc = rtDbgModCvLoadSegmentMap(pThis);
2053	if (RT_SUCCESS(rc) && !pThis->fHaveLoadedSegments)
2054	{
2055	rc = VERR_CV_TODO; /** @todo Scan anything containing address, in particular sstSegMap and sstModule,
2056	* and reconstruct the segments from that information. */
2057	pThis->cbImage = 0x1000;
2058	rc = VINF_SUCCESS;
2059	}
2060
2061	/*
2062	* Process the directory.
2063	*/
2064	for (uint32_t i = 0; RT_SUCCESS(rc) && i < pThis->cDirEnts; i++)
2065	{
2066	PCRTCVDIRENT32 pDirEnt = &pThis->paDirEnts[i];
2067	Log3(("Processing module %#06x subsection #%04u %s\n", pDirEnt->iMod, i, rtDbgModCvGetSubSectionName(pDirEnt->uSubSectType)));
2068	PFNDBGMODCVSUBSECTCALLBACK pfnCallback = NULL;
2069	switch (pDirEnt->uSubSectType)
2070	{
2071	case kCvSst_GlobalPub:
2072	case kCvSst_GlobalSym:
2073	case kCvSst_StaticSym:
2074	pfnCallback = rtDbgModCvSs_GlobalPub_GlobalSym_StaticSym;
2075	break;
2076	case kCvSst_Module:
2077	pfnCallback = rtDbgModCvSs_Module;
2078	break;
2079	case kCvSst_PublicSym:
2080	case kCvSst_Symbols:
2081	case kCvSst_AlignSym:
2082	pfnCallback = rtDbgModCvSs_Symbols_PublicSym_AlignSym;
2083	break;
2084
2085	case kCvSst_OldModule:
2086	case kCvSst_OldPublic:
2087	case kCvSst_OldTypes:
2088	case kCvSst_OldSymbols:
2089	case kCvSst_OldSrcLines:
2090	case kCvSst_OldLibraries:
2091	case kCvSst_OldImports:
2092	case kCvSst_OldCompacted:
2093	case kCvSst_OldSrcLnSeg:
2094	case kCvSst_OldSrcLines3:
2095	/** @todo implement more. */
2096	break;
2097
2098	case kCvSst_Types:
2099	case kCvSst_Public:
2100	case kCvSst_SrcLnSeg:
2101	/** @todo implement more. */
2102	break;
2103	case kCvSst_SrcModule:
2104	pfnCallback = rtDbgModCvSs_SrcModule;
2105	break;
2106	case kCvSst_Libraries:
2107	case kCvSst_GlobalTypes:
2108	case kCvSst_MPC:
2109	case kCvSst_PreComp:
2110	case kCvSst_PreCompMap:
2111	case kCvSst_OffsetMap16:
2112	case kCvSst_OffsetMap32:
2113	case kCvSst_FileIndex:
2114
2115	default:
2116	/** @todo implement more. */
2117	break;
2118
2119	/* Skip because we've already processed them: */
2120	case kCvSst_SegMap:
2121	case kCvSst_SegName:
2122	pfnCallback = NULL;
2123	break;
2124	}
2125
2126	if (pfnCallback)
2127	{
2128	void *pvSubSect;
2129	rc = rtDbgModCvReadAtAlloc(pThis, pDirEnt->off, &pvSubSect, pDirEnt->cb);
2130	if (RT_SUCCESS(rc))
2131	{
2132	rc = pfnCallback(pThis, pvSubSect, pDirEnt->cb, pDirEnt);
2133	RTMemFree(pvSubSect);
2134	}
2135	}
2136	}
2137
2138	/*
2139	* Free temporary parsing objects.
2140	*/
2141	if (pThis->pbSrcInfo)
2142	{
2143	RTMemFree(pThis->pbSrcInfo);
2144	pThis->pbSrcInfo = NULL;
2145	pThis->cbSrcInfo = 0;
2146	pThis->cbSrcInfoAlloc = 0;
2147	}
2148	if (pThis->pchSrcStrings)
2149	{
2150	RTMemFree(pThis->pchSrcStrings);
2151	pThis->pchSrcStrings = NULL;
2152	pThis->cbSrcStrings = 0;
2153	pThis->cbSrcStringsAlloc = 0;
2154	}
2155
2156	return rc;
2157	}
2158
2159
2160	/*
2161	*
2162	* COFF Debug Info Parsing.
2163	* COFF Debug Info Parsing.
2164	* COFF Debug Info Parsing.
2165	*
2166	*/
2167
2168	#ifdef LOG_ENABLED
2169	static const char *rtDbgModCvGetCoffStorageClassName(uint8_t bStorageClass)
2170	{
2171	switch (bStorageClass)
2172	{
2173	case IMAGE_SYM_CLASS_END_OF_FUNCTION: return "END_OF_FUNCTION";
2174	case IMAGE_SYM_CLASS_NULL: return "NULL";
2175	case IMAGE_SYM_CLASS_AUTOMATIC: return "AUTOMATIC";
2176	case IMAGE_SYM_CLASS_EXTERNAL: return "EXTERNAL";
2177	case IMAGE_SYM_CLASS_STATIC: return "STATIC";
2178	case IMAGE_SYM_CLASS_REGISTER: return "REGISTER";
2179	case IMAGE_SYM_CLASS_EXTERNAL_DEF: return "EXTERNAL_DEF";
2180	case IMAGE_SYM_CLASS_LABEL: return "LABEL";
2181	case IMAGE_SYM_CLASS_UNDEFINED_LABEL: return "UNDEFINED_LABEL";
2182	case IMAGE_SYM_CLASS_MEMBER_OF_STRUCT: return "MEMBER_OF_STRUCT";
2183	case IMAGE_SYM_CLASS_ARGUMENT: return "ARGUMENT";
2184	case IMAGE_SYM_CLASS_STRUCT_TAG: return "STRUCT_TAG";
2185	case IMAGE_SYM_CLASS_MEMBER_OF_UNION: return "MEMBER_OF_UNION";
2186	case IMAGE_SYM_CLASS_UNION_TAG: return "UNION_TAG";
2187	case IMAGE_SYM_CLASS_TYPE_DEFINITION: return "TYPE_DEFINITION";
2188	case IMAGE_SYM_CLASS_UNDEFINED_STATIC: return "UNDEFINED_STATIC";
2189	case IMAGE_SYM_CLASS_ENUM_TAG: return "ENUM_TAG";
2190	case IMAGE_SYM_CLASS_MEMBER_OF_ENUM: return "MEMBER_OF_ENUM";
2191	case IMAGE_SYM_CLASS_REGISTER_PARAM: return "REGISTER_PARAM";
2192	case IMAGE_SYM_CLASS_BIT_FIELD: return "BIT_FIELD";
2193	case IMAGE_SYM_CLASS_FAR_EXTERNAL: return "FAR_EXTERNAL";
2194	case IMAGE_SYM_CLASS_BLOCK: return "BLOCK";
2195	case IMAGE_SYM_CLASS_FUNCTION: return "FUNCTION";
2196	case IMAGE_SYM_CLASS_END_OF_STRUCT: return "END_OF_STRUCT";
2197	case IMAGE_SYM_CLASS_FILE: return "FILE";
2198	case IMAGE_SYM_CLASS_SECTION: return "SECTION";
2199	case IMAGE_SYM_CLASS_WEAK_EXTERNAL: return "WEAK_EXTERNAL";
2200	case IMAGE_SYM_CLASS_CLR_TOKEN: return "CLR_TOKEN";
2201	}
2202
2203	static char s_szName[32];
2204	RTStrPrintf(s_szName, sizeof(s_szName), "Unknown%#04x", bStorageClass);
2205	return s_szName;
2206	}
2207	#endif /* LOG_ENABLED */
2208
2209
2210	/**
2211	* Adds a chunk of COFF line numbers.
2212	*
2213	* @param pThis The COFF/CodeView reader instance.
2214	* @param pszFile The source file name.
2215	* @param iSection The section number.
2216	* @param paLines Pointer to the first line number table entry.
2217	* @param cLines The number of line number table entries to add.
2218	*/
2219	static void rtDbgModCvAddCoffLineNumbers(PRTDBGMODCV pThis, const char *pszFile, uint32_t iSection,
2220	PCIMAGE_LINENUMBER paLines, uint32_t cLines)
2221	{
2222	RT_NOREF_PV(iSection);
2223	Log4(("Adding %u line numbers in section #%u for %s\n", cLines, iSection, pszFile));
2224	PCIMAGE_LINENUMBER pCur = paLines;
2225	while (cLines-- > 0)
2226	{
2227	if (pCur->Linenumber)
2228	{
2229	int rc = RTDbgModLineAdd(pThis->hCnt, pszFile, pCur->Linenumber, RTDBGSEGIDX_RVA, pCur->Type.VirtualAddress, NULL);
2230	Log4((" %#010x: %u [%Rrc]\n", pCur->Type.VirtualAddress, pCur->Linenumber, rc)); NOREF(rc);
2231	}
2232	pCur++;
2233	}
2234	}
2235
2236
2237	/**
2238	* Adds a COFF symbol.
2239	*
2240	* @returns IPRT status (ignored)
2241	* @param pThis The COFF/CodeView reader instance.
2242	* @param idxSeg IPRT RVA or ABS segment index indicator.
2243	* @param uValue The symbol value.
2244	* @param pszName The symbol name.
2245	*/
2246	static int rtDbgModCvAddCoffSymbol(PRTDBGMODCV pThis, uint32_t idxSeg, uint32_t uValue, const char *pszName)
2247	{
2248	int rc = RTDbgModSymbolAdd(pThis->hCnt, pszName, idxSeg, uValue, 0, 0 /fFlags/, NULL);
2249	Log(("Symbol: %s:%08x %s [%Rrc]\n", idxSeg == RTDBGSEGIDX_RVA ? "rva" : "abs", uValue, pszName, rc));
2250	if (rc == VERR_DBG_ADDRESS_CONFLICT \|\| rc == VERR_DBG_DUPLICATE_SYMBOL)
2251	rc = VINF_SUCCESS;
2252	return rc;
2253	}
2254
2255
2256	/**
2257	* Processes the COFF symbol table.
2258	*
2259	* @returns IPRT status code
2260	* @param pThis The COFF/CodeView reader instance.
2261	* @param paSymbols Pointer to the symbol table.
2262	* @param cSymbols The number of entries in the symbol table.
2263	* @param paLines Pointer to the line number table.
2264	* @param cLines The number of entires in the line number table.
2265	* @param pszzStrTab Pointer to the string table.
2266	* @param cbStrTab Size of the string table.
2267	*/
2268	static int rtDbgModCvProcessCoffSymbolTable(PRTDBGMODCV pThis,
2269	PCIMAGE_SYMBOL paSymbols, uint32_t cSymbols,
2270	PCIMAGE_LINENUMBER paLines, uint32_t cLines,
2271	const char *pszzStrTab, uint32_t cbStrTab)
2272	{
2273	Log3(("Processing COFF symbol table with %#x symbols\n", cSymbols));
2274
2275	/*
2276	* Making some bold assumption that the line numbers for the section in
2277	* the file are allocated sequentially, we do multiple passes until we've
2278	* gathered them all.
2279	*/
2280	int rc = VINF_SUCCESS;
2281	uint32_t cSections = 1;
2282	uint32_t iLineSect = 1;
2283	uint32_t iLine = 0;
2284	do
2285	{
2286	/*
2287	* Process the symbols.
2288	*/
2289	char szShort[9];
2290	char szFile[RTPATH_MAX];
2291	uint32_t iSymbol = 0;
2292	szFile[0] = '\0';
2293	szShort[8] = '\0'; /* avoid having to terminate it all the time. */
2294
2295	while (iSymbol < cSymbols && RT_SUCCESS(rc))
2296	{
2297	/* Copy the symbol in and hope it works around the misalignment
2298	issues everywhere. */
2299	IMAGE_SYMBOL Sym;
2300	memcpy(&Sym, &paSymbols[iSymbol], sizeof(Sym));
2301	RTDBGMODCV_CHECK_NOMSG_RET_BF(Sym.NumberOfAuxSymbols < cSymbols);
2302
2303	/* Calc a zero terminated symbol name. */
2304	const char *pszName;
2305	if (Sym.N.Name.Short)
2306	pszName = (const char *)memcpy(szShort, &Sym.N, 8);
2307	else
2308	{
2309	RTDBGMODCV_CHECK_NOMSG_RET_BF(Sym.N.Name.Long < cbStrTab);
2310	pszName = pszzStrTab + Sym.N.Name.Long;
2311	}
2312
2313	/* Only log stuff and count sections the in the first pass.*/
2314	if (iLineSect == 1)
2315	{
2316	Log3(("%04x: s=%#06x v=%#010x t=%#06x a=%#04x c=%#04x (%s) name='%s'\n",
2317	iSymbol, Sym.SectionNumber, Sym.Value, Sym.Type, Sym.NumberOfAuxSymbols,
2318	Sym.StorageClass, rtDbgModCvGetCoffStorageClassName(Sym.StorageClass), pszName));
2319	if ((int16_t)cSections <= Sym.SectionNumber && Sym.SectionNumber > 0)
2320	cSections = Sym.SectionNumber + 1;
2321	}
2322
2323	/*
2324	* Use storage class to pick what we need (which isn't much because,
2325	* MS only provides a very restricted set of symbols).
2326	*/
2327	IMAGE_AUX_SYMBOL Aux;
2328	switch (Sym.StorageClass)
2329	{
2330	case IMAGE_SYM_CLASS_NULL:
2331	/* a NOP */
2332	break;
2333
2334	case IMAGE_SYM_CLASS_FILE:
2335	{
2336	/* Change the current file name (for line numbers). Pretend
2337	ANSI and ISO-8859-1 are similar enough for out purposes... */
2338	RTDBGMODCV_CHECK_NOMSG_RET_BF(Sym.NumberOfAuxSymbols > 0);
2339	const char pszFile = (const char )&paSymbols[iSymbol + 1];
2340	char *pszDst = szFile;
2341	rc = RTLatin1ToUtf8Ex(pszFile, Sym.NumberOfAuxSymbols * sizeof(IMAGE_SYMBOL), &pszDst, sizeof(szFile), NULL);
2342	if (RT_FAILURE(rc))
2343	Log(("Error converting COFF filename: %Rrc\n", rc));
2344	else if (iLineSect == 1)
2345	Log3((" filename='%s'\n", szFile));
2346	break;
2347	}
2348
2349	case IMAGE_SYM_CLASS_STATIC:
2350	if ( Sym.NumberOfAuxSymbols == 1
2351	&& ( iLineSect == 1
2352	\|\| Sym.SectionNumber == (int32_t)iLineSect) )
2353	{
2354	memcpy(&Aux, &paSymbols[iSymbol + 1], sizeof(Aux));
2355	if (iLineSect == 1)
2356	Log3((" section: cb=%#010x #relocs=%#06x #lines=%#06x csum=%#x num=%#x sel=%x rvd=%u\n",
2357	Aux.Section.Length, Aux.Section.NumberOfRelocations,
2358	Aux.Section.NumberOfLinenumbers,
2359	Aux.Section.CheckSum,
2360	RT_MAKE_U32(Aux.Section.Number, Aux.Section.HighNumber),
2361	Aux.Section.Selection,
2362	Aux.Section.bReserved));
2363	if ( Sym.SectionNumber == (int32_t)iLineSect
2364	&& Aux.Section.NumberOfLinenumbers > 0)
2365	{
2366	uint32_t cLinesToAdd = RT_MIN(Aux.Section.NumberOfLinenumbers, cLines - iLine);
2367	if (iLine < cLines && szFile[0])
2368	rtDbgModCvAddCoffLineNumbers(pThis, szFile, iLineSect, &paLines[iLine], cLinesToAdd);
2369	iLine += cLinesToAdd;
2370	}
2371	}
2372	/* Not so sure about the quality here, but might be useful. */
2373	else if ( iLineSect == 1
2374	&& Sym.NumberOfAuxSymbols == 0
2375	&& Sym.SectionNumber != IMAGE_SYM_UNDEFINED
2376	&& Sym.SectionNumber != IMAGE_SYM_ABSOLUTE
2377	&& Sym.SectionNumber != IMAGE_SYM_DEBUG
2378	&& Sym.Value > 0
2379	&& *pszName)
2380	rtDbgModCvAddCoffSymbol(pThis, RTDBGSEGIDX_RVA, Sym.Value, pszName);
2381	break;
2382
2383	case IMAGE_SYM_CLASS_EXTERNAL:
2384	/* Add functions (first pass only). */
2385	if ( iLineSect == 1
2386	&& (ISFCN(Sym.Type) \|\| Sym.Type == 0)
2387	&& Sym.NumberOfAuxSymbols == 0
2388	&& *pszName )
2389	{
2390	if (Sym.SectionNumber == IMAGE_SYM_ABSOLUTE)
2391	rtDbgModCvAddCoffSymbol(pThis, RTDBGSEGIDX_ABS, Sym.Value, pszName);
2392	else if ( Sym.SectionNumber != IMAGE_SYM_UNDEFINED
2393	&& Sym.SectionNumber != IMAGE_SYM_DEBUG)
2394	rtDbgModCvAddCoffSymbol(pThis, RTDBGSEGIDX_RVA, Sym.Value, pszName);
2395	}
2396	break;
2397
2398	case IMAGE_SYM_CLASS_FUNCTION:
2399	/* Not sure this is really used. */
2400	break;
2401
2402	case IMAGE_SYM_CLASS_END_OF_FUNCTION:
2403	case IMAGE_SYM_CLASS_AUTOMATIC:
2404	case IMAGE_SYM_CLASS_REGISTER:
2405	case IMAGE_SYM_CLASS_EXTERNAL_DEF:
2406	case IMAGE_SYM_CLASS_LABEL:
2407	case IMAGE_SYM_CLASS_UNDEFINED_LABEL:
2408	case IMAGE_SYM_CLASS_MEMBER_OF_STRUCT:
2409	case IMAGE_SYM_CLASS_ARGUMENT:
2410	case IMAGE_SYM_CLASS_STRUCT_TAG:
2411	case IMAGE_SYM_CLASS_MEMBER_OF_UNION:
2412	case IMAGE_SYM_CLASS_UNION_TAG:
2413	case IMAGE_SYM_CLASS_TYPE_DEFINITION:
2414	case IMAGE_SYM_CLASS_UNDEFINED_STATIC:
2415	case IMAGE_SYM_CLASS_ENUM_TAG:
2416	case IMAGE_SYM_CLASS_MEMBER_OF_ENUM:
2417	case IMAGE_SYM_CLASS_REGISTER_PARAM:
2418	case IMAGE_SYM_CLASS_BIT_FIELD:
2419	case IMAGE_SYM_CLASS_FAR_EXTERNAL:
2420	case IMAGE_SYM_CLASS_BLOCK:
2421	case IMAGE_SYM_CLASS_END_OF_STRUCT:
2422	case IMAGE_SYM_CLASS_SECTION:
2423	case IMAGE_SYM_CLASS_WEAK_EXTERNAL:
2424	case IMAGE_SYM_CLASS_CLR_TOKEN:
2425	/* Not used by MS, I think. */
2426	break;
2427
2428	default:
2429	Log(("RTDbgCv: Unexpected COFF storage class %#x (%u)\n", Sym.StorageClass, Sym.StorageClass));
2430	break;
2431	}
2432
2433	/* next symbol */
2434	iSymbol += 1 + Sym.NumberOfAuxSymbols;
2435	}
2436
2437	/* Next section with line numbers. */
2438	iLineSect++;
2439	} while (iLine < cLines && iLineSect < cSections && RT_SUCCESS(rc));
2440
2441	return rc;
2442	}
2443
2444
2445	/**
2446	* Loads COFF debug information into the container.
2447	*
2448	* @returns IPRT status code.
2449	* @param pThis The COFF/CodeView debug reader instance.
2450	*/
2451	static int rtDbgModCvLoadCoffInfo(PRTDBGMODCV pThis)
2452	{
2453	/*
2454	* Read the whole section into memory.
2455	* Note! Cannot use rtDbgModCvReadAt or rtDbgModCvReadAtAlloc here.
2456	*/
2457	int rc;
2458	uint8_t pbDbgSect = (uint8_t )RTMemAlloc(pThis->cbCoffDbgInfo);
2459	if (pbDbgSect)
2460	{
2461	if (pThis->hFile == NIL_RTFILE)
2462	rc = pThis->pMod->pImgVt->pfnReadAt(pThis->pMod, UINT32_MAX, pThis->offCoffDbgInfo, pbDbgSect, pThis->cbCoffDbgInfo);
2463	else
2464	rc = RTFileReadAt(pThis->hFile, pThis->offCoffDbgInfo, pbDbgSect, pThis->cbCoffDbgInfo, NULL);
2465	if (RT_SUCCESS(rc))
2466	{
2467	/* The string table follows after the symbol table. */
2468	const char pszzStrTab = (const char )( pbDbgSect
2469	+ pThis->CoffHdr.LvaToFirstSymbol
2470	+ pThis->CoffHdr.NumberOfSymbols * sizeof(IMAGE_SYMBOL));
2471	uint32_t cbStrTab = (uint32_t)((uintptr_t)(pbDbgSect + pThis->cbCoffDbgInfo) - (uintptr_t)pszzStrTab);
2472	/** @todo The symbol table starts with a size. Read it and checking. Also verify
2473	* that the symtab ends with a terminator character. */
2474
2475	rc = rtDbgModCvProcessCoffSymbolTable(pThis,
2476	(PCIMAGE_SYMBOL)(pbDbgSect + pThis->CoffHdr.LvaToFirstSymbol),
2477	pThis->CoffHdr.NumberOfSymbols,
2478	(PCIMAGE_LINENUMBER)(pbDbgSect + pThis->CoffHdr.LvaToFirstLinenumber),
2479	pThis->CoffHdr.NumberOfLinenumbers,
2480	pszzStrTab, cbStrTab);
2481	}
2482	RTMemFree(pbDbgSect);
2483	}
2484	else
2485	rc = VERR_NO_MEMORY;
2486	return rc;
2487	}
2488
2489
2490
2491
2492
2493
2494	/*
2495	*
2496	* CodeView Debug module implementation.
2497	* CodeView Debug module implementation.
2498	* CodeView Debug module implementation.
2499	*
2500	*/
2501
2502
2503	/** @interface_method_impl{RTDBGMODVTDBG,pfnUnwindFrame} */
2504	static DECLCALLBACK(int) rtDbgModCv_UnwindFrame(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off, PRTDBGUNWINDSTATE pState)
2505	{
2506	RT_NOREF(pMod, iSeg, off, pState);
2507	return VERR_DBG_NO_UNWIND_INFO;
2508	}
2509
2510
2511	/** @interface_method_impl{RTDBGMODVTDBG,pfnLineByAddr} */
2512	static DECLCALLBACK(int) rtDbgModCv_LineByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off,
2513	PRTINTPTR poffDisp, PRTDBGLINE pLineInfo)
2514	{
2515	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2516	return RTDbgModLineByAddr(pThis->hCnt, iSeg, off, poffDisp, pLineInfo);
2517	}
2518
2519
2520	/** @interface_method_impl{RTDBGMODVTDBG,pfnLineByOrdinal} */
2521	static DECLCALLBACK(int) rtDbgModCv_LineByOrdinal(PRTDBGMODINT pMod, uint32_t iOrdinal, PRTDBGLINE pLineInfo)
2522	{
2523	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2524	return RTDbgModLineByOrdinal(pThis->hCnt, iOrdinal, pLineInfo);
2525	}
2526
2527
2528	/** @interface_method_impl{RTDBGMODVTDBG,pfnLineCount} */
2529	static DECLCALLBACK(uint32_t) rtDbgModCv_LineCount(PRTDBGMODINT pMod)
2530	{
2531	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2532	return RTDbgModLineCount(pThis->hCnt);
2533	}
2534
2535
2536	/** @interface_method_impl{RTDBGMODVTDBG,pfnLineAdd} */
2537	static DECLCALLBACK(int) rtDbgModCv_LineAdd(PRTDBGMODINT pMod, const char *pszFile, size_t cchFile, uint32_t uLineNo,
2538	uint32_t iSeg, RTUINTPTR off, uint32_t *piOrdinal)
2539	{
2540	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2541	Assert(!pszFile[cchFile]); NOREF(cchFile);
2542	return RTDbgModLineAdd(pThis->hCnt, pszFile, uLineNo, iSeg, off, piOrdinal);
2543	}
2544
2545
2546	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByAddr} */
2547	static DECLCALLBACK(int) rtDbgModCv_SymbolByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t fFlags,
2548	PRTINTPTR poffDisp, PRTDBGSYMBOL pSymInfo)
2549	{
2550	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2551	return RTDbgModSymbolByAddr(pThis->hCnt, iSeg, off, fFlags, poffDisp, pSymInfo);
2552	}
2553
2554
2555	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByName} */
2556	static DECLCALLBACK(int) rtDbgModCv_SymbolByName(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
2557	PRTDBGSYMBOL pSymInfo)
2558	{
2559	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2560	Assert(!pszSymbol[cchSymbol]); RT_NOREF_PV(cchSymbol);
2561	return RTDbgModSymbolByName(pThis->hCnt, pszSymbol/, cchSymbol/, pSymInfo);
2562	}
2563
2564
2565	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByOrdinal} */
2566	static DECLCALLBACK(int) rtDbgModCv_SymbolByOrdinal(PRTDBGMODINT pMod, uint32_t iOrdinal, PRTDBGSYMBOL pSymInfo)
2567	{
2568	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2569	return RTDbgModSymbolByOrdinal(pThis->hCnt, iOrdinal, pSymInfo);
2570	}
2571
2572
2573	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolCount} */
2574	static DECLCALLBACK(uint32_t) rtDbgModCv_SymbolCount(PRTDBGMODINT pMod)
2575	{
2576	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2577	return RTDbgModSymbolCount(pThis->hCnt);
2578	}
2579
2580
2581	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolAdd} */
2582	static DECLCALLBACK(int) rtDbgModCv_SymbolAdd(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
2583	RTDBGSEGIDX iSeg, RTUINTPTR off, RTUINTPTR cb, uint32_t fFlags,
2584	uint32_t *piOrdinal)
2585	{
2586	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2587	Assert(!pszSymbol[cchSymbol]); NOREF(cchSymbol);
2588	return RTDbgModSymbolAdd(pThis->hCnt, pszSymbol, iSeg, off, cb, fFlags, piOrdinal);
2589	}
2590
2591
2592	/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentByIndex} */
2593	static DECLCALLBACK(int) rtDbgModCv_SegmentByIndex(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, PRTDBGSEGMENT pSegInfo)
2594	{
2595	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2596	return RTDbgModSegmentByIndex(pThis->hCnt, iSeg, pSegInfo);
2597	}
2598
2599
2600	/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentCount} */
2601	static DECLCALLBACK(RTDBGSEGIDX) rtDbgModCv_SegmentCount(PRTDBGMODINT pMod)
2602	{
2603	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2604	return RTDbgModSegmentCount(pThis->hCnt);
2605	}
2606
2607
2608	/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentAdd} */
2609	static DECLCALLBACK(int) rtDbgModCv_SegmentAdd(PRTDBGMODINT pMod, RTUINTPTR uRva, RTUINTPTR cb, const char *pszName, size_t cchName,
2610	uint32_t fFlags, PRTDBGSEGIDX piSeg)
2611	{
2612	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2613	Assert(!pszName[cchName]); NOREF(cchName);
2614	return RTDbgModSegmentAdd(pThis->hCnt, uRva, cb, pszName, fFlags, piSeg);
2615	}
2616
2617
2618	/** @interface_method_impl{RTDBGMODVTDBG,pfnImageSize} */
2619	static DECLCALLBACK(RTUINTPTR) rtDbgModCv_ImageSize(PRTDBGMODINT pMod)
2620	{
2621	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2622	if (pThis->cbImage)
2623	return pThis->cbImage;
2624	return RTDbgModImageSize(pThis->hCnt);
2625	}
2626
2627
2628	/** @interface_method_impl{RTDBGMODVTDBG,pfnRvaToSegOff} */
2629	static DECLCALLBACK(RTDBGSEGIDX) rtDbgModCv_RvaToSegOff(PRTDBGMODINT pMod, RTUINTPTR uRva, PRTUINTPTR poffSeg)
2630	{
2631	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2632	return RTDbgModRvaToSegOff(pThis->hCnt, uRva, poffSeg);
2633	}
2634
2635
2636	/** @interface_method_impl{RTDBGMODVTDBG,pfnClose} */
2637	static DECLCALLBACK(int) rtDbgModCv_Close(PRTDBGMODINT pMod)
2638	{
2639	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
2640
2641	RTDbgModRelease(pThis->hCnt);
2642	if (pThis->hFile != NIL_RTFILE)
2643	RTFileClose(pThis->hFile);
2644	RTMemFree(pThis->paDirEnts);
2645	RTStrFree(pThis->pszPdbFilename);
2646	RTVfsRelease(pThis->hVfsPdb);
2647	pThis->hVfsPdb = NIL_RTVFS;
2648	RTMemFree(pThis);
2649
2650	pMod->pvDbgPriv = NULL; /* for internal use */
2651	return VINF_SUCCESS;
2652	}
2653
2654
2655	/*
2656	*
2657	* Probing code used by rtDbgModCv_TryOpen.
2658	* Probing code used by rtDbgModCv_TryOpen.
2659	*
2660	*/
2661
2662
2663
2664	/**
2665	* @callback_method_impl{FNRTLDRENUMSEGS, Used to add segments from the image}
2666	*/
2667	static DECLCALLBACK(int) rtDbgModCvAddSegmentsCallback(RTLDRMOD hLdrMod, PCRTLDRSEG pSeg, void *pvUser)
2668	{
2669	PRTDBGMODCV pThis = (PRTDBGMODCV)pvUser;
2670	Log(("Segment %s: LinkAddress=%#llx RVA=%#llx cb=%#llx\n",
2671	pSeg->pszName, (uint64_t)pSeg->LinkAddress, (uint64_t)pSeg->RVA, pSeg->cb));
2672	NOREF(hLdrMod);
2673
2674	/* If the segment doesn't have a mapping, just add a dummy so the indexing
2675	works out correctly (same as for the image). */
2676	if (pSeg->RVA == NIL_RTLDRADDR)
2677	return RTDbgModSegmentAdd(pThis->hCnt, 0, 0, pSeg->pszName, 0 /fFlags/, NULL);
2678
2679	RTLDRADDR cb = RT_MAX(pSeg->cb, pSeg->cbMapped);
2680	return RTDbgModSegmentAdd(pThis->hCnt, pSeg->RVA, cb, pSeg->pszName, 0 /fFlags/, NULL);
2681	}
2682
2683
2684	/**
2685	* Helper for rounding the section size up to the start of the start of the
2686	* next section (e.g. RTLDRSEG::cbMapped approximation).
2687	*/
2688	DECLINLINE(uint32_t) rtDbgModCvAdjustSectionSizeByNext(PCIMAGE_SECTION_HEADER paShs, uint32_t cShs,
2689	uint32_t iCur, uint32_t cbMapped)
2690	{
2691	size_t iNext = iCur + 1;
2692	while (iNext < cShs && (paShs[iNext].Characteristics & IMAGE_SCN_TYPE_NOLOAD))
2693	iNext++;
2694	if (iNext < cShs)
2695	{
2696	uint32_t cbAvailable = paShs[iNext].VirtualAddress - paShs[iCur].VirtualAddress;
2697	Assert(cbMapped <= cbAvailable);
2698	return cbAvailable;
2699	}
2700	return cbMapped;
2701	}
2702
2703
2704	/**
2705	* Copies the sections over from the DBG file.
2706	*
2707	* Called if we don't have an associated executable image.
2708	*
2709	* @returns IPRT status code.
2710	* @param pThis The CV module instance.
2711	* @param paShs The section headers.
2712	* @param cShs The number of section headers.
2713	* @param cbSectionAlign The section alignment
2714	* (IMAGE_SEPARATE_DEBUG_HEADER::SectionAlignment,
2715	* IMAGE_OPTIONAL_HEADER32::SectionAlignment, ++).
2716	* @param cbImage The image size (if not availble, UINT32_MAX).
2717	* @param pszFilename The filename (for logging).
2718	*/
2719	static int rtDbgModCvAddSegmentsFromSectHdrs(PRTDBGMODCV pThis, PCIMAGE_SECTION_HEADER paShs, uint32_t cShs,
2720	uint32_t cbSectionAlign, uint32_t cbImage, const char *pszFilename)
2721	{
2722	RT_NOREF_PV(pszFilename);
2723	Assert(RT_IS_POWER_OF_TWO(cbSectionAlign));
2724
2725	/*
2726	* Do some basic validation of the section headers.
2727	*/
2728	int rc = VINF_SUCCESS;
2729	uint32_t cbHeaders = 0;
2730	uint32_t uRvaPrev = 0;
2731	for (uint32_t i = 0; i < cShs; i++)
2732	{
2733	Log3(("RTDbgModCv: Section #%02u %#010x LB %#010x %.*s\n",
2734	i, paShs[i].VirtualAddress, paShs[i].Misc.VirtualSize, sizeof(paShs[i].Name), paShs[i].Name));
2735
2736	if (paShs[i].Characteristics & IMAGE_SCN_TYPE_NOLOAD)
2737	continue;
2738
2739	if (paShs[i].VirtualAddress < uRvaPrev)
2740	{
2741	Log(("RTDbgModCv: %s: Overlap or sorting error, VirtualAddress=%#x uRvaPrev=%#x - section #%d '%.*s'!!!\n",
2742	pszFilename, paShs[i].VirtualAddress, uRvaPrev, i, sizeof(paShs[i].Name), paShs[i].Name));
2743	rc = VERR_CV_BAD_FORMAT;
2744	}
2745	else if ( paShs[i].VirtualAddress > cbImage
2746	\|\| paShs[i].Misc.VirtualSize > cbImage
2747	\|\| paShs[i].VirtualAddress + paShs[i].Misc.VirtualSize > cbImage)
2748	{
2749	Log(("RTDbgModCv: %s: VirtualAddress=%#x VirtualSize=%#x (total %x) - beyond image size (%#x) - section #%d '%.*s'!!!\n",
2750	pszFilename, paShs[i].VirtualAddress, paShs[i].Misc.VirtualSize,
2751	paShs[i].VirtualAddress + paShs[i].Misc.VirtualSize,
2752	pThis->cbImage, i, sizeof(paShs[i].Name), paShs[i].Name));
2753	rc = VERR_CV_BAD_FORMAT;
2754	}
2755	else if (paShs[i].VirtualAddress & (cbSectionAlign - 1))
2756	{
2757	Log(("RTDbgModCv: %s: VirtualAddress=%#x misaligned (%#x) - section #%d '%.*s'!!!\n",
2758	pszFilename, paShs[i].VirtualAddress, cbSectionAlign, i, sizeof(paShs[i].Name), paShs[i].Name));
2759	rc = VERR_CV_BAD_FORMAT;
2760	}
2761	else if (paShs[i].Characteristics & IMAGE_SCN_ALIGN_MASK)
2762	{
2763	uint32_t const cbAlign = RT_BIT_32((paShs[i].Characteristics & IMAGE_SCN_ALIGN_MASK) >> IMAGE_SCN_ALIGN_SHIFT);
2764	if (RT_ALIGN_32(paShs[i].VirtualAddress, cbAlign) != paShs[i].VirtualAddress)
2765	{
2766	Log(("RTDbgModCv: %s: VirtualAddress=%#x misaligned by flags (%#x) - section #%d '%.*s'!!!\n",
2767	pszFilename, paShs[i].VirtualAddress, cbAlign, i, sizeof(paShs[i].Name), paShs[i].Name));
2768	rc = VERR_CV_BAD_FORMAT;
2769	}
2770	}
2771
2772	if (uRvaPrev == 0)
2773	cbHeaders = paShs[i].VirtualAddress;
2774	uRvaPrev = paShs[i].VirtualAddress + paShs[i].Misc.VirtualSize;
2775	}
2776	if (uRvaPrev == 0)
2777	{
2778	Log(("RTDbgModCv: %s: No loadable sections.\n", pszFilename));
2779	rc = VERR_CV_BAD_FORMAT;
2780	}
2781	if (cbHeaders == 0)
2782	{
2783	Log(("RTDbgModCv: %s: No space for PE headers.\n", pszFilename));
2784	rc = VERR_CV_BAD_FORMAT;
2785	}
2786	if (RT_SUCCESS(rc))
2787	{
2788	/*
2789	* Add sections.
2790	*/
2791	rc = RTDbgModSegmentAdd(pThis->hCnt, 0, cbHeaders, "NtHdrs", 0 /fFlags/, NULL);
2792	if (RT_SUCCESS(rc))
2793	{
2794	for (uint32_t i = 0; RT_SUCCESS(rc) && i < cShs; i++)
2795	{
2796	char szName[sizeof(paShs[i].Name) + 1];
2797	memcpy(szName, paShs[i].Name, sizeof(paShs[i].Name));
2798	szName[sizeof(szName) - 1] = '\0';
2799	RTStrStripR(szName);
2800
2801	uint32_t uRva = paShs[i].VirtualAddress;
2802	uint32_t cbMapped;
2803	if (!(paShs[i].Characteristics & IMAGE_SCN_TYPE_NOLOAD))
2804	cbMapped = rtDbgModCvAdjustSectionSizeByNext(paShs, cShs, i, paShs[i].Misc.VirtualSize);
2805	else
2806	uRva = cbMapped = 0;
2807	rc = RTDbgModSegmentAdd(pThis->hCnt, paShs[i].VirtualAddress, cbMapped, szName, 0 /fFlags/, NULL);
2808	if (RT_FAILURE(rc))
2809	{
2810	Log(("RTDbgModCv: RTDbgModSegmentAdd failed on #%u: uRva=%#RX32 cbMapped=%#RX32 Flags=%#RX32 '%s' -> %Rrc\n",
2811	i + 1, uRva, cbMapped, szName, paShs[i].Characteristics, rc));
2812	break;
2813	}
2814
2815	}
2816	if (RT_SUCCESS(rc))
2817	pThis->fHaveLoadedSegments = true;
2818	}
2819	else
2820	Log(("RTDbgModCv: RTDbgModSegmentAdd on 'NtHdrs': cbHeaders=%#RX32 - %Rrc\n", cbHeaders, rc));
2821	}
2822	return rc;
2823	}
2824
2825
2826	/**
2827	* Copies the sections over from the DBG file.
2828	*
2829	* Called if we don't have an associated executable image.
2830	*
2831	* @returns IPRT status code.
2832	* @param pThis The CV module instance.
2833	* @param pDbgHdr The DBG file header.
2834	* @param pszFilename The filename (for logging).
2835	*/
2836	static int rtDbgModCvAddSegmentsFromDbg(PRTDBGMODCV pThis, PCIMAGE_SEPARATE_DEBUG_HEADER pDbgHdr, const char *pszFilename)
2837	{
2838	RT_NOREF_PV(pszFilename);
2839
2840	/*
2841	* Validate the header fields a little.
2842	*/
2843	if ( pDbgHdr->NumberOfSections < 1
2844	\|\| pDbgHdr->NumberOfSections > 4096)
2845	{
2846	Log(("RTDbgModCv: Bad NumberOfSections: %d\n", pDbgHdr->NumberOfSections));
2847	return VERR_CV_BAD_FORMAT;
2848	}
2849
2850	/*
2851	* Read the section table.
2852	*/
2853	size_t const cbShs = pDbgHdr->NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
2854	PIMAGE_SECTION_HEADER const paShs = (PIMAGE_SECTION_HEADER)RTMemTmpAlloc(cbShs);
2855	if (paShs)
2856	{
2857	int rc = RTFileReadAt(pThis->hFile, sizeof(*pDbgHdr), paShs, cbShs, NULL);
2858	if (RT_SUCCESS(rc))
2859	{
2860	/*
2861	* Process them.
2862	*/
2863	rc = rtDbgModCvAddSegmentsFromSectHdrs(pThis, paShs, pDbgHdr->NumberOfSections, pDbgHdr->SectionAlignment,
2864	pDbgHdr->SizeOfImage, pszFilename);
2865	}
2866	RTMemTmpFree(paShs);
2867	return rc;
2868	}
2869	return VERR_NO_TMP_MEMORY;
2870	}
2871
2872
2873	/**
2874	* Instantiates the CV/COFF reader.
2875	*
2876	* @returns IPRT status code
2877	* @param pDbgMod The debug module instance.
2878	* @param enmFileType The type of input file.
2879	* @param hFile The file handle, NIL_RTFILE of image.
2880	* @param ppThis Where to return the reader instance.
2881	*/
2882	static int rtDbgModCvCreateInstance(PRTDBGMODINT pDbgMod, RTCVFILETYPE enmFileType, RTFILE hFile, PRTDBGMODCV *ppThis)
2883	{
2884	/*
2885	* Do we already have an instance? Happens if we find multiple debug
2886	* formats we support.
2887	*/
2888	PRTDBGMODCV pThis = (PRTDBGMODCV)pDbgMod->pvDbgPriv;
2889	if (pThis)
2890	{
2891	Assert(pThis->enmType == enmFileType);
2892	Assert(pThis->hFile == hFile);
2893	Assert(pThis->pMod == pDbgMod);
2894	*ppThis = pThis;
2895	return VINF_SUCCESS;
2896	}
2897
2898	/*
2899	* Create a new instance.
2900	*/
2901	pThis = (PRTDBGMODCV)RTMemAllocZ(sizeof(RTDBGMODCV));
2902	if (!pThis)
2903	return VERR_NO_MEMORY;
2904	int rc = RTDbgModCreate(&pThis->hCnt, pDbgMod->pszName, 0 /cbSeg/, 0 /fFlags/);
2905	if (RT_SUCCESS(rc))
2906	{
2907	pDbgMod->pvDbgPriv = pThis;
2908	pThis->enmType = enmFileType;
2909	pThis->hFile = hFile;
2910	pThis->pMod = pDbgMod;
2911	pThis->offBase = UINT32_MAX;
2912	pThis->offCoffDbgInfo = UINT32_MAX;
2913	pThis->hVfsPdb = NIL_RTVFS;
2914	*ppThis = pThis;
2915	return VINF_SUCCESS;
2916	}
2917	RTMemFree(pThis);
2918	return rc;
2919	}
2920
2921
2922	/**
2923	* Common part of the COFF probing.
2924	*
2925	* @returns status code.
2926	* @param pDbgMod The debug module instance. On success pvDbgPriv
2927	* will point to a valid RTDBGMODCV.
2928	* @param enmFileType The kind of file this is we're probing.
2929	* @param hFile The file with debug info in it.
2930	* @param off The offset where to expect CV debug info.
2931	* @param cb The number of bytes of debug info.
2932	* @param pszFilename The path to the file (for logging).
2933	*/
2934	static int rtDbgModCvProbeCoff(PRTDBGMODINT pDbgMod, RTCVFILETYPE enmFileType, RTFILE hFile,
2935	uint32_t off, uint32_t cb, const char *pszFilename)
2936	{
2937	RT_NOREF_PV(pszFilename);
2938
2939	/*
2940	* Check that there is sufficient data for a header, then read it.
2941	*/
2942	if (cb < sizeof(IMAGE_COFF_SYMBOLS_HEADER))
2943	{
2944	Log(("RTDbgModCv: Not enough room for COFF header.\n"));
2945	return VERR_BAD_EXE_FORMAT;
2946	}
2947	if (cb >= UINT32_C(128) * _1M)
2948	{
2949	Log(("RTDbgModCv: COFF debug information is to large (%'u bytes), max is 128MB\n", cb));
2950	return VERR_BAD_EXE_FORMAT;
2951	}
2952
2953	int rc;
2954	IMAGE_COFF_SYMBOLS_HEADER Hdr;
2955	if (hFile == NIL_RTFILE)
2956	rc = pDbgMod->pImgVt->pfnReadAt(pDbgMod, UINT32_MAX, off, &Hdr, sizeof(Hdr));
2957	else
2958	rc = RTFileReadAt(hFile, off, &Hdr, sizeof(Hdr), NULL);
2959	if (RT_FAILURE(rc))
2960	{
2961	Log(("RTDbgModCv: Error reading COFF header: %Rrc\n", rc));
2962	return rc;
2963	}
2964
2965	Log2(("RTDbgModCv: Found COFF debug info header at %#x (LB %#x) in %s\n", off, cb, pszFilename));
2966	Log2((" NumberOfSymbols = %#010x\n", Hdr.NumberOfSymbols));
2967	Log2((" LvaToFirstSymbol = %#010x\n", Hdr.LvaToFirstSymbol));
2968	Log2((" NumberOfLinenumbers = %#010x\n", Hdr.NumberOfLinenumbers));
2969	Log2((" LvaToFirstLinenumber = %#010x\n", Hdr.LvaToFirstLinenumber));
2970	Log2((" RvaToFirstByteOfCode = %#010x\n", Hdr.RvaToFirstByteOfCode));
2971	Log2((" RvaToLastByteOfCode = %#010x\n", Hdr.RvaToLastByteOfCode));
2972	Log2((" RvaToFirstByteOfData = %#010x\n", Hdr.RvaToFirstByteOfData));
2973	Log2((" RvaToLastByteOfData = %#010x\n", Hdr.RvaToLastByteOfData));
2974
2975	/*
2976	* Validate the COFF header.
2977	*/
2978	if ( (uint64_t)Hdr.LvaToFirstSymbol + (uint64_t)Hdr.NumberOfSymbols * sizeof(IMAGE_SYMBOL) > cb
2979	\|\| (Hdr.LvaToFirstSymbol < sizeof(Hdr) && Hdr.NumberOfSymbols > 0))
2980	{
2981	Log(("RTDbgModCv: Bad COFF symbol count or/and offset: LvaToFirstSymbol=%#x, NumberOfSymbols=%#x cbCoff=%#x\n",
2982	Hdr.LvaToFirstSymbol, Hdr.NumberOfSymbols, cb));
2983	return VERR_BAD_EXE_FORMAT;
2984	}
2985	if ( (uint64_t)Hdr.LvaToFirstLinenumber + (uint64_t)Hdr.NumberOfLinenumbers * sizeof(IMAGE_LINENUMBER) > cb
2986	\|\| (Hdr.LvaToFirstLinenumber < sizeof(Hdr) && Hdr.NumberOfLinenumbers > 0))
2987	{
2988	Log(("RTDbgModCv: Bad COFF symbol count or/and offset: LvaToFirstSymbol=%#x, NumberOfSymbols=%#x cbCoff=%#x\n",
2989	Hdr.LvaToFirstSymbol, Hdr.NumberOfSymbols, cb));
2990	return VERR_BAD_EXE_FORMAT;
2991	}
2992	if (Hdr.NumberOfSymbols < 2)
2993	{
2994	Log(("RTDbgModCv: The COFF symbol table is too short to be of any worth... (%u syms)\n", Hdr.NumberOfSymbols));
2995	return VERR_NO_DATA;
2996	}
2997
2998	/*
2999	* What we care about looks fine, use it.
3000	*/
3001	PRTDBGMODCV pThis;
3002	rc = rtDbgModCvCreateInstance(pDbgMod, enmFileType, hFile, &pThis);
3003	if (RT_SUCCESS(rc))
3004	{
3005	pThis->offCoffDbgInfo = off;
3006	pThis->cbCoffDbgInfo = cb;
3007	pThis->CoffHdr = Hdr;
3008	}
3009
3010	return rc;
3011	}
3012
3013	/**
3014	* Argument package for rtDbgModCvOpenPdb20Callback via pvUser2.
3015	*/
3016	typedef struct RTDBGMODCVOPENPDB20CALLBACK
3017	{
3018	RTLDRARCH enmArch;
3019	RTFILE hFile;
3020	RTCVFILETYPE enmFileType;
3021	uint32_t uTimestamp;
3022	uint32_t uAge;
3023	} RTDBGMODCVOPENPDB20CALLBACK;
3024
3025	/** @callback_method_impl{FNRTDBGCFGOPEN,
3026	* For opening PDB linked in windows 2000 area DBG files.}
3027	*/
3028	static DECLCALLBACK(int) rtDbgModCvOpenPdb20Callback(RTDBGCFG hDbgCfg, const char pszFilename, void pvUser1, void *pvUser2)
3029	{
3030	PRTDBGMODINT const pDbgMod = (PRTDBGMODINT)pvUser1;
3031	RTDBGMODCVOPENPDB20CALLBACK * const pArgs = (RTDBGMODCVOPENPDB20CALLBACK *)pvUser2;
3032	RT_NOREF(hDbgCfg);
3033
3034	/*
3035	* Open the file as a VFS and check that the timestamp and age matches
3036	* what we're looking for.
3037	*/
3038	Log2(("rtDbgModCvOpenPdb20Callback: Trying '%s'...\n", pszFilename));
3039	RTVFSFILE hVfsFilePdb = NIL_RTVFSFILE;
3040	int rc = RTVfsFileOpenNormal(pszFilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE, &hVfsFilePdb);
3041	if (RT_SUCCESS(rc))
3042	{
3043	RTVFS hVfsPdb = NIL_RTVFS;
3044	#ifdef LOG_ENABLED
3045	RTERRINFOSTATIC ErrInfo;
3046	rc = RTFsPdbVolOpen(hVfsFilePdb, 0, &hVfsPdb, RTErrInfoInitStatic(&ErrInfo));
3047	#else
3048	rc = RTFsPdbVolOpen(hVfsFilePdb, 0, &hVfsPdb, NULL /pErrInfo/);
3049	#endif
3050	RTVfsFileRelease(hVfsFilePdb);
3051	if (RT_SUCCESS(rc))
3052	{
3053	/*
3054	* The timestamp + age is available as a string.
3055	*/
3056	size_t cbRet;
3057	char szTimestampAndAge[64] = {0};
3058	rc = RTVfsQueryLabel(hVfsPdb, false /RTVFSQIEX_VOL_LABEL/,
3059	szTimestampAndAge, sizeof(szTimestampAndAge) - 1, &cbRet);
3060	AssertRC(rc);
3061	if (RT_SUCCESS(rc))
3062	{
3063	char szExpect[64];
3064	RTStrPrintf(szExpect, sizeof(szExpect), "%08X%x", pArgs->uTimestamp, pArgs->uAge);
3065	if (RTStrICmpAscii(szTimestampAndAge, szExpect) == 0)
3066	{
3067	/** @todo check ARCH. It's usually in the DBI header. */
3068
3069	/*
3070	* Okay, we're good.
3071	*/
3072	PRTDBGMODCV pThis;
3073	rc = rtDbgModCvCreateInstance(pDbgMod, pArgs->enmFileType, pArgs->hFile, &pThis);
3074	if (RT_SUCCESS(rc))
3075	{
3076	pThis->u32CvMagic = RTCVHDR_MAGIC_NB10;
3077	pThis->offBase = UINT32_MAX;
3078	pThis->cbDbgInfo = 0;
3079	pThis->offDir = 0;
3080	pThis->pszPdbFilename = RTStrDup(pszFilename);
3081	if (pThis->pszPdbFilename)
3082	{
3083	pThis->hVfsPdb = hVfsPdb;
3084	return VINF_CALLBACK_RETURN;
3085	}
3086	}
3087	}
3088	else
3089	Log2(("RTFsPdbVolOpen: timestamp+age mismatch: %s, expected %s (for '%s')\n",
3090	szTimestampAndAge, szExpect, pszFilename));
3091	}
3092	}
3093	else
3094	Log2(("RTFsPdbVolOpen: RTVfsFileOpenNormal '%s' failed: %Rrc%#RTeim\n", pszFilename, rc, &ErrInfo.Core));
3095	}
3096	else
3097	Log2(("rtDbgModCvOpenPdb20Callback: RTVfsFileOpenNormal '%s' failed: %Rrc\n", pszFilename, rc));
3098	return rc;
3099	}
3100
3101
3102	/**
3103	* Common part of the CodeView probing.
3104	*
3105	* @returns status code.
3106	* @param pDbgMod The debug module instance. On success pvDbgPriv
3107	* will point to a valid RTDBGMODCV.
3108	* @param pCvHdr The CodeView base header.
3109	* @param enmFileType The kind of file this is we're probing.
3110	* @param hFile The file with debug info in it.
3111	* @param off The offset where to expect CV debug info.
3112	* @param cb The number of bytes of debug info.
3113	* @param enmArch The desired image architecture.
3114	* @param cbImage The image size, if available.
3115	* @param pszFilename The path to the file (for logging).
3116	* @param hDbgCfg For dealing with external PDB found in windows
3117	* 2000 area DBG files.
3118	*/
3119	static int rtDbgModCvProbeCommon(PRTDBGMODINT pDbgMod, PRTCVHDR pCvHdr, RTCVFILETYPE enmFileType, RTFILE hFile,
3120	uint32_t off, uint32_t cb, RTLDRARCH enmArch, size_t cbImage,
3121	const char *pszFilename, RTDBGCFG hDbgCfg)
3122	{
3123	int rc = VERR_DBG_NO_MATCHING_INTERPRETER;
3124	RT_NOREF_PV(enmArch); RT_NOREF_PV(pszFilename);
3125
3126	/* Is a codeview format we (wish to) support? */
3127	if ( pCvHdr->u32Magic == RTCVHDR_MAGIC_NB11
3128	\|\| pCvHdr->u32Magic == RTCVHDR_MAGIC_NB09
3129	\|\| pCvHdr->u32Magic == RTCVHDR_MAGIC_NB08
3130	\|\| pCvHdr->u32Magic == RTCVHDR_MAGIC_NB05
3131	\|\| pCvHdr->u32Magic == RTCVHDR_MAGIC_NB04
3132	\|\| pCvHdr->u32Magic == RTCVHDR_MAGIC_NB02
3133	\|\| pCvHdr->u32Magic == RTCVHDR_MAGIC_NB00
3134	)
3135	{
3136	/* We're assuming it's a base header, so the offset must be within
3137	the area defined by the debug info we got from the loader. */
3138	if (pCvHdr->off < cb && pCvHdr->off >= sizeof(*pCvHdr))
3139	{
3140	Log(("RTDbgModCv: Found %c%c%c%c at %#x - size %#x, directory at %#x. file type %d\n",
3141	RT_BYTE1(pCvHdr->u32Magic), RT_BYTE2(pCvHdr->u32Magic), RT_BYTE3(pCvHdr->u32Magic), RT_BYTE4(pCvHdr->u32Magic),
3142	off, cb, pCvHdr->off, enmFileType));
3143
3144	/*
3145	* Create a module instance, if not already done.
3146	*/
3147	PRTDBGMODCV pThis;
3148	rc = rtDbgModCvCreateInstance(pDbgMod, enmFileType, hFile, &pThis);
3149	if (RT_SUCCESS(rc))
3150	{
3151	pThis->u32CvMagic = pCvHdr->u32Magic;
3152	pThis->offBase = off;
3153	pThis->cbDbgInfo = cb;
3154	pThis->offDir = pCvHdr->off;
3155	return VINF_SUCCESS;
3156	}
3157	}
3158	}
3159	/*
3160	* The NB10 is used to link to a PDB file.
3161	* This is the case with the windows 2000 DBG files.
3162	*/
3163	else if (pCvHdr->u32Magic == RTCVHDR_MAGIC_NB10)
3164	{
3165	if (pCvHdr->off == 0)
3166	{
3167	if (cb > RT_UOFFSETOF(CVPDB20INFO, szPdbFilename) && cb < _64K)
3168	{
3169	/*
3170	* Read it into memory and validate it.
3171	*/
3172	PCVPDB20INFO pInfo = (PCVPDB20INFO)RTMemTmpAlloc(cb);
3173	if (pInfo)
3174	{
3175	int rc2 = RTFileReadAt(hFile, off, pInfo, cb, NULL);
3176	if (RT_SUCCESS(rc2))
3177	{
3178	uint32_t const cbPdbFilename = cb - RT_UOFFSETOF(CVPDB20INFO, szPdbFilename);
3179	rc2 = RTStrValidateEncodingEx((char const *)&pInfo->szPdbFilename[0], cbPdbFilename,
3180	RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED);
3181	if (RT_SUCCESS(rc2))
3182	{
3183	Log2(("RTDbgModCv: Found external PDB (v2.0): TS=%#010RX32 uAge=%x '%.*s'\n", pInfo->uTimestamp,
3184	pInfo->uAge, cb - RT_UOFFSETOF(CVPDB20INFO, szPdbFilename), &pInfo->szPdbFilename[0]));
3185	if ( hDbgCfg != NIL_RTDBGCFG
3186	&& enmFileType == RTCVFILETYPE_DBG)
3187	{
3188	/*
3189	* Try open it. Need to figure the image size first if
3190	* we can, though not actually used by the function.
3191	*
3192	* The callback will create an instance if a PDB is found,
3193	* but it won't actually read it. That's done later by the
3194	* RTDbgModCv_TryOpen code.
3195	*/
3196	RTDBGMODCVOPENPDB20CALLBACK Args = { enmArch, hFile, enmFileType, pInfo->uTimestamp, pInfo->uAge };
3197	rc = RTDbgCfgOpenPdb20(hDbgCfg, (const char *)&pInfo->szPdbFilename[0],
3198	(uint32_t)cbImage, pInfo->uTimestamp, pInfo->uAge,
3199	rtDbgModCvOpenPdb20Callback, pDbgMod, &Args);
3200	Log(("RTDbgModCv: RTDbgCfgOpenPdb20 returns %Rrc\n", rc));
3201	}
3202	}
3203	else
3204	Log(("RTDbgModCv: Found external PDB (v2.0) w/ invalid filename encoding: TS=%#010RX32 uAge=%x %.*Rhxs rc2=%Rrc\n",
3205	pInfo->uTimestamp, pInfo->uAge, cbPdbFilename, &pInfo->szPdbFilename[0], rc2));
3206	}
3207	else
3208	Log(("RTDbgModCv: NB10 read error - %Rrc\n", rc2));
3209	RTMemTmpFree(pInfo);
3210	}
3211	else
3212	rc = VERR_NO_TMP_MEMORY;
3213	}
3214	else
3215	Log(("RTDbgModCv: NB10 with bogus size: %#x\n", cb));
3216	}
3217	else
3218	Log(("RTDbgModCv: NB10 with non-zero offset!\n"));
3219	}
3220	return rc;
3221	}
3222
3223
3224	/**
3225	* Arguments passed to rtDbgModCvEnumCallback
3226	*/
3227	typedef struct RTDBGMODCVENUMCALLBACKARGS
3228	{
3229	PRTDBGMODINT pDbgMod;
3230	RTDBGCFG hDbgCfg;
3231	} RTDBGMODCVENUMCALLBACKARGS;
3232
3233
3234	/** @callback_method_impl{FNRTLDRENUMDBG} */
3235	static DECLCALLBACK(int) rtDbgModCvEnumCallback(RTLDRMOD hLdrMod, PCRTLDRDBGINFO pDbgInfo, void *pvUser)
3236	{
3237	RTDBGMODCVENUMCALLBACKARGS * const pArgs = (RTDBGMODCVENUMCALLBACKARGS *)pvUser;
3238	PRTDBGMODINT const pDbgMod = pArgs->pDbgMod;
3239	Assert(!pDbgMod->pvDbgPriv);
3240	RT_NOREF_PV(hLdrMod);
3241
3242	/* Skip external files, RTDbgMod will deal with those
3243	via RTDBGMODINT::pszDbgFile. */
3244	if (pDbgInfo->pszExtFile)
3245	return VINF_SUCCESS;
3246
3247	/* We only handle the codeview sections. */
3248	if (pDbgInfo->enmType == RTLDRDBGINFOTYPE_CODEVIEW)
3249	{
3250	/* Read the specified header and check if we like it. */
3251	RTCVHDR CvHdr;
3252	int rc = pDbgMod->pImgVt->pfnReadAt(pDbgMod, pDbgInfo->iDbgInfo, pDbgInfo->offFile, &CvHdr, sizeof(CvHdr));
3253	if (RT_SUCCESS(rc))
3254	rc = rtDbgModCvProbeCommon(pDbgMod, &CvHdr, RTCVFILETYPE_IMAGE, NIL_RTFILE, pDbgInfo->offFile, pDbgInfo->cb,
3255	pDbgMod->pImgVt->pfnGetArch(pDbgMod), pDbgMod->pImgVt->pfnImageSize(pDbgMod),
3256	pDbgMod->pszImgFile, pArgs->hDbgCfg);
3257	}
3258	else if (pDbgInfo->enmType == RTLDRDBGINFOTYPE_COFF)
3259	{
3260	/* Join paths with the DBG code. */
3261	rtDbgModCvProbeCoff(pDbgMod, RTCVFILETYPE_IMAGE, NIL_RTFILE, pDbgInfo->offFile, pDbgInfo->cb, pDbgMod->pszImgFile);
3262	}
3263
3264	return VINF_SUCCESS;
3265	}
3266
3267
3268	/**
3269	* Part two of the external file probing.
3270	*
3271	* @returns status code.
3272	* @param pThis The debug module instance. On success pvDbgPriv
3273	* will point to a valid RTDBGMODCV.
3274	* @param enmFileType The kind of file this is we're probing.
3275	* @param hFile The file with debug info in it.
3276	* @param off The offset where to expect CV debug info.
3277	* @param cb The number of bytes of debug info.
3278	* @param enmArch The desired image architecture.
3279	* @param cbImage The image size (for PDB lookup, see hDbgCfg).
3280	* @param pszFilename The path to the file (for logging).
3281	* @param hDbgCfg Optional debug config handle for locating PDB
3282	* linked to by NB10 records (in DBG and
3283	* elsewhere).
3284	*/
3285	static int rtDbgModCvProbeFile2(PRTDBGMODINT pThis, RTCVFILETYPE enmFileType, RTFILE hFile, uint32_t off, uint32_t cb,
3286	RTLDRARCH enmArch, size_t cbImage, const char *pszFilename, RTDBGCFG hDbgCfg)
3287	{
3288	RTCVHDR CvHdr;
3289	int rc = RTFileReadAt(hFile, off, &CvHdr, sizeof(CvHdr), NULL);
3290	if (RT_SUCCESS(rc))
3291	rc = rtDbgModCvProbeCommon(pThis, &CvHdr, enmFileType, hFile, off, cb, enmArch, cbImage, pszFilename, hDbgCfg);
3292	return rc;
3293	}
3294
3295	#ifdef LOG_ENABLED
3296	/** Translate PE debug directory type value to string. */
3297	static const char *dbgPeDebugTypeName(uint32_t uType)
3298	{
3299	switch (uType)
3300	{
3301	case IMAGE_DEBUG_TYPE_UNKNOWN: return "UNKNOWN";
3302	case IMAGE_DEBUG_TYPE_COFF: return "COFF";
3303	case IMAGE_DEBUG_TYPE_CODEVIEW: return "CODEVIEW";
3304	case IMAGE_DEBUG_TYPE_FPO: return "FPO";
3305	case IMAGE_DEBUG_TYPE_MISC: return "MISC";
3306	case IMAGE_DEBUG_TYPE_EXCEPTION: return "EXCEPTION";
3307	case IMAGE_DEBUG_TYPE_FIXUP: return "FIXUP";
3308	case IMAGE_DEBUG_TYPE_OMAP_TO_SRC: return "OMAP_TO_SRC";
3309	case IMAGE_DEBUG_TYPE_OMAP_FROM_SRC: return "OMAP_FROM_SRC";
3310	case IMAGE_DEBUG_TYPE_BORLAND: return "BORLAND";
3311	case IMAGE_DEBUG_TYPE_RESERVED10: return "RESERVED10";
3312	case IMAGE_DEBUG_TYPE_CLSID: return "CLSID";
3313	case IMAGE_DEBUG_TYPE_VC_FEATURE: return "VC_FEATURE";
3314	case IMAGE_DEBUG_TYPE_POGO: return "POGO";
3315	case IMAGE_DEBUG_TYPE_ILTCG: return "ILTCG";
3316	case IMAGE_DEBUG_TYPE_MPX: return "MPX";
3317	case IMAGE_DEBUG_TYPE_REPRO: return "REPRO";
3318	}
3319	return "??";
3320	}
3321	#endif
3322
3323	/**
3324	* Probes an external file for CodeView information.
3325	*
3326	* @returns status code.
3327	* @param pDbgMod The debug module instance. On success pvDbgPriv
3328	* will point to a valid RTDBGMODCV.
3329	* @param pszFilename The path to the file to probe.
3330	* @param enmArch The desired image architecture.
3331	* @param hDbgCfg Optional debug config handle for locating PDB
3332	* linked to by NB10 records (in DBG and
3333	* elsewhere).
3334	*/
3335	static int rtDbgModCvProbeFile(PRTDBGMODINT pDbgMod, const char *pszFilename, RTLDRARCH enmArch, RTDBGCFG hDbgCfg)
3336	{
3337	RTFILE hFile;
3338	int rc = RTFileOpen(&hFile, pszFilename, RTFILE_O_READ \| RTFILE_O_DENY_WRITE \| RTFILE_O_OPEN);
3339	if (RT_FAILURE(rc))
3340	return rc;
3341
3342	/*
3343	* Check for .DBG file
3344	*/
3345	IMAGE_SEPARATE_DEBUG_HEADER DbgHdr;
3346	rc = RTFileReadAt(hFile, 0, &DbgHdr, sizeof(DbgHdr), NULL);
3347	if ( RT_SUCCESS(rc)
3348	&& DbgHdr.Signature == IMAGE_SEPARATE_DEBUG_SIGNATURE)
3349	{
3350	Log2(("RTDbgModCv: Found separate debug header in %s:\n", pszFilename));
3351	Log2((" Flags = %#x\n", DbgHdr.Flags));
3352	Log2((" Machine = %#x\n", DbgHdr.Machine));
3353	Log2((" Characteristics = %#x\n", DbgHdr.Characteristics));
3354	Log2((" TimeDateStamp = %#x\n", DbgHdr.TimeDateStamp));
3355	Log2((" CheckSum = %#x\n", DbgHdr.CheckSum));
3356	Log2((" ImageBase = %#x\n", DbgHdr.ImageBase));
3357	Log2((" SizeOfImage = %#x\n", DbgHdr.SizeOfImage));
3358	Log2((" NumberOfSections = %#x\n", DbgHdr.NumberOfSections));
3359	Log2((" ExportedNamesSize = %#x\n", DbgHdr.ExportedNamesSize));
3360	Log2((" DebugDirectorySize = %#x\n", DbgHdr.DebugDirectorySize));
3361	Log2((" SectionAlignment = %#x\n", DbgHdr.SectionAlignment));
3362
3363	/*
3364	* Match up the architecture if specified.
3365	*/
3366	switch (enmArch)
3367	{
3368	case RTLDRARCH_X86_32:
3369	if (DbgHdr.Machine != IMAGE_FILE_MACHINE_I386)
3370	rc = VERR_LDR_ARCH_MISMATCH;
3371	break;
3372	case RTLDRARCH_AMD64:
3373	if (DbgHdr.Machine != IMAGE_FILE_MACHINE_AMD64)
3374	rc = VERR_LDR_ARCH_MISMATCH;
3375	break;
3376
3377	default:
3378	RT_FALL_THROUGH();
3379	case RTLDRARCH_HOST:
3380	AssertFailedBreak();
3381	case RTLDRARCH_WHATEVER:
3382	break;
3383	}
3384	if (RT_FAILURE(rc))
3385	{
3386	RTFileClose(hFile);
3387	return rc;
3388	}
3389
3390	/*
3391	* Probe for readable debug info in the debug directory.
3392	*/
3393	uint32_t offDbgDir = sizeof(DbgHdr)
3394	+ DbgHdr.NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
3395	+ DbgHdr.ExportedNamesSize;
3396
3397	uint32_t cEntries = DbgHdr.DebugDirectorySize / sizeof(IMAGE_DEBUG_DIRECTORY);
3398	for (uint32_t i = 0; i < cEntries; i++, offDbgDir += sizeof(IMAGE_DEBUG_DIRECTORY))
3399	{
3400	IMAGE_DEBUG_DIRECTORY DbgDir;
3401	rc = RTFileReadAt(hFile, offDbgDir, &DbgDir, sizeof(DbgDir), NULL);
3402	if (RT_FAILURE(rc))
3403	break;
3404	Log2(("DbgDir[%u]: Type=%#x Char=%#x TS=%#010x Ver=%#x.%#x Size=%#010x Addr=%#010x Ptr=%#010x %s\n",
3405	i, DbgDir.Type, DbgDir.Characteristics, DbgDir.TimeDateStamp, DbgDir.MajorVersion, DbgDir.MinorVersion,
3406	DbgDir.SizeOfData, DbgDir.AddressOfRawData, DbgDir.PointerToRawData, dbgPeDebugTypeName(DbgDir.Type)));
3407	if (DbgDir.Type == IMAGE_DEBUG_TYPE_CODEVIEW)
3408	rc = rtDbgModCvProbeFile2(pDbgMod, RTCVFILETYPE_DBG, hFile,
3409	DbgDir.PointerToRawData, DbgDir.SizeOfData,
3410	enmArch, DbgHdr.SizeOfImage, pszFilename, hDbgCfg);
3411	else if (DbgDir.Type == IMAGE_DEBUG_TYPE_COFF)
3412	rc = rtDbgModCvProbeCoff(pDbgMod, RTCVFILETYPE_DBG, hFile,
3413	DbgDir.PointerToRawData, DbgDir.SizeOfData, pszFilename);
3414	else
3415	continue;
3416	Log2(("DbgDir[%u]: parsing -> %Rrc\n", i, rc));
3417	}
3418
3419	#ifdef LOG_ENABLED
3420	/*
3421	* Dump the section table.
3422	*/
3423	for (uint32_t i = 0, offSecHdr = sizeof(DbgHdr);
3424	i < DbgHdr.NumberOfSections;
3425	i++, offSecHdr += sizeof(IMAGE_SECTION_HEADER))
3426	{
3427	IMAGE_SECTION_HEADER Sh;
3428	rc = RTFileReadAt(hFile, offSecHdr, &Sh, sizeof(Sh), NULL);
3429	if (RT_FAILURE(rc))
3430	break;
3431	Log2(("SHdr[%02u]: VA=%#08RX32 LB %#08RX32 Char=%#010RX32 Ptr=%#08RX32 LB %#08RX32 PtrLines=%#RX32 L %#RX32 PtrReloc=%#RX32 L %#RX32 '%.8s'\n",
3432	i, Sh.VirtualAddress, Sh.Misc.VirtualSize, Sh.Characteristics, Sh.PointerToRawData, Sh.SizeOfRawData,
3433	Sh.PointerToLinenumbers, Sh.NumberOfLinenumbers, Sh.PointerToRelocations, Sh.NumberOfRelocations, &Sh.Name[0]));
3434	}
3435	#endif
3436
3437	/*
3438	* If we get down here with an instance, it prooves that we've found
3439	* something, regardless of any errors. Add the sections and such.
3440	*/
3441	PRTDBGMODCV pThis = (PRTDBGMODCV)pDbgMod->pvDbgPriv;
3442	if (pThis)
3443	{
3444	pThis->cbImage = DbgHdr.SizeOfImage;
3445	if (pDbgMod->pImgVt)
3446	rc = VINF_SUCCESS;
3447	else
3448	{
3449	rc = rtDbgModCvAddSegmentsFromDbg(pThis, &DbgHdr, pszFilename);
3450	if (RT_FAILURE(rc))
3451	rtDbgModCv_Close(pDbgMod);
3452	}
3453	return rc;
3454	}
3455
3456	/* Failed to find CV or smth, look at the end of the file just to be sure... */
3457	}
3458
3459	/*
3460	* Look for CV tail header.
3461	*/
3462	uint64_t cbFile;
3463	rc = RTFileSeek(hFile, -(RTFOFF)sizeof(RTCVHDR), RTFILE_SEEK_END, &cbFile);
3464	if (RT_SUCCESS(rc))
3465	{
3466	cbFile += sizeof(RTCVHDR);
3467	RTCVHDR CvHdr;
3468	rc = RTFileRead(hFile, &CvHdr, sizeof(CvHdr), NULL);
3469	if (RT_SUCCESS(rc))
3470	rc = rtDbgModCvProbeFile2(pDbgMod, RTCVFILETYPE_OTHER_AT_END, hFile,
3471	cbFile - CvHdr.off, CvHdr.off, enmArch,
3472	pDbgMod->pImgVt ? pDbgMod->pImgVt->pfnImageSize(pDbgMod) : 0 /cbImage /,
3473	pszFilename, hDbgCfg);
3474	}
3475
3476	if (RT_FAILURE(rc))
3477	RTFileClose(hFile);
3478	return rc;
3479	}
3480
3481
3482
3483	/** @interface_method_impl{RTDBGMODVTDBG,pfnTryOpen} */
3484	static DECLCALLBACK(int) rtDbgModCv_TryOpen(PRTDBGMODINT pMod, RTLDRARCH enmArch, RTDBGCFG hDbgCfg)
3485	{
3486	/*
3487	* Look for debug info.
3488	*/
3489	int rc = VERR_DBG_NO_MATCHING_INTERPRETER;
3490	if (pMod->pszDbgFile)
3491	rc = rtDbgModCvProbeFile(pMod, pMod->pszDbgFile, enmArch, hDbgCfg);
3492
3493	if (!pMod->pvDbgPriv && pMod->pImgVt)
3494	{
3495	RTDBGMODCVENUMCALLBACKARGS Args = { pMod, hDbgCfg };
3496	int rc2 = pMod->pImgVt->pfnEnumDbgInfo(pMod, rtDbgModCvEnumCallback, &Args);
3497	if (RT_FAILURE(rc2))
3498	rc = rc2;
3499
3500	if (!pMod->pvDbgPriv)
3501	{
3502	/* Try the executable in case it has a NBxx tail header. */
3503	rc2 = rtDbgModCvProbeFile(pMod, pMod->pszImgFile, enmArch, hDbgCfg);
3504	if (RT_FAILURE(rc2) && (RT_SUCCESS(rc) \|\| rc == VERR_DBG_NO_MATCHING_INTERPRETER))
3505	rc = rc2;
3506	}
3507	}
3508
3509	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3510	if (!pThis)
3511	return RT_SUCCESS_NP(rc) ? VERR_DBG_NO_MATCHING_INTERPRETER : rc;
3512	Assert( pThis->offBase != UINT32_MAX
3513	\|\| pThis->offCoffDbgInfo != UINT32_MAX
3514	\|\| (pThis->pszPdbFilename != NULL && pThis->hVfsPdb != NIL_RTVFS && pThis->enmType == RTCVFILETYPE_DBG));
3515
3516	/*
3517	* Load the debug info.
3518	*/
3519	if (pMod->pImgVt)
3520	{
3521	rc = pMod->pImgVt->pfnEnumSegments(pMod, rtDbgModCvAddSegmentsCallback, pThis);
3522	pThis->fHaveLoadedSegments = true;
3523	}
3524	if (RT_SUCCESS(rc) && pThis->offBase != UINT32_MAX)
3525	rc = rtDbgModCvLoadCodeViewInfo(pThis);
3526	if (RT_SUCCESS(rc) && pThis->offCoffDbgInfo != UINT32_MAX)
3527	rc = rtDbgModCvLoadCoffInfo(pThis);
3528	if (RT_SUCCESS(rc) && pThis->hVfsPdb != NIL_RTVFS)
3529	{
3530	rc = rtDbgModPdb_CommonOpenWorker(pThis, pThis->pszPdbFilename, pThis->hVfsPdb, hDbgCfg);
3531	RTVfsRelease(pThis->hVfsPdb);
3532	pThis->hVfsPdb = NIL_RTVFS;
3533	}
3534	if (RT_SUCCESS(rc))
3535	{
3536	Log(("RTDbgCv: Successfully loaded debug info\n"));
3537	return VINF_SUCCESS;
3538	}
3539
3540	Log(("RTDbgCv: Debug info load error %Rrc\n", rc));
3541	rtDbgModCv_Close(pMod);
3542	RT_NOREF(hDbgCfg);
3543	return rc;
3544	}
3545
3546
3547
3548
3549
3550	/** Virtual function table for the CodeView debug info reader. */
3551	DECL_HIDDEN_CONST(RTDBGMODVTDBG) const g_rtDbgModVtDbgCodeView =
3552	{
3553	/.u32Magic = / RTDBGMODVTDBG_MAGIC,
3554	/.fSupports = / RT_DBGTYPE_CODEVIEW,
3555	/.pszName = / "codeview",
3556	/.pfnTryOpen = / rtDbgModCv_TryOpen,
3557	/.pfnClose = / rtDbgModCv_Close,
3558
3559	/.pfnRvaToSegOff = / rtDbgModCv_RvaToSegOff,
3560	/.pfnImageSize = / rtDbgModCv_ImageSize,
3561
3562	/.pfnSegmentAdd = / rtDbgModCv_SegmentAdd,
3563	/.pfnSegmentCount = / rtDbgModCv_SegmentCount,
3564	/.pfnSegmentByIndex = / rtDbgModCv_SegmentByIndex,
3565
3566	/.pfnSymbolAdd = / rtDbgModCv_SymbolAdd,
3567	/.pfnSymbolCount = / rtDbgModCv_SymbolCount,
3568	/.pfnSymbolByOrdinal = / rtDbgModCv_SymbolByOrdinal,
3569	/.pfnSymbolByName = / rtDbgModCv_SymbolByName,
3570	/.pfnSymbolByAddr = / rtDbgModCv_SymbolByAddr,
3571
3572	/.pfnLineAdd = / rtDbgModCv_LineAdd,
3573	/.pfnLineCount = / rtDbgModCv_LineCount,
3574	/.pfnLineByOrdinal = / rtDbgModCv_LineByOrdinal,
3575	/.pfnLineByAddr = / rtDbgModCv_LineByAddr,
3576
3577	/.pfnUnwindFrame = / rtDbgModCv_UnwindFrame,
3578
3579	/.u32EndMagic = / RTDBGMODVTDBG_MAGIC
3580	};
3581
3582
3583	/*
3584	*
3585	* PDB Debug module implementation.
3586	* PDB Debug module implementation.
3587	* PDB Debug module implementation.
3588	*
3589	*/
3590
3591
3592	/** @interface_method_impl{RTDBGMODVTDBG,pfnUnwindFrame} */
3593	static DECLCALLBACK(int) rtDbgModPdb_UnwindFrame(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off, PRTDBGUNWINDSTATE pState)
3594	{
3595	RT_NOREF(pMod, iSeg, off, pState);
3596	return VERR_DBG_NO_UNWIND_INFO;
3597	}
3598
3599
3600	/** @interface_method_impl{RTDBGMODVTDBG,pfnLineByAddr} */
3601	static DECLCALLBACK(int) rtDbgModPdb_LineByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off,
3602	PRTINTPTR poffDisp, PRTDBGLINE pLineInfo)
3603	{
3604	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3605	return RTDbgModLineByAddr(pThis->hCnt, iSeg, off, poffDisp, pLineInfo);
3606	}
3607
3608
3609	/** @interface_method_impl{RTDBGMODVTDBG,pfnLineByOrdinal} */
3610	static DECLCALLBACK(int) rtDbgModPdb_LineByOrdinal(PRTDBGMODINT pMod, uint32_t iOrdinal, PRTDBGLINE pLineInfo)
3611	{
3612	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3613	return RTDbgModLineByOrdinal(pThis->hCnt, iOrdinal, pLineInfo);
3614	}
3615
3616
3617	/** @interface_method_impl{RTDBGMODVTDBG,pfnLineCount} */
3618	static DECLCALLBACK(uint32_t) rtDbgModPdb_LineCount(PRTDBGMODINT pMod)
3619	{
3620	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3621	return RTDbgModLineCount(pThis->hCnt);
3622	}
3623
3624
3625	/** @interface_method_impl{RTDBGMODVTDBG,pfnLineAdd} */
3626	static DECLCALLBACK(int) rtDbgModPdb_LineAdd(PRTDBGMODINT pMod, const char *pszFile, size_t cchFile, uint32_t uLineNo,
3627	uint32_t iSeg, RTUINTPTR off, uint32_t *piOrdinal)
3628	{
3629	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3630	Assert(!pszFile[cchFile]); NOREF(cchFile);
3631	return RTDbgModLineAdd(pThis->hCnt, pszFile, uLineNo, iSeg, off, piOrdinal);
3632	}
3633
3634
3635	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByAddr} */
3636	static DECLCALLBACK(int) rtDbgModPdb_SymbolByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t fFlags,
3637	PRTINTPTR poffDisp, PRTDBGSYMBOL pSymInfo)
3638	{
3639	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3640	return RTDbgModSymbolByAddr(pThis->hCnt, iSeg, off, fFlags, poffDisp, pSymInfo);
3641	}
3642
3643
3644	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByName} */
3645	static DECLCALLBACK(int) rtDbgModPdb_SymbolByName(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
3646	PRTDBGSYMBOL pSymInfo)
3647	{
3648	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3649	Assert(!pszSymbol[cchSymbol]); RT_NOREF_PV(cchSymbol);
3650	return RTDbgModSymbolByName(pThis->hCnt, pszSymbol/, cchSymbol/, pSymInfo);
3651	}
3652
3653
3654	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByOrdinal} */
3655	static DECLCALLBACK(int) rtDbgModPdb_SymbolByOrdinal(PRTDBGMODINT pMod, uint32_t iOrdinal, PRTDBGSYMBOL pSymInfo)
3656	{
3657	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3658	return RTDbgModSymbolByOrdinal(pThis->hCnt, iOrdinal, pSymInfo);
3659	}
3660
3661
3662	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolCount} */
3663	static DECLCALLBACK(uint32_t) rtDbgModPdb_SymbolCount(PRTDBGMODINT pMod)
3664	{
3665	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3666	return RTDbgModSymbolCount(pThis->hCnt);
3667	}
3668
3669
3670	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolAdd} */
3671	static DECLCALLBACK(int) rtDbgModPdb_SymbolAdd(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
3672	RTDBGSEGIDX iSeg, RTUINTPTR off, RTUINTPTR cb, uint32_t fFlags,
3673	uint32_t *piOrdinal)
3674	{
3675	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3676	Assert(!pszSymbol[cchSymbol]); NOREF(cchSymbol);
3677	return RTDbgModSymbolAdd(pThis->hCnt, pszSymbol, iSeg, off, cb, fFlags, piOrdinal);
3678	}
3679
3680
3681	/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentByIndex} */
3682	static DECLCALLBACK(int) rtDbgModPdb_SegmentByIndex(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, PRTDBGSEGMENT pSegInfo)
3683	{
3684	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3685	return RTDbgModSegmentByIndex(pThis->hCnt, iSeg, pSegInfo);
3686	}
3687
3688
3689	/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentCount} */
3690	static DECLCALLBACK(RTDBGSEGIDX) rtDbgModPdb_SegmentCount(PRTDBGMODINT pMod)
3691	{
3692	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3693	return RTDbgModSegmentCount(pThis->hCnt);
3694	}
3695
3696
3697	/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentAdd} */
3698	static DECLCALLBACK(int) rtDbgModPdb_SegmentAdd(PRTDBGMODINT pMod, RTUINTPTR uRva, RTUINTPTR cb, const char *pszName,
3699	size_t cchName, uint32_t fFlags, PRTDBGSEGIDX piSeg)
3700	{
3701	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3702	Assert(!pszName[cchName]); NOREF(cchName);
3703	return RTDbgModSegmentAdd(pThis->hCnt, uRva, cb, pszName, fFlags, piSeg);
3704	}
3705
3706
3707	/** @interface_method_impl{RTDBGMODVTDBG,pfnImageSize} */
3708	static DECLCALLBACK(RTUINTPTR) rtDbgModPdb_ImageSize(PRTDBGMODINT pMod)
3709	{
3710	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3711	if (pThis->cbImage)
3712	return pThis->cbImage;
3713	return RTDbgModImageSize(pThis->hCnt);
3714	}
3715
3716
3717	/** @interface_method_impl{RTDBGMODVTDBG,pfnRvaToSegOff} */
3718	static DECLCALLBACK(RTDBGSEGIDX) rtDbgModPdb_RvaToSegOff(PRTDBGMODINT pMod, RTUINTPTR uRva, PRTUINTPTR poffSeg)
3719	{
3720	PRTDBGMODCV pThis = (PRTDBGMODCV)pMod->pvDbgPriv;
3721	return RTDbgModRvaToSegOff(pThis->hCnt, uRva, poffSeg);
3722	}
3723
3724
3725	/** @interface_method_impl{RTDBGMODVTDBG,pfnClose} */
3726	static DECLCALLBACK(int) rtDbgModPdb_Close(PRTDBGMODINT pMod)
3727	{
3728	return rtDbgModCv_Close(pMod);
3729	}
3730
3731
3732	/*
3733	*
3734	* Probing code used by rtDbgModPdb_TryOpen.
3735	* Probing code used by rtDbgModPdb_TryOpen.
3736	*
3737	*/
3738
3739	static int rtDbgModPdb_ScanSymRecs(PRTDBGMODCV pThis, RTVFS hVfsPdb)
3740	{
3741	RTVFSFILE hVfsFileSymRecs = NIL_RTVFSFILE;
3742	int rc = RTVfsFileOpen(hVfsPdb, "symbol-records", RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE, &hVfsFileSymRecs);
3743	if (RT_SUCCESS(rc))
3744	{
3745	void *pvSymRecs;
3746	size_t cbSymRecs;
3747	rc = RTVfsFileReadAll(hVfsFileSymRecs, &pvSymRecs, &cbSymRecs);
3748	RTVfsFileRelease(hVfsFileSymRecs);
3749	if (RT_SUCCESS(rc))
3750	{
3751	Log3(("rtDbgModPdb_ScanSymRecs: %p LB %#x\n", pvSymRecs, cbSymRecs));
3752	rc = rtDbgModCvSsProcessV4PlusSymTab(pThis, pvSymRecs, cbSymRecs, 0 /fFlags/);
3753
3754	RTVfsFileReadAllFree(pvSymRecs, cbSymRecs);
3755	}
3756	else
3757	Log(("rtDbgModPdb_ScanSymRecs: RTVfsFileReadAll failed - %Rrc\n", rc));
3758	}
3759	return rc;
3760	}
3761
3762
3763	static int rtDbgModPdb_LoadSegMap(PRTDBGMODCV pThis, RTVFS hVfsPdb)
3764	{
3765	/*
3766	* Open the DBI section map and read it into a regular heap block just like
3767	* rtDbgModCvReadAtAlloc does for the other code path.
3768	*/
3769	RTVFSFILE hVfsFile = NIL_RTVFSFILE;
3770	int rc = RTVfsFileOpen(hVfsPdb, "dbi-section-map", RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE, &hVfsFile);
3771	if (RT_SUCCESS(rc))
3772	{
3773	uint64_t cbSegMap;
3774	rc = RTVfsFileQuerySize(hVfsFile, &cbSegMap);
3775	AssertRC(rc);
3776	if (RT_SUCCESS(rc))
3777	{
3778	if ( cbSegMap >= RT_UOFFSETOF(RTCVSEGMAP, aDescs)
3779	&& cbSegMap <= RT_UOFFSETOF_DYN(RTCVSEGMAP, aDescs[4096])) /* random upper limit */
3780	{
3781	pThis->pSegMap = (PRTCVSEGMAP)RTMemAlloc((size_t)cbSegMap);
3782	if (pThis->pSegMap)
3783	{
3784	rc = RTVfsFileReadAt(hVfsFile, 0, pThis->pSegMap, cbSegMap, NULL);
3785	if (RT_SUCCESS(rc))
3786	{
3787	/*
3788	* Join paths with the codeview module reader and process the map.
3789	*/
3790	rc = rtDbgModCvProcessSegmentMap(pThis);
3791
3792	}
3793	else
3794	Log(("rtDbgModPdb_LoadSegMap: Read error: %Rrc\n", rc));
3795	}
3796	else
3797	rc = VERR_NO_MEMORY;
3798	}
3799	else
3800	{
3801	Log(("rtDbgModPdb_LoadSegMap: Bogus section map size: %#RX64\n", cbSegMap));
3802	rc = VERR_CV_BAD_FORMAT;
3803	}
3804	}
3805	RTVfsFileRelease(hVfsFile);
3806	}
3807	else
3808	{
3809	Log(("rtDbgModPdb_LoadSegMap: Failed to open dbi-section-map: %Rrc\n", rc));
3810	if (rc == VERR_PATH_NOT_FOUND \|\| rc == VERR_FILE_NOT_FOUND)
3811	rc = VINF_SUCCESS;
3812	}
3813	return rc;
3814	}
3815
3816
3817	/**
3818	* Helper for rtDbgModPdb_TryOpen that loads the section/segments into the
3819	* container.
3820	*/
3821	static int rtDbgModPdb_LoadSections(PRTDBGMODCV pThis, PRTDBGMODINT pDbgMod, RTVFS hVfsPdb, const char *pszFilename)
3822	{
3823	/*
3824	* Use the info from the image if present.
3825	*/
3826	int rc;
3827	if (pDbgMod->pImgVt)
3828	rc = pDbgMod->pImgVt->pfnEnumSegments(pDbgMod, rtDbgModCvAddSegmentsCallback, pThis);
3829	/*
3830	* Otherwise use the copy of the section table from the PDB.
3831	*/
3832	else
3833	{
3834	RTVFSFILE hVfsFileSHdrs;
3835	rc = RTVfsFileOpen(hVfsPdb, "image-section-headers", RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE, &hVfsFileSHdrs);
3836	if (RT_SUCCESS(rc))
3837	{
3838	PIMAGE_SECTION_HEADER paShs = NULL;
3839	size_t cbSHdrs = 0;
3840	rc = RTVfsFileReadAll(hVfsFileSHdrs, (void **)&paShs, &cbSHdrs);
3841	RTVfsFileRelease(hVfsFileSHdrs);
3842	if (RT_SUCCESS(rc))
3843	{
3844	rc = rtDbgModCvAddSegmentsFromSectHdrs(pThis, paShs, (uint32_t)(cbSHdrs / sizeof(IMAGE_SECTION_HEADER)),
3845	1 /* cbSectAlign - only for validation */,
3846	pThis->cbImage ? (uint32_t)pThis->cbImage : UINT32_MAX /* only for validation */,
3847	pszFilename);
3848	RTVfsFileReadAllFree(paShs, cbSHdrs);
3849	}
3850	else
3851	Log(("rtDbgModPdb_LoadSections: RTVfsFileReadAll failed - %Rrc\n", rc));
3852	}
3853	else
3854	Log2(("rtDbgModPdb_TryOpen: Failed to open 'image-section-headers' in '%s' -> %Rrc\n", pszFilename, rc));
3855	}
3856	RT_NOREF(pszFilename);
3857	pThis->fHaveLoadedSegments = true;
3858	return rc;
3859	}
3860
3861
3862	/**
3863	* Common worker for rtDbgModPdb_TryOpen and rtDbgModCv_TryOpen (for DBG+PDB).
3864	*/
3865	static int rtDbgModPdb_CommonOpenWorker(PRTDBGMODCV pThis, const char *pszFilename, RTVFS hVfsPdb, RTDBGCFG hDbgCfg)
3866	{
3867	RT_NOREF(hDbgCfg, pszFilename);
3868
3869	/*
3870	* We need section headers to successfully deal with the section (segment)
3871	* map and symbol records. If there is an associated EXE or DBG file, they
3872	* will have segment information we can enumerate or load. In the DBG case,
3873	* it's already done by the time we get here. Otherwise, newer PDB files
3874	* will include a copy of the section header and we can use that of we got
3875	* no EXE or DBG files.
3876	*/
3877	int rc = VINF_SUCCESS;
3878	if (!pThis->fHaveLoadedSegments)
3879	rc = rtDbgModPdb_LoadSections(pThis, pThis->pMod, hVfsPdb, pszFilename);
3880	if (RT_SUCCESS(rc))
3881	{
3882	/*
3883	* Load the section/segment map as we need to know how absolute segments
3884	* and such. This should definitely be done after loading sections.
3885	* (Unfortuantely, the segement map doesn't not provide sufficient
3886	* information to replace the section headers if we cannot find them.)
3887	*/
3888	rc = rtDbgModPdb_LoadSegMap(pThis, hVfsPdb);
3889	if (RT_SUCCESS(rc))
3890	{
3891	/*
3892	* Scan symbol records for symbol addresses and anything else we find
3893	* interesting.
3894	*/
3895	rc = rtDbgModPdb_ScanSymRecs(pThis, hVfsPdb);
3896	if (RT_SUCCESS(rc))
3897	{
3898	/*
3899	* We're good.
3900	*/
3901	/** @todo load source files and line numbers if present. */
3902	/** @todo load unwind information. */
3903	Log(("rtDbgModPdb_TryOpen: Succeeded\n"));
3904	return VINF_SUCCESS;
3905	}
3906	Log(("rtDbgModPdb_TryOpen: rtDbgModPdb_ScanSymRecs failed - %Rrc\n", rc));
3907	}
3908	else
3909	Log(("rtDbgModPdb_TryOpen: rtDbgModPdb_LoadSegMap failed on '%s' -> %Rrc\n", pszFilename, rc));
3910	}
3911	else
3912	Log(("rtDbgModPdb_TryOpen: rtDbgModPdb_LoadSections failed on '%s' -> %Rrc\n", pszFilename, rc));
3913	return rc;
3914	}
3915
3916
3917	/** @interface_method_impl{RTDBGMODVTDBG,pfnTryOpen} */
3918	static DECLCALLBACK(int) rtDbgModPdb_TryOpen(PRTDBGMODINT pMod, RTLDRARCH enmArch, RTDBGCFG hDbgCfg)
3919	{
3920	/*
3921	* This only works for external files for now.
3922	*/
3923	if (!pMod->pszDbgFile)
3924	return VERR_DBG_NO_MATCHING_INTERPRETER;
3925
3926	/*
3927	* Open the PDB as a VFS.
3928	*/
3929	RTVFSFILE hVfsFilePdb = NIL_RTVFSFILE;
3930	int rc = RTVfsFileOpenNormal(pMod->pszDbgFile, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE, &hVfsFilePdb);
3931	if (RT_SUCCESS(rc))
3932	{
3933	RTVFS hVfsPdb = NIL_RTVFS;
3934	#ifdef LOG_ENABLED
3935	RTERRINFOSTATIC ErrInfo;
3936	rc = RTFsPdbVolOpen(hVfsFilePdb, 0, &hVfsPdb, RTErrInfoInitStatic(&ErrInfo));
3937	#else
3938	rc = RTFsPdbVolOpen(hVfsFilePdb, 0, &hVfsPdb, NULL /pErrInfo/);
3939	#endif
3940	RTVfsFileRelease(hVfsFilePdb);
3941	if (RT_SUCCESS(rc))
3942	{
3943	/** @todo check enmArch. It's part of the new DBI header. */
3944	RT_NOREF(enmArch);
3945
3946	/*
3947	* Create an instance so we can share the next bits with the DBG+PDB
3948	* code path in rtDbgModCv_TryOpen. We need to be able to check if
3949	* section headers have been loaded among other things.
3950	*/
3951	PRTDBGMODCV pThis;
3952	rc = rtDbgModCvCreateInstance(pMod, RTCVFILETYPE_PDB, NIL_RTFILE, &pThis);
3953	if (RT_SUCCESS(rc))
3954	{
3955	rc = rtDbgModPdb_CommonOpenWorker(pThis, pMod->pszDbgFile, hVfsPdb, hDbgCfg);
3956	if (RT_FAILURE(rc))
3957	rtDbgModCv_Close(pMod);
3958	}
3959	RTVfsRelease(hVfsPdb);
3960	}
3961	else
3962	Log2(("rtDbgModPdb_TryOpen: RTFsPdbVolOpen '%s' -> %Rrc%#RTeim\n", pMod->pszDbgFile, rc, &ErrInfo.Core));
3963	}
3964	else
3965	Log2(("rtDbgModPdb_TryOpen: RTVfsFileOpenNormal '%s' -> %Rrc\n", pMod->pszDbgFile, rc));
3966	return rc;
3967	}
3968
3969
3970
3971	/** Virtual function table for the PDB debug info reader. */
3972	DECL_HIDDEN_CONST(RTDBGMODVTDBG) const g_rtDbgModVtDbgPdb =
3973	{
3974	/.u32Magic = / RTDBGMODVTDBG_MAGIC,
3975	/.fSupports = / RT_DBGTYPE_CODEVIEW,
3976	/.pszName = / "pdb",
3977	/.pfnTryOpen = / rtDbgModPdb_TryOpen,
3978	/.pfnClose = / rtDbgModPdb_Close,
3979
3980	/.pfnRvaToSegOff = / rtDbgModPdb_RvaToSegOff,
3981	/.pfnImageSize = / rtDbgModPdb_ImageSize,
3982
3983	/.pfnSegmentAdd = / rtDbgModPdb_SegmentAdd,
3984	/.pfnSegmentCount = / rtDbgModPdb_SegmentCount,
3985	/.pfnSegmentByIndex = / rtDbgModPdb_SegmentByIndex,
3986
3987	/.pfnSymbolAdd = / rtDbgModPdb_SymbolAdd,
3988	/.pfnSymbolCount = / rtDbgModPdb_SymbolCount,
3989	/.pfnSymbolByOrdinal = / rtDbgModPdb_SymbolByOrdinal,
3990	/.pfnSymbolByName = / rtDbgModPdb_SymbolByName,
3991	/.pfnSymbolByAddr = / rtDbgModPdb_SymbolByAddr,
3992
3993	/.pfnLineAdd = / rtDbgModPdb_LineAdd,
3994	/.pfnLineCount = / rtDbgModPdb_LineCount,
3995	/.pfnLineByOrdinal = / rtDbgModPdb_LineByOrdinal,
3996	/.pfnLineByAddr = / rtDbgModPdb_LineByAddr,
3997
3998	/.pfnUnwindFrame = / rtDbgModPdb_UnwindFrame,
3999
4000	/.u32EndMagic = / RTDBGMODVTDBG_MAGIC
4001	};
4002

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

source: vbox/trunk/src/VBox/Runtime/common/dbg/dbgmodcodeview.cpp

Download in other formats: