Fix a crash when emulator, in non-debugger mode, opens the breakpoint UIs at launch

[clinton/Virtual-Jaguar-Rx.git] / src / debugger / DWARFManager.cpp

//\r
// DWARFManager.cpp: DWARF format manager\r
//\r
// by Jean-Paul Mari\r
//\r
// JPM = Jean-Paul Mari <djipi.mari@gmail.com>\r
//\r
// WHO  WHEN        WHAT\r
// ---  ----------  ------------------------------------------------------------\r
// JPM   Dec./2016  Created this file, and added the DWARF format support\r
// JPM  Sept./2018  Added LEB128 decoding features, and improve the DWARF parsing information\r
// JPM   Oct./2018  Improve the DWARF parsing information, and the source file text reading; support the used source lines from DWARF structure, and the search paths for the files\r
//\r
\r
// To Do\r
// To use pointers instead of arrays usage\r
// To keep sources text file intact wihtout QT/HTML transformation\r
// \r
\r
\r
#include <stdlib.h>\r
#include <stdio.h>\r
#include <stdint.h>\r
#include <string.h>\r
#include <libdwarf.h>\r
#include <dwarf.h>\r
#include "LEB128.h"\r
\r
\r
// Definitions for debugging\r
//#define DEBUG_NumCU			0x9					// CU number to debug or undefine it\r
//#define DEBUG_VariableName	"sound_death"				// Variable name to look for or undefine it\r
//#define DEBUG_TypeName		"Cbuf_Execute"			// Type name to look for or undefine it\r
//#define DEBUG_TypeDef			DW_TAG_typedef		// Type def to look for or undefine it (not supported)\r
//#define DEBUG_Filename		"net_jag.c"			// Filename to look for or undefine it\r
\r
// Definitions for the variables's typetag\r
#define	TypeTag_structure			0x01			// structure\r
#define	TypeTag_pointer				0x02			// pointer\r
#define	TypeTag_subrange			0x04			// (subrange_type?)\r
#define	TypeTag_arraytype			0x08			// array type\r
#define	TypeTag_consttype			0x10			// const type\r
#define	TypeTag_typedef				0x20			// typedef\r
#define TypeTag_enumeration_type	0x40			// enumeration\r
#define TypeTag_subroutine_type		0x80			// subroutine\r
\r
\r
// Source line CU structure\r
typedef struct CUStruct_LineSrc\r
{\r
	size_t StartPC;\r
	size_t NumLineSrc;\r
	char *PtrLineSrc;\r
}S_CUStruct_LineSrc;\r
\r
// Source line internal structure\r
typedef struct DMIStruct_LineSrc\r
{\r
	size_t Tag;\r
	size_t StartPC;\r
	size_t NumLineSrc;\r
	char *PtrLineSrc;\r
}S_DMIStruct_LineSrc;\r
\r
// Enumeration structure\r
typedef struct EnumerationStruct\r
{\r
	char *PtrName;							// Enumeration's name\r
	size_t value;							// Enumeration's value\r
}S_EnumerationStruct;\r
\r
// Structure members structure\r
//typedef struct StructureMembersStruct\r
//{\r
//}S_StructureMembersStruct;\r
\r
// Base type internal structure\r
typedef struct BaseTypeStruct\r
{\r
	size_t Tag;										// Type's Tag\r
	size_t Offset;									// Type's offset\r
	size_t TypeOffset;								// Type's offset on another type\r
	size_t ByteSize;								// Type's Byte Size\r
	size_t Encoding;								// Type's encoding\r
	char *PtrName;									// Type's name\r
	size_t NbEnumeration;							// Type's enumeration numbers\r
	EnumerationStruct *PtrEnumeration;				// Type's enumeration\r
//	StructureMembersStruct *PtrStructureMembers;	// Type's structure members\r
}S_BaseTypeStruct;\r
\r
// Variables internal structure\r
typedef struct VariablesStruct\r
{\r
	size_t Op;								// Variable's DW_OP\r
	union\r
	{\r
		size_t Addr;						// Variable memory address\r
		int Offset;							// Variable stack offset (signed)\r
	};\r
	char *PtrName;							// Variable's name\r
	size_t TypeOffset;						// Offset pointing on the Variable's Type\r
	size_t TypeByteSize;					// Variable's Type byte size\r
	size_t TypeTag;							// Variable's Type Tag\r
	size_t TypeEncoding;					// Variable's Type encoding\r
	char *PtrTypeName;						// Variable's Type name\r
}S_VariablesStruct;\r
\r
// Sub program internal structure\r
typedef struct SubProgStruct\r
{\r
	size_t Tag;\r
	size_t NumLineSrc;\r
	size_t StartPC;\r
	size_t LowPC, HighPC;\r
	size_t FrameBase;\r
	char *PtrLineSrc;\r
	char *PtrSubprogramName;						// Sub program name\r
	size_t NbLinesSrc;								// Number of lines source used by the sub program\r
	DMIStruct_LineSrc *PtrLinesSrc;					// Pointer of the lines source for the sub program\r
	size_t NbVariables;								// Variables number\r
	VariablesStruct *PtrVariables;					// Pointer to the local variables list information structure\r
}S_SubProgStruct;\r
\r
// Compilation Unit internal structure\r
typedef struct CUStruct\r
{\r
	size_t Tag;\r
	size_t LowPC, HighPC;							// Memory range for the code\r
	char *PtrProducer;								// Pointer to the "Producer" text information (mostly compiler and compilation options used)\r
	char *PtrSourceFilename;						// Source file name\r
	char *PtrSourceFileDirectory;					// Directory of the source file\r
	char *PtrFullFilename;							// Pointer to full namefile (directory & filename)\r
	size_t SizeLoadSrc;								// Source code text size\r
	char *PtrLoadSrc;								// Pointer to the source code text\r
	size_t NbLinesLoadSrc;							// Total number of lines in the source code text\r
	char **PtrLinesLoadSrc;							// Pointer lists to each source line put in QT html/text conformity\r
	size_t NbSubProgs;								// Number of sub programs / routines\r
	SubProgStruct *PtrSubProgs;						// Pointer to the sub programs / routines structure\r
	size_t NbTypes;									// Number of types\r
	BaseTypeStruct *PtrTypes;						// Pointer to types\r
	size_t NbVariables;								// Variables number\r
	VariablesStruct *PtrVariables;					// Pointer to the global variables list structure\r
	size_t NbFrames;								// Frames number\r
	size_t NbLinesSrc;								// Number of used source lines\r
	CUStruct_LineSrc *PtrLinesSrc;					// Pointer to the used source lines list structure\r
}S_CUStruct;\r
\r
\r
// Dwarf management\r
uint32_t LibDwarf;\r
uint32_t NbCU;\r
Dwarf_Ptr errarg;\r
Dwarf_Error error;\r
Dwarf_Debug dbg;\r
CUStruct *PtrCU;\r
char **ListSearchPaths;\r
size_t NbSearchPaths;\r
\r
\r
//\r
Dwarf_Handler DWARFManager_ErrorHandler(Dwarf_Ptr perrarg);\r
void DWARFManager_InitDMI(void);\r
void DWARFManager_CloseDMI(void);\r
bool DWARFManager_ElfClose(void);\r
char *DWARFManager_GetLineSrcFromNumLine(char *PtrSrcFile, size_t NumLine);\r
void DWARFManager_InitInfosVariable(VariablesStruct *PtrVariables);\r
void DWARFManager_SourceFileSearchPathsInit(void);\r
void DWARFManager_SourceFileSearchPathsReset(void);\r
void DWARFManager_SourceFileSearchPathsClose(void);\r
\r
\r
//\r
Dwarf_Handler DWARFManager_ErrorHandler(Dwarf_Ptr perrarg)\r
{\r
	return	0;\r
}\r
\r
\r
// Dwarf manager list search paths init\r
void DWARFManager_SourceFileSearchPathsInit(void)\r
{\r
	ListSearchPaths = NULL;\r
	NbSearchPaths = 0;\r
}\r
\r
\r
// Dwarf manager list search paths reset\r
void DWARFManager_SourceFileSearchPathsReset(void)\r
{\r
	ListSearchPaths = NULL;\r
	NbSearchPaths = 0;\r
}\r
\r
\r
// Dwarf manager list search paths close\r
void DWARFManager_SourceFileSearchPathsClose(void)\r
{\r
	DWARFManager_SourceFileSearchPathsReset();\r
}\r
\r
\r
// Dwarf manager init\r
void DWARFManager_Init(void)\r
{\r
	DWARFManager_SourceFileSearchPathsInit();\r
	LibDwarf = DW_DLV_NO_ENTRY;\r
}\r
\r
\r
// Dwarf manager settings\r
void DWARFManager_Set(size_t NbPathsInList, char **PtrListPaths)\r
{\r
	// Search paths init\r
	ListSearchPaths = PtrListPaths;\r
	NbSearchPaths = NbPathsInList;\r
}\r
\r
\r
// Dwarf manager Reset\r
bool DWARFManager_Reset(void)\r
{\r
	DWARFManager_SourceFileSearchPathsReset();\r
	return DWARFManager_ElfClose();\r
}\r
\r
\r
// Dwarf manager Close\r
bool DWARFManager_Close(void)\r
{\r
	DWARFManager_SourceFileSearchPathsClose();\r
	return(DWARFManager_Reset());\r
}\r
\r
\r
// Dwarf manager Elf init\r
int	DWARFManager_ElfInit(Elf *ElfPtr)\r
{\r
	if ((LibDwarf = dwarf_elf_init(ElfPtr, DW_DLC_READ, (Dwarf_Handler)DWARFManager_ErrorHandler, errarg, &dbg, &error)) == DW_DLV_OK)\r
	{\r
		DWARFManager_InitDMI();\r
	}\r
\r
	return LibDwarf;\r
}\r
\r
\r
// Dwarf manager Elf close\r
bool DWARFManager_ElfClose(void)\r
{\r
	if (LibDwarf == DW_DLV_OK)\r
	{\r
		DWARFManager_CloseDMI();\r
\r
		if (dwarf_finish(dbg, &error) == DW_DLV_OK)\r
		{\r
			LibDwarf = DW_DLV_NO_ENTRY;\r
			return	true;\r
		}\r
		else\r
		{\r
			return	false;\r
		}\r
	}\r
	else\r
	{\r
		return	true;\r
	}\r
}\r
\r
\r
// Dwarf manager Compilation Units close\r
void DWARFManager_CloseDMI(void)\r
{\r
	while (NbCU--)\r
	{\r
		free(PtrCU[NbCU].PtrFullFilename);\r
		free(PtrCU[NbCU].PtrLoadSrc);\r
		free(PtrCU[NbCU].PtrProducer);\r
		free(PtrCU[NbCU].PtrSourceFilename);\r
		free(PtrCU[NbCU].PtrSourceFileDirectory);\r
		free(PtrCU[NbCU].PtrLinesSrc);\r
\r
		while (PtrCU[NbCU].NbLinesLoadSrc--)\r
		{\r
			free(PtrCU[NbCU].PtrLinesLoadSrc[PtrCU[NbCU].NbLinesLoadSrc]);\r
		}\r
		free(PtrCU[NbCU].PtrLinesLoadSrc);\r
\r
		while (PtrCU[NbCU].NbSubProgs--)\r
		{\r
			while (PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbVariables--)\r
			{\r
				free(PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrVariables[PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbVariables].PtrName);\r
				free(PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrVariables[PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbVariables].PtrTypeName);\r
			}\r
			free(PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrVariables);\r
\r
			free(PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrLinesSrc);\r
			free(PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrSubprogramName);\r
		}\r
		free(PtrCU[NbCU].PtrSubProgs);\r
\r
		while (PtrCU[NbCU].NbTypes--)\r
		{\r
			free(PtrCU[NbCU].PtrTypes[PtrCU[NbCU].NbTypes].PtrName);\r
		}\r
		free(PtrCU[NbCU].PtrTypes);\r
\r
		while (PtrCU[NbCU].NbVariables--)\r
		{\r
			free(PtrCU[NbCU].PtrVariables[PtrCU[NbCU].NbVariables].PtrName);\r
			free(PtrCU[NbCU].PtrVariables[PtrCU[NbCU].NbVariables].PtrTypeName);\r
		}\r
		free(PtrCU[NbCU].PtrVariables);\r
	}\r
\r
	free(PtrCU);\r
}\r
\r
\r
// Dwarf manager Compilation Units initialisations\r
void DWARFManager_InitDMI(void)\r
{\r
	Dwarf_Unsigned	next_cu_header, return_uvalue;\r
	Dwarf_Error	error;\r
	Dwarf_Attribute	*atlist;\r
	Dwarf_Attribute	return_attr1;\r
	Dwarf_Half return_tagval, return_attr;\r
	Dwarf_Addr return_lowpc, return_highpc, return_lineaddr;\r
	Dwarf_Block *return_block;\r
	Dwarf_Signed atcnt, cnt;\r
	Dwarf_Die return_sib, return_die, return_sub, return_subdie;\r
	Dwarf_Off return_offset;\r
	Dwarf_Line *linebuf;\r
	FILE *SrcFile;\r
	char *return_string;\r
	char *Ptr, *Ptr1;\r
\r
	// Initialisation for the Compilation Units table\r
	NbCU = 0;\r
	PtrCU = NULL;\r
\r
	// loop on the available Compilation Unit\r
	while (dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, &next_cu_header, &error) == DW_DLV_OK)\r
	{\r
		// Allocation of an additional Compilation Unit structure in the table\r
		if (Ptr = (char *)realloc(PtrCU, ((NbCU + 1) * sizeof(CUStruct))))\r
		{\r
			// Compilation Unit RAZ\r
			PtrCU = (CUStruct *)Ptr;\r
			memset(PtrCU + NbCU, 0, sizeof(CUStruct));\r
\r
			// Debug specific CU\r
#ifdef DEBUG_NumCU\r
			if (NbCU == DEBUG_NumCU)\r
#endif\r
			{\r
				// Get 1st Die from the Compilation Unit\r
				if (dwarf_siblingof(dbg, NULL, &return_sib, &error) == DW_DLV_OK)\r
				{\r
					// Get Die's Tag\r
					if ((dwarf_tag(return_sib, &return_tagval, &error) == DW_DLV_OK))\r
					{\r
						PtrCU[NbCU].Tag = return_tagval;\r
\r
						// Die type detection\r
						switch (return_tagval)\r
						{\r
						case DW_TAG_compile_unit:\r
							if (dwarf_attrlist(return_sib, &atlist, &atcnt, &error) == DW_DLV_OK)\r
							{\r
								for (Dwarf_Signed i = 0; i < atcnt; ++i)\r
								{\r
									if (dwarf_whatattr(atlist[i], &return_attr, &error) == DW_DLV_OK)\r
									{\r
										switch (return_attr)\r
										{\r
											// Start address\r
										case DW_AT_low_pc:\r
											if (dwarf_lowpc(return_sib, &return_lowpc, &error) == DW_DLV_OK)\r
											{\r
												PtrCU[NbCU].LowPC = return_lowpc;\r
											}\r
											break;\r
\r
											// End address\r
										case DW_AT_high_pc:\r
											if (dwarf_highpc(return_sib, &return_highpc, &error) == DW_DLV_OK)\r
											{\r
												PtrCU[NbCU].HighPC = return_highpc;\r
											}\r
											break;\r
\r
											// compilation information\r
										case DW_AT_producer:\r
											if (dwarf_formstring(atlist[i], &return_string, &error) == DW_DLV_OK)\r
											{\r
												PtrCU[NbCU].PtrProducer = (char *)calloc(strlen(return_string) + 1, 1);\r
												strcpy(PtrCU[NbCU].PtrProducer, return_string);\r
												dwarf_dealloc(dbg, return_string, DW_DLA_STRING);\r
											}\r
											break;\r
\r
											// Filename\r
										case DW_AT_name:\r
											if (dwarf_formstring(atlist[i], &return_string, &error) == DW_DLV_OK)\r
											{\r
#ifdef DEBUG_Filename\r
												if (strstr(return_string, DEBUG_Filename))\r
#endif\r
												{\r
													PtrCU[NbCU].PtrSourceFilename = (char *)calloc((strlen(return_string) + 1), 1);\r
													strcpy(PtrCU[NbCU].PtrSourceFilename, return_string);\r
												}\r
												dwarf_dealloc(dbg, return_string, DW_DLA_STRING);\r
											}\r
											break;\r
\r
											// Directory name\r
										case DW_AT_comp_dir:\r
											if (dwarf_formstring(atlist[i], &return_string, &error) == DW_DLV_OK)\r
											{\r
												PtrCU[NbCU].PtrSourceFileDirectory = (char *)calloc((strlen(return_string) + 1), 1);\r
												strcpy(PtrCU[NbCU].PtrSourceFileDirectory, return_string);\r
												dwarf_dealloc(dbg, return_string, DW_DLA_STRING);\r
											}\r
											break;\r
\r
										default:\r
											break;\r
										}\r
									}\r
									dwarf_dealloc(dbg, atlist[i], DW_DLA_ATTR);\r
								}\r
								dwarf_dealloc(dbg, atlist, DW_DLA_LIST);\r
							}\r
\r
							// Check filename presence\r
							if (!PtrCU[NbCU].PtrSourceFilename)\r
							{\r
								PtrCU[NbCU].PtrSourceFilename = (char *)calloc(1, 1);\r
							}\r
\r
							// Check directory presence\r
							if (!PtrCU[NbCU].PtrSourceFileDirectory)\r
							{\r
								// Check if file exists in the search paths\r
								for (size_t i = 0; i < NbSearchPaths; i++)\r
								{\r
									PtrCU[NbCU].PtrFullFilename = (char *)realloc(PtrCU[NbCU].PtrFullFilename, strlen(PtrCU[NbCU].PtrSourceFilename) + strlen((const char *)ListSearchPaths[i]) + 2);\r
#if defined(_WIN32)\r
									sprintf(PtrCU[NbCU].PtrFullFilename, "%s\\%s", ListSearchPaths[i], PtrCU[NbCU].PtrSourceFilename);\r
#else\r
									sprintf(PtrCU[NbCU].PtrFullFilename, "%s/%s", ListSearchPaths[i], PtrCU[NbCU].PtrSourceFilename);\r
#endif\r
									if (!fopen_s(&SrcFile, PtrCU[NbCU].PtrFullFilename, "rb"))\r
									{\r
										PtrCU[NbCU].PtrSourceFileDirectory = (char *)realloc(PtrCU[NbCU].PtrSourceFileDirectory, strlen(ListSearchPaths[i]) + 1);\r
										strcpy(PtrCU[NbCU].PtrSourceFileDirectory, ListSearchPaths[i]);\r
									}\r
								}\r
\r
								// File directory doesn't exits\r
								if (!PtrCU[NbCU].PtrSourceFileDirectory)\r
								{\r
									PtrCU[NbCU].PtrSourceFileDirectory = (char *)realloc(PtrCU[NbCU].PtrSourceFileDirectory, 2);\r
									strcpy(PtrCU[NbCU].PtrSourceFileDirectory, ".");\r
								}\r
							}\r
\r
							// Create full filename\r
							Ptr = PtrCU[NbCU].PtrFullFilename = (char *)realloc(PtrCU[NbCU].PtrFullFilename, strlen(PtrCU[NbCU].PtrSourceFilename) + strlen(PtrCU[NbCU].PtrSourceFileDirectory) + 2);\r
#if defined(_WIN32)\r
							sprintf(PtrCU[NbCU].PtrFullFilename, "%s\\%s", PtrCU[NbCU].PtrSourceFileDirectory, PtrCU[NbCU].PtrSourceFilename);\r
#else\r
							sprintf(PtrCU[NbCU].PtrFullFilename, "%s/%s", PtrCU[NbCU].PtrSourceFileDirectory, PtrCU[NbCU].PtrSourceFilename);\r
#endif\r
							// Conform slashes and backslashes\r
							while (*Ptr)\r
							{\r
#if defined(_WIN32)\r
								if (*Ptr == '/')\r
								{\r
									*Ptr = '\\';\r
								}\r
#else\r
								if (*Ptr == '\\')\r
								{\r
									*Ptr = '/';\r
								}\r
#endif\r
								Ptr++;\r
							}\r
\r
							// Directory path clean-up\r
#if defined(_WIN32)\r
							while ((Ptr1 = Ptr = strstr(PtrCU[NbCU].PtrFullFilename, "\\..\\")))\r
#else\r
							while ((Ptr1 = Ptr = strstr(PtrCU[NbCU].PtrFullFilename, "/../")))\r
#endif\r
							{\r
#if defined(_WIN32)\r
								while (*--Ptr1 != '\\');\r
#else\r
								while (*--Ptr1 != '/');\r
#endif\r
								strcpy((Ptr1 + 1), (Ptr + 4));\r
							}\r
\r
							// Open the source file as a binary file\r
							if (!fopen_s(&SrcFile, PtrCU[NbCU].PtrFullFilename, "rb"))\r
							{\r
								if (!fseek(SrcFile, 0, SEEK_END))\r
								{\r
									if ((PtrCU[NbCU].SizeLoadSrc = ftell(SrcFile)) > 0)\r
									{\r
										if (!fseek(SrcFile, 0, SEEK_SET))\r
										{\r
											if (PtrCU[NbCU].PtrLoadSrc = Ptr = Ptr1 = (char *)calloc(1, (PtrCU[NbCU].SizeLoadSrc + 2)))\r
											{\r
												// Read whole file\r
												if (fread_s(PtrCU[NbCU].PtrLoadSrc, PtrCU[NbCU].SizeLoadSrc, PtrCU[NbCU].SizeLoadSrc, 1, SrcFile) != 1)\r
												{\r
													free(PtrCU[NbCU].PtrLoadSrc);\r
													PtrCU[NbCU].PtrLoadSrc = NULL;\r
													PtrCU[NbCU].SizeLoadSrc = 0;\r
												}\r
												else\r
												{\r
													// Eliminate all carriage return code '\r' (oxd)\r
													do\r
													{\r
														if ((*Ptr = *Ptr1) != '\r')\r
														{\r
															Ptr++;\r
														}\r
													}\r
													while (*Ptr1++);\r
\r
													// Get back the new text file size\r
													PtrCU[NbCU].SizeLoadSrc = strlen(Ptr = PtrCU[NbCU].PtrLoadSrc);\r
\r
													// Make sure the text file finish with a new line code '\n' (0xa)\r
													if (PtrCU[NbCU].PtrLoadSrc[PtrCU[NbCU].SizeLoadSrc - 1] != '\n')\r
													{\r
														PtrCU[NbCU].PtrLoadSrc[PtrCU[NbCU].SizeLoadSrc++] = '\n';\r
														PtrCU[NbCU].PtrLoadSrc[PtrCU[NbCU].SizeLoadSrc] = 0;\r
													}\r
\r
													// Reallocate text file\r
													if (PtrCU[NbCU].PtrLoadSrc = Ptr = (char *)realloc(PtrCU[NbCU].PtrLoadSrc, (PtrCU[NbCU].SizeLoadSrc + 1)))\r
													{\r
														// Count line numbers, based on the new line code '\n' (0xa), and finish each line with 0\r
														do\r
														{\r
															if (*Ptr == '\n')\r
															{\r
																PtrCU[NbCU].NbLinesLoadSrc++;\r
																*Ptr = 0;\r
															}\r
														} while (*++Ptr);\r
													}\r
												}\r
											}\r
										}\r
									}\r
								}\r
								fclose(SrcFile);\r
							}\r
							break;\r
\r
						default:\r
							break;\r
						}\r
					}\r
\r
					// Get the source lines table located in the CU\r
					if (dwarf_srclines(return_sib, &linebuf, &cnt, &error) == DW_DLV_OK)\r
					{\r
						if (cnt)\r
						{\r
							PtrCU[NbCU].NbLinesSrc = cnt;\r
							PtrCU[NbCU].PtrLinesSrc = (CUStruct_LineSrc *)calloc(cnt, sizeof(CUStruct_LineSrc));\r
							for (Dwarf_Signed i = 0; i < cnt; i++)\r
							{\r
								if (dwarf_lineaddr(linebuf[i], &return_lineaddr, &error) == DW_DLV_OK)\r
								{\r
									if (dwarf_lineno(linebuf[i], &return_uvalue, &error) == DW_DLV_OK)\r
									{\r
										PtrCU[NbCU].PtrLinesSrc[i].StartPC = return_lineaddr;\r
										PtrCU[NbCU].PtrLinesSrc[i].NumLineSrc = return_uvalue;\r
									}\r
								}\r
							}\r
						}\r
					}\r
\r
					// Check if the CU has child\r
					if (dwarf_child(return_sib, &return_die, &error) == DW_DLV_OK)\r
					{\r
						do\r
						{\r
							return_sib = return_die;\r
							if ((dwarf_tag(return_die, &return_tagval, &error) == DW_DLV_OK))\r
							{\r
								switch (return_tagval)\r
								{\r
								case DW_TAG_lexical_block:\r
									break;\r
\r
								case DW_TAG_variable:\r
									if (dwarf_attrlist(return_die, &atlist, &atcnt, &error) == DW_DLV_OK)\r
									{\r
										PtrCU[NbCU].PtrVariables = (VariablesStruct *)realloc(PtrCU[NbCU].PtrVariables, ((PtrCU[NbCU].NbVariables + 1) * sizeof(VariablesStruct)));\r
										memset(PtrCU[NbCU].PtrVariables + PtrCU[NbCU].NbVariables, 0, sizeof(VariablesStruct));\r
\r
										for (Dwarf_Signed i = 0; i < atcnt; ++i)\r
										{\r
											if (dwarf_whatattr(atlist[i], &return_attr, &error) == DW_DLV_OK)\r
											{\r
												if (dwarf_attr(return_die, return_attr, &return_attr1, &error) == DW_DLV_OK)\r
												{\r
													switch (return_attr)\r
													{\r
													case DW_AT_location:\r
														if (dwarf_formblock(return_attr1, &return_block, &error) == DW_DLV_OK)\r
														{\r
															PtrCU[NbCU].PtrVariables[PtrCU[NbCU].NbVariables].Op = (*((unsigned char *)(return_block->bl_data)));\r
\r
															switch (return_block->bl_len)\r
															{\r
															case 5:\r
																PtrCU[NbCU].PtrVariables[PtrCU[NbCU].NbVariables].Addr = (*((unsigned char *)(return_block->bl_data) + 1) << 24) + (*((unsigned char *)(return_block->bl_data) + 2) << 16) + (*((unsigned char *)(return_block->bl_data) + 3) << 8) + (*((unsigned char *)(return_block->bl_data) + 4));\r
																break;\r
\r
															default:\r
																break;\r
															}\r
															dwarf_dealloc(dbg, return_block, DW_DLA_BLOCK);\r
														}\r
														break;\r
\r
													case DW_AT_type:\r
														if (dwarf_global_formref(return_attr1, &return_offset, &error) == DW_DLV_OK)\r
														{\r
															PtrCU[NbCU].PtrVariables[PtrCU[NbCU].NbVariables].TypeOffset = return_offset;\r
														}\r
														break;\r
\r
														// Variable name\r
													case DW_AT_name:\r
														if (dwarf_formstring(return_attr1, &return_string, &error) == DW_DLV_OK)\r
														{\r
#ifdef DEBUG_VariableName\r
															if (!strcmp(return_string, DEBUG_VariableName))\r
#endif\r
															{\r
																PtrCU[NbCU].PtrVariables[PtrCU[NbCU].NbVariables].PtrName = (char *)calloc(strlen(return_string) + 1, 1);\r
																strcpy(PtrCU[NbCU].PtrVariables[PtrCU[NbCU].NbVariables].PtrName, return_string);\r
															}\r
															dwarf_dealloc(dbg, return_string, DW_DLA_STRING);\r
														}\r
														break;\r
\r
														default:\r
														break;\r
													}\r
												}\r
											}\r
\r
											dwarf_dealloc(dbg, atlist[i], DW_DLA_ATTR);\r
										}\r
\r
										// Check variable's name validity\r
										if (PtrCU[NbCU].PtrVariables[PtrCU[NbCU].NbVariables].PtrName)\r
										{\r
											// Check variable's memory address validity\r
											if (PtrCU[NbCU].PtrVariables[PtrCU[NbCU].NbVariables].Addr)\r
											{\r
												// Valid variable\r
												PtrCU[NbCU].NbVariables++;\r
											}\r
											else\r
											{\r
												// Invalid variable\r
												free(PtrCU[NbCU].PtrVariables[PtrCU[NbCU].NbVariables].PtrName);\r
												PtrCU[NbCU].PtrVariables[PtrCU[NbCU].NbVariables].PtrName = NULL;\r
											}\r
										}\r
\r
										dwarf_dealloc(dbg, atlist, DW_DLA_LIST);\r
									}\r
									break;\r
\r
								case DW_TAG_base_type:\r
								case DW_TAG_typedef:\r
								case DW_TAG_structure_type:\r
								case DW_TAG_pointer_type:\r
								case DW_TAG_const_type:\r
								case DW_TAG_array_type:\r
								case DW_TAG_subrange_type:\r
								case DW_TAG_subroutine_type:\r
								case DW_TAG_enumeration_type:\r
									if (dwarf_attrlist(return_die, &atlist, &atcnt, &error) == DW_DLV_OK)\r
									{\r
										// Allocate memory for this type\r
										PtrCU[NbCU].PtrTypes = (BaseTypeStruct *)realloc(PtrCU[NbCU].PtrTypes, ((PtrCU[NbCU].NbTypes + 1) * sizeof(BaseTypeStruct)));\r
										memset(PtrCU[NbCU].PtrTypes + PtrCU[NbCU].NbTypes, 0, sizeof(BaseTypeStruct));\r
										PtrCU[NbCU].PtrTypes[PtrCU[NbCU].NbTypes].Tag = return_tagval;\r
\r
										if (dwarf_dieoffset(return_die, &return_offset, &error) == DW_DLV_OK)\r
										{\r
											PtrCU[NbCU].PtrTypes[PtrCU[NbCU].NbTypes].Offset = return_offset;\r
										}\r
\r
										for (Dwarf_Signed i = 0; i < atcnt; ++i)\r
										{\r
											if (dwarf_whatattr(atlist[i], &return_attr, &error) == DW_DLV_OK)\r
											{\r
												if (dwarf_attr(return_die, return_attr, &return_attr1, &error) == DW_DLV_OK)\r
												{\r
													switch (return_attr)\r
													{\r
														// \r
													case DW_AT_sibling:\r
														break;\r
\r
														// Type's type offset\r
													case DW_AT_type:\r
														if (dwarf_global_formref(return_attr1, &return_offset, &error) == DW_DLV_OK)\r
														{\r
															PtrCU[NbCU].PtrTypes[PtrCU[NbCU].NbTypes].TypeOffset = return_offset;\r
														}\r
														break;\r
\r
														// Type's byte size\r
													case DW_AT_byte_size:\r
														if (dwarf_formudata(return_attr1, &return_uvalue, &error) == DW_DLV_OK)\r
														{\r
															PtrCU[NbCU].PtrTypes[PtrCU[NbCU].NbTypes].ByteSize = return_uvalue;\r
														}\r
														break;\r
\r
														// Type's encoding\r
													case DW_AT_encoding:\r
														if (dwarf_formudata(return_attr1, &return_uvalue, &error) == DW_DLV_OK)\r
														{\r
															PtrCU[NbCU].PtrTypes[PtrCU[NbCU].NbTypes].Encoding = return_uvalue;\r
														}\r
														break;\r
\r
														// Type's name\r
													case DW_AT_name:\r
														if (dwarf_formstring(return_attr1, &return_string, &error) == DW_DLV_OK)\r
														{\r
#ifdef DEBUG_TypeName\r
															if (!strcmp(return_string, DEBUG_TypeName))\r
#endif\r
															{\r
																PtrCU[NbCU].PtrTypes[PtrCU[NbCU].NbTypes].PtrName = (char *)calloc(strlen(return_string) + 1, 1);\r
																strcpy(PtrCU[NbCU].PtrTypes[PtrCU[NbCU].NbTypes].PtrName, return_string);\r
															}\r
															dwarf_dealloc(dbg, return_string, DW_DLA_STRING);\r
														}\r
														break;\r
\r
														// Type's file number\r
													case DW_AT_decl_file:\r
														break;\r
\r
														// Type's line number\r
													case DW_AT_decl_line:\r
														break;\r
\r
													default:\r
														break;\r
													}\r
												}\r
											}\r
\r
											dwarf_dealloc(dbg, atlist[i], DW_DLA_ATTR);\r
										}\r
\r
										PtrCU[NbCU].NbTypes++;\r
\r
										dwarf_dealloc(dbg, atlist, DW_DLA_LIST);\r
									}\r
									break;\r
\r
								case DW_TAG_subprogram:\r
									if (dwarf_attrlist(return_die, &atlist, &atcnt, &error) == DW_DLV_OK)\r
									{\r
										PtrCU[NbCU].PtrSubProgs = (SubProgStruct *)realloc(PtrCU[NbCU].PtrSubProgs, ((PtrCU[NbCU].NbSubProgs + 1) * sizeof(SubProgStruct)));\r
										memset((void *)(PtrCU[NbCU].PtrSubProgs + PtrCU[NbCU].NbSubProgs), 0, sizeof(SubProgStruct));\r
										PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].Tag = return_tagval;\r
\r
										for (Dwarf_Signed i = 0; i < atcnt; ++i)\r
										{\r
											if (dwarf_whatattr(atlist[i], &return_attr, &error) == DW_DLV_OK)\r
											{\r
												if (dwarf_attr(return_die, return_attr, &return_attr1, &error) == DW_DLV_OK)\r
												{\r
													switch (return_attr)\r
													{\r
														// start address\r
													case DW_AT_low_pc:\r
														if (dwarf_lowpc(return_die, &return_lowpc, &error) == DW_DLV_OK)\r
														{\r
															PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].StartPC = return_lowpc;\r
															PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].LowPC = return_lowpc;\r
														}\r
														break;\r
\r
														// end address\r
													case DW_AT_high_pc:\r
														if (dwarf_highpc(return_die, &return_highpc, &error) == DW_DLV_OK)\r
														{\r
															PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].HighPC = return_highpc;\r
														}\r
														break;\r
\r
														// Line number\r
													case DW_AT_decl_line:\r
														if (dwarf_formudata(return_attr1, &return_uvalue, &error) == DW_DLV_OK)\r
														{\r
															PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NumLineSrc = return_uvalue;\r
														}\r
														break;\r
\r
														// Frame\r
													case DW_AT_frame_base:\r
														if (dwarf_formudata(return_attr1, &return_uvalue, &error) == DW_DLV_OK)\r
														{\r
															PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].FrameBase = return_uvalue;\r
															PtrCU[NbCU].NbFrames++;\r
														}\r
														break;\r
\r
														// function name\r
													case DW_AT_name:\r
														if (dwarf_formstring(return_attr1, &return_string, &error) == DW_DLV_OK)\r
														{\r
															PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrSubprogramName = (char *)calloc(strlen(return_string) + 1, 1);\r
															strcpy(PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrSubprogramName, return_string);\r
															dwarf_dealloc(dbg, return_string, DW_DLA_STRING);\r
														}\r
														break;\r
\r
													case DW_AT_sibling:\r
														break;\r
\r
													case DW_AT_GNU_all_tail_call_sites:\r
														break;\r
\r
													case DW_AT_type:\r
														break;\r
\r
													case DW_AT_prototyped:\r
														break;\r
\r
														// File number\r
													case DW_AT_decl_file:\r
														break;\r
\r
													case DW_AT_external:\r
														break;\r
\r
													default:\r
														break;\r
													}\r
												}\r
											}\r
											dwarf_dealloc(dbg, atlist[i], DW_DLA_ATTR);\r
										}\r
										dwarf_dealloc(dbg, atlist, DW_DLA_LIST);\r
\r
										// Get source line number and associated block of address\r
										for (Dwarf_Signed i = 0; i < cnt; ++i)\r
										{\r
											if (dwarf_lineaddr(linebuf[i], &return_lineaddr, &error) == DW_DLV_OK)\r
											{\r
												if (dwarf_lineno(linebuf[i], &return_uvalue, &error) == DW_DLV_OK)\r
												{\r
													if ((return_lineaddr >= return_lowpc) && (return_lineaddr <= return_highpc))\r
													{\r
														PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrLinesSrc = (DMIStruct_LineSrc *)realloc(PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrLinesSrc, (PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbLinesSrc + 1) * sizeof(DMIStruct_LineSrc));\r
														memset((void *)(PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrLinesSrc + PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbLinesSrc), 0, sizeof(DMIStruct_LineSrc));\r
														PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrLinesSrc[PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbLinesSrc].StartPC = return_lineaddr;\r
														PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrLinesSrc[PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbLinesSrc].NumLineSrc = return_uvalue;\r
														PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbLinesSrc++;\r
													}\r
												}\r
											}\r
										}\r
\r
										if (dwarf_child(return_die, &return_subdie, &error) == DW_DLV_OK)\r
										{\r
											do\r
											{\r
												return_sub = return_subdie;\r
												if ((dwarf_tag(return_subdie, &return_tagval, &error) == DW_DLV_OK))\r
												{\r
													switch (return_tagval)\r
													{\r
													case DW_TAG_formal_parameter:\r
													case DW_TAG_variable:\r
														if (dwarf_attrlist(return_subdie, &atlist, &atcnt, &error) == DW_DLV_OK)\r
														{\r
															PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrVariables = (VariablesStruct *)realloc(PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrVariables, ((PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbVariables + 1) * sizeof(VariablesStruct)));\r
															memset(PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrVariables + PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbVariables, 0, sizeof(VariablesStruct));\r
\r
															for (Dwarf_Signed i = 0; i < atcnt; ++i)\r
															{\r
																if (dwarf_whatattr(atlist[i], &return_attr, &error) == DW_DLV_OK)\r
																{\r
																	if (dwarf_attr(return_subdie, return_attr, &return_attr1, &error) == DW_DLV_OK)\r
																	{\r
																		switch (return_attr)\r
																		{\r
																		case DW_AT_location:\r
																			if (dwarf_formblock(return_attr1, &return_block, &error) == DW_DLV_OK)\r
																			{\r
																				PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrVariables[PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbVariables].Op = *((unsigned char *)(return_block->bl_data));\r
\r
																				switch (return_block->bl_len)\r
																				{\r
																				case 1:\r
																					break;\r
\r
																				case 2:\r
																				case 3:\r
																					switch (return_tagval)\r
																					{\r
																					case DW_TAG_variable:\r
																						PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrVariables[PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbVariables].Offset = ReadLEB128((char *)return_block->bl_data + 1);\r
																						break;\r
\r
																					case DW_TAG_formal_parameter:\r
																						PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrVariables[PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbVariables].Offset = ReadULEB128((char *)return_block->bl_data + 1);\r
																						break;\r
\r
																					default:\r
																						break;\r
																					}\r
																					break;\r
\r
																				default:\r
																					break;\r
																				}\r
																				dwarf_dealloc(dbg, return_block, DW_DLA_BLOCK);\r
																			}\r
																			break;\r
\r
																		case DW_AT_type:\r
																			if (dwarf_global_formref(return_attr1, &return_offset, &error) == DW_DLV_OK)\r
																			{\r
																				PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrVariables[PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbVariables].TypeOffset = return_offset;\r
																			}\r
																			break;\r
\r
																		case DW_AT_name:\r
																			if (dwarf_formstring(return_attr1, &return_string, &error) == DW_DLV_OK)\r
																			{\r
#ifdef DEBUG_VariableName\r
																				if (!strcmp(return_string, DEBUG_VariableName))\r
#endif\r
																				{\r
																					PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrVariables[PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbVariables].PtrName = (char *)calloc(strlen(return_string) + 1, 1);\r
																					strcpy(PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].PtrVariables[PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbVariables].PtrName, return_string);\r
																				}\r
																				dwarf_dealloc(dbg, return_string, DW_DLA_STRING);\r
																			}\r
																			break;\r
\r
																		case DW_AT_decl_file:\r
																			break;\r
\r
																		case DW_AT_decl_line:\r
																			break;\r
\r
																		default:\r
																			break;\r
																		}\r
																	}\r
																}\r
\r
																dwarf_dealloc(dbg, atlist[i], DW_DLA_ATTR);\r
															}\r
\r
															PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs].NbVariables++;\r
\r
															dwarf_dealloc(dbg, atlist, DW_DLA_LIST);\r
														}\r
														break;\r
\r
													case DW_TAG_label:\r
														break;\r
\r
													default:\r
														break;\r
													}\r
												}\r
											}\r
											while (dwarf_siblingof(dbg, return_sub, &return_subdie, &error) == DW_DLV_OK);\r
										}\r
\r
										PtrCU[NbCU].NbSubProgs++;\r
									}\r
									break;\r
\r
								default:\r
									break;\r
								}\r
							}\r
						}\r
						while (dwarf_siblingof(dbg, return_sib, &return_die, &error) == DW_DLV_OK);\r
					}\r
\r
					// Release the memory used by the source lines\r
					for (Dwarf_Signed i = 0; i < cnt; ++i)\r
					{\r
						dwarf_dealloc(dbg, linebuf[i], DW_DLA_LINE);\r
					}\r
					dwarf_dealloc(dbg, linebuf, DW_DLA_LIST);\r
				}\r
\r
				// Set the source code lines for QT html/text conformity\r
				if (PtrCU[NbCU].NbLinesLoadSrc)\r
				{\r
					if (PtrCU[NbCU].PtrLinesLoadSrc = (char **)calloc(PtrCU[NbCU].NbLinesLoadSrc, sizeof(char *)))\r
					{\r
						for (size_t j = 0; j < PtrCU[NbCU].NbLinesLoadSrc; j++)\r
						{\r
							if (PtrCU[NbCU].PtrLinesLoadSrc[j] = (char *)calloc(10000, sizeof(char)))\r
							{\r
								if (Ptr = DWARFManager_GetLineSrcFromNumLine(PtrCU[NbCU].PtrLoadSrc, (j + 1)))\r
								{\r
									size_t i = 0;\r
\r
									while (*Ptr)\r
									{\r
										switch (*Ptr)\r
										{\r
										case 9:\r
											strcat(PtrCU[NbCU].PtrLinesLoadSrc[j], "&nbsp;");\r
											i += 6;\r
											break;\r
\r
										case '<':\r
											strcat(PtrCU[NbCU].PtrLinesLoadSrc[j], "&lt;");\r
											i += 4;\r
											break;\r
\r
										case '>':\r
											strcat(PtrCU[NbCU].PtrLinesLoadSrc[j], "&gt;");\r
											i += 4;\r
											break;\r
#if 0\r
										case '&':\r
											strcpy(PtrCU[NbCU].PtrLinesLoadSrc[j], "&amp;");\r
											i += strlen("&amp;");\r
											break;\r
#endif\r
#if 0\r
										case '"':\r
											strcpy(PtrCU[NbCU].PtrLinesLoadSrc[j], "&quot;");\r
											i += strlen("&quot;");\r
											break;\r
#endif\r
										default:\r
											PtrCU[NbCU].PtrLinesLoadSrc[j][i++] = *Ptr;\r
											break;\r
										}\r
										Ptr++;\r
									}\r
								}\r
								PtrCU[NbCU].PtrLinesLoadSrc[j] = (char *)realloc(PtrCU[NbCU].PtrLinesLoadSrc[j], strlen(PtrCU[NbCU].PtrLinesLoadSrc[j]) + 1);\r
							}\r
						}\r
\r
						// Init lines source information for each source code line numbers and for each subprogs\r
						for (size_t j = 0; j < PtrCU[NbCU].NbSubProgs; j++)\r
						{\r
							// Check if the subprog / function's line exists in the source code\r
							if (PtrCU[NbCU].PtrSubProgs[j].NumLineSrc <= PtrCU[NbCU].NbLinesLoadSrc)\r
							{\r
								PtrCU[NbCU].PtrSubProgs[j].PtrLineSrc = PtrCU[NbCU].PtrLinesLoadSrc[PtrCU[NbCU].PtrSubProgs[j].NumLineSrc - 1];\r
							}\r
\r
							for (size_t k = 0; k < PtrCU[NbCU].PtrSubProgs[j].NbLinesSrc; k++)\r
							{\r
								if (PtrCU[NbCU].PtrSubProgs[j].PtrLinesSrc[k].NumLineSrc <= PtrCU[NbCU].NbLinesLoadSrc)\r
								{\r
									PtrCU[NbCU].PtrSubProgs[j].PtrLinesSrc[k].PtrLineSrc = PtrCU[NbCU].PtrLinesLoadSrc[PtrCU[NbCU].PtrSubProgs[j].PtrLinesSrc[k].NumLineSrc - 1];\r
								}\r
							}\r
						}\r
					}\r
				}\r
				else\r
				{\r
					// Set each source lines pointer to NULL\r
					if (PtrCU[NbCU].NbSubProgs)\r
					{\r
						// Check the presence of source lines dedicated to the sub progs\r
						if (PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs - 1].NbLinesSrc)\r
						{\r
							size_t i = PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs - 1].PtrLinesSrc[PtrCU[NbCU].PtrSubProgs[PtrCU[NbCU].NbSubProgs - 1].NbLinesSrc - 1].NumLineSrc;\r
							if (PtrCU[NbCU].PtrLinesLoadSrc = (char **)calloc(i, sizeof(char *)))\r
							{\r
								for (size_t j = 0; j < i; j++)\r
								{\r
									PtrCU[NbCU].PtrLinesLoadSrc[j] = NULL;\r
								}\r
							}\r
						}\r
					}\r
				}\r
\r
				// Set information based on used line numbers\r
				if (PtrCU[NbCU].PtrLinesSrc)\r
				{\r
					// Set the line source pointer for each used line numbers\r
					if (PtrCU[NbCU].PtrLinesLoadSrc)\r
					{\r
						for (size_t i = 0; i < PtrCU[NbCU].NbLinesSrc; i++)\r
						{\r
							PtrCU[NbCU].PtrLinesSrc[i].PtrLineSrc = PtrCU[NbCU].PtrLinesLoadSrc[PtrCU[NbCU].PtrLinesSrc[i].NumLineSrc - 1];\r
						}\r
\r
						// Setup memory range for the code if CU doesn't have already this information\r
						// It is taken from the used lines structure\r
						if (!PtrCU[NbCU].LowPC && (!PtrCU[NbCU].HighPC || (PtrCU[NbCU].HighPC == ~0)))\r
						{\r
							PtrCU[NbCU].LowPC = PtrCU[NbCU].PtrLinesSrc[0].StartPC;\r
							PtrCU[NbCU].HighPC = PtrCU[NbCU].PtrLinesSrc[PtrCU[NbCU].NbLinesSrc - 1].StartPC;\r
						}\r
					}\r
				}\r
\r
				// Init global variables information based on types information\r
				for (size_t i = 0; i < PtrCU[NbCU].NbVariables; i++)\r
				{\r
					DWARFManager_InitInfosVariable(PtrCU[NbCU].PtrVariables + i);\r
				}\r
\r
				// Init local variables information based on types information\r
				for (size_t i = 0; i < PtrCU[NbCU].NbSubProgs; i++)\r
				{\r
					for (size_t j = 0; j < PtrCU[NbCU].PtrSubProgs[i].NbVariables; j++)\r
					{\r
						DWARFManager_InitInfosVariable(PtrCU[NbCU].PtrSubProgs[i].PtrVariables + j);\r
					}\r
				}\r
			}\r
\r
			++NbCU;\r
		}\r
	} \r
}\r
\r
\r
// Variables information initialisation\r
void DWARFManager_InitInfosVariable(VariablesStruct *PtrVariables)\r
{\r
	size_t j, TypeOffset;\r
\r
#ifdef DEBUG_VariableName\r
	if (PtrVariables->PtrName && !strcmp(PtrVariables->PtrName, DEBUG_VariableName))\r
#endif\r
	{\r
		PtrVariables->PtrTypeName = (char *)calloc(1000, 1);\r
		TypeOffset = PtrVariables->TypeOffset;\r
\r
		for (j = 0; j < PtrCU[NbCU].NbTypes; j++)\r
		{\r
			if (TypeOffset == PtrCU[NbCU].PtrTypes[j].Offset)\r
			{\r
				switch (PtrCU[NbCU].PtrTypes[j].Tag)\r
				{\r
				case DW_TAG_subroutine_type:\r
					PtrVariables->TypeTag |= TypeTag_subroutine_type;\r
					strcat(PtrVariables->PtrTypeName, " (* ) ()");\r
					break;\r
\r
					// Structure type tag\r
				case DW_TAG_structure_type:\r
					PtrVariables->TypeTag |= TypeTag_structure;\r
					if (!(PtrVariables->TypeTag & TypeTag_typedef))\r
					{\r
						strcat(PtrVariables->PtrTypeName, PtrCU[NbCU].PtrTypes[j].PtrName);\r
					}\r
					if ((TypeOffset = PtrCU[NbCU].PtrTypes[j].TypeOffset))\r
					{\r
						j = -1;\r
					}\r
					else\r
					{\r
						if ((PtrVariables->TypeTag & TypeTag_pointer))\r
						{\r
							strcat(PtrVariables->PtrTypeName, " *");\r
						}\r
					}\r
					break;\r
\r
					// Pointer type tag\r
				case DW_TAG_pointer_type:\r
					PtrVariables->TypeTag |= TypeTag_pointer;\r
					PtrVariables->TypeByteSize = PtrCU[NbCU].PtrTypes[j].ByteSize;\r
					PtrVariables->TypeEncoding = 0x10;\r
					if (!(TypeOffset = PtrCU[NbCU].PtrTypes[j].TypeOffset))\r
					{\r
						strcat(PtrVariables->PtrTypeName, "void *");\r
					}\r
					else\r
					{\r
						j = -1;\r
					}\r
					break;\r
\r
				case DW_TAG_enumeration_type:\r
					PtrVariables->TypeTag |= TypeTag_enumeration_type;\r
					PtrVariables->TypeByteSize = PtrCU[NbCU].PtrTypes[j].ByteSize;\r
					if (!(PtrVariables->TypeEncoding = PtrCU[NbCU].PtrTypes[j].Encoding))\r
					{\r
						// Try to determine the possible size\r
						switch (PtrVariables->TypeByteSize)\r
						{\r
						case 4:\r
							PtrVariables->TypeEncoding = 0x7;\r
							break;\r
\r
						default:\r
							break;\r
						}\r
					}\r
					break;\r
\r
					// Typedef type tag\r
				case DW_TAG_typedef:\r
					if (!(PtrVariables->TypeTag & TypeTag_typedef))\r
					{\r
						PtrVariables->TypeTag |= TypeTag_typedef;\r
						strcat(PtrVariables->PtrTypeName, PtrCU[NbCU].PtrTypes[j].PtrName);\r
					}\r
					if ((TypeOffset = PtrCU[NbCU].PtrTypes[j].TypeOffset))\r
					{\r
						j = -1;\r
					}\r
					break;\r
\r
					// ? type tag\r
				case DW_TAG_subrange_type:\r
					PtrVariables->TypeTag |= TypeTag_subrange;\r
					break;\r
\r
					// Array type tag\r
				case DW_TAG_array_type:\r
					PtrVariables->TypeTag |= TypeTag_arraytype;\r
					if ((TypeOffset = PtrCU[NbCU].PtrTypes[j].TypeOffset))\r
					{\r
						j = -1;\r
					}\r
					break;\r
\r
					// Const type tag\r
				case DW_TAG_const_type:\r
					PtrVariables->TypeTag |= TypeTag_consttype;\r
					strcat(PtrVariables->PtrTypeName, "const ");\r
					if ((TypeOffset = PtrCU[NbCU].PtrTypes[j].TypeOffset))\r
					{\r
						j = -1;\r
					}\r
					break;\r
\r
					// Base type tag\r
				case DW_TAG_base_type:\r
					if (!(PtrVariables->TypeTag & TypeTag_typedef))\r
					{\r
						strcat(PtrVariables->PtrTypeName, PtrCU[NbCU].PtrTypes[j].PtrName);\r
					}\r
					if ((PtrVariables->TypeTag & TypeTag_pointer))\r
					{\r
						strcat(PtrVariables->PtrTypeName, " *");\r
					}\r
					else\r
					{\r
						PtrVariables->TypeByteSize = PtrCU[NbCU].PtrTypes[j].ByteSize;\r
						PtrVariables->TypeEncoding = PtrCU[NbCU].PtrTypes[j].Encoding;\r
					}\r
					if ((PtrVariables->TypeTag & TypeTag_arraytype))\r
					{\r
						strcat(PtrVariables->PtrTypeName, "[]");\r
					}\r
					break;\r
\r
				default:\r
					break;\r
				}\r
			}\r
		}\r
	}\r
}\r
\r
\r
// Get symbol name based from address\r
// Return NULL if no symbol name exists\r
char *DWARFManager_GetSymbolnameFromAdr(size_t Adr)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((PtrCU[i].PtrSubProgs[j].StartPC == Adr))\r
				{\r
					return PtrCU[i].PtrSubProgs[j].PtrSubprogramName;\r
				}\r
			}\r
		}\r
	}\r
\r
	return NULL;\r
}\r
\r
\r
// Get complete source filename based from address\r
// Return NULL if no source filename exists\r
// Return the existence status (true or false) in Error\r
char *DWARFManager_GetFullSourceFilenameFromAdr(size_t Adr, bool *Error)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			*Error = PtrCU[i].PtrLoadSrc ? true : false;\r
			return PtrCU[i].PtrFullFilename;\r
		}\r
	}\r
\r
	return	NULL;\r
}\r
\r
\r
// Get text line source based on line number (starting from 1)\r
// Return NULL if no text line exists or if line number is 0\r
char *DWARFManager_GetLineSrcFromNumLine(char *PtrSrcFile, size_t NumLine)\r
{\r
	size_t i = 0;\r
	char *PtrLineSrc = NULL;\r
\r
	if (PtrSrcFile)\r
	{\r
		while (i != NumLine)\r
		{\r
			PtrLineSrc = PtrSrcFile;\r
			while (*PtrSrcFile++);\r
			i++;\r
		}\r
	}\r
\r
	return PtrLineSrc;\r
}\r
\r
\r
// Get number of variables referenced by the function range address\r
size_t DWARFManager_GetNbLocalVariables(size_t Adr)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((Adr >= PtrCU[i].PtrSubProgs[j].LowPC) && (Adr < PtrCU[i].PtrSubProgs[j].HighPC))\r
				{\r
					return PtrCU[i].PtrSubProgs[j].NbVariables;\r
				}\r
			}\r
		}\r
	}\r
\r
	return 0;\r
}\r
\r
\r
// Get local variable name based on his index (starting from 1)\r
// Return name's pointer text found\r
// Return NULL if not found\r
char *DWARFManager_GetLocalVariableName(size_t Adr, size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((Adr >= PtrCU[i].PtrSubProgs[j].LowPC) && (Adr < PtrCU[i].PtrSubProgs[j].HighPC))\r
				{\r
					return PtrCU[i].PtrSubProgs[j].PtrVariables[Index - 1].PtrName;\r
				}\r
			}\r
		}\r
	}\r
\r
	return NULL;\r
}\r
\r
\r
// Get local variable's type tag based on his index (starting from 1)\r
// Return 0 if not found\r
size_t DWARFManager_GetLocalVariableTypeTag(size_t Adr, size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((Adr >= PtrCU[i].PtrSubProgs[j].LowPC) && (Adr < PtrCU[i].PtrSubProgs[j].HighPC))\r
				{\r
					return PtrCU[i].PtrSubProgs[j].PtrVariables[Index - 1].TypeTag;\r
				}\r
			}\r
		}\r
	}\r
\r
	return 0;\r
}\r
\r
\r
// Get the local variable's offset based on a index (starting from 1)\r
// Return 0 if no offset has been found\r
int DWARFManager_GetLocalVariableOffset(size_t Adr, size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((Adr >= PtrCU[i].PtrSubProgs[j].LowPC) && (Adr < PtrCU[i].PtrSubProgs[j].HighPC))\r
				{\r
					return PtrCU[i].PtrSubProgs[j].PtrVariables[Index - 1].Offset;\r
				}\r
			}\r
		}\r
	}\r
\r
	return 0;\r
}\r
\r
\r
// Get local variable Type Byte Size based on his address and index (starting from 1)\r
// Return 0 if not found\r
// May return 0 if there is no Type Byte Size linked to the variable's address and index\r
size_t DWARFManager_GetLocalVariableTypeByteSize(size_t Adr, size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((Adr >= PtrCU[i].PtrSubProgs[j].LowPC) && (Adr < PtrCU[i].PtrSubProgs[j].HighPC))\r
				{\r
					return PtrCU[i].PtrSubProgs[j].PtrVariables[Index - 1].TypeByteSize;\r
				}\r
			}\r
		}\r
	}\r
\r
	return 0;\r
}\r
\r
\r
// Get local variable Type Encoding based on his address and index (starting from 1)\r
// Return 0 if not found\r
// May return 0 if there is no Type Encoding linked to the variable's address and index\r
size_t DWARFManager_GetLocalVariableTypeEncoding(size_t Adr, size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((Adr >= PtrCU[i].PtrSubProgs[j].LowPC) && (Adr < PtrCU[i].PtrSubProgs[j].HighPC))\r
				{\r
					return PtrCU[i].PtrSubProgs[j].PtrVariables[Index - 1].TypeEncoding;\r
				}\r
			}\r
		}\r
	}\r
\r
	return 0;\r
}\r
\r
\r
// Get local variable Op based on his address and index (starting from 1)\r
// Return 0 if not found, may return 0 if there isn't Op linked to the variable's index\r
size_t DWARFManager_GetLocalVariableOp(size_t Adr, size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((Adr >= PtrCU[i].PtrSubProgs[j].LowPC) && (Adr < PtrCU[i].PtrSubProgs[j].HighPC))\r
				{\r
					return PtrCU[i].PtrSubProgs[j].PtrVariables[Index - 1].Op;\r
				}\r
			}\r
		}\r
	}\r
\r
	return 0;\r
}\r
\r
\r
// Get local variable type name based on his index (starting from 1) and an address\r
// Return NULL if not found, may also return NULL if there is no type linked to the variable's index\r
char *DWARFManager_GetLocalVariableTypeName(size_t Adr, size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((Adr >= PtrCU[i].PtrSubProgs[j].LowPC) && (Adr < PtrCU[i].PtrSubProgs[j].HighPC))\r
				{\r
					return PtrCU[i].PtrSubProgs[j].PtrVariables[Index - 1].PtrTypeName;\r
				}\r
			}\r
		}\r
	}\r
\r
	return NULL;\r
}\r
\r
\r
// Get Compilation Unit / global variables numbers\r
// Return number of variables\r
size_t DWARFManager_GetNbGlobalVariables(void)\r
{\r
	size_t NbVariables = 0;\r
\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		NbVariables += PtrCU[i].NbVariables;\r
	}\r
\r
	return NbVariables;\r
}\r
\r
\r
// Get global variable type name based on his index (starting from 1)\r
// Return NULL if not found\r
// May return NULL if there is not type linked to the variable's index\r
char *DWARFManager_GetGlobalVariableTypeName(size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if (PtrCU[i].NbVariables)\r
		{\r
			if (Index <= PtrCU[i].NbVariables)\r
			{\r
				return PtrCU[i].PtrVariables[Index - 1].PtrTypeName;\r
			}\r
			else\r
			{\r
				Index -= PtrCU[i].NbVariables;\r
			}\r
		}\r
	}\r
\r
	return NULL;\r
}\r
\r
\r
// Get global variable's type tag based on his index (starting from 1)\r
// Return 0 if not found\r
size_t DWARFManager_GetGlobalVariableTypeTag(size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if (PtrCU[i].NbVariables)\r
		{\r
			if (Index <= PtrCU[i].NbVariables)\r
			{\r
				return PtrCU[i].PtrVariables[Index - 1].TypeTag;\r
			}\r
			else\r
			{\r
				Index -= PtrCU[i].NbVariables;\r
			}\r
		}\r
	}\r
\r
	return 0;\r
}\r
\r
\r
// Get global variable byte size based on his index (starting from 1)\r
// Return 0 if not found\r
size_t DWARFManager_GetGlobalVariableTypeByteSize(size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if (PtrCU[i].NbVariables)\r
		{\r
			if (Index <= PtrCU[i].NbVariables)\r
			{\r
				return PtrCU[i].PtrVariables[Index - 1].TypeByteSize;\r
			}\r
			else\r
			{\r
				Index -= PtrCU[i].NbVariables;\r
			}\r
		}\r
	}\r
\r
	return 0;\r
}\r
\r
\r
// Get global variable encoding based on his index (starting from 1)\r
// Return 0 if not found\r
size_t DWARFManager_GetGlobalVariableTypeEncoding(size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if (PtrCU[i].NbVariables)\r
		{\r
			if (Index <= PtrCU[i].NbVariables)\r
			{\r
				return PtrCU[i].PtrVariables[Index - 1].TypeEncoding;\r
			}\r
			else\r
			{\r
				Index -= PtrCU[i].NbVariables;\r
			}\r
		}\r
	}\r
\r
	return 0;\r
}\r
\r
\r
// Get global variable memory address based on his index (starting from 1)\r
// Return 0 if not found\r
size_t DWARFManager_GetGlobalVariableAdr(size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if (PtrCU[i].NbVariables)\r
		{\r
			if (Index <= PtrCU[i].NbVariables)\r
			{\r
				return PtrCU[i].PtrVariables[Index - 1].Addr;\r
			}\r
			else\r
			{\r
				Index -= PtrCU[i].NbVariables;\r
			}\r
		}\r
	}\r
\r
	return 0;\r
}\r
\r
\r
// Get global variable memory address based on his name\r
// Return 0 if not found, or will return the first occurence found\r
size_t DWARFManager_GetGlobalVariableAdrFromName(char *VariableName)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if (PtrCU[i].NbVariables)\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbVariables; j++)\r
			{\r
				if (!strcmp(PtrCU[i].PtrVariables[j].PtrName,VariableName))\r
				{\r
					return PtrCU[i].PtrVariables[j].Addr;\r
				}\r
			}\r
		}\r
	}\r
\r
	return 0;\r
}\r
\r
\r
// Get global variable name based on his index (starting from 1)\r
// Return name's pointer text found, or will return NULL if no variable can be found\r
char *DWARFManager_GetGlobalVariableName(size_t Index)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if (PtrCU[i].NbVariables)\r
		{\r
			if (Index <= PtrCU[i].NbVariables)\r
			{\r
				return PtrCU[i].PtrVariables[Index - 1].PtrName;\r
			}\r
			else\r
			{\r
				Index -= PtrCU[i].NbVariables;\r
			}\r
		}\r
	}\r
\r
	return NULL;\r
}\r
\r
\r
// Get text line from source based on address and his tag\r
// A tag can be either 0 or a DW_TAG_subprogram\r
// DW_TAG_subprogram will look for the line pointing to the function\r
// Return NULL if no text line has been found\r
char *DWARFManager_GetLineSrcFromAdr(size_t Adr, size_t Tag)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((Adr >= PtrCU[i].PtrSubProgs[j].LowPC) && (Adr < PtrCU[i].PtrSubProgs[j].HighPC))\r
				{\r
					if ((PtrCU[i].PtrSubProgs[j].StartPC == Adr) && (!Tag || (Tag == DW_TAG_subprogram)))\r
					{\r
						return PtrCU[i].PtrSubProgs[j].PtrLineSrc;\r
					}\r
					else\r
					{\r
						for (size_t k = 0; k < PtrCU[i].PtrSubProgs[j].NbLinesSrc; k++)\r
						{\r
							if (PtrCU[i].PtrSubProgs[j].PtrLinesSrc[k].StartPC <= Adr)\r
							{\r
								if ((PtrCU[i].PtrSubProgs[j].PtrLinesSrc[k].StartPC == Adr) && (!Tag || (PtrCU[i].PtrSubProgs[j].PtrLinesSrc[k].Tag == Tag)))\r
								{\r
									return PtrCU[i].PtrSubProgs[j].PtrLinesSrc[k].PtrLineSrc;\r
								}\r
							}\r
							else\r
							{\r
								return PtrCU[i].PtrSubProgs[j].PtrLinesSrc[k - 1].PtrLineSrc;\r
							}\r
						}\r
					}\r
				}\r
			}\r
		}\r
	}\r
\r
	return	NULL;\r
}\r
\r
\r
// Get line number based on the address and a tag\r
// A tag can be either 0 or a DW_TAG_subprogram\r
// DW_TAG_subprogram will look for the line pointing to the function name as described in the source code\r
// Return 0 if no line number has been found\r
size_t DWARFManager_GetNumLineFromAdr(size_t Adr, size_t Tag)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((Adr >= PtrCU[i].PtrSubProgs[j].LowPC) && (Adr < PtrCU[i].PtrSubProgs[j].HighPC))\r
				{\r
					if ((PtrCU[i].PtrSubProgs[j].StartPC == Adr) && (!Tag || (Tag == DW_TAG_subprogram)))\r
					{\r
						return PtrCU[i].PtrSubProgs[j].NumLineSrc;\r
					}\r
					else\r
					{\r
						for (size_t k = 0; k < PtrCU[i].PtrSubProgs[j].NbLinesSrc; k++)\r
						{\r
							if ((PtrCU[i].PtrSubProgs[j].PtrLinesSrc[k].StartPC == Adr) && (!Tag || (PtrCU[i].PtrSubProgs[j].PtrLinesSrc[k].Tag == Tag)))\r
							{\r
								return PtrCU[i].PtrSubProgs[j].PtrLinesSrc[k].NumLineSrc;\r
							}\r
						}\r
					}\r
#if 0\r
					if (!Tag || (Tag == DW_TAG_subprogram))\r
					{\r
						return PtrCU[i].PtrSubProgs[j].NumLineSrc;\r
					}\r
#endif\r
				}\r
			}\r
\r
			// Check if a used line is found with the address\r
			for (size_t j = 0; j < PtrCU[i].NbLinesSrc; j++)\r
			{\r
				if (PtrCU[i].PtrLinesSrc[j].StartPC == Adr)\r
				{\r
					return PtrCU[i].PtrLinesSrc[j].NumLineSrc;\r
				}\r
			}\r
		}\r
	}\r
\r
	return	0;\r
}\r
\r
\r
// Get function name based on an address\r
// Return NULL if no function name has been found, otherwise will return the function name in the range of the provided address\r
char *DWARFManager_GetFunctionName(size_t Adr)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((Adr >= PtrCU[i].PtrSubProgs[j].LowPC) && (Adr < PtrCU[i].PtrSubProgs[j].HighPC))\r
				{\r
					return PtrCU[i].PtrSubProgs[j].PtrSubprogramName;\r
				}\r
			}\r
		}\r
	}\r
\r
	return NULL;\r
}\r
\r
\r
// Get text line from source based on address and num line (starting from 1)\r
// Return NULL if no text line has been found\r
char *DWARFManager_GetLineSrcFromAdrNumLine(size_t Adr, size_t NumLine)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			for (size_t j = 0; j < PtrCU[i].NbSubProgs; j++)\r
			{\r
				if ((Adr >= PtrCU[i].PtrSubProgs[j].LowPC) && (Adr < PtrCU[i].PtrSubProgs[j].HighPC))\r
				{\r
					if (PtrCU[i].PtrSubProgs[j].NumLineSrc == NumLine)\r
					{\r
						return PtrCU[i].PtrSubProgs[j].PtrLineSrc;\r
					}\r
					else\r
					{\r
						for (size_t k = 0; k < PtrCU[i].PtrSubProgs[j].NbLinesSrc; k++)\r
						{\r
							if (PtrCU[i].PtrSubProgs[j].PtrLinesSrc[k].NumLineSrc == NumLine)\r
							{\r
								return PtrCU[i].PtrSubProgs[j].PtrLinesSrc[k].PtrLineSrc;\r
							}\r
						}\r
					}\r
				}\r
			}\r
		}\r
	}\r
\r
	return NULL;\r
}\r
\r
\r
// Get text line pointer from source, based on address and line number (starting from 1)\r
// Return NULL if no text line has been found, or if requested number line is above the source total number of lines\r
char *DWARFManager_GetLineSrcFromNumLineBaseAdr(size_t Adr, size_t NumLine)\r
{\r
	for (size_t i = 0; i < NbCU; i++)\r
	{\r
		if ((Adr >= PtrCU[i].LowPC) && (Adr < PtrCU[i].HighPC))\r
		{\r
			if (NumLine <= PtrCU[i].NbLinesLoadSrc)\r
			{\r
				return PtrCU[i].PtrLinesLoadSrc[NumLine - 1];\r
			}\r
			else\r
			{\r
				return NULL;\r
			}\r
		}\r
	}\r
\r
	return NULL;\r
}\r
\r
\r
// Get number of source code filenames\r
size_t DWARFManager_GetNbFullSourceFilename(void)\r
{\r
	return NbCU;\r
}\r
\r
\r
// Get source code filename based on index (starting from 0)\r
char *DWARFManager_GetNumFullSourceFilename(size_t Index)\r
{\r
	return (PtrCU[Index].PtrFullFilename);\r
}\r
\r