dbgmoddwarf.cpp@ 100765

Last change on this file since 100765 was 99775, checked in by vboxsync, 19 months ago
*: Mark functions as static if not used outside of a given compilation unit. Enables the compiler to optimize inlining, reduces the symbol tables, exposes unused functions and in some rare cases exposes mismtaches between function declarations and definitions, but most importantly reduces the number of parfait reports for the extern-function-no-forward-declaration category. This should not result in any functional changes, bugref:3409
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 230.1 KB

Line
1	/* $Id: dbgmoddwarf.cpp 99775 2023-05-12 12:21:58Z vboxsync $ */
2	/** @file
3	* IPRT - Debug Info Reader For DWARF.
4	*/
5
6	/*
7	* Copyright (C) 2011-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#define LOG_GROUP RTLOGGROUP_DBG_DWARF
42	#include <iprt/dbg.h>
43	#include "internal/iprt.h"
44
45	#include <iprt/asm.h>
46	#include <iprt/ctype.h>
47	#include <iprt/err.h>
48	#include <iprt/list.h>
49	#include <iprt/log.h>
50	#include <iprt/mem.h>
51	#define RTDBGMODDWARF_WITH_MEM_CACHE
52	#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
53	# include <iprt/memcache.h>
54	#endif
55	#include <iprt/path.h>
56	#include <iprt/string.h>
57	#include <iprt/strcache.h>
58	#include <iprt/x86.h>
59	#include <iprt/formats/dwarf.h>
60	#include "internal/dbgmod.h"
61
62
63
64	/*********************************************************************************************************************************
65	* Structures and Typedefs *
66	*********************************************************************************************************************************/
67	/** Pointer to a DWARF section reader. */
68	typedef struct RTDWARFCURSOR *PRTDWARFCURSOR;
69	/** Pointer to an attribute descriptor. */
70	typedef struct RTDWARFATTRDESC const *PCRTDWARFATTRDESC;
71	/** Pointer to a DIE. */
72	typedef struct RTDWARFDIE *PRTDWARFDIE;
73	/** Pointer to a const DIE. */
74	typedef struct RTDWARFDIE const *PCRTDWARFDIE;
75
76	/**
77	* DWARF sections.
78	*/
79	typedef enum krtDbgModDwarfSect
80	{
81	krtDbgModDwarfSect_abbrev = 0,
82	krtDbgModDwarfSect_aranges,
83	krtDbgModDwarfSect_frame,
84	krtDbgModDwarfSect_info,
85	krtDbgModDwarfSect_inlined,
86	krtDbgModDwarfSect_line,
87	krtDbgModDwarfSect_loc,
88	krtDbgModDwarfSect_macinfo,
89	krtDbgModDwarfSect_pubnames,
90	krtDbgModDwarfSect_pubtypes,
91	krtDbgModDwarfSect_ranges,
92	krtDbgModDwarfSect_str,
93	krtDbgModDwarfSect_types,
94	/** End of valid parts (exclusive). */
95	krtDbgModDwarfSect_End
96	} krtDbgModDwarfSect;
97
98	/**
99	* Abbreviation cache entry.
100	*/
101	typedef struct RTDWARFABBREV
102	{
103	/** Whether there are children or not. */
104	bool fChildren;
105	#ifdef LOG_ENABLED
106	uint8_t cbHdr; /*< For calcing ABGOFF matching dwarfdump. /
107	#endif
108	/** The tag. */
109	uint16_t uTag;
110	/** Offset into the abbrev section of the specification pairs. */
111	uint32_t offSpec;
112	/** The abbreviation table offset this is entry is valid for.
113	* UINT32_MAX if not valid. */
114	uint32_t offAbbrev;
115	} RTDWARFABBREV;
116	/** Pointer to an abbreviation cache entry. */
117	typedef RTDWARFABBREV *PRTDWARFABBREV;
118	/** Pointer to a const abbreviation cache entry. */
119	typedef RTDWARFABBREV const *PCRTDWARFABBREV;
120
121	/**
122	* Structure for gathering segment info.
123	*/
124	typedef struct RTDBGDWARFSEG
125	{
126	/** The highest offset in the segment. */
127	uint64_t offHighest;
128	/** Calculated base address. */
129	uint64_t uBaseAddr;
130	/** Estimated The segment size. */
131	uint64_t cbSegment;
132	/** Segment number (RTLDRSEG::Sel16bit). */
133	RTSEL uSegment;
134	} RTDBGDWARFSEG;
135	/** Pointer to segment info. */
136	typedef RTDBGDWARFSEG *PRTDBGDWARFSEG;
137
138
139	/**
140	* The instance data of the DWARF reader.
141	*/
142	typedef struct RTDBGMODDWARF
143	{
144	/** The debug container containing doing the real work. */
145	RTDBGMOD hCnt;
146	/** The image module (no reference). */
147	PRTDBGMODINT pImgMod;
148	/** The debug info module (no reference). */
149	PRTDBGMODINT pDbgInfoMod;
150	/** Nested image module (with reference ofc). */
151	PRTDBGMODINT pNestedMod;
152
153	/** DWARF debug info sections. */
154	struct
155	{
156	/** The file offset of the part. */
157	RTFOFF offFile;
158	/** The size of the part. */
159	size_t cb;
160	/** The memory mapping of the part. */
161	void const *pv;
162	/** Set if present. */
163	bool fPresent;
164	/** The debug info ordinal number in the image file. */
165	uint32_t iDbgInfo;
166	} aSections[krtDbgModDwarfSect_End];
167
168	/** The offset into the abbreviation section of the current cache. */
169	uint32_t offCachedAbbrev;
170	/** The number of cached abbreviations we've allocated space for. */
171	uint32_t cCachedAbbrevsAlloced;
172	/** Array of cached abbreviations, indexed by code. */
173	PRTDWARFABBREV paCachedAbbrevs;
174	/** Used by rtDwarfAbbrev_Lookup when the result is uncachable. */
175	RTDWARFABBREV LookupAbbrev;
176
177	/** The list of compilation units (RTDWARFDIE). */
178	RTLISTANCHOR CompileUnitList;
179
180	/** Set if we have to use link addresses because the module does not have
181	* fixups (mach_kernel). */
182	bool fUseLinkAddress;
183	/** This is set to -1 if we're doing everything in one pass.
184	* Otherwise it's 1 or 2:
185	* - In pass 1, we collect segment info.
186	* - In pass 2, we add debug info to the container.
187	* The two pass parsing is necessary for watcom generated symbol files as
188	* these contains no information about the code and data segments in the
189	* image. So we have to figure out some approximate stuff based on the
190	* segments and offsets we encounter in the debug info. */
191	int8_t iWatcomPass;
192	/** Segment index hint. */
193	uint16_t iSegHint;
194	/** The number of segments in paSegs.
195	* (During segment copying, this is abused to count useful segments.) */
196	uint32_t cSegs;
197	/** Pointer to segments if iWatcomPass isn't -1. */
198	PRTDBGDWARFSEG paSegs;
199	#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
200	/** DIE allocators. */
201	struct
202	{
203	RTMEMCACHE hMemCache;
204	uint32_t cbMax;
205	} aDieAllocators[2];
206	#endif
207	} RTDBGMODDWARF;
208	/** Pointer to instance data of the DWARF reader. */
209	typedef RTDBGMODDWARF *PRTDBGMODDWARF;
210
211	/**
212	* DWARF cursor for reading byte data.
213	*/
214	typedef struct RTDWARFCURSOR
215	{
216	/** The current position. */
217	uint8_t const *pb;
218	/** The number of bytes left to read. */
219	size_t cbLeft;
220	/** The number of bytes left to read in the current unit. */
221	size_t cbUnitLeft;
222	/** The DWARF debug info reader instance. (Can be NULL for eh_frame.) */
223	PRTDBGMODDWARF pDwarfMod;
224	/** Set if this is 64-bit DWARF, clear if 32-bit. */
225	bool f64bitDwarf;
226	/** Set if the format endian is native, clear if endian needs to be
227	* inverted. */
228	bool fNativEndian;
229	/** The size of a native address. */
230	uint8_t cbNativeAddr;
231	/** The cursor status code. This is VINF_SUCCESS until some error
232	* occurs. */
233	int rc;
234	/** The start of the area covered by the cursor.
235	* Used for repositioning the cursor relative to the start of a section. */
236	uint8_t const *pbStart;
237	/** The section. */
238	krtDbgModDwarfSect enmSect;
239	} RTDWARFCURSOR;
240
241
242	/**
243	* DWARF line number program state.
244	*/
245	typedef struct RTDWARFLINESTATE
246	{
247	/** @name Virtual Line Number Machine Registers.
248	* @{ */
249	struct
250	{
251	uint64_t uAddress;
252	uint64_t idxOp;
253	uint32_t iFile;
254	uint32_t uLine;
255	uint32_t uColumn;
256	bool fIsStatement;
257	bool fBasicBlock;
258	bool fEndSequence;
259	bool fPrologueEnd;
260	bool fEpilogueBegin;
261	uint32_t uIsa;
262	uint32_t uDiscriminator;
263	RTSEL uSegment;
264	} Regs;
265	/** @} */
266
267	/** Header. */
268	struct
269	{
270	uint32_t uVer;
271	uint64_t offFirstOpcode;
272	uint8_t cbMinInstr;
273	uint8_t cMaxOpsPerInstr;
274	uint8_t u8DefIsStmt;
275	int8_t s8LineBase;
276	uint8_t u8LineRange;
277	uint8_t u8OpcodeBase;
278	uint8_t const *pacStdOperands;
279	} Hdr;
280
281	/** @name Include Path Table (0-based)
282	* @{ */
283	const char **papszIncPaths;
284	uint32_t cIncPaths;
285	/** @} */
286
287	/** @name File Name Table (0-based, dummy zero entry)
288	* @{ */
289	char **papszFileNames;
290	uint32_t cFileNames;
291	/** @} */
292
293	/** The DWARF debug info reader instance. */
294	PRTDBGMODDWARF pDwarfMod;
295	} RTDWARFLINESTATE;
296	/** Pointer to a DWARF line number program state. */
297	typedef RTDWARFLINESTATE *PRTDWARFLINESTATE;
298
299
300	/**
301	* Decodes an attribute and stores it in the specified DIE member field.
302	*
303	* @returns IPRT status code.
304	* @param pDie Pointer to the DIE structure.
305	* @param pbMember Pointer to the first byte in the member.
306	* @param pDesc The attribute descriptor.
307	* @param uForm The data form.
308	* @param pCursor The cursor to read data from.
309	*/
310	typedef DECLCALLBACKTYPE(int, FNRTDWARFATTRDECODER,(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
311	uint32_t uForm, PRTDWARFCURSOR pCursor));
312	/** Pointer to an attribute decoder callback. */
313	typedef FNRTDWARFATTRDECODER *PFNRTDWARFATTRDECODER;
314
315	/**
316	* Attribute descriptor.
317	*/
318	typedef struct RTDWARFATTRDESC
319	{
320	/** The attribute. */
321	uint16_t uAttr;
322	/** The data member offset. */
323	uint16_t off;
324	/** The data member size and initialization method. */
325	uint8_t cbInit;
326	uint8_t bPadding[3]; /*< Alignment padding. /
327	/** The decoder function. */
328	PFNRTDWARFATTRDECODER pfnDecoder;
329	} RTDWARFATTRDESC;
330
331	/** Define a attribute entry. */
332	#define ATTR_ENTRY(a_uAttr, a_Struct, a_Member, a_Init, a_pfnDecoder) \
333	{ \
334	a_uAttr, \
335	(uint16_t)RT_OFFSETOF(a_Struct, a_Member), \
336	a_Init \| ((uint8_t)RT_SIZEOFMEMB(a_Struct, a_Member) & ATTR_SIZE_MASK), \
337	{ 0, 0, 0 }, \
338	a_pfnDecoder\
339	}
340
341	/** @name Attribute size and init methods.
342	* @{ */
343	#define ATTR_INIT_ZERO UINT8_C(0x00)
344	#define ATTR_INIT_FFFS UINT8_C(0x80)
345	#define ATTR_INIT_MASK UINT8_C(0x80)
346	#define ATTR_SIZE_MASK UINT8_C(0x3f)
347	#define ATTR_GET_SIZE(a_pAttrDesc) ((a_pAttrDesc)->cbInit & ATTR_SIZE_MASK)
348	/** @} */
349
350
351	/**
352	* DIE descriptor.
353	*/
354	typedef struct RTDWARFDIEDESC
355	{
356	/** The size of the DIE. */
357	size_t cbDie;
358	/** The number of attributes. */
359	size_t cAttributes;
360	/** Pointer to the array of attributes. */
361	PCRTDWARFATTRDESC paAttributes;
362	} RTDWARFDIEDESC;
363	typedef struct RTDWARFDIEDESC const *PCRTDWARFDIEDESC;
364	/** DIE descriptor initializer. */
365	#define DIE_DESC_INIT(a_Type, a_aAttrs) { sizeof(a_Type), RT_ELEMENTS(a_aAttrs), &a_aAttrs[0] }
366
367
368	/**
369	* DIE core structure, all inherits (starts with) this.
370	*/
371	typedef struct RTDWARFDIE
372	{
373	/** Pointer to the parent node. NULL if root unit. */
374	struct RTDWARFDIE *pParent;
375	/** Our node in the sibling list. */
376	RTLISTNODE SiblingNode;
377	/** List of children. */
378	RTLISTNODE ChildList;
379	/** The number of attributes successfully decoded. */
380	uint8_t cDecodedAttrs;
381	/** The number of unknown or otherwise unhandled attributes. */
382	uint8_t cUnhandledAttrs;
383	#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
384	/** The allocator index. */
385	uint8_t iAllocator;
386	#endif
387	/** The die tag, indicating which union structure to use. */
388	uint16_t uTag;
389	/** Offset of the abbreviation specification (within debug_abbrev). */
390	uint32_t offSpec;
391	} RTDWARFDIE;
392
393
394	/**
395	* DWARF address structure.
396	*/
397	typedef struct RTDWARFADDR
398	{
399	/** The address. */
400	uint64_t uAddress;
401	} RTDWARFADDR;
402	typedef RTDWARFADDR *PRTDWARFADDR;
403	typedef RTDWARFADDR const *PCRTDWARFADDR;
404
405
406	/**
407	* DWARF address range.
408	*/
409	typedef struct RTDWARFADDRRANGE
410	{
411	uint64_t uLowAddress;
412	uint64_t uHighAddress;
413	uint8_t const pbRanges; / ?? */
414	uint8_t cAttrs : 2;
415	uint8_t fHaveLowAddress : 1;
416	uint8_t fHaveHighAddress : 1;
417	uint8_t fHaveHighIsAddress : 1;
418	uint8_t fHaveRanges : 1;
419	} RTDWARFADDRRANGE;
420	typedef RTDWARFADDRRANGE *PRTDWARFADDRRANGE;
421	typedef RTDWARFADDRRANGE const *PCRTDWARFADDRRANGE;
422
423	/** What a RTDWARFREF is relative to. */
424	typedef enum krtDwarfRef
425	{
426	krtDwarfRef_NotSet,
427	krtDwarfRef_LineSection,
428	krtDwarfRef_LocSection,
429	krtDwarfRef_RangesSection,
430	krtDwarfRef_InfoSection,
431	krtDwarfRef_SameUnit,
432	krtDwarfRef_TypeId64
433	} krtDwarfRef;
434
435	/**
436	* DWARF reference.
437	*/
438	typedef struct RTDWARFREF
439	{
440	/** The offset. */
441	uint64_t off;
442	/** What the offset is relative to. */
443	krtDwarfRef enmWrt;
444	} RTDWARFREF;
445	typedef RTDWARFREF *PRTDWARFREF;
446	typedef RTDWARFREF const *PCRTDWARFREF;
447
448
449	/**
450	* DWARF Location state.
451	*/
452	typedef struct RTDWARFLOCST
453	{
454	/** The input cursor. */
455	RTDWARFCURSOR Cursor;
456	/** Points to the current top of the stack. Initial value -1. */
457	int32_t iTop;
458	/** The value stack. */
459	uint64_t auStack[64];
460	} RTDWARFLOCST;
461	/** Pointer to location state. */
462	typedef RTDWARFLOCST *PRTDWARFLOCST;
463
464
465
466	/*********************************************************************************************************************************
467	* Internal Functions *
468	*********************************************************************************************************************************/
469	static FNRTDWARFATTRDECODER rtDwarfDecode_Address;
470	static FNRTDWARFATTRDECODER rtDwarfDecode_Bool;
471	static FNRTDWARFATTRDECODER rtDwarfDecode_LowHighPc;
472	static FNRTDWARFATTRDECODER rtDwarfDecode_Ranges;
473	static FNRTDWARFATTRDECODER rtDwarfDecode_Reference;
474	static FNRTDWARFATTRDECODER rtDwarfDecode_SectOff;
475	static FNRTDWARFATTRDECODER rtDwarfDecode_String;
476	static FNRTDWARFATTRDECODER rtDwarfDecode_UnsignedInt;
477	static FNRTDWARFATTRDECODER rtDwarfDecode_SegmentLoc;
478
479
480	/*********************************************************************************************************************************
481	* Global Variables *
482	*********************************************************************************************************************************/
483	/** RTDWARFDIE description. */
484	static const RTDWARFDIEDESC g_CoreDieDesc = { sizeof(RTDWARFDIE), 0, NULL };
485
486
487	/**
488	* DW_TAG_compile_unit & DW_TAG_partial_unit.
489	*/
490	typedef struct RTDWARFDIECOMPILEUNIT
491	{
492	/** The DIE core structure. */
493	RTDWARFDIE Core;
494	/** The unit name. */
495	const char *pszName;
496	/** The address range of the code belonging to this unit. */
497	RTDWARFADDRRANGE PcRange;
498	/** The language name. */
499	uint16_t uLanguage;
500	/** The identifier case. */
501	uint8_t uIdentifierCase;
502	/** String are UTF-8 encoded. If not set, the encoding is
503	* unknown. */
504	bool fUseUtf8;
505	/** The unit contains main() or equivalent. */
506	bool fMainFunction;
507	/** The line numbers for this unit. */
508	RTDWARFREF StmtListRef;
509	/** The macro information for this unit. */
510	RTDWARFREF MacroInfoRef;
511	/** Reference to the base types. */
512	RTDWARFREF BaseTypesRef;
513	/** Working directory for the unit. */
514	const char *pszCurDir;
515	/** The name of the compiler or whatever that produced this unit. */
516	const char *pszProducer;
517
518	/** @name From the unit header.
519	* @{ */
520	/** The offset into debug_info of this unit (for references). */
521	uint64_t offUnit;
522	/** The length of this unit. */
523	uint64_t cbUnit;
524	/** The offset into debug_abbrev of the abbreviation for this unit. */
525	uint64_t offAbbrev;
526	/** The native address size. */
527	uint8_t cbNativeAddr;
528	/** The DWARF version. */
529	uint8_t uDwarfVer;
530	/** @} */
531	} RTDWARFDIECOMPILEUNIT;
532	typedef RTDWARFDIECOMPILEUNIT *PRTDWARFDIECOMPILEUNIT;
533
534
535	/** RTDWARFDIECOMPILEUNIT attributes. */
536	static const RTDWARFATTRDESC g_aCompileUnitAttrs[] =
537	{
538	ATTR_ENTRY(DW_AT_name, RTDWARFDIECOMPILEUNIT, pszName, ATTR_INIT_ZERO, rtDwarfDecode_String),
539	ATTR_ENTRY(DW_AT_low_pc, RTDWARFDIECOMPILEUNIT, PcRange, ATTR_INIT_ZERO, rtDwarfDecode_LowHighPc),
540	ATTR_ENTRY(DW_AT_high_pc, RTDWARFDIECOMPILEUNIT, PcRange, ATTR_INIT_ZERO, rtDwarfDecode_LowHighPc),
541	ATTR_ENTRY(DW_AT_ranges, RTDWARFDIECOMPILEUNIT, PcRange, ATTR_INIT_ZERO, rtDwarfDecode_Ranges),
542	ATTR_ENTRY(DW_AT_language, RTDWARFDIECOMPILEUNIT, uLanguage, ATTR_INIT_ZERO, rtDwarfDecode_UnsignedInt),
543	ATTR_ENTRY(DW_AT_macro_info, RTDWARFDIECOMPILEUNIT, MacroInfoRef, ATTR_INIT_ZERO, rtDwarfDecode_SectOff),
544	ATTR_ENTRY(DW_AT_stmt_list, RTDWARFDIECOMPILEUNIT, StmtListRef, ATTR_INIT_ZERO, rtDwarfDecode_SectOff),
545	ATTR_ENTRY(DW_AT_comp_dir, RTDWARFDIECOMPILEUNIT, pszCurDir, ATTR_INIT_ZERO, rtDwarfDecode_String),
546	ATTR_ENTRY(DW_AT_producer, RTDWARFDIECOMPILEUNIT, pszProducer, ATTR_INIT_ZERO, rtDwarfDecode_String),
547	ATTR_ENTRY(DW_AT_identifier_case, RTDWARFDIECOMPILEUNIT, uIdentifierCase,ATTR_INIT_ZERO, rtDwarfDecode_UnsignedInt),
548	ATTR_ENTRY(DW_AT_base_types, RTDWARFDIECOMPILEUNIT, BaseTypesRef, ATTR_INIT_ZERO, rtDwarfDecode_Reference),
549	ATTR_ENTRY(DW_AT_use_UTF8, RTDWARFDIECOMPILEUNIT, fUseUtf8, ATTR_INIT_ZERO, rtDwarfDecode_Bool),
550	ATTR_ENTRY(DW_AT_main_subprogram, RTDWARFDIECOMPILEUNIT, fMainFunction, ATTR_INIT_ZERO, rtDwarfDecode_Bool)
551	};
552
553	/** RTDWARFDIECOMPILEUNIT description. */
554	static const RTDWARFDIEDESC g_CompileUnitDesc = DIE_DESC_INIT(RTDWARFDIECOMPILEUNIT, g_aCompileUnitAttrs);
555
556
557	/**
558	* DW_TAG_subprogram.
559	*/
560	typedef struct RTDWARFDIESUBPROGRAM
561	{
562	/** The DIE core structure. */
563	RTDWARFDIE Core;
564	/** The name. */
565	const char *pszName;
566	/** The linkage name. */
567	const char *pszLinkageName;
568	/** The address range of the code belonging to this unit. */
569	RTDWARFADDRRANGE PcRange;
570	/** The first instruction in the function. */
571	RTDWARFADDR EntryPc;
572	/** Segment number (watcom). */
573	RTSEL uSegment;
574	/** Reference to the specification. */
575	RTDWARFREF SpecRef;
576	} RTDWARFDIESUBPROGRAM;
577	/** Pointer to a DW_TAG_subprogram DIE. */
578	typedef RTDWARFDIESUBPROGRAM *PRTDWARFDIESUBPROGRAM;
579	/** Pointer to a const DW_TAG_subprogram DIE. */
580	typedef RTDWARFDIESUBPROGRAM const *PCRTDWARFDIESUBPROGRAM;
581
582
583	/** RTDWARFDIESUBPROGRAM attributes. */
584	static const RTDWARFATTRDESC g_aSubProgramAttrs[] =
585	{
586	ATTR_ENTRY(DW_AT_name, RTDWARFDIESUBPROGRAM, pszName, ATTR_INIT_ZERO, rtDwarfDecode_String),
587	ATTR_ENTRY(DW_AT_linkage_name, RTDWARFDIESUBPROGRAM, pszLinkageName, ATTR_INIT_ZERO, rtDwarfDecode_String),
588	ATTR_ENTRY(DW_AT_MIPS_linkage_name, RTDWARFDIESUBPROGRAM, pszLinkageName, ATTR_INIT_ZERO, rtDwarfDecode_String),
589	ATTR_ENTRY(DW_AT_low_pc, RTDWARFDIESUBPROGRAM, PcRange, ATTR_INIT_ZERO, rtDwarfDecode_LowHighPc),
590	ATTR_ENTRY(DW_AT_high_pc, RTDWARFDIESUBPROGRAM, PcRange, ATTR_INIT_ZERO, rtDwarfDecode_LowHighPc),
591	ATTR_ENTRY(DW_AT_ranges, RTDWARFDIESUBPROGRAM, PcRange, ATTR_INIT_ZERO, rtDwarfDecode_Ranges),
592	ATTR_ENTRY(DW_AT_entry_pc, RTDWARFDIESUBPROGRAM, EntryPc, ATTR_INIT_ZERO, rtDwarfDecode_Address),
593	ATTR_ENTRY(DW_AT_segment, RTDWARFDIESUBPROGRAM, uSegment, ATTR_INIT_ZERO, rtDwarfDecode_SegmentLoc),
594	ATTR_ENTRY(DW_AT_specification, RTDWARFDIESUBPROGRAM, SpecRef, ATTR_INIT_ZERO, rtDwarfDecode_Reference)
595	};
596
597	/** RTDWARFDIESUBPROGRAM description. */
598	static const RTDWARFDIEDESC g_SubProgramDesc = DIE_DESC_INIT(RTDWARFDIESUBPROGRAM, g_aSubProgramAttrs);
599
600
601	/** RTDWARFDIESUBPROGRAM attributes for the specification hack. */
602	static const RTDWARFATTRDESC g_aSubProgramSpecHackAttrs[] =
603	{
604	ATTR_ENTRY(DW_AT_name, RTDWARFDIESUBPROGRAM, pszName, ATTR_INIT_ZERO, rtDwarfDecode_String),
605	ATTR_ENTRY(DW_AT_linkage_name, RTDWARFDIESUBPROGRAM, pszLinkageName, ATTR_INIT_ZERO, rtDwarfDecode_String),
606	ATTR_ENTRY(DW_AT_MIPS_linkage_name, RTDWARFDIESUBPROGRAM, pszLinkageName, ATTR_INIT_ZERO, rtDwarfDecode_String),
607	};
608
609	/** RTDWARFDIESUBPROGRAM description for the specification hack. */
610	static const RTDWARFDIEDESC g_SubProgramSpecHackDesc = DIE_DESC_INIT(RTDWARFDIESUBPROGRAM, g_aSubProgramSpecHackAttrs);
611
612
613	/**
614	* DW_TAG_label.
615	*/
616	typedef struct RTDWARFDIELABEL
617	{
618	/** The DIE core structure. */
619	RTDWARFDIE Core;
620	/** The name. */
621	const char *pszName;
622	/** The address of the first instruction. */
623	RTDWARFADDR Address;
624	/** Segment number (watcom). */
625	RTSEL uSegment;
626	/** Externally visible? */
627	bool fExternal;
628	} RTDWARFDIELABEL;
629	/** Pointer to a DW_TAG_label DIE. */
630	typedef RTDWARFDIELABEL *PRTDWARFDIELABEL;
631	/** Pointer to a const DW_TAG_label DIE. */
632	typedef RTDWARFDIELABEL const *PCRTDWARFDIELABEL;
633
634
635	/** RTDWARFDIESUBPROGRAM attributes. */
636	static const RTDWARFATTRDESC g_aLabelAttrs[] =
637	{
638	ATTR_ENTRY(DW_AT_name, RTDWARFDIELABEL, pszName, ATTR_INIT_ZERO, rtDwarfDecode_String),
639	ATTR_ENTRY(DW_AT_low_pc, RTDWARFDIELABEL, Address, ATTR_INIT_ZERO, rtDwarfDecode_Address),
640	ATTR_ENTRY(DW_AT_segment, RTDWARFDIELABEL, uSegment, ATTR_INIT_ZERO, rtDwarfDecode_SegmentLoc),
641	ATTR_ENTRY(DW_AT_external, RTDWARFDIELABEL, fExternal, ATTR_INIT_ZERO, rtDwarfDecode_Bool)
642	};
643
644	/** RTDWARFDIESUBPROGRAM description. */
645	static const RTDWARFDIEDESC g_LabelDesc = DIE_DESC_INIT(RTDWARFDIELABEL, g_aLabelAttrs);
646
647
648	/**
649	* Tag names and descriptors.
650	*/
651	static const struct RTDWARFTAGDESC
652	{
653	/** The tag value. */
654	uint16_t uTag;
655	/** The tag name as string. */
656	const char *pszName;
657	/** The DIE descriptor to use. */
658	PCRTDWARFDIEDESC pDesc;
659	} g_aTagDescs[] =
660	{
661	#define TAGDESC(a_Name, a_pDesc) { DW_ ## a_Name, #a_Name, a_pDesc }
662	#define TAGDESC_EMPTY() { 0, NULL, &g_CoreDieDesc }
663	#define TAGDESC_CORE(a_Name) TAGDESC(a_Name, &g_CoreDieDesc)
664	TAGDESC_EMPTY(), /* 0x00 */
665	TAGDESC_CORE(TAG_array_type),
666	TAGDESC_CORE(TAG_class_type),
667	TAGDESC_CORE(TAG_entry_point),
668	TAGDESC_CORE(TAG_enumeration_type), /* 0x04 */
669	TAGDESC_CORE(TAG_formal_parameter),
670	TAGDESC_EMPTY(),
671	TAGDESC_EMPTY(),
672	TAGDESC_CORE(TAG_imported_declaration), /* 0x08 */
673	TAGDESC_EMPTY(),
674	TAGDESC(TAG_label, &g_LabelDesc),
675	TAGDESC_CORE(TAG_lexical_block),
676	TAGDESC_EMPTY(), /* 0x0c */
677	TAGDESC_CORE(TAG_member),
678	TAGDESC_EMPTY(),
679	TAGDESC_CORE(TAG_pointer_type),
680	TAGDESC_CORE(TAG_reference_type), /* 0x10 */
681	TAGDESC_CORE(TAG_compile_unit),
682	TAGDESC_CORE(TAG_string_type),
683	TAGDESC_CORE(TAG_structure_type),
684	TAGDESC_EMPTY(), /* 0x14 */
685	TAGDESC_CORE(TAG_subroutine_type),
686	TAGDESC_CORE(TAG_typedef),
687	TAGDESC_CORE(TAG_union_type),
688	TAGDESC_CORE(TAG_unspecified_parameters), /* 0x18 */
689	TAGDESC_CORE(TAG_variant),
690	TAGDESC_CORE(TAG_common_block),
691	TAGDESC_CORE(TAG_common_inclusion),
692	TAGDESC_CORE(TAG_inheritance), /* 0x1c */
693	TAGDESC_CORE(TAG_inlined_subroutine),
694	TAGDESC_CORE(TAG_module),
695	TAGDESC_CORE(TAG_ptr_to_member_type),
696	TAGDESC_CORE(TAG_set_type), /* 0x20 */
697	TAGDESC_CORE(TAG_subrange_type),
698	TAGDESC_CORE(TAG_with_stmt),
699	TAGDESC_CORE(TAG_access_declaration),
700	TAGDESC_CORE(TAG_base_type), /* 0x24 */
701	TAGDESC_CORE(TAG_catch_block),
702	TAGDESC_CORE(TAG_const_type),
703	TAGDESC_CORE(TAG_constant),
704	TAGDESC_CORE(TAG_enumerator), /* 0x28 */
705	TAGDESC_CORE(TAG_file_type),
706	TAGDESC_CORE(TAG_friend),
707	TAGDESC_CORE(TAG_namelist),
708	TAGDESC_CORE(TAG_namelist_item), /* 0x2c */
709	TAGDESC_CORE(TAG_packed_type),
710	TAGDESC(TAG_subprogram, &g_SubProgramDesc),
711	TAGDESC_CORE(TAG_template_type_parameter),
712	TAGDESC_CORE(TAG_template_value_parameter), /* 0x30 */
713	TAGDESC_CORE(TAG_thrown_type),
714	TAGDESC_CORE(TAG_try_block),
715	TAGDESC_CORE(TAG_variant_part),
716	TAGDESC_CORE(TAG_variable), /* 0x34 */
717	TAGDESC_CORE(TAG_volatile_type),
718	TAGDESC_CORE(TAG_dwarf_procedure),
719	TAGDESC_CORE(TAG_restrict_type),
720	TAGDESC_CORE(TAG_interface_type), /* 0x38 */
721	TAGDESC_CORE(TAG_namespace),
722	TAGDESC_CORE(TAG_imported_module),
723	TAGDESC_CORE(TAG_unspecified_type),
724	TAGDESC_CORE(TAG_partial_unit), /* 0x3c */
725	TAGDESC_CORE(TAG_imported_unit),
726	TAGDESC_EMPTY(),
727	TAGDESC_CORE(TAG_condition),
728	TAGDESC_CORE(TAG_shared_type), /* 0x40 */
729	TAGDESC_CORE(TAG_type_unit),
730	TAGDESC_CORE(TAG_rvalue_reference_type),
731	TAGDESC_CORE(TAG_template_alias)
732	#undef TAGDESC
733	#undef TAGDESC_EMPTY
734	#undef TAGDESC_CORE
735	};
736
737
738	/*********************************************************************************************************************************
739	* Internal Functions *
740	*********************************************************************************************************************************/
741	static int rtDwarfInfo_ParseDie(PRTDBGMODDWARF pThis, PRTDWARFDIE pDie, PCRTDWARFDIEDESC pDieDesc,
742	PRTDWARFCURSOR pCursor, PCRTDWARFABBREV pAbbrev, bool fInitDie);
743
744
745
746	#if defined(LOG_ENABLED) \|\| defined(RT_STRICT)
747
748	# if 0 /* unused */
749	/**
750	* Turns a tag value into a string for logging purposes.
751	*
752	* @returns String name.
753	* @param uTag The tag.
754	*/
755	static const char *rtDwarfLog_GetTagName(uint32_t uTag)
756	{
757	if (uTag < RT_ELEMENTS(g_aTagDescs))
758	{
759	const char *pszTag = g_aTagDescs[uTag].pszName;
760	if (pszTag)
761	return pszTag;
762	}
763
764	static char s_szStatic[32];
765	RTStrPrintf(s_szStatic, sizeof(s_szStatic),"DW_TAG_%#x", uTag);
766	return s_szStatic;
767	}
768	# endif
769
770
771	/**
772	* Turns an attributevalue into a string for logging purposes.
773	*
774	* @returns String name.
775	* @param uAttr The attribute.
776	*/
777	static const char *rtDwarfLog_AttrName(uint32_t uAttr)
778	{
779	switch (uAttr)
780	{
781	RT_CASE_RET_STR(DW_AT_sibling);
782	RT_CASE_RET_STR(DW_AT_location);
783	RT_CASE_RET_STR(DW_AT_name);
784	RT_CASE_RET_STR(DW_AT_ordering);
785	RT_CASE_RET_STR(DW_AT_byte_size);
786	RT_CASE_RET_STR(DW_AT_bit_offset);
787	RT_CASE_RET_STR(DW_AT_bit_size);
788	RT_CASE_RET_STR(DW_AT_stmt_list);
789	RT_CASE_RET_STR(DW_AT_low_pc);
790	RT_CASE_RET_STR(DW_AT_high_pc);
791	RT_CASE_RET_STR(DW_AT_language);
792	RT_CASE_RET_STR(DW_AT_discr);
793	RT_CASE_RET_STR(DW_AT_discr_value);
794	RT_CASE_RET_STR(DW_AT_visibility);
795	RT_CASE_RET_STR(DW_AT_import);
796	RT_CASE_RET_STR(DW_AT_string_length);
797	RT_CASE_RET_STR(DW_AT_common_reference);
798	RT_CASE_RET_STR(DW_AT_comp_dir);
799	RT_CASE_RET_STR(DW_AT_const_value);
800	RT_CASE_RET_STR(DW_AT_containing_type);
801	RT_CASE_RET_STR(DW_AT_default_value);
802	RT_CASE_RET_STR(DW_AT_inline);
803	RT_CASE_RET_STR(DW_AT_is_optional);
804	RT_CASE_RET_STR(DW_AT_lower_bound);
805	RT_CASE_RET_STR(DW_AT_producer);
806	RT_CASE_RET_STR(DW_AT_prototyped);
807	RT_CASE_RET_STR(DW_AT_return_addr);
808	RT_CASE_RET_STR(DW_AT_start_scope);
809	RT_CASE_RET_STR(DW_AT_bit_stride);
810	RT_CASE_RET_STR(DW_AT_upper_bound);
811	RT_CASE_RET_STR(DW_AT_abstract_origin);
812	RT_CASE_RET_STR(DW_AT_accessibility);
813	RT_CASE_RET_STR(DW_AT_address_class);
814	RT_CASE_RET_STR(DW_AT_artificial);
815	RT_CASE_RET_STR(DW_AT_base_types);
816	RT_CASE_RET_STR(DW_AT_calling_convention);
817	RT_CASE_RET_STR(DW_AT_count);
818	RT_CASE_RET_STR(DW_AT_data_member_location);
819	RT_CASE_RET_STR(DW_AT_decl_column);
820	RT_CASE_RET_STR(DW_AT_decl_file);
821	RT_CASE_RET_STR(DW_AT_decl_line);
822	RT_CASE_RET_STR(DW_AT_declaration);
823	RT_CASE_RET_STR(DW_AT_discr_list);
824	RT_CASE_RET_STR(DW_AT_encoding);
825	RT_CASE_RET_STR(DW_AT_external);
826	RT_CASE_RET_STR(DW_AT_frame_base);
827	RT_CASE_RET_STR(DW_AT_friend);
828	RT_CASE_RET_STR(DW_AT_identifier_case);
829	RT_CASE_RET_STR(DW_AT_macro_info);
830	RT_CASE_RET_STR(DW_AT_namelist_item);
831	RT_CASE_RET_STR(DW_AT_priority);
832	RT_CASE_RET_STR(DW_AT_segment);
833	RT_CASE_RET_STR(DW_AT_specification);
834	RT_CASE_RET_STR(DW_AT_static_link);
835	RT_CASE_RET_STR(DW_AT_type);
836	RT_CASE_RET_STR(DW_AT_use_location);
837	RT_CASE_RET_STR(DW_AT_variable_parameter);
838	RT_CASE_RET_STR(DW_AT_virtuality);
839	RT_CASE_RET_STR(DW_AT_vtable_elem_location);
840	RT_CASE_RET_STR(DW_AT_allocated);
841	RT_CASE_RET_STR(DW_AT_associated);
842	RT_CASE_RET_STR(DW_AT_data_location);
843	RT_CASE_RET_STR(DW_AT_byte_stride);
844	RT_CASE_RET_STR(DW_AT_entry_pc);
845	RT_CASE_RET_STR(DW_AT_use_UTF8);
846	RT_CASE_RET_STR(DW_AT_extension);
847	RT_CASE_RET_STR(DW_AT_ranges);
848	RT_CASE_RET_STR(DW_AT_trampoline);
849	RT_CASE_RET_STR(DW_AT_call_column);
850	RT_CASE_RET_STR(DW_AT_call_file);
851	RT_CASE_RET_STR(DW_AT_call_line);
852	RT_CASE_RET_STR(DW_AT_description);
853	RT_CASE_RET_STR(DW_AT_binary_scale);
854	RT_CASE_RET_STR(DW_AT_decimal_scale);
855	RT_CASE_RET_STR(DW_AT_small);
856	RT_CASE_RET_STR(DW_AT_decimal_sign);
857	RT_CASE_RET_STR(DW_AT_digit_count);
858	RT_CASE_RET_STR(DW_AT_picture_string);
859	RT_CASE_RET_STR(DW_AT_mutable);
860	RT_CASE_RET_STR(DW_AT_threads_scaled);
861	RT_CASE_RET_STR(DW_AT_explicit);
862	RT_CASE_RET_STR(DW_AT_object_pointer);
863	RT_CASE_RET_STR(DW_AT_endianity);
864	RT_CASE_RET_STR(DW_AT_elemental);
865	RT_CASE_RET_STR(DW_AT_pure);
866	RT_CASE_RET_STR(DW_AT_recursive);
867	RT_CASE_RET_STR(DW_AT_signature);
868	RT_CASE_RET_STR(DW_AT_main_subprogram);
869	RT_CASE_RET_STR(DW_AT_data_bit_offset);
870	RT_CASE_RET_STR(DW_AT_const_expr);
871	RT_CASE_RET_STR(DW_AT_enum_class);
872	RT_CASE_RET_STR(DW_AT_linkage_name);
873	RT_CASE_RET_STR(DW_AT_MIPS_linkage_name);
874	RT_CASE_RET_STR(DW_AT_WATCOM_memory_model);
875	RT_CASE_RET_STR(DW_AT_WATCOM_references_start);
876	RT_CASE_RET_STR(DW_AT_WATCOM_parm_entry);
877	}
878	static char s_szStatic[32];
879	RTStrPrintf(s_szStatic, sizeof(s_szStatic),"DW_AT_%#x", uAttr);
880	return s_szStatic;
881	}
882
883
884	/**
885	* Turns a form value into a string for logging purposes.
886	*
887	* @returns String name.
888	* @param uForm The form.
889	*/
890	static const char *rtDwarfLog_FormName(uint32_t uForm)
891	{
892	switch (uForm)
893	{
894	RT_CASE_RET_STR(DW_FORM_addr);
895	RT_CASE_RET_STR(DW_FORM_block2);
896	RT_CASE_RET_STR(DW_FORM_block4);
897	RT_CASE_RET_STR(DW_FORM_data2);
898	RT_CASE_RET_STR(DW_FORM_data4);
899	RT_CASE_RET_STR(DW_FORM_data8);
900	RT_CASE_RET_STR(DW_FORM_string);
901	RT_CASE_RET_STR(DW_FORM_block);
902	RT_CASE_RET_STR(DW_FORM_block1);
903	RT_CASE_RET_STR(DW_FORM_data1);
904	RT_CASE_RET_STR(DW_FORM_flag);
905	RT_CASE_RET_STR(DW_FORM_sdata);
906	RT_CASE_RET_STR(DW_FORM_strp);
907	RT_CASE_RET_STR(DW_FORM_udata);
908	RT_CASE_RET_STR(DW_FORM_ref_addr);
909	RT_CASE_RET_STR(DW_FORM_ref1);
910	RT_CASE_RET_STR(DW_FORM_ref2);
911	RT_CASE_RET_STR(DW_FORM_ref4);
912	RT_CASE_RET_STR(DW_FORM_ref8);
913	RT_CASE_RET_STR(DW_FORM_ref_udata);
914	RT_CASE_RET_STR(DW_FORM_indirect);
915	RT_CASE_RET_STR(DW_FORM_sec_offset);
916	RT_CASE_RET_STR(DW_FORM_exprloc);
917	RT_CASE_RET_STR(DW_FORM_flag_present);
918	RT_CASE_RET_STR(DW_FORM_ref_sig8);
919	}
920	static char s_szStatic[32];
921	RTStrPrintf(s_szStatic, sizeof(s_szStatic),"DW_FORM_%#x", uForm);
922	return s_szStatic;
923	}
924
925	#endif /* LOG_ENABLED \|\| RT_STRICT */
926
927
928
929	/** @callback_method_impl{FNRTLDRENUMSEGS} */
930	static DECLCALLBACK(int) rtDbgModDwarfScanSegmentsCallback(RTLDRMOD hLdrMod, PCRTLDRSEG pSeg, void *pvUser)
931	{
932	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pvUser;
933	Log(("Segment %.*s: LinkAddress=%#llx RVA=%#llx cb=%#llx\n",
934	pSeg->cchName, pSeg->pszName, (uint64_t)pSeg->LinkAddress, (uint64_t)pSeg->RVA, pSeg->cb));
935	NOREF(hLdrMod);
936
937	/* Count relevant segments. */
938	if (pSeg->RVA != NIL_RTLDRADDR)
939	pThis->cSegs++;
940
941	return VINF_SUCCESS;
942	}
943
944
945	/** @callback_method_impl{FNRTLDRENUMSEGS} */
946	static DECLCALLBACK(int) rtDbgModDwarfAddSegmentsCallback(RTLDRMOD hLdrMod, PCRTLDRSEG pSeg, void *pvUser)
947	{
948	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pvUser;
949	Log(("Segment %.*s: LinkAddress=%#llx RVA=%#llx cb=%#llx cbMapped=%#llx\n",
950	pSeg->cchName, pSeg->pszName, (uint64_t)pSeg->LinkAddress, (uint64_t)pSeg->RVA, pSeg->cb, pSeg->cbMapped));
951	NOREF(hLdrMod);
952	Assert(pSeg->cchName > 0);
953	Assert(!pSeg->pszName[pSeg->cchName]);
954
955	/* If the segment doesn't have a mapping, just add a dummy so the indexing
956	works out correctly (same as for the image). */
957	if (pSeg->RVA == NIL_RTLDRADDR)
958	return RTDbgModSegmentAdd(pThis->hCnt, 0, 0, pSeg->pszName, 0 /fFlags/, NULL);
959
960	/* The link address is 0 for all segments in a relocatable ELF image. */
961	RTLDRADDR cb = pSeg->cb;
962	if ( cb < pSeg->cbMapped
963	&& RTLdrGetFormat(hLdrMod) != RTLDRFMT_LX /* for debugging our drivers; 64KB section align by linker, 4KB by loader. */
964	)
965	cb = pSeg->cbMapped;
966	return RTDbgModSegmentAdd(pThis->hCnt, pSeg->RVA, cb, pSeg->pszName, 0 /fFlags/, NULL);
967	}
968
969
970	/**
971	* Calls rtDbgModDwarfAddSegmentsCallback for each segment in the executable
972	* image.
973	*
974	* @returns IPRT status code.
975	* @param pThis The DWARF instance.
976	*/
977	static int rtDbgModDwarfAddSegmentsFromImage(PRTDBGMODDWARF pThis)
978	{
979	AssertReturn(pThis->pImgMod && pThis->pImgMod->pImgVt, VERR_INTERNAL_ERROR_2);
980	Assert(!pThis->cSegs);
981	int rc = pThis->pImgMod->pImgVt->pfnEnumSegments(pThis->pImgMod, rtDbgModDwarfScanSegmentsCallback, pThis);
982	if (RT_SUCCESS(rc))
983	{
984	if (pThis->cSegs == 0)
985	pThis->iWatcomPass = 1;
986	else
987	{
988	pThis->cSegs = 0;
989	pThis->iWatcomPass = -1;
990	rc = pThis->pImgMod->pImgVt->pfnEnumSegments(pThis->pImgMod, rtDbgModDwarfAddSegmentsCallback, pThis);
991	}
992	}
993
994	return rc;
995	}
996
997
998	/**
999	* Looks up a segment.
1000	*
1001	* @returns Pointer to the segment on success, NULL if not found.
1002	* @param pThis The DWARF instance.
1003	* @param uSeg The segment number / selector.
1004	*/
1005	static PRTDBGDWARFSEG rtDbgModDwarfFindSegment(PRTDBGMODDWARF pThis, RTSEL uSeg)
1006	{
1007	uint32_t cSegs = pThis->cSegs;
1008	uint32_t iSeg = pThis->iSegHint;
1009	PRTDBGDWARFSEG paSegs = pThis->paSegs;
1010	if ( iSeg < cSegs
1011	&& paSegs[iSeg].uSegment == uSeg)
1012	return &paSegs[iSeg];
1013
1014	for (iSeg = 0; iSeg < cSegs; iSeg++)
1015	if (uSeg == paSegs[iSeg].uSegment)
1016	{
1017	pThis->iSegHint = iSeg;
1018	return &paSegs[iSeg];
1019	}
1020
1021	AssertFailed();
1022	return NULL;
1023	}
1024
1025
1026	/**
1027	* Record a segment:offset during pass 1.
1028	*
1029	* @returns IPRT status code.
1030	* @param pThis The DWARF instance.
1031	* @param uSeg The segment number / selector.
1032	* @param offSeg The segment offset.
1033	*/
1034	static int rtDbgModDwarfRecordSegOffset(PRTDBGMODDWARF pThis, RTSEL uSeg, uint64_t offSeg)
1035	{
1036	/* Look up the segment. */
1037	uint32_t cSegs = pThis->cSegs;
1038	uint32_t iSeg = pThis->iSegHint;
1039	PRTDBGDWARFSEG paSegs = pThis->paSegs;
1040	if ( iSeg >= cSegs
1041	\|\| paSegs[iSeg].uSegment != uSeg)
1042	{
1043	for (iSeg = 0; iSeg < cSegs; iSeg++)
1044	if (uSeg <= paSegs[iSeg].uSegment)
1045	break;
1046	if ( iSeg >= cSegs
1047	\|\| paSegs[iSeg].uSegment != uSeg)
1048	{
1049	/* Add */
1050	void pvNew = RTMemRealloc(paSegs, (pThis->cSegs + 1) sizeof(paSegs[0]));
1051	if (!pvNew)
1052	return VERR_NO_MEMORY;
1053	pThis->paSegs = paSegs = (PRTDBGDWARFSEG)pvNew;
1054	if (iSeg != cSegs)
1055	memmove(&paSegs[iSeg + 1], &paSegs[iSeg], (cSegs - iSeg) * sizeof(paSegs[0]));
1056	paSegs[iSeg].offHighest = offSeg;
1057	paSegs[iSeg].uBaseAddr = 0;
1058	paSegs[iSeg].cbSegment = 0;
1059	paSegs[iSeg].uSegment = uSeg;
1060	pThis->cSegs++;
1061	}
1062
1063	pThis->iSegHint = iSeg;
1064	}
1065
1066	/* Increase it's range? */
1067	if (paSegs[iSeg].offHighest < offSeg)
1068	{
1069	Log3(("rtDbgModDwarfRecordSegOffset: iSeg=%d uSeg=%#06x offSeg=%#llx\n", iSeg, uSeg, offSeg));
1070	paSegs[iSeg].offHighest = offSeg;
1071	}
1072
1073	return VINF_SUCCESS;
1074	}
1075
1076
1077	/**
1078	* Calls pfnSegmentAdd for each segment in the executable image.
1079	*
1080	* @returns IPRT status code.
1081	* @param pThis The DWARF instance.
1082	*/
1083	static int rtDbgModDwarfAddSegmentsFromPass1(PRTDBGMODDWARF pThis)
1084	{
1085	AssertReturn(pThis->cSegs, VERR_DWARF_BAD_INFO);
1086	uint32_t const cSegs = pThis->cSegs;
1087	PRTDBGDWARFSEG paSegs = pThis->paSegs;
1088
1089	/*
1090	* Are the segments assigned more or less in numerical order?
1091	*/
1092	if ( paSegs[0].uSegment < 16U
1093	&& paSegs[cSegs - 1].uSegment - paSegs[0].uSegment + 1U <= cSegs + 16U)
1094	{
1095	/** @todo heuristics, plase. */
1096	AssertFailedReturn(VERR_DWARF_TODO);
1097
1098	}
1099	/*
1100	* Assume DOS segmentation.
1101	*/
1102	else
1103	{
1104	for (uint32_t iSeg = 0; iSeg < cSegs; iSeg++)
1105	paSegs[iSeg].uBaseAddr = (uint32_t)paSegs[iSeg].uSegment << 16;
1106	for (uint32_t iSeg = 0; iSeg < cSegs; iSeg++)
1107	paSegs[iSeg].cbSegment = paSegs[iSeg].offHighest;
1108	}
1109
1110	/*
1111	* Add them.
1112	*/
1113	for (uint32_t iSeg = 0; iSeg < cSegs; iSeg++)
1114	{
1115	Log3(("rtDbgModDwarfAddSegmentsFromPass1: Seg#%u: %#010llx LB %#llx uSegment=%#x\n",
1116	iSeg, paSegs[iSeg].uBaseAddr, paSegs[iSeg].cbSegment, paSegs[iSeg].uSegment));
1117	char szName[32];
1118	RTStrPrintf(szName, sizeof(szName), "seg-%#04xh", paSegs[iSeg].uSegment);
1119	int rc = RTDbgModSegmentAdd(pThis->hCnt, paSegs[iSeg].uBaseAddr, paSegs[iSeg].cbSegment,
1120	szName, 0 /fFlags/, NULL);
1121	if (RT_FAILURE(rc))
1122	return rc;
1123	}
1124
1125	return VINF_SUCCESS;
1126	}
1127
1128
1129	/**
1130	* Loads a DWARF section from the image file.
1131	*
1132	* @returns IPRT status code.
1133	* @param pThis The DWARF instance.
1134	* @param enmSect The section to load.
1135	*/
1136	static int rtDbgModDwarfLoadSection(PRTDBGMODDWARF pThis, krtDbgModDwarfSect enmSect)
1137	{
1138	/*
1139	* Don't load stuff twice.
1140	*/
1141	if (pThis->aSections[enmSect].pv)
1142	return VINF_SUCCESS;
1143
1144	/*
1145	* Sections that are not present cannot be loaded, treat them like they
1146	* are empty
1147	*/
1148	if (!pThis->aSections[enmSect].fPresent)
1149	{
1150	Assert(pThis->aSections[enmSect].cb);
1151	return VINF_SUCCESS;
1152	}
1153	if (!pThis->aSections[enmSect].cb)
1154	return VINF_SUCCESS;
1155
1156	/*
1157	* Sections must be readable with the current image interface.
1158	*/
1159	if (pThis->aSections[enmSect].offFile < 0)
1160	return VERR_OUT_OF_RANGE;
1161
1162	/*
1163	* Do the job.
1164	*/
1165	return pThis->pDbgInfoMod->pImgVt->pfnMapPart(pThis->pDbgInfoMod,
1166	pThis->aSections[enmSect].iDbgInfo,
1167	pThis->aSections[enmSect].offFile,
1168	pThis->aSections[enmSect].cb,
1169	&pThis->aSections[enmSect].pv);
1170	}
1171
1172
1173	#ifdef SOME_UNUSED_FUNCTION
1174	/**
1175	* Unloads a DWARF section previously mapped by rtDbgModDwarfLoadSection.
1176	*
1177	* @returns IPRT status code.
1178	* @param pThis The DWARF instance.
1179	* @param enmSect The section to unload.
1180	*/
1181	static int rtDbgModDwarfUnloadSection(PRTDBGMODDWARF pThis, krtDbgModDwarfSect enmSect)
1182	{
1183	if (!pThis->aSections[enmSect].pv)
1184	return VINF_SUCCESS;
1185
1186	int rc = pThis->pDbgInfoMod->pImgVt->pfnUnmapPart(pThis->pDbgInfoMod, pThis->aSections[enmSect].cb, &pThis->aSections[enmSect].pv);
1187	AssertRC(rc);
1188	return rc;
1189	}
1190	#endif
1191
1192
1193	/**
1194	* Converts to UTF-8 or otherwise makes sure it's valid UTF-8.
1195	*
1196	* @returns IPRT status code.
1197	* @param pThis The DWARF instance.
1198	* @param ppsz Pointer to the string pointer. May be
1199	* reallocated (RTStr*).
1200	*/
1201	static int rtDbgModDwarfStringToUtf8(PRTDBGMODDWARF pThis, char **ppsz)
1202	{
1203	/** @todo DWARF & UTF-8. */
1204	NOREF(pThis);
1205	RTStrPurgeEncoding(*ppsz);
1206	return VINF_SUCCESS;
1207	}
1208
1209
1210	/**
1211	* Convers a link address into a segment+offset or RVA.
1212	*
1213	* @returns IPRT status code.
1214	* @param pThis The DWARF instance.
1215	* @param uSegment The segment, 0 if not applicable.
1216	* @param LinkAddress The address to convert..
1217	* @param piSeg The segment index.
1218	* @param poffSeg Where to return the segment offset.
1219	*/
1220	static int rtDbgModDwarfLinkAddressToSegOffset(PRTDBGMODDWARF pThis, RTSEL uSegment, uint64_t LinkAddress,
1221	PRTDBGSEGIDX piSeg, PRTLDRADDR poffSeg)
1222	{
1223	if (pThis->paSegs)
1224	{
1225	PRTDBGDWARFSEG pSeg = rtDbgModDwarfFindSegment(pThis, uSegment);
1226	if (pSeg)
1227	{
1228	*piSeg = pSeg - pThis->paSegs;
1229	*poffSeg = LinkAddress;
1230	return VINF_SUCCESS;
1231	}
1232	}
1233
1234	if (pThis->fUseLinkAddress)
1235	return pThis->pImgMod->pImgVt->pfnLinkAddressToSegOffset(pThis->pImgMod, LinkAddress, piSeg, poffSeg);
1236
1237	/* If we have a non-zero segment number, assume it's correct for now.
1238	This helps loading watcom linked LX drivers. */
1239	if (uSegment > 0)
1240	{
1241	*piSeg = uSegment - 1;
1242	*poffSeg = LinkAddress;
1243	return VINF_SUCCESS;
1244	}
1245
1246	return pThis->pImgMod->pImgVt->pfnRvaToSegOffset(pThis->pImgMod, LinkAddress, piSeg, poffSeg);
1247	}
1248
1249
1250	/**
1251	* Converts a segment+offset address into an RVA.
1252	*
1253	* @returns IPRT status code.
1254	* @param pThis The DWARF instance.
1255	* @param idxSegment The segment index.
1256	* @param offSegment The segment offset.
1257	* @param puRva Where to return the calculated RVA.
1258	*/
1259	static int rtDbgModDwarfSegOffsetToRva(PRTDBGMODDWARF pThis, RTDBGSEGIDX idxSegment, uint64_t offSegment, PRTUINTPTR puRva)
1260	{
1261	if (pThis->paSegs)
1262	{
1263	PRTDBGDWARFSEG pSeg = rtDbgModDwarfFindSegment(pThis, idxSegment);
1264	if (pSeg)
1265	{
1266	*puRva = pSeg->uBaseAddr + offSegment;
1267	return VINF_SUCCESS;
1268	}
1269	}
1270
1271	RTUINTPTR uRva = RTDbgModSegmentRva(pThis->pImgMod, idxSegment);
1272	if (uRva != RTUINTPTR_MAX)
1273	{
1274	*puRva = uRva + offSegment;
1275	return VINF_SUCCESS;
1276	}
1277	return VERR_INVALID_POINTER;
1278	}
1279
1280	/**
1281	* Converts a segment+offset address into an RVA.
1282	*
1283	* @returns IPRT status code.
1284	* @param pThis The DWARF instance.
1285	* @param uRva The RVA to convert.
1286	* @param pidxSegment Where to return the segment index.
1287	* @param poffSegment Where to return the segment offset.
1288	*/
1289	static int rtDbgModDwarfRvaToSegOffset(PRTDBGMODDWARF pThis, RTUINTPTR uRva, RTDBGSEGIDX pidxSegment, uint64_t poffSegment)
1290	{
1291	RTUINTPTR offSeg = 0;
1292	RTDBGSEGIDX idxSeg = RTDbgModRvaToSegOff(pThis->pImgMod, uRva, &offSeg);
1293	if (idxSeg != NIL_RTDBGSEGIDX)
1294	{
1295	*pidxSegment = idxSeg;
1296	*poffSegment = offSeg;
1297	return VINF_SUCCESS;
1298	}
1299	return VERR_INVALID_POINTER;
1300	}
1301
1302
1303
1304	/*
1305	*
1306	* DWARF Cursor.
1307	* DWARF Cursor.
1308	* DWARF Cursor.
1309	*
1310	*/
1311
1312
1313	/**
1314	* Reads a 8-bit unsigned integer and advances the cursor.
1315	*
1316	* @returns 8-bit unsigned integer. On error RTDWARFCURSOR::rc is set and @a
1317	* uErrValue is returned.
1318	* @param pCursor The cursor.
1319	* @param uErrValue What to return on read error.
1320	*/
1321	static uint8_t rtDwarfCursor_GetU8(PRTDWARFCURSOR pCursor, uint8_t uErrValue)
1322	{
1323	if (pCursor->cbUnitLeft < 1)
1324	{
1325	pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1326	return uErrValue;
1327	}
1328
1329	uint8_t u8 = pCursor->pb[0];
1330	pCursor->pb += 1;
1331	pCursor->cbUnitLeft -= 1;
1332	pCursor->cbLeft -= 1;
1333	return u8;
1334	}
1335
1336
1337	/**
1338	* Reads a 16-bit unsigned integer and advances the cursor.
1339	*
1340	* @returns 16-bit unsigned integer. On error RTDWARFCURSOR::rc is set and @a
1341	* uErrValue is returned.
1342	* @param pCursor The cursor.
1343	* @param uErrValue What to return on read error.
1344	*/
1345	static uint16_t rtDwarfCursor_GetU16(PRTDWARFCURSOR pCursor, uint16_t uErrValue)
1346	{
1347	if (pCursor->cbUnitLeft < 2)
1348	{
1349	pCursor->pb += pCursor->cbUnitLeft;
1350	pCursor->cbLeft -= pCursor->cbUnitLeft;
1351	pCursor->cbUnitLeft = 0;
1352	pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1353	return uErrValue;
1354	}
1355
1356	uint16_t u16 = RT_MAKE_U16(pCursor->pb[0], pCursor->pb[1]);
1357	pCursor->pb += 2;
1358	pCursor->cbUnitLeft -= 2;
1359	pCursor->cbLeft -= 2;
1360	if (!pCursor->fNativEndian)
1361	u16 = RT_BSWAP_U16(u16);
1362	return u16;
1363	}
1364
1365
1366	/**
1367	* Reads a 32-bit unsigned integer and advances the cursor.
1368	*
1369	* @returns 32-bit unsigned integer. On error RTDWARFCURSOR::rc is set and @a
1370	* uErrValue is returned.
1371	* @param pCursor The cursor.
1372	* @param uErrValue What to return on read error.
1373	*/
1374	static uint32_t rtDwarfCursor_GetU32(PRTDWARFCURSOR pCursor, uint32_t uErrValue)
1375	{
1376	if (pCursor->cbUnitLeft < 4)
1377	{
1378	pCursor->pb += pCursor->cbUnitLeft;
1379	pCursor->cbLeft -= pCursor->cbUnitLeft;
1380	pCursor->cbUnitLeft = 0;
1381	pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1382	return uErrValue;
1383	}
1384
1385	uint32_t u32 = RT_MAKE_U32_FROM_U8(pCursor->pb[0], pCursor->pb[1], pCursor->pb[2], pCursor->pb[3]);
1386	pCursor->pb += 4;
1387	pCursor->cbUnitLeft -= 4;
1388	pCursor->cbLeft -= 4;
1389	if (!pCursor->fNativEndian)
1390	u32 = RT_BSWAP_U32(u32);
1391	return u32;
1392	}
1393
1394
1395	/**
1396	* Reads a 64-bit unsigned integer and advances the cursor.
1397	*
1398	* @returns 64-bit unsigned integer. On error RTDWARFCURSOR::rc is set and @a
1399	* uErrValue is returned.
1400	* @param pCursor The cursor.
1401	* @param uErrValue What to return on read error.
1402	*/
1403	static uint64_t rtDwarfCursor_GetU64(PRTDWARFCURSOR pCursor, uint64_t uErrValue)
1404	{
1405	if (pCursor->cbUnitLeft < 8)
1406	{
1407	pCursor->pb += pCursor->cbUnitLeft;
1408	pCursor->cbLeft -= pCursor->cbUnitLeft;
1409	pCursor->cbUnitLeft = 0;
1410	pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1411	return uErrValue;
1412	}
1413
1414	uint64_t u64 = RT_MAKE_U64_FROM_U8(pCursor->pb[0], pCursor->pb[1], pCursor->pb[2], pCursor->pb[3],
1415	pCursor->pb[4], pCursor->pb[5], pCursor->pb[6], pCursor->pb[7]);
1416	pCursor->pb += 8;
1417	pCursor->cbUnitLeft -= 8;
1418	pCursor->cbLeft -= 8;
1419	if (!pCursor->fNativEndian)
1420	u64 = RT_BSWAP_U64(u64);
1421	return u64;
1422	}
1423
1424
1425	/**
1426	* Reads an unsigned LEB128 encoded number.
1427	*
1428	* @returns unsigned 64-bit number. On error RTDWARFCURSOR::rc is set and @a
1429	* uErrValue is returned.
1430	* @param pCursor The cursor.
1431	* @param uErrValue The value to return on error.
1432	*/
1433	static uint64_t rtDwarfCursor_GetULeb128(PRTDWARFCURSOR pCursor, uint64_t uErrValue)
1434	{
1435	if (pCursor->cbUnitLeft < 1)
1436	{
1437	pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1438	return uErrValue;
1439	}
1440
1441	/*
1442	* Special case - single byte.
1443	*/
1444	uint8_t b = pCursor->pb[0];
1445	if (!(b & 0x80))
1446	{
1447	pCursor->pb += 1;
1448	pCursor->cbUnitLeft -= 1;
1449	pCursor->cbLeft -= 1;
1450	return b;
1451	}
1452
1453	/*
1454	* Generic case.
1455	*/
1456	/* Decode. */
1457	uint32_t off = 1;
1458	uint64_t u64Ret = b & 0x7f;
1459	do
1460	{
1461	if (off == pCursor->cbUnitLeft)
1462	{
1463	pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1464	u64Ret = uErrValue;
1465	break;
1466	}
1467	b = pCursor->pb[off];
1468	u64Ret \|= (b & 0x7f) << off * 7;
1469	off++;
1470	} while (b & 0x80);
1471
1472	/* Update the cursor. */
1473	pCursor->pb += off;
1474	pCursor->cbUnitLeft -= off;
1475	pCursor->cbLeft -= off;
1476
1477	/* Check the range. */
1478	uint32_t cBits = off * 7;
1479	if (cBits > 64)
1480	{
1481	pCursor->rc = VERR_DWARF_LEB_OVERFLOW;
1482	u64Ret = uErrValue;
1483	}
1484
1485	return u64Ret;
1486	}
1487
1488
1489	/**
1490	* Reads a signed LEB128 encoded number.
1491	*
1492	* @returns signed 64-bit number. On error RTDWARFCURSOR::rc is set and @a
1493	* uErrValue is returned.
1494	* @param pCursor The cursor.
1495	* @param sErrValue The value to return on error.
1496	*/
1497	static int64_t rtDwarfCursor_GetSLeb128(PRTDWARFCURSOR pCursor, int64_t sErrValue)
1498	{
1499	if (pCursor->cbUnitLeft < 1)
1500	{
1501	pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1502	return sErrValue;
1503	}
1504
1505	/*
1506	* Special case - single byte.
1507	*/
1508	uint8_t b = pCursor->pb[0];
1509	if (!(b & 0x80))
1510	{
1511	pCursor->pb += 1;
1512	pCursor->cbUnitLeft -= 1;
1513	pCursor->cbLeft -= 1;
1514	if (b & 0x40)
1515	b \|= 0x80;
1516	return (int8_t)b;
1517	}
1518
1519	/*
1520	* Generic case.
1521	*/
1522	/* Decode it. */
1523	uint32_t off = 1;
1524	uint64_t u64Ret = b & 0x7f;
1525	do
1526	{
1527	if (off == pCursor->cbUnitLeft)
1528	{
1529	pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1530	u64Ret = (uint64_t)sErrValue;
1531	break;
1532	}
1533	b = pCursor->pb[off];
1534	u64Ret \|= (b & 0x7f) << off * 7;
1535	off++;
1536	} while (b & 0x80);
1537
1538	/* Update cursor. */
1539	pCursor->pb += off;
1540	pCursor->cbUnitLeft -= off;
1541	pCursor->cbLeft -= off;
1542
1543	/* Check the range. */
1544	uint32_t cBits = off * 7;
1545	if (cBits > 64)
1546	{
1547	pCursor->rc = VERR_DWARF_LEB_OVERFLOW;
1548	u64Ret = (uint64_t)sErrValue;
1549	}
1550	/* Sign extend the value. */
1551	else if (u64Ret & RT_BIT_64(cBits - 1))
1552	u64Ret \|= ~(RT_BIT_64(cBits - 1) - 1);
1553
1554	return (int64_t)u64Ret;
1555	}
1556
1557
1558	/**
1559	* Reads an unsigned LEB128 encoded number, max 32-bit width.
1560	*
1561	* @returns unsigned 32-bit number. On error RTDWARFCURSOR::rc is set and @a
1562	* uErrValue is returned.
1563	* @param pCursor The cursor.
1564	* @param uErrValue The value to return on error.
1565	*/
1566	static uint32_t rtDwarfCursor_GetULeb128AsU32(PRTDWARFCURSOR pCursor, uint32_t uErrValue)
1567	{
1568	uint64_t u64 = rtDwarfCursor_GetULeb128(pCursor, uErrValue);
1569	if (u64 > UINT32_MAX)
1570	{
1571	pCursor->rc = VERR_DWARF_LEB_OVERFLOW;
1572	return uErrValue;
1573	}
1574	return (uint32_t)u64;
1575	}
1576
1577
1578	/**
1579	* Reads a signed LEB128 encoded number, max 32-bit width.
1580	*
1581	* @returns signed 32-bit number. On error RTDWARFCURSOR::rc is set and @a
1582	* uErrValue is returned.
1583	* @param pCursor The cursor.
1584	* @param sErrValue The value to return on error.
1585	*/
1586	static int32_t rtDwarfCursor_GetSLeb128AsS32(PRTDWARFCURSOR pCursor, int32_t sErrValue)
1587	{
1588	int64_t s64 = rtDwarfCursor_GetSLeb128(pCursor, sErrValue);
1589	if (s64 > INT32_MAX \|\| s64 < INT32_MIN)
1590	{
1591	pCursor->rc = VERR_DWARF_LEB_OVERFLOW;
1592	return sErrValue;
1593	}
1594	return (int32_t)s64;
1595	}
1596
1597
1598	/**
1599	* Skips a LEB128 encoded number.
1600	*
1601	* @returns IPRT status code.
1602	* @param pCursor The cursor.
1603	*/
1604	static int rtDwarfCursor_SkipLeb128(PRTDWARFCURSOR pCursor)
1605	{
1606	if (RT_FAILURE(pCursor->rc))
1607	return pCursor->rc;
1608
1609	if (pCursor->cbUnitLeft < 1)
1610	return pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1611
1612	uint32_t offSkip = 1;
1613	if (pCursor->pb[0] & 0x80)
1614	do
1615	{
1616	if (offSkip == pCursor->cbUnitLeft)
1617	{
1618	pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1619	break;
1620	}
1621	} while (pCursor->pb[offSkip++] & 0x80);
1622
1623	pCursor->pb += offSkip;
1624	pCursor->cbUnitLeft -= offSkip;
1625	pCursor->cbLeft -= offSkip;
1626	return pCursor->rc;
1627	}
1628
1629
1630	/**
1631	* Advances the cursor a given number of bytes.
1632	*
1633	* @returns IPRT status code.
1634	* @param pCursor The cursor.
1635	* @param offSkip The number of bytes to advance.
1636	*/
1637	static int rtDwarfCursor_SkipBytes(PRTDWARFCURSOR pCursor, uint64_t offSkip)
1638	{
1639	if (RT_FAILURE(pCursor->rc))
1640	return pCursor->rc;
1641	if (pCursor->cbUnitLeft < offSkip)
1642	return pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1643
1644	size_t const offSkipSizeT = (size_t)offSkip;
1645	pCursor->cbUnitLeft -= offSkipSizeT;
1646	pCursor->cbLeft -= offSkipSizeT;
1647	pCursor->pb += offSkipSizeT;
1648
1649	return VINF_SUCCESS;
1650	}
1651
1652
1653	/**
1654	* Reads a zero terminated string, advancing the cursor beyond the terminator.
1655	*
1656	* @returns Pointer to the string.
1657	* @param pCursor The cursor.
1658	* @param pszErrValue What to return if the string isn't terminated
1659	* before the end of the unit.
1660	*/
1661	static const char rtDwarfCursor_GetSZ(PRTDWARFCURSOR pCursor, const char pszErrValue)
1662	{
1663	const char pszRet = (const char )pCursor->pb;
1664	for (;;)
1665	{
1666	if (!pCursor->cbUnitLeft)
1667	{
1668	pCursor->rc = VERR_DWARF_BAD_STRING;
1669	return pszErrValue;
1670	}
1671	pCursor->cbUnitLeft--;
1672	pCursor->cbLeft--;
1673	if (!*pCursor->pb++)
1674	break;
1675	}
1676	return pszRet;
1677	}
1678
1679
1680	/**
1681	* Reads a 1, 2, 4 or 8 byte unsigned value.
1682	*
1683	* @returns 64-bit unsigned value.
1684	* @param pCursor The cursor.
1685	* @param cbValue The value size.
1686	* @param uErrValue The error value.
1687	*/
1688	static uint64_t rtDwarfCursor_GetVarSizedU(PRTDWARFCURSOR pCursor, size_t cbValue, uint64_t uErrValue)
1689	{
1690	uint64_t u64Ret;
1691	switch (cbValue)
1692	{
1693	case 1: u64Ret = rtDwarfCursor_GetU8( pCursor, UINT8_MAX); break;
1694	case 2: u64Ret = rtDwarfCursor_GetU16(pCursor, UINT16_MAX); break;
1695	case 4: u64Ret = rtDwarfCursor_GetU32(pCursor, UINT32_MAX); break;
1696	case 8: u64Ret = rtDwarfCursor_GetU64(pCursor, UINT64_MAX); break;
1697	default:
1698	pCursor->rc = VERR_DWARF_BAD_INFO;
1699	return uErrValue;
1700	}
1701	if (RT_FAILURE(pCursor->rc))
1702	return uErrValue;
1703	return u64Ret;
1704	}
1705
1706
1707	#if 0 /* unused */
1708	/**
1709	* Gets the pointer to a variable size block and advances the cursor.
1710	*
1711	* @returns Pointer to the block at the current cursor location. On error
1712	* RTDWARFCURSOR::rc is set and NULL returned.
1713	* @param pCursor The cursor.
1714	* @param cbBlock The block size.
1715	*/
1716	static const uint8_t *rtDwarfCursor_GetBlock(PRTDWARFCURSOR pCursor, uint32_t cbBlock)
1717	{
1718	if (cbBlock > pCursor->cbUnitLeft)
1719	{
1720	pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1721	return NULL;
1722	}
1723
1724	uint8_t const *pb = &pCursor->pb[0];
1725	pCursor->pb += cbBlock;
1726	pCursor->cbUnitLeft -= cbBlock;
1727	pCursor->cbLeft -= cbBlock;
1728	return pb;
1729	}
1730	#endif
1731
1732
1733	/**
1734	* Reads an unsigned DWARF half number.
1735	*
1736	* @returns The number. On error RTDWARFCURSOR::rc is set and @a
1737	* uErrValue is returned.
1738	* @param pCursor The cursor.
1739	* @param uErrValue What to return on error.
1740	*/
1741	static uint16_t rtDwarfCursor_GetUHalf(PRTDWARFCURSOR pCursor, uint16_t uErrValue)
1742	{
1743	return rtDwarfCursor_GetU16(pCursor, uErrValue);
1744	}
1745
1746
1747	/**
1748	* Reads an unsigned DWARF byte number.
1749	*
1750	* @returns The number. On error RTDWARFCURSOR::rc is set and @a
1751	* uErrValue is returned.
1752	* @param pCursor The cursor.
1753	* @param uErrValue What to return on error.
1754	*/
1755	static uint8_t rtDwarfCursor_GetUByte(PRTDWARFCURSOR pCursor, uint8_t uErrValue)
1756	{
1757	return rtDwarfCursor_GetU8(pCursor, uErrValue);
1758	}
1759
1760
1761	/**
1762	* Reads a signed DWARF byte number.
1763	*
1764	* @returns The number. On error RTDWARFCURSOR::rc is set and @a
1765	* uErrValue is returned.
1766	* @param pCursor The cursor.
1767	* @param iErrValue What to return on error.
1768	*/
1769	static int8_t rtDwarfCursor_GetSByte(PRTDWARFCURSOR pCursor, int8_t iErrValue)
1770	{
1771	return (int8_t)rtDwarfCursor_GetU8(pCursor, (uint8_t)iErrValue);
1772	}
1773
1774
1775	/**
1776	* Reads a unsigned DWARF offset value.
1777	*
1778	* @returns The value. On error RTDWARFCURSOR::rc is set and @a
1779	* uErrValue is returned.
1780	* @param pCursor The cursor.
1781	* @param uErrValue What to return on error.
1782	*/
1783	static uint64_t rtDwarfCursor_GetUOff(PRTDWARFCURSOR pCursor, uint64_t uErrValue)
1784	{
1785	if (pCursor->f64bitDwarf)
1786	return rtDwarfCursor_GetU64(pCursor, uErrValue);
1787	return rtDwarfCursor_GetU32(pCursor, (uint32_t)uErrValue);
1788	}
1789
1790
1791	/**
1792	* Reads a unsigned DWARF native offset value.
1793	*
1794	* @returns The value. On error RTDWARFCURSOR::rc is set and @a
1795	* uErrValue is returned.
1796	* @param pCursor The cursor.
1797	* @param uErrValue What to return on error.
1798	*/
1799	static uint64_t rtDwarfCursor_GetNativeUOff(PRTDWARFCURSOR pCursor, uint64_t uErrValue)
1800	{
1801	switch (pCursor->cbNativeAddr)
1802	{
1803	case 1: return rtDwarfCursor_GetU8(pCursor, (uint8_t )uErrValue);
1804	case 2: return rtDwarfCursor_GetU16(pCursor, (uint16_t)uErrValue);
1805	case 4: return rtDwarfCursor_GetU32(pCursor, (uint32_t)uErrValue);
1806	case 8: return rtDwarfCursor_GetU64(pCursor, uErrValue);
1807	default:
1808	pCursor->rc = VERR_INTERNAL_ERROR_2;
1809	return uErrValue;
1810	}
1811	}
1812
1813
1814	/**
1815	* Reads a 1, 2, 4 or 8 byte unsigned value.
1816	*
1817	* @returns 64-bit unsigned value.
1818	* @param pCursor The cursor.
1819	* @param bPtrEnc The pointer encoding.
1820	* @param uErrValue The error value.
1821	*/
1822	static uint64_t rtDwarfCursor_GetPtrEnc(PRTDWARFCURSOR pCursor, uint8_t bPtrEnc, uint64_t uErrValue)
1823	{
1824	uint64_t u64Ret;
1825	switch (bPtrEnc & DW_EH_PE_FORMAT_MASK)
1826	{
1827	case DW_EH_PE_ptr:
1828	u64Ret = rtDwarfCursor_GetNativeUOff(pCursor, uErrValue);
1829	break;
1830	case DW_EH_PE_uleb128:
1831	u64Ret = rtDwarfCursor_GetULeb128(pCursor, uErrValue);
1832	break;
1833	case DW_EH_PE_udata2:
1834	u64Ret = rtDwarfCursor_GetU16(pCursor, UINT16_MAX);
1835	break;
1836	case DW_EH_PE_udata4:
1837	u64Ret = rtDwarfCursor_GetU32(pCursor, UINT32_MAX);
1838	break;
1839	case DW_EH_PE_udata8:
1840	u64Ret = rtDwarfCursor_GetU64(pCursor, UINT64_MAX);
1841	break;
1842	case DW_EH_PE_sleb128:
1843	u64Ret = rtDwarfCursor_GetSLeb128(pCursor, uErrValue);
1844	break;
1845	case DW_EH_PE_sdata2:
1846	u64Ret = (int64_t)(int16_t)rtDwarfCursor_GetU16(pCursor, UINT16_MAX);
1847	break;
1848	case DW_EH_PE_sdata4:
1849	u64Ret = (int64_t)(int32_t)rtDwarfCursor_GetU32(pCursor, UINT32_MAX);
1850	break;
1851	case DW_EH_PE_sdata8:
1852	u64Ret = rtDwarfCursor_GetU64(pCursor, UINT64_MAX);
1853	break;
1854	default:
1855	pCursor->rc = VERR_DWARF_BAD_INFO;
1856	return uErrValue;
1857	}
1858	if (RT_FAILURE(pCursor->rc))
1859	return uErrValue;
1860	return u64Ret;
1861	}
1862
1863
1864	/**
1865	* Gets the unit length, updating the unit length member and DWARF bitness
1866	* members of the cursor.
1867	*
1868	* @returns The unit length.
1869	* @param pCursor The cursor.
1870	*/
1871	static uint64_t rtDwarfCursor_GetInitialLength(PRTDWARFCURSOR pCursor)
1872	{
1873	/*
1874	* Read the initial length.
1875	*/
1876	pCursor->cbUnitLeft = pCursor->cbLeft;
1877	uint64_t cbUnit = rtDwarfCursor_GetU32(pCursor, 0);
1878	if (cbUnit != UINT32_C(0xffffffff))
1879	pCursor->f64bitDwarf = false;
1880	else
1881	{
1882	pCursor->f64bitDwarf = true;
1883	cbUnit = rtDwarfCursor_GetU64(pCursor, 0);
1884	}
1885
1886
1887	/*
1888	* Set the unit length, quitely fixing bad lengths.
1889	*/
1890	pCursor->cbUnitLeft = (size_t)cbUnit;
1891	if ( pCursor->cbUnitLeft > pCursor->cbLeft
1892	\|\| pCursor->cbUnitLeft != cbUnit)
1893	pCursor->cbUnitLeft = pCursor->cbLeft;
1894
1895	return cbUnit;
1896	}
1897
1898
1899	/**
1900	* Calculates the section offset corresponding to the current cursor position.
1901	*
1902	* @returns 32-bit section offset. If out of range, RTDWARFCURSOR::rc will be
1903	* set and UINT32_MAX returned.
1904	* @param pCursor The cursor.
1905	*/
1906	static uint32_t rtDwarfCursor_CalcSectOffsetU32(PRTDWARFCURSOR pCursor)
1907	{
1908	size_t off = pCursor->pb - pCursor->pbStart;
1909	uint32_t offRet = (uint32_t)off;
1910	if (offRet != off)
1911	{
1912	AssertFailed();
1913	pCursor->rc = VERR_OUT_OF_RANGE;
1914	offRet = UINT32_MAX;
1915	}
1916	return offRet;
1917	}
1918
1919
1920	/**
1921	* Calculates an absolute cursor position from one relative to the current
1922	* cursor position.
1923	*
1924	* @returns The absolute cursor position.
1925	* @param pCursor The cursor.
1926	* @param offRelative The relative position. Must be a positive
1927	* offset.
1928	*/
1929	static uint8_t const *rtDwarfCursor_CalcPos(PRTDWARFCURSOR pCursor, size_t offRelative)
1930	{
1931	if (offRelative > pCursor->cbUnitLeft)
1932	{
1933	Log(("rtDwarfCursor_CalcPos: bad position %#zx, cbUnitLeft=%#zu\n", offRelative, pCursor->cbUnitLeft));
1934	pCursor->rc = VERR_DWARF_BAD_POS;
1935	return NULL;
1936	}
1937	return pCursor->pb + offRelative;
1938	}
1939
1940
1941	/**
1942	* Advances the cursor to the given position.
1943	*
1944	* @returns IPRT status code.
1945	* @param pCursor The cursor.
1946	* @param pbNewPos The new position - returned by
1947	* rtDwarfCursor_CalcPos().
1948	*/
1949	static int rtDwarfCursor_AdvanceToPos(PRTDWARFCURSOR pCursor, uint8_t const *pbNewPos)
1950	{
1951	if (RT_FAILURE(pCursor->rc))
1952	return pCursor->rc;
1953	AssertPtr(pbNewPos);
1954	if ((uintptr_t)pbNewPos < (uintptr_t)pCursor->pb)
1955	{
1956	Log(("rtDwarfCursor_AdvanceToPos: bad position %p, current %p\n", pbNewPos, pCursor->pb));
1957	return pCursor->rc = VERR_DWARF_BAD_POS;
1958	}
1959
1960	uintptr_t cbAdj = (uintptr_t)pbNewPos - (uintptr_t)pCursor->pb;
1961	if (RT_UNLIKELY(cbAdj > pCursor->cbUnitLeft))
1962	{
1963	AssertFailed();
1964	pCursor->rc = VERR_DWARF_BAD_POS;
1965	cbAdj = pCursor->cbUnitLeft;
1966	}
1967
1968	pCursor->cbUnitLeft -= cbAdj;
1969	pCursor->cbLeft -= cbAdj;
1970	pCursor->pb += cbAdj;
1971	return pCursor->rc;
1972	}
1973
1974
1975	/**
1976	* Check if the cursor is at the end of the current DWARF unit.
1977	*
1978	* @retval true if at the end or a cursor error is pending.
1979	* @retval false if not.
1980	* @param pCursor The cursor.
1981	*/
1982	static bool rtDwarfCursor_IsAtEndOfUnit(PRTDWARFCURSOR pCursor)
1983	{
1984	return !pCursor->cbUnitLeft \|\| RT_FAILURE(pCursor->rc);
1985	}
1986
1987
1988	/**
1989	* Skips to the end of the current unit.
1990	*
1991	* @returns IPRT status code.
1992	* @param pCursor The cursor.
1993	*/
1994	static int rtDwarfCursor_SkipUnit(PRTDWARFCURSOR pCursor)
1995	{
1996	pCursor->pb += pCursor->cbUnitLeft;
1997	pCursor->cbLeft -= pCursor->cbUnitLeft;
1998	pCursor->cbUnitLeft = 0;
1999	return pCursor->rc;
2000	}
2001
2002
2003	/**
2004	* Check if the cursor is at the end of the section (or whatever the cursor is
2005	* processing).
2006	*
2007	* @retval true if at the end or a cursor error is pending.
2008	* @retval false if not.
2009	* @param pCursor The cursor.
2010	*/
2011	static bool rtDwarfCursor_IsAtEnd(PRTDWARFCURSOR pCursor)
2012	{
2013	return !pCursor->cbLeft \|\| RT_FAILURE(pCursor->rc);
2014	}
2015
2016
2017	/**
2018	* Initialize a section reader cursor.
2019	*
2020	* @returns IPRT status code.
2021	* @param pCursor The cursor.
2022	* @param pThis The dwarf module.
2023	* @param enmSect The name of the section to read.
2024	*/
2025	static int rtDwarfCursor_Init(PRTDWARFCURSOR pCursor, PRTDBGMODDWARF pThis, krtDbgModDwarfSect enmSect)
2026	{
2027	int rc = rtDbgModDwarfLoadSection(pThis, enmSect);
2028	if (RT_FAILURE(rc))
2029	return rc;
2030
2031	pCursor->enmSect = enmSect;
2032	pCursor->pbStart = (uint8_t const *)pThis->aSections[enmSect].pv;
2033	pCursor->pb = pCursor->pbStart;
2034	pCursor->cbLeft = pThis->aSections[enmSect].cb;
2035	pCursor->cbUnitLeft = pCursor->cbLeft;
2036	pCursor->pDwarfMod = pThis;
2037	pCursor->f64bitDwarf = false;
2038	/** @todo ask the image about the endian used as well as the address
2039	* width. */
2040	pCursor->fNativEndian = true;
2041	pCursor->cbNativeAddr = 4;
2042	pCursor->rc = VINF_SUCCESS;
2043
2044	return VINF_SUCCESS;
2045	}
2046
2047
2048	/**
2049	* Initialize a section reader cursor with a skip offset.
2050	*
2051	* @returns IPRT status code.
2052	* @param pCursor The cursor.
2053	* @param pThis The dwarf module.
2054	* @param enmSect The name of the section to read.
2055	* @param offSect The offset to skip into the section.
2056	*/
2057	static int rtDwarfCursor_InitWithOffset(PRTDWARFCURSOR pCursor, PRTDBGMODDWARF pThis,
2058	krtDbgModDwarfSect enmSect, uint32_t offSect)
2059	{
2060	if (offSect > pThis->aSections[enmSect].cb)
2061	{
2062	Log(("rtDwarfCursor_InitWithOffset: offSect=%#x cb=%#x enmSect=%d\n", offSect, pThis->aSections[enmSect].cb, enmSect));
2063	return VERR_DWARF_BAD_POS;
2064	}
2065
2066	int rc = rtDwarfCursor_Init(pCursor, pThis, enmSect);
2067	if (RT_SUCCESS(rc))
2068	{
2069	/* pCursor->pbStart += offSect; - we're skipping, offsets are relative to start of section... */
2070	pCursor->pb += offSect;
2071	pCursor->cbLeft -= offSect;
2072	pCursor->cbUnitLeft -= offSect;
2073	}
2074
2075	return rc;
2076	}
2077
2078
2079	/**
2080	* Initialize a cursor for a block (subsection) retrieved from the given cursor.
2081	*
2082	* The parent cursor will be advanced past the block.
2083	*
2084	* @returns IPRT status code.
2085	* @param pCursor The cursor.
2086	* @param pParent The parent cursor. Will be moved by @a cbBlock.
2087	* @param cbBlock The size of the block the new cursor should
2088	* cover.
2089	*/
2090	static int rtDwarfCursor_InitForBlock(PRTDWARFCURSOR pCursor, PRTDWARFCURSOR pParent, uint32_t cbBlock)
2091	{
2092	if (RT_FAILURE(pParent->rc))
2093	return pParent->rc;
2094	if (pParent->cbUnitLeft < cbBlock)
2095	{
2096	Log(("rtDwarfCursor_InitForBlock: cbUnitLeft=%#x < cbBlock=%#x \n", pParent->cbUnitLeft, cbBlock));
2097	return VERR_DWARF_BAD_POS;
2098	}
2099
2100	pCursor = pParent;
2101	pCursor->cbLeft = cbBlock;
2102	pCursor->cbUnitLeft = cbBlock;
2103
2104	pParent->pb += cbBlock;
2105	pParent->cbLeft -= cbBlock;
2106	pParent->cbUnitLeft -= cbBlock;
2107
2108	return VINF_SUCCESS;
2109	}
2110
2111
2112	/**
2113	* Initialize a reader cursor for a memory block (eh_frame).
2114	*
2115	* @returns IPRT status code.
2116	* @param pCursor The cursor.
2117	* @param pvMem The memory block.
2118	* @param cbMem The size of the memory block.
2119	*/
2120	static int rtDwarfCursor_InitForMem(PRTDWARFCURSOR pCursor, void const *pvMem, size_t cbMem)
2121	{
2122	pCursor->enmSect = krtDbgModDwarfSect_End;
2123	pCursor->pbStart = (uint8_t const *)pvMem;
2124	pCursor->pb = (uint8_t const *)pvMem;
2125	pCursor->cbLeft = cbMem;
2126	pCursor->cbUnitLeft = cbMem;
2127	pCursor->pDwarfMod = NULL;
2128	pCursor->f64bitDwarf = false;
2129	/** @todo ask the image about the endian used as well as the address
2130	* width. */
2131	pCursor->fNativEndian = true;
2132	pCursor->cbNativeAddr = 4;
2133	pCursor->rc = VINF_SUCCESS;
2134
2135	return VINF_SUCCESS;
2136	}
2137
2138
2139	/**
2140	* Deletes a section reader initialized by rtDwarfCursor_Init.
2141	*
2142	* @returns @a rcOther or RTDWARCURSOR::rc.
2143	* @param pCursor The section reader.
2144	* @param rcOther Other error code to be returned if it indicates
2145	* error or if the cursor status is OK.
2146	*/
2147	static int rtDwarfCursor_Delete(PRTDWARFCURSOR pCursor, int rcOther)
2148	{
2149	/* ... and a drop of poison. */
2150	pCursor->pb = NULL;
2151	pCursor->cbLeft = ~(size_t)0;
2152	pCursor->cbUnitLeft = ~(size_t)0;
2153	pCursor->pDwarfMod = NULL;
2154	if (RT_FAILURE(pCursor->rc) && RT_SUCCESS(rcOther))
2155	rcOther = pCursor->rc;
2156	pCursor->rc = VERR_INTERNAL_ERROR_4;
2157	return rcOther;
2158	}
2159
2160
2161	/*
2162	*
2163	* DWARF Frame Unwind Information.
2164	* DWARF Frame Unwind Information.
2165	* DWARF Frame Unwind Information.
2166	*
2167	*/
2168
2169	/**
2170	* Common information entry (CIE) information.
2171	*/
2172	typedef struct RTDWARFCIEINFO
2173	{
2174	/** The segment location of the CIE. */
2175	uint64_t offCie;
2176	/** The DWARF version. */
2177	uint8_t uDwarfVer;
2178	/** The address pointer encoding. */
2179	uint8_t bAddressPtrEnc;
2180	/** The segment size (v4). */
2181	uint8_t cbSegment;
2182	/** The return register column. UINT8_MAX if default register. */
2183	uint8_t bRetReg;
2184	/** The LSDA pointer encoding. */
2185	uint8_t bLsdaPtrEnc;
2186
2187	/** Set if the EH data field is present ('eh'). */
2188	bool fHasEhData : 1;
2189	/** Set if there is an augmentation data size ('z'). */
2190	bool fHasAugmentationSize : 1;
2191	/** Set if the augmentation data contains a LSDA (pointer size byte in CIE,
2192	* pointer in FDA) ('L'). */
2193	bool fHasLanguageSpecificDataArea : 1;
2194	/** Set if the augmentation data contains a personality routine
2195	* (pointer size + pointer) ('P'). */
2196	bool fHasPersonalityRoutine : 1;
2197	/** Set if the augmentation data contains the address encoding . */
2198	bool fHasAddressEnc : 1;
2199	/** Set if signal frame. */
2200	bool fIsSignalFrame : 1;
2201	/** Set if we've encountered unknown augmentation data. This
2202	* means the CIE is incomplete and cannot be used. */
2203	bool fHasUnknowAugmentation : 1;
2204
2205	/** Copy of the augmentation string. */
2206	const char *pszAugmentation;
2207
2208	/** Code alignment factor for the instruction. */
2209	uint64_t uCodeAlignFactor;
2210	/** Data alignment factor for the instructions. */
2211	int64_t iDataAlignFactor;
2212
2213	/** Pointer to the instruction sequence. */
2214	uint8_t const *pbInstructions;
2215	/** The length of the instruction sequence. */
2216	size_t cbInstructions;
2217	} RTDWARFCIEINFO;
2218	/** Pointer to CIE info. */
2219	typedef RTDWARFCIEINFO *PRTDWARFCIEINFO;
2220	/** Pointer to const CIE info. */
2221	typedef RTDWARFCIEINFO const *PCRTDWARFCIEINFO;
2222
2223
2224	/** Number of registers we care about.
2225	* @note We're currently not expecting to be decoding ppc, arm, ia64 or such,
2226	* only x86 and x86_64. We can easily increase the column count. */
2227	#define RTDWARFCF_MAX_REGISTERS 96
2228
2229
2230	/**
2231	* Call frame state row.
2232	*/
2233	typedef struct RTDWARFCFROW
2234	{
2235	/** Stack worked by DW_CFA_remember_state and DW_CFA_restore_state. */
2236	struct RTDWARFCFROW *pNextOnStack;
2237
2238	/** @name CFA - Canonical frame address expression.
2239	* Since there are partial CFA instructions, we cannot be lazy like with the
2240	* register but keep register+offset around. For DW_CFA_def_cfa_expression
2241	* we just take down the program location, though.
2242	* @{ */
2243	/** Pointer to DW_CFA_def_cfa_expression instruction, NULL if reg+offset. */
2244	uint8_t const *pbCfaExprInstr;
2245	/** The CFA register offset. */
2246	int64_t offCfaReg;
2247	/** The CFA base register number. */
2248	uint16_t uCfaBaseReg;
2249	/** Set if we've got a valid CFA definition. */
2250	bool fCfaDefined : 1;
2251	/** @} */
2252
2253	/** Set if on the heap and needs freeing. */
2254	bool fOnHeap : 1;
2255	/** Pointer to the instructions bytes defining registers.
2256	* NULL means */
2257	uint8_t const *apbRegInstrs[RTDWARFCF_MAX_REGISTERS];
2258	} RTDWARFCFROW;
2259	typedef RTDWARFCFROW *PRTDWARFCFROW;
2260	typedef RTDWARFCFROW const *PCRTDWARFCFROW;
2261
2262	/** Row program execution state. */
2263	typedef struct RTDWARFCFEXEC
2264	{
2265	PRTDWARFCFROW pRow;
2266	/** Number of PC bytes left to advance before we get a hit. */
2267	uint64_t cbLeftToAdvance;
2268	/** Number of pushed rows. */
2269	uint32_t cPushes;
2270	/** Set if little endian, clear if big endian. */
2271	bool fLittleEndian;
2272	/** The CIE. */
2273	PCRTDWARFCIEINFO pCie;
2274	/** The program counter value for the FDE. Subjected to segment.
2275	* Needed for DW_CFA_set_loc. */
2276	uint64_t uPcBegin;
2277	/** The offset relative to uPcBegin for which we're searching for a row.
2278	* Needed for DW_CFA_set_loc. */
2279	uint64_t offInRange;
2280	} RTDWARFCFEXEC;
2281	typedef RTDWARFCFEXEC *PRTDWARFCFEXEC;
2282
2283
2284	/* Set of macros for getting and skipping operands. */
2285	#define SKIP_ULEB128_OR_LEB128() \
2286	do \
2287	{ \
2288	AssertReturn(offInstr < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO); \
2289	} while (pbInstr[offInstr++] & 0x80)
2290
2291	#define GET_ULEB128_AS_U14(a_uDst) \
2292	do \
2293	{ \
2294	AssertReturn(offInstr < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO); \
2295	uint8_t b = pbInstr[offInstr++]; \
2296	(a_uDst) = b & 0x7f; \
2297	if (b & 0x80) \
2298	{ \
2299	AssertReturn(offInstr < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO); \
2300	b = pbInstr[offInstr++]; \
2301	AssertReturn(!(b & 0x80), VERR_DBG_MALFORMED_UNWIND_INFO); \
2302	(a_uDst) \|= (uint16_t)b << 7; \
2303	} \
2304	} while (0)
2305	#define GET_ULEB128_AS_U63(a_uDst) \
2306	do \
2307	{ \
2308	AssertReturn(offInstr < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO); \
2309	uint8_t b = pbInstr[offInstr++]; \
2310	(a_uDst) = b & 0x7f; \
2311	if (b & 0x80) \
2312	{ \
2313	unsigned cShift = 7; \
2314	do \
2315	{ \
2316	AssertReturn(offInstr < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO); \
2317	AssertReturn(cShift < 63, VERR_DWARF_LEB_OVERFLOW); \
2318	b = pbInstr[offInstr++]; \
2319	(a_uDst) \|= (uint16_t)(b & 0x7f) << cShift; \
2320	cShift += 7; \
2321	} while (b & 0x80); \
2322	} \
2323	} while (0)
2324	#define GET_LEB128_AS_I63(a_uDst) \
2325	do \
2326	{ \
2327	AssertReturn(offInstr < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO); \
2328	uint8_t b = pbInstr[offInstr++]; \
2329	if (!(b & 0x80)) \
2330	(a_uDst) = !(b & 0x40) ? b : (int64_t)(int8_t)(b \| 0x80); \
2331	else \
2332	{ \
2333	/* Read value into unsigned variable: */ \
2334	unsigned cShift = 7; \
2335	uint64_t uTmp = b & 0x7f; \
2336	do \
2337	{ \
2338	AssertReturn(offInstr < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO); \
2339	AssertReturn(cShift < 63, VERR_DWARF_LEB_OVERFLOW); \
2340	b = pbInstr[offInstr++]; \
2341	uTmp \|= (uint16_t)(b & 0x7f) << cShift; \
2342	cShift += 7; \
2343	} while (b & 0x80); \
2344	/* Sign extend before setting the destination value: */ \
2345	cShift -= 7 + 1; \
2346	if (uTmp & RT_BIT_64(cShift)) \
2347	uTmp \|= ~(RT_BIT_64(cShift) - 1); \
2348	(a_uDst) = (int64_t)uTmp; \
2349	} \
2350	} while (0)
2351
2352	#define SKIP_BLOCK() \
2353	do \
2354	{ \
2355	uint16_t cbBlock; \
2356	GET_ULEB128_AS_U14(cbBlock); \
2357	AssertReturn(offInstr + cbBlock <= cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO); \
2358	offInstr += cbBlock; \
2359	} while (0)
2360
2361
2362	static int rtDwarfUnwind_Execute(PRTDWARFCFEXEC pExecState, uint8_t const *pbInstr, uint32_t cbInstr)
2363	{
2364	PRTDWARFCFROW pRow = pExecState->pRow;
2365	for (uint32_t offInstr = 0; offInstr < cbInstr;)
2366	{
2367	/*
2368	* Instruction switches.
2369	*/
2370	uint8_t const bInstr = pbInstr[offInstr++];
2371	switch (bInstr & DW_CFA_high_bit_mask)
2372	{
2373	case DW_CFA_advance_loc:
2374	{
2375	uint8_t const cbAdvance = bInstr & ~DW_CFA_high_bit_mask;
2376	if (cbAdvance > pExecState->cbLeftToAdvance)
2377	return VINF_SUCCESS;
2378	pExecState->cbLeftToAdvance -= cbAdvance;
2379	break;
2380	}
2381
2382	case DW_CFA_offset:
2383	{
2384	uint8_t iReg = bInstr & ~DW_CFA_high_bit_mask;
2385	if (iReg < RT_ELEMENTS(pRow->apbRegInstrs))
2386	pRow->apbRegInstrs[iReg] = &pbInstr[offInstr - 1];
2387	SKIP_ULEB128_OR_LEB128();
2388	break;
2389	}
2390
2391	case 0:
2392	switch (bInstr)
2393	{
2394	case DW_CFA_nop:
2395	break;
2396
2397	/*
2398	* Register instructions.
2399	*/
2400	case DW_CFA_register:
2401	case DW_CFA_offset_extended:
2402	case DW_CFA_offset_extended_sf:
2403	case DW_CFA_val_offset:
2404	case DW_CFA_val_offset_sf:
2405	{
2406	uint8_t const * const pbCurInstr = &pbInstr[offInstr - 1];
2407	uint16_t iReg;
2408	GET_ULEB128_AS_U14(iReg);
2409	if (iReg < RT_ELEMENTS(pRow->apbRegInstrs))
2410	pRow->apbRegInstrs[iReg] = pbCurInstr;
2411	SKIP_ULEB128_OR_LEB128();
2412	break;
2413	}
2414
2415	case DW_CFA_expression:
2416	case DW_CFA_val_expression:
2417	{
2418	uint8_t const * const pbCurInstr = &pbInstr[offInstr - 1];
2419	uint16_t iReg;
2420	GET_ULEB128_AS_U14(iReg);
2421	if (iReg < RT_ELEMENTS(pRow->apbRegInstrs))
2422	pRow->apbRegInstrs[iReg] = pbCurInstr;
2423	SKIP_BLOCK();
2424	break;
2425	}
2426
2427	case DW_CFA_restore_extended:
2428	{
2429	uint8_t const * const pbCurInstr = &pbInstr[offInstr - 1];
2430	uint16_t iReg;
2431	GET_ULEB128_AS_U14(iReg);
2432	if (iReg < RT_ELEMENTS(pRow->apbRegInstrs))
2433	pRow->apbRegInstrs[iReg] = pbCurInstr;
2434	break;
2435	}
2436
2437	case DW_CFA_undefined:
2438	{
2439	uint16_t iReg;
2440	GET_ULEB128_AS_U14(iReg);
2441	if (iReg < RT_ELEMENTS(pRow->apbRegInstrs))
2442	pRow->apbRegInstrs[iReg] = NULL;
2443	break;
2444	}
2445
2446	case DW_CFA_same_value:
2447	{
2448	uint8_t const * const pbCurInstr = &pbInstr[offInstr - 1];
2449	uint16_t iReg;
2450	GET_ULEB128_AS_U14(iReg);
2451	if (iReg < RT_ELEMENTS(pRow->apbRegInstrs))
2452	pRow->apbRegInstrs[iReg] = pbCurInstr;
2453	break;
2454	}
2455
2456
2457	/*
2458	* CFA instructions.
2459	*/
2460	case DW_CFA_def_cfa:
2461	{
2462	GET_ULEB128_AS_U14(pRow->uCfaBaseReg);
2463	uint64_t offCfaReg;
2464	GET_ULEB128_AS_U63(offCfaReg);
2465	pRow->offCfaReg = offCfaReg;
2466	pRow->pbCfaExprInstr = NULL;
2467	pRow->fCfaDefined = true;
2468	break;
2469	}
2470
2471	case DW_CFA_def_cfa_register:
2472	{
2473	GET_ULEB128_AS_U14(pRow->uCfaBaseReg);
2474	pRow->pbCfaExprInstr = NULL;
2475	pRow->fCfaDefined = true;
2476	/* Leaves offCfaReg as is. */
2477	break;
2478	}
2479
2480	case DW_CFA_def_cfa_offset:
2481	{
2482	uint64_t offCfaReg;
2483	GET_ULEB128_AS_U63(offCfaReg);
2484	pRow->offCfaReg = offCfaReg;
2485	pRow->pbCfaExprInstr = NULL;
2486	pRow->fCfaDefined = true;
2487	/* Leaves uCfaBaseReg as is. */
2488	break;
2489	}
2490
2491	case DW_CFA_def_cfa_sf:
2492	GET_ULEB128_AS_U14(pRow->uCfaBaseReg);
2493	GET_LEB128_AS_I63(pRow->offCfaReg);
2494	pRow->pbCfaExprInstr = NULL;
2495	pRow->fCfaDefined = true;
2496	break;
2497
2498	case DW_CFA_def_cfa_offset_sf:
2499	GET_LEB128_AS_I63(pRow->offCfaReg);
2500	pRow->pbCfaExprInstr = NULL;
2501	pRow->fCfaDefined = true;
2502	/* Leaves uCfaBaseReg as is. */
2503	break;
2504
2505	case DW_CFA_def_cfa_expression:
2506	pRow->pbCfaExprInstr = &pbInstr[offInstr - 1];
2507	pRow->fCfaDefined = true;
2508	SKIP_BLOCK();
2509	break;
2510
2511	/*
2512	* Less likely instructions:
2513	*/
2514	case DW_CFA_advance_loc1:
2515	{
2516	AssertReturn(offInstr < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO);
2517	uint8_t const cbAdvance = pbInstr[offInstr++];
2518	if (cbAdvance > pExecState->cbLeftToAdvance)
2519	return VINF_SUCCESS;
2520	pExecState->cbLeftToAdvance -= cbAdvance;
2521	break;
2522	}
2523
2524	case DW_CFA_advance_loc2:
2525	{
2526	AssertReturn(offInstr + 1 < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO);
2527	uint16_t const cbAdvance = pExecState->fLittleEndian
2528	? RT_MAKE_U16(pbInstr[offInstr], pbInstr[offInstr + 1])
2529	: RT_MAKE_U16(pbInstr[offInstr + 1], pbInstr[offInstr]);
2530	if (cbAdvance > pExecState->cbLeftToAdvance)
2531	return VINF_SUCCESS;
2532	pExecState->cbLeftToAdvance -= cbAdvance;
2533	offInstr += 2;
2534	break;
2535	}
2536
2537	case DW_CFA_advance_loc4:
2538	{
2539	AssertReturn(offInstr + 3 < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO);
2540	uint32_t const cbAdvance = pExecState->fLittleEndian
2541	? RT_MAKE_U32_FROM_U8(pbInstr[offInstr + 0], pbInstr[offInstr + 1],
2542	pbInstr[offInstr + 2], pbInstr[offInstr + 3])
2543	: RT_MAKE_U32_FROM_U8(pbInstr[offInstr + 3], pbInstr[offInstr + 2],
2544	pbInstr[offInstr + 1], pbInstr[offInstr + 0]);
2545	if (cbAdvance > pExecState->cbLeftToAdvance)
2546	return VINF_SUCCESS;
2547	pExecState->cbLeftToAdvance -= cbAdvance;
2548	offInstr += 4;
2549	break;
2550	}
2551
2552	/*
2553	* This bugger is really annoying and probably never used.
2554	*/
2555	case DW_CFA_set_loc:
2556	{
2557	/* Ignore the segment number. */
2558	if (pExecState->pCie->cbSegment)
2559	{
2560	offInstr += pExecState->pCie->cbSegment;
2561	AssertReturn(offInstr < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO);
2562	}
2563
2564	/* Retrieve the address. sigh. */
2565	uint64_t uAddress;
2566	switch (pExecState->pCie->bAddressPtrEnc & (DW_EH_PE_FORMAT_MASK \| DW_EH_PE_indirect))
2567	{
2568	case DW_EH_PE_udata2:
2569	AssertReturn(offInstr + 1 < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO);
2570	if (pExecState->fLittleEndian)
2571	uAddress = RT_MAKE_U16(pbInstr[offInstr], pbInstr[offInstr + 1]);
2572	else
2573	uAddress = RT_MAKE_U16(pbInstr[offInstr + 1], pbInstr[offInstr]);
2574	offInstr += 2;
2575	break;
2576	case DW_EH_PE_sdata2:
2577	AssertReturn(offInstr + 1 < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO);
2578	if (pExecState->fLittleEndian)
2579	uAddress = (int64_t)(int16_t)RT_MAKE_U16(pbInstr[offInstr], pbInstr[offInstr + 1]);
2580	else
2581	uAddress = (int64_t)(int16_t)RT_MAKE_U16(pbInstr[offInstr + 1], pbInstr[offInstr]);
2582	offInstr += 2;
2583	break;
2584	case DW_EH_PE_udata4:
2585	AssertReturn(offInstr + 3 < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO);
2586	if (pExecState->fLittleEndian)
2587	uAddress = RT_MAKE_U32_FROM_U8(pbInstr[offInstr + 0], pbInstr[offInstr + 1],
2588	pbInstr[offInstr + 2], pbInstr[offInstr + 3]);
2589	else
2590	uAddress = RT_MAKE_U32_FROM_U8(pbInstr[offInstr + 3], pbInstr[offInstr + 2],
2591	pbInstr[offInstr + 1], pbInstr[offInstr + 0]);
2592
2593	offInstr += 4;
2594	break;
2595	case DW_EH_PE_sdata4:
2596	AssertReturn(offInstr + 3 < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO);
2597	if (pExecState->fLittleEndian)
2598	uAddress = (int64_t)(int32_t)RT_MAKE_U32_FROM_U8(pbInstr[offInstr + 0], pbInstr[offInstr + 1],
2599	pbInstr[offInstr + 2], pbInstr[offInstr + 3]);
2600	else
2601	uAddress = (int64_t)(int32_t)RT_MAKE_U32_FROM_U8(pbInstr[offInstr + 3], pbInstr[offInstr + 2],
2602	pbInstr[offInstr + 1], pbInstr[offInstr + 0]);
2603	offInstr += 4;
2604	break;
2605	case DW_EH_PE_udata8:
2606	case DW_EH_PE_sdata8:
2607	AssertReturn(offInstr + 7 < cbInstr, VERR_DBG_MALFORMED_UNWIND_INFO);
2608	if (pExecState->fLittleEndian)
2609	uAddress = RT_MAKE_U64_FROM_U8(pbInstr[offInstr + 0], pbInstr[offInstr + 1],
2610	pbInstr[offInstr + 2], pbInstr[offInstr + 3],
2611	pbInstr[offInstr + 4], pbInstr[offInstr + 5],
2612	pbInstr[offInstr + 6], pbInstr[offInstr + 7]);
2613	else
2614	uAddress = RT_MAKE_U64_FROM_U8(pbInstr[offInstr + 7], pbInstr[offInstr + 6],
2615	pbInstr[offInstr + 5], pbInstr[offInstr + 4],
2616	pbInstr[offInstr + 3], pbInstr[offInstr + 2],
2617	pbInstr[offInstr + 1], pbInstr[offInstr + 0]);
2618	offInstr += 8;
2619	break;
2620	case DW_EH_PE_sleb128:
2621	case DW_EH_PE_uleb128:
2622	default:
2623	AssertMsgFailedReturn(("%#x\n", pExecState->pCie->bAddressPtrEnc), VERR_DWARF_TODO);
2624	}
2625	AssertReturn(uAddress >= pExecState->uPcBegin, VERR_DBG_MALFORMED_UNWIND_INFO);
2626
2627	/* Did we advance past the desire address already? */
2628	if (uAddress > pExecState->uPcBegin + pExecState->offInRange)
2629	return VINF_SUCCESS;
2630	pExecState->cbLeftToAdvance = pExecState->uPcBegin + pExecState->offInRange - uAddress;
2631	break;
2632
2633
2634	/*
2635	* Row state push/pop instructions.
2636	*/
2637
2638	case DW_CFA_remember_state:
2639	{
2640	AssertReturn(pExecState->cPushes < 10, VERR_DBG_MALFORMED_UNWIND_INFO);
2641	PRTDWARFCFROW pNewRow = (PRTDWARFCFROW)RTMemTmpAlloc(sizeof(*pNewRow));
2642	AssertReturn(pNewRow, VERR_NO_TMP_MEMORY);
2643	memcpy(pNewRow, pRow, sizeof(*pNewRow));
2644	pNewRow->pNextOnStack = pRow;
2645	pNewRow->fOnHeap = true;
2646	pExecState->pRow = pNewRow;
2647	pExecState->cPushes += 1;
2648	pRow = pNewRow;
2649	break;
2650	}
2651
2652	case DW_CFA_restore_state:
2653	AssertReturn(pRow->pNextOnStack, VERR_DBG_MALFORMED_UNWIND_INFO);
2654	Assert(pRow->fOnHeap);
2655	Assert(pExecState->cPushes > 0);
2656	pExecState->cPushes -= 1;
2657	pExecState->pRow = pRow->pNextOnStack;
2658	RTMemTmpFree(pRow);
2659	pRow = pExecState->pRow;
2660	break;
2661	}
2662	}
2663	break;
2664
2665	case DW_CFA_restore:
2666	{
2667	uint8_t const * const pbCurInstr = &pbInstr[offInstr - 1];
2668	uint8_t const iReg = bInstr & ~DW_CFA_high_bit_mask;
2669	if (iReg < RT_ELEMENTS(pRow->apbRegInstrs))
2670	pRow->apbRegInstrs[iReg] = pbCurInstr;
2671	break;
2672	}
2673	}
2674	}
2675	return VINF_TRY_AGAIN;
2676	}
2677
2678
2679	/**
2680	* Register getter for AMD64.
2681	*
2682	* @returns true if found, false if not.
2683	* @param pState The unwind state to get the register from.
2684	* @param iReg The dwarf register number.
2685	* @param puValue Where to store the register value.
2686	*/
2687	static bool rtDwarfUnwind_Amd64GetRegFromState(PCRTDBGUNWINDSTATE pState, uint16_t iReg, uint64_t *puValue)
2688	{
2689	switch (iReg)
2690	{
2691	case DWREG_AMD64_RAX: *puValue = pState->u.x86.auRegs[X86_GREG_xAX]; return true;
2692	case DWREG_AMD64_RDX: *puValue = pState->u.x86.auRegs[X86_GREG_xDX]; return true;
2693	case DWREG_AMD64_RCX: *puValue = pState->u.x86.auRegs[X86_GREG_xCX]; return true;
2694	case DWREG_AMD64_RBX: *puValue = pState->u.x86.auRegs[X86_GREG_xBX]; return true;
2695	case DWREG_AMD64_RSI: *puValue = pState->u.x86.auRegs[X86_GREG_xSI]; return true;
2696	case DWREG_AMD64_RDI: *puValue = pState->u.x86.auRegs[X86_GREG_xDI]; return true;
2697	case DWREG_AMD64_RBP: *puValue = pState->u.x86.auRegs[X86_GREG_xBP]; return true;
2698	case DWREG_AMD64_RSP: *puValue = pState->u.x86.auRegs[X86_GREG_xSP]; return true;
2699	case DWREG_AMD64_R8: *puValue = pState->u.x86.auRegs[X86_GREG_x8]; return true;
2700	case DWREG_AMD64_R9: *puValue = pState->u.x86.auRegs[X86_GREG_x9]; return true;
2701	case DWREG_AMD64_R10: *puValue = pState->u.x86.auRegs[X86_GREG_x10]; return true;
2702	case DWREG_AMD64_R11: *puValue = pState->u.x86.auRegs[X86_GREG_x11]; return true;
2703	case DWREG_AMD64_R12: *puValue = pState->u.x86.auRegs[X86_GREG_x12]; return true;
2704	case DWREG_AMD64_R13: *puValue = pState->u.x86.auRegs[X86_GREG_x13]; return true;
2705	case DWREG_AMD64_R14: *puValue = pState->u.x86.auRegs[X86_GREG_x14]; return true;
2706	case DWREG_AMD64_R15: *puValue = pState->u.x86.auRegs[X86_GREG_x15]; return true;
2707	case DWREG_AMD64_RFLAGS: *puValue = pState->u.x86.uRFlags; return true;
2708	case DWREG_AMD64_ES: *puValue = pState->u.x86.auSegs[X86_SREG_ES]; return true;
2709	case DWREG_AMD64_CS: *puValue = pState->u.x86.auSegs[X86_SREG_CS]; return true;
2710	case DWREG_AMD64_SS: *puValue = pState->u.x86.auSegs[X86_SREG_SS]; return true;
2711	case DWREG_AMD64_DS: *puValue = pState->u.x86.auSegs[X86_SREG_DS]; return true;
2712	case DWREG_AMD64_FS: *puValue = pState->u.x86.auSegs[X86_SREG_FS]; return true;
2713	case DWREG_AMD64_GS: *puValue = pState->u.x86.auSegs[X86_SREG_GS]; return true;
2714	}
2715	return false;
2716	}
2717
2718
2719	/**
2720	* Register getter for 386+.
2721	*
2722	* @returns true if found, false if not.
2723	* @param pState The unwind state to get the register from.
2724	* @param iReg The dwarf register number.
2725	* @param puValue Where to store the register value.
2726	*/
2727	static bool rtDwarfUnwind_X86GetRegFromState(PCRTDBGUNWINDSTATE pState, uint16_t iReg, uint64_t *puValue)
2728	{
2729	switch (iReg)
2730	{
2731	case DWREG_X86_EAX: *puValue = pState->u.x86.auRegs[X86_GREG_xAX]; return true;
2732	case DWREG_X86_ECX: *puValue = pState->u.x86.auRegs[X86_GREG_xCX]; return true;
2733	case DWREG_X86_EDX: *puValue = pState->u.x86.auRegs[X86_GREG_xDX]; return true;
2734	case DWREG_X86_EBX: *puValue = pState->u.x86.auRegs[X86_GREG_xBX]; return true;
2735	case DWREG_X86_ESP: *puValue = pState->u.x86.auRegs[X86_GREG_xSP]; return true;
2736	case DWREG_X86_EBP: *puValue = pState->u.x86.auRegs[X86_GREG_xBP]; return true;
2737	case DWREG_X86_ESI: *puValue = pState->u.x86.auRegs[X86_GREG_xSI]; return true;
2738	case DWREG_X86_EDI: *puValue = pState->u.x86.auRegs[X86_GREG_xDI]; return true;
2739	case DWREG_X86_EFLAGS: *puValue = pState->u.x86.uRFlags; return true;
2740	case DWREG_X86_ES: *puValue = pState->u.x86.auSegs[X86_SREG_ES]; return true;
2741	case DWREG_X86_CS: *puValue = pState->u.x86.auSegs[X86_SREG_CS]; return true;
2742	case DWREG_X86_SS: *puValue = pState->u.x86.auSegs[X86_SREG_SS]; return true;
2743	case DWREG_X86_DS: *puValue = pState->u.x86.auSegs[X86_SREG_DS]; return true;
2744	case DWREG_X86_FS: *puValue = pState->u.x86.auSegs[X86_SREG_FS]; return true;
2745	case DWREG_X86_GS: *puValue = pState->u.x86.auSegs[X86_SREG_GS]; return true;
2746	}
2747	return false;
2748	}
2749
2750	/** Register getter. */
2751	typedef bool FNDWARFUNWINDGEREGFROMSTATE(PCRTDBGUNWINDSTATE pState, uint16_t iReg, uint64_t *puValue);
2752	/** Pointer to a register getter. */
2753	typedef FNDWARFUNWINDGEREGFROMSTATE *PFNDWARFUNWINDGEREGFROMSTATE;
2754
2755
2756
2757	/**
2758	* Does the heavy work for figuring out the return value of a register.
2759	*
2760	* @returns IPRT status code.
2761	* @retval VERR_NOT_FOUND if register is undefined.
2762	*
2763	* @param pRow The DWARF unwind table "row" to use.
2764	* @param uReg The DWARF register number.
2765	* @param pCie The corresponding CIE.
2766	* @param uCfa The canonical frame address to use.
2767	* @param pState The unwind to use when reading stack.
2768	* @param pOldState The unwind state to get register values from.
2769	* @param pfnGetReg The register value getter.
2770	* @param puValue Where to store the return value.
2771	* @param cbValue The size this register would have on the stack.
2772	*/
2773	static int rtDwarfUnwind_CalcRegisterValue(PRTDWARFCFROW pRow, unsigned uReg, PCRTDWARFCIEINFO pCie, uint64_t uCfa,
2774	PRTDBGUNWINDSTATE pState, PCRTDBGUNWINDSTATE pOldState,
2775	PFNDWARFUNWINDGEREGFROMSTATE pfnGetReg, uint64_t *puValue, uint8_t cbValue)
2776	{
2777	Assert(uReg < RT_ELEMENTS(pRow->apbRegInstrs));
2778	uint8_t const *pbInstr = pRow->apbRegInstrs[uReg];
2779	if (!pbInstr)
2780	return VERR_NOT_FOUND;
2781
2782	uint32_t cbInstr = UINT32_MAX / 2;
2783	uint32_t offInstr = 1;
2784	uint8_t const bInstr = *pbInstr;
2785	switch (bInstr)
2786	{
2787	default:
2788	if ((bInstr & DW_CFA_high_bit_mask) == DW_CFA_offset)
2789	{
2790	uint64_t offCfa;
2791	GET_ULEB128_AS_U63(offCfa);
2792	int rc = pState->pfnReadStack(pState, uCfa + (int64_t)offCfa * pCie->iDataAlignFactor, cbValue, puValue);
2793	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_offset %#RX64: %Rrc, %#RX64\n", uReg, uCfa + (int64_t)offCfa * pCie->iDataAlignFactor, rc, *puValue));
2794	return rc;
2795	}
2796	AssertReturn((bInstr & DW_CFA_high_bit_mask) == DW_CFA_restore, VERR_INTERNAL_ERROR);
2797	RT_FALL_THRU();
2798	case DW_CFA_restore_extended:
2799	/* Need to search the CIE for the rule. */
2800	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_restore/extended:\n", uReg));
2801	AssertFailedReturn(VERR_DWARF_TODO);
2802
2803	case DW_CFA_offset_extended:
2804	{
2805	SKIP_ULEB128_OR_LEB128();
2806	uint64_t offCfa;
2807	GET_ULEB128_AS_U63(offCfa);
2808	int rc = pState->pfnReadStack(pState, uCfa + (int64_t)offCfa * pCie->iDataAlignFactor, cbValue, puValue);
2809	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_offset_extended %#RX64: %Rrc, %#RX64\n", uReg, uCfa + (int64_t)offCfa * pCie->iDataAlignFactor, rc, *puValue));
2810	return rc;
2811	}
2812
2813	case DW_CFA_offset_extended_sf:
2814	{
2815	SKIP_ULEB128_OR_LEB128();
2816	int64_t offCfa;
2817	GET_LEB128_AS_I63(offCfa);
2818	int rc = pState->pfnReadStack(pState, uCfa + offCfa * pCie->iDataAlignFactor, cbValue, puValue);
2819	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_offset_extended_sf %#RX64: %Rrc, %#RX64\n", uReg, uCfa + offCfa * pCie->iDataAlignFactor, rc, *puValue));
2820	return rc;
2821	}
2822
2823	case DW_CFA_val_offset:
2824	{
2825	SKIP_ULEB128_OR_LEB128();
2826	uint64_t offCfa;
2827	GET_ULEB128_AS_U63(offCfa);
2828	puValue = uCfa + (int64_t)offCfa pCie->iDataAlignFactor;
2829	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_val_offset: %#RX64\n", uReg, *puValue));
2830	return VINF_SUCCESS;
2831	}
2832
2833	case DW_CFA_val_offset_sf:
2834	{
2835	SKIP_ULEB128_OR_LEB128();
2836	int64_t offCfa;
2837	GET_LEB128_AS_I63(offCfa);
2838	puValue = uCfa + offCfa pCie->iDataAlignFactor;
2839	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_val_offset_sf: %#RX64\n", uReg, *puValue));
2840	return VINF_SUCCESS;
2841	}
2842
2843	case DW_CFA_register:
2844	{
2845	SKIP_ULEB128_OR_LEB128();
2846	uint16_t iSrcReg;
2847	GET_ULEB128_AS_U14(iSrcReg);
2848	if (pfnGetReg(pOldState, uReg, puValue))
2849	{
2850	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_register: %#RX64\n", uReg, *puValue));
2851	return VINF_SUCCESS;
2852	}
2853	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_register: VERR_NOT_FOUND\n", uReg));
2854	return VERR_NOT_FOUND;
2855	}
2856
2857	case DW_CFA_expression:
2858	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_expression: TODO\n", uReg));
2859	AssertFailedReturn(VERR_DWARF_TODO);
2860
2861	case DW_CFA_val_expression:
2862	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_val_expression: TODO\n", uReg));
2863	AssertFailedReturn(VERR_DWARF_TODO);
2864
2865	case DW_CFA_undefined:
2866	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_undefined\n", uReg));
2867	return VERR_NOT_FOUND;
2868
2869	case DW_CFA_same_value:
2870	if (pfnGetReg(pOldState, uReg, puValue))
2871	{
2872	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_same_value: %#RX64\n", uReg, *puValue));
2873	return VINF_SUCCESS;
2874	}
2875	Log8(("rtDwarfUnwind_CalcRegisterValue(%#x): DW_CFA_same_value: VERR_NOT_FOUND\n", uReg));
2876	return VERR_NOT_FOUND;
2877	}
2878	}
2879
2880
2881	DECLINLINE(void) rtDwarfUnwind_UpdateX86GRegFromRow(PRTDBGUNWINDSTATE pState, PCRTDBGUNWINDSTATE pOldState, unsigned idxGReg,
2882	PRTDWARFCFROW pRow, unsigned idxDwReg, PCRTDWARFCIEINFO pCie,
2883	uint64_t uCfa, PFNDWARFUNWINDGEREGFROMSTATE pfnGetReg, uint8_t cbGReg)
2884	{
2885	int rc = rtDwarfUnwind_CalcRegisterValue(pRow, idxDwReg, pCie, uCfa, pState, pOldState, pfnGetReg,
2886	&pState->u.x86.auRegs[idxGReg], cbGReg);
2887	if (RT_SUCCESS(rc))
2888	pState->u.x86.Loaded.s.fRegs \|= RT_BIT_32(idxGReg);
2889	}
2890
2891
2892	DECLINLINE(void) rtDwarfUnwind_UpdateX86SRegFromRow(PRTDBGUNWINDSTATE pState, PCRTDBGUNWINDSTATE pOldState, unsigned idxSReg,
2893	PRTDWARFCFROW pRow, unsigned idxDwReg, PCRTDWARFCIEINFO pCie,
2894	uint64_t uCfa, PFNDWARFUNWINDGEREGFROMSTATE pfnGetReg)
2895	{
2896	uint64_t uValue = pState->u.x86.auSegs[idxSReg];
2897	int rc = rtDwarfUnwind_CalcRegisterValue(pRow, idxDwReg, pCie, uCfa, pState, pOldState, pfnGetReg, &uValue, sizeof(uint16_t));
2898	if (RT_SUCCESS(rc))
2899	{
2900	pState->u.x86.auSegs[idxSReg] = (uint16_t)uValue;
2901	pState->u.x86.Loaded.s.fSegs \|= RT_BIT_32(idxSReg);
2902	}
2903	}
2904
2905
2906	DECLINLINE(void) rtDwarfUnwind_UpdateX86RFlagsFromRow(PRTDBGUNWINDSTATE pState, PCRTDBGUNWINDSTATE pOldState,
2907	PRTDWARFCFROW pRow, unsigned idxDwReg, PCRTDWARFCIEINFO pCie,
2908	uint64_t uCfa, PFNDWARFUNWINDGEREGFROMSTATE pfnGetReg)
2909	{
2910	int rc = rtDwarfUnwind_CalcRegisterValue(pRow, idxDwReg, pCie, uCfa, pState, pOldState, pfnGetReg,
2911	&pState->u.x86.uRFlags, sizeof(uint32_t));
2912	if (RT_SUCCESS(rc))
2913	pState->u.x86.Loaded.s.fRFlags = 1;
2914	}
2915
2916
2917	DECLINLINE(void) rtDwarfUnwind_UpdatePCFromRow(PRTDBGUNWINDSTATE pState, PCRTDBGUNWINDSTATE pOldState,
2918	PRTDWARFCFROW pRow, unsigned idxDwReg, PCRTDWARFCIEINFO pCie,
2919	uint64_t uCfa, PFNDWARFUNWINDGEREGFROMSTATE pfnGetReg, uint8_t cbPc)
2920	{
2921	if (pCie->bRetReg != UINT8_MAX)
2922	idxDwReg = pCie->bRetReg;
2923	int rc = rtDwarfUnwind_CalcRegisterValue(pRow, idxDwReg, pCie, uCfa, pState, pOldState, pfnGetReg, &pState->uPc, cbPc);
2924	if (RT_SUCCESS(rc))
2925	pState->u.x86.Loaded.s.fPc = 1;
2926	else
2927	{
2928	rc = pState->pfnReadStack(pState, uCfa - cbPc, cbPc, &pState->uPc);
2929	if (RT_SUCCESS(rc))
2930	pState->u.x86.Loaded.s.fPc = 1;
2931	}
2932	}
2933
2934
2935
2936	/**
2937	* Updates @a pState with the rules found in @a pRow.
2938	*
2939	* @returns IPRT status code.
2940	* @param pState The unwind state to update.
2941	* @param pRow The "row" in the dwarf unwind table.
2942	* @param pCie The CIE structure for the row.
2943	* @param enmImageArch The image architecture.
2944	*/
2945	static int rtDwarfUnwind_UpdateStateFromRow(PRTDBGUNWINDSTATE pState, PRTDWARFCFROW pRow,
2946	PCRTDWARFCIEINFO pCie, RTLDRARCH enmImageArch)
2947	{
2948	/*
2949	* We need to make a copy of the current state so we can get at the
2950	* current register values while calculating the ones of the next frame.
2951	*/
2952	RTDBGUNWINDSTATE const Old = *pState;
2953
2954	/*
2955	* Get the register state getter.
2956	*/
2957	PFNDWARFUNWINDGEREGFROMSTATE pfnGetReg;
2958	switch (enmImageArch)
2959	{
2960	case RTLDRARCH_AMD64:
2961	pfnGetReg = rtDwarfUnwind_Amd64GetRegFromState;
2962	break;
2963	case RTLDRARCH_X86_32:
2964	case RTLDRARCH_X86_16:
2965	pfnGetReg = rtDwarfUnwind_X86GetRegFromState;
2966	break;
2967	default:
2968	return VERR_NOT_SUPPORTED;
2969	}
2970
2971	/*
2972	* Calc the canonical frame address for the current row.
2973	*/
2974	AssertReturn(pRow->fCfaDefined, VERR_DBG_MALFORMED_UNWIND_INFO);
2975	uint64_t uCfa = 0;
2976	if (!pRow->pbCfaExprInstr)
2977	{
2978	pfnGetReg(&Old, pRow->uCfaBaseReg, &uCfa);
2979	uCfa += pRow->offCfaReg;
2980	}
2981	else
2982	{
2983	AssertFailed();
2984	return VERR_DWARF_TODO;
2985	}
2986	Log8(("rtDwarfUnwind_UpdateStateFromRow: uCfa=%RX64\n", uCfa));
2987
2988	/*
2989	* Do the architecture specific register updating.
2990	*/
2991	switch (enmImageArch)
2992	{
2993	case RTLDRARCH_AMD64:
2994	pState->enmRetType = RTDBGRETURNTYPE_NEAR64;
2995	pState->u.x86.FrameAddr.off = uCfa - 8*2;
2996	pState->u.x86.Loaded.fAll = 0;
2997	pState->u.x86.Loaded.s.fFrameAddr = 1;
2998	rtDwarfUnwind_UpdatePCFromRow(pState, &Old, pRow, DWREG_AMD64_RA, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
2999	rtDwarfUnwind_UpdateX86RFlagsFromRow(pState, &Old, pRow, DWREG_AMD64_RFLAGS, pCie, uCfa, pfnGetReg);
3000	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xAX, pRow, DWREG_AMD64_RAX, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3001	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xCX, pRow, DWREG_AMD64_RCX, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3002	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xDX, pRow, DWREG_AMD64_RDX, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3003	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xBX, pRow, DWREG_AMD64_RBX, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3004	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xSP, pRow, DWREG_AMD64_RSP, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3005	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xBP, pRow, DWREG_AMD64_RBP, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3006	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xSI, pRow, DWREG_AMD64_RSI, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3007	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xDI, pRow, DWREG_AMD64_RDI, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3008	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_x8, pRow, DWREG_AMD64_R8, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3009	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_x9, pRow, DWREG_AMD64_R9, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3010	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_x10, pRow, DWREG_AMD64_R10, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3011	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_x11, pRow, DWREG_AMD64_R11, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3012	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_x12, pRow, DWREG_AMD64_R12, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3013	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_x13, pRow, DWREG_AMD64_R13, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3014	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_x14, pRow, DWREG_AMD64_R14, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3015	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_x15, pRow, DWREG_AMD64_R15, pCie, uCfa, pfnGetReg, sizeof(uint64_t));
3016	rtDwarfUnwind_UpdateX86SRegFromRow(pState, &Old, X86_SREG_ES, pRow, DWREG_AMD64_ES, pCie, uCfa, pfnGetReg);
3017	rtDwarfUnwind_UpdateX86SRegFromRow(pState, &Old, X86_SREG_CS, pRow, DWREG_AMD64_CS, pCie, uCfa, pfnGetReg);
3018	rtDwarfUnwind_UpdateX86SRegFromRow(pState, &Old, X86_SREG_SS, pRow, DWREG_AMD64_SS, pCie, uCfa, pfnGetReg);
3019	rtDwarfUnwind_UpdateX86SRegFromRow(pState, &Old, X86_SREG_DS, pRow, DWREG_AMD64_DS, pCie, uCfa, pfnGetReg);
3020	rtDwarfUnwind_UpdateX86SRegFromRow(pState, &Old, X86_SREG_FS, pRow, DWREG_AMD64_FS, pCie, uCfa, pfnGetReg);
3021	rtDwarfUnwind_UpdateX86SRegFromRow(pState, &Old, X86_SREG_GS, pRow, DWREG_AMD64_GS, pCie, uCfa, pfnGetReg);
3022	break;
3023
3024	case RTLDRARCH_X86_32:
3025	case RTLDRARCH_X86_16:
3026	pState->enmRetType = RTDBGRETURNTYPE_NEAR32;
3027	pState->u.x86.FrameAddr.off = uCfa - 4*2;
3028	pState->u.x86.Loaded.fAll = 0;
3029	pState->u.x86.Loaded.s.fFrameAddr = 1;
3030	rtDwarfUnwind_UpdatePCFromRow(pState, &Old, pRow, DWREG_X86_RA, pCie, uCfa, pfnGetReg, sizeof(uint32_t));
3031	rtDwarfUnwind_UpdateX86RFlagsFromRow(pState, &Old, pRow, DWREG_X86_EFLAGS, pCie, uCfa, pfnGetReg);
3032	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xAX, pRow, DWREG_X86_EAX, pCie, uCfa, pfnGetReg, sizeof(uint32_t));
3033	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xCX, pRow, DWREG_X86_ECX, pCie, uCfa, pfnGetReg, sizeof(uint32_t));
3034	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xDX, pRow, DWREG_X86_EDX, pCie, uCfa, pfnGetReg, sizeof(uint32_t));
3035	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xBX, pRow, DWREG_X86_EBX, pCie, uCfa, pfnGetReg, sizeof(uint32_t));
3036	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xSP, pRow, DWREG_X86_ESP, pCie, uCfa, pfnGetReg, sizeof(uint32_t));
3037	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xBP, pRow, DWREG_X86_EBP, pCie, uCfa, pfnGetReg, sizeof(uint32_t));
3038	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xSI, pRow, DWREG_X86_ESI, pCie, uCfa, pfnGetReg, sizeof(uint32_t));
3039	rtDwarfUnwind_UpdateX86GRegFromRow(pState, &Old, X86_GREG_xDI, pRow, DWREG_X86_EDI, pCie, uCfa, pfnGetReg, sizeof(uint32_t));
3040	rtDwarfUnwind_UpdateX86SRegFromRow(pState, &Old, X86_SREG_ES, pRow, DWREG_X86_ES, pCie, uCfa, pfnGetReg);
3041	rtDwarfUnwind_UpdateX86SRegFromRow(pState, &Old, X86_SREG_CS, pRow, DWREG_X86_CS, pCie, uCfa, pfnGetReg);
3042	rtDwarfUnwind_UpdateX86SRegFromRow(pState, &Old, X86_SREG_SS, pRow, DWREG_X86_SS, pCie, uCfa, pfnGetReg);
3043	rtDwarfUnwind_UpdateX86SRegFromRow(pState, &Old, X86_SREG_DS, pRow, DWREG_X86_DS, pCie, uCfa, pfnGetReg);
3044	rtDwarfUnwind_UpdateX86SRegFromRow(pState, &Old, X86_SREG_FS, pRow, DWREG_X86_FS, pCie, uCfa, pfnGetReg);
3045	rtDwarfUnwind_UpdateX86SRegFromRow(pState, &Old, X86_SREG_GS, pRow, DWREG_X86_GS, pCie, uCfa, pfnGetReg);
3046	if (pState->u.x86.Loaded.s.fRegs & RT_BIT_32(X86_GREG_xSP))
3047	pState->u.x86.FrameAddr.off = pState->u.x86.auRegs[X86_GREG_xSP] - 8;
3048	else
3049	pState->u.x86.FrameAddr.off = uCfa - 8;
3050	pState->u.x86.FrameAddr.sel = pState->u.x86.auSegs[X86_SREG_SS];
3051	if (pState->u.x86.Loaded.s.fSegs & RT_BIT_32(X86_SREG_CS))
3052	{
3053	if ((pState->uPc >> 16) == pState->u.x86.auSegs[X86_SREG_CS])
3054	{
3055	pState->enmRetType = RTDBGRETURNTYPE_FAR16;
3056	pState->uPc &= UINT16_MAX;
3057	Log8(("rtDwarfUnwind_UpdateStateFromRow: Detected FAR16 return to %04x:%04RX64\n", pState->u.x86.auSegs[X86_SREG_CS], pState->uPc));
3058	}
3059	else
3060	{
3061	pState->enmRetType = RTDBGRETURNTYPE_FAR32;
3062	Log8(("rtDwarfUnwind_UpdateStateFromRow: CS loaded, assume far return.\n"));
3063	}
3064	}
3065	break;
3066
3067	default:
3068	AssertFailedReturn(VERR_NOT_SUPPORTED);
3069	}
3070
3071	return VINF_SUCCESS;
3072	}
3073
3074
3075	/**
3076	* Processes a FDE, taking over after the PC range field.
3077	*
3078	* @returns IPRT status code.
3079	* @param pCursor The cursor.
3080	* @param pCie Information about the corresponding CIE.
3081	* @param uPcBegin The PC begin field value (sans segment).
3082	* @param cbPcRange The PC range from @a uPcBegin.
3083	* @param offInRange The offset into the range corresponding to
3084	* pState->uPc.
3085	* @param enmImageArch The image architecture.
3086	* @param pState The unwind state to work.
3087	*/
3088	static int rtDwarfUnwind_ProcessFde(PRTDWARFCURSOR pCursor, PCRTDWARFCIEINFO pCie, uint64_t uPcBegin,
3089	uint64_t cbPcRange, uint64_t offInRange, RTLDRARCH enmImageArch, PRTDBGUNWINDSTATE pState)
3090	{
3091	/*
3092	* Deal with augmented data fields.
3093	*/
3094	/* The size. */
3095	size_t cbInstr = ~(size_t)0;
3096	if (pCie->fHasAugmentationSize)
3097	{
3098	uint64_t cbAugData = rtDwarfCursor_GetULeb128(pCursor, UINT64_MAX);
3099	if (RT_FAILURE(pCursor->rc))
3100	return pCursor->rc;
3101	if (cbAugData > pCursor->cbUnitLeft)
3102	return VERR_DBG_MALFORMED_UNWIND_INFO;
3103	cbInstr = pCursor->cbUnitLeft - cbAugData;
3104	}
3105	else if (pCie->fHasUnknowAugmentation)
3106	return VERR_DBG_MALFORMED_UNWIND_INFO;
3107
3108	/* Parse the string and fetch FDE fields. */
3109	if (!pCie->fHasEhData)
3110	for (const char pszAug = pCie->pszAugmentation; pszAug != '\0'; pszAug++)
3111	switch (*pszAug)
3112	{
3113	case 'L':
3114	if (pCie->bLsdaPtrEnc != DW_EH_PE_omit)
3115	rtDwarfCursor_GetPtrEnc(pCursor, pCie->bLsdaPtrEnc, 0);
3116	break;
3117	}
3118
3119	/* Skip unconsumed bytes. */
3120	if ( cbInstr != ~(size_t)0
3121	&& pCursor->cbUnitLeft > cbInstr)
3122	rtDwarfCursor_SkipBytes(pCursor, pCursor->cbUnitLeft - cbInstr);
3123	if (RT_FAILURE(pCursor->rc))
3124	return pCursor->rc;
3125
3126	/*
3127	* Now "execute" the programs till we've constructed the desired row.
3128	*/
3129	RTDWARFCFROW Row;
3130	RTDWARFCFEXEC ExecState = { &Row, offInRange, 0, true /** @todo byte-order*/, pCie, uPcBegin, offInRange };
3131	RT_ZERO(Row);
3132
3133	int rc = rtDwarfUnwind_Execute(&ExecState, pCie->pbInstructions, (uint32_t)pCie->cbInstructions);
3134	if (rc == VINF_TRY_AGAIN)
3135	rc = rtDwarfUnwind_Execute(&ExecState, pCursor->pb, (uint32_t)pCursor->cbUnitLeft);
3136
3137	/* On success, extract whatever state we've got. */
3138	if (RT_SUCCESS(rc))
3139	rc = rtDwarfUnwind_UpdateStateFromRow(pState, &Row, pCie, enmImageArch);
3140
3141	/*
3142	* Clean up allocations in case of pushes.
3143	*/
3144	if (ExecState.pRow == &Row)
3145	Assert(!ExecState.pRow->fOnHeap);
3146	else
3147	do
3148	{
3149	PRTDWARFCFROW pPopped = ExecState.pRow;
3150	ExecState.pRow = ExecState.pRow->pNextOnStack;
3151	Assert(pPopped->fOnHeap);
3152	RTMemTmpFree(pPopped);
3153	} while (ExecState.pRow && ExecState.pRow != &Row);
3154
3155	RT_NOREF(pState, uPcBegin, cbPcRange, offInRange);
3156	return rc;
3157	}
3158
3159
3160	/**
3161	* Load the information we need from a CIE.
3162	*
3163	* This starts after the initial length and CIE_pointer fields has
3164	* been processed.
3165	*
3166	* @returns IPRT status code.
3167	* @param pCursor The cursor.
3168	* @param pNewCie The structure to populate with parsed CIE info.
3169	* @param offUnit The unit offset.
3170	* @param bDefaultPtrEnc The default pointer encoding.
3171	*/
3172	static int rtDwarfUnwind_LoadCie(PRTDWARFCURSOR pCursor, PRTDWARFCIEINFO pNewCie, uint64_t offUnit, uint8_t bDefaultPtrEnc)
3173	{
3174	/*
3175	* Initialize the CIE record and get the version.
3176	*/
3177	RT_ZERO(*pNewCie);
3178	pNewCie->offCie = offUnit;
3179	pNewCie->bLsdaPtrEnc = DW_EH_PE_omit;
3180	pNewCie->bAddressPtrEnc = DW_EH_PE_omit; /* set later */
3181	pNewCie->uDwarfVer = rtDwarfCursor_GetUByte(pCursor, 0);
3182	if ( pNewCie->uDwarfVer >= 1 /* Note! Some GCC versions may emit v1 here. */
3183	&& pNewCie->uDwarfVer <= 5)
3184	{ /* likely */ }
3185	else
3186	{
3187	Log(("rtDwarfUnwind_LoadCie(%RX64): uDwarfVer=%u: VERR_VERSION_MISMATCH\n", offUnit, pNewCie->uDwarfVer));
3188	return VERR_VERSION_MISMATCH;
3189	}
3190
3191	/*
3192	* The augmentation string.
3193	*
3194	* First deal with special "eh" string from oldish GCC (dwarf2out.c about 1997), specified in LSB:
3195	* https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA/ehframechpt.html
3196	*/
3197	pNewCie->pszAugmentation = rtDwarfCursor_GetSZ(pCursor, "");
3198	if ( pNewCie->pszAugmentation[0] == 'e'
3199	&& pNewCie->pszAugmentation[1] == 'h'
3200	&& pNewCie->pszAugmentation[2] == '\0')
3201	{
3202	pNewCie->fHasEhData = true;
3203	rtDwarfCursor_GetPtrEnc(pCursor, bDefaultPtrEnc, 0);
3204	}
3205	else
3206	{
3207	/* Regular augmentation string. */
3208	for (const char pszAug = pNewCie->pszAugmentation; pszAug != '\0'; pszAug++)
3209	switch (*pszAug)
3210	{
3211	case 'z':
3212	pNewCie->fHasAugmentationSize = true;
3213	break;
3214	case 'L':
3215	pNewCie->fHasLanguageSpecificDataArea = true;
3216	break;
3217	case 'P':
3218	pNewCie->fHasPersonalityRoutine = true;
3219	break;
3220	case 'R':
3221	pNewCie->fHasAddressEnc = true;
3222	break;
3223	case 'S':
3224	pNewCie->fIsSignalFrame = true;
3225	break;
3226	default:
3227	pNewCie->fHasUnknowAugmentation = true;
3228	break;
3229	}
3230	}
3231
3232	/*
3233	* More standard fields
3234	*/
3235	uint8_t cbAddress = 0;
3236	if (pNewCie->uDwarfVer >= 4)
3237	{
3238	cbAddress = rtDwarfCursor_GetU8(pCursor, bDefaultPtrEnc == DW_EH_PE_udata8 ? 8 : 4);
3239	pNewCie->cbSegment = rtDwarfCursor_GetU8(pCursor, 0);
3240	}
3241	pNewCie->uCodeAlignFactor = rtDwarfCursor_GetULeb128(pCursor, 1);
3242	pNewCie->iDataAlignFactor = rtDwarfCursor_GetSLeb128(pCursor, 1);
3243	pNewCie->bRetReg = rtDwarfCursor_GetU8(pCursor, UINT8_MAX);
3244
3245	/*
3246	* Augmentation data.
3247	*/
3248	if (!pNewCie->fHasEhData)
3249	{
3250	/* The size. */
3251	size_t cbInstr = ~(size_t)0;
3252	if (pNewCie->fHasAugmentationSize)
3253	{
3254	uint64_t cbAugData = rtDwarfCursor_GetULeb128(pCursor, UINT64_MAX);
3255	if (RT_FAILURE(pCursor->rc))
3256	{
3257	Log(("rtDwarfUnwind_LoadCie(%#RX64): rtDwarfCursor_GetULeb128 -> %Rrc!\n", offUnit, pCursor->rc));
3258	return pCursor->rc;
3259	}
3260	if (cbAugData > pCursor->cbUnitLeft)
3261	{
3262	Log(("rtDwarfUnwind_LoadCie(%#RX64): cbAugData=%#x pCursor->cbUnitLeft=%#x -> VERR_DBG_MALFORMED_UNWIND_INFO!\n", offUnit, cbAugData, pCursor->cbUnitLeft));
3263	return VERR_DBG_MALFORMED_UNWIND_INFO;
3264	}
3265	cbInstr = pCursor->cbUnitLeft - cbAugData;
3266	}
3267	else if (pNewCie->fHasUnknowAugmentation)
3268	{
3269	Log(("rtDwarfUnwind_LoadCie(%#RX64): fHasUnknowAugmentation=1 -> VERR_DBG_MALFORMED_UNWIND_INFO!\n", offUnit));
3270	return VERR_DBG_MALFORMED_UNWIND_INFO;
3271	}
3272
3273	/* Parse the string. */
3274	for (const char pszAug = pNewCie->pszAugmentation; pszAug != '\0'; pszAug++)
3275	switch (*pszAug)
3276	{
3277	case 'L':
3278	pNewCie->bLsdaPtrEnc = rtDwarfCursor_GetU8(pCursor, DW_EH_PE_omit);
3279	break;
3280	case 'P':
3281	rtDwarfCursor_GetPtrEnc(pCursor, rtDwarfCursor_GetU8(pCursor, DW_EH_PE_omit), 0);
3282	break;
3283	case 'R':
3284	pNewCie->bAddressPtrEnc = rtDwarfCursor_GetU8(pCursor, DW_EH_PE_omit);
3285	break;
3286	}
3287
3288	/* Skip unconsumed bytes. */
3289	if ( cbInstr != ~(size_t)0
3290	&& pCursor->cbUnitLeft > cbInstr)
3291	rtDwarfCursor_SkipBytes(pCursor, pCursor->cbUnitLeft - cbInstr);
3292	}
3293
3294	/*
3295	* Note down where the instructions are.
3296	*/
3297	pNewCie->pbInstructions = pCursor->pb;
3298	pNewCie->cbInstructions = pCursor->cbUnitLeft;
3299
3300	/*
3301	* Determine the target address encoding. Make sure we resolve DW_EH_PE_ptr.
3302	*/
3303	if (pNewCie->bAddressPtrEnc == DW_EH_PE_omit)
3304	switch (cbAddress)
3305	{
3306	case 2: pNewCie->bAddressPtrEnc = DW_EH_PE_udata2; break;
3307	case 4: pNewCie->bAddressPtrEnc = DW_EH_PE_udata4; break;
3308	case 8: pNewCie->bAddressPtrEnc = DW_EH_PE_udata8; break;
3309	default: pNewCie->bAddressPtrEnc = bDefaultPtrEnc; break;
3310	}
3311	else if ((pNewCie->bAddressPtrEnc & DW_EH_PE_FORMAT_MASK) == DW_EH_PE_ptr)
3312	pNewCie->bAddressPtrEnc = bDefaultPtrEnc;
3313
3314	return VINF_SUCCESS;
3315	}
3316
3317
3318	/**
3319	* Does a slow unwind of a '.debug_frame' or '.eh_frame' section.
3320	*
3321	* @returns IPRT status code.
3322	* @param pCursor The cursor.
3323	* @param uRvaCursor The RVA corrsponding to the cursor start location.
3324	* @param idxSeg The segment of the PC location.
3325	* @param offSeg The segment offset of the PC location.
3326	* @param uRva The RVA of the PC location.
3327	* @param pState The unwind state to work.
3328	* @param bDefaultPtrEnc The default pointer encoding.
3329	* @param fIsEhFrame Set if this is a '.eh_frame'. GCC generate these
3330	* with different CIE_pointer values.
3331	* @param enmImageArch The image architecture.
3332	*/
3333	static int rtDwarfUnwind_Slow(PRTDWARFCURSOR pCursor, RTUINTPTR uRvaCursor,
3334	RTDBGSEGIDX idxSeg, RTUINTPTR offSeg, RTUINTPTR uRva,
3335	PRTDBGUNWINDSTATE pState, uint8_t bDefaultPtrEnc, bool fIsEhFrame, RTLDRARCH enmImageArch)
3336	{
3337	Log8(("rtDwarfUnwind_Slow: idxSeg=%#x offSeg=%RTptr uRva=%RTptr enmArch=%d PC=%#RX64\n", idxSeg, offSeg, uRva, pState->enmArch, pState->uPc));
3338
3339	/*
3340	* CIE info we collect.
3341	*/
3342	PRTDWARFCIEINFO paCies = NULL;
3343	uint32_t cCies = 0;
3344	PRTDWARFCIEINFO pCieHint = NULL;
3345
3346	/*
3347	* Do the scanning.
3348	*/
3349	uint64_t const offCieOffset = pCursor->f64bitDwarf ? UINT64_MAX : UINT32_MAX;
3350	int rc = VERR_DBG_UNWIND_INFO_NOT_FOUND;
3351	while (!rtDwarfCursor_IsAtEnd(pCursor))
3352	{
3353	uint64_t const offUnit = rtDwarfCursor_CalcSectOffsetU32(pCursor);
3354	if (rtDwarfCursor_GetInitialLength(pCursor) == 0)
3355	break;
3356
3357	uint64_t const offRelCie = rtDwarfCursor_GetUOff(pCursor, offCieOffset);
3358	if (offRelCie != offCieOffset)
3359	{
3360	/*
3361	* Frame descriptor entry (FDE).
3362	*/
3363	/* Locate the corresponding CIE. The CIE pointer is self relative
3364	in .eh_frame and section relative in .debug_frame. */
3365	PRTDWARFCIEINFO pCieForFde;
3366	uint64_t offCie = fIsEhFrame ? offUnit + 4 - offRelCie : offRelCie;
3367	if (pCieHint && pCieHint->offCie == offCie)
3368	pCieForFde = pCieHint;
3369	else
3370	{
3371	pCieForFde = NULL;
3372	uint32_t i = cCies;
3373	while (i-- > 0)
3374	if (paCies[i].offCie == offCie)
3375	{
3376	pCieHint = pCieForFde = &paCies[i];
3377	break;
3378	}
3379	}
3380	if (pCieForFde)
3381	{
3382	/* Read the PC range covered by this FDE (the fields are also known as initial_location). */
3383	RTDBGSEGIDX idxFdeSeg = RTDBGSEGIDX_RVA;
3384	if (pCieForFde->cbSegment)
3385	idxFdeSeg = rtDwarfCursor_GetVarSizedU(pCursor, pCieForFde->cbSegment, RTDBGSEGIDX_RVA);
3386	uint64_t uPcBegin;
3387	switch (pCieForFde->bAddressPtrEnc & DW_EH_PE_APPL_MASK)
3388	{
3389	default: AssertFailed();
3390	RT_FALL_THRU();
3391	case DW_EH_PE_absptr:
3392	uPcBegin = rtDwarfCursor_GetPtrEnc(pCursor, pCieForFde->bAddressPtrEnc, 0);
3393	break;
3394	case DW_EH_PE_pcrel:
3395	{
3396	uPcBegin = rtDwarfCursor_CalcSectOffsetU32(pCursor) + uRvaCursor;
3397	uPcBegin += rtDwarfCursor_GetPtrEnc(pCursor, pCieForFde->bAddressPtrEnc, 0);
3398	break;
3399	}
3400	}
3401	uint64_t cbPcRange = rtDwarfCursor_GetPtrEnc(pCursor, pCieForFde->bAddressPtrEnc, 0);
3402
3403	/* Match it with what we're looking for. */
3404	bool fMatch = idxFdeSeg == RTDBGSEGIDX_RVA
3405	? uRva - uPcBegin < cbPcRange
3406	: idxSeg == idxFdeSeg && offSeg - uPcBegin < cbPcRange;
3407	Log8(("%#08RX64: FDE pCie=%p idxFdeSeg=%#x uPcBegin=%#RX64 cbPcRange=%#x fMatch=%d\n",
3408	offUnit, pCieForFde, idxFdeSeg, uPcBegin, cbPcRange, fMatch));
3409	if (fMatch)
3410	{
3411	rc = rtDwarfUnwind_ProcessFde(pCursor, pCieForFde, uPcBegin, cbPcRange,
3412	idxFdeSeg == RTDBGSEGIDX_RVA ? uRva - uPcBegin : offSeg - uPcBegin,
3413	enmImageArch, pState);
3414	break;
3415	}
3416	}
3417	else
3418	Log8(("%#08RX64: FDE - pCie=NULL!! offCie=%#RX64 offRelCie=%#RX64 fIsEhFrame=%d\n", offUnit, offCie, offRelCie, fIsEhFrame));
3419	}
3420	else
3421	{
3422	/*
3423	* Common information entry (CIE). Record the info we need about it.
3424	*/
3425	if ((cCies % 8) == 0)
3426	{
3427	void pvNew = RTMemRealloc(paCies, sizeof(paCies[0]) (cCies + 8));
3428	if (pvNew)
3429	{
3430	paCies = (PRTDWARFCIEINFO)pvNew;
3431	pCieHint = NULL;
3432	}
3433	else
3434	{
3435	rc = VERR_NO_MEMORY;
3436	break;
3437	}
3438	}
3439	Log8(("%#08RX64: CIE\n", offUnit));
3440	int rc2 = rtDwarfUnwind_LoadCie(pCursor, &paCies[cCies], offUnit, bDefaultPtrEnc);
3441	if (RT_SUCCESS(rc2))
3442	{
3443	Log8(("%#08RX64: CIE #%u: offCie=%#RX64\n", offUnit, cCies, paCies[cCies].offCie));
3444	cCies++;
3445	}
3446	}
3447	rtDwarfCursor_SkipUnit(pCursor);
3448	}
3449
3450	/*
3451	* Cleanup.
3452	*/
3453	if (paCies)
3454	RTMemFree(paCies);
3455	Log8(("rtDwarfUnwind_Slow: returns %Rrc PC=%#RX64\n", rc, pState->uPc));
3456	return rc;
3457	}
3458
3459
3460	/**
3461	* Helper for translating a loader architecture value to a pointe encoding.
3462	*
3463	* @returns Pointer encoding.
3464	* @param enmLdrArch The loader architecture value to convert.
3465	*/
3466	static uint8_t rtDwarfUnwind_ArchToPtrEnc(RTLDRARCH enmLdrArch)
3467	{
3468	switch (enmLdrArch)
3469	{
3470	case RTLDRARCH_AMD64:
3471	case RTLDRARCH_ARM64:
3472	return DW_EH_PE_udata8;
3473	case RTLDRARCH_X86_16:
3474	case RTLDRARCH_X86_32:
3475	case RTLDRARCH_ARM32:
3476	return DW_EH_PE_udata4;
3477	case RTLDRARCH_HOST:
3478	case RTLDRARCH_WHATEVER:
3479	case RTLDRARCH_INVALID:
3480	case RTLDRARCH_END:
3481	case RTLDRARCH_32BIT_HACK:
3482	break;
3483	}
3484	AssertFailed();
3485	return DW_EH_PE_udata4;
3486	}
3487
3488
3489	/**
3490	* Interface for the loader code.
3491	*
3492	* @returns IPRT status.
3493	* @param pvSection The '.eh_frame' section data.
3494	* @param cbSection The size of the '.eh_frame' section data.
3495	* @param uRvaSection The RVA of the '.eh_frame' section.
3496	* @param idxSeg The segment of the PC location.
3497	* @param offSeg The segment offset of the PC location.
3498	* @param uRva The RVA of the PC location.
3499	* @param pState The unwind state to work.
3500	* @param enmArch The image architecture.
3501	*/
3502	DECLHIDDEN(int) rtDwarfUnwind_EhData(void const *pvSection, size_t cbSection, RTUINTPTR uRvaSection,
3503	RTDBGSEGIDX idxSeg, RTUINTPTR offSeg, RTUINTPTR uRva,
3504	PRTDBGUNWINDSTATE pState, RTLDRARCH enmArch)
3505	{
3506	RTDWARFCURSOR Cursor;
3507	rtDwarfCursor_InitForMem(&Cursor, pvSection, cbSection);
3508	int rc = rtDwarfUnwind_Slow(&Cursor, uRvaSection, idxSeg, offSeg, uRva, pState,
3509	rtDwarfUnwind_ArchToPtrEnc(enmArch), true /fIsEhFrame/, enmArch);
3510	LogFlow(("rtDwarfUnwind_EhData: rtDwarfUnwind_Slow -> %Rrc\n", rc));
3511	rc = rtDwarfCursor_Delete(&Cursor, rc);
3512	LogFlow(("rtDwarfUnwind_EhData: returns %Rrc\n", rc));
3513	return rc;
3514	}
3515
3516
3517	/*
3518	*
3519	* DWARF Line Numbers.
3520	* DWARF Line Numbers.
3521	* DWARF Line Numbers.
3522	*
3523	*/
3524
3525
3526	/**
3527	* Defines a file name.
3528	*
3529	* @returns IPRT status code.
3530	* @param pLnState The line number program state.
3531	* @param pszFilename The name of the file.
3532	* @param idxInc The include path index.
3533	*/
3534	static int rtDwarfLine_DefineFileName(PRTDWARFLINESTATE pLnState, const char *pszFilename, uint64_t idxInc)
3535	{
3536	/*
3537	* Resize the array if necessary.
3538	*/
3539	uint32_t iFileName = pLnState->cFileNames;
3540	if ((iFileName % 2) == 0)
3541	{
3542	void pv = RTMemRealloc(pLnState->papszFileNames, sizeof(pLnState->papszFileNames[0]) (iFileName + 2));
3543	if (!pv)
3544	return VERR_NO_MEMORY;
3545	pLnState->papszFileNames = (char **)pv;
3546	}
3547
3548	/*
3549	* Add the file name.
3550	*/
3551	if ( pszFilename[0] == '/'
3552	\|\| pszFilename[0] == '\\'
3553	\|\| (RT_C_IS_ALPHA(pszFilename[0]) && pszFilename[1] == ':') )
3554	pLnState->papszFileNames[iFileName] = RTStrDup(pszFilename);
3555	else if (idxInc < pLnState->cIncPaths)
3556	pLnState->papszFileNames[iFileName] = RTPathJoinA(pLnState->papszIncPaths[idxInc], pszFilename);
3557	else
3558	return VERR_DWARF_BAD_LINE_NUMBER_HEADER;
3559	if (!pLnState->papszFileNames[iFileName])
3560	return VERR_NO_STR_MEMORY;
3561	pLnState->cFileNames = iFileName + 1;
3562
3563	/*
3564	* Sanitize the name.
3565	*/
3566	int rc = rtDbgModDwarfStringToUtf8(pLnState->pDwarfMod, &pLnState->papszFileNames[iFileName]);
3567	Log((" File #%02u = '%s'\n", iFileName, pLnState->papszFileNames[iFileName]));
3568	return rc;
3569	}
3570
3571
3572	/**
3573	* Adds a line to the table and resets parts of the state (DW_LNS_copy).
3574	*
3575	* @returns IPRT status code
3576	* @param pLnState The line number program state.
3577	* @param offOpCode The opcode offset (for logging
3578	* purposes).
3579	*/
3580	static int rtDwarfLine_AddLine(PRTDWARFLINESTATE pLnState, uint32_t offOpCode)
3581	{
3582	PRTDBGMODDWARF pThis = pLnState->pDwarfMod;
3583	int rc;
3584	if (pThis->iWatcomPass == 1)
3585	rc = rtDbgModDwarfRecordSegOffset(pThis, pLnState->Regs.uSegment, pLnState->Regs.uAddress + 1);
3586	else
3587	{
3588	const char *pszFile = pLnState->Regs.iFile < pLnState->cFileNames
3589	? pLnState->papszFileNames[pLnState->Regs.iFile]
3590	: "<bad file name index>";
3591	NOREF(offOpCode);
3592
3593	RTDBGSEGIDX iSeg;
3594	RTUINTPTR offSeg;
3595	rc = rtDbgModDwarfLinkAddressToSegOffset(pLnState->pDwarfMod, pLnState->Regs.uSegment, pLnState->Regs.uAddress,
3596	&iSeg, &offSeg); /AssertRC(rc);/
3597	if (RT_SUCCESS(rc))
3598	{
3599	Log2(("rtDwarfLine_AddLine: %x:%08llx (%#llx) %s(%d) [offOpCode=%08x]\n", iSeg, offSeg, pLnState->Regs.uAddress, pszFile, pLnState->Regs.uLine, offOpCode));
3600	rc = RTDbgModLineAdd(pLnState->pDwarfMod->hCnt, pszFile, pLnState->Regs.uLine, iSeg, offSeg, NULL);
3601
3602	/* Ignore address conflicts for now. */
3603	if (rc == VERR_DBG_ADDRESS_CONFLICT)
3604	rc = VINF_SUCCESS;
3605	}
3606	else
3607	rc = VINF_SUCCESS; /* ignore failure */
3608	}
3609
3610	pLnState->Regs.fBasicBlock = false;
3611	pLnState->Regs.fPrologueEnd = false;
3612	pLnState->Regs.fEpilogueBegin = false;
3613	pLnState->Regs.uDiscriminator = 0;
3614	return rc;
3615	}
3616
3617
3618	/**
3619	* Reset the program to the start-of-sequence state.
3620	*
3621	* @param pLnState The line number program state.
3622	*/
3623	static void rtDwarfLine_ResetState(PRTDWARFLINESTATE pLnState)
3624	{
3625	pLnState->Regs.uAddress = 0;
3626	pLnState->Regs.idxOp = 0;
3627	pLnState->Regs.iFile = 1;
3628	pLnState->Regs.uLine = 1;
3629	pLnState->Regs.uColumn = 0;
3630	pLnState->Regs.fIsStatement = RT_BOOL(pLnState->Hdr.u8DefIsStmt);
3631	pLnState->Regs.fBasicBlock = false;
3632	pLnState->Regs.fEndSequence = false;
3633	pLnState->Regs.fPrologueEnd = false;
3634	pLnState->Regs.fEpilogueBegin = false;
3635	pLnState->Regs.uIsa = 0;
3636	pLnState->Regs.uDiscriminator = 0;
3637	pLnState->Regs.uSegment = 0;
3638	}
3639
3640
3641	/**
3642	* Runs the line number program.
3643	*
3644	* @returns IPRT status code.
3645	* @param pLnState The line number program state.
3646	* @param pCursor The cursor.
3647	*/
3648	static int rtDwarfLine_RunProgram(PRTDWARFLINESTATE pLnState, PRTDWARFCURSOR pCursor)
3649	{
3650	LogFlow(("rtDwarfLine_RunProgram: cbUnitLeft=%zu\n", pCursor->cbUnitLeft));
3651
3652	int rc = VINF_SUCCESS;
3653	rtDwarfLine_ResetState(pLnState);
3654
3655	while (!rtDwarfCursor_IsAtEndOfUnit(pCursor))
3656	{
3657	#ifdef LOG_ENABLED
3658	uint32_t const offOpCode = rtDwarfCursor_CalcSectOffsetU32(pCursor);
3659	#else
3660	uint32_t const offOpCode = 0;
3661	#endif
3662	uint8_t bOpCode = rtDwarfCursor_GetUByte(pCursor, DW_LNS_extended);
3663	if (bOpCode >= pLnState->Hdr.u8OpcodeBase)
3664	{
3665	/*
3666	* Special opcode.
3667	*/
3668	uint8_t const bLogOpCode = bOpCode; NOREF(bLogOpCode);
3669	bOpCode -= pLnState->Hdr.u8OpcodeBase;
3670
3671	int32_t const cLineDelta = bOpCode % pLnState->Hdr.u8LineRange + (int32_t)pLnState->Hdr.s8LineBase;
3672	bOpCode /= pLnState->Hdr.u8LineRange;
3673
3674	uint64_t uTmp = bOpCode + pLnState->Regs.idxOp;
3675	uint64_t const cAddressDelta = uTmp / pLnState->Hdr.cMaxOpsPerInstr * pLnState->Hdr.cbMinInstr;
3676	uint64_t const cOpIndexDelta = uTmp % pLnState->Hdr.cMaxOpsPerInstr;
3677
3678	pLnState->Regs.uLine += cLineDelta;
3679	pLnState->Regs.uAddress += cAddressDelta;
3680	pLnState->Regs.idxOp += cOpIndexDelta;
3681	Log2(("%08x: DW Special Opcode %#04x: uLine + %d => %u; uAddress + %#llx => %#llx; idxOp + %#llx => %#llx\n",
3682	offOpCode, bLogOpCode, cLineDelta, pLnState->Regs.uLine, cAddressDelta, pLnState->Regs.uAddress,
3683	cOpIndexDelta, pLnState->Regs.idxOp));
3684
3685	/*
3686	* LLVM emits debug info for global constructors (_GLOBAL__I_a) which are not part of source
3687	* code but are inserted by the compiler: The resulting line number will be 0
3688	* because they are not part of the source file obviously (see https://reviews.llvm.org/rL205999),
3689	* so skip adding them when they are encountered.
3690	*/
3691	if (pLnState->Regs.uLine)
3692	rc = rtDwarfLine_AddLine(pLnState, offOpCode);
3693	}
3694	else
3695	{
3696	switch (bOpCode)
3697	{
3698	/*
3699	* Standard opcode.
3700	*/
3701	case DW_LNS_copy:
3702	Log2(("%08x: DW_LNS_copy\n", offOpCode));
3703	/* See the comment about LLVM above. */
3704	if (pLnState->Regs.uLine)
3705	rc = rtDwarfLine_AddLine(pLnState, offOpCode);
3706	break;
3707
3708	case DW_LNS_advance_pc:
3709	{
3710	uint64_t u64Adv = rtDwarfCursor_GetULeb128(pCursor, 0);
3711	pLnState->Regs.uAddress += (pLnState->Regs.idxOp + u64Adv) / pLnState->Hdr.cMaxOpsPerInstr
3712	* pLnState->Hdr.cbMinInstr;
3713	pLnState->Regs.idxOp += (pLnState->Regs.idxOp + u64Adv) % pLnState->Hdr.cMaxOpsPerInstr;
3714	Log2(("%08x: DW_LNS_advance_pc: u64Adv=%#llx (%lld) )\n", offOpCode, u64Adv, u64Adv));
3715	break;
3716	}
3717
3718	case DW_LNS_advance_line:
3719	{
3720	int32_t cLineDelta = rtDwarfCursor_GetSLeb128AsS32(pCursor, 0);
3721	pLnState->Regs.uLine += cLineDelta;
3722	Log2(("%08x: DW_LNS_advance_line: uLine + %d => %u\n", offOpCode, cLineDelta, pLnState->Regs.uLine));
3723	break;
3724	}
3725
3726	case DW_LNS_set_file:
3727	pLnState->Regs.iFile = rtDwarfCursor_GetULeb128AsU32(pCursor, 0);
3728	Log2(("%08x: DW_LNS_set_file: iFile=%u\n", offOpCode, pLnState->Regs.iFile));
3729	break;
3730
3731	case DW_LNS_set_column:
3732	pLnState->Regs.uColumn = rtDwarfCursor_GetULeb128AsU32(pCursor, 0);
3733	Log2(("%08x: DW_LNS_set_column\n", offOpCode));
3734	break;
3735
3736	case DW_LNS_negate_stmt:
3737	pLnState->Regs.fIsStatement = !pLnState->Regs.fIsStatement;
3738	Log2(("%08x: DW_LNS_negate_stmt\n", offOpCode));
3739	break;
3740
3741	case DW_LNS_set_basic_block:
3742	pLnState->Regs.fBasicBlock = true;
3743	Log2(("%08x: DW_LNS_set_basic_block\n", offOpCode));
3744	break;
3745
3746	case DW_LNS_const_add_pc:
3747	{
3748	uint8_t u8Adv = (255 - pLnState->Hdr.u8OpcodeBase) / pLnState->Hdr.u8LineRange;
3749	if (pLnState->Hdr.cMaxOpsPerInstr <= 1)
3750	pLnState->Regs.uAddress += (uint32_t)pLnState->Hdr.cbMinInstr * u8Adv;
3751	else
3752	{
3753	pLnState->Regs.uAddress += (pLnState->Regs.idxOp + u8Adv) / pLnState->Hdr.cMaxOpsPerInstr
3754	* pLnState->Hdr.cbMinInstr;
3755	pLnState->Regs.idxOp = (pLnState->Regs.idxOp + u8Adv) % pLnState->Hdr.cMaxOpsPerInstr;
3756	}
3757	Log2(("%08x: DW_LNS_const_add_pc\n", offOpCode));
3758	break;
3759	}
3760	case DW_LNS_fixed_advance_pc:
3761	pLnState->Regs.uAddress += rtDwarfCursor_GetUHalf(pCursor, 0);
3762	pLnState->Regs.idxOp = 0;
3763	Log2(("%08x: DW_LNS_fixed_advance_pc\n", offOpCode));
3764	break;
3765
3766	case DW_LNS_set_prologue_end:
3767	pLnState->Regs.fPrologueEnd = true;
3768	Log2(("%08x: DW_LNS_set_prologue_end\n", offOpCode));
3769	break;
3770
3771	case DW_LNS_set_epilogue_begin:
3772	pLnState->Regs.fEpilogueBegin = true;
3773	Log2(("%08x: DW_LNS_set_epilogue_begin\n", offOpCode));
3774	break;
3775
3776	case DW_LNS_set_isa:
3777	pLnState->Regs.uIsa = rtDwarfCursor_GetULeb128AsU32(pCursor, 0);
3778	Log2(("%08x: DW_LNS_set_isa %#x\n", offOpCode, pLnState->Regs.uIsa));
3779	break;
3780
3781	default:
3782	{
3783	unsigned cOpsToSkip = pLnState->Hdr.pacStdOperands[bOpCode - 1];
3784	Log(("rtDwarfLine_RunProgram: Unknown standard opcode %#x, %#x operands, at %08x.\n", bOpCode, cOpsToSkip, offOpCode));
3785	while (cOpsToSkip-- > 0)
3786	rc = rtDwarfCursor_SkipLeb128(pCursor);
3787	break;
3788	}
3789
3790	/*
3791	* Extended opcode.
3792	*/
3793	case DW_LNS_extended:
3794	{
3795	/* The instruction has a length prefix. */
3796	uint64_t cbInstr = rtDwarfCursor_GetULeb128(pCursor, UINT64_MAX);
3797	if (RT_FAILURE(pCursor->rc))
3798	return pCursor->rc;
3799	if (cbInstr > pCursor->cbUnitLeft)
3800	return VERR_DWARF_BAD_LNE;
3801	uint8_t const * const pbEndOfInstr = rtDwarfCursor_CalcPos(pCursor, cbInstr);
3802
3803	/* Get the opcode and deal with it if we know it. */
3804	bOpCode = rtDwarfCursor_GetUByte(pCursor, 0);
3805	switch (bOpCode)
3806	{
3807	case DW_LNE_end_sequence:
3808	#if 0 /* No need for this, I think. */
3809	pLnState->Regs.fEndSequence = true;
3810	rc = rtDwarfLine_AddLine(pLnState, offOpCode);
3811	#endif
3812	rtDwarfLine_ResetState(pLnState);
3813	Log2(("%08x: DW_LNE_end_sequence\n", offOpCode));
3814	break;
3815
3816	case DW_LNE_set_address:
3817	pLnState->Regs.uAddress = rtDwarfCursor_GetVarSizedU(pCursor, cbInstr - 1, UINT64_MAX);
3818	pLnState->Regs.idxOp = 0;
3819	Log2(("%08x: DW_LNE_set_address: %#llx\n", offOpCode, pLnState->Regs.uAddress));
3820	break;
3821
3822	case DW_LNE_define_file:
3823	{
3824	const char *pszFilename = rtDwarfCursor_GetSZ(pCursor, NULL);
3825	uint32_t idxInc = rtDwarfCursor_GetULeb128AsU32(pCursor, UINT32_MAX);
3826	rtDwarfCursor_SkipLeb128(pCursor); /* st_mtime */
3827	rtDwarfCursor_SkipLeb128(pCursor); /* st_size */
3828	Log2(("%08x: DW_LNE_define_file: {%d}/%s\n", offOpCode, idxInc, pszFilename));
3829
3830	rc = rtDwarfCursor_AdvanceToPos(pCursor, pbEndOfInstr);
3831	if (RT_SUCCESS(rc))
3832	rc = rtDwarfLine_DefineFileName(pLnState, pszFilename, idxInc);
3833	break;
3834	}
3835
3836	/*
3837	* Note! Was defined in DWARF 4. But... Watcom used it for setting the
3838	* segment in DWARF 2, creating an incompatibility with the newer
3839	* standard. And gcc 10 uses v3 for these.
3840	*/
3841	case DW_LNE_set_descriminator:
3842	if (pLnState->Hdr.uVer != 2)
3843	{
3844	Assert(pLnState->Hdr.uVer >= 3);
3845	pLnState->Regs.uDiscriminator = rtDwarfCursor_GetULeb128AsU32(pCursor, UINT32_MAX);
3846	Log2(("%08x: DW_LNE_set_descriminator: %u\n", offOpCode, pLnState->Regs.uDiscriminator));
3847	}
3848	else
3849	{
3850	uint64_t uSeg = rtDwarfCursor_GetVarSizedU(pCursor, cbInstr - 1, UINT64_MAX);
3851	Log2(("%08x: DW_LNE_set_segment: %#llx, cbInstr=%#x - Watcom Extension\n", offOpCode, uSeg, cbInstr));
3852	pLnState->Regs.uSegment = (RTSEL)uSeg;
3853	AssertStmt(pLnState->Regs.uSegment == uSeg, rc = VERR_DWARF_BAD_INFO);
3854	}
3855	break;
3856
3857	default:
3858	Log(("rtDwarfLine_RunProgram: Unknown extended opcode %#x, length %#x at %08x\n", bOpCode, cbInstr, offOpCode));
3859	break;
3860	}
3861
3862	/* Advance the cursor to the end of the instruction . */
3863	rtDwarfCursor_AdvanceToPos(pCursor, pbEndOfInstr);
3864	break;
3865	}
3866	}
3867	}
3868
3869	/*
3870	* Check the status before looping.
3871	*/
3872	if (RT_FAILURE(rc))
3873	return rc;
3874	if (RT_FAILURE(pCursor->rc))
3875	return pCursor->rc;
3876	}
3877	return rc;
3878	}
3879
3880
3881	/**
3882	* Reads the include directories for a line number unit.
3883	*
3884	* @returns IPRT status code
3885	* @param pLnState The line number program state.
3886	* @param pCursor The cursor.
3887	*/
3888	static int rtDwarfLine_ReadFileNames(PRTDWARFLINESTATE pLnState, PRTDWARFCURSOR pCursor)
3889	{
3890	int rc = rtDwarfLine_DefineFileName(pLnState, "/<bad-zero-file-name-entry>", 0);
3891	if (RT_FAILURE(rc))
3892	return rc;
3893
3894	for (;;)
3895	{
3896	const char *psz = rtDwarfCursor_GetSZ(pCursor, NULL);
3897	if (!*psz)
3898	break;
3899
3900	uint64_t idxInc = rtDwarfCursor_GetULeb128(pCursor, UINT64_MAX);
3901	rtDwarfCursor_SkipLeb128(pCursor); /* st_mtime */
3902	rtDwarfCursor_SkipLeb128(pCursor); /* st_size */
3903
3904	rc = rtDwarfLine_DefineFileName(pLnState, psz, idxInc);
3905	if (RT_FAILURE(rc))
3906	return rc;
3907	}
3908	return pCursor->rc;
3909	}
3910
3911
3912	/**
3913	* Reads the include directories for a line number unit.
3914	*
3915	* @returns IPRT status code
3916	* @param pLnState The line number program state.
3917	* @param pCursor The cursor.
3918	*/
3919	static int rtDwarfLine_ReadIncludePaths(PRTDWARFLINESTATE pLnState, PRTDWARFCURSOR pCursor)
3920	{
3921	const char psz = ""; / The zeroth is the unit dir. */
3922	for (;;)
3923	{
3924	if ((pLnState->cIncPaths % 2) == 0)
3925	{
3926	void pv = RTMemRealloc(pLnState->papszIncPaths, sizeof(pLnState->papszIncPaths[0]) (pLnState->cIncPaths + 2));
3927	if (!pv)
3928	return VERR_NO_MEMORY;
3929	pLnState->papszIncPaths = (const char **)pv;
3930	}
3931	Log((" Path #%02u = '%s'\n", pLnState->cIncPaths, psz));
3932	pLnState->papszIncPaths[pLnState->cIncPaths] = psz;
3933	pLnState->cIncPaths++;
3934
3935	psz = rtDwarfCursor_GetSZ(pCursor, NULL);
3936	if (!*psz)
3937	break;
3938	}
3939
3940	return pCursor->rc;
3941	}
3942
3943
3944	/**
3945	* Explodes the line number table for a compilation unit.
3946	*
3947	* @returns IPRT status code
3948	* @param pThis The DWARF instance.
3949	* @param pCursor The cursor to read the line number information
3950	* via.
3951	*/
3952	static int rtDwarfLine_ExplodeUnit(PRTDBGMODDWARF pThis, PRTDWARFCURSOR pCursor)
3953	{
3954	RTDWARFLINESTATE LnState;
3955	RT_ZERO(LnState);
3956	LnState.pDwarfMod = pThis;
3957
3958	/*
3959	* Parse the header.
3960	*/
3961	rtDwarfCursor_GetInitialLength(pCursor);
3962	LnState.Hdr.uVer = rtDwarfCursor_GetUHalf(pCursor, 0);
3963	if ( LnState.Hdr.uVer < 2
3964	\|\| LnState.Hdr.uVer > 4)
3965	return rtDwarfCursor_SkipUnit(pCursor);
3966
3967	LnState.Hdr.offFirstOpcode = rtDwarfCursor_GetUOff(pCursor, 0);
3968	uint8_t const * const pbFirstOpcode = rtDwarfCursor_CalcPos(pCursor, LnState.Hdr.offFirstOpcode);
3969
3970	LnState.Hdr.cbMinInstr = rtDwarfCursor_GetUByte(pCursor, 0);
3971	if (LnState.Hdr.uVer >= 4)
3972	LnState.Hdr.cMaxOpsPerInstr = rtDwarfCursor_GetUByte(pCursor, 0);
3973	else
3974	LnState.Hdr.cMaxOpsPerInstr = 1;
3975	LnState.Hdr.u8DefIsStmt = rtDwarfCursor_GetUByte(pCursor, 0);
3976	LnState.Hdr.s8LineBase = rtDwarfCursor_GetSByte(pCursor, 0);
3977	LnState.Hdr.u8LineRange = rtDwarfCursor_GetUByte(pCursor, 0);
3978	LnState.Hdr.u8OpcodeBase = rtDwarfCursor_GetUByte(pCursor, 0);
3979
3980	if ( !LnState.Hdr.u8OpcodeBase
3981	\|\| !LnState.Hdr.cMaxOpsPerInstr
3982	\|\| !LnState.Hdr.u8LineRange
3983	\|\| LnState.Hdr.u8DefIsStmt > 1)
3984	return VERR_DWARF_BAD_LINE_NUMBER_HEADER;
3985	Log2(("DWARF Line number header:\n"
3986	" uVer %d\n"
3987	" offFirstOpcode %#llx\n"
3988	" cbMinInstr %u\n"
3989	" cMaxOpsPerInstr %u\n"
3990	" u8DefIsStmt %u\n"
3991	" s8LineBase %d\n"
3992	" u8LineRange %u\n"
3993	" u8OpcodeBase %u\n",
3994	LnState.Hdr.uVer, LnState.Hdr.offFirstOpcode, LnState.Hdr.cbMinInstr, LnState.Hdr.cMaxOpsPerInstr,
3995	LnState.Hdr.u8DefIsStmt, LnState.Hdr.s8LineBase, LnState.Hdr.u8LineRange, LnState.Hdr.u8OpcodeBase));
3996
3997	LnState.Hdr.pacStdOperands = pCursor->pb;
3998	for (uint8_t iStdOpcode = 1; iStdOpcode < LnState.Hdr.u8OpcodeBase; iStdOpcode++)
3999	rtDwarfCursor_GetUByte(pCursor, 0);
4000
4001	int rc = pCursor->rc;
4002	if (RT_SUCCESS(rc))
4003	rc = rtDwarfLine_ReadIncludePaths(&LnState, pCursor);
4004	if (RT_SUCCESS(rc))
4005	rc = rtDwarfLine_ReadFileNames(&LnState, pCursor);
4006
4007	/*
4008	* Run the program....
4009	*/
4010	if (RT_SUCCESS(rc))
4011	rc = rtDwarfCursor_AdvanceToPos(pCursor, pbFirstOpcode);
4012	if (RT_SUCCESS(rc))
4013	rc = rtDwarfLine_RunProgram(&LnState, pCursor);
4014
4015	/*
4016	* Clean up.
4017	*/
4018	size_t i = LnState.cFileNames;
4019	while (i-- > 0)
4020	RTStrFree(LnState.papszFileNames[i]);
4021	RTMemFree(LnState.papszFileNames);
4022	RTMemFree(LnState.papszIncPaths);
4023
4024	Assert(rtDwarfCursor_IsAtEndOfUnit(pCursor) \|\| RT_FAILURE(rc));
4025	return rc;
4026	}
4027
4028
4029	/**
4030	* Explodes the line number table.
4031	*
4032	* The line numbers are insered into the debug info container.
4033	*
4034	* @returns IPRT status code
4035	* @param pThis The DWARF instance.
4036	*/
4037	static int rtDwarfLine_ExplodeAll(PRTDBGMODDWARF pThis)
4038	{
4039	if (!pThis->aSections[krtDbgModDwarfSect_line].fPresent)
4040	return VINF_SUCCESS;
4041
4042	RTDWARFCURSOR Cursor;
4043	int rc = rtDwarfCursor_Init(&Cursor, pThis, krtDbgModDwarfSect_line);
4044	if (RT_FAILURE(rc))
4045	return rc;
4046
4047	while ( !rtDwarfCursor_IsAtEnd(&Cursor)
4048	&& RT_SUCCESS(rc))
4049	rc = rtDwarfLine_ExplodeUnit(pThis, &Cursor);
4050
4051	return rtDwarfCursor_Delete(&Cursor, rc);
4052	}
4053
4054
4055	/*
4056	*
4057	* DWARF Abbreviations.
4058	* DWARF Abbreviations.
4059	* DWARF Abbreviations.
4060	*
4061	*/
4062
4063	/**
4064	* Deals with a cache miss in rtDwarfAbbrev_Lookup.
4065	*
4066	* @returns Pointer to abbreviation cache entry (read only). May be rendered
4067	* invalid by subsequent calls to this function.
4068	* @param pThis The DWARF instance.
4069	* @param uCode The abbreviation code to lookup.
4070	*/
4071	static PCRTDWARFABBREV rtDwarfAbbrev_LookupMiss(PRTDBGMODDWARF pThis, uint32_t uCode)
4072	{
4073	/*
4074	* There is no entry with code zero.
4075	*/
4076	if (!uCode)
4077	return NULL;
4078
4079	/*
4080	* Resize the cache array if the code is considered cachable.
4081	*/
4082	bool fFillCache = true;
4083	if (pThis->cCachedAbbrevsAlloced < uCode)
4084	{
4085	if (uCode >= _64K)
4086	fFillCache = false;
4087	else
4088	{
4089	uint32_t cNew = RT_ALIGN(uCode, 64);
4090	void pv = RTMemRealloc(pThis->paCachedAbbrevs, sizeof(pThis->paCachedAbbrevs[0]) cNew);
4091	if (!pv)
4092	fFillCache = false;
4093	else
4094	{
4095	Log(("rtDwarfAbbrev_LookupMiss: Growing from %u to %u...\n", pThis->cCachedAbbrevsAlloced, cNew));
4096	pThis->paCachedAbbrevs = (PRTDWARFABBREV)pv;
4097	for (uint32_t i = pThis->cCachedAbbrevsAlloced; i < cNew; i++)
4098	pThis->paCachedAbbrevs[i].offAbbrev = UINT32_MAX;
4099	pThis->cCachedAbbrevsAlloced = cNew;
4100	}
4101	}
4102	}
4103
4104	/*
4105	* Walk the abbreviations till we find the desired code.
4106	*/
4107	RTDWARFCURSOR Cursor;
4108	int rc = rtDwarfCursor_InitWithOffset(&Cursor, pThis, krtDbgModDwarfSect_abbrev, pThis->offCachedAbbrev);
4109	if (RT_FAILURE(rc))
4110	return NULL;
4111
4112	PRTDWARFABBREV pRet = NULL;
4113	if (fFillCache)
4114	{
4115	/*
4116	* Search for the entry and fill the cache while doing so.
4117	* We assume that abbreviation codes for a unit will stop when we see
4118	* zero code or when the code value drops.
4119	*/
4120	uint32_t uPrevCode = 0;
4121	for (;;)
4122	{
4123	/* Read the 'header'. Skipping zero code bytes. */
4124	#ifdef LOG_ENABLED
4125	uint32_t const offStart = rtDwarfCursor_CalcSectOffsetU32(&Cursor);
4126	#endif
4127	uint32_t const uCurCode = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
4128	if (pRet && (uCurCode == 0 \|\| uCurCode < uPrevCode))
4129	break; /* probably end of unit. */
4130	if (uCurCode != 0)
4131	{
4132	uint32_t const uCurTag = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
4133	uint8_t const uChildren = rtDwarfCursor_GetU8(&Cursor, 0);
4134	if (RT_FAILURE(Cursor.rc))
4135	break;
4136	if ( uCurTag > 0xffff
4137	\|\| uChildren > 1)
4138	{
4139	Cursor.rc = VERR_DWARF_BAD_ABBREV;
4140	break;
4141	}
4142
4143	/* Cache it? */
4144	if (uCurCode <= pThis->cCachedAbbrevsAlloced)
4145	{
4146	PRTDWARFABBREV pEntry = &pThis->paCachedAbbrevs[uCurCode - 1];
4147	if (pEntry->offAbbrev != pThis->offCachedAbbrev)
4148	{
4149	pEntry->offAbbrev = pThis->offCachedAbbrev;
4150	pEntry->fChildren = RT_BOOL(uChildren);
4151	pEntry->uTag = uCurTag;
4152	pEntry->offSpec = rtDwarfCursor_CalcSectOffsetU32(&Cursor);
4153	#ifdef LOG_ENABLED
4154	pEntry->cbHdr = (uint8_t)(pEntry->offSpec - offStart);
4155	Log7(("rtDwarfAbbrev_LookupMiss(%#x): fill: %#x: uTag=%#x offAbbrev=%#x%s\n",
4156	uCode, offStart, pEntry->uTag, pEntry->offAbbrev, pEntry->fChildren ? " has-children" : ""));
4157	#endif
4158	if (uCurCode == uCode)
4159	{
4160	Assert(!pRet);
4161	pRet = pEntry;
4162	if (uCurCode == pThis->cCachedAbbrevsAlloced)
4163	break;
4164	}
4165	}
4166	else if (pRet)
4167	break; /* Next unit, don't cache more. */
4168	/* else: We're growing the cache and re-reading old data. */
4169	}
4170
4171	/* Skip the specification. */
4172	uint32_t uAttr, uForm;
4173	do
4174	{
4175	uAttr = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
4176	uForm = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
4177	} while (uAttr != 0);
4178	}
4179	if (RT_FAILURE(Cursor.rc))
4180	break;
4181
4182	/* Done? (Maximize cache filling.) */
4183	if ( pRet != NULL
4184	&& uCurCode >= pThis->cCachedAbbrevsAlloced)
4185	break;
4186	uPrevCode = uCurCode;
4187	}
4188	if (pRet)
4189	Log6(("rtDwarfAbbrev_LookupMiss(%#x): uTag=%#x offSpec=%#x offAbbrev=%#x [fill]\n",
4190	uCode, pRet->uTag, pRet->offSpec, pRet->offAbbrev));
4191	else
4192	Log6(("rtDwarfAbbrev_LookupMiss(%#x): failed [fill]\n", uCode));
4193	}
4194	else
4195	{
4196	/*
4197	* Search for the entry with the desired code, no cache filling.
4198	*/
4199	for (;;)
4200	{
4201	/* Read the 'header'. */
4202	#ifdef LOG_ENABLED
4203	uint32_t const offStart = rtDwarfCursor_CalcSectOffsetU32(&Cursor);
4204	#endif
4205	uint32_t const uCurCode = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
4206	uint32_t const uCurTag = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
4207	uint8_t const uChildren = rtDwarfCursor_GetU8(&Cursor, 0);
4208	if (RT_FAILURE(Cursor.rc))
4209	break;
4210	if ( uCurTag > 0xffff
4211	\|\| uChildren > 1)
4212	{
4213	Cursor.rc = VERR_DWARF_BAD_ABBREV;
4214	break;
4215	}
4216
4217	/* Do we have a match? */
4218	if (uCurCode == uCode)
4219	{
4220	pRet = &pThis->LookupAbbrev;
4221	pRet->fChildren = RT_BOOL(uChildren);
4222	pRet->uTag = uCurTag;
4223	pRet->offSpec = rtDwarfCursor_CalcSectOffsetU32(&Cursor);
4224	pRet->offAbbrev = pThis->offCachedAbbrev;
4225	#ifdef LOG_ENABLED
4226	pRet->cbHdr = (uint8_t)(pRet->offSpec - offStart);
4227	#endif
4228	break;
4229	}
4230
4231	/* Skip the specification. */
4232	uint32_t uAttr, uForm;
4233	do
4234	{
4235	uAttr = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
4236	uForm = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
4237	} while (uAttr != 0);
4238	if (RT_FAILURE(Cursor.rc))
4239	break;
4240	}
4241	if (pRet)
4242	Log6(("rtDwarfAbbrev_LookupMiss(%#x): uTag=%#x offSpec=%#x offAbbrev=%#x [no-fill]\n",
4243	uCode, pRet->uTag, pRet->offSpec, pRet->offAbbrev));
4244	else
4245	Log6(("rtDwarfAbbrev_LookupMiss(%#x): failed [no-fill]\n", uCode));
4246	}
4247
4248	rtDwarfCursor_Delete(&Cursor, VINF_SUCCESS);
4249	return pRet;
4250	}
4251
4252
4253	/**
4254	* Looks up an abbreviation.
4255	*
4256	* @returns Pointer to abbreviation cache entry (read only). May be rendered
4257	* invalid by subsequent calls to this function.
4258	* @param pThis The DWARF instance.
4259	* @param uCode The abbreviation code to lookup.
4260	*/
4261	static PCRTDWARFABBREV rtDwarfAbbrev_Lookup(PRTDBGMODDWARF pThis, uint32_t uCode)
4262	{
4263	uCode -= 1;
4264	if (uCode < pThis->cCachedAbbrevsAlloced)
4265	{
4266	if (pThis->paCachedAbbrevs[uCode].offAbbrev == pThis->offCachedAbbrev)
4267	return &pThis->paCachedAbbrevs[uCode];
4268	}
4269	return rtDwarfAbbrev_LookupMiss(pThis, uCode + 1);
4270	}
4271
4272
4273	/**
4274	* Sets the abbreviation offset of the current unit.
4275	*
4276	* @param pThis The DWARF instance.
4277	* @param offAbbrev The offset into the abbreviation section.
4278	*/
4279	static void rtDwarfAbbrev_SetUnitOffset(PRTDBGMODDWARF pThis, uint32_t offAbbrev)
4280	{
4281	pThis->offCachedAbbrev = offAbbrev;
4282	}
4283
4284
4285
4286	/*
4287	*
4288	* DIE Attribute Parsers.
4289	* DIE Attribute Parsers.
4290	* DIE Attribute Parsers.
4291	*
4292	*/
4293
4294	/**
4295	* Gets the compilation unit a DIE belongs to.
4296	*
4297	* @returns The compilation unit DIE.
4298	* @param pDie Some DIE in the unit.
4299	*/
4300	static PRTDWARFDIECOMPILEUNIT rtDwarfDie_GetCompileUnit(PRTDWARFDIE pDie)
4301	{
4302	while (pDie->pParent)
4303	pDie = pDie->pParent;
4304	AssertReturn( pDie->uTag == DW_TAG_compile_unit
4305	\|\| pDie->uTag == DW_TAG_partial_unit,
4306	NULL);
4307	return (PRTDWARFDIECOMPILEUNIT)pDie;
4308	}
4309
4310
4311	/**
4312	* Resolves a string section (debug_str) reference.
4313	*
4314	* @returns Pointer to the string (inside the string section).
4315	* @param pThis The DWARF instance.
4316	* @param pCursor The cursor.
4317	* @param pszErrValue What to return on failure (@a
4318	* pCursor->rc is set).
4319	*/
4320	static const char rtDwarfDecodeHlp_GetStrp(PRTDBGMODDWARF pThis, PRTDWARFCURSOR pCursor, const char pszErrValue)
4321	{
4322	uint64_t offDebugStr = rtDwarfCursor_GetUOff(pCursor, UINT64_MAX);
4323	if (RT_FAILURE(pCursor->rc))
4324	return pszErrValue;
4325
4326	if (offDebugStr >= pThis->aSections[krtDbgModDwarfSect_str].cb)
4327	{
4328	/* Ugly: Exploit the cursor status field for reporting errors. */
4329	pCursor->rc = VERR_DWARF_BAD_INFO;
4330	return pszErrValue;
4331	}
4332
4333	if (!pThis->aSections[krtDbgModDwarfSect_str].pv)
4334	{
4335	int rc = rtDbgModDwarfLoadSection(pThis, krtDbgModDwarfSect_str);
4336	if (RT_FAILURE(rc))
4337	{
4338	/* Ugly: Exploit the cursor status field for reporting errors. */
4339	pCursor->rc = rc;
4340	return pszErrValue;
4341	}
4342	}
4343
4344	return (const char *)pThis->aSections[krtDbgModDwarfSect_str].pv + (size_t)offDebugStr;
4345	}
4346
4347
4348	/** @callback_method_impl{FNRTDWARFATTRDECODER} */
4349	static DECLCALLBACK(int) rtDwarfDecode_Address(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
4350	uint32_t uForm, PRTDWARFCURSOR pCursor)
4351	{
4352	AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFADDR), VERR_INTERNAL_ERROR_3);
4353	NOREF(pDie);
4354
4355	uint64_t uAddr;
4356	switch (uForm)
4357	{
4358	case DW_FORM_addr: uAddr = rtDwarfCursor_GetNativeUOff(pCursor, 0); break;
4359	case DW_FORM_data1: uAddr = rtDwarfCursor_GetU8(pCursor, 0); break;
4360	case DW_FORM_data2: uAddr = rtDwarfCursor_GetU16(pCursor, 0); break;
4361	case DW_FORM_data4: uAddr = rtDwarfCursor_GetU32(pCursor, 0); break;
4362	case DW_FORM_data8: uAddr = rtDwarfCursor_GetU64(pCursor, 0); break;
4363	case DW_FORM_udata: uAddr = rtDwarfCursor_GetULeb128(pCursor, 0); break;
4364	default:
4365	AssertMsgFailedReturn(("%#x (%s)\n", uForm, rtDwarfLog_FormName(uForm)), VERR_DWARF_UNEXPECTED_FORM);
4366	}
4367	if (RT_FAILURE(pCursor->rc))
4368	return pCursor->rc;
4369
4370	PRTDWARFADDR pAddr = (PRTDWARFADDR)pbMember;
4371	pAddr->uAddress = uAddr;
4372
4373	Log4((" %-20s %#010llx [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), uAddr, rtDwarfLog_FormName(uForm)));
4374	return VINF_SUCCESS;
4375	}
4376
4377
4378	/** @callback_method_impl{FNRTDWARFATTRDECODER} */
4379	static DECLCALLBACK(int) rtDwarfDecode_Bool(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
4380	uint32_t uForm, PRTDWARFCURSOR pCursor)
4381	{
4382	AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(bool), VERR_INTERNAL_ERROR_3);
4383	NOREF(pDie);
4384
4385	bool pfMember = (bool )pbMember;
4386	switch (uForm)
4387	{
4388	case DW_FORM_flag:
4389	{
4390	uint8_t b = rtDwarfCursor_GetU8(pCursor, UINT8_MAX);
4391	if (b > 1)
4392	{
4393	Log(("Unexpected boolean value %#x\n", b));
4394	return RT_FAILURE(pCursor->rc) ? pCursor->rc : pCursor->rc = VERR_DWARF_BAD_INFO;
4395	}
4396	*pfMember = RT_BOOL(b);
4397	break;
4398	}
4399
4400	case DW_FORM_flag_present:
4401	*pfMember = true;
4402	break;
4403
4404	default:
4405	AssertMsgFailedReturn(("%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
4406	}
4407
4408	Log4((" %-20s %RTbool [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), *pfMember, rtDwarfLog_FormName(uForm)));
4409	return VINF_SUCCESS;
4410	}
4411
4412
4413	/** @callback_method_impl{FNRTDWARFATTRDECODER} */
4414	static DECLCALLBACK(int) rtDwarfDecode_LowHighPc(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
4415	uint32_t uForm, PRTDWARFCURSOR pCursor)
4416	{
4417	AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFADDRRANGE), VERR_INTERNAL_ERROR_3);
4418	AssertReturn(pDesc->uAttr == DW_AT_low_pc \|\| pDesc->uAttr == DW_AT_high_pc, VERR_INTERNAL_ERROR_3);
4419	NOREF(pDie);
4420
4421	uint64_t uAddr;
4422	switch (uForm)
4423	{
4424	case DW_FORM_addr: uAddr = rtDwarfCursor_GetNativeUOff(pCursor, 0); break;
4425	case DW_FORM_data1: uAddr = rtDwarfCursor_GetU8(pCursor, 0); break;
4426	case DW_FORM_data2: uAddr = rtDwarfCursor_GetU16(pCursor, 0); break;
4427	case DW_FORM_data4: uAddr = rtDwarfCursor_GetU32(pCursor, 0); break;
4428	case DW_FORM_data8: uAddr = rtDwarfCursor_GetU64(pCursor, 0); break;
4429	case DW_FORM_udata: uAddr = rtDwarfCursor_GetULeb128(pCursor, 0); break;
4430	default:
4431	AssertMsgFailedReturn(("%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
4432	}
4433	if (RT_FAILURE(pCursor->rc))
4434	return pCursor->rc;
4435
4436	PRTDWARFADDRRANGE pRange = (PRTDWARFADDRRANGE)pbMember;
4437	if (pDesc->uAttr == DW_AT_low_pc)
4438	{
4439	if (pRange->fHaveLowAddress)
4440	{
4441	Log(("rtDwarfDecode_LowHighPc: Duplicate DW_AT_low_pc\n"));
4442	return pCursor->rc = VERR_DWARF_BAD_INFO;
4443	}
4444	pRange->fHaveLowAddress = true;
4445	pRange->uLowAddress = uAddr;
4446	}
4447	else
4448	{
4449	if (pRange->fHaveHighAddress)
4450	{
4451	Log(("rtDwarfDecode_LowHighPc: Duplicate DW_AT_high_pc\n"));
4452	return pCursor->rc = VERR_DWARF_BAD_INFO;
4453	}
4454	pRange->fHaveHighAddress = true;
4455	pRange->fHaveHighIsAddress = uForm == DW_FORM_addr;
4456	if (!pRange->fHaveHighIsAddress && pRange->fHaveLowAddress)
4457	{
4458	pRange->fHaveHighIsAddress = true;
4459	pRange->uHighAddress = uAddr + pRange->uLowAddress;
4460	}
4461	else
4462	pRange->uHighAddress = uAddr;
4463
4464	}
4465	pRange->cAttrs++;
4466
4467	Log4((" %-20s %#010llx [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), uAddr, rtDwarfLog_FormName(uForm)));
4468	return VINF_SUCCESS;
4469	}
4470
4471
4472	/** @callback_method_impl{FNRTDWARFATTRDECODER} */
4473	static DECLCALLBACK(int) rtDwarfDecode_Ranges(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
4474	uint32_t uForm, PRTDWARFCURSOR pCursor)
4475	{
4476	AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFADDRRANGE), VERR_INTERNAL_ERROR_3);
4477	AssertReturn(pDesc->uAttr == DW_AT_ranges, VERR_INTERNAL_ERROR_3);
4478	NOREF(pDie);
4479
4480	/* Decode it. */
4481	uint64_t off;
4482	switch (uForm)
4483	{
4484	case DW_FORM_addr: off = rtDwarfCursor_GetNativeUOff(pCursor, 0); break;
4485	case DW_FORM_data4: off = rtDwarfCursor_GetU32(pCursor, 0); break;
4486	case DW_FORM_data8: off = rtDwarfCursor_GetU64(pCursor, 0); break;
4487	case DW_FORM_sec_offset: off = rtDwarfCursor_GetUOff(pCursor, 0); break;
4488	default:
4489	AssertMsgFailedReturn(("%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
4490	}
4491	if (RT_FAILURE(pCursor->rc))
4492	return pCursor->rc;
4493
4494	/* Validate the offset and load the ranges. */
4495	PRTDBGMODDWARF pThis = pCursor->pDwarfMod;
4496	if (off >= pThis->aSections[krtDbgModDwarfSect_ranges].cb)
4497	{
4498	Log(("rtDwarfDecode_Ranges: bad ranges off=%#llx\n", off));
4499	return pCursor->rc = VERR_DWARF_BAD_POS;
4500	}
4501
4502	if (!pThis->aSections[krtDbgModDwarfSect_ranges].pv)
4503	{
4504	int rc = rtDbgModDwarfLoadSection(pThis, krtDbgModDwarfSect_ranges);
4505	if (RT_FAILURE(rc))
4506	return pCursor->rc = rc;
4507	}
4508
4509	/* Store the result. */
4510	PRTDWARFADDRRANGE pRange = (PRTDWARFADDRRANGE)pbMember;
4511	if (pRange->fHaveRanges)
4512	{
4513	Log(("rtDwarfDecode_Ranges: Duplicate DW_AT_ranges\n"));
4514	return pCursor->rc = VERR_DWARF_BAD_INFO;
4515	}
4516	pRange->fHaveRanges = true;
4517	pRange->cAttrs++;
4518	pRange->pbRanges = (uint8_t const *)pThis->aSections[krtDbgModDwarfSect_ranges].pv + (size_t)off;
4519
4520	Log4((" %-20s TODO [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), rtDwarfLog_FormName(uForm)));
4521	return VINF_SUCCESS;
4522	}
4523
4524
4525	/** @callback_method_impl{FNRTDWARFATTRDECODER} */
4526	static DECLCALLBACK(int) rtDwarfDecode_Reference(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
4527	uint32_t uForm, PRTDWARFCURSOR pCursor)
4528	{
4529	AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFREF), VERR_INTERNAL_ERROR_3);
4530
4531	/* Decode it. */
4532	uint64_t off;
4533	krtDwarfRef enmWrt = krtDwarfRef_SameUnit;
4534	switch (uForm)
4535	{
4536	case DW_FORM_ref1: off = rtDwarfCursor_GetU8(pCursor, 0); break;
4537	case DW_FORM_ref2: off = rtDwarfCursor_GetU16(pCursor, 0); break;
4538	case DW_FORM_ref4: off = rtDwarfCursor_GetU32(pCursor, 0); break;
4539	case DW_FORM_ref8: off = rtDwarfCursor_GetU64(pCursor, 0); break;
4540	case DW_FORM_ref_udata: off = rtDwarfCursor_GetULeb128(pCursor, 0); break;
4541
4542	case DW_FORM_ref_addr:
4543	enmWrt = krtDwarfRef_InfoSection;
4544	off = rtDwarfCursor_GetUOff(pCursor, 0);
4545	break;
4546
4547	case DW_FORM_ref_sig8:
4548	enmWrt = krtDwarfRef_TypeId64;
4549	off = rtDwarfCursor_GetU64(pCursor, 0);
4550	break;
4551
4552	default:
4553	AssertMsgFailedReturn(("%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
4554	}
4555	if (RT_FAILURE(pCursor->rc))
4556	return pCursor->rc;
4557
4558	/* Validate the offset and convert to debug_info relative offsets. */
4559	if (enmWrt == krtDwarfRef_InfoSection)
4560	{
4561	if (off >= pCursor->pDwarfMod->aSections[krtDbgModDwarfSect_info].cb)
4562	{
4563	Log(("rtDwarfDecode_Reference: bad info off=%#llx\n", off));
4564	return pCursor->rc = VERR_DWARF_BAD_POS;
4565	}
4566	}
4567	else if (enmWrt == krtDwarfRef_SameUnit)
4568	{
4569	PRTDWARFDIECOMPILEUNIT pUnit = rtDwarfDie_GetCompileUnit(pDie);
4570	if (off >= pUnit->cbUnit)
4571	{
4572	Log(("rtDwarfDecode_Reference: bad unit off=%#llx\n", off));
4573	return pCursor->rc = VERR_DWARF_BAD_POS;
4574	}
4575	off += pUnit->offUnit;
4576	enmWrt = krtDwarfRef_InfoSection;
4577	}
4578	/* else: not bother verifying/resolving the indirect type reference yet. */
4579
4580	/* Store it */
4581	PRTDWARFREF pRef = (PRTDWARFREF)pbMember;
4582	pRef->enmWrt = enmWrt;
4583	pRef->off = off;
4584
4585	Log4((" %-20s %d:%#010llx [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), enmWrt, off, rtDwarfLog_FormName(uForm)));
4586	return VINF_SUCCESS;
4587	}
4588
4589
4590	/** @callback_method_impl{FNRTDWARFATTRDECODER} */
4591	static DECLCALLBACK(int) rtDwarfDecode_SectOff(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
4592	uint32_t uForm, PRTDWARFCURSOR pCursor)
4593	{
4594	AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFREF), VERR_INTERNAL_ERROR_3);
4595	NOREF(pDie);
4596
4597	uint64_t off;
4598	switch (uForm)
4599	{
4600	case DW_FORM_data4: off = rtDwarfCursor_GetU32(pCursor, 0); break;
4601	case DW_FORM_data8: off = rtDwarfCursor_GetU64(pCursor, 0); break;
4602	case DW_FORM_sec_offset: off = rtDwarfCursor_GetUOff(pCursor, 0); break;
4603	default:
4604	AssertMsgFailedReturn(("%#x (%s)\n", uForm, rtDwarfLog_FormName(uForm)), VERR_DWARF_UNEXPECTED_FORM);
4605	}
4606	if (RT_FAILURE(pCursor->rc))
4607	return pCursor->rc;
4608
4609	krtDbgModDwarfSect enmSect;
4610	krtDwarfRef enmWrt;
4611	switch (pDesc->uAttr)
4612	{
4613	case DW_AT_stmt_list: enmSect = krtDbgModDwarfSect_line; enmWrt = krtDwarfRef_LineSection; break;
4614	case DW_AT_macro_info: enmSect = krtDbgModDwarfSect_loc; enmWrt = krtDwarfRef_LocSection; break;
4615	case DW_AT_ranges: enmSect = krtDbgModDwarfSect_ranges; enmWrt = krtDwarfRef_RangesSection; break;
4616	default:
4617	AssertMsgFailedReturn(("%u (%s)\n", pDesc->uAttr, rtDwarfLog_AttrName(pDesc->uAttr)), VERR_INTERNAL_ERROR_4);
4618	}
4619	size_t cbSect = pCursor->pDwarfMod->aSections[enmSect].cb;
4620	if (off >= cbSect)
4621	{
4622	/* Watcom generates offset past the end of the section, increasing the
4623	offset by one for each compile unit. So, just fudge it. */
4624	Log(("rtDwarfDecode_SectOff: bad off=%#llx, attr %#x (%s), enmSect=%d cb=%#llx; Assuming watcom/gcc.\n", off,
4625	pDesc->uAttr, rtDwarfLog_AttrName(pDesc->uAttr), enmSect, cbSect));
4626	off = cbSect;
4627	}
4628
4629	PRTDWARFREF pRef = (PRTDWARFREF)pbMember;
4630	pRef->enmWrt = enmWrt;
4631	pRef->off = off;
4632
4633	Log4((" %-20s %d:%#010llx [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), enmWrt, off, rtDwarfLog_FormName(uForm)));
4634	return VINF_SUCCESS;
4635	}
4636
4637
4638	/** @callback_method_impl{FNRTDWARFATTRDECODER} */
4639	static DECLCALLBACK(int) rtDwarfDecode_String(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
4640	uint32_t uForm, PRTDWARFCURSOR pCursor)
4641	{
4642	AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(const char *), VERR_INTERNAL_ERROR_3);
4643	NOREF(pDie);
4644
4645	const char *psz;
4646	switch (uForm)
4647	{
4648	case DW_FORM_string:
4649	psz = rtDwarfCursor_GetSZ(pCursor, NULL);
4650	break;
4651
4652	case DW_FORM_strp:
4653	psz = rtDwarfDecodeHlp_GetStrp(pCursor->pDwarfMod, pCursor, NULL);
4654	break;
4655
4656	default:
4657	AssertMsgFailedReturn(("%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
4658	}
4659
4660	(const char *)pbMember = psz;
4661	Log4((" %-20s '%s' [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), psz, rtDwarfLog_FormName(uForm)));
4662	return pCursor->rc;
4663	}
4664
4665
4666	/** @callback_method_impl{FNRTDWARFATTRDECODER} */
4667	static DECLCALLBACK(int) rtDwarfDecode_UnsignedInt(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
4668	uint32_t uForm, PRTDWARFCURSOR pCursor)
4669	{
4670	NOREF(pDie);
4671	uint64_t u64Val;
4672	switch (uForm)
4673	{
4674	case DW_FORM_udata: u64Val = rtDwarfCursor_GetULeb128(pCursor, 0); break;
4675	case DW_FORM_data1: u64Val = rtDwarfCursor_GetU8(pCursor, 0); break;
4676	case DW_FORM_data2: u64Val = rtDwarfCursor_GetU16(pCursor, 0); break;
4677	case DW_FORM_data4: u64Val = rtDwarfCursor_GetU32(pCursor, 0); break;
4678	case DW_FORM_data8: u64Val = rtDwarfCursor_GetU64(pCursor, 0); break;
4679	default:
4680	AssertMsgFailedReturn(("%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
4681	}
4682	if (RT_FAILURE(pCursor->rc))
4683	return pCursor->rc;
4684
4685	switch (ATTR_GET_SIZE(pDesc))
4686	{
4687	case 1:
4688	*pbMember = (uint8_t)u64Val;
4689	if (*pbMember != u64Val)
4690	{
4691	AssertFailed();
4692	return VERR_OUT_OF_RANGE;
4693	}
4694	break;
4695
4696	case 2:
4697	(uint16_t )pbMember = (uint16_t)u64Val;
4698	if ((uint16_t )pbMember != u64Val)
4699	{
4700	AssertFailed();
4701	return VERR_OUT_OF_RANGE;
4702	}
4703	break;
4704
4705	case 4:
4706	(uint32_t )pbMember = (uint32_t)u64Val;
4707	if ((uint32_t )pbMember != u64Val)
4708	{
4709	AssertFailed();
4710	return VERR_OUT_OF_RANGE;
4711	}
4712	break;
4713
4714	case 8:
4715	(uint64_t )pbMember = (uint64_t)u64Val;
4716	if ((uint64_t )pbMember != u64Val)
4717	{
4718	AssertFailed();
4719	return VERR_OUT_OF_RANGE;
4720	}
4721	break;
4722
4723	default:
4724	AssertMsgFailedReturn(("%#x\n", ATTR_GET_SIZE(pDesc)), VERR_INTERNAL_ERROR_2);
4725	}
4726	return VINF_SUCCESS;
4727	}
4728
4729
4730	/**
4731	* Initialize location interpreter state from cursor & form.
4732	*
4733	* @returns IPRT status code.
4734	* @retval VERR_NOT_FOUND if no location information (i.e. there is source but
4735	* it resulted in no byte code).
4736	* @param pLoc The location state structure to initialize.
4737	* @param pCursor The cursor to read from.
4738	* @param uForm The attribute form.
4739	*/
4740	static int rtDwarfLoc_Init(PRTDWARFLOCST pLoc, PRTDWARFCURSOR pCursor, uint32_t uForm)
4741	{
4742	uint32_t cbBlock;
4743	switch (uForm)
4744	{
4745	case DW_FORM_block1:
4746	cbBlock = rtDwarfCursor_GetU8(pCursor, 0);
4747	break;
4748
4749	case DW_FORM_block2:
4750	cbBlock = rtDwarfCursor_GetU16(pCursor, 0);
4751	break;
4752
4753	case DW_FORM_block4:
4754	cbBlock = rtDwarfCursor_GetU32(pCursor, 0);
4755	break;
4756
4757	case DW_FORM_block:
4758	cbBlock = rtDwarfCursor_GetULeb128(pCursor, 0);
4759	break;
4760
4761	default:
4762	AssertMsgFailedReturn(("uForm=%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
4763	}
4764	if (!cbBlock)
4765	return VERR_NOT_FOUND;
4766
4767	int rc = rtDwarfCursor_InitForBlock(&pLoc->Cursor, pCursor, cbBlock);
4768	if (RT_FAILURE(rc))
4769	return rc;
4770	pLoc->iTop = -1;
4771	return VINF_SUCCESS;
4772	}
4773
4774
4775	/**
4776	* Pushes a value onto the stack.
4777	*
4778	* @returns VINF_SUCCESS or VERR_DWARF_STACK_OVERFLOW.
4779	* @param pLoc The state.
4780	* @param uValue The value to push.
4781	*/
4782	static int rtDwarfLoc_Push(PRTDWARFLOCST pLoc, uint64_t uValue)
4783	{
4784	int iTop = pLoc->iTop + 1;
4785	AssertReturn((unsigned)iTop < RT_ELEMENTS(pLoc->auStack), VERR_DWARF_STACK_OVERFLOW);
4786	pLoc->auStack[iTop] = uValue;
4787	pLoc->iTop = iTop;
4788	return VINF_SUCCESS;
4789	}
4790
4791
4792	static int rtDwarfLoc_Evaluate(PRTDWARFLOCST pLoc, void pvLater, void pvUser)
4793	{
4794	RT_NOREF_PV(pvLater); RT_NOREF_PV(pvUser);
4795
4796	while (!rtDwarfCursor_IsAtEndOfUnit(&pLoc->Cursor))
4797	{
4798	/* Read the next opcode.*/
4799	uint8_t const bOpcode = rtDwarfCursor_GetU8(&pLoc->Cursor, 0);
4800
4801	/* Get its operands. */
4802	uint64_t uOperand1 = 0;
4803	uint64_t uOperand2 = 0;
4804	switch (bOpcode)
4805	{
4806	case DW_OP_addr:
4807	uOperand1 = rtDwarfCursor_GetNativeUOff(&pLoc->Cursor, 0);
4808	break;
4809	case DW_OP_pick:
4810	case DW_OP_const1u:
4811	case DW_OP_deref_size:
4812	case DW_OP_xderef_size:
4813	uOperand1 = rtDwarfCursor_GetU8(&pLoc->Cursor, 0);
4814	break;
4815	case DW_OP_const1s:
4816	uOperand1 = (int8_t)rtDwarfCursor_GetU8(&pLoc->Cursor, 0);
4817	break;
4818	case DW_OP_const2u:
4819	uOperand1 = rtDwarfCursor_GetU16(&pLoc->Cursor, 0);
4820	break;
4821	case DW_OP_skip:
4822	case DW_OP_bra:
4823	case DW_OP_const2s:
4824	uOperand1 = (int16_t)rtDwarfCursor_GetU16(&pLoc->Cursor, 0);
4825	break;
4826	case DW_OP_const4u:
4827	uOperand1 = rtDwarfCursor_GetU32(&pLoc->Cursor, 0);
4828	break;
4829	case DW_OP_const4s:
4830	uOperand1 = (int32_t)rtDwarfCursor_GetU32(&pLoc->Cursor, 0);
4831	break;
4832	case DW_OP_const8u:
4833	uOperand1 = rtDwarfCursor_GetU64(&pLoc->Cursor, 0);
4834	break;
4835	case DW_OP_const8s:
4836	uOperand1 = rtDwarfCursor_GetU64(&pLoc->Cursor, 0);
4837	break;
4838	case DW_OP_regx:
4839	case DW_OP_piece:
4840	case DW_OP_plus_uconst:
4841	case DW_OP_constu:
4842	uOperand1 = rtDwarfCursor_GetULeb128(&pLoc->Cursor, 0);
4843	break;
4844	case DW_OP_consts:
4845	case DW_OP_fbreg:
4846	case DW_OP_breg0+0: case DW_OP_breg0+1: case DW_OP_breg0+2: case DW_OP_breg0+3:
4847	case DW_OP_breg0+4: case DW_OP_breg0+5: case DW_OP_breg0+6: case DW_OP_breg0+7:
4848	case DW_OP_breg0+8: case DW_OP_breg0+9: case DW_OP_breg0+10: case DW_OP_breg0+11:
4849	case DW_OP_breg0+12: case DW_OP_breg0+13: case DW_OP_breg0+14: case DW_OP_breg0+15:
4850	case DW_OP_breg0+16: case DW_OP_breg0+17: case DW_OP_breg0+18: case DW_OP_breg0+19:
4851	case DW_OP_breg0+20: case DW_OP_breg0+21: case DW_OP_breg0+22: case DW_OP_breg0+23:
4852	case DW_OP_breg0+24: case DW_OP_breg0+25: case DW_OP_breg0+26: case DW_OP_breg0+27:
4853	case DW_OP_breg0+28: case DW_OP_breg0+29: case DW_OP_breg0+30: case DW_OP_breg0+31:
4854	uOperand1 = rtDwarfCursor_GetSLeb128(&pLoc->Cursor, 0);
4855	break;
4856	case DW_OP_bregx:
4857	uOperand1 = rtDwarfCursor_GetULeb128(&pLoc->Cursor, 0);
4858	uOperand2 = rtDwarfCursor_GetSLeb128(&pLoc->Cursor, 0);
4859	break;
4860	}
4861	if (RT_FAILURE(pLoc->Cursor.rc))
4862	break;
4863
4864	/* Interpret the opcode. */
4865	int rc;
4866	switch (bOpcode)
4867	{
4868	case DW_OP_const1u:
4869	case DW_OP_const1s:
4870	case DW_OP_const2u:
4871	case DW_OP_const2s:
4872	case DW_OP_const4u:
4873	case DW_OP_const4s:
4874	case DW_OP_const8u:
4875	case DW_OP_const8s:
4876	case DW_OP_constu:
4877	case DW_OP_consts:
4878	case DW_OP_addr:
4879	rc = rtDwarfLoc_Push(pLoc, uOperand1);
4880	break;
4881	case DW_OP_lit0 + 0: case DW_OP_lit0 + 1: case DW_OP_lit0 + 2: case DW_OP_lit0 + 3:
4882	case DW_OP_lit0 + 4: case DW_OP_lit0 + 5: case DW_OP_lit0 + 6: case DW_OP_lit0 + 7:
4883	case DW_OP_lit0 + 8: case DW_OP_lit0 + 9: case DW_OP_lit0 + 10: case DW_OP_lit0 + 11:
4884	case DW_OP_lit0 + 12: case DW_OP_lit0 + 13: case DW_OP_lit0 + 14: case DW_OP_lit0 + 15:
4885	case DW_OP_lit0 + 16: case DW_OP_lit0 + 17: case DW_OP_lit0 + 18: case DW_OP_lit0 + 19:
4886	case DW_OP_lit0 + 20: case DW_OP_lit0 + 21: case DW_OP_lit0 + 22: case DW_OP_lit0 + 23:
4887	case DW_OP_lit0 + 24: case DW_OP_lit0 + 25: case DW_OP_lit0 + 26: case DW_OP_lit0 + 27:
4888	case DW_OP_lit0 + 28: case DW_OP_lit0 + 29: case DW_OP_lit0 + 30: case DW_OP_lit0 + 31:
4889	rc = rtDwarfLoc_Push(pLoc, bOpcode - DW_OP_lit0);
4890	break;
4891	case DW_OP_nop:
4892	break;
4893	case DW_OP_dup: /** @todo 0 operands. */
4894	case DW_OP_drop: /** @todo 0 operands. */
4895	case DW_OP_over: /** @todo 0 operands. */
4896	case DW_OP_pick: /** @todo 1 operands, a 1-byte stack index. */
4897	case DW_OP_swap: /** @todo 0 operands. */
4898	case DW_OP_rot: /** @todo 0 operands. */
4899	case DW_OP_abs: /** @todo 0 operands. */
4900	case DW_OP_and: /** @todo 0 operands. */
4901	case DW_OP_div: /** @todo 0 operands. */
4902	case DW_OP_minus: /** @todo 0 operands. */
4903	case DW_OP_mod: /** @todo 0 operands. */
4904	case DW_OP_mul: /** @todo 0 operands. */
4905	case DW_OP_neg: /** @todo 0 operands. */
4906	case DW_OP_not: /** @todo 0 operands. */
4907	case DW_OP_or: /** @todo 0 operands. */
4908	case DW_OP_plus: /** @todo 0 operands. */
4909	case DW_OP_plus_uconst: /** @todo 1 operands, a ULEB128 addend. */
4910	case DW_OP_shl: /** @todo 0 operands. */
4911	case DW_OP_shr: /** @todo 0 operands. */
4912	case DW_OP_shra: /** @todo 0 operands. */
4913	case DW_OP_xor: /** @todo 0 operands. */
4914	case DW_OP_skip: /** @todo 1 signed 2-byte constant. */
4915	case DW_OP_bra: /** @todo 1 signed 2-byte constant. */
4916	case DW_OP_eq: /** @todo 0 operands. */
4917	case DW_OP_ge: /** @todo 0 operands. */
4918	case DW_OP_gt: /** @todo 0 operands. */
4919	case DW_OP_le: /** @todo 0 operands. */
4920	case DW_OP_lt: /** @todo 0 operands. */
4921	case DW_OP_ne: /** @todo 0 operands. */
4922	case DW_OP_reg0 + 0: case DW_OP_reg0 + 1: case DW_OP_reg0 + 2: case DW_OP_reg0 + 3: /** @todo 0 operands - reg 0..31. */
4923	case DW_OP_reg0 + 4: case DW_OP_reg0 + 5: case DW_OP_reg0 + 6: case DW_OP_reg0 + 7:
4924	case DW_OP_reg0 + 8: case DW_OP_reg0 + 9: case DW_OP_reg0 + 10: case DW_OP_reg0 + 11:
4925	case DW_OP_reg0 + 12: case DW_OP_reg0 + 13: case DW_OP_reg0 + 14: case DW_OP_reg0 + 15:
4926	case DW_OP_reg0 + 16: case DW_OP_reg0 + 17: case DW_OP_reg0 + 18: case DW_OP_reg0 + 19:
4927	case DW_OP_reg0 + 20: case DW_OP_reg0 + 21: case DW_OP_reg0 + 22: case DW_OP_reg0 + 23:
4928	case DW_OP_reg0 + 24: case DW_OP_reg0 + 25: case DW_OP_reg0 + 26: case DW_OP_reg0 + 27:
4929	case DW_OP_reg0 + 28: case DW_OP_reg0 + 29: case DW_OP_reg0 + 30: case DW_OP_reg0 + 31:
4930	case DW_OP_breg0+ 0: case DW_OP_breg0+ 1: case DW_OP_breg0+ 2: case DW_OP_breg0+ 3: /** @todo 1 operand, a SLEB128 offset. */
4931	case DW_OP_breg0+ 4: case DW_OP_breg0+ 5: case DW_OP_breg0+ 6: case DW_OP_breg0+ 7:
4932	case DW_OP_breg0+ 8: case DW_OP_breg0+ 9: case DW_OP_breg0+ 10: case DW_OP_breg0+ 11:
4933	case DW_OP_breg0+ 12: case DW_OP_breg0+ 13: case DW_OP_breg0+ 14: case DW_OP_breg0+ 15:
4934	case DW_OP_breg0+ 16: case DW_OP_breg0+ 17: case DW_OP_breg0+ 18: case DW_OP_breg0+ 19:
4935	case DW_OP_breg0+ 20: case DW_OP_breg0+ 21: case DW_OP_breg0+ 22: case DW_OP_breg0+ 23:
4936	case DW_OP_breg0+ 24: case DW_OP_breg0+ 25: case DW_OP_breg0+ 26: case DW_OP_breg0+ 27:
4937	case DW_OP_breg0+ 28: case DW_OP_breg0+ 29: case DW_OP_breg0+ 30: case DW_OP_breg0+ 31:
4938	case DW_OP_piece: /** @todo 1 operand, a ULEB128 size of piece addressed. */
4939	case DW_OP_regx: /** @todo 1 operand, a ULEB128 register. */
4940	case DW_OP_fbreg: /** @todo 1 operand, a SLEB128 offset. */
4941	case DW_OP_bregx: /** @todo 2 operands, a ULEB128 register followed by a SLEB128 offset. */
4942	case DW_OP_deref: /** @todo 0 operands. */
4943	case DW_OP_deref_size: /** @todo 1 operand, a 1-byte size of data retrieved. */
4944	case DW_OP_xderef: /** @todo 0 operands. */
4945	case DW_OP_xderef_size: /** @todo 1 operand, a 1-byte size of data retrieved. */
4946	AssertMsgFailedReturn(("bOpcode=%#x\n", bOpcode), VERR_DWARF_TODO);
4947	default:
4948	AssertMsgFailedReturn(("bOpcode=%#x\n", bOpcode), VERR_DWARF_UNKNOWN_LOC_OPCODE);
4949	}
4950	}
4951
4952	return pLoc->Cursor.rc;
4953	}
4954
4955
4956	/** @callback_method_impl{FNRTDWARFATTRDECODER} */
4957	static DECLCALLBACK(int) rtDwarfDecode_SegmentLoc(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
4958	uint32_t uForm, PRTDWARFCURSOR pCursor)
4959	{
4960	NOREF(pDie);
4961	AssertReturn(ATTR_GET_SIZE(pDesc) == 2, VERR_DWARF_IPE);
4962
4963	int rc;
4964	if ( uForm == DW_FORM_block
4965	\|\| uForm == DW_FORM_block1
4966	\|\| uForm == DW_FORM_block2
4967	\|\| uForm == DW_FORM_block4)
4968	{
4969	RTDWARFLOCST LocSt;
4970	rc = rtDwarfLoc_Init(&LocSt, pCursor, uForm);
4971	if (RT_SUCCESS(rc))
4972	{
4973	rc = rtDwarfLoc_Evaluate(&LocSt, NULL, NULL);
4974	if (RT_SUCCESS(rc))
4975	{
4976	if (LocSt.iTop >= 0)
4977	{
4978	(uint16_t )pbMember = LocSt.auStack[LocSt.iTop];
4979	Log4((" %-20s %#06llx [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr),
4980	LocSt.auStack[LocSt.iTop], rtDwarfLog_FormName(uForm)));
4981	return VINF_SUCCESS;
4982	}
4983	rc = VERR_DWARF_STACK_UNDERFLOW;
4984	}
4985	}
4986	}
4987	else
4988	rc = rtDwarfDecode_UnsignedInt(pDie, pbMember, pDesc, uForm, pCursor);
4989	return rc;
4990	}
4991
4992	/*
4993	*
4994	* DWARF debug_info parser
4995	* DWARF debug_info parser
4996	* DWARF debug_info parser
4997	*
4998	*/
4999
5000
5001	/**
5002	* Special hack to get the name and/or linkage name for a subprogram via a
5003	* specification reference.
5004	*
5005	* Since this is a hack, we ignore failure.
5006	*
5007	* If we want to really make use of DWARF info, we'll have to create some kind
5008	* of lookup tree for handling this. But currently we don't, so a hack will
5009	* suffice.
5010	*
5011	* @param pThis The DWARF instance.
5012	* @param pSubProgram The subprogram which is short on names.
5013	*/
5014	static void rtDwarfInfo_TryGetSubProgramNameFromSpecRef(PRTDBGMODDWARF pThis, PRTDWARFDIESUBPROGRAM pSubProgram)
5015	{
5016	/*
5017	* Must have a spec ref, and it must be in the info section.
5018	*/
5019	if (pSubProgram->SpecRef.enmWrt != krtDwarfRef_InfoSection)
5020	return;
5021
5022	/*
5023	* Create a cursor for reading the info and then the abbrivation code
5024	* starting the off the DIE.
5025	*/
5026	RTDWARFCURSOR InfoCursor;
5027	int rc = rtDwarfCursor_InitWithOffset(&InfoCursor, pThis, krtDbgModDwarfSect_info, pSubProgram->SpecRef.off);
5028	if (RT_FAILURE(rc))
5029	return;
5030
5031	uint32_t uAbbrCode = rtDwarfCursor_GetULeb128AsU32(&InfoCursor, UINT32_MAX);
5032	if (uAbbrCode)
5033	{
5034	/* Only references to subprogram tags are interesting here. */
5035	PCRTDWARFABBREV pAbbrev = rtDwarfAbbrev_Lookup(pThis, uAbbrCode);
5036	if ( pAbbrev
5037	&& pAbbrev->uTag == DW_TAG_subprogram)
5038	{
5039	/*
5040	* Use rtDwarfInfo_ParseDie to do the parsing, but with a different
5041	* attribute spec than usual.
5042	*/
5043	rtDwarfInfo_ParseDie(pThis, &pSubProgram->Core, &g_SubProgramSpecHackDesc, &InfoCursor,
5044	pAbbrev, false /fInitDie/);
5045	}
5046	}
5047
5048	rtDwarfCursor_Delete(&InfoCursor, VINF_SUCCESS);
5049	}
5050
5051
5052	/**
5053	* Select which name to use.
5054	*
5055	* @returns One of the names.
5056	* @param pszName The DWARF name, may exclude namespace and class.
5057	* Can also be NULL.
5058	* @param pszLinkageName The linkage name. Can be NULL.
5059	*/
5060	static const char rtDwarfInfo_SelectName(const char pszName, const char *pszLinkageName)
5061	{
5062	if (!pszName \|\| !pszLinkageName)
5063	return pszName ? pszName : pszLinkageName;
5064
5065	/*
5066	* Some heuristics for selecting the link name if the normal name is missing
5067	* namespace or class prefixes.
5068	*/
5069	size_t cchName = strlen(pszName);
5070	size_t cchLinkageName = strlen(pszLinkageName);
5071	if (cchLinkageName <= cchName + 1)
5072	return pszName;
5073
5074	const char *psz = strstr(pszLinkageName, pszName);
5075	if (!psz \|\| psz - pszLinkageName < 4)
5076	return pszName;
5077
5078	return pszLinkageName;
5079	}
5080
5081
5082	/**
5083	* Parse the attributes of a DIE.
5084	*
5085	* @returns IPRT status code.
5086	* @param pThis The DWARF instance.
5087	* @param pDie The internal DIE structure to fill.
5088	*/
5089	static int rtDwarfInfo_SnoopSymbols(PRTDBGMODDWARF pThis, PRTDWARFDIE pDie)
5090	{
5091	int rc = VINF_SUCCESS;
5092	switch (pDie->uTag)
5093	{
5094	case DW_TAG_subprogram:
5095	{
5096	PRTDWARFDIESUBPROGRAM pSubProgram = (PRTDWARFDIESUBPROGRAM)pDie;
5097
5098	/* Obtain referenced specification there is only partial info. */
5099	if ( pSubProgram->PcRange.cAttrs
5100	&& !pSubProgram->pszName)
5101	rtDwarfInfo_TryGetSubProgramNameFromSpecRef(pThis, pSubProgram);
5102
5103	if (pSubProgram->PcRange.cAttrs)
5104	{
5105	if (pSubProgram->PcRange.fHaveRanges)
5106	Log5(("subprogram %s (%s) <implement ranges>\n", pSubProgram->pszName, pSubProgram->pszLinkageName));
5107	else
5108	{
5109	Log5(("subprogram %s (%s) %#llx-%#llx%s\n", pSubProgram->pszName, pSubProgram->pszLinkageName,
5110	pSubProgram->PcRange.uLowAddress, pSubProgram->PcRange.uHighAddress,
5111	pSubProgram->PcRange.cAttrs == 2 ? "" : " !bad!"));
5112	if ( ( pSubProgram->pszName \|\| pSubProgram->pszLinkageName)
5113	&& pSubProgram->PcRange.cAttrs == 2)
5114	{
5115	if (pThis->iWatcomPass == 1)
5116	rc = rtDbgModDwarfRecordSegOffset(pThis, pSubProgram->uSegment, pSubProgram->PcRange.uHighAddress);
5117	else
5118	{
5119	RTDBGSEGIDX iSeg;
5120	RTUINTPTR offSeg;
5121	rc = rtDbgModDwarfLinkAddressToSegOffset(pThis, pSubProgram->uSegment,
5122	pSubProgram->PcRange.uLowAddress,
5123	&iSeg, &offSeg);
5124	if (RT_SUCCESS(rc))
5125	{
5126	uint64_t cb;
5127	if (pSubProgram->PcRange.uHighAddress >= pSubProgram->PcRange.uLowAddress)
5128	cb = pSubProgram->PcRange.uHighAddress - pSubProgram->PcRange.uLowAddress;
5129	else
5130	cb = 1;
5131	rc = RTDbgModSymbolAdd(pThis->hCnt,
5132	rtDwarfInfo_SelectName(pSubProgram->pszName, pSubProgram->pszLinkageName),
5133	iSeg, offSeg, cb, 0 /fFlags/, NULL /piOrdinal/);
5134	if (RT_FAILURE(rc))
5135	{
5136	if ( rc == VERR_DBG_DUPLICATE_SYMBOL
5137	\|\| rc == VERR_DBG_ADDRESS_CONFLICT /** @todo figure why this happens with 10.6.8 mach_kernel, 32-bit. */
5138	)
5139	rc = VINF_SUCCESS;
5140	else
5141	AssertMsgFailed(("%Rrc\n", rc));
5142	}
5143	}
5144	else if ( pSubProgram->PcRange.uLowAddress == 0 /* see with vmlinux */
5145	&& pSubProgram->PcRange.uHighAddress == 0)
5146	{
5147	Log5(("rtDbgModDwarfLinkAddressToSegOffset: Ignoring empty range.\n"));
5148	rc = VINF_SUCCESS; /* ignore */
5149	}
5150	else
5151	{
5152	AssertRC(rc);
5153	Log5(("rtDbgModDwarfLinkAddressToSegOffset failed: %Rrc\n", rc));
5154	}
5155	}
5156	}
5157	}
5158	}
5159	else
5160	Log5(("subprogram %s (%s) external\n", pSubProgram->pszName, pSubProgram->pszLinkageName));
5161	break;
5162	}
5163
5164	case DW_TAG_label:
5165	{
5166	PCRTDWARFDIELABEL pLabel = (PCRTDWARFDIELABEL)pDie;
5167	//if (pLabel->fExternal)
5168	{
5169	Log5(("label %s %#x:%#llx\n", pLabel->pszName, pLabel->uSegment, pLabel->Address.uAddress));
5170	if (pThis->iWatcomPass == 1)
5171	rc = rtDbgModDwarfRecordSegOffset(pThis, pLabel->uSegment, pLabel->Address.uAddress);
5172	else if (pLabel->pszName && pLabel->pszName != '\0') / Seen empty labels with isolinux. */
5173	{
5174	RTDBGSEGIDX iSeg;
5175	RTUINTPTR offSeg;
5176	rc = rtDbgModDwarfLinkAddressToSegOffset(pThis, pLabel->uSegment, pLabel->Address.uAddress,
5177	&iSeg, &offSeg);
5178	AssertRC(rc);
5179	if (RT_SUCCESS(rc))
5180	{
5181	rc = RTDbgModSymbolAdd(pThis->hCnt, pLabel->pszName, iSeg, offSeg, 0 /cb/,
5182	0 /fFlags/, NULL /piOrdinal/);
5183	AssertMsg(RT_SUCCESS(rc) \|\| rc == VERR_DBG_ADDRESS_CONFLICT,
5184	("%Rrc %s %x:%x\n", rc, pLabel->pszName, iSeg, offSeg));
5185	}
5186	else
5187	Log5(("rtDbgModDwarfLinkAddressToSegOffset failed: %Rrc\n", rc));
5188
5189	/* Ignore errors regarding local labels. */
5190	if (RT_FAILURE(rc) && !pLabel->fExternal)
5191	rc = -rc;
5192	}
5193
5194	}
5195	break;
5196	}
5197
5198	}
5199	return rc;
5200	}
5201
5202
5203	/**
5204	* Initializes the non-core fields of an internal DIE structure.
5205	*
5206	* @param pDie The DIE structure.
5207	* @param pDieDesc The DIE descriptor.
5208	*/
5209	static void rtDwarfInfo_InitDie(PRTDWARFDIE pDie, PCRTDWARFDIEDESC pDieDesc)
5210	{
5211	size_t i = pDieDesc->cAttributes;
5212	while (i-- > 0)
5213	{
5214	switch (pDieDesc->paAttributes[i].cbInit & ATTR_INIT_MASK)
5215	{
5216	case ATTR_INIT_ZERO:
5217	/* Nothing to do (RTMemAllocZ). */
5218	break;
5219
5220	case ATTR_INIT_FFFS:
5221	switch (pDieDesc->paAttributes[i].cbInit & ATTR_SIZE_MASK)
5222	{
5223	case 1:
5224	(uint8_t )((uintptr_t)pDie + pDieDesc->paAttributes[i].off) = UINT8_MAX;
5225	break;
5226	case 2:
5227	(uint16_t )((uintptr_t)pDie + pDieDesc->paAttributes[i].off) = UINT16_MAX;
5228	break;
5229	case 4:
5230	(uint32_t )((uintptr_t)pDie + pDieDesc->paAttributes[i].off) = UINT32_MAX;
5231	break;
5232	case 8:
5233	(uint64_t )((uintptr_t)pDie + pDieDesc->paAttributes[i].off) = UINT64_MAX;
5234	break;
5235	default:
5236	AssertFailed();
5237	memset((uint8_t *)pDie + pDieDesc->paAttributes[i].off, 0xff,
5238	pDieDesc->paAttributes[i].cbInit & ATTR_SIZE_MASK);
5239	break;
5240	}
5241	break;
5242
5243	default:
5244	AssertFailed();
5245	}
5246	}
5247	}
5248
5249
5250	/**
5251	* Creates a new internal DIE structure and links it up.
5252	*
5253	* @returns Pointer to the new DIE structure.
5254	* @param pThis The DWARF instance.
5255	* @param pDieDesc The DIE descriptor (for size and init).
5256	* @param pAbbrev The abbreviation cache entry.
5257	* @param pParent The parent DIE (NULL if unit).
5258	*/
5259	static PRTDWARFDIE rtDwarfInfo_NewDie(PRTDBGMODDWARF pThis, PCRTDWARFDIEDESC pDieDesc,
5260	PCRTDWARFABBREV pAbbrev, PRTDWARFDIE pParent)
5261	{
5262	NOREF(pThis);
5263	Assert(pDieDesc->cbDie >= sizeof(RTDWARFDIE));
5264	#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
5265	uint32_t iAllocator = pDieDesc->cbDie > pThis->aDieAllocators[0].cbMax;
5266	Assert(pDieDesc->cbDie <= pThis->aDieAllocators[iAllocator].cbMax);
5267	PRTDWARFDIE pDie = (PRTDWARFDIE)RTMemCacheAlloc(pThis->aDieAllocators[iAllocator].hMemCache);
5268	#else
5269	PRTDWARFDIE pDie = (PRTDWARFDIE)RTMemAllocZ(pDieDesc->cbDie);
5270	#endif
5271	if (pDie)
5272	{
5273	#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
5274	RT_BZERO(pDie, pDieDesc->cbDie);
5275	pDie->iAllocator = iAllocator;
5276	#endif
5277	rtDwarfInfo_InitDie(pDie, pDieDesc);
5278
5279	pDie->uTag = pAbbrev->uTag;
5280	pDie->offSpec = pAbbrev->offSpec;
5281	pDie->pParent = pParent;
5282	if (pParent)
5283	RTListAppend(&pParent->ChildList, &pDie->SiblingNode);
5284	else
5285	RTListInit(&pDie->SiblingNode);
5286	RTListInit(&pDie->ChildList);
5287
5288	}
5289	return pDie;
5290	}
5291
5292
5293	/**
5294	* Free all children of a DIE.
5295	*
5296	* @param pThis The DWARF instance.
5297	* @param pParentDie The parent DIE.
5298	*/
5299	static void rtDwarfInfo_FreeChildren(PRTDBGMODDWARF pThis, PRTDWARFDIE pParentDie)
5300	{
5301	PRTDWARFDIE pChild, pNextChild;
5302	RTListForEachSafe(&pParentDie->ChildList, pChild, pNextChild, RTDWARFDIE, SiblingNode)
5303	{
5304	if (!RTListIsEmpty(&pChild->ChildList))
5305	rtDwarfInfo_FreeChildren(pThis, pChild);
5306	RTListNodeRemove(&pChild->SiblingNode);
5307	#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
5308	RTMemCacheFree(pThis->aDieAllocators[pChild->iAllocator].hMemCache, pChild);
5309	#else
5310	RTMemFree(pChild);
5311	#endif
5312	}
5313	}
5314
5315
5316	/**
5317	* Free a DIE an all its children.
5318	*
5319	* @param pThis The DWARF instance.
5320	* @param pDie The DIE to free.
5321	*/
5322	static void rtDwarfInfo_FreeDie(PRTDBGMODDWARF pThis, PRTDWARFDIE pDie)
5323	{
5324	rtDwarfInfo_FreeChildren(pThis, pDie);
5325	RTListNodeRemove(&pDie->SiblingNode);
5326	#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
5327	RTMemCacheFree(pThis->aDieAllocators[pDie->iAllocator].hMemCache, pDie);
5328	#else
5329	RTMemFree(pChild);
5330	#endif
5331	}
5332
5333
5334	/**
5335	* Skips a form.
5336	* @returns IPRT status code
5337	* @param pCursor The cursor.
5338	* @param uForm The form to skip.
5339	*/
5340	static int rtDwarfInfo_SkipForm(PRTDWARFCURSOR pCursor, uint32_t uForm)
5341	{
5342	switch (uForm)
5343	{
5344	case DW_FORM_addr:
5345	return rtDwarfCursor_SkipBytes(pCursor, pCursor->cbNativeAddr);
5346
5347	case DW_FORM_block:
5348	case DW_FORM_exprloc:
5349	return rtDwarfCursor_SkipBytes(pCursor, rtDwarfCursor_GetULeb128(pCursor, 0));
5350
5351	case DW_FORM_block1:
5352	return rtDwarfCursor_SkipBytes(pCursor, rtDwarfCursor_GetU8(pCursor, 0));
5353
5354	case DW_FORM_block2:
5355	return rtDwarfCursor_SkipBytes(pCursor, rtDwarfCursor_GetU16(pCursor, 0));
5356
5357	case DW_FORM_block4:
5358	return rtDwarfCursor_SkipBytes(pCursor, rtDwarfCursor_GetU32(pCursor, 0));
5359
5360	case DW_FORM_data1:
5361	case DW_FORM_ref1:
5362	case DW_FORM_flag:
5363	return rtDwarfCursor_SkipBytes(pCursor, 1);
5364
5365	case DW_FORM_data2:
5366	case DW_FORM_ref2:
5367	return rtDwarfCursor_SkipBytes(pCursor, 2);
5368
5369	case DW_FORM_data4:
5370	case DW_FORM_ref4:
5371	return rtDwarfCursor_SkipBytes(pCursor, 4);
5372
5373	case DW_FORM_data8:
5374	case DW_FORM_ref8:
5375	case DW_FORM_ref_sig8:
5376	return rtDwarfCursor_SkipBytes(pCursor, 8);
5377
5378	case DW_FORM_udata:
5379	case DW_FORM_sdata:
5380	case DW_FORM_ref_udata:
5381	return rtDwarfCursor_SkipLeb128(pCursor);
5382
5383	case DW_FORM_string:
5384	rtDwarfCursor_GetSZ(pCursor, NULL);
5385	return pCursor->rc;
5386
5387	case DW_FORM_indirect:
5388	return rtDwarfInfo_SkipForm(pCursor, rtDwarfCursor_GetULeb128AsU32(pCursor, UINT32_MAX));
5389
5390	case DW_FORM_strp:
5391	case DW_FORM_ref_addr:
5392	case DW_FORM_sec_offset:
5393	return rtDwarfCursor_SkipBytes(pCursor, pCursor->f64bitDwarf ? 8 : 4);
5394
5395	case DW_FORM_flag_present:
5396	return pCursor->rc; /* no data */
5397
5398	default:
5399	Log(("rtDwarfInfo_SkipForm: Unknown form %#x\n", uForm));
5400	return VERR_DWARF_UNKNOWN_FORM;
5401	}
5402	}
5403
5404
5405
5406	#ifdef SOME_UNUSED_FUNCTION
5407	/**
5408	* Skips a DIE.
5409	*
5410	* @returns IPRT status code.
5411	* @param pCursor The cursor.
5412	* @param pAbbrevCursor The abbreviation cursor.
5413	*/
5414	static int rtDwarfInfo_SkipDie(PRTDWARFCURSOR pCursor, PRTDWARFCURSOR pAbbrevCursor)
5415	{
5416	for (;;)
5417	{
5418	uint32_t uAttr = rtDwarfCursor_GetULeb128AsU32(pAbbrevCursor, 0);
5419	uint32_t uForm = rtDwarfCursor_GetULeb128AsU32(pAbbrevCursor, 0);
5420	if (uAttr == 0 && uForm == 0)
5421	break;
5422
5423	int rc = rtDwarfInfo_SkipForm(pCursor, uForm);
5424	if (RT_FAILURE(rc))
5425	return rc;
5426	}
5427	return RT_FAILURE(pCursor->rc) ? pCursor->rc : pAbbrevCursor->rc;
5428	}
5429	#endif
5430
5431
5432	/**
5433	* Parse the attributes of a DIE.
5434	*
5435	* @returns IPRT status code.
5436	* @param pThis The DWARF instance.
5437	* @param pDie The internal DIE structure to fill.
5438	* @param pDieDesc The DIE descriptor.
5439	* @param pCursor The debug_info cursor.
5440	* @param pAbbrev The abbreviation cache entry.
5441	* @param fInitDie Whether to initialize the DIE first. If not (@c
5442	* false) it's safe to assume we're following a
5443	* DW_AT_specification or DW_AT_abstract_origin,
5444	* and that we shouldn't be snooping any symbols.
5445	*/
5446	static int rtDwarfInfo_ParseDie(PRTDBGMODDWARF pThis, PRTDWARFDIE pDie, PCRTDWARFDIEDESC pDieDesc,
5447	PRTDWARFCURSOR pCursor, PCRTDWARFABBREV pAbbrev, bool fInitDie)
5448	{
5449	RTDWARFCURSOR AbbrevCursor;
5450	int rc = rtDwarfCursor_InitWithOffset(&AbbrevCursor, pThis, krtDbgModDwarfSect_abbrev, pAbbrev->offSpec);
5451	if (RT_FAILURE(rc))
5452	return rc;
5453
5454	if (fInitDie)
5455	rtDwarfInfo_InitDie(pDie, pDieDesc);
5456	for (;;)
5457	{
5458	#ifdef LOG_ENABLED
5459	uint32_t const off = (uint32_t)(AbbrevCursor.pb - AbbrevCursor.pbStart);
5460	#endif
5461	uint32_t uAttr = rtDwarfCursor_GetULeb128AsU32(&AbbrevCursor, 0);
5462	uint32_t uForm = rtDwarfCursor_GetULeb128AsU32(&AbbrevCursor, 0);
5463	Log4((" %04x: %-23s [%s]\n", off, rtDwarfLog_AttrName(uAttr), rtDwarfLog_FormName(uForm)));
5464	if (uAttr == 0)
5465	break;
5466	if (uForm == DW_FORM_indirect)
5467	uForm = rtDwarfCursor_GetULeb128AsU32(pCursor, 0);
5468
5469	/* Look up the attribute in the descriptor and invoke the decoder. */
5470	PCRTDWARFATTRDESC pAttr = NULL;
5471	size_t i = pDieDesc->cAttributes;
5472	while (i-- > 0)
5473	if (pDieDesc->paAttributes[i].uAttr == uAttr)
5474	{
5475	pAttr = &pDieDesc->paAttributes[i];
5476	rc = pAttr->pfnDecoder(pDie, (uint8_t *)pDie + pAttr->off, pAttr, uForm, pCursor);
5477	break;
5478	}
5479
5480	/* Some house keeping. */
5481	if (pAttr)
5482	pDie->cDecodedAttrs++;
5483	else
5484	{
5485	pDie->cUnhandledAttrs++;
5486	rc = rtDwarfInfo_SkipForm(pCursor, uForm);
5487	}
5488	if (RT_FAILURE(rc))
5489	break;
5490	}
5491
5492	rc = rtDwarfCursor_Delete(&AbbrevCursor, rc);
5493	if (RT_SUCCESS(rc))
5494	rc = pCursor->rc;
5495
5496	/*
5497	* Snoop up symbols on the way out.
5498	*/
5499	if (RT_SUCCESS(rc) && fInitDie)
5500	{
5501	rc = rtDwarfInfo_SnoopSymbols(pThis, pDie);
5502	/* Ignore duplicates, get work done instead. */
5503	/** @todo clean up global/static symbol mess. */
5504	if (rc == VERR_DBG_DUPLICATE_SYMBOL \|\| rc == VERR_DBG_ADDRESS_CONFLICT)
5505	rc = VINF_SUCCESS;
5506	}
5507
5508	return rc;
5509	}
5510
5511
5512	/**
5513	* Load the debug information of a unit.
5514	*
5515	* @returns IPRT status code.
5516	* @param pThis The DWARF instance.
5517	* @param pCursor The debug_info cursor.
5518	* @param fKeepDies Whether to keep the DIEs or discard them as soon
5519	* as possible.
5520	*/
5521	static int rtDwarfInfo_LoadUnit(PRTDBGMODDWARF pThis, PRTDWARFCURSOR pCursor, bool fKeepDies)
5522	{
5523	Log(("rtDwarfInfo_LoadUnit: %#x\n", rtDwarfCursor_CalcSectOffsetU32(pCursor)));
5524
5525	/*
5526	* Read the compilation unit header.
5527	*/
5528	uint64_t offUnit = rtDwarfCursor_CalcSectOffsetU32(pCursor);
5529	uint64_t cbUnit = rtDwarfCursor_GetInitialLength(pCursor);
5530	cbUnit += rtDwarfCursor_CalcSectOffsetU32(pCursor) - offUnit;
5531	uint16_t const uVer = rtDwarfCursor_GetUHalf(pCursor, 0);
5532	if ( uVer < 2
5533	\|\| uVer > 4)
5534	return rtDwarfCursor_SkipUnit(pCursor);
5535	uint64_t const offAbbrev = rtDwarfCursor_GetUOff(pCursor, UINT64_MAX);
5536	uint8_t const cbNativeAddr = rtDwarfCursor_GetU8(pCursor, UINT8_MAX);
5537	if (RT_FAILURE(pCursor->rc))
5538	return pCursor->rc;
5539	Log((" uVer=%d offAbbrev=%#llx cbNativeAddr=%d\n", uVer, offAbbrev, cbNativeAddr));
5540
5541	/*
5542	* Set up the abbreviation cache and store the native address size in the cursor.
5543	*/
5544	if (offAbbrev > UINT32_MAX)
5545	{
5546	Log(("Unexpected abbrviation code offset of %#llx\n", offAbbrev));
5547	return VERR_DWARF_BAD_INFO;
5548	}
5549	rtDwarfAbbrev_SetUnitOffset(pThis, (uint32_t)offAbbrev);
5550	pCursor->cbNativeAddr = cbNativeAddr;
5551
5552	/*
5553	* The first DIE is a compile or partial unit, parse it here.
5554	*/
5555	uint32_t uAbbrCode = rtDwarfCursor_GetULeb128AsU32(pCursor, UINT32_MAX);
5556	if (!uAbbrCode)
5557	{
5558	Log(("Unexpected abbrviation code of zero\n"));
5559	return VERR_DWARF_BAD_INFO;
5560	}
5561	PCRTDWARFABBREV pAbbrev = rtDwarfAbbrev_Lookup(pThis, uAbbrCode);
5562	if (!pAbbrev)
5563	return VERR_DWARF_ABBREV_NOT_FOUND;
5564	if ( pAbbrev->uTag != DW_TAG_compile_unit
5565	&& pAbbrev->uTag != DW_TAG_partial_unit)
5566	{
5567	Log(("Unexpected compile/partial unit tag %#x\n", pAbbrev->uTag));
5568	return VERR_DWARF_BAD_INFO;
5569	}
5570
5571	PRTDWARFDIECOMPILEUNIT pUnit;
5572	pUnit = (PRTDWARFDIECOMPILEUNIT)rtDwarfInfo_NewDie(pThis, &g_CompileUnitDesc, pAbbrev, NULL /pParent/);
5573	if (!pUnit)
5574	return VERR_NO_MEMORY;
5575	pUnit->offUnit = offUnit;
5576	pUnit->cbUnit = cbUnit;
5577	pUnit->offAbbrev = offAbbrev;
5578	pUnit->cbNativeAddr = cbNativeAddr;
5579	pUnit->uDwarfVer = (uint8_t)uVer;
5580	RTListAppend(&pThis->CompileUnitList, &pUnit->Core.SiblingNode);
5581
5582	int rc = rtDwarfInfo_ParseDie(pThis, &pUnit->Core, &g_CompileUnitDesc, pCursor, pAbbrev, true /fInitDie/);
5583	if (RT_FAILURE(rc))
5584	return rc;
5585
5586	/*
5587	* Parse DIEs.
5588	*/
5589	uint32_t cDepth = 0;
5590	PRTDWARFDIE pParentDie = &pUnit->Core;
5591	while (!rtDwarfCursor_IsAtEndOfUnit(pCursor))
5592	{
5593	#ifdef LOG_ENABLED
5594	uint32_t offLog = rtDwarfCursor_CalcSectOffsetU32(pCursor);
5595	#endif
5596	uAbbrCode = rtDwarfCursor_GetULeb128AsU32(pCursor, UINT32_MAX);
5597	if (!uAbbrCode)
5598	{
5599	/* End of siblings, up one level. (Is this correct?) */
5600	if (pParentDie->pParent)
5601	{
5602	pParentDie = pParentDie->pParent;
5603	cDepth--;
5604	if (!fKeepDies && pParentDie->pParent)
5605	rtDwarfInfo_FreeChildren(pThis, pParentDie);
5606	}
5607	}
5608	else
5609	{
5610	/*
5611	* Look up the abbreviation and match the tag up with a descriptor.
5612	*/
5613	pAbbrev = rtDwarfAbbrev_Lookup(pThis, uAbbrCode);
5614	if (!pAbbrev)
5615	return VERR_DWARF_ABBREV_NOT_FOUND;
5616
5617	PCRTDWARFDIEDESC pDieDesc;
5618	const char *pszName;
5619	if (pAbbrev->uTag < RT_ELEMENTS(g_aTagDescs))
5620	{
5621	Assert(g_aTagDescs[pAbbrev->uTag].uTag == pAbbrev->uTag \|\| g_aTagDescs[pAbbrev->uTag].uTag == 0);
5622	pszName = g_aTagDescs[pAbbrev->uTag].pszName;
5623	pDieDesc = g_aTagDescs[pAbbrev->uTag].pDesc;
5624	}
5625	else
5626	{
5627	pszName = "<unknown>";
5628	pDieDesc = &g_CoreDieDesc;
5629	}
5630	Log4(("%08x: %stag=%s (%#x, abbrev %u @ %#x)%s\n", offLog, cDepth 2, "", pszName,
5631	pAbbrev->uTag, uAbbrCode, pAbbrev->offSpec - pAbbrev->cbHdr, pAbbrev->fChildren ? " has children" : ""));
5632
5633	/*
5634	* Create a new internal DIE structure and parse the
5635	* attributes.
5636	*/
5637	PRTDWARFDIE pNewDie = rtDwarfInfo_NewDie(pThis, pDieDesc, pAbbrev, pParentDie);
5638	if (!pNewDie)
5639	return VERR_NO_MEMORY;
5640
5641	if (pAbbrev->fChildren)
5642	{
5643	pParentDie = pNewDie;
5644	cDepth++;
5645	}
5646
5647	rc = rtDwarfInfo_ParseDie(pThis, pNewDie, pDieDesc, pCursor, pAbbrev, true /fInitDie/);
5648	if (RT_FAILURE(rc))
5649	return rc;
5650
5651	if (!fKeepDies && !pAbbrev->fChildren)
5652	rtDwarfInfo_FreeDie(pThis, pNewDie);
5653	}
5654	} /* while more DIEs */
5655
5656
5657	/* Unlink and free child DIEs if told to do so. */
5658	if (!fKeepDies)
5659	rtDwarfInfo_FreeChildren(pThis, &pUnit->Core);
5660
5661	return RT_SUCCESS(rc) ? pCursor->rc : rc;
5662	}
5663
5664
5665	/**
5666	* Extracts the symbols.
5667	*
5668	* The symbols are insered into the debug info container.
5669	*
5670	* @returns IPRT status code
5671	* @param pThis The DWARF instance.
5672	*/
5673	static int rtDwarfInfo_LoadAll(PRTDBGMODDWARF pThis)
5674	{
5675	RTDWARFCURSOR Cursor;
5676	int rc = rtDwarfCursor_Init(&Cursor, pThis, krtDbgModDwarfSect_info);
5677	if (RT_SUCCESS(rc))
5678	{
5679	while ( !rtDwarfCursor_IsAtEnd(&Cursor)
5680	&& RT_SUCCESS(rc))
5681	rc = rtDwarfInfo_LoadUnit(pThis, &Cursor, false /* fKeepDies */);
5682
5683	rc = rtDwarfCursor_Delete(&Cursor, rc);
5684	}
5685	return rc;
5686	}
5687
5688
5689
5690	/*
5691	*
5692	* Public and image level symbol handling.
5693	* Public and image level symbol handling.
5694	* Public and image level symbol handling.
5695	* Public and image level symbol handling.
5696	*
5697	*
5698	*/
5699
5700	#define RTDBGDWARF_SYM_ENUM_BASE_ADDRESS UINT32_C(0x200000)
5701
5702	/** @callback_method_impl{FNRTLDRENUMSYMS,
5703	* Adds missing symbols from the image symbol table.} */
5704	static DECLCALLBACK(int) rtDwarfSyms_EnumSymbolsCallback(RTLDRMOD hLdrMod, const char *pszSymbol, unsigned uSymbol,
5705	RTLDRADDR Value, void *pvUser)
5706	{
5707	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pvUser;
5708	RT_NOREF_PV(hLdrMod); RT_NOREF_PV(uSymbol);
5709	Assert(pThis->iWatcomPass != 1);
5710
5711	RTLDRADDR uRva = Value - RTDBGDWARF_SYM_ENUM_BASE_ADDRESS;
5712	if ( Value >= RTDBGDWARF_SYM_ENUM_BASE_ADDRESS
5713	&& uRva < _1G)
5714	{
5715	RTDBGSYMBOL SymInfo;
5716	RTINTPTR offDisp;
5717	int rc = RTDbgModSymbolByAddr(pThis->hCnt, RTDBGSEGIDX_RVA, uRva, RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL, &offDisp, &SymInfo);
5718	if ( RT_FAILURE(rc)
5719	\|\| offDisp != 0)
5720	{
5721	rc = RTDbgModSymbolAdd(pThis->hCnt, pszSymbol, RTDBGSEGIDX_RVA, uRva, 1, 0 /fFlags/, NULL /piOrdinal/);
5722	Log(("Dwarf: Symbol #%05u %#018RTptr %s [%Rrc]\n", uSymbol, Value, pszSymbol, rc)); NOREF(rc);
5723	}
5724	}
5725	else
5726	Log(("Dwarf: Symbol #%05u %#018RTptr '%s' [SKIPPED - INVALID ADDRESS]\n", uSymbol, Value, pszSymbol));
5727	return VINF_SUCCESS;
5728	}
5729
5730
5731
5732	/**
5733	* Loads additional symbols from the pubnames section and the executable image.
5734	*
5735	* The symbols are insered into the debug info container.
5736	*
5737	* @returns IPRT status code
5738	* @param pThis The DWARF instance.
5739	*/
5740	static int rtDwarfSyms_LoadAll(PRTDBGMODDWARF pThis)
5741	{
5742	/*
5743	* pubnames.
5744	*/
5745	int rc = VINF_SUCCESS;
5746	if (pThis->aSections[krtDbgModDwarfSect_pubnames].fPresent)
5747	{
5748	// RTDWARFCURSOR Cursor;
5749	// int rc = rtDwarfCursor_Init(&Cursor, pThis, krtDbgModDwarfSect_info);
5750	// if (RT_SUCCESS(rc))
5751	// {
5752	// while ( !rtDwarfCursor_IsAtEnd(&Cursor)
5753	// && RT_SUCCESS(rc))
5754	// rc = rtDwarfInfo_LoadUnit(pThis, &Cursor, false /* fKeepDies */);
5755	//
5756	// rc = rtDwarfCursor_Delete(&Cursor, rc);
5757	// }
5758	// return rc;
5759	}
5760
5761	/*
5762	* The executable image.
5763	*/
5764	if ( pThis->pImgMod
5765	&& pThis->pImgMod->pImgVt->pfnEnumSymbols
5766	&& pThis->iWatcomPass != 1
5767	&& RT_SUCCESS(rc))
5768	{
5769	rc = pThis->pImgMod->pImgVt->pfnEnumSymbols(pThis->pImgMod,
5770	RTLDR_ENUM_SYMBOL_FLAGS_ALL \| RTLDR_ENUM_SYMBOL_FLAGS_NO_FWD,
5771	RTDBGDWARF_SYM_ENUM_BASE_ADDRESS,
5772	rtDwarfSyms_EnumSymbolsCallback,
5773	pThis);
5774	}
5775
5776	return rc;
5777	}
5778
5779
5780
5781
5782	/*
5783	*
5784	* DWARF Debug module implementation.
5785	* DWARF Debug module implementation.
5786	* DWARF Debug module implementation.
5787	*
5788	*/
5789
5790
5791	/** @interface_method_impl{RTDBGMODVTDBG,pfnUnwindFrame} */
5792	static DECLCALLBACK(int) rtDbgModDwarf_UnwindFrame(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off, PRTDBGUNWINDSTATE pState)
5793	{
5794	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5795
5796	/*
5797	* Unwinding info is stored in the '.debug_frame' section, or altertively
5798	* in the '.eh_frame' one in the image. In the latter case the dbgmodldr.cpp
5799	* part of the operation will take care of it. Since the sections contain the
5800	* same data, we just create a cursor and call a common function to do the job.
5801	*/
5802	if (pThis->aSections[krtDbgModDwarfSect_frame].fPresent)
5803	{
5804	RTDWARFCURSOR Cursor;
5805	int rc = rtDwarfCursor_Init(&Cursor, pThis, krtDbgModDwarfSect_frame);
5806	if (RT_SUCCESS(rc))
5807	{
5808	/* Figure default pointer encoding from image arch. */
5809	uint8_t bPtrEnc = rtDwarfUnwind_ArchToPtrEnc(pMod->pImgVt->pfnGetArch(pMod));
5810
5811	/* Make sure we've got both seg:off and rva for the input address. */
5812	RTUINTPTR uRva = off;
5813	if (iSeg == RTDBGSEGIDX_RVA)
5814	rtDbgModDwarfRvaToSegOffset(pThis, uRva, &iSeg, &off);
5815	else
5816	rtDbgModDwarfSegOffsetToRva(pThis, iSeg, off, &uRva);
5817
5818	/* Do the work */
5819	rc = rtDwarfUnwind_Slow(&Cursor, 0 /** @todo .debug_frame RVA*/, iSeg, off, uRva,
5820	pState, bPtrEnc, false /fIsEhFrame/, pMod->pImgVt->pfnGetArch(pMod));
5821
5822	rc = rtDwarfCursor_Delete(&Cursor, rc);
5823	}
5824	return rc;
5825	}
5826	return VERR_DBG_NO_UNWIND_INFO;
5827	}
5828
5829
5830	/** @interface_method_impl{RTDBGMODVTDBG,pfnLineByAddr} */
5831	static DECLCALLBACK(int) rtDbgModDwarf_LineByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off,
5832	PRTINTPTR poffDisp, PRTDBGLINE pLineInfo)
5833	{
5834	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5835	return RTDbgModLineByAddr(pThis->hCnt, iSeg, off, poffDisp, pLineInfo);
5836	}
5837
5838
5839	/** @interface_method_impl{RTDBGMODVTDBG,pfnLineByOrdinal} */
5840	static DECLCALLBACK(int) rtDbgModDwarf_LineByOrdinal(PRTDBGMODINT pMod, uint32_t iOrdinal, PRTDBGLINE pLineInfo)
5841	{
5842	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5843	return RTDbgModLineByOrdinal(pThis->hCnt, iOrdinal, pLineInfo);
5844	}
5845
5846
5847	/** @interface_method_impl{RTDBGMODVTDBG,pfnLineCount} */
5848	static DECLCALLBACK(uint32_t) rtDbgModDwarf_LineCount(PRTDBGMODINT pMod)
5849	{
5850	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5851	return RTDbgModLineCount(pThis->hCnt);
5852	}
5853
5854
5855	/** @interface_method_impl{RTDBGMODVTDBG,pfnLineAdd} */
5856	static DECLCALLBACK(int) rtDbgModDwarf_LineAdd(PRTDBGMODINT pMod, const char *pszFile, size_t cchFile, uint32_t uLineNo,
5857	uint32_t iSeg, RTUINTPTR off, uint32_t *piOrdinal)
5858	{
5859	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5860	Assert(!pszFile[cchFile]); NOREF(cchFile);
5861	return RTDbgModLineAdd(pThis->hCnt, pszFile, uLineNo, iSeg, off, piOrdinal);
5862	}
5863
5864
5865	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByAddr} */
5866	static DECLCALLBACK(int) rtDbgModDwarf_SymbolByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t fFlags,
5867	PRTINTPTR poffDisp, PRTDBGSYMBOL pSymInfo)
5868	{
5869	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5870	return RTDbgModSymbolByAddr(pThis->hCnt, iSeg, off, fFlags, poffDisp, pSymInfo);
5871	}
5872
5873
5874	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByName} */
5875	static DECLCALLBACK(int) rtDbgModDwarf_SymbolByName(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
5876	PRTDBGSYMBOL pSymInfo)
5877	{
5878	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5879	Assert(!pszSymbol[cchSymbol]); RT_NOREF_PV(cchSymbol);
5880	return RTDbgModSymbolByName(pThis->hCnt, pszSymbol/, cchSymbol/, pSymInfo);
5881	}
5882
5883
5884	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByOrdinal} */
5885	static DECLCALLBACK(int) rtDbgModDwarf_SymbolByOrdinal(PRTDBGMODINT pMod, uint32_t iOrdinal, PRTDBGSYMBOL pSymInfo)
5886	{
5887	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5888	return RTDbgModSymbolByOrdinal(pThis->hCnt, iOrdinal, pSymInfo);
5889	}
5890
5891
5892	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolCount} */
5893	static DECLCALLBACK(uint32_t) rtDbgModDwarf_SymbolCount(PRTDBGMODINT pMod)
5894	{
5895	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5896	return RTDbgModSymbolCount(pThis->hCnt);
5897	}
5898
5899
5900	/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolAdd} */
5901	static DECLCALLBACK(int) rtDbgModDwarf_SymbolAdd(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
5902	RTDBGSEGIDX iSeg, RTUINTPTR off, RTUINTPTR cb, uint32_t fFlags,
5903	uint32_t *piOrdinal)
5904	{
5905	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5906	Assert(!pszSymbol[cchSymbol]); NOREF(cchSymbol);
5907	return RTDbgModSymbolAdd(pThis->hCnt, pszSymbol, iSeg, off, cb, fFlags, piOrdinal);
5908	}
5909
5910
5911	/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentByIndex} */
5912	static DECLCALLBACK(int) rtDbgModDwarf_SegmentByIndex(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, PRTDBGSEGMENT pSegInfo)
5913	{
5914	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5915	return RTDbgModSegmentByIndex(pThis->hCnt, iSeg, pSegInfo);
5916	}
5917
5918
5919	/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentCount} */
5920	static DECLCALLBACK(RTDBGSEGIDX) rtDbgModDwarf_SegmentCount(PRTDBGMODINT pMod)
5921	{
5922	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5923	return RTDbgModSegmentCount(pThis->hCnt);
5924	}
5925
5926
5927	/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentAdd} */
5928	static DECLCALLBACK(int) rtDbgModDwarf_SegmentAdd(PRTDBGMODINT pMod, RTUINTPTR uRva, RTUINTPTR cb, const char *pszName, size_t cchName,
5929	uint32_t fFlags, PRTDBGSEGIDX piSeg)
5930	{
5931	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5932	Assert(!pszName[cchName]); NOREF(cchName);
5933	return RTDbgModSegmentAdd(pThis->hCnt, uRva, cb, pszName, fFlags, piSeg);
5934	}
5935
5936
5937	/** @interface_method_impl{RTDBGMODVTDBG,pfnImageSize} */
5938	static DECLCALLBACK(RTUINTPTR) rtDbgModDwarf_ImageSize(PRTDBGMODINT pMod)
5939	{
5940	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5941	RTUINTPTR cb1 = RTDbgModImageSize(pThis->hCnt);
5942	RTUINTPTR cb2 = pThis->pImgMod->pImgVt->pfnImageSize(pMod);
5943	return RT_MAX(cb1, cb2);
5944	}
5945
5946
5947	/** @interface_method_impl{RTDBGMODVTDBG,pfnRvaToSegOff} */
5948	static DECLCALLBACK(RTDBGSEGIDX) rtDbgModDwarf_RvaToSegOff(PRTDBGMODINT pMod, RTUINTPTR uRva, PRTUINTPTR poffSeg)
5949	{
5950	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5951	return RTDbgModRvaToSegOff(pThis->hCnt, uRva, poffSeg);
5952	}
5953
5954
5955	/** @interface_method_impl{RTDBGMODVTDBG,pfnClose} */
5956	static DECLCALLBACK(int) rtDbgModDwarf_Close(PRTDBGMODINT pMod)
5957	{
5958	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
5959
5960	for (unsigned iSect = 0; iSect < RT_ELEMENTS(pThis->aSections); iSect++)
5961	if (pThis->aSections[iSect].pv)
5962	pThis->pDbgInfoMod->pImgVt->pfnUnmapPart(pThis->pDbgInfoMod, pThis->aSections[iSect].cb, &pThis->aSections[iSect].pv);
5963
5964	RTDbgModRelease(pThis->hCnt);
5965	RTMemFree(pThis->paCachedAbbrevs);
5966	if (pThis->pNestedMod)
5967	{
5968	pThis->pNestedMod->pImgVt->pfnClose(pThis->pNestedMod);
5969	RTStrCacheRelease(g_hDbgModStrCache, pThis->pNestedMod->pszName);
5970	RTStrCacheRelease(g_hDbgModStrCache, pThis->pNestedMod->pszDbgFile);
5971	RTMemFree(pThis->pNestedMod);
5972	pThis->pNestedMod = NULL;
5973	}
5974
5975	#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
5976	uint32_t i = RT_ELEMENTS(pThis->aDieAllocators);
5977	while (i-- > 0)
5978	{
5979	RTMemCacheDestroy(pThis->aDieAllocators[i].hMemCache);
5980	pThis->aDieAllocators[i].hMemCache = NIL_RTMEMCACHE;
5981	}
5982	#endif
5983
5984	RTMemFree(pThis);
5985
5986	return VINF_SUCCESS;
5987	}
5988
5989
5990	/** @callback_method_impl{FNRTLDRENUMDBG} */
5991	static DECLCALLBACK(int) rtDbgModDwarfEnumCallback(RTLDRMOD hLdrMod, PCRTLDRDBGINFO pDbgInfo, void *pvUser)
5992	{
5993	RT_NOREF_PV(hLdrMod);
5994
5995	/*
5996	* Skip stuff we can't handle.
5997	*/
5998	if (pDbgInfo->enmType != RTLDRDBGINFOTYPE_DWARF)
5999	return VINF_SUCCESS;
6000	const char *pszSection = pDbgInfo->u.Dwarf.pszSection;
6001	if (!pszSection \|\| !*pszSection)
6002	return VINF_SUCCESS;
6003	Assert(!pDbgInfo->pszExtFile);
6004
6005	/*
6006	* Must have a part name starting with debug_ and possibly prefixed by dots
6007	* or underscores.
6008	*/
6009	if (!strncmp(pszSection, RT_STR_TUPLE(".debug_"))) /* ELF */
6010	pszSection += sizeof(".debug_") - 1;
6011	else if (!strncmp(pszSection, RT_STR_TUPLE("__debug_"))) /* Mach-O */
6012	pszSection += sizeof("__debug_") - 1;
6013	else if (!strcmp(pszSection, ".WATCOM_references"))
6014	return VINF_SUCCESS; /* Ignore special watcom section for now.*/
6015	else if ( !strcmp(pszSection, "__apple_types")
6016	\|\| !strcmp(pszSection, "__apple_namespac")
6017	\|\| !strcmp(pszSection, "__apple_objc")
6018	\|\| !strcmp(pszSection, "__apple_names"))
6019	return VINF_SUCCESS; /* Ignore special apple sections for now. */
6020	else
6021	AssertMsgFailedReturn(("%s\n", pszSection), VINF_SUCCESS /ignore/);
6022
6023	/*
6024	* Figure out which part we're talking about.
6025	*/
6026	krtDbgModDwarfSect enmSect;
6027	if (0) { /* dummy */ }
6028	#define ELSE_IF_STRCMP_SET(a_Name) else if (!strcmp(pszSection, #a_Name)) enmSect = krtDbgModDwarfSect_ ## a_Name
6029	ELSE_IF_STRCMP_SET(abbrev);
6030	ELSE_IF_STRCMP_SET(aranges);
6031	ELSE_IF_STRCMP_SET(frame);
6032	ELSE_IF_STRCMP_SET(info);
6033	ELSE_IF_STRCMP_SET(inlined);
6034	ELSE_IF_STRCMP_SET(line);
6035	ELSE_IF_STRCMP_SET(loc);
6036	ELSE_IF_STRCMP_SET(macinfo);
6037	ELSE_IF_STRCMP_SET(pubnames);
6038	ELSE_IF_STRCMP_SET(pubtypes);
6039	ELSE_IF_STRCMP_SET(ranges);
6040	ELSE_IF_STRCMP_SET(str);
6041	ELSE_IF_STRCMP_SET(types);
6042	#undef ELSE_IF_STRCMP_SET
6043	else
6044	{
6045	AssertMsgFailed(("%s\n", pszSection));
6046	return VINF_SUCCESS;
6047	}
6048
6049	/*
6050	* Record the section.
6051	*/
6052	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pvUser;
6053	AssertMsgReturn(!pThis->aSections[enmSect].fPresent, ("duplicate %s\n", pszSection), VINF_SUCCESS /ignore/);
6054
6055	pThis->aSections[enmSect].fPresent = true;
6056	pThis->aSections[enmSect].offFile = pDbgInfo->offFile;
6057	pThis->aSections[enmSect].pv = NULL;
6058	pThis->aSections[enmSect].cb = (size_t)pDbgInfo->cb;
6059	pThis->aSections[enmSect].iDbgInfo = pDbgInfo->iDbgInfo;
6060	if (pThis->aSections[enmSect].cb != pDbgInfo->cb)
6061	pThis->aSections[enmSect].cb = ~(size_t)0;
6062
6063	return VINF_SUCCESS;
6064	}
6065
6066
6067	static int rtDbgModDwarfTryOpenDbgFile(PRTDBGMODINT pDbgMod, PRTDBGMODDWARF pThis, RTLDRARCH enmArch)
6068	{
6069	if ( !pDbgMod->pszDbgFile
6070	\|\| RTPathIsSame(pDbgMod->pszDbgFile, pDbgMod->pszImgFile) == (int)true /* returns VERR too */)
6071	return VERR_DBG_NO_MATCHING_INTERPRETER;
6072
6073	/*
6074	* Only open the image.
6075	*/
6076	PRTDBGMODINT pDbgInfoMod = (PRTDBGMODINT)RTMemAllocZ(sizeof(*pDbgInfoMod));
6077	if (!pDbgInfoMod)
6078	return VERR_NO_MEMORY;
6079
6080	int rc;
6081	pDbgInfoMod->u32Magic = RTDBGMOD_MAGIC;
6082	pDbgInfoMod->cRefs = 1;
6083	if (RTStrCacheRetain(pDbgMod->pszDbgFile) != UINT32_MAX)
6084	{
6085	pDbgInfoMod->pszImgFile = pDbgMod->pszDbgFile;
6086	if (RTStrCacheRetain(pDbgMod->pszName) != UINT32_MAX)
6087	{
6088	pDbgInfoMod->pszName = pDbgMod->pszName;
6089	pDbgInfoMod->pImgVt = &g_rtDbgModVtImgLdr;
6090	rc = pDbgInfoMod->pImgVt->pfnTryOpen(pDbgInfoMod, enmArch, 0 /fLdrFlags/);
6091	if (RT_SUCCESS(rc))
6092	{
6093	pThis->pDbgInfoMod = pDbgInfoMod;
6094	pThis->pNestedMod = pDbgInfoMod;
6095	return VINF_SUCCESS;
6096	}
6097
6098	RTStrCacheRelease(g_hDbgModStrCache, pDbgInfoMod->pszName);
6099	}
6100	else
6101	rc = VERR_NO_STR_MEMORY;
6102	RTStrCacheRelease(g_hDbgModStrCache, pDbgInfoMod->pszImgFile);
6103	}
6104	else
6105	rc = VERR_NO_STR_MEMORY;
6106	RTMemFree(pDbgInfoMod);
6107	return rc;
6108	}
6109
6110
6111	/** @interface_method_impl{RTDBGMODVTDBG,pfnTryOpen} */
6112	static DECLCALLBACK(int) rtDbgModDwarf_TryOpen(PRTDBGMODINT pMod, RTLDRARCH enmArch)
6113	{
6114	/*
6115	* DWARF is only supported when part of an image.
6116	*/
6117	if (!pMod->pImgVt)
6118	return VERR_DBG_NO_MATCHING_INTERPRETER;
6119
6120	/*
6121	* Create the module instance data.
6122	*/
6123	PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)RTMemAllocZ(sizeof(*pThis));
6124	if (!pThis)
6125	return VERR_NO_MEMORY;
6126	pThis->pDbgInfoMod = pMod;
6127	pThis->pImgMod = pMod;
6128	RTListInit(&pThis->CompileUnitList);
6129
6130	/** @todo better fUseLinkAddress heuristics! */
6131	/* mach_kernel: */
6132	if ( (pMod->pszDbgFile && strstr(pMod->pszDbgFile, "mach_kernel"))
6133	\|\| (pMod->pszImgFile && strstr(pMod->pszImgFile, "mach_kernel"))
6134	\|\| (pMod->pszImgFileSpecified && strstr(pMod->pszImgFileSpecified, "mach_kernel")) )
6135	pThis->fUseLinkAddress = true;
6136
6137	#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
6138	AssertCompile(RT_ELEMENTS(pThis->aDieAllocators) == 2);
6139	pThis->aDieAllocators[0].cbMax = sizeof(RTDWARFDIE);
6140	pThis->aDieAllocators[1].cbMax = sizeof(RTDWARFDIECOMPILEUNIT);
6141	for (uint32_t i = 0; i < RT_ELEMENTS(g_aTagDescs); i++)
6142	if (g_aTagDescs[i].pDesc && g_aTagDescs[i].pDesc->cbDie > pThis->aDieAllocators[1].cbMax)
6143	pThis->aDieAllocators[1].cbMax = (uint32_t)g_aTagDescs[i].pDesc->cbDie;
6144	pThis->aDieAllocators[1].cbMax = RT_ALIGN_32(pThis->aDieAllocators[1].cbMax, sizeof(uint64_t));
6145
6146	for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aDieAllocators); i++)
6147	{
6148	int rc = RTMemCacheCreate(&pThis->aDieAllocators[i].hMemCache, pThis->aDieAllocators[i].cbMax, sizeof(uint64_t),
6149	UINT32_MAX, NULL /pfnCtor/, NULL /pfnDtor/, NULL /pvUser/, 0 /fFlags/);
6150	if (RT_FAILURE(rc))
6151	{
6152	while (i-- > 0)
6153	RTMemCacheDestroy(pThis->aDieAllocators[i].hMemCache);
6154	RTMemFree(pThis);
6155	return rc;
6156	}
6157	}
6158	#endif
6159
6160	/*
6161	* If the debug file name is set, let's see if it's an ELF image with DWARF
6162	* inside it. In that case we'll have to deal with two image modules, one
6163	* for segments and address translation and one for the debug information.
6164	*/
6165	if (pMod->pszDbgFile != NULL)
6166	rtDbgModDwarfTryOpenDbgFile(pMod, pThis, enmArch);
6167
6168	/*
6169	* Enumerate the debug info in the module, looking for DWARF bits.
6170	*/
6171	int rc = pThis->pDbgInfoMod->pImgVt->pfnEnumDbgInfo(pThis->pDbgInfoMod, rtDbgModDwarfEnumCallback, pThis);
6172	if (RT_SUCCESS(rc))
6173	{
6174	if (pThis->aSections[krtDbgModDwarfSect_info].fPresent)
6175	{
6176	/*
6177	* Extract / explode the data we want (symbols and line numbers)
6178	* storing them in a container module.
6179	*/
6180	rc = RTDbgModCreate(&pThis->hCnt, pMod->pszName, 0 /cbSeg/, 0 /fFlags/);
6181	if (RT_SUCCESS(rc))
6182	{
6183	pMod->pvDbgPriv = pThis;
6184
6185	rc = rtDbgModDwarfAddSegmentsFromImage(pThis);
6186	if (RT_SUCCESS(rc))
6187	rc = rtDwarfInfo_LoadAll(pThis);
6188	if (RT_SUCCESS(rc))
6189	rc = rtDwarfSyms_LoadAll(pThis);
6190	if (RT_SUCCESS(rc))
6191	rc = rtDwarfLine_ExplodeAll(pThis);
6192	if (RT_SUCCESS(rc) && pThis->iWatcomPass == 1)
6193	{
6194	rc = rtDbgModDwarfAddSegmentsFromPass1(pThis);
6195	pThis->iWatcomPass = 2;
6196	if (RT_SUCCESS(rc))
6197	rc = rtDwarfInfo_LoadAll(pThis);
6198	if (RT_SUCCESS(rc))
6199	rc = rtDwarfSyms_LoadAll(pThis);
6200	if (RT_SUCCESS(rc))
6201	rc = rtDwarfLine_ExplodeAll(pThis);
6202	}
6203
6204	/*
6205	* Free the cached abbreviations and unload all sections.
6206	*/
6207	pThis->cCachedAbbrevsAlloced = 0;
6208	RTMemFree(pThis->paCachedAbbrevs);
6209	pThis->paCachedAbbrevs = NULL;
6210
6211	for (unsigned iSect = 0; iSect < RT_ELEMENTS(pThis->aSections); iSect++)
6212	if (pThis->aSections[iSect].pv)
6213	pThis->pDbgInfoMod->pImgVt->pfnUnmapPart(pThis->pDbgInfoMod, pThis->aSections[iSect].cb,
6214	&pThis->aSections[iSect].pv);
6215
6216	if (RT_SUCCESS(rc))
6217	{
6218	/** @todo Kill pThis->CompileUnitList and the alloc caches. */
6219	return VINF_SUCCESS;
6220	}
6221
6222	/* bail out. */
6223	RTDbgModRelease(pThis->hCnt);
6224	pMod->pvDbgPriv = NULL;
6225	}
6226	}
6227	else
6228	rc = VERR_DBG_NO_MATCHING_INTERPRETER;
6229	}
6230
6231	if (pThis->paCachedAbbrevs)
6232	RTMemFree(pThis->paCachedAbbrevs);
6233	pThis->paCachedAbbrevs = NULL;
6234
6235	for (unsigned iSect = 0; iSect < RT_ELEMENTS(pThis->aSections); iSect++)
6236	if (pThis->aSections[iSect].pv)
6237	pThis->pDbgInfoMod->pImgVt->pfnUnmapPart(pThis->pDbgInfoMod, pThis->aSections[iSect].cb,
6238	&pThis->aSections[iSect].pv);
6239
6240	#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
6241	uint32_t i = RT_ELEMENTS(pThis->aDieAllocators);
6242	while (i-- > 0)
6243	{
6244	RTMemCacheDestroy(pThis->aDieAllocators[i].hMemCache);
6245	pThis->aDieAllocators[i].hMemCache = NIL_RTMEMCACHE;
6246	}
6247	#endif
6248
6249	RTMemFree(pThis);
6250
6251	return rc;
6252	}
6253
6254
6255
6256	/** Virtual function table for the DWARF debug info reader. */
6257	DECL_HIDDEN_CONST(RTDBGMODVTDBG) const g_rtDbgModVtDbgDwarf =
6258	{
6259	/.u32Magic = / RTDBGMODVTDBG_MAGIC,
6260	/.fSupports = / RT_DBGTYPE_DWARF,
6261	/.pszName = / "dwarf",
6262	/.pfnTryOpen = / rtDbgModDwarf_TryOpen,
6263	/.pfnClose = / rtDbgModDwarf_Close,
6264
6265	/.pfnRvaToSegOff = / rtDbgModDwarf_RvaToSegOff,
6266	/.pfnImageSize = / rtDbgModDwarf_ImageSize,
6267
6268	/.pfnSegmentAdd = / rtDbgModDwarf_SegmentAdd,
6269	/.pfnSegmentCount = / rtDbgModDwarf_SegmentCount,
6270	/.pfnSegmentByIndex = / rtDbgModDwarf_SegmentByIndex,
6271
6272	/.pfnSymbolAdd = / rtDbgModDwarf_SymbolAdd,
6273	/.pfnSymbolCount = / rtDbgModDwarf_SymbolCount,
6274	/.pfnSymbolByOrdinal = / rtDbgModDwarf_SymbolByOrdinal,
6275	/.pfnSymbolByName = / rtDbgModDwarf_SymbolByName,
6276	/.pfnSymbolByAddr = / rtDbgModDwarf_SymbolByAddr,
6277
6278	/.pfnLineAdd = / rtDbgModDwarf_LineAdd,
6279	/.pfnLineCount = / rtDbgModDwarf_LineCount,
6280	/.pfnLineByOrdinal = / rtDbgModDwarf_LineByOrdinal,
6281	/.pfnLineByAddr = / rtDbgModDwarf_LineByAddr,
6282
6283	/.pfnUnwindFrame = / rtDbgModDwarf_UnwindFrame,
6284
6285	/.u32EndMagic = / RTDBGMODVTDBG_MAGIC
6286	};
6287

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

source: vbox/trunk/src/VBox/Runtime/common/dbg/dbgmoddwarf.cpp@ 100765

Download in other formats: