6502/cc65
1
0
Fork 0
mirror of https://github.com/cc65/cc65.git synced 2024-12-25 02:29:52 +00:00
Code Issues Projects Releases Wiki Activity

Added functions to access the c symbols in the debug info file.

Browse Source 
git-svn-id: svn://svn.cc65.org/cc65/trunk@5294 b7a2c559-68d2-44c3-8de9-860c34a00d81
This commit is contained in:
uz 2011-09-01 20:51:07 +00:00
parent 8504f42497
commit 3ec4b296ba
3 changed files with 514 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

360
src/dbginfo/dbginfo.c
View File

@ -265,7 +265,6 @@ struct CSymInfo {
unsigned Id; /* Id of scope */
ScopeInfo* Info; /* Pointer to scope */
} Scope;
Collection* LocalsByName; /* Locals if this is a function */
char Name[1]; /* Name of file with full path */
};
@ -731,9 +730,9 @@ static void CollFree (Collection* C)
static unsigned CollCount (const Collection* C)
/* Return the number of items in the collection */
/* Return the number of items in the collection. Return 0 if C is NULL. */
{
return C->Count;
return C? C->Count : 0;
}
@ -1069,6 +1068,21 @@ static void DBGPRINT(const char* format, ...) {}
static unsigned GetId (const void* Data)
/* Return the id of one of the info structures. All structures have the Id
* field as first member, and the C standard allows converting a union pointer
* to the data type of the first member, so this is safe and portable.
*/
{
if (Data) {
return *(const unsigned*)Data;
} else {
return CC65_INV_ID;
}
}
static unsigned HexValue (char C)
/* Convert the ascii representation of a hex nibble into the hex nibble */
{
@ -1182,7 +1196,6 @@ static CSymInfo* NewCSymInfo (const StrBuf* Name)
CSymInfo* S = xmalloc (sizeof (CSymInfo) + SB_GetLen (Name));
/* Initialize it */
S->LocalsByName = 0;
memcpy (S->Name, SB_GetConstBuf (Name), SB_GetLen (Name) + 1);
/* Return it */
@ -1194,15 +1207,39 @@ static CSymInfo* NewCSymInfo (const StrBuf* Name)
static void FreeCSymInfo (CSymInfo* S)
/* Free a CSymInfo struct */
{
/* Free collections */
CollFree (S->LocalsByName);
/* Free the structure itself */
xfree (S);
}
static cc65_csyminfo* new_cc65_csyminfo (unsigned Count)
/* Allocate and return a cc65_csyminfo struct that is able to hold Count
* entries. Initialize the count field of the returned struct.
*/
{
cc65_csyminfo* S = xmalloc (sizeof (*S) - sizeof (S->data[0]) +
Count * sizeof (S->data[0]));
S->count = Count;
return S;
}
static void CopyCSymInfo (cc65_csymdata* D, const CSymInfo* S)
/* Copy data from a CSymInfo struct to a cc65_csymdata struct */
{
D->csym_id = S->Id;
D->csym_kind = S->Kind;
D->csym_sc = S->SC;
D->csym_offs = S->Offs;
D->symbol_id = GetId (S->Sym.Info);
D->scope_id = GetId (S->Scope.Info);
D->csym_name = S->Name;
}
static int CompareCSymInfoByName (const void* L, const void* R)
/* Helper function to sort c symbol infos in a collection by name */
{
@ -1476,16 +1513,8 @@ static void CopyModInfo (cc65_moduledata* D, const ModInfo* M)
D->module_id = M->Id;
D->module_name = M->Name;
D->source_id = M->File.Info->Id;
if (M->Lib.Info) {
D->library_id = M->Lib.Info->Id;
} else {
D->library_id = CC65_INV_ID;
}
if (M->MainScope) {
D->scope_id = M->MainScope->Id;
} else {
D->scope_id = CC65_INV_ID;
}
D->library_id = GetId (M->Lib.Info);
D->scope_id = GetId (M->MainScope);
}
@ -1557,16 +1586,8 @@ static void CopyScopeInfo (cc65_scopedata* D, const ScopeInfo* S)
D->scope_name = S->Name;
D->scope_type = S->Type;
D->scope_size = S->Size;
if (S->Parent.Info) {
D->parent_id = S->Parent.Info->Id;
} else {
D->parent_id = CC65_INV_ID;
}
if (S->Label.Info) {
D->symbol_id = S->Label.Info->Id;
} else {
D->symbol_id = CC65_INV_ID;
}
D->parent_id = GetId (S->Parent.Info);
D->symbol_id = GetId (S->Label.Info);
D->module_id = S->Mod.Info->Id;
}
@ -1718,21 +1739,9 @@ static void CopySpanInfo (cc65_spandata* D, const SpanInfo* S)
D->span_start = S->Start;
D->span_end = S->End;
D->segment_id = S->Seg.Info->Id;
if (S->Type.Info) {
D->type_id = S->Type.Info->Id;
} else {
D->type_id = CC65_INV_ID;
}
if (S->ScopeInfoList) {
D->type_id = GetId (S->Type.Info);
D->scope_count = CollCount (S->ScopeInfoList);
} else {
D->scope_count = 0;
}
if (S->LineInfoList) {
D->line_count = CollCount (S->LineInfoList);
} else {
D->line_count = 0;
}
}
@ -4605,7 +4614,51 @@ ErrorExit:
static int FindFileInfoByName (Collection* FileInfos, const char* Name,
static int FindCSymInfoByName (const Collection* CSymInfos, const char* Name,
unsigned* Index)
/* Find the C symbol info with a given file name. The function returns true if
* the name was found. In this case, Index contains the index of the first item
* that matches. If the item wasn't found, the function returns false and
* Index contains the insert position for Name.
*/
{
/* Do a binary search */
int Lo = 0;
int Hi = (int) CollCount (CSymInfos) - 1;
int Found = 0;
while (Lo <= Hi) {
/* Mid of range */
int Cur = (Lo + Hi) / 2;
/* Get item */
const CSymInfo* CurItem = CollAt (CSymInfos, Cur);
/* Compare */
int Res = strcmp (CurItem->Name, Name);
/* Found? */
if (Res < 0) {
Lo = Cur + 1;
} else {
Hi = Cur - 1;
/* Since we may have duplicates, repeat the search until we've
* the first item that has a match.
*/
if (Res == 0) {
Found = 1;
}
}
}
/* Pass back the index. This is also the insert position */
*Index = Lo;
return Found;
}
static int FindFileInfoByName (const Collection* FileInfos, const char* Name,
unsigned* Index)
/* Find the FileInfo for a given file name. The function returns true if the
* name was found. In this case, Index contains the index of the first item
@ -4623,7 +4676,7 @@ static int FindFileInfoByName (Collection* FileInfos, const char* Name,
int Cur = (Lo + Hi) / 2;
/* Get item */
FileInfo* CurItem = CollAt (FileInfos, Cur);
const FileInfo* CurItem = CollAt (FileInfos, Cur);
/* Compare */
int Res = strcmp (CurItem->Name, Name);
@ -4965,14 +5018,14 @@ static void ProcessCSymInfo (InputData* D)
}
}
/* Walk over all scopes and sort the c symbols by name */
/* Walk over all scopes and sort the c symbols by name. */
for (I = 0; I < CollCount (&D->Info->ScopeInfoById); ++I) {
/* Get this scope */
ScopeInfo* S = CollAt (&D->Info->ScopeInfoById, I);
/* Ignore scopes without C symbols */
if (S->CSymInfoByName && CollCount (S->CSymInfoByName) > 1) {
if (CollCount (S->CSymInfoByName) > 1) {
/* Sort the c symbols for this scope by name */
CollSort (S->CSymInfoByName, CompareCSymInfoByName);
}
@ -5741,6 +5794,217 @@ void cc65_free_dbginfo (cc65_dbginfo Handle)
/*****************************************************************************/
/* C symbols */
/*****************************************************************************/
const cc65_csyminfo* cc65_get_csymlist (cc65_dbginfo Handle)
/* Return a list of all c symbols */
{
const DbgInfo* Info;
cc65_csyminfo* S;
unsigned I;
/* Check the parameter */
assert (Handle != 0);
/* The handle is actually a pointer to a debug info struct */
Info = Handle;
/* Allocate memory for the data structure returned to the caller */
S = new_cc65_csyminfo (CollCount (&Info->CSymInfoById));
/* Fill in the data */
for (I = 0; I < CollCount (&Info->CSymInfoById); ++I) {
/* Copy the data */
CopyCSymInfo (S->data + I, CollAt (&Info->CSymInfoById, I));
}
/* Return the result */
return S;
}
const cc65_csyminfo* cc65_csym_byid (cc65_dbginfo Handle, unsigned Id)
/* Return information about a c symbol with a specific id. The function
* returns NULL if the id is invalid (no such c symbol) and otherwise a
* cc65_csyminfo structure with one entry that contains the requested
* symbol information.
*/
{
const DbgInfo* Info;
cc65_csyminfo* S;
/* Check the parameter */
assert (Handle != 0);
/* The handle is actually a pointer to a debug info struct */
Info = Handle;
/* Check if the id is valid */
if (Id >= CollCount (&Info->CSymInfoById)) {
return 0;
}
/* Allocate memory for the data structure returned to the caller */
S = new_cc65_csyminfo (1);
/* Fill in the data */
CopyCSymInfo (S->data, CollAt (&Info->CSymInfoById, Id));
/* Return the result */
return S;
}
const cc65_csyminfo* cc65_cfunc_bymodule (cc65_dbginfo Handle, unsigned ModId)
/* Return the list of C functions (not symbols!) for a specific module. If
* the module id is invalid, the function will return NULL, otherwise a
* (possibly empty) c symbol list.
*/
{
const DbgInfo* Info;
const ModInfo* M;
cc65_csyminfo* D;
unsigned I;
/* Check the parameter */
assert (Handle != 0);
/* The handle is actually a pointer to a debug info struct */
Info = Handle;
/* Check if the module id is valid */
if (ModId >= CollCount (&Info->ModInfoById)) {
return 0;
}
/* Get a pointer to the module info */
M = CollAt (&Info->ModInfoById, ModId);
/* Allocate memory for the data structure returned to the caller */
D = new_cc65_csyminfo (CollCount (&M->CSymFuncByName));
/* Fill in the data */
for (I = 0; I < CollCount (&M->CSymFuncByName); ++I) {
CopyCSymInfo (D->data + I, CollAt (&M->CSymFuncByName, I));
}
/* Return the result */
return D;
}
const cc65_csyminfo* cc65_cfunc_byname (cc65_dbginfo Handle, const char* Name)
/* Return a list of all C functions with the given name that have a
* definition.
*/
{
const DbgInfo* Info;
unsigned Index;
unsigned Count;
const CSymInfo* S;
cc65_csyminfo* D;
unsigned I;
/* Check the parameter */
assert (Handle != 0);
/* The handle is actually a pointer to a debug info struct */
Info = Handle;
/* Search for a function with the given name */
if (!FindCSymInfoByName (&Info->CSymFuncByName, Name, &Index)) {
return 0;
}
/* Count functions with this name */
Count = 1;
I = Index;
while (1) {
if (++I >= CollCount (&Info->CSymFuncByName)) {
break;
}
S = CollAt (&Info->CSymFuncByName, I);
if (strcmp (S->Name, Name) != 0) {
/* Next symbol has another name */
break;
}
++Count;
}
/* Allocate memory for the data structure returned to the caller */
D = new_cc65_csyminfo (Count);
/* Fill in the data */
for (I = 0; I < Count; ++I, ++Index) {
CopyCSymInfo (D->data + I, CollAt (&Info->CSymFuncByName, Index));
}
/* Return the result */
return D;
}
const cc65_csyminfo* cc65_csym_byscope (cc65_dbginfo Handle, unsigned ScopeId)
/* Return all C symbols for a scope. The function will return NULL if the
* given id is invalid.
*/
{
const DbgInfo* Info;
const ScopeInfo* S;
cc65_csyminfo* D;
unsigned I;
/* Check the parameter */
assert (Handle != 0);
/* The handle is actually a pointer to a debug info struct */
Info = Handle;
/* Check if the scope id is valid */
if (ScopeId >= CollCount (&Info->ScopeInfoById)) {
return 0;
}
/* Get a pointer to the scope */
S = CollAt (&Info->ScopeInfoById, ScopeId);
/* Allocate memory for the data structure returned to the caller */
D = new_cc65_csyminfo (CollCount (S->CSymInfoByName));
/* Fill in the data */
for (I = 0; I < CollCount (S->CSymInfoByName); ++I) {
CopyCSymInfo (D->data + I, CollAt (S->CSymInfoByName, I));
}
/* Return the result */
return D;
}
void cc65_free_csyminfo (cc65_dbginfo Handle, const cc65_csyminfo* Info)
/* Free a c symbol info record */
{
/* Just for completeness, check the handle */
assert (Handle != 0);
/* Just free the memory */
xfree ((cc65_csyminfo*) Info);
}
/*****************************************************************************/
/* Libraries */
/*****************************************************************************/
@ -6046,9 +6310,9 @@ const cc65_lineinfo* cc65_line_byspan (cc65_dbginfo Handle, unsigned SpanId)
S = CollAt (&Info->SpanInfoById, SpanId);
/* Prepare the struct we will return to the caller */
D = new_cc65_lineinfo (S->LineInfoList? CollCount (S->LineInfoList) : 0);
D = new_cc65_lineinfo (CollCount (S->LineInfoList));
/* Fill in the data. Since D->LineInfoList may be NULL, we will use the
/* Fill in the data. Since S->LineInfoList may be NULL, we will use the
* count field of the returned data struct instead.
*/
for (I = 0; I < D->count; ++I) {
@ -6652,7 +6916,7 @@ const cc65_scopeinfo* cc65_scope_byspan (cc65_dbginfo Handle, unsigned SpanId)
S = CollAt (&Info->SpanInfoById, SpanId);
/* Prepare the struct we will return to the caller */
D = new_cc65_scopeinfo (S->ScopeInfoList? CollCount (S->ScopeInfoList) : 0);
D = new_cc65_scopeinfo (CollCount (S->ScopeInfoList));
/* Fill in the data. Since D->ScopeInfoList may be NULL, we will use the
* count field of the returned data struct instead.
@ -6694,7 +6958,7 @@ const cc65_scopeinfo* cc65_childscopes_byid (cc65_dbginfo Handle, unsigned Id)
S = CollAt (&Info->ScopeInfoById, Id);
/* Allocate memory for the data structure returned to the caller */
D = new_cc65_scopeinfo (S->ChildScopeList? CollCount (S->ChildScopeList) : 0);
D = new_cc65_scopeinfo (CollCount (S->ChildScopeList));
/* Fill in the data */
for (I = 0; I < D->count; ++I) {

16
src/dbginfo/dbginfo.h
View File

@ -158,6 +158,22 @@ const cc65_csyminfo* cc65_csym_byid (cc65_dbginfo handle, unsigned id);
* symbol information.
*/
const cc65_csyminfo* cc65_cfunc_bymodule (cc65_dbginfo handle, unsigned module_id);
/* Return the list of C functions (not symbols!) for a specific module. If
* the module id is invalid, the function will return NULL, otherwise a
* (possibly empty) c symbol list.
*/
const cc65_csyminfo* cc65_cfunc_byname (cc65_dbginfo handle, const char* name);
/* Return a list of all C functions with the given name that have a
* definition.
*/
const cc65_csyminfo* cc65_csym_byscope (cc65_dbginfo handle, unsigned scope_id);
/* Return all C symbols for a scope. The function will return NULL if the
* given id is invalid.
*/
void cc65_free_csyminfo (cc65_dbginfo handle, const cc65_csyminfo* info);
/* Free a c symbol info record */

175
src/dbginfo/dbgsh.c
View File

@ -75,6 +75,12 @@ static void CmdShowHelp (Collection* Args);
static void CmdShowChildScopes (Collection* Args);
/* Show child scopes from the debug info file */
static void CmdShowCSymbol (Collection* Args);
/* Show c symbols from the debug info file */
static void CmdShowFunction (Collection* Args);
/* Show C functions from the debug info file */
static void CmdShowLibrary (Collection* Args);
/* Show libraries from the debug info file */
@ -132,6 +138,7 @@ static unsigned FileWarnings = 0;
/* Type of an id */
enum {
InvalidId,
CSymbolId,
LibraryId,
LineId,
ModuleId,
@ -194,9 +201,29 @@ static const CmdEntry ShowCmds[] = {
"Show child scopes of other scopes.",
-2,
CmdShowChildScopes
}, {
"csym",
0,
-1,
CmdShowCSymbol
}, {
"csymbol",
"Show c symbols.",
-1,
CmdShowCSymbol
}, {
"func",
0,
-2,
CmdShowFunction
}, {
"function",
"Show c functions.",
-2,
CmdShowFunction
}, {
"help",
"Show available subcommands",
"Show available subcommands.",
1,
CmdShowHelp
}, {
@ -491,10 +518,10 @@ static void PrintAddr (cc65_addr Addr, unsigned FieldWidth)
static void PrintNumber (unsigned long Num, unsigned Width, unsigned FieldWidth)
static void PrintNumber (long Num, unsigned Width, unsigned FieldWidth)
/* Output a number */
{
Print ("%*lu", Width, Num);
Print ("%*ld", Width, Num);
if (FieldWidth > Width) {
Print ("%*s", FieldWidth - Width, "");
}
@ -544,6 +571,38 @@ static void PrintTime (time_t T, unsigned FieldWidth)
static void PrintCSymbolHeader (void)
/* Output a header for a list of C symbols */
{
/* Header */
PrintLine (" id name type kind sc offs symbol scope");
PrintSeparator ();
}
static void PrintCSymbols (const cc65_csyminfo* S)
/* Output a list of C symbols */
{
unsigned I;
const cc65_csymdata* D;
/* Segments */
for (I = 0, D = S->data; I < S->count; ++I, ++D) {
PrintId (D->csym_id, 6);
Print ("%-28s", D->csym_name);
PrintId (0, 6);
PrintNumber (D->csym_kind, 4, 6);
PrintNumber (D->csym_sc, 4, 6);
PrintNumber (D->csym_offs, 4, 8);
PrintId (D->symbol_id, 6);
PrintId (D->scope_id, 0);
NewLine ();
}
}
static void PrintLibraryHeader (void)
/* Output the header for a library list */
{
@ -1002,6 +1061,116 @@ static void CmdShowChildScopes (Collection* Args)
static void CmdShowCSymbol (Collection* Args)
/* Show C symbols from the debug info file */
{
const cc65_csyminfo* S;
/* Be sure a file is loaded */
if (!FileIsLoaded ()) {
return;
}
/* Output the header */
PrintCSymbolHeader ();
/* No arguments means show all libraries */
if (CollCount (Args) == 0) {
/* Fetch the list of c symbols */
S = cc65_get_csymlist (Info);
/* Output the c symbols */
PrintCSymbols (S);
/* Free the list */
cc65_free_csyminfo (Info, S);
} else {
/* Output c symbols for all arguments */
unsigned I;
for (I = 0; I < CollCount (Args); ++I) {
/* Parse the argument */
unsigned Id;
unsigned IdType = CSymbolId;
if (GetId (CollConstAt (Args, I), &Id, &IdType)) {
/* Fetch list depending on type */
switch (IdType) {
case CSymbolId:
S = cc65_csym_byid (Info, Id);
break;
case ScopeId:
S = cc65_csym_byscope (Info, Id);
break;
default:
S = 0;
PrintLine ("Invalid id type");
break;
}
} else {
/* Invalid id */
S = 0;
}
/* Output the list */
if (S) {
PrintCSymbols (S);
cc65_free_csyminfo (Info, S);
}
}
}
}
static void CmdShowFunction (Collection* Args)
/* Show C functions from the debug info file */
{
const cc65_csyminfo* S;
unsigned I;
/* Be sure a file is loaded */
if (!FileIsLoaded ()) {
return;
}
/* Output the header */
PrintCSymbolHeader ();
/* Output c symbols for all arguments */
for (I = 0; I < CollCount (Args); ++I) {
/* Parse the argument */
unsigned Id;
unsigned IdType = ModuleId;
if (GetId (CollConstAt (Args, I), &Id, &IdType)) {
/* Fetch list depending on type */
switch (IdType) {
case ModuleId:
S = cc65_cfunc_bymodule (Info, Id);
break;
default:
S = 0;
PrintLine ("Invalid id type");
break;
}
} else {
/* An invalid id may be a function name */
S = cc65_cfunc_byname (Info, CollConstAt (Args, I));
}
/* Output the list */
if (S) {
PrintCSymbols (S);
cc65_free_csyminfo (Info, S);
}
}
}
static void CmdShowLine (Collection* Args)
/* Show lines from the debug info file */
{