/*****************************************************************************/
/* */
-/* exports.c */
+/* exports.c */
/* */
-/* Exports handing for the ld65 linker */
+/* Exports handling for the ld65 linker */
/* */
/* */
/* */
-/* (C) 1998 Ullrich von Bassewitz */
-/* Wacholderweg 14 */
-/* D-70597 Stuttgart */
-/* EMail: uz@musoftware.de */
+/* (C) 1998-2013, Ullrich von Bassewitz */
+/* Roemerstrasse 52 */
+/* D-70794 Filderstadt */
+/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
#include <string.h>
/* common */
+#include "addrsize.h"
#include "check.h"
-#include "hashstr.h"
+#include "hashfunc.h"
+#include "lidefs.h"
#include "symdefs.h"
#include "xmalloc.h"
/* ld65 */
-#include "global.h"
+#include "condes.h"
#include "error.h"
+#include "exports.h"
+#include "expr.h"
#include "fileio.h"
+#include "global.h"
+#include "lineinfo.h"
+#include "memarea.h"
#include "objdata.h"
-#include "expr.h"
-#include "exports.h"
+#include "spool.h"
/*****************************************************************************/
-/* Data */
+/* Data */
/*****************************************************************************/
/* Hash table */
-#define HASHTAB_SIZE 4081
-static Export* HashTab [HASHTAB_SIZE];
+#define HASHTAB_MASK 0x0FFFU
+#define HASHTAB_SIZE (HASHTAB_MASK + 1)
+static Export* HashTab[HASHTAB_SIZE];
/* Import management variables */
-static unsigned ImpCount = 0; /* Import count */
-static unsigned ImpOpen = 0; /* Count of open imports */
+static unsigned ImpCount = 0; /* Import count */
+static unsigned ImpOpen = 0; /* Count of open imports */
/* Export management variables */
-static unsigned ExpCount = 0; /* Export count */
-static Export** ExpPool = 0; /* Exports array */
+static unsigned ExpCount = 0; /* Export count */
+static Export** ExpPool = 0; /* Exports array */
+
+/* Defines for the flags in Import */
+#define IMP_INLIST 0x0001U /* Import is in exports list */
/* Defines for the flags in Export */
-#define EXP_USERMARK 0x0001
+#define EXP_INLIST 0x0001U /* Export is in exports list */
+#define EXP_USERMARK 0x0002U /* User setable flag */
/*****************************************************************************/
-/* Import handling */
+/* Import handling */
/*****************************************************************************/
-static Export* NewExport (unsigned char Type, const char* Name, ObjData* Obj);
+static Export* NewExport (unsigned Type, unsigned char AddrSize,
+ unsigned Name, ObjData* Obj);
/* Create a new export and initialize it */
-static Import* NewImport (unsigned char Type, ObjData* Obj)
+static Import* NewImport (unsigned char AddrSize, ObjData* Obj)
/* Create a new import and initialize it */
{
/* Allocate memory */
- Import* I = xmalloc (sizeof (Import));
+ Import* I = xmalloc (sizeof (Import));
/* Initialize the fields */
- I->Next = 0;
- I->Obj = Obj;
- I->V.Name = 0;
- I->Type = Type;
+ I->Next = 0;
+ I->Obj = Obj;
+ I->DefLines = EmptyCollection;
+ I->RefLines = EmptyCollection;
+ I->Exp = 0;
+ I->Name = INVALID_STRING_ID;
+ I->Flags = 0;
+ I->AddrSize = AddrSize;
/* Return the new structure */
return I;
-void InsertImport (Import* I)
-/* Insert an import into the table */
+void FreeImport (Import* I)
+/* Free an import. NOTE: This won't remove the import from the exports table,
+ * so it may only be called for unused imports (imports from modules that
+ * aren't referenced).
+ */
+{
+ /* Safety */
+ PRECONDITION ((I->Flags & IMP_INLIST) == 0);
+
+ /* Free the line info collections */
+ DoneCollection (&I->DefLines);
+ DoneCollection (&I->RefLines);
+
+ /* Free the struct */
+ xfree (I);
+}
+
+
+
+Import* ReadImport (FILE* F, ObjData* Obj)
+/* Read an import from a file and return it */
+{
+ Import* I;
+
+ /* Read the import address size */
+ unsigned char AddrSize = Read8 (F);
+
+ /* Create a new import */
+ I = NewImport (AddrSize, Obj);
+
+ /* Read the name */
+ I->Name = MakeGlobalStringId (Obj, ReadVar (F));
+
+ /* Read the line infos */
+ ReadLineInfoList (F, Obj, &I->DefLines);
+ ReadLineInfoList (F, Obj, &I->RefLines);
+
+ /* Check the address size */
+ if (I->AddrSize == ADDR_SIZE_DEFAULT || I->AddrSize > ADDR_SIZE_LONG) {
+ /* Beware: This function may be called in cases where the object file
+ * is not read completely into memory. In this case, the file list is
+ * invalid. Be sure not to access it in this case.
+ */
+ if (ObjHasFiles (I->Obj)) {
+ const LineInfo* LI = GetImportPos (I);
+ Error ("Invalid import size in for `%s', imported from %s(%u): 0x%02X",
+ GetString (I->Name),
+ GetSourceName (LI),
+ GetSourceLine (LI),
+ I->AddrSize);
+ } else {
+ Error ("Invalid import size in for `%s', imported from %s: 0x%02X",
+ GetString (I->Name),
+ GetObjFileName (I->Obj),
+ I->AddrSize);
+ }
+ }
+
+ /* Return the new import */
+ return I;
+}
+
+
+
+Import* GenImport (unsigned Name, unsigned char AddrSize)
+/* Generate a new import with the given name and address size and return it */
+{
+ /* Create a new import */
+ Import* I = NewImport (AddrSize, 0);
+
+ /* Read the name */
+ I->Name = Name;
+
+ /* Check the address size */
+ if (I->AddrSize == ADDR_SIZE_DEFAULT || I->AddrSize > ADDR_SIZE_LONG) {
+ /* We have no object file information and no line info for a new
+ * import
+ */
+ Error ("Invalid import size 0x%02X for symbol `%s'",
+ I->AddrSize,
+ GetString (I->Name));
+ }
+
+ /* Return the new import */
+ return I;
+}
+
+
+
+Import* InsertImport (Import* I)
+/* Insert an import into the table, return I */
{
Export* E;
- unsigned HashVal;
/* As long as the import is not inserted, V.Name is valid */
- const char* Name = I->V.Name;
+ unsigned Name = I->Name;
/* Create a hash value for the given name */
- HashVal = HashStr (Name) % HASHTAB_SIZE;
+ unsigned Hash = (Name & HASHTAB_MASK);
- /* Search through the list in that slot and print matching duplicates */
- if (HashTab [HashVal] == 0) {
- /* The slot is empty, we need to insert a dummy export */
- E = HashTab [HashVal] = NewExport (0, Name, 0);
- ++ExpCount;
+ /* Search through the list in that slot for a symbol with that name */
+ 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;
} else {
- E = HashTab [HashVal];
- while (1) {
- if (strcmp (E->Name, Name) == 0) {
- /* We have an entry, L points to it */
- break;
- }
- if (E->Next == 0) {
- /* End of list an entry not found, insert a dummy */
- E->Next = NewExport (0, Name, 0);
- E = E->Next; /* Point to dummy */
- ++ExpCount; /* One export more */
- break;
- } else {
- E = E->Next;
- }
- }
+ E = HashTab [Hash];
+ while (1) {
+ if (E->Name == Name) {
+ /* We have an entry, L points to it */
+ break;
+ }
+ if (E->Next == 0) {
+ /* End of list an entry not found, insert a dummy */
+ E->Next = NewExport (0, ADDR_SIZE_DEFAULT, Name, 0);
+ E = E->Next; /* Point to dummy */
+ ++ExpCount; /* One export more */
+ break;
+ } else {
+ E = E->Next;
+ }
+ }
}
/* Ok, E now points to a valid exports entry for the given import. Insert
* the import into the imports list and update the counters.
*/
- I->V.Exp = E;
+ I->Exp = E;
I->Next = E->ImpList;
E->ImpList = I;
E->ImpCount++;
- ++ImpCount; /* Total import count */
+ ++ImpCount; /* Total import count */
if (E->Expr == 0) {
- /* This is a dummy export */
- ++ImpOpen;
+ /* This is a dummy export */
+ ++ImpOpen;
}
- /* Now free the name since it's no longer needed */
- xfree (Name);
+ /* Mark the import so we know it's in the list */
+ I->Flags |= IMP_INLIST;
+
+ /* Return the import to allow shorter code */
+ return I;
}
-Import* ReadImport (FILE* F, ObjData* Obj)
-/* Read an import from a file and return it */
+const LineInfo* GetImportPos (const Import* Imp)
+/* Return the basic line info of an import */
{
- Import* I;
-
- /* Read the import type and check it */
- unsigned char Type = Read8 (F);
- if (Type != IMP_ZP && Type != IMP_ABS) {
- Error ("Unknown import type in module `%s': %02X", Obj->Name, Type);
+ /* Search in DefLines, then in RefLines */
+ const LineInfo* LI = GetAsmLineInfo (&Imp->DefLines);
+ if (LI == 0) {
+ LI = GetAsmLineInfo (&Imp->RefLines);
}
-
- /* Create a new import */
- I = NewImport (Type, Obj);
-
- /* Read the name */
- I->V.Name = ReadStr (F);
-
- /* Read the file position */
- ReadFilePos (F, &I->Pos);
-
- /* Return the new import */
- return I;
+ return LI;
}
/*****************************************************************************/
-/* Code */
+/* Code */
/*****************************************************************************/
-static Export* NewExport (unsigned char Type, const char* Name, ObjData* Obj)
+static Export* NewExport (unsigned Type, unsigned char AddrSize,
+ unsigned Name, ObjData* Obj)
/* Create a new export and initialize it */
{
+ unsigned I;
+
/* Allocate memory */
Export* E = xmalloc (sizeof (Export));
/* Initialize the fields */
- E->Next = 0;
- E->Flags = 0;
- E->Obj = Obj;
- E->ImpCount = 0;
- E->ImpList = 0;
- E->Expr = 0;
- E->Type = Type;
- if (Name) {
- E->Name = xstrdup (Name);
- } else {
- /* Name will get added later */
- E->Name = 0;
+ E->Name = Name;
+ E->Next = 0;
+ E->Flags = 0;
+ E->Obj = Obj;
+ E->ImpCount = 0;
+ E->ImpList = 0;
+ E->Expr = 0;
+ E->Size = 0;
+ E->DefLines = EmptyCollection;
+ E->RefLines = EmptyCollection;
+ E->DbgSymId = ~0U;
+ E->Type = Type | SYM_EXPORT;
+ E->AddrSize = AddrSize;
+ for (I = 0; I < sizeof (E->ConDes) / sizeof (E->ConDes[0]); ++I) {
+ E->ConDes[I] = CD_PRIO_NONE;
}
/* Return the new entry */
-void InsertExport (Export* E)
-/* Insert an exported identifier and check if it's already in the list */
+void FreeExport (Export* E)
+/* Free an export. NOTE: This won't remove the export from the exports table,
+ * so it may only be called for unused exports (exports from modules that
+ * aren't referenced).
+ */
{
- Export* L;
- Export* Last;
- Import* Imp;
- unsigned HashVal;
+ /* Safety */
+ PRECONDITION ((E->Flags & EXP_INLIST) == 0);
- /* Create a hash value for the given name */
- HashVal = HashStr (E->Name) % HASHTAB_SIZE;
+ /* Free the line infos */
+ DoneCollection (&E->DefLines);
+ DoneCollection (&E->RefLines);
- /* Search through the list in that slot */
- if (HashTab [HashVal] == 0) {
- /* The slot is empty */
- HashTab [HashVal] = E;
- ++ExpCount;
- } else {
+ /* Free the export expression */
+ FreeExpr (E->Expr);
- Last = 0;
- L = HashTab [HashVal];
- do {
- if (strcmp (L->Name, E->Name) == 0) {
- /* This may be an unresolved external */
- if (L->Expr == 0) {
-
- /* This *is* an unresolved external */
- E->Next = L->Next;
- E->ImpCount = L->ImpCount;
- E->ImpList = L->ImpList;
- if (Last) {
- Last->Next = E;
- } else {
- HashTab [HashVal] = E;
- }
- ImpOpen -= E->ImpCount; /* Decrease open imports now */
- xfree (L);
- /* We must run through the import list and change the
- * export pointer now.
- */
- Imp = E->ImpList;
- while (Imp) {
- Imp->V.Exp = E;
- Imp = Imp->Next;
- }
- } else {
- /* Duplicate entry, ignore it */
- Warning ("Duplicate external identifier: `%s'", L->Name);
- }
- return;
- }
- Last = L;
- L = L->Next;
-
- } while (L);
-
- /* Insert export at end of queue */
- Last->Next = E;
- ++ExpCount;
- }
+ /* Free the struct */
+ xfree (E);
}
Export* ReadExport (FILE* F, ObjData* O)
/* Read an export from a file */
{
- unsigned char Type;
- Export* E;
+ unsigned ConDesCount;
+ unsigned I;
+ Export* E;
/* Read the type */
- Type = Read8 (F);
+ unsigned Type = ReadVar (F);
+
+ /* Read the address size */
+ unsigned char AddrSize = Read8 (F);
/* Create a new export without a name */
- E = NewExport (Type, 0, O);
+ E = NewExport (Type, AddrSize, INVALID_STRING_ID, O);
+
+ /* Read the constructor/destructor decls if we have any */
+ ConDesCount = SYM_GET_CONDES_COUNT (Type);
+ if (ConDesCount > 0) {
+
+ unsigned char ConDes[CD_TYPE_COUNT];
+
+ /* Read the data into temp storage */
+ ReadData (F, ConDes, ConDesCount);
+
+ /* Re-order the data. In the file, each decl is encoded into a byte
+ * which contains the type and the priority. In memory, we will use
+ * an array of types which contain the priority.
+ */
+ for (I = 0; I < ConDesCount; ++I) {
+ E->ConDes[CD_GET_TYPE (ConDes[I])] = CD_GET_PRIO (ConDes[I]);
+ }
+ }
/* Read the name */
- E->Name = ReadStr (F);
+ E->Name = MakeGlobalStringId (O, ReadVar (F));
/* Read the value */
- if (Type & EXP_EXPR) {
- E->Expr = ReadExpr (F, O);
+ if (SYM_IS_EXPR (Type)) {
+ E->Expr = ReadExpr (F, O);
} else {
- E->Expr = LiteralExpr (Read32 (F), O);
+ E->Expr = LiteralExpr (Read32 (F), O);
}
- /* Last is the file position where the definition was done */
- ReadFilePos (F, &E->Pos);
+ /* Read the size */
+ if (SYM_HAS_SIZE (Type)) {
+ E->Size = ReadVar (F);
+ }
+
+ /* Last are the locations */
+ ReadLineInfoList (F, O, &E->DefLines);
+ ReadLineInfoList (F, O, &E->RefLines);
+
+ /* If this symbol is exported as a condes, and the condes type declares a
+ * forced import, add this import to the object module.
+ */
+ for (I = 0; I < CD_TYPE_COUNT; ++I) {
+ const ConDesImport* CDI;
+
+ if (E->ConDes[I] != CD_PRIO_NONE && (CDI = ConDesGetImport (I)) != 0) {
+ unsigned J;
+
+ /* Generate a new import, and add it to the module's import list. */
+ Import* Imp = GenImport (CDI->Name, CDI->AddrSize);
+
+ Imp->Obj = O;
+ CollAppend (&O->Imports, Imp);
+
+ /* Add line info for the export that is actually the condes that
+ * forces the import. Then, add line info for the config. file.
+ * The export's info is added first because the import pretends
+ * that it came from the object module instead of the config. file.
+ */
+ for (J = 0; J < CollCount (&E->DefLines); ++J) {
+ CollAppend (&Imp->RefLines, DupLineInfo (CollAt (&E->DefLines, J)));
+ }
+ CollAppend (&Imp->RefLines, GenLineInfo (&CDI->Pos));
+ }
+ }
/* Return the new export */
return E;
-Export* CreateConstExport (const char* Name, long Value)
+void InsertExport (Export* E)
+/* Insert an exported identifier and check if it's already in the list */
+{
+ Export* L;
+ Export* Last;
+ Import* Imp;
+ unsigned Hash;
+
+ /* Mark the export as inserted */
+ E->Flags |= EXP_INLIST;
+
+ /* Insert the export into any condes tables if needed */
+ if (SYM_IS_CONDES (E->Type)) {
+ ConDesAddExport (E);
+ }
+
+ /* Create a hash value for the given name */
+ Hash = (E->Name & HASHTAB_MASK);
+
+ /* Search through the list in that slot */
+ if (HashTab[Hash] == 0) {
+ /* The slot is empty */
+ HashTab[Hash] = E;
+ ++ExpCount;
+ } else {
+
+ Last = 0;
+ L = HashTab[Hash];
+ do {
+ if (L->Name == E->Name) {
+ /* This may be an unresolved external */
+ if (L->Expr == 0) {
+
+ /* This *is* an unresolved external. Use the actual export
+ * in E instead of the dummy one in L.
+ */
+ E->Next = L->Next;
+ E->ImpCount = L->ImpCount;
+ E->ImpList = L->ImpList;
+ if (Last) {
+ Last->Next = E;
+ } else {
+ HashTab[Hash] = E;
+ }
+ ImpOpen -= E->ImpCount; /* Decrease open imports now */
+ xfree (L);
+ /* We must run through the import list and change the
+ * export pointer now.
+ */
+ Imp = E->ImpList;
+ while (Imp) {
+ Imp->Exp = E;
+ Imp = Imp->Next;
+ }
+ } else {
+ /* Duplicate entry, ignore it */
+ Warning ("Duplicate external identifier: `%s'",
+ GetString (L->Name));
+ }
+ return;
+ }
+ Last = L;
+ L = L->Next;
+
+ } while (L);
+
+ /* Insert export at end of queue */
+ Last->Next = E;
+ ++ExpCount;
+ }
+}
+
+
+
+const LineInfo* GetExportPos (const Export* E)
+/* Return the basic line info of an export */
+{
+ /* Search in DefLines, then in RefLines */
+ const LineInfo* LI = GetAsmLineInfo (&E->DefLines);
+ if (LI == 0) {
+ LI = GetAsmLineInfo (&E->RefLines);
+ }
+ return LI;
+}
+
+
+
+Export* CreateConstExport (unsigned Name, long Value)
/* Create an export for a literal date */
{
/* Create a new export */
- Export* E = NewExport (EXP_ABS, Name, 0);
+ Export* E = NewExport (SYM_CONST|SYM_EQUATE, ADDR_SIZE_ABS, Name, 0);
/* Assign the value */
E->Expr = LiteralExpr (Value, 0);
-Export* CreateMemExport (const char* Name, Memory* Mem, unsigned long Offs)
+Export* CreateExprExport (unsigned Name, ExprNode* Expr, unsigned char AddrSize)
+/* Create an export for an expression */
+{
+ /* Create a new export */
+ Export* E = NewExport (SYM_EXPR|SYM_EQUATE, AddrSize, Name, 0);
+
+ /* Assign the value expression */
+ E->Expr = Expr;
+
+ /* Insert the export */
+ InsertExport (E);
+
+ /* Return the new export */
+ return E;
+}
+
+
+
+Export* CreateMemoryExport (unsigned Name, MemoryArea* Mem, unsigned long Offs)
/* Create an relative export for a memory area offset */
{
/* Create a new export */
- Export* E = NewExport (EXP_ABS, Name, 0);
+ Export* E = NewExport (SYM_EXPR | SYM_LABEL, ADDR_SIZE_ABS, Name, 0);
/* Assign the value */
- E->Expr = MemExpr (Mem, Offs, 0);
+ E->Expr = MemoryExpr (Mem, Offs, 0);
/* Insert the export */
InsertExport (E);
-static Export* FindExport (const char* Name)
+Export* CreateSegmentExport (unsigned Name, Segment* Seg, unsigned long Offs)
+/* Create a relative export to a segment */
+{
+ /* Create a new export */
+ Export* E = NewExport (SYM_EXPR | SYM_LABEL, Seg->AddrSize, Name, 0);
+
+ /* Assign the value */
+ E->Expr = SegmentExpr (Seg, Offs, 0);
+
+ /* Insert the export */
+ InsertExport (E);
+
+ /* Return the new export */
+ return E;
+}
+
+
+
+Export* CreateSectionExport (unsigned Name, Section* Sec, unsigned long Offs)
+/* Create a relative export to a section */
+{
+ /* Create a new export */
+ Export* E = NewExport (SYM_EXPR | SYM_LABEL, Sec->AddrSize, Name, 0);
+
+ /* Assign the value */
+ E->Expr = SectionExpr (Sec, Offs, 0);
+
+ /* Insert the export */
+ InsertExport (E);
+
+ /* Return the new export */
+ return E;
+}
+
+
+
+Export* FindExport (unsigned Name)
/* Check for an identifier in the list. Return 0 if not found, otherwise
* return a pointer to the export.
*/
{
/* Get a pointer to the list with the symbols hash value */
- Export* L = HashTab [HashStr (Name) % HASHTAB_SIZE];
+ Export* L = HashTab[Name & HASHTAB_MASK];
while (L) {
/* Search through the list in that slot */
- if (strcmp (L->Name, Name) == 0) {
- /* Entry found */
- return L;
- }
- L = L->Next;
+ if (L->Name == Name) {
+ /* Entry found */
+ return L;
+ }
+ L = L->Next;
}
/* Not found */
-int IsUnresolved (const char* Name)
+int IsUnresolved (unsigned Name)
/* Check if this symbol is an unresolved export */
{
/* Find the export */
- Export* E = FindExport (Name);
+ return IsUnresolvedExport (FindExport (Name));
+}
+
+
+int IsUnresolvedExport (const Export* E)
+/* Return true if the given export is unresolved */
+{
/* Check if it's unresolved */
return E != 0 && E->Expr == 0;
}
/* Return true if the expression associated with this export is const */
{
if (E->Expr == 0) {
- /* External symbols cannot be const */
- return 0;
+ /* External symbols cannot be const */
+ return 0;
} else {
return IsConstExpr (E->Expr);
}
/* Get the value of this export */
{
if (E->Expr == 0) {
- /* OOPS */
- Internal ("`%s' is an undefined external", E->Name);
+ /* OOPS */
+ Internal ("`%s' is an undefined external", GetString (E->Name));
}
return GetExprVal (E->Expr);
}
-static void CheckSymType (Export* E)
+static void CheckSymType (const Export* E)
/* Check the types for one export */
{
/* External with matching imports */
- Import* Imp = E->ImpList;
- int ZP = (E->Type & EXP_ZP) != 0;
- while (Imp) {
- if (ZP != ((Imp->Type & IMP_ZP) != 0)) {
- /* Export is ZP, import is abs or the other way round */
- if (E->Obj) {
- /* User defined export */
- Warning ("Type mismatch for `%s', export in "
- "%s(%lu), import in %s(%lu)",
- E->Name, E->Obj->Files [Imp->Pos.Name],
- E->Pos.Line, Imp->Obj->Files [Imp->Pos.Name],
- Imp->Pos.Line);
- } else {
- /* Export created by the linker */
- Warning ("Type mismatch for `%s', imported from %s(%lu)",
- E->Name, Imp->Obj->Files [Imp->Pos.Name],
- Imp->Pos.Line);
- }
- }
- Imp = Imp->Next;
+ Import* I = E->ImpList;
+ while (I) {
+ if (E->AddrSize != I->AddrSize) {
+ /* Export and import address sizes do not match */
+ StrBuf ExportLoc = STATIC_STRBUF_INITIALIZER;
+ StrBuf ImportLoc = STATIC_STRBUF_INITIALIZER;
+ const char* ExpAddrSize = AddrSizeToStr ((unsigned char) E->AddrSize);
+ const char* ImpAddrSize = AddrSizeToStr ((unsigned char) I->AddrSize);
+ const LineInfo* ExportLI = GetExportPos (E);
+ const LineInfo* ImportLI = GetImportPos (I);
+
+ /* Generate strings that describe the location of the im- and
+ * exports. This depends on the place from where they come:
+ * Object file or linker config.
+ */
+ if (E->Obj) {
+ /* The export comes from an object file */
+ SB_Printf (&ExportLoc, "%s, %s(%u)",
+ GetString (E->Obj->Name),
+ GetSourceName (ExportLI),
+ GetSourceLine (ExportLI));
+ } else {
+ SB_Printf (&ExportLoc, "%s(%u)",
+ GetSourceName (ExportLI),
+ GetSourceLine (ExportLI));
+ }
+ if (I->Obj) {
+ /* The import comes from an object file */
+ SB_Printf (&ImportLoc, "%s, %s(%u)",
+ GetString (I->Obj->Name),
+ GetSourceName (ImportLI),
+ GetSourceLine (ImportLI));
+ } else if (ImportLI) {
+ /* The import is linker generated and we have line
+ * information
+ */
+ SB_Printf (&ImportLoc, "%s(%u)",
+ GetSourceName (ImportLI),
+ GetSourceLine (ImportLI));
+ } else {
+ /* The import is linker generated and we don't have line
+ * information
+ */
+ SB_Printf (&ImportLoc, "%s", GetObjFileName (I->Obj));
+ }
+
+ /* Output the diagnostic */
+ Warning ("Address size mismatch for `%s': "
+ "Exported from %s as `%s', "
+ "import in %s as `%s'",
+ GetString (E->Name),
+ SB_GetConstBuf (&ExportLoc),
+ ExpAddrSize,
+ SB_GetConstBuf (&ImportLoc),
+ ImpAddrSize);
+
+ /* Free the temporary strings */
+ SB_Done (&ExportLoc);
+ SB_Done (&ImportLoc);
+ }
+ I = I->Next;
}
}
/* Print all open imports */
for (I = 0; I < ExpCount; ++I) {
- Export* E = ExpPool [I];
- if (E->Expr != 0 && E->ImpCount > 0) {
- /* External with matching imports */
- CheckSymType (E);
- }
+ const Export* E = ExpPool [I];
+ if (E->Expr != 0 && E->ImpCount > 0) {
+ /* External with matching imports */
+ CheckSymType (E);
+ }
}
}
/* Print all open imports */
for (I = 0; I < ExpCount; ++I) {
- Export* E = ExpPool [I];
- if (E->Expr == 0 && E->ImpCount > 0 && F (E->Name, Data) == 0) {
- /* Unresolved external */
- Import* Imp = E->ImpList;
- fprintf (stderr,
- "Unresolved external `%s' referenced in:\n",
- E->Name);
- while (Imp) {
- const char* Name = Imp->Obj->Files [Imp->Pos.Name];
- fprintf (stderr, " %s(%lu)\n", Name, Imp->Pos.Line);
- Imp = Imp->Next;
- }
- }
+ Export* E = ExpPool [I];
+ if (E->Expr == 0 && E->ImpCount > 0 && F (E->Name, Data) == 0) {
+ /* Unresolved external */
+ Import* Imp = E->ImpList;
+ fprintf (stderr,
+ "Unresolved external `%s' referenced in:\n",
+ GetString (E->Name));
+ while (Imp) {
+ unsigned J;
+ for (J = 0; J < CollCount (&Imp->RefLines); ++J) {
+ const LineInfo* LI = CollConstAt (&Imp->RefLines, J);
+ fprintf (stderr,
+ " %s(%u)\n",
+ GetSourceName (LI),
+ GetSourceLine (LI));
+ }
+ Imp = Imp->Next;
+ }
+ }
}
}
static int CmpExpName (const void* K1, const void* K2)
/* Compare function for qsort */
{
- return strcmp ((*(Export**)K1)->Name, (*(Export**)K2)->Name);
+ return SB_Compare (GetStrBuf ((*(Export**)K1)->Name),
+ GetStrBuf ((*(Export**)K2)->Name));
}
/* Allocate memory */
if (ExpPool) {
- xfree (ExpPool);
+ xfree (ExpPool);
}
ExpPool = xmalloc (ExpCount * sizeof (Export*));
/* Walk through the list and insert the exports */
for (I = 0, J = 0; I < sizeof (HashTab) / sizeof (HashTab [0]); ++I) {
- Export* E = HashTab [I];
- while (E) {
- CHECK (J < ExpCount);
- ExpPool [J++] = E;
- E = E->Next;
- }
+ Export* E = HashTab[I];
+ while (E) {
+ CHECK (J < ExpCount);
+ ExpPool[J++] = E;
+ E = E->Next;
+ }
}
/* Sort them by name */
-void CheckExports (ExpCheckFunc F, void* Data)
-/* Check if there are any unresolved symbols. On unresolved symbols, F is
- * called (see the comments on ExpCheckFunc in the data section).
+void CheckExports (void)
+/* Setup the list of all exports and check for export/import symbol type
+ * mismatches.
*/
{
/* Create an export pool */
/* Check for symbol type mismatches */
CheckSymTypes ();
+}
- /* Check for unresolved externals (check here for special bin formats) */
+
+
+void CheckUnresolvedImports (ExpCheckFunc F, void* Data)
+/* Check if there are any unresolved imports. On unresolved imports, F is
+ * called (see the comments on ExpCheckFunc in the data section).
+ */
+{
+ /* Check for unresolved externals */
if (ImpOpen != 0) {
- /* Print all open imports */
- PrintUnresolved (F, Data);
+ /* Print all open imports */
+ PrintUnresolved (F, Data);
+ }
+}
+
+
+
+static char GetAddrSizeCode (unsigned char AddrSize)
+/* Get a one char code for the address size */
+{
+ switch (AddrSize) {
+ case ADDR_SIZE_ZP: return 'Z';
+ case ADDR_SIZE_ABS: return 'A';
+ case ADDR_SIZE_FAR: return 'F';
+ case ADDR_SIZE_LONG: return 'L';
+ default:
+ Internal ("Invalid address size: %u", AddrSize);
+ /* NOTREACHED */
+ return '-';
}
}
/* Print all exports */
Count = 0;
for (I = 0; I < ExpCount; ++I) {
- Export* E = ExpPool [I];
-
- /* Print unreferenced symbols only if explictly requested */
- if (VerboseMap || E->ImpCount > 0) {
- fprintf (F,
- "%-25s %06lX %c%c ",
- E->Name,
- GetExportVal (E),
- E->ImpCount? 'R' : ' ',
- (E->Type & EXP_ZP)? 'Z' : ' ');
- if (++Count == 2) {
- Count = 0;
- fprintf (F, "\n");
- }
- }
+ const Export* E = ExpPool [I];
+
+ /* Print unreferenced symbols only if explictly requested */
+ if (VerboseMap || E->ImpCount > 0 || SYM_IS_CONDES (E->Type)) {
+ fprintf (F,
+ "%-25s %06lX %c%c%c%c ",
+ GetString (E->Name),
+ GetExportVal (E),
+ E->ImpCount? 'R' : ' ',
+ SYM_IS_LABEL (E->Type)? 'L' : 'E',
+ GetAddrSizeCode ((unsigned char) E->AddrSize),
+ SYM_IS_CONDES (E->Type)? 'I' : ' ');
+ if (++Count == 2) {
+ Count = 0;
+ fprintf (F, "\n");
+ }
+ }
}
fprintf (F, "\n");
}
/* Print an import map to the given file */
{
unsigned I;
- Import* Imp;
+ const Import* Imp;
/* Loop over all exports */
for (I = 0; I < ExpCount; ++I) {
- /* Get the export */
- Export* Exp = ExpPool [I];
-
- /* Print the symbol only if there are imports, or if a verbose map
- * file is requested.
- */
- if (VerboseMap || Exp->ImpCount > 0) {
-
- /* Get the name of the object file that exports the symbol.
- * Beware: There may be no object file if the symbol is a linker
- * generated symbol.
- */
- const char* ObjName = (Exp->Obj != 0)? Exp->Obj->Name : "linker generated";
-
- /* Print the export */
- fprintf (F,
- "%s (%s):\n",
- Exp->Name,
- ObjName);
-
- /* Print all imports for this symbol */
- Imp = Exp->ImpList;
- while (Imp) {
-
- /* Print the import */
- fprintf (F,
- " %-25s %s(%lu)\n",
- Imp->Obj->Name,
- Imp->Obj->Files [Imp->Pos.Name],
- Imp->Pos.Line);
-
- /* Next import */
- Imp = Imp->Next;
- }
- }
+ /* Get the export */
+ const Export* Exp = ExpPool [I];
+
+ /* Print the symbol only if there are imports, or if a verbose map
+ * file is requested.
+ */
+ if (VerboseMap || Exp->ImpCount > 0) {
+
+ /* Print the export */
+ fprintf (F,
+ "%s (%s):\n",
+ GetString (Exp->Name),
+ GetObjFileName (Exp->Obj));
+
+ /* Print all imports for this symbol */
+ Imp = Exp->ImpList;
+ while (Imp) {
+
+ /* Print the import. Beware: The import might be linker
+ * generated, in which case there is no object file and
+ * sometimes no line information.
+ */
+ const LineInfo* LI = GetImportPos (Imp);
+ if (LI) {
+ fprintf (F,
+ " %-25s %s(%u)\n",
+ GetObjFileName (Imp->Obj),
+ GetSourceName (LI),
+ GetSourceLine (LI));
+ } else {
+ fprintf (F,
+ " %-25s\n",
+ GetObjFileName (Imp->Obj));
+ }
+
+ /* Next import */
+ Imp = Imp->Next;
+ }
+ }
}
fprintf (F, "\n");
}
/* Print all exports */
for (I = 0; I < ExpCount; ++I) {
- Export* E = ExpPool [I];
- fprintf (F, "al %06lX .%s\n", GetExportVal (E), E->Name);
+ const Export* E = ExpPool [I];
+ fprintf (F, "al %06lX .%s\n", GetExportVal (E), GetString (E->Name));
}
}
void CircularRefError (const Export* E)
/* Print an error about a circular reference using to define the given export */
{
- Error ("Circular reference for symbol `%s', %s(%lu)",
- E->Name, E->Obj->Files [E->Pos.Name], E->Pos.Line);
+ const LineInfo* LI = GetExportPos (E);
+ Error ("Circular reference for symbol `%s', %s(%u)",
+ GetString (E->Name),
+ GetSourceName (LI),
+ GetSourceLine (LI));
}
-
-
-
projects / cc65 / blobdiff