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

//\r
// DBGManager.cpp: Debugger information 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  12/21/2016  Created this file\r
// JPM              Various efforts to set the ELF format support\r
// JPM              Various efforts to set the DWARF format support\r
// JPM  09/15/2018  Support the unsigned char\r
// JPM   Oct./2018  Cosmetic changes, added source file search paths, and ELF function name\r
// JPM  Sept./2019  Support the unsigned/signed short type\r
//\r
\r
// To Do\r
// To think about unique format to handle variations from ELF, DWARF, etc.\r
//\r
\r
\r
#include <stdlib.h>\r
#include <string.h>\r
#include <stdint.h>\r
#include "libelf/libelf.h"\r
#include "libelf/gelf.h"\r
#include "log.h"\r
#include "ELFManager.h"\r
#include "DwarfManager.h"\r
#include "DBGManager.h"\r
#include "HWLABELManager.h"\r
#include "settings.h"\r
#include "memory.h"\r
\r
\r
//\r
struct Value\r
{\r
	union\r
	{\r
		char Ct[10];\r
		char C;\r
		bool B;\r
		double D;\r
		float F;\r
		int16_t SS;\r
		int32_t SI;\r
		int64_t SL;\r
		uint16_t US;\r
		uint32_t UI;\r
		uint64_t UL;\r
	};\r
}S_Value;\r
\r
\r
//\r
void DBGManager_SourceFileSearchPathsInit(void);\r
void DBGManager_SourceFileSearchPathsReset(void);\r
void DBGManager_SourceFileSearchPathsClose(void);\r
\r
\r
// Common debugger variables\r
size_t	DBGType;\r
char value[1000];\r
size_t NbSFSearchPaths;\r
char **SourceFileSearchPaths;\r
\r
\r
// Init the source file search paths\r
void DBGManager_SourceFileSearchPathsInit(void)\r
{\r
	NbSFSearchPaths = 0;\r
	SourceFileSearchPaths = NULL;\r
}\r
\r
\r
// Set the source file search paths\r
// Create individual path for each one provided in the list (separate with ';')\r
void DBGManager_SourceFileSearchPathsSet(char *ListPaths)\r
{\r
	// Check presence of a previous list\r
	if (NbSFSearchPaths)\r
	{\r
		// Reset previous list\r
		DBGManager_SourceFileSearchPathsReset();\r
	}\r
\r
	// Check if there is a paths list\r
	if (strlen(ListPaths))\r
	{\r
		// Get number of paths\r
		char *Ptr = ListPaths;\r
		while(*Ptr)\r
		{\r
			while (*Ptr && (*Ptr++ != ';'));\r
			{\r
				NbSFSearchPaths++;\r
			}\r
		}\r
\r
		// Isolate each search path\r
		SourceFileSearchPaths = (char **)calloc(NbSFSearchPaths, sizeof(char *));\r
		size_t i = 0;\r
		Ptr = ListPaths;\r
\r
		while (*Ptr)\r
		{\r
			// Search the path separator (';')\r
			char *Ptr1 = Ptr;\r
			while (*Ptr && (*Ptr++ != ';'));\r
\r
			// Copy the inidividual search path\r
			SourceFileSearchPaths[i] = (char *)calloc(1, (Ptr - Ptr1) + 1);\r
			strncpy(SourceFileSearchPaths[i], Ptr1, (Ptr - Ptr1));\r
			if (SourceFileSearchPaths[i][strlen(SourceFileSearchPaths[i]) - 1] == ';')\r
			{\r
				SourceFileSearchPaths[i][strlen(SourceFileSearchPaths[i]) - 1] = 0;\r
			}\r
			i++;\r
		}\r
	}\r
\r
	DWARFManager_Set(NbSFSearchPaths, SourceFileSearchPaths);\r
}\r
\r
\r
// Reset the source file search paths\r
void DBGManager_SourceFileSearchPathsReset(void)\r
{\r
	// Free each path\r
	while (NbSFSearchPaths)\r
	{\r
		free(SourceFileSearchPaths[--NbSFSearchPaths]);\r
	}\r
\r
	// Free the pointers list\r
	free(SourceFileSearchPaths);\r
	SourceFileSearchPaths = NULL;\r
}\r
\r
\r
// Close the source file search paths\r
void DBGManager_SourceFileSearchPathsClose(void)\r
{\r
	DBGManager_SourceFileSearchPathsReset();\r
}\r
\r
\r
// Common debugger initialisation\r
void DBGManager_Init(void)\r
{\r
	// DBG initialisations\r
	DBGType = DBG_NO_TYPE;\r
	DBGManager_SourceFileSearchPathsInit();\r
\r
	// ELF initialisation \r
	ELFManager_Init();\r
	// DWARF initialisation\r
	DWARFManager_Init();\r
}\r
\r
\r
// Common debugger reset\r
void DBGManager_Reset(void)\r
{\r
	if ((DBGType & DBG_DWARF))\r
	{\r
		DWARFManager_Reset();\r
	}\r
\r
	if ((DBGType & DBG_ELF))\r
	{\r
		ELFManager_Reset();\r
	}\r
\r
	//DBGType = vjs.displayHWlabels ? DBG_HWLABEL : DBG_NO_TYPE;\r
	DBGType = DBG_NO_TYPE;\r
}\r
\r
\r
// Common debugger close\r
void DBGManager_Close(void)\r
{\r
	if ((DBGType & DBG_DWARF))\r
	{\r
		DWARFManager_Close();\r
	}\r
\r
	if ((DBGType & DBG_ELF))\r
	{\r
		ELFManager_Close();\r
	}\r
\r
	DBGManager_SourceFileSearchPathsClose();\r
	DBGType = DBG_NO_TYPE;\r
}\r
\r
\r
// Common debugger set\r
void DBGManager_SetType(size_t DBGTypeSet)\r
{\r
	DBGType |= DBGTypeSet;\r
}\r
\r
\r
// Get debugger type\r
size_t DBGManager_GetType(void)\r
{\r
	return DBGType;\r
}\r
\r
\r
// Get source filename based on the memeory address\r
// return NULL if no source filename\r
char *DBGManager_GetFullSourceFilenameFromAdr(size_t Adr, bool *Error)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetFullSourceFilenameFromAdr(Adr, Error);\r
	}\r
	else\r
	{\r
		return	NULL;\r
	}\r
}\r
\r
\r
// Get number of local variables\r
// Return 0 if none has been found\r
size_t DBGManager_GetNbLocalVariables(size_t Adr)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetNbLocalVariables(Adr);\r
	}\r
	else\r
	{\r
		return	0;\r
	}\r
}\r
\r
\r
// Get number of global variables\r
// Return 0 if none has been found\r
size_t DBGManager_GetNbGlobalVariables(void)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetNbGlobalVariables();\r
	}\r
	else\r
	{\r
		return	0;\r
	}\r
}\r
\r
\r
// Get address from symbol name\r
// Return found address\r
// Return NULL if no symbol has been found\r
size_t DBGManager_GetAdrFromSymbolName(char *SymbolName)\r
{\r
	if (SymbolName)\r
	{\r
		if ((DBGType & DBG_ELF))\r
		{\r
			return ELFManager_GetAdrFromSymbolName(SymbolName);\r
		}\r
	}\r
\r
	return 0;\r
}\r
\r
\r
// Get global variable's Address based on his Name\r
// Return found Address\r
// Return NULL if no Address has been found\r
size_t DBGManager_GetGlobalVariableAdrFromName(char *VariableName)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetGlobalVariableAdrFromName(VariableName);\r
	}\r
	else\r
	{\r
		return 0;\r
	}\r
}\r
\r
\r
// Get local variable's type encoding based on his address and Index\r
// Return the type encoding found\r
// Return 0 if no type encoding has been found\r
size_t DBGManager_GetLocalVariableTypeEncoding(size_t Adr, size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetLocalVariableTypeEncoding(Adr, Index);\r
	}\r
	else\r
	{\r
		return	0;\r
	}\r
}\r
\r
\r
//\r
int DBGManager_GetLocalVariableOffset(size_t Adr, size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetLocalVariableOffset(Adr, Index);\r
	}\r
	else\r
	{\r
		return	0;\r
	}\r
}\r
\r
\r
// Get local variable's type byte size based on his address and Index\r
// Return the type's byte size found\r
// Return 0 if no type's byte size has been found\r
size_t DBGManager_GetLocalVariableTypeByteSize(size_t Adr, size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetLocalVariableTypeByteSize(Adr, Index);\r
	}\r
	else\r
	{\r
		return	0;\r
	}\r
}\r
\r
\r
//\r
size_t DBGManager_GetLocalVariableTypeTag(size_t Adr, size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetLocalVariableTypeTag(Adr, Index);\r
	}\r
	else\r
	{\r
		return	0;\r
	}\r
}\r
\r
\r
//\r
size_t DBGManager_GetGlobalVariableTypeTag(size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetGlobalVariableTypeTag(Index);\r
	}\r
	else\r
	{\r
		return	0;\r
	}\r
}\r
\r
\r
// Get global variable's type name based on his Index\r
// Return type name's text pointer found\r
// Return NULL if no type name has been found\r
char *DBGManager_GetGlobalVariableTypeName(size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetGlobalVariableTypeName(Index);\r
	}\r
	else\r
	{\r
		return	NULL;\r
	}\r
}\r
\r
\r
// Get global variable's Address based on his Index\r
// Return the Address found\r
// Return 0 if no Address has been found\r
size_t DBGManager_GetGlobalVariableAdr(size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetGlobalVariableAdr(Index);\r
	}\r
	else\r
	{\r
		return	0;\r
	}\r
}\r
\r
\r
// Get global variable's type byte size based on his Index\r
// Return the type's byte size found\r
// Return 0 if no type's byte size has been found\r
size_t DBGManager_GetGlobalVariableTypeByteSize(size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetGlobalVariableTypeByteSize(Index);\r
	}\r
	else\r
	{\r
		return	0;\r
	}\r
}\r
\r
\r
// Get global variable's type encoding based on his Index\r
// Return the type encoding found\r
// Return 0 if no type encoding has been found\r
size_t DBGManager_GetGlobalVariableTypeEncoding(size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetGlobalVariableTypeEncoding(Index);\r
	}\r
	else\r
	{\r
		return	0;\r
	}\r
}\r
\r
\r
// Get global variable value based on his Index\r
// Return value as a text pointer\r
// Note: Pointer may point on a 0 lenght text\r
char *DBGManager_GetGlobalVariableValue(size_t Index)\r
{\r
	size_t Adr = 0;\r
	size_t TypeEncoding = DBG_NO_TYPEENCODING;\r
	size_t TypeByteSize = 0;\r
\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		Adr = DWARFManager_GetGlobalVariableAdr(Index);\r
		TypeEncoding = DWARFManager_GetGlobalVariableTypeEncoding(Index);\r
		TypeByteSize = DWARFManager_GetGlobalVariableTypeByteSize(Index);\r
	}\r
\r
	return DBGManager_GetVariableValueFromAdr(Adr, TypeEncoding, TypeByteSize);\r
}\r
\r
\r
// Get variable value based on his Adresse, Encoding Type and Size\r
// Return value as a text pointer\r
// Note: Pointer may point on a 0 length text\r
char *DBGManager_GetVariableValueFromAdr(size_t Adr, size_t TypeEncoding, size_t TypeByteSize)\r
{\r
	Value V;\r
	char *Ptrvalue = value;\r
\r
	value[0] = 0;\r
\r
#if 0\r
	if (Adr)\r
#endif\r
	{\r
		memset(&V, 0, sizeof(Value));\r
#if 0\r
		for (uint32_t i = 0; i < TypeByteSize; i++)\r
			jaguarMainRAM[Adr + i] = 0;\r
			//jaguarMainRAM[Adr + i] = rand();\r
		jaguarMainRAM[Adr + TypeByteSize - 1] = 0x10;\r
#else\r
		for (size_t i = 0, j = TypeByteSize; i < TypeByteSize; i++, j--)\r
		{\r
			V.Ct[i] = jaguarMainRAM[Adr + j - 1];\r
		}\r
#endif\r
		switch (TypeEncoding)\r
		{\r
		case DBG_ATE_address:\r
			break;\r
\r
		case DBG_ATE_boolean:\r
			sprintf(value, "%s", V.B ? "true" : "false");\r
			break;\r
\r
		case DBG_ATE_complex_float:\r
			break;\r
\r
		case DBG_ATE_float:\r
			switch (TypeByteSize)\r
			{\r
			case 4:\r
				sprintf(value, "%F", V.F);\r
				break;\r
\r
			case 8:\r
				//V.D = (double)jaguarMainRAM[Adr];\r
				//sprintf(value, "%10.10F", V.D);\r
				sprintf(value, "%F", V.D);\r
				break;\r
\r
			default:\r
				break;\r
			}\r
			break;\r
\r
		case DBG_ATE_signed:\r
			switch (TypeByteSize)\r
			{\r
			case 2:\r
				sprintf(value, "%i", V.SS);\r
				break;\r
\r
			case 4:\r
				sprintf(value, "%i", V.SI);\r
				break;\r
\r
			case 8:\r
				sprintf(value, "%i", V.SL);\r
				break;\r
\r
			default:\r
				break;\r
			}\r
			break;\r
\r
		case DBG_ATE_signed_char:\r
			break;\r
\r
		case DBG_ATE_unsigned:\r
			switch (TypeByteSize)\r
			{\r
			case 2:\r
				sprintf(value, "%u", V.US);\r
				break;\r
\r
			case 4:\r
				sprintf(value, "%u", V.UI);\r
				break;\r
\r
			case 8:\r
				sprintf(value, "%u", V.UL);\r
				break;\r
\r
			default:\r
				break;\r
			}\r
			break;\r
\r
		case DBG_ATE_unsigned_char:\r
			sprintf(value, "%u", (unsigned int(V.C)));\r
			break;\r
\r
		case DBG_ATE_ptr:\r
			switch (TypeByteSize)\r
			{\r
			case 4:\r
				sprintf(value, "0x%06x", V.UI);\r
				break;\r
\r
			default:\r
				break;\r
			}\r
\r
		default:\r
			break;\r
		}\r
	}\r
\r
	return Ptrvalue;\r
}\r
\r
\r
// Get local variable's type name based on his Index\r
// Return type name's text pointer found\r
// Return NULL if no type name has been found\r
char *DBGManager_GetLocalVariableTypeName(size_t Adr, size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetLocalVariableTypeName(Adr, Index);\r
	}\r
	else\r
	{\r
		return	NULL;\r
	}\r
}\r
\r
\r
// Get local variable Op based on his Index\r
// Return variable Op's found\r
// Return 0 if no variable Op has been found\r
size_t DBGManager_GetLocalVariableOp(size_t Adr, size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetLocalVariableOp(Adr, Index);\r
	}\r
	else\r
	{\r
		return	0;\r
	}\r
}\r
\r
\r
// Get local variable name based on his Index\r
// Return variable name's text pointer found\r
// Return NULL if no variable name has been found\r
char *DBGManager_GetLocalVariableName(size_t Adr, size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetLocalVariableName(Adr, Index);\r
	}\r
	else\r
	{\r
		return	NULL;\r
	}\r
}\r
\r
\r
// Get global variable name based on his Index\r
// Return variable name's text pointer found\r
// Return NULL if no variable name has been found\r
char *DBGManager_GetGlobalVariableName(size_t Index)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetGlobalVariableName(Index);\r
	}\r
	else\r
	{\r
		return	NULL;\r
	}\r
}\r
\r
\r
// Get function name from address\r
// Return function name found\r
// Return NULL if no function name has been found\r
char *DBGManager_GetFunctionName(size_t Adr)\r
{\r
	char *Symbolname = NULL;\r
\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		Symbolname = DWARFManager_GetFunctionName(Adr);\r
	}\r
\r
	if ((DBGType & DBG_ELF) && (Symbolname == NULL))\r
	{\r
		Symbolname = ELFManager_GetFunctionName(Adr);\r
	}\r
\r
	return	Symbolname;\r
}\r
\r
\r
// Get line number from address and his tag\r
// Return line number on the symbol name found\r
// Return 0 if no symbol name has been found\r
size_t DBGManager_GetNumLineFromAdr(size_t Adr, size_t Tag)\r
{\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		return DWARFManager_GetNumLineFromAdr(Adr, Tag);\r
	}\r
	else\r
	{\r
		return	0;\r
	}\r
}\r
\r
\r
// Get symbol name from address\r
// Return text pointer on the symbol name found\r
// Return NULL if no symbol name has been found\r
char *DBGManager_GetSymbolNameFromAdr(size_t Adr)\r
{\r
	char *Symbolname;\r
\r
	//if ((DBGType & DBG_HWLABEL) || vjs.displayHWlabels)\r
	if (vjs.displayHWlabels)\r
	{\r
		Symbolname = HWLABELManager_GetSymbolnameFromAdr(Adr);\r
	}\r
	else\r
	{\r
		Symbolname = NULL;\r
	}\r
#ifdef _MSC_VER\r
#pragma message("Warning: !!! Need to set the DBG_HWLABEL in DBGType instead to use the setting value !!!")\r
#else\r
	#warning "!!! Need to set the DBG_HWLABEL in DBGType instead to use the setting value !!!"\r
#endif // _MSC_VER\r
\r
	if (Symbolname == NULL)\r
	{\r
		if ((DBGType & DBG_ELFDWARF))\r
		{\r
			Symbolname = DWARFManager_GetSymbolnameFromAdr(Adr);\r
		}\r
\r
		if ((DBGType & DBG_ELF) && (Symbolname == NULL))\r
		{\r
			Symbolname = ELFManager_GetSymbolnameFromAdr(Adr);\r
		}\r
	}\r
\r
	return	Symbolname;\r
}\r
\r
\r
// Get source line based on the Address and his Tag\r
// Return text pointer on the source line found\r
// Return NULL if no source line has been found\r
char *DBGManager_GetLineSrcFromAdr(size_t Adr, size_t Tag)\r
{\r
	char *TextLine = NULL;\r
\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		TextLine = DWARFManager_GetLineSrcFromAdr(Adr, Tag);\r
	}\r
\r
	return	TextLine;\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 *DBGManager_GetLineSrcFromAdrNumLine(size_t Adr, size_t NumLine)\r
{\r
	char *TextLine = NULL;\r
\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		TextLine = DWARFManager_GetLineSrcFromAdrNumLine(Adr, NumLine);\r
	}\r
\r
	return	TextLine;\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 *DBGManager_GetLineSrcFromNumLineBaseAdr(size_t Adr, size_t NumLine)\r
{\r
	char *TextLine = NULL;\r
\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		TextLine = DWARFManager_GetLineSrcFromNumLineBaseAdr(Adr, NumLine);\r
	}\r
\r
	return	TextLine;\r
}\r
\r
\r
// Get number of source code filenames\r
size_t DBGManager_GetNbFullSourceFilename(void)\r
{\r
	size_t Nbr = 0;\r
\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		Nbr = DWARFManager_GetNbFullSourceFilename();\r
	}\r
\r
	return Nbr;\r
}\r
\r
\r
// Get source code filename based on index\r
char *DBGManager_GetNumFullSourceFilename(size_t Index)\r
{\r
	char *FullSourceFilename = NULL;\r
\r
	if ((DBGType & DBG_ELFDWARF))\r
	{\r
		FullSourceFilename = DWARFManager_GetNumFullSourceFilename(Index);\r
	}\r
\r
	return	FullSourceFilename;\r
}\r
Commit	Line	Data
2d0121d4 JPM	1	//\r
	2	// DBGManager.cpp: Debugger information manager\r
	3	//\r
	4	// by Jean-Paul Mari\r
	5	//\r
	6	// JPM = Jean-Paul Mari <djipi.mari@gmail.com>\r
	7	//\r
	8	// WHO WHEN WHAT\r
	9	// --- ---------- ------------------------------------------------------------\r
	10	// JPM 12/21/2016 Created this file\r
	11	// JPM Various efforts to set the ELF format support\r
	12	// JPM Various efforts to set the DWARF format support\r
fe3b257d	13	// JPM 09/15/2018 Support the unsigned char\r
4f945aea	14	// JPM Oct./2018 Cosmetic changes, added source file search paths, and ELF function name\r
ef0da6de	15	// JPM Sept./2019 Support the unsigned/signed short type\r
fe3b257d	16	//\r
f8dde18d JPM	17	\r
f8dde18d JPM	18	// To Do\r
4f945aea	19	// To think about unique format to handle variations from ELF, DWARF, etc.\r
f8dde18d JPM	20	//\r
f8dde18d JPM	21	\r
2d0121d4 JPM	22	\r
	23	#include <stdlib.h>\r
	24	#include <string.h>\r
	25	#include <stdint.h>\r
	26	#include "libelf/libelf.h"\r
	27	#include "libelf/gelf.h"\r
	28	#include "log.h"\r
	29	#include "ELFManager.h"\r
	30	#include "DwarfManager.h"\r
	31	#include "DBGManager.h"\r
	32	#include "HWLABELManager.h"\r
	33	#include "settings.h"\r
	34	#include "memory.h"\r
	35	\r
	36	\r
2d0121d4 JPM	37	//\r
	38	struct Value\r
	39	{\r
	40	union\r
	41	{\r
f8dde18d JPM	42	char Ct[10];\r
	43	char C;\r
	44	bool B;\r
2d0121d4 JPM	45	double D;\r
2d0121d4 JPM	46	float F;\r
ef0da6de	47	int16_t SS;\r
2d0121d4 JPM	48	int32_t SI;\r
2d0121d4 JPM	49	int64_t SL;\r
ef0da6de	50	uint16_t US;\r
2d0121d4 JPM	51	uint32_t UI;\r
	52	uint64_t UL;\r
	53	};\r
	54	}S_Value;\r
	55	\r
	56	\r
f0dd2f7b JPM	57	//\r
	58	void DBGManager_SourceFileSearchPathsInit(void);\r
	59	void DBGManager_SourceFileSearchPathsReset(void);\r
	60	void DBGManager_SourceFileSearchPathsClose(void);\r
	61	\r
	62	\r
2d0121d4 JPM	63	// Common debugger variables\r
	64	size_t DBGType;\r
	65	char value[1000];\r
f0dd2f7b JPM	66	size_t NbSFSearchPaths;\r
	67	char **SourceFileSearchPaths;\r
	68	\r
	69	\r
	70	// Init the source file search paths\r
	71	void DBGManager_SourceFileSearchPathsInit(void)\r
	72	{\r
	73	NbSFSearchPaths = 0;\r
	74	SourceFileSearchPaths = NULL;\r
	75	}\r
	76	\r
	77	\r
	78	// Set the source file search paths\r
	79	// Create individual path for each one provided in the list (separate with ';')\r
	80	void DBGManager_SourceFileSearchPathsSet(char *ListPaths)\r
	81	{\r
	82	// Check presence of a previous list\r
	83	if (NbSFSearchPaths)\r
	84	{\r
	85	// Reset previous list\r
	86	DBGManager_SourceFileSearchPathsReset();\r
	87	}\r
	88	\r
	89	// Check if there is a paths list\r
	90	if (strlen(ListPaths))\r
	91	{\r
	92	// Get number of paths\r
	93	char *Ptr = ListPaths;\r
	94	while(*Ptr)\r
	95	{\r
	96	while (Ptr && (Ptr++ != ';'));\r
	97	{\r
	98	NbSFSearchPaths++;\r
	99	}\r
	100	}\r
	101	\r
	102	// Isolate each search path\r
	103	SourceFileSearchPaths = (char *)calloc(NbSFSearchPaths, sizeof(char ));\r
	104	size_t i = 0;\r
	105	Ptr = ListPaths;\r
	106	\r
	107	while (*Ptr)\r
	108	{\r
	109	// Search the path separator (';')\r
	110	char *Ptr1 = Ptr;\r
	111	while (Ptr && (Ptr++ != ';'));\r
	112	\r
	113	// Copy the inidividual search path\r
	114	SourceFileSearchPaths[i] = (char *)calloc(1, (Ptr - Ptr1) + 1);\r
	115	strncpy(SourceFileSearchPaths[i], Ptr1, (Ptr - Ptr1));\r
	116	if (SourceFileSearchPaths[i][strlen(SourceFileSearchPaths[i]) - 1] == ';')\r
	117	{\r
	118	SourceFileSearchPaths[i][strlen(SourceFileSearchPaths[i]) - 1] = 0;\r
	119	}\r
	120	i++;\r
	121	}\r
	122	}\r
	123	\r
	124	DWARFManager_Set(NbSFSearchPaths, SourceFileSearchPaths);\r
	125	}\r
	126	\r
	127	\r
	128	// Reset the source file search paths\r
	129	void DBGManager_SourceFileSearchPathsReset(void)\r
130	{\r
131	// Free each path\r
132	while (NbSFSearchPaths)\r
133	{\r
134	free(SourceFileSearchPaths[--NbSFSearchPaths]);\r
135	}\r
136	\r
137	// Free the pointers list\r
138	free(SourceFileSearchPaths);\r
139	SourceFileSearchPaths = NULL;\r
140	}\r
141	\r
142	\r
143	// Close the source file search paths\r
144	void DBGManager_SourceFileSearchPathsClose(void)\r
145	{\r
146	DBGManager_SourceFileSearchPathsReset();\r
147	}\r
2d0121d4 JPM	148	\r
	149	\r
	150	// Common debugger initialisation\r
	151	void DBGManager_Init(void)\r
	152	{\r
f0dd2f7b	153	// DBG initialisations\r
2d0121d4	154	DBGType = DBG_NO_TYPE;\r
f0dd2f7b JPM	155	DBGManager_SourceFileSearchPathsInit();\r
	156	\r
	157	// ELF initialisation \r
2d0121d4	158	ELFManager_Init();\r
f0dd2f7b	159	// DWARF initialisation\r
2d0121d4 JPM	160	DWARFManager_Init();\r
	161	}\r
	162	\r
	163	\r
	164	// Common debugger reset\r
	165	void DBGManager_Reset(void)\r
	166	{\r
	167	if ((DBGType & DBG_DWARF))\r
	168	{\r
	169	DWARFManager_Reset();\r
	170	}\r
	171	\r
	172	if ((DBGType & DBG_ELF))\r
	173	{\r
	174	ELFManager_Reset();\r
	175	}\r
	176	\r
	177	//DBGType = vjs.displayHWlabels ? DBG_HWLABEL : DBG_NO_TYPE;\r
	178	DBGType = DBG_NO_TYPE;\r
	179	}\r
	180	\r
	181	\r
2d0121d4 JPM	182	// Common debugger close\r
	183	void DBGManager_Close(void)\r
	184	{\r
	185	if ((DBGType & DBG_DWARF))\r
	186	{\r
	187	DWARFManager_Close();\r
	188	}\r
	189	\r
	190	if ((DBGType & DBG_ELF))\r
	191	{\r
	192	ELFManager_Close();\r
	193	}\r
f0dd2f7b JPM	194	\r
	195	DBGManager_SourceFileSearchPathsClose();\r
	196	DBGType = DBG_NO_TYPE;\r
	197	}\r
	198	\r
	199	\r
	200	// Common debugger set\r
	201	void DBGManager_SetType(size_t DBGTypeSet)\r
	202	{\r
	203	DBGType \|= DBGTypeSet;\r
	204	}\r
	205	\r
	206	\r
	207	// Get debugger type\r
	208	size_t DBGManager_GetType(void)\r
	209	{\r
	210	return DBGType;\r
2d0121d4 JPM	211	}\r
	212	\r
	213	\r
	214	// Get source filename based on the memeory address\r
	215	// return NULL if no source filename\r
	216	char DBGManager_GetFullSourceFilenameFromAdr(size_t Adr, bool Error)\r
	217	{\r
	218	if ((DBGType & DBG_ELFDWARF))\r
	219	{\r
	220	return DWARFManager_GetFullSourceFilenameFromAdr(Adr, Error);\r
	221	}\r
	222	else\r
	223	{\r
	224	return NULL;\r
	225	}\r
	226	}\r
	227	\r
	228	\r
0203b5fd JPM	229	// Get number of local variables\r
	230	// Return 0 if none has been found\r
	231	size_t DBGManager_GetNbLocalVariables(size_t Adr)\r
	232	{\r
	233	if ((DBGType & DBG_ELFDWARF))\r
	234	{\r
	235	return DWARFManager_GetNbLocalVariables(Adr);\r
	236	}\r
	237	else\r
	238	{\r
	239	return 0;\r
	240	}\r
	241	}\r
	242	\r
	243	\r
	244	// Get number of global variables\r
2d0121d4	245	// Return 0 if none has been found\r
0203b5fd	246	size_t DBGManager_GetNbGlobalVariables(void)\r
2d0121d4 JPM	247	{\r
	248	if ((DBGType & DBG_ELFDWARF))\r
	249	{\r
0203b5fd	250	return DWARFManager_GetNbGlobalVariables();\r
2d0121d4 JPM	251	}\r
	252	else\r
	253	{\r
	254	return 0;\r
	255	}\r
	256	}\r
	257	\r
	258	\r
a4e46c05 JPM	259	// Get address from symbol name\r
	260	// Return found address\r
	261	// Return NULL if no symbol has been found\r
2d0121d4 JPM	262	size_t DBGManager_GetAdrFromSymbolName(char *SymbolName)\r
2d0121d4 JPM	263	{\r
a4e46c05	264	if (SymbolName)\r
2d0121d4	265	{\r
a4e46c05 JPM	266	if ((DBGType & DBG_ELF))\r
	267	{\r
	268	return ELFManager_GetAdrFromSymbolName(SymbolName);\r
	269	}\r
2d0121d4	270	}\r
a4e46c05 JPM	271	\r
a4e46c05 JPM	272	return 0;\r
2d0121d4 JPM	273	}\r
	274	\r
	275	\r
0203b5fd	276	// Get global variable's Address based on his Name\r
2d0121d4 JPM	277	// Return found Address\r
2d0121d4 JPM	278	// Return NULL if no Address has been found\r
0203b5fd	279	size_t DBGManager_GetGlobalVariableAdrFromName(char *VariableName)\r
2d0121d4 JPM	280	{\r
	281	if ((DBGType & DBG_ELFDWARF))\r
	282	{\r
0203b5fd	283	return DWARFManager_GetGlobalVariableAdrFromName(VariableName);\r
2d0121d4 JPM	284	}\r
	285	else\r
	286	{\r
	287	return 0;\r
	288	}\r
	289	}\r
	290	\r
	291	\r
0203b5fd JPM	292	// Get local variable's type encoding based on his address and Index\r
	293	// Return the type encoding found\r
	294	// Return 0 if no type encoding has been found\r
	295	size_t DBGManager_GetLocalVariableTypeEncoding(size_t Adr, size_t Index)\r
	296	{\r
	297	if ((DBGType & DBG_ELFDWARF))\r
	298	{\r
	299	return DWARFManager_GetLocalVariableTypeEncoding(Adr, Index);\r
	300	}\r
	301	else\r
	302	{\r
	303	return 0;\r
	304	}\r
	305	}\r
	306	\r
	307	\r
	308	//\r
	309	int DBGManager_GetLocalVariableOffset(size_t Adr, size_t Index)\r
	310	{\r
	311	if ((DBGType & DBG_ELFDWARF))\r
	312	{\r
	313	return DWARFManager_GetLocalVariableOffset(Adr, Index);\r
	314	}\r
	315	else\r
	316	{\r
	317	return 0;\r
	318	}\r
	319	}\r
	320	\r
	321	\r
	322	// Get local variable's type byte size based on his address and Index\r
	323	// Return the type's byte size found\r
	324	// Return 0 if no type's byte size has been found\r
	325	size_t DBGManager_GetLocalVariableTypeByteSize(size_t Adr, size_t Index)\r
	326	{\r
	327	if ((DBGType & DBG_ELFDWARF))\r
	328	{\r
	329	return DWARFManager_GetLocalVariableTypeByteSize(Adr, Index);\r
	330	}\r
	331	else\r
	332	{\r
	333	return 0;\r
	334	}\r
	335	}\r
	336	\r
	337	\r
	338	//\r
	339	size_t DBGManager_GetLocalVariableTypeTag(size_t Adr, size_t Index)\r
	340	{\r
	341	if ((DBGType & DBG_ELFDWARF))\r
	342	{\r
	343	return DWARFManager_GetLocalVariableTypeTag(Adr, Index);\r
	344	}\r
	345	else\r
	346	{\r
	347	return 0;\r
	348	}\r
	349	}\r
	350	\r
	351	\r
2d0121d4	352	//\r
0203b5fd	353	size_t DBGManager_GetGlobalVariableTypeTag(size_t Index)\r
2d0121d4 JPM	354	{\r
	355	if ((DBGType & DBG_ELFDWARF))\r
	356	{\r
0203b5fd	357	return DWARFManager_GetGlobalVariableTypeTag(Index);\r
2d0121d4 JPM	358	}\r
	359	else\r
	360	{\r
	361	return 0;\r
	362	}\r
	363	}\r
	364	\r
	365	\r
0203b5fd	366	// Get global variable's type name based on his Index\r
2d0121d4 JPM	367	// Return type name's text pointer found\r
2d0121d4 JPM	368	// Return NULL if no type name has been found\r
0203b5fd	369	char *DBGManager_GetGlobalVariableTypeName(size_t Index)\r
2d0121d4 JPM	370	{\r
	371	if ((DBGType & DBG_ELFDWARF))\r
	372	{\r
0203b5fd	373	return DWARFManager_GetGlobalVariableTypeName(Index);\r
2d0121d4 JPM	374	}\r
	375	else\r
	376	{\r
	377	return NULL;\r
	378	}\r
	379	}\r
	380	\r
	381	\r
0203b5fd	382	// Get global variable's Address based on his Index\r
2d0121d4 JPM	383	// Return the Address found\r
2d0121d4 JPM	384	// Return 0 if no Address has been found\r
0203b5fd	385	size_t DBGManager_GetGlobalVariableAdr(size_t Index)\r
2d0121d4 JPM	386	{\r
	387	if ((DBGType & DBG_ELFDWARF))\r
	388	{\r
0203b5fd	389	return DWARFManager_GetGlobalVariableAdr(Index);\r
2d0121d4 JPM	390	}\r
	391	else\r
	392	{\r
	393	return 0;\r
	394	}\r
	395	}\r
	396	\r
	397	\r
0203b5fd	398	// Get global variable's type byte size based on his Index\r
2d0121d4 JPM	399	// Return the type's byte size found\r
2d0121d4 JPM	400	// Return 0 if no type's byte size has been found\r
0203b5fd	401	size_t DBGManager_GetGlobalVariableTypeByteSize(size_t Index)\r
2d0121d4 JPM	402	{\r
	403	if ((DBGType & DBG_ELFDWARF))\r
	404	{\r
0203b5fd	405	return DWARFManager_GetGlobalVariableTypeByteSize(Index);\r
2d0121d4 JPM	406	}\r
	407	else\r
	408	{\r
	409	return 0;\r
	410	}\r
	411	}\r
	412	\r
	413	\r
0203b5fd	414	// Get global variable's type encoding based on his Index\r
2d0121d4 JPM	415	// Return the type encoding found\r
2d0121d4 JPM	416	// Return 0 if no type encoding has been found\r
0203b5fd	417	size_t DBGManager_GetGlobalVariableTypeEncoding(size_t Index)\r
2d0121d4 JPM	418	{\r
	419	if ((DBGType & DBG_ELFDWARF))\r
	420	{\r
0203b5fd	421	return DWARFManager_GetGlobalVariableTypeEncoding(Index);\r
2d0121d4 JPM	422	}\r
	423	else\r
	424	{\r
	425	return 0;\r
	426	}\r
	427	}\r
	428	\r
	429	\r
0203b5fd	430	// Get global variable value based on his Index\r
2d0121d4 JPM	431	// Return value as a text pointer\r
2d0121d4 JPM	432	// Note: Pointer may point on a 0 lenght text\r
0203b5fd	433	char *DBGManager_GetGlobalVariableValue(size_t Index)\r
2d0121d4	434	{\r
0203b5fd JPM	435	size_t Adr = 0;\r
	436	size_t TypeEncoding = DBG_NO_TYPEENCODING;\r
	437	size_t TypeByteSize = 0;\r
2d0121d4 JPM	438	\r
	439	if ((DBGType & DBG_ELFDWARF))\r
	440	{\r
0203b5fd JPM	441	Adr = DWARFManager_GetGlobalVariableAdr(Index);\r
	442	TypeEncoding = DWARFManager_GetGlobalVariableTypeEncoding(Index);\r
	443	TypeByteSize = DWARFManager_GetGlobalVariableTypeByteSize(Index);\r
2d0121d4 JPM	444	}\r
	445	\r
	446	return DBGManager_GetVariableValueFromAdr(Adr, TypeEncoding, TypeByteSize);\r
	447	}\r
	448	\r
	449	\r
	450	// Get variable value based on his Adresse, Encoding Type and Size\r
	451	// Return value as a text pointer\r
f8dde18d	452	// Note: Pointer may point on a 0 length text\r
0203b5fd	453	char *DBGManager_GetVariableValueFromAdr(size_t Adr, size_t TypeEncoding, size_t TypeByteSize)\r
2d0121d4 JPM	454	{\r
	455	Value V;\r
	456	char *Ptrvalue = value;\r
	457	\r
	458	value[0] = 0;\r
	459	\r
f8dde18d	460	#if 0\r
2d0121d4	461	if (Adr)\r
f8dde18d	462	#endif\r
2d0121d4 JPM	463	{\r
	464	memset(&V, 0, sizeof(Value));\r
	465	#if 0\r
	466	for (uint32_t i = 0; i < TypeByteSize; i++)\r
	467	jaguarMainRAM[Adr + i] = 0;\r
	468	//jaguarMainRAM[Adr + i] = rand();\r
	469	jaguarMainRAM[Adr + TypeByteSize - 1] = 0x10;\r
f8dde18d	470	#else\r
0203b5fd	471	for (size_t i = 0, j = TypeByteSize; i < TypeByteSize; i++, j--)\r
2d0121d4	472	{\r
f8dde18d	473	V.Ct[i] = jaguarMainRAM[Adr + j - 1];\r
2d0121d4 JPM	474	}\r
2d0121d4 JPM	475	#endif\r
2d0121d4 JPM	476	switch (TypeEncoding)\r
	477	{\r
	478	case DBG_ATE_address:\r
	479	break;\r
	480	\r
	481	case DBG_ATE_boolean:\r
f8dde18d	482	sprintf(value, "%s", V.B ? "true" : "false");\r
2d0121d4 JPM	483	break;\r
	484	\r
	485	case DBG_ATE_complex_float:\r
	486	break;\r
	487	\r
	488	case DBG_ATE_float:\r
	489	switch (TypeByteSize)\r
	490	{\r
	491	case 4:\r
	492	sprintf(value, "%F", V.F);\r
	493	break;\r
	494	\r
	495	case 8:\r
	496	//V.D = (double)jaguarMainRAM[Adr];\r
	497	//sprintf(value, "%10.10F", V.D);\r
	498	sprintf(value, "%F", V.D);\r
	499	break;\r
	500	\r
	501	default:\r
	502	break;\r
	503	}\r
	504	break;\r
	505	\r
	506	case DBG_ATE_signed:\r
	507	switch (TypeByteSize)\r
	508	{\r
ef0da6de JPM	509	case 2:\r
	510	sprintf(value, "%i", V.SS);\r
	511	break;\r
	512	\r
2d0121d4 JPM	513	case 4:\r
	514	sprintf(value, "%i", V.SI);\r
	515	break;\r
	516	\r
	517	case 8:\r
	518	sprintf(value, "%i", V.SL);\r
	519	break;\r
	520	\r
	521	default:\r
	522	break;\r
	523	}\r
	524	break;\r
	525	\r
	526	case DBG_ATE_signed_char:\r
	527	break;\r
	528	\r
	529	case DBG_ATE_unsigned:\r
	530	switch (TypeByteSize)\r
	531	{\r
ef0da6de JPM	532	case 2:\r
	533	sprintf(value, "%u", V.US);\r
	534	break;\r
	535	\r
2d0121d4 JPM	536	case 4:\r
	537	sprintf(value, "%u", V.UI);\r
	538	break;\r
	539	\r
	540	case 8:\r
	541	sprintf(value, "%u", V.UL);\r
	542	break;\r
	543	\r
	544	default:\r
	545	break;\r
	546	}\r
	547	break;\r
	548	\r
	549	case DBG_ATE_unsigned_char:\r
f8dde18d	550	sprintf(value, "%u", (unsigned int(V.C)));\r
2d0121d4 JPM	551	break;\r
	552	\r
	553	case DBG_ATE_ptr:\r
	554	switch (TypeByteSize)\r
	555	{\r
	556	case 4:\r
	557	sprintf(value, "0x%06x", V.UI);\r
	558	break;\r
	559	\r
	560	default:\r
	561	break;\r
	562	}\r
	563	\r
	564	default:\r
	565	break;\r
	566	}\r
	567	}\r
	568	\r
	569	return Ptrvalue;\r
	570	}\r
	571	\r
	572	\r
0203b5fd JPM	573	// Get local variable's type name based on his Index\r
	574	// Return type name's text pointer found\r
	575	// Return NULL if no type name has been found\r
	576	char *DBGManager_GetLocalVariableTypeName(size_t Adr, size_t Index)\r
	577	{\r
	578	if ((DBGType & DBG_ELFDWARF))\r
	579	{\r
	580	return DWARFManager_GetLocalVariableTypeName(Adr, Index);\r
	581	}\r
	582	else\r
	583	{\r
	584	return NULL;\r
	585	}\r
	586	}\r
	587	\r
	588	\r
	589	// Get local variable Op based on his Index\r
	590	// Return variable Op's found\r
	591	// Return 0 if no variable Op has been found\r
	592	size_t DBGManager_GetLocalVariableOp(size_t Adr, size_t Index)\r
	593	{\r
	594	if ((DBGType & DBG_ELFDWARF))\r
	595	{\r
	596	return DWARFManager_GetLocalVariableOp(Adr, Index);\r
	597	}\r
	598	else\r
	599	{\r
	600	return 0;\r
	601	}\r
	602	}\r
	603	\r
	604	\r
	605	// Get local variable name based on his Index\r
	606	// Return variable name's text pointer found\r
	607	// Return NULL if no variable name has been found\r
	608	char *DBGManager_GetLocalVariableName(size_t Adr, size_t Index)\r
	609	{\r
	610	if ((DBGType & DBG_ELFDWARF))\r
	611	{\r
	612	return DWARFManager_GetLocalVariableName(Adr, Index);\r
	613	}\r
	614	else\r
	615	{\r
	616	return NULL;\r
	617	}\r
	618	}\r
	619	\r
	620	\r
	621	// Get global variable name based on his Index\r
2d0121d4 JPM	622	// Return variable name's text pointer found\r
2d0121d4 JPM	623	// Return NULL if no variable name has been found\r
0203b5fd JPM	624	char *DBGManager_GetGlobalVariableName(size_t Index)\r
	625	{\r
	626	if ((DBGType & DBG_ELFDWARF))\r
	627	{\r
	628	return DWARFManager_GetGlobalVariableName(Index);\r
	629	}\r
	630	else\r
	631	{\r
	632	return NULL;\r
	633	}\r
	634	}\r
	635	\r
	636	\r
	637	// Get function name from address\r
	638	// Return function name found\r
	639	// Return NULL if no function name has been found\r
	640	char *DBGManager_GetFunctionName(size_t Adr)\r
2d0121d4	641	{\r
4f945aea JPM	642	char *Symbolname = NULL;\r
4f945aea JPM	643	\r
2d0121d4 JPM	644	if ((DBGType & DBG_ELFDWARF))\r
2d0121d4 JPM	645	{\r
4f945aea	646	Symbolname = DWARFManager_GetFunctionName(Adr);\r
2d0121d4	647	}\r
4f945aea JPM	648	\r
4f945aea JPM	649	if ((DBGType & DBG_ELF) && (Symbolname == NULL))\r
2d0121d4	650	{\r
4f945aea	651	Symbolname = ELFManager_GetFunctionName(Adr);\r
2d0121d4	652	}\r
4f945aea JPM	653	\r
4f945aea JPM	654	return Symbolname;\r
2d0121d4 JPM	655	}\r
	656	\r
	657	\r
	658	// Get line number from address and his tag\r
	659	// Return line number on the symbol name found\r
	660	// Return 0 if no symbol name has been found\r
	661	size_t DBGManager_GetNumLineFromAdr(size_t Adr, size_t Tag)\r
	662	{\r
	663	if ((DBGType & DBG_ELFDWARF))\r
	664	{\r
	665	return DWARFManager_GetNumLineFromAdr(Adr, Tag);\r
	666	}\r
	667	else\r
	668	{\r
	669	return 0;\r
	670	}\r
	671	}\r
	672	\r
	673	\r
	674	// Get symbol name from address\r
	675	// Return text pointer on the symbol name found\r
	676	// Return NULL if no symbol name has been found\r
0203b5fd	677	char *DBGManager_GetSymbolNameFromAdr(size_t Adr)\r
2d0121d4 JPM	678	{\r
	679	char *Symbolname;\r
	680	\r
	681	//if ((DBGType & DBG_HWLABEL) \|\| vjs.displayHWlabels)\r
	682	if (vjs.displayHWlabels)\r
	683	{\r
	684	Symbolname = HWLABELManager_GetSymbolnameFromAdr(Adr);\r
	685	}\r
	686	else\r
	687	{\r
	688	Symbolname = NULL;\r
	689	}\r
41d6f5f7 JPM	690	#ifdef _MSC_VER\r
	691	#pragma message("Warning: !!! Need to set the DBG_HWLABEL in DBGType instead to use the setting value !!!")\r
	692	#else\r
	693	#warning "!!! Need to set the DBG_HWLABEL in DBGType instead to use the setting value !!!"\r
2d0121d4 JPM	694	#endif // _MSC_VER\r
	695	\r
	696	if (Symbolname == NULL)\r
	697	{\r
	698	if ((DBGType & DBG_ELFDWARF))\r
	699	{\r
	700	Symbolname = DWARFManager_GetSymbolnameFromAdr(Adr);\r
	701	}\r
	702	\r
	703	if ((DBGType & DBG_ELF) && (Symbolname == NULL))\r
	704	{\r
	705	Symbolname = ELFManager_GetSymbolnameFromAdr(Adr);\r
	706	}\r
	707	}\r
	708	\r
	709	return Symbolname;\r
	710	}\r
	711	\r
	712	\r
	713	// Get source line based on the Address and his Tag\r
	714	// Return text pointer on the source line found\r
	715	// Return NULL if no source line has been found\r
	716	char *DBGManager_GetLineSrcFromAdr(size_t Adr, size_t Tag)\r
	717	{\r
fe3b257d	718	char *TextLine = NULL;\r
2d0121d4 JPM	719	\r
	720	if ((DBGType & DBG_ELFDWARF))\r
	721	{\r
fe3b257d	722	TextLine = DWARFManager_GetLineSrcFromAdr(Adr, Tag);\r
2d0121d4 JPM	723	}\r
2d0121d4 JPM	724	\r
fe3b257d	725	return TextLine;\r
2d0121d4 JPM	726	}\r
	727	\r
	728	\r
fe3b257d	729	// Get text line from source based on address and num line (starting from 1)\r
2d0121d4 JPM	730	// Return NULL if no text line has been found\r
	731	char *DBGManager_GetLineSrcFromAdrNumLine(size_t Adr, size_t NumLine)\r
	732	{\r
fe3b257d	733	char *TextLine = NULL;\r
2d0121d4 JPM	734	\r
	735	if ((DBGType & DBG_ELFDWARF))\r
	736	{\r
fe3b257d	737	TextLine = DWARFManager_GetLineSrcFromAdrNumLine(Adr, NumLine);\r
2d0121d4 JPM	738	}\r
2d0121d4 JPM	739	\r
fe3b257d	740	return TextLine;\r
2d0121d4 JPM	741	}\r
	742	\r
	743	\r
fe3b257d	744	// Get text line from source based on address and num line (starting from 1)\r
2d0121d4 JPM	745	// Return NULL if no text line has been found\r
	746	char *DBGManager_GetLineSrcFromNumLineBaseAdr(size_t Adr, size_t NumLine)\r
	747	{\r
fe3b257d	748	char *TextLine = NULL;\r
2d0121d4 JPM	749	\r
	750	if ((DBGType & DBG_ELFDWARF))\r
	751	{\r
fe3b257d	752	TextLine = DWARFManager_GetLineSrcFromNumLineBaseAdr(Adr, NumLine);\r
2d0121d4 JPM	753	}\r
2d0121d4 JPM	754	\r
fe3b257d	755	return TextLine;\r
2d0121d4 JPM	756	}\r
2d0121d4 JPM	757	\r
6564336c JPM	758	\r
	759	// Get number of source code filenames\r
	760	size_t DBGManager_GetNbFullSourceFilename(void)\r
	761	{\r
	762	size_t Nbr = 0;\r
	763	\r
	764	if ((DBGType & DBG_ELFDWARF))\r
	765	{\r
	766	Nbr = DWARFManager_GetNbFullSourceFilename();\r
	767	}\r
	768	\r
	769	return Nbr;\r
	770	}\r
	771	\r
	772	\r
	773	// Get source code filename based on index\r
	774	char *DBGManager_GetNumFullSourceFilename(size_t Index)\r
	775	{\r
	776	char *FullSourceFilename = NULL;\r
	777	\r
	778	if ((DBGType & DBG_ELFDWARF))\r
	779	{\r
	780	FullSourceFilename = DWARFManager_GetNumFullSourceFilename(Index);\r
	781	}\r
	782	\r
	783	return FullSourceFilename;\r
	784	}\r