Write imports out to the debug info file. Add the id of the corresponding

export.


git-svn-id: svn://svn.cc65.org/cc65/trunk@5186 b7a2c559-68d2-44c3-8de9-860c34a00d81

src/ld65/dbgsyms.c

@@ -44,6 +44,7 @@
 /* ld65 */
 #include "dbgsyms.h"
 #include "error.h"
+#include "exports.h"
 #include "expr.h"
 #include "fileio.h"
 #include "global.h"
@@ -59,6 +60,21 @@
 
 
 
+/* Definition of the debug symbol structure */
+struct DbgSym {
+    unsigned            Id;             /* Id of debug symbol */
+    DbgSym*    	       	Next;  		/* Pool linear list link */
+    ObjData*   		Obj;	    	/* Object file that exports the name */
+    Collection          LineInfos;      /* Line infos of definition */
+    ExprNode*  		Expr;		/* Expression (0 if not def'd) */
+    unsigned            Size;           /* Symbol size if any */
+    unsigned            OwnerId;        /* Id of parent/owner */
+    unsigned            ImportId;       /* Id of import if this is one */
+    unsigned            Name;  	       	/* Name */
+    unsigned short      Type;		/* Type of symbol */
+    unsigned short      AddrSize;       /* Address size of symbol */
+};
+
 /* We will collect all debug symbols in the following array and remove
  * duplicates before outputing them.
  */
@@ -72,22 +88,25 @@ static DbgSym*	DbgSymPool[256];
 
 
 
-static DbgSym* NewDbgSym (unsigned Type, unsigned char AddrSize, ObjData* O)
+static DbgSym* NewDbgSym (unsigned Id, unsigned Type, unsigned char AddrSize,
+                          ObjData* O)
 /* Create a new DbgSym and return it */
 {
     /* Allocate memory */
-    DbgSym* D    = xmalloc (sizeof (DbgSym));
+    DbgSym* D     = xmalloc (sizeof (DbgSym));
 
     /* Initialize the fields */
-    D->Next      = 0;
+    D->Id         = Id;
-    D->Obj       = O;
+    D->Next       = 0;
-    D->LineInfos = EmptyCollection;
+    D->Obj        = O;
-    D->Expr    	 = 0;
+    D->LineInfos  = EmptyCollection;
-    D->Size      = 0;
+    D->Expr    	  = 0;
-    D->OwnerId   = ~0U;
+    D->Size       = 0;
-    D->Name 	 = 0;
+    D->OwnerId    = ~0U;
-    D->Type    	 = Type;
+    D->ImportId   = ~0U;
-    D->AddrSize  = AddrSize;
+    D->Name 	  = 0;
+    D->Type    	  = Type;
+    D->AddrSize   = AddrSize;
 
     /* Return the new entry */
     return D;
@@ -141,7 +160,7 @@ static void InsertDbgSym (DbgSym* D, long Val)
 
 
 
-DbgSym* ReadDbgSym (FILE* F, ObjData* O)
+DbgSym* ReadDbgSym (FILE* F, ObjData* O, unsigned Id)
 /* Read a debug symbol from a file, insert and return it */
 {
     /* Read the type and address size */
@@ -149,7 +168,7 @@ DbgSym* ReadDbgSym (FILE* F, ObjData* O)
     unsigned char AddrSize = Read8 (F);
 
     /* Create a new debug symbol */
-    DbgSym* D = NewDbgSym (Type, AddrSize, O);
+    DbgSym* D = NewDbgSym (Id, Type, AddrSize, O);
 
     /* Read the id of the owner scope/symbol */
     D->OwnerId = ReadVar (F);
@@ -169,6 +188,19 @@ DbgSym* ReadDbgSym (FILE* F, ObjData* O)
         D->Size = ReadVar (F);
     }
 
+    /* If this is an import, the file contains its id */
+    if (SYM_IS_IMPORT (D->Type)) {
+        D->ImportId = ReadVar (F);
+    }
+
+    /* If its an exports, there's also the export id, but we don't remember
+     * it but use it to let the export point back to us.
+     */
+    if (SYM_IS_EXPORT (D->Type)) {
+        /* Get the export from the export id, then set the our id */
+        GetObjExport (O, ReadVar (F))->DbgSymId = Id;
+    }
+
     /* Last is the list of line infos for this symbol */
     ReadLineInfoList (F, O, &D->LineInfos);
 
@@ -195,7 +227,7 @@ void ClearDbgSymTable (void)
 
 
 
-long GetDbgSymVal (const DbgSym* D)
+static long GetDbgSymVal (const DbgSym* D)
 /* Get the value of this symbol */
 {
     CHECK (D->Expr != 0);
@@ -203,7 +235,7 @@ long GetDbgSymVal (const DbgSym* D)
 }
 
 
-             
+
 void PrintDbgSyms (FILE* F)
 /* Print the debug symbols in a debug file */
 {
@@ -212,40 +244,56 @@ void PrintDbgSyms (FILE* F)
     for (I = 0; I < CollCount (&ObjDataList); ++I) {
 
         /* Get the object file */
-        const ObjData* O = CollAtUnchecked (&ObjDataList, I);
+        ObjData* O = CollAtUnchecked (&ObjDataList, I);
 
         /* Walk through all debug symbols in this module */
         for (J = 0; J < CollCount (&O->DbgSyms); ++J) {
 
-            long Val;
-            SegExprDesc D;
-
             /* Get the next debug symbol */
             const DbgSym* S = CollConstAt (&O->DbgSyms, J);
 
-            /* Get the symbol value */
-            Val = GetDbgSymVal (S);
-
             /* Emit the base data for the entry */
             fprintf (F,
-                     "sym\tid=%u,name=\"%s\",val=0x%lX,addrsize=%s,type=%s",
+                     "sym\tid=%u,name=\"%s\",addrsize=%s,type=%s",
                      O->SymBaseId + J,
                      GetString (S->Name),
-                     Val,
                      AddrSizeToStr (S->AddrSize),
                      SYM_IS_LABEL (S->Type)? "lab" : "equ");
 
-            /* Emit the size only if we know it */
+            /* If this is not an import, output its value and - if we have
-            if (S->Size != 0) {
+             * it - the segment.
-                fprintf (F, ",size=%lu", S->Size);
+             */
+            if (!SYM_IS_IMPORT (S->Type)) {
+
+                SegExprDesc D;
+
+                /* Get the symbol value */
+                long Val = GetDbgSymVal (S);
+
+                /* Output it */
+                fprintf (F, ",val=0x%lX", Val);
+
+                /* Check for a segmented expression and add the segment id to
+                 * the debug info if we have one.
+                 */
+                GetSegExprVal (S->Expr, &D);
+                if (!D.TooComplex && D.Seg != 0) {
+                    fprintf (F, ",seg=%u", D.Seg->Id);
+                }
+
+                /* Output the type */
+                fprintf (F, ",type=%s", SYM_IS_LABEL (S->Type)? "lab" : "equ");
+
+            } else {
+
+                /* Output the type */
+                fputs (",type=imp", F);
+
             }
 
-            /* Check for a segmented expression and add the segment id to the
+            /* Emit the size only if we know it */
-             * debug info if we have one.
+            if (S->Size != 0) {
-             */
+                fprintf (F, ",size=%u", S->Size);
-            GetSegExprVal (S->Expr, &D);
-            if (!D.TooComplex && D.Seg != 0) {
-                fprintf (F, ",seg=%u", D.Seg->Id);
             }
 
             /* For cheap local symbols, add the owner symbol, for others,
@@ -257,6 +305,23 @@ void PrintDbgSyms (FILE* F)
                 fprintf (F, ",parent=%u", O->SymBaseId + S->OwnerId);
             }
 
+            /* If this is an import, output the id of the matching export */
+            if (SYM_IS_IMPORT (S->Type)) {
+
+                /* Get the import */
+                const Import* Imp = GetObjImport (O, S->ImportId);
+
+                /* Get the export from the import */
+                const Export* Exp = Imp->Exp;
+
+                /* If this is not a linker generated symbol, output the debug
+                 * symbol id for the export
+                 */
+                if (Exp->Obj) {
+                    fprintf (F, ",exp=%u", Exp->Obj->SymBaseId + Exp->DbgSymId);
+                }
+            }
+
             /* Terminate the output line */
             fputc ('\n', F);
         }
@@ -278,25 +343,25 @@ void PrintDbgSymLabels (ObjData* O, FILE* F)
 	/* Get the next debug symbol */
  	DbgSym* D = CollAt (&O->DbgSyms, I);
 
-        /* Emit this symbol only if it is a label (ignore equates) */
+        /* Emit this symbol only if it is a label (ignore equates and imports) */
-        if (SYM_IS_EQUATE (D->Type)) {
+        if (SYM_IS_EQUATE (D->Type) || SYM_IS_IMPORT (D->Type)) {
             continue;
         }
 
-	/* Get the symbol value */
+       	/* Get the symbol value */
-	Val = GetDbgSymVal (D);
+       	Val = GetDbgSymVal (D);
 
-	/* Lookup this symbol in the table. If it is found in the table, it was
+       	/* Lookup this symbol in the table. If it is found in the table, it was
-	 * already written to the file, so don't emit it twice. If it is not in
+       	 * already written to the file, so don't emit it twice. If it is not in
-	 * the table, insert and output it.
+       	 * the table, insert and output it.
-	 */
+       	 */
        	if (GetDbgSym (D, Val) == 0) {
 
-	    /* Emit the VICE label line */
+       	    /* Emit the VICE label line */
        	    fprintf (F, "al %06lX .%s\n", Val, GetString (D->Name));
 
-	    /* Insert the symbol into the table */
+       	    /* Insert the symbol into the table */
-	    InsertDbgSym (D, Val);
+       	    InsertDbgSym (D, Val);
        	}
     }
 }

src/ld65/dbgsyms.h

@@ -58,34 +58,20 @@
 /* Forwards */
 struct Scope;
 
-/* Debug symbol structure */
+/* Opaque debug symbol structure */
 typedef struct DbgSym DbgSym;
-struct DbgSym {
-    DbgSym*    	       	Next;  		/* Pool linear list link */
-    ObjData*   		Obj;	    	/* Object file that exports the name */
-    Collection          LineInfos;      /* Line infos of definition */
-    ExprNode*  		Expr;		/* Expression (0 if not def'd) */
-    unsigned            Size;           /* Symbol size if any */
-    unsigned            OwnerId;        /* Id of parent/owner */
-    unsigned            Name;  	       	/* Name */
-    unsigned short      Type;		/* Type of symbol */
-    unsigned short      AddrSize;       /* Address size of symbol */
-};
 
 
 
 /*****************************************************************************/
-/*     	      	    		     Code			       	     */
+/*     	      	    		     Code	      		       	     */
 /*****************************************************************************/
 
 
 
-DbgSym* ReadDbgSym (FILE* F, ObjData* Obj);
+DbgSym* ReadDbgSym (FILE* F, ObjData* Obj, unsigned Id);
 /* Read a debug symbol from a file, insert and return it */
 
-long GetDbgSymVal (const DbgSym* D);
-/* Get the value of this symbol */
-
 void ClearDbgSymTable (void);
 /* Clear the debug symbol table. Must be called before outputting debug syms
  * or debug labels the first time.

src/ld65/exports.c

@@ -41,6 +41,7 @@
 #include "addrsize.h"
 #include "check.h"
 #include "hashfunc.h"
+#include "lidefs.h"
 #include "symdefs.h"
 #include "xmalloc.h"
 
@@ -232,7 +233,7 @@ Import* InsertImport (Import* I)
     if (HashTab[Hash] == 0) {
     	/* The slot is empty, we need to insert a dummy export */
        	E = HashTab[Hash] = NewExport (0, ADDR_SIZE_DEFAULT, Name, 0);
-	++ExpCount;
+       	++ExpCount;
     } else {
     	E = HashTab [Hash];
     	while (1) {
@@ -274,11 +275,21 @@ Import* InsertImport (Import* I)
 
 
 
-const LineInfo* GetImportPos (const Import* I)
+const LineInfo* GetImportPos (const Import* Imp)
 /* Return the basic line info of an import */
 {
-    /* Source file position is always in slot zero */
+    unsigned I;
-    return CollConstAt (&I->LineInfos, 0);
+
+    /* Search for a line info of LI_TYPE_ASM */
+    for (I = 0; I < CollCount (&Imp->LineInfos); ++I) {
+        const LineInfo* LI = CollConstAt (&Imp->LineInfos, I);
+        if (LI_GET_TYPE (LI->Type) == LI_TYPE_ASM) {
+            return LI;
+        }
+    }
+
+    /* Not found - return the one in slot zero */
+    return CollConstAt (&Imp->LineInfos, 0);
 }
 
 
@@ -306,6 +317,7 @@ static Export* NewExport (unsigned Type, unsigned char AddrSize,
     E->Expr    	 = 0;
     E->Size      = 0;
     E->LineInfos = EmptyCollection;
+    E->DbgSymId  = ~0U;
     E->Type    	 = Type | SYM_EXPORT;
     E->AddrSize  = AddrSize;
     memset (E->ConDes, 0, sizeof (E->ConDes));

src/ld65/exports.h

@@ -85,6 +85,7 @@ struct Export {
     ExprNode*  		Expr;		/* Expression (0 if not def'd) */
     unsigned            Size;           /* Size of the symbol if any */
     Collection          LineInfos;      /* Line info of definition */
+    unsigned            DbgSymId;       /* Id of debug symbol for this export */
     unsigned short      Type;		/* Type of export */
     unsigned short      AddrSize;       /* Address size of export */
     unsigned char	ConDes[CD_TYPE_COUNT];	/* Constructor/destructor decls */

src/ld65/expr.c

@@ -201,8 +201,8 @@ Import* GetExprImport (ExprNode* Expr)
      * import pointer.
      */
     if (Expr->Obj) {
-	/* Return the export */
+	/* Return the Import */
-       	return CollAt (&Expr->Obj->Imports, Expr->V.ImpNum);
+       	return GetObjImport (Expr->Obj, Expr->V.ImpNum);
     } else {
 	return Expr->V.Imp;
     }

src/ld65/objdata.c

@@ -211,6 +211,30 @@ struct Section* GetObjSection (ObjData* O, unsigned Id)
 
 
 
+struct Import* GetObjImport (ObjData* O, unsigned Id)
+/* Get an import from an object file checking for a valid index */
+{
+    if (Id >= CollCount (&O->Imports)) {
+        Error ("Invalid import index (%u) in module `%s'",
+               Id, GetObjFileName (O));
+    }
+    return CollAtUnchecked (&O->Imports, Id);
+}
+
+
+
+struct Export* GetObjExport (ObjData* O, unsigned Id)
+/* Get an export from an object file checking for a valid index */
+{
+    if (Id >= CollCount (&O->Exports)) {
+        Error ("Invalid export index (%u) in module `%s'",
+               Id, GetObjFileName (O));
+    }
+    return CollAtUnchecked (&O->Exports, Id);
+}
+
+
+
 struct Scope* GetObjScope (ObjData* O, unsigned Id)
 /* Get a scope from an object file checking for a valid index */
 {

src/ld65/objdata.h

@@ -52,6 +52,8 @@
 
 
 /* Forwards */
+struct Export;
+struct Import;
 struct Library;
 struct Scope;
 struct Section;
@@ -144,6 +146,12 @@ INLINE int ObjHasFiles (const ObjData* O)
 struct Section* GetObjSection (ObjData* Obj, unsigned Id);
 /* Get a section from an object file checking for a valid index */
 
+struct Import* GetObjImport (ObjData* Obj, unsigned Id);
+/* Get an import from an object file checking for a valid index */
+
+struct Export* GetObjExport (ObjData* Obj, unsigned Id);
+/* Get an export from an object file checking for a valid index */
+
 struct Scope* GetObjScope (ObjData* Obj, unsigned Id);
 /* Get a scope from an object file checking for a valid index */
 

src/ld65/objfile.c

@@ -200,7 +200,7 @@ void ObjReadDbgSyms (FILE* F, unsigned long Pos, ObjData* O)
     DbgSymCount = ReadVar (F);
     CollGrow (&O->DbgSyms, DbgSymCount);
     for (I = 0; I < DbgSymCount; ++I) {
-	CollAppend (&O->DbgSyms, ReadDbgSym (F, O));
+	CollAppend (&O->DbgSyms, ReadDbgSym (F, O, I));
     }
 }
 
@@ -276,7 +276,7 @@ void ObjReadScopes (FILE* F, unsigned long Pos, ObjData* O)
     CollGrow (&O->Scopes, ScopeCount);
     for (I = 0; I < ScopeCount; ++I) {
         CollAppend (&O->Scopes,  ReadScope (F, O, I));
-    }   
+    }
 }