bslathi19/cc65
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

More work on high level language debug symbols. They are now passed correctly

Browse Source 
via the object files to the linker and written to the debug info file.


git-svn-id: svn://svn.cc65.org/cc65/trunk@5285 b7a2c559-68d2-44c3-8de9-860c34a00d81
This commit is contained in:
uz
2011-08-30 11:42:26 +00:00
parent 2f82cb4fb8
commit aaa21c6417
16 changed files with 339 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
src/ca65/dbginfo.c
View File

@@ -37,7 +37,9 @@
/* common */
#include "coll.h"
#include "filepos.h"
#include "hlldbgsym.h"
#include "scopedefs.h"
#include "strbuf.h"
/* ca65 */
@@ -49,16 +51,31 @@
#include "lineinfo.h"
#include "objfile.h"
#include "nexttok.h"
#include "symentry.h"
#include "symtab.h"
/*****************************************************************************/
/* Data */
/* Data */
/*****************************************************************************/
/* Structure used for a high level language function or symbol */
typedef struct HLLDbgSym HLLDbgSym;
struct HLLDbgSym {
unsigned Flags; /* See above */
unsigned Name; /* String id of name */
unsigned AsmName; /* String id of asm symbol name */
SymEntry* Sym; /* The assembler symbol */
int Offs; /* Offset if any */
unsigned Type; /* String id of type */
SymTable* Scope; /* Parent scope */
unsigned FuncId; /* Id of hll function if any */
FilePos Pos; /* Position of statement */
};
/* The current line info */
static LineInfo* CurLineInfo = 0;
@@ -83,9 +100,12 @@ static HLLDbgSym* NewHLLDbgSym (unsigned Flags, unsigned Name, unsigned Type)
S->Flags = Flags;
S->Name = Name;
S->AsmName = EMPTY_STRING_ID;
S->Sym = 0;
S->Offs = 0;
S->Type = Type;
S->ScopeId = CurrentScope->Id;
S->Scope = CurrentScope;
S->FuncId = ~0U;
S->Pos = CurTok.Pos;
/* Return the result */
return S;
@@ -199,15 +219,21 @@ void DbgInfoFunc (void)
if (CurrentScope == RootScope) {
ErrorSkip ("Functions may not be used in the root scope");
return;
} else if (CurrentScope->Flags & ST_EXTFUNC) {
ErrorSkip ("Only one function per scope allowed");
} else if (CurrentScope->Type != SCOPE_SCOPE || CurrentScope->Label == 0) {
ErrorSkip ("Functions can only be tagged to .PROC scopes");
return;
} else if (CurrentScope->Label->HLLSym != 0) {
ErrorSkip ("Only one HLL symbol per asm symbol is allowed");
return;
} else if (CurrentScope->Label->Name != AsmName) {
ErrorSkip ("Scope label and asm name for function must match");
return;
}
CurrentScope->Flags |= ST_EXTFUNC;
/* Add the function */
S = NewHLLDbgSym (Flags, Name, Type);
S->AsmName = AsmName;
S->Sym = CurrentScope->Label;
CurrentScope->Label->HLLSym = S;
CollAppend (&HLLDbgSyms, S);
}
@@ -353,6 +379,45 @@ void DbgInfoSym (void)
void DbgInfoCheck (void)
/* Do checks on all hll debug info symbols when assembly is complete */
{
/* When parsing the debug statements for HLL symbols, we have already
* tagged the functions to their asm counterparts. This wasn't done for
* C symbols, since we will allow forward declarations. So we have to
* resolve the normal C symbols now.
*/
unsigned I;
for (I = 0; I < CollCount (&HLLDbgSyms); ++I) {
/* Get the next symbol */
HLLDbgSym* S = CollAtUnchecked (&HLLDbgSyms, I);
/* Ignore functions and auto symbols, because the later live on the
* stack and don't have corresponding asm symbols.
*/
if (HLL_IS_FUNC (S->Flags) || HLL_GET_SC (S->Flags) == HLL_SC_AUTO) {
continue;
}
/* Safety */
CHECK (S->Sym == 0 && S->Scope != 0);
/* Search for the symbol name */
S->Sym = SymFindAny (S->Scope, GetStrBuf (S->AsmName));
if (S->Sym == 0) {
PError (&S->Pos, "Assembler symbol `%s' not found",
GetString (S->AsmName));
} else {
/* Set the backlink */
S->Sym->HLLSym = S;
}
}
}
void WriteHLLDbgSyms (void)
/* Write a list of all high level language symbols to the object file. */
{
@@ -370,13 +435,21 @@ void WriteHLLDbgSyms (void)
/* Get the next symbol */
const HLLDbgSym* S = CollAtUnchecked (&HLLDbgSyms, I);
/* Get the type of the symbol */
unsigned SC = HLL_GET_SC (S->Flags);
/* Write the symbol data */
ObjWriteVar (S->Flags);
ObjWriteVar (S->Name);
ObjWriteVar (S->AsmName);
ObjWriteVar (S->Offs);
if (SC != HLL_SC_AUTO) {
CHECK (S->Sym->DebugSymId != ~0U);
ObjWriteVar (S->Sym->DebugSymId);
}
if (SC == HLL_SC_AUTO || SC == HLL_SC_REG) {
ObjWriteVar (S->Offs);
}
ObjWriteVar (S->Type);
ObjWriteVar (S->ScopeId);
ObjWriteVar (S->Scope->Id);
}
} else {

3
src/ca65/dbginfo.h
View File

@@ -56,6 +56,9 @@ void DbgInfoLine (void);
void DbgInfoSym (void);
/* Parse and handle SYM subcommand of the .dbg pseudo instruction */
void DbgInfoCheck (void);
/* Do checks on all hll debug info symbols when assembly is complete */
void WriteHLLDbgSyms (void);
/* Write a list of all high level language symbols to the object file. */

14
src/ca65/error.c
View File

@@ -280,6 +280,20 @@ void Error (const char* Format, ...)
void PError (const FilePos* Pos, const char* Format, ...)
/* Print an error message giving an explicit file and position. */
{
va_list ap;
va_start (ap, Format);
VPrintMsg (Pos, "Error", Format, ap);
va_end (ap);
/* Count errors */
++ErrorCount;
}
void LIError (const Collection* LineInfos, const char* Format, ...)
/* Print an error message using the given line infos. */
{

3
src/ca65/error.h
View File

@@ -78,6 +78,9 @@ void LIWarning (const Collection* LineInfos, unsigned Level, const char* Format,
void Error (const char* Format, ...) attribute ((format (printf, 1, 2)));
/* Print an error message */
void PError (const FilePos* Pos, const char* Format, ...) attribute ((format (printf, 2, 3)));
/* Print an error message giving an explicit file and position. */
void LIError (const Collection* LineInfos, const char* Format, ...) attribute ((format (printf, 2, 3)));
/* Print an error message using the given line infos. */

6
src/ca65/main.c
View File

@@ -53,6 +53,7 @@
/* ca65 */
#include "abend.h"
#include "asserts.h"
#include "dbginfo.h"
#include "error.h"
#include "expr.h"
#include "feature.h"
@@ -1028,6 +1029,11 @@ int main (int argc, char* argv [])
SymCheck ();
}
/* If we didn't have any errors, check the hll debug symbols */
if (ErrorCount == 0) {
DbgInfoCheck ();
}
/* If we didn't have any errors, close the file scope lexical level */
if (ErrorCount == 0) {
SymLeaveLevel ();

3
src/ca65/symentry.c
View File

@@ -90,7 +90,8 @@ SymEntry* NewSymEntry (const StrBuf* Name, unsigned Flags)
S->RefLines = EmptyCollection;
for (I = 0; I < sizeof (S->GuessedUse) / sizeof (S->GuessedUse[0]); ++I) {
S->GuessedUse[I] = 0;
}
}
S->HLLSym = 0;
S->Flags = Flags;
S->DebugSymId = ~0U;
S->ImportId = ~0U;

8
src/ca65/symentry.h
View File

@@ -56,9 +56,12 @@
/* Forwards */
struct HLLDbgSym;
/* Bits for the Flags value in SymEntry */
#define SF_NONE 0x0000 /* Empty flag set */
#define SF_USER 0x0001 /* User bit */
#define SF_USER 0x0001 /* User bit */
#define SF_UNUSED 0x0002 /* Unused entry */
#define SF_EXPORT 0x0004 /* Export this symbol */
#define SF_IMPORT 0x0008 /* Import this symbol */
@@ -87,7 +90,7 @@ struct SymEntry {
SymEntry* Locals; /* Root of subtree for local symbols */
union {
struct SymTable* Tab; /* Table this symbol is in */
struct SymEntry* Entry;
struct SymEntry* Entry; /* Parent for cheap locals */
} Sym;
Collection DefLines; /* Line infos for definition */
Collection RefLines; /* Line infos for references */
@@ -97,6 +100,7 @@ struct SymEntry {
* used. Currently only for zero page
* addressing
*/
struct HLLDbgSym* HLLSym; /* Symbol from high level language */
unsigned Flags; /* Symbol flags */
unsigned DebugSymId; /* Debug symbol id */
unsigned ImportId; /* Id of import if this is one */

21
src/ca65/symtab.c
View File

@@ -419,15 +419,22 @@ SymEntry* SymFindAny (SymTable* Scope, const StrBuf* Name)
{
SymEntry* Sym;
do {
/* Search in the current table */
Sym = SymFind (Scope, Name, SYM_FIND_EXISTING);
if (Sym) {
/* Found, return it */
break;
}
/* Search in the current table. Ignore entries flagged with SF_UNUSED,
* because for such symbols there is a real entry in one of the parent
* scopes.
*/
Sym = SymFind (Scope, Name, SYM_FIND_EXISTING);
if (Sym) {
if (Sym->Flags & SF_UNUSED) {
Sym = 0;
} else {
/* Found, return it */
break;
}
}
/* Not found, search in the parent scope, if we have one */
Scope = Scope->Parent;
Scope = Scope->Parent;
} while (Sym == 0 && Scope != 0);

1
src/ca65/symtab.h
View File

@@ -58,7 +58,6 @@
/* Symbol table flags */
#define ST_NONE 0x00 /* No flags */
#define ST_DEFINED 0x01 /* Scope has been defined */
#define ST_EXTFUNC 0x02 /* External debug function assigned */
/* A symbol table */
typedef struct SymTable SymTable;