X-Git-Url: http://git.hcoop.net/clinton/Virtual-Jaguar-Rx.git/blobdiff_plain/2d0121d42315127fa7d7ac67eb3c8c4e5e2d8a84..ef0da6debd1fc73d0f4c3914e21d9a09dd8fe7e7:/src/debugger/DBGManager.cpp?ds=sidebyside

diff --git a/src/debugger/DBGManager.cpp b/src/debugger/DBGManager.cpp
index d4df274..1d024e3 100644
--- a/src/debugger/DBGManager.cpp
+++ b/src/debugger/DBGManager.cpp
@@ -10,6 +10,15 @@
 // JPM  12/21/2016  Created this file
 // JPM              Various efforts to set the ELF format support
 // JPM              Various efforts to set the DWARF format support
+// JPM  09/15/2018  Support the unsigned char
+// JPM   Oct./2018  Cosmetic changes, added source file search paths, and ELF function name
+// JPM  Sept./2019  Support the unsigned/signed short type
+//
+
+// To Do
+// To think about unique format to handle variations from ELF, DWARF, etc.
+//
+
 
 #include <stdlib.h>
 #include <string.h>
@@ -25,36 +34,129 @@
 #include "memory.h"
 
 
-// 
-char *DBGManager_GetVariableValueFromAdr(uint32_t Adr, uint32_t TypeEncoding, uint32_t TypeByteSize);
-
-
 //
 struct Value
 {
 	union
 	{
-		char C[10];
+		char Ct[10];
+		char C;
+		bool B;
 		double D;
 		float F;
+		int16_t SS;
 		int32_t SI;
 		int64_t SL;
+		uint16_t US;
 		uint32_t UI;
 		uint64_t UL;
 	};
 }S_Value;
 
 
+//
+void DBGManager_SourceFileSearchPathsInit(void);
+void DBGManager_SourceFileSearchPathsReset(void);
+void DBGManager_SourceFileSearchPathsClose(void);
+
+
 // Common debugger variables
 size_t	DBGType;
 char value[1000];
+size_t NbSFSearchPaths;
+char **SourceFileSearchPaths;
+
+
+// Init the source file search paths
+void DBGManager_SourceFileSearchPathsInit(void)
+{
+	NbSFSearchPaths = 0;
+	SourceFileSearchPaths = NULL;
+}
+
+
+// Set the source file search paths
+// Create individual path for each one provided in the list (separate with ';')
+void DBGManager_SourceFileSearchPathsSet(char *ListPaths)
+{
+	// Check presence of a previous list
+	if (NbSFSearchPaths)
+	{
+		// Reset previous list
+		DBGManager_SourceFileSearchPathsReset();
+	}
+
+	// Check if there is a paths list
+	if (strlen(ListPaths))
+	{
+		// Get number of paths
+		char *Ptr = ListPaths;
+		while(*Ptr)
+		{
+			while (*Ptr && (*Ptr++ != ';'));
+			{
+				NbSFSearchPaths++;
+			}
+		}
+
+		// Isolate each search path
+		SourceFileSearchPaths = (char **)calloc(NbSFSearchPaths, sizeof(char *));
+		size_t i = 0;
+		Ptr = ListPaths;
+
+		while (*Ptr)
+		{
+			// Search the path separator (';')
+			char *Ptr1 = Ptr;
+			while (*Ptr && (*Ptr++ != ';'));
+
+			// Copy the inidividual search path
+			SourceFileSearchPaths[i] = (char *)calloc(1, (Ptr - Ptr1) + 1);
+			strncpy(SourceFileSearchPaths[i], Ptr1, (Ptr - Ptr1));
+			if (SourceFileSearchPaths[i][strlen(SourceFileSearchPaths[i]) - 1] == ';')
+			{
+				SourceFileSearchPaths[i][strlen(SourceFileSearchPaths[i]) - 1] = 0;
+			}
+			i++;
+		}
+	}
+
+	DWARFManager_Set(NbSFSearchPaths, SourceFileSearchPaths);
+}
+
+
+// Reset the source file search paths
+void DBGManager_SourceFileSearchPathsReset(void)
+{
+	// Free each path
+	while (NbSFSearchPaths)
+	{
+		free(SourceFileSearchPaths[--NbSFSearchPaths]);
+	}
+
+	// Free the pointers list
+	free(SourceFileSearchPaths);
+	SourceFileSearchPaths = NULL;
+}
+
+
+// Close the source file search paths
+void DBGManager_SourceFileSearchPathsClose(void)
+{
+	DBGManager_SourceFileSearchPathsReset();
+}
 
 
 // Common debugger initialisation
 void DBGManager_Init(void)
 {
+	// DBG initialisations
 	DBGType = DBG_NO_TYPE;
+	DBGManager_SourceFileSearchPathsInit();
+
+	// ELF initialisation 
 	ELFManager_Init();
+	// DWARF initialisation
 	DWARFManager_Init();
 }
 
@@ -77,13 +179,6 @@ void DBGManager_Reset(void)
 }
 
 
-// Common debugger set
-void DBGManager_SetType(size_t DBGTypeSet)
-{
-	DBGType |= DBGTypeSet;
-}
-
-
 // Common debugger close
 void DBGManager_Close(void)
 {
@@ -96,6 +191,23 @@ void DBGManager_Close(void)
 	{
 		ELFManager_Close();
 	}
+
+	DBGManager_SourceFileSearchPathsClose();
+	DBGType = DBG_NO_TYPE;
+}
+
+
+// Common debugger set
+void DBGManager_SetType(size_t DBGTypeSet)
+{
+	DBGType |= DBGTypeSet;
+}
+
+
+// Get debugger type
+size_t DBGManager_GetType(void)
+{
+	return DBGType;
 }
 
 
@@ -114,13 +226,13 @@ char *DBGManager_GetFullSourceFilenameFromAdr(size_t Adr, bool *Error)
 }
 
 
-// Get number of external variables
+// Get number of local variables
 // Return 0 if none has been found
-size_t DBGManager_GetNbExternalVariables(void)
+size_t DBGManager_GetNbLocalVariables(size_t Adr)
 {
 	if ((DBGType & DBG_ELFDWARF))
 	{
-		return DWARFManager_GetNbExternalVariables();
+		return DWARFManager_GetNbLocalVariables(Adr);
 	}
 	else
 	{
@@ -129,28 +241,46 @@ size_t DBGManager_GetNbExternalVariables(void)
 }
 
 
-//
-size_t DBGManager_GetAdrFromSymbolName(char *SymbolName)
+// Get number of global variables
+// Return 0 if none has been found
+size_t DBGManager_GetNbGlobalVariables(void)
 {
-	if ((DBGType & DBG_ELF))
+	if ((DBGType & DBG_ELFDWARF))
 	{
-		return ELFManager_GetAdrFromSymbolName(SymbolName);
+		return DWARFManager_GetNbGlobalVariables();
 	}
 	else
 	{
-		return 0;
+		return	0;
 	}
 }
 
 
-// Get external variable's Address based on his Name
+// Get address from symbol name
+// Return found address
+// Return NULL if no symbol has been found
+size_t DBGManager_GetAdrFromSymbolName(char *SymbolName)
+{
+	if (SymbolName)
+	{
+		if ((DBGType & DBG_ELF))
+		{
+			return ELFManager_GetAdrFromSymbolName(SymbolName);
+		}
+	}
+
+	return 0;
+}
+
+
+// Get global variable's Address based on his Name
 // Return found Address
 // Return NULL if no Address has been found
-size_t DBGManager_GetExternalVariableAdrFromName(char *VariableName)
+size_t DBGManager_GetGlobalVariableAdrFromName(char *VariableName)
 {
 	if ((DBGType & DBG_ELFDWARF))
 	{
-		return DWARFManager_GetExternalVariableAdrFromName(VariableName);
+		return DWARFManager_GetGlobalVariableAdrFromName(VariableName);
 	}
 	else
 	{
@@ -159,12 +289,58 @@ size_t DBGManager_GetExternalVariableAdrFromName(char *VariableName)
 }
 
 
+// Get local variable's type encoding based on his address and Index
+// Return the type encoding found
+// Return 0 if no type encoding has been found
+size_t DBGManager_GetLocalVariableTypeEncoding(size_t Adr, size_t Index)
+{
+	if ((DBGType & DBG_ELFDWARF))
+	{
+		return DWARFManager_GetLocalVariableTypeEncoding(Adr, Index);
+	}
+	else
+	{
+		return	0;
+	}
+}
+
+
+//
+int DBGManager_GetLocalVariableOffset(size_t Adr, size_t Index)
+{
+	if ((DBGType & DBG_ELFDWARF))
+	{
+		return DWARFManager_GetLocalVariableOffset(Adr, Index);
+	}
+	else
+	{
+		return	0;
+	}
+}
+
+
+// Get local variable's type byte size based on his address and Index
+// Return the type's byte size found
+// Return 0 if no type's byte size has been found
+size_t DBGManager_GetLocalVariableTypeByteSize(size_t Adr, size_t Index)
+{
+	if ((DBGType & DBG_ELFDWARF))
+	{
+		return DWARFManager_GetLocalVariableTypeByteSize(Adr, Index);
+	}
+	else
+	{
+		return	0;
+	}
+}
+
+
 //
-size_t DBGManager_GetExternalVariableTypeTag(size_t Index)
+size_t DBGManager_GetLocalVariableTypeTag(size_t Adr, size_t Index)
 {
 	if ((DBGType & DBG_ELFDWARF))
 	{
-		return DWARFManager_GetExternalVariableTypeTag(Index);
+		return DWARFManager_GetLocalVariableTypeTag(Adr, Index);
 	}
 	else
 	{
@@ -173,14 +349,28 @@ size_t DBGManager_GetExternalVariableTypeTag(size_t Index)
 }
 
 
-// Get external variable's type name based on his Index
+//
+size_t DBGManager_GetGlobalVariableTypeTag(size_t Index)
+{
+	if ((DBGType & DBG_ELFDWARF))
+	{
+		return DWARFManager_GetGlobalVariableTypeTag(Index);
+	}
+	else
+	{
+		return	0;
+	}
+}
+
+
+// Get global variable's type name based on his Index
 // Return type name's text pointer found
 // Return NULL if no type name has been found
-char *DBGManager_GetExternalVariableTypeName(size_t Index)
+char *DBGManager_GetGlobalVariableTypeName(size_t Index)
 {
 	if ((DBGType & DBG_ELFDWARF))
 	{
-		return DWARFManager_GetExternalVariableTypeName(Index);
+		return DWARFManager_GetGlobalVariableTypeName(Index);
 	}
 	else
 	{
@@ -189,14 +379,14 @@ char *DBGManager_GetExternalVariableTypeName(size_t Index)
 }
 
 
-// Get external variable's Address based on his Index
+// Get global variable's Address based on his Index
 // Return the Address found
 // Return 0 if no Address has been found
-size_t DBGManager_GetExternalVariableAdr(size_t Index)
+size_t DBGManager_GetGlobalVariableAdr(size_t Index)
 {
 	if ((DBGType & DBG_ELFDWARF))
 	{
-		return DWARFManager_GetExternalVariableAdr(Index);
+		return DWARFManager_GetGlobalVariableAdr(Index);
 	}
 	else
 	{
@@ -205,14 +395,14 @@ size_t DBGManager_GetExternalVariableAdr(size_t Index)
 }
 
 
-// Get external variable's type byte size based on his Index
+// Get global variable's type byte size based on his Index
 // Return the type's byte size found
 // Return 0 if no type's byte size has been found
-size_t DBGManager_GetExternalVariableTypeByteSize(size_t Index)
+size_t DBGManager_GetGlobalVariableTypeByteSize(size_t Index)
 {
 	if ((DBGType & DBG_ELFDWARF))
 	{
-		return DWARFManager_GetExternalVariableTypeByteSize(Index);
+		return DWARFManager_GetGlobalVariableTypeByteSize(Index);
 	}
 	else
 	{
@@ -221,14 +411,14 @@ size_t DBGManager_GetExternalVariableTypeByteSize(size_t Index)
 }
 
 
-// Get external variable's type encoding based on his Index
+// Get global variable's type encoding based on his Index
 // Return the type encoding found
 // Return 0 if no type encoding has been found
-size_t DBGManager_GetExternalVariableTypeEncoding(size_t Index)
+size_t DBGManager_GetGlobalVariableTypeEncoding(size_t Index)
 {
 	if ((DBGType & DBG_ELFDWARF))
 	{
-		return DWARFManager_GetExternalVariableTypeEncoding(Index);
+		return DWARFManager_GetGlobalVariableTypeEncoding(Index);
 	}
 	else
 	{
@@ -237,20 +427,20 @@ size_t DBGManager_GetExternalVariableTypeEncoding(size_t Index)
 }
 
 
-// Get external variable value based on his Index
+// Get global variable value based on his Index
 // Return value as a text pointer
 // Note: Pointer may point on a 0 lenght text
-char *DBGManager_GetExternalVariableValue(size_t Index)
+char *DBGManager_GetGlobalVariableValue(size_t Index)
 {
-	uint32_t Adr = 0;
-	uint32_t TypeEncoding = DBG_NO_TYPEENCODING;
-	uint32_t TypeByteSize = 0;
+	size_t Adr = 0;
+	size_t TypeEncoding = DBG_NO_TYPEENCODING;
+	size_t TypeByteSize = 0;
 
 	if ((DBGType & DBG_ELFDWARF))
 	{
-		Adr = DWARFManager_GetExternalVariableAdr(Index);
-		TypeEncoding = DWARFManager_GetExternalVariableTypeEncoding(Index);
-		TypeByteSize = DWARFManager_GetExternalVariableTypeByteSize(Index);
+		Adr = DWARFManager_GetGlobalVariableAdr(Index);
+		TypeEncoding = DWARFManager_GetGlobalVariableTypeEncoding(Index);
+		TypeByteSize = DWARFManager_GetGlobalVariableTypeByteSize(Index);
 	}
 
 	return DBGManager_GetVariableValueFromAdr(Adr, TypeEncoding, TypeByteSize);
@@ -259,15 +449,17 @@ char *DBGManager_GetExternalVariableValue(size_t Index)
 
 // Get variable value based on his Adresse, Encoding Type and Size
 // Return value as a text pointer
-// Note: Pointer may point on a 0 lenght text if Adress is NULL
-char *DBGManager_GetVariableValueFromAdr(uint32_t Adr, uint32_t TypeEncoding, uint32_t TypeByteSize)
+// Note: Pointer may point on a 0 length text
+char *DBGManager_GetVariableValueFromAdr(size_t Adr, size_t TypeEncoding, size_t TypeByteSize)
 {
 	Value V;
 	char *Ptrvalue = value;
 
 	value[0] = 0;
 
+#if 0
 	if (Adr)
+#endif
 	{
 		memset(&V, 0, sizeof(Value));
 #if 0
@@ -275,20 +467,19 @@ char *DBGManager_GetVariableValueFromAdr(uint32_t Adr, uint32_t TypeEncoding, ui
 			jaguarMainRAM[Adr + i] = 0;
 			//jaguarMainRAM[Adr + i] = rand();
 		jaguarMainRAM[Adr + TypeByteSize - 1] = 0x10;
-#endif
-#if 1
-		for (uint32_t i = 0, j = TypeByteSize; i < TypeByteSize; i++, j--)
+#else
+		for (size_t i = 0, j = TypeByteSize; i < TypeByteSize; i++, j--)
 		{
-			V.C[i] = jaguarMainRAM[Adr + j - 1];
+			V.Ct[i] = jaguarMainRAM[Adr + j - 1];
 		}
 #endif
-
 		switch (TypeEncoding)
 		{
 		case DBG_ATE_address:
 			break;
 
 		case DBG_ATE_boolean:
+			sprintf(value, "%s", V.B ? "true" : "false");
 			break;
 
 		case DBG_ATE_complex_float:
@@ -315,6 +506,10 @@ char *DBGManager_GetVariableValueFromAdr(uint32_t Adr, uint32_t TypeEncoding, ui
 		case DBG_ATE_signed:
 			switch (TypeByteSize)
 			{
+			case 2:
+				sprintf(value, "%i", V.SS);
+				break;
+
 			case 4:
 				sprintf(value, "%i", V.SI);
 				break;
@@ -334,6 +529,10 @@ char *DBGManager_GetVariableValueFromAdr(uint32_t Adr, uint32_t TypeEncoding, ui
 		case DBG_ATE_unsigned:
 			switch (TypeByteSize)
 			{
+			case 2:
+				sprintf(value, "%u", V.US);
+				break;
+
 			case 4:
 				sprintf(value, "%u", V.UI);
 				break;
@@ -348,6 +547,7 @@ char *DBGManager_GetVariableValueFromAdr(uint32_t Adr, uint32_t TypeEncoding, ui
 			break;
 
 		case DBG_ATE_unsigned_char:
+			sprintf(value, "%u", (unsigned int(V.C)));
 			break;
 
 		case DBG_ATE_ptr:
@@ -370,14 +570,46 @@ char *DBGManager_GetVariableValueFromAdr(uint32_t Adr, uint32_t TypeEncoding, ui
 }
 
 
-// Get external variable name based on his Index
+// Get local variable's type name based on his Index
+// Return type name's text pointer found
+// Return NULL if no type name has been found
+char *DBGManager_GetLocalVariableTypeName(size_t Adr, size_t Index)
+{
+	if ((DBGType & DBG_ELFDWARF))
+	{
+		return DWARFManager_GetLocalVariableTypeName(Adr, Index);
+	}
+	else
+	{
+		return	NULL;
+	}
+}
+
+
+// Get local variable Op based on his Index
+// Return variable Op's found
+// Return 0 if no variable Op has been found
+size_t DBGManager_GetLocalVariableOp(size_t Adr, size_t Index)
+{
+	if ((DBGType & DBG_ELFDWARF))
+	{
+		return DWARFManager_GetLocalVariableOp(Adr, Index);
+	}
+	else
+	{
+		return	0;
+	}
+}
+
+
+// Get local variable name based on his Index
 // Return variable name's text pointer found
 // Return NULL if no variable name has been found
-char *DBGManager_GetExternalVariableName(size_t Index)
+char *DBGManager_GetLocalVariableName(size_t Adr, size_t Index)
 {
 	if ((DBGType & DBG_ELFDWARF))
 	{
-		return DWARFManager_GetExternalVariableName(Index);
+		return DWARFManager_GetLocalVariableName(Adr, Index);
 	}
 	else
 	{
@@ -386,6 +618,43 @@ char *DBGManager_GetExternalVariableName(size_t Index)
 }
 
 
+// Get global variable name based on his Index
+// Return variable name's text pointer found
+// Return NULL if no variable name has been found
+char *DBGManager_GetGlobalVariableName(size_t Index)
+{
+	if ((DBGType & DBG_ELFDWARF))
+	{
+		return DWARFManager_GetGlobalVariableName(Index);
+	}
+	else
+	{
+		return	NULL;
+	}
+}
+
+
+// Get function name from address
+// Return function name found
+// Return NULL if no function name has been found
+char *DBGManager_GetFunctionName(size_t Adr)
+{
+	char *Symbolname = NULL;
+
+	if ((DBGType & DBG_ELFDWARF))
+	{
+		Symbolname = DWARFManager_GetFunctionName(Adr);
+	}
+
+	if ((DBGType & DBG_ELF) && (Symbolname == NULL))
+	{
+		Symbolname = ELFManager_GetFunctionName(Adr);
+	}
+
+	return	Symbolname;
+}
+
+
 // Get line number from address and his tag
 // Return line number on the symbol name found
 // Return 0 if no symbol name has been found
@@ -405,7 +674,7 @@ size_t DBGManager_GetNumLineFromAdr(size_t Adr, size_t Tag)
 // Get symbol name from address
 // Return text pointer on the symbol name found
 // Return NULL if no symbol name has been found
-char *DBGManager_GetSymbolnameFromAdr(size_t Adr)
+char *DBGManager_GetSymbolNameFromAdr(size_t Adr)
 {
 	char *Symbolname;
 
@@ -418,10 +687,10 @@ char *DBGManager_GetSymbolnameFromAdr(size_t Adr)
 	{
 		Symbolname = NULL;
 	}
-#ifdef _MSC_VER
-#pragma message("Warning: !!! Need to set the DBG_HWLABEL in DBGType instead to use the setting value !!!")
-#else
-	#warning "!!! Need to set the DBG_HWLABEL in DBGType instead to use the setting value !!!"
+#ifdef _MSC_VER
+#pragma message("Warning: !!! Need to set the DBG_HWLABEL in DBGType instead to use the setting value !!!")
+#else
+	#warning "!!! Need to set the DBG_HWLABEL in DBGType instead to use the setting value !!!"
 #endif // _MSC_VER
 
 	if (Symbolname == NULL)
@@ -446,43 +715,70 @@ char *DBGManager_GetSymbolnameFromAdr(size_t Adr)
 // Return NULL if no source line has been found
 char *DBGManager_GetLineSrcFromAdr(size_t Adr, size_t Tag)
 {
-	char *Symbolname = NULL;
+	char *TextLine = NULL;
 
 	if ((DBGType & DBG_ELFDWARF))
 	{
-		Symbolname = DWARFManager_GetLineSrcFromAdr(Adr, Tag);
+		TextLine = DWARFManager_GetLineSrcFromAdr(Adr, Tag);
 	}
 
-	return	Symbolname;
+	return	TextLine;
 }
 
 
-// Get text line from source based on address and num line (starting by 1)
+// Get text line from source based on address and num line (starting from 1)
 // Return NULL if no text line has been found
 char *DBGManager_GetLineSrcFromAdrNumLine(size_t Adr, size_t NumLine)
 {
-	char *Symbolname = NULL;
+	char *TextLine = NULL;
 
 	if ((DBGType & DBG_ELFDWARF))
 	{
-		Symbolname = DWARFManager_GetLineSrcFromAdrNumLine(Adr, NumLine);
+		TextLine = DWARFManager_GetLineSrcFromAdrNumLine(Adr, NumLine);
 	}
 
-	return	Symbolname;
+	return	TextLine;
 }
 
 
-// Get text line from source based on address and num line (starting by 1)
+// Get text line from source based on address and num line (starting from 1)
 // Return NULL if no text line has been found
 char *DBGManager_GetLineSrcFromNumLineBaseAdr(size_t Adr, size_t NumLine)
 {
-	char *Symbolname = NULL;
+	char *TextLine = NULL;
 
 	if ((DBGType & DBG_ELFDWARF))
 	{
-		Symbolname = DWARFManager_GetLineSrcFromNumLineBaseAdr(Adr, NumLine);
+		TextLine = DWARFManager_GetLineSrcFromNumLineBaseAdr(Adr, NumLine);
 	}
 
-	return	Symbolname;
+	return	TextLine;
+}
+
+
+// Get number of source code filenames
+size_t DBGManager_GetNbFullSourceFilename(void)
+{
+	size_t Nbr = 0;
+
+	if ((DBGType & DBG_ELFDWARF))
+	{
+		Nbr = DWARFManager_GetNbFullSourceFilename();
+	}
+
+	return Nbr;
 }
 
+
+// Get source code filename based on index
+char *DBGManager_GetNumFullSourceFilename(size_t Index)
+{
+	char *FullSourceFilename = NULL;
+
+	if ((DBGType & DBG_ELFDWARF))
+	{
+		FullSourceFilename = DWARFManager_GetNumFullSourceFilename(Index);
+	}
+
+	return	FullSourceFilename;
+}