1 /*****************************************************************************/
5 /* Symbol table for the ca65 macroassembler */
9 /* (C) 1998-2003 Ullrich von Bassewitz */
11 /* D-70794 Filderstadt */
12 /* EMail: uz@cc65.org */
15 /* This software is provided 'as-is', without any expressed or implied */
16 /* warranty. In no event will the authors be held liable for any damages */
17 /* arising from the use of this software. */
19 /* Permission is granted to anyone to use this software for any purpose, */
20 /* including commercial applications, and to alter it and redistribute it */
21 /* freely, subject to the following restrictions: */
23 /* 1. The origin of this software must not be misrepresented; you must not */
24 /* claim that you wrote the original software. If you use this software */
25 /* in a product, an acknowledgment in the product documentation would be */
26 /* appreciated but is not required. */
27 /* 2. Altered source versions must be plainly marked as such, and must not */
28 /* be misrepresented as being the original software. */
29 /* 3. This notice may not be removed or altered from any source */
32 /*****************************************************************************/
55 #include "studyexpr.h"
60 /*****************************************************************************/
62 /*****************************************************************************/
66 /* Combined symbol entry flags used within this module */
67 #define SF_UNDEFMASK (SF_REFERENCED | SF_DEFINED | SF_IMPORT)
68 #define SF_UNDEFVAL (SF_REFERENCED)
69 #define SF_DBGINFOMASK (SF_UNUSED | SF_DEFINED | SF_IMPORT)
70 #define SF_DBGINFOVAL (SF_DEFINED)
73 SymTable* CurrentScope = 0; /* Pointer to current symbol table */
74 SymTable* RootScope = 0; /* Root symbol table */
76 /* Symbol table variables */
77 static unsigned ImportCount = 0; /* Counter for import symbols */
78 static unsigned ExportCount = 0; /* Counter for export symbols */
82 /*****************************************************************************/
83 /* Internally used functions */
84 /*****************************************************************************/
88 static unsigned ScopeTableSize (unsigned Level)
89 /* Get the size of a table for the given lexical level */
100 static SymTable* NewSymTable (SymTable* Parent, const char* Name)
101 /* Allocate a symbol table on the heap and return it */
103 /* Determine the lexical level and the number of table slots */
104 unsigned Level = Parent? Parent->Level + 1 : 0;
105 unsigned Slots = ScopeTableSize (Level);
107 /* Allocate memory */
108 SymTable* S = xmalloc (sizeof (SymTable) + (Slots-1) * sizeof (SymEntry*));
110 /* Set variables and clear hash table entries */
114 S->SegRanges = AUTO_COLLECTION_INITIALIZER;
116 S->AddrSize = ADDR_SIZE_DEFAULT;
119 S->TableSlots = Slots;
122 S->Name = GetStringId (Name);
127 /* Insert the symbol table into the child tree of the parent */
129 SymTable* T = Parent->Childs;
135 /* Choose next entry */
136 int Cmp = strcmp (Name, GetString (T->Name));
144 } else if (Cmp > 0) {
152 /* Duplicate scope name */
153 Internal ("Duplicate scope name: `%s'", Name);
159 /* Return the prepared struct */
165 /*****************************************************************************/
167 /*****************************************************************************/
171 void SymEnterLevel (const char* ScopeName, unsigned char Type, unsigned char AddrSize)
172 /* Enter a new lexical level */
174 /* Map a default address size to something real */
175 if (AddrSize == ADDR_SIZE_DEFAULT) {
176 /* Use the segment address size */
177 AddrSize = GetCurrentSegAddrSize ();
180 /* If we have a current scope, search for the given name and create a
181 * new one if it doesn't exist. If this is the root scope, just create it.
185 /* Search for the scope, create a new one */
186 CurrentScope = SymFindScope (CurrentScope, ScopeName, SYM_ALLOC_NEW);
188 /* Check if the scope has been defined before */
189 if (CurrentScope->Flags & ST_DEFINED) {
190 Error ("Duplicate scope `%s'", ScopeName);
194 CurrentScope = RootScope = NewSymTable (0, ScopeName);
197 /* Mark the scope as defined and set type and address size */
198 CurrentScope->Flags |= ST_DEFINED;
199 CurrentScope->AddrSize = AddrSize;
200 CurrentScope->Type = Type;
202 /* If this is a scope that allows to emit data into segments, add segment
203 * ranges for all currently existing segments. Doing this for just a few
204 * scope types is not really necessary but an optimization, because it
205 * does not allocate memory for useless data (unhandled types here don't
206 * occupy space in any segment).
208 if (CurrentScope->Type <= ST_SCOPE_HAS_DATA) {
209 AddSegRanges (&CurrentScope->SegRanges);
215 void SymLeaveLevel (void)
216 /* Leave the current lexical level */
218 /* Close the segment ranges. We don't care about the scope type here,
219 * since types without segment ranges will just have an empty list.
221 CloseSegRanges (&CurrentScope->SegRanges);
223 /* If we have segment ranges, the first one is the segment that was
224 * active, when the scope was opened. Set the size of the scope to the
225 * number of data bytes emitted into this segment.
227 if (CollCount (&CurrentScope->SegRanges) > 0) {
228 const SegRange* R = CollAtUnchecked (&CurrentScope->SegRanges, 0);
229 DefSizeOfScope (CurrentScope, GetSegRangeSize (R));
232 /* Leave the scope */
233 CurrentScope = CurrentScope->Parent;
238 SymTable* SymFindScope (SymTable* Parent, const char* Name, int AllocNew)
239 /* Find a scope in the given enclosing scope */
241 SymTable** T = &Parent->Childs;
243 int Cmp = strcmp (Name, GetString ((*T)->Name));
246 } else if (Cmp > 0) {
249 /* Found the scope */
254 /* Create a new scope if requested and we didn't find one */
255 if (*T == 0 && AllocNew) {
256 *T = NewSymTable (Parent, Name);
259 /* Return the scope */
265 SymTable* SymFindAnyScope (SymTable* Parent, const char* Name)
266 /* Find a scope in the given or any of its parent scopes. The function will
267 * never create a new symbol, since this can only be done in one specific
273 /* Search in the current table */
274 Scope = SymFindScope (Parent, Name, SYM_FIND_EXISTING);
276 /* Not found, search in the parent scope, if we have one */
277 Parent = Parent->Parent;
279 } while (Scope == 0 && Parent != 0);
286 SymEntry* SymFindLocal (SymEntry* Parent, const char* Name, int AllocNew)
287 /* Find a cheap local symbol. If AllocNew is given and the entry is not
288 * found, create a new one. Return the entry found, or the new entry created,
289 * or - in case AllocNew is zero - return 0.
295 /* Local symbol, get the table */
297 /* No last global, so there's no local table */
298 Error ("No preceeding global symbol");
300 return NewSymEntry (Name, SF_LOCAL);
306 /* Search for the symbol if we have a table */
307 Cmp = SymSearchTree (Parent->Locals, Name, &S);
309 /* If we found an entry, return it */
316 /* Otherwise create a new entry, insert and return it */
317 SymEntry* N = NewSymEntry (Name, SF_LOCAL);
320 } else if (Cmp < 0) {
328 /* We did not find the entry and AllocNew is false. */
334 SymEntry* SymFind (SymTable* Scope, const char* Name, int AllocNew)
335 /* Find a new symbol table entry in the given table. If AllocNew is given and
336 * the entry is not found, create a new one. Return the entry found, or the
337 * new entry created, or - in case AllocNew is zero - return 0.
342 /* Global symbol: Get the hash value for the name */
343 unsigned Hash = HashStr (Name) % Scope->TableSlots;
345 /* Search for the entry */
346 int Cmp = SymSearchTree (Scope->Table[Hash], Name, &S);
348 /* If we found an entry, return it */
355 /* Otherwise create a new entry, insert and return it */
356 SymEntry* N = NewSymEntry (Name, SF_NONE);
358 Scope->Table[Hash] = N;
359 } else if (Cmp < 0) {
365 ++Scope->TableEntries;
370 /* We did not find the entry and AllocNew is false. */
376 SymEntry* SymFindAny (SymTable* Scope, const char* Name)
377 /* Find a symbol in the given or any of its parent scopes. The function will
378 * never create a new symbol, since this can only be done in one specific
384 /* Search in the current table */
385 Sym = SymFind (Scope, Name, SYM_FIND_EXISTING);
387 /* Found, return it */
391 /* Not found, search in the parent scope, if we have one */
392 Scope = Scope->Parent;
394 } while (Sym == 0 && Scope != 0);
396 /* Return the result */
402 unsigned char GetCurrentSymTabType ()
403 /* Return the type of the current symbol table */
405 CHECK (CurrentScope != 0);
406 return CurrentScope->Type;
411 static void SymCheckUndefined (SymEntry* S)
412 /* Handle an undefined symbol */
414 /* Undefined symbol. It may be...
416 * - An undefined symbol in a nested lexical level. In this
417 * case, search for the symbol in the higher levels and
418 * make the entry a trampoline entry if we find one.
420 * - If the symbol is not found, it is a real undefined symbol.
421 * If the AutoImport flag is set, make it an import. If the
422 * AutoImport flag is not set, it's an error.
425 SymTable* Tab = GetSymParentScope (S);
427 Sym = SymFind (Tab, GetString (S->Name), SYM_FIND_EXISTING);
428 if (Sym && (Sym->Flags & (SF_DEFINED | SF_IMPORT)) != 0) {
429 /* We've found a symbol in a higher level that is
430 * either defined in the source, or an import.
434 /* No matching symbol found in this level. Look further */
440 /* We found the symbol in a higher level. Transfer the flags and
441 * address size from the local symbol to that in the higher level
442 * and check for problems.
444 if (S->Flags & SF_EXPORT) {
445 if (Sym->Flags & SF_IMPORT) {
446 /* The symbol is already marked as import */
447 PError (&S->Pos, "Symbol `%s' is already an import",
448 GetString (Sym->Name));
450 if (Sym->Flags & SF_EXPORT) {
451 /* The symbol is already marked as an export. */
452 if (Sym->AddrSize > S->ExportSize) {
453 /* We're exporting a symbol smaller than it actually is */
454 PWarning (&S->Pos, 1, "Symbol `%s' is %s but exported %s",
455 GetSymName (Sym), AddrSizeToStr (Sym->AddrSize),
456 AddrSizeToStr (S->ExportSize));
459 /* Mark the symbol as an export */
460 Sym->Flags |= SF_EXPORT;
461 Sym->ExportSize = S->ExportSize;
462 if (Sym->ExportSize == ADDR_SIZE_DEFAULT) {
463 /* Use the actual size of the symbol */
464 Sym->ExportSize = Sym->AddrSize;
466 if (Sym->AddrSize > Sym->ExportSize) {
467 /* We're exporting a symbol smaller than it actually is */
468 PWarning (&S->Pos, 1, "Symbol `%s' is %s but exported %s",
469 GetSymName (Sym), AddrSizeToStr (Sym->AddrSize),
470 AddrSizeToStr (Sym->ExportSize));
474 Sym->Flags |= (S->Flags & SF_REFERENCED);
476 /* Transfer all expression references */
477 SymTransferExprRefs (S, Sym);
479 /* Mark the symbol as unused removing all other flags */
480 S->Flags = SF_UNUSED;
483 /* The symbol is definitely undefined */
484 if (S->Flags & SF_EXPORT) {
485 /* We will not auto-import an export */
486 PError (&S->Pos, "Exported symbol `%s' was never defined",
487 GetString (S->Name));
490 /* Mark as import, will be indexed later */
491 S->Flags |= SF_IMPORT;
492 /* Use the address size for code */
493 S->AddrSize = CodeAddrSize;
496 PError (&S->Pos, "Symbol `%s' is undefined", GetString (S->Name));
505 /* Run through all symbols and check for anomalies and errors */
509 /* Check for open scopes */
510 if (CurrentScope->Parent != 0) {
511 Error ("Local scope was not closed");
514 /* First pass: Walk through all symbols, checking for undefined's and
515 * changing them to trampoline symbols or make them imports.
519 /* If the symbol is marked as global, mark it as export, if it is
520 * already defined, otherwise mark it as import.
522 if (S->Flags & SF_GLOBAL) {
523 S->Flags &= ~SF_GLOBAL;
524 if (S->Flags & SF_DEFINED) {
525 S->Flags |= SF_EXPORT;
527 S->Flags |= SF_IMPORT;
531 /* Handle undefined symbols */
532 if ((S->Flags & SF_UNDEFMASK) == SF_UNDEFVAL) {
533 /* This is an undefined symbol. Handle it. */
534 SymCheckUndefined (S);
541 /* Second pass: Walk again through the symbols. Count exports and imports
542 * and set address sizes where this has not happened before. Ignore
543 * undefined's, since we handled them in the last pass, and ignore unused
544 * symbols, since we handled them in the last pass, too.
548 if ((S->Flags & SF_UNUSED) == 0 &&
549 (S->Flags & SF_UNDEFMASK) != SF_UNDEFVAL) {
551 /* Check for defined symbols that were never referenced */
552 if ((S->Flags & SF_DEFINED) != 0 && (S->Flags & SF_REFERENCED) == 0) {
553 PWarning (&S->Pos, 2,
554 "Symbol `%s' is defined but never used",
555 GetString (S->Name));
558 /* Assign an index to all imports */
559 if (S->Flags & SF_IMPORT) {
560 if ((S->Flags & (SF_REFERENCED | SF_FORCED)) == SF_NONE) {
561 /* Imported symbol is not referenced */
562 PWarning (&S->Pos, 2,
563 "Symbol `%s' is imported but never used",
564 GetString (S->Name));
566 /* Give the import an index, count imports */
567 S->Index = ImportCount++;
568 S->Flags |= SF_INDEXED;
572 /* Assign an index to all exports */
573 if (S->Flags & SF_EXPORT) {
574 /* Give the export an index, count exports */
575 S->Index = ExportCount++;
576 S->Flags |= SF_INDEXED;
579 /* If the symbol is defined but has an unknown address size,
582 if (SymHasExpr (S) && S->AddrSize == ADDR_SIZE_DEFAULT) {
585 StudyExpr (S->Expr, &ED);
586 S->AddrSize = ED.AddrSize;
598 void SymDump (FILE* F)
599 /* Dump the symbol table */
601 SymEntry* S = SymList;
604 /* Ignore unused symbols */
605 if ((S->Flags & SF_UNUSED) != 0) {
607 "%-24s %s %s %s %s %s\n",
609 (S->Flags & SF_DEFINED)? "DEF" : "---",
610 (S->Flags & SF_REFERENCED)? "REF" : "---",
611 (S->Flags & SF_IMPORT)? "IMP" : "---",
612 (S->Flags & SF_EXPORT)? "EXP" : "---",
613 AddrSizeToStr (S->AddrSize));
622 void WriteImports (void)
623 /* Write the imports list to the object file */
627 /* Tell the object file module that we're about to start the imports */
630 /* Write the import count to the list */
631 ObjWriteVar (ImportCount);
633 /* Walk throught list and write all valid imports to the file. An import
634 * is considered valid, if it is either referenced, or the forced bit is
635 * set. Otherwise, the import is ignored (no need to link in something
640 if ((S->Flags & (SF_UNUSED | SF_IMPORT)) == SF_IMPORT &&
641 (S->Flags & (SF_REFERENCED | SF_FORCED)) != 0) {
643 ObjWrite8 (S->AddrSize);
644 ObjWriteVar (S->Name);
645 ObjWritePos (&S->Pos);
650 /* Done writing imports */
656 void WriteExports (void)
657 /* Write the exports list to the object file */
662 /* Tell the object file module that we're about to start the exports */
665 /* Write the export count to the list */
666 ObjWriteVar (ExportCount);
668 /* Walk throught list and write all exports to the file */
671 if ((S->Flags & (SF_UNUSED | SF_EXPORT)) == SF_EXPORT) {
675 /* Get the expression bits */
676 unsigned char ExprMask = SymIsConst (S, &ConstVal)? EXP_CONST : EXP_EXPR;
677 ExprMask |= (S->Flags & SF_LABEL)? EXP_LABEL : EXP_EQUATE;
679 /* Count the number of ConDes types */
680 for (Type = 0; Type < CD_TYPE_COUNT; ++Type) {
681 if (S->ConDesPrio[Type] != CD_PRIO_NONE) {
682 INC_EXP_CONDES_COUNT (ExprMask);
686 /* Write the type and the export size */
687 ObjWrite8 (ExprMask);
688 ObjWrite8 (S->ExportSize);
690 /* Write any ConDes declarations */
691 if (GET_EXP_CONDES_COUNT (ExprMask) > 0) {
692 for (Type = 0; Type < CD_TYPE_COUNT; ++Type) {
693 unsigned char Prio = S->ConDesPrio[Type];
694 if (Prio != CD_PRIO_NONE) {
695 ObjWrite8 (CD_BUILD (Type, Prio));
701 ObjWriteVar (S->Name);
703 /* Write the value */
704 if ((ExprMask & EXP_MASK_VAL) == EXP_CONST) {
706 ObjWrite32 (ConstVal);
708 /* Expression involved */
712 /* Write the source file position */
713 ObjWritePos (&S->Pos);
718 /* Done writing exports */
724 void WriteDbgSyms (void)
725 /* Write a list of all symbols to the object file */
730 /* Tell the object file module that we're about to start the debug info */
733 /* Check if debug info is requested */
736 /* Walk through the list and count the symbols */
740 if ((S->Flags & SF_DBGINFOMASK) == SF_DBGINFOVAL) {
746 /* Write the symbol count to the list */
749 /* Walk through list and write all symbols to the file */
752 if ((S->Flags & SF_DBGINFOMASK) == SF_DBGINFOVAL) {
756 /* Get the expression bits */
757 unsigned char ExprMask = (SymIsConst (S, &ConstVal))? EXP_CONST : EXP_EXPR;
758 ExprMask |= (S->Flags & SF_LABEL)? EXP_LABEL : EXP_EQUATE;
761 ObjWrite8 (ExprMask);
763 /* Write the address size */
764 ObjWrite8 (S->AddrSize);
767 ObjWriteVar (S->Name);
769 /* Write the value */
770 if ((ExprMask & EXP_MASK_VAL) == EXP_CONST) {
772 ObjWrite32 (ConstVal);
774 /* Expression involved */
778 /* Write the source file position */
779 ObjWritePos (&S->Pos);
786 /* No debug symbols */
791 /* Done writing debug symbols */
797 void WriteScopes (void)
798 /* Write the scope table to the object file */
800 /* Tell the object file module that we're about to start the scopes */
806 /* Done writing the scopes */