1/*****************************************************************************/
2/* */
3/* dbgsyms.c */
4/* */
5/* Debug symbol handling for the ld65 linker */
6/* */
7/* */
8/* */
9/* (C) 1998-2011, Ullrich von Bassewitz */
10/* Roemerstrasse 52 */
11/* D-70794 Filderstadt */
12/* EMail: uz@cc65.org */
13/* */
14/* */
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. */
18/* */
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: */
22/* */
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 */
30/* distribution. */
31/* */
32/*****************************************************************************/
33
34
35
36#include <string.h>
37
38/* common */
39#include "addrsize.h"
40#include "attrib.h"
41#include "check.h"
42#include "hlldbgsym.h"
43#include "symdefs.h"
44#include "xmalloc.h"
45
46/* ld65 */
47#include "dbgsyms.h"
48#include "error.h"
49#include "exports.h"
50#include "expr.h"
51#include "fileio.h"
52#include "global.h"
53#include "lineinfo.h"
54#include "objdata.h"
55#include "spool.h"
56#include "tpool.h"
57
58
59
60/*****************************************************************************/
61/* Data */
62/*****************************************************************************/
63
64
65
66/* Definition of the debug symbol structure */
67struct DbgSym {
68 unsigned Id; /* Id of debug symbol */
69 DbgSym* Next; /* Pool linear list link */
70 ObjData* Obj; /* Object file that exports the name */
71 Collection DefLines; /* Line infos for definition */
72 Collection RefLines; /* Line infos for references */
73 ExprNode* Expr; /* Expression (0 if not def'd) */
74 unsigned Size; /* Symbol size if any */
75 unsigned OwnerId; /* Id of parent/owner */
76 unsigned ImportId; /* Id of import if this is one */
77 unsigned Name; /* Name */
78 unsigned short Type; /* Type of symbol */
79 unsigned short AddrSize; /* Address size of symbol */
80};
81
82/* Structure used for a high level language function or symbol */
83typedef struct HLLDbgSym HLLDbgSym;
84struct HLLDbgSym {
85 unsigned Flags; /* See above */
86 unsigned Name; /* String id of name */
87 DbgSym* Sym; /* Assembler symbol */
88 int Offs; /* Offset if any */
89 unsigned Type; /* String id of type */
90 unsigned ScopeId; /* Parent scope */
91};
92
93/* We will collect all debug symbols in the following array and remove
94** duplicates before outputing them into a label file.
95*/
96static DbgSym* DbgSymPool[256];
97
98
99
100/*****************************************************************************/
101/* Code */
102/*****************************************************************************/
103
104
105
106static DbgSym* NewDbgSym (unsigned Id, unsigned Type, unsigned char AddrSize,
107 ObjData* O)
108/* Create a new DbgSym and return it */
109{
110 /* Allocate memory */
111 DbgSym* D = xmalloc (sizeof (DbgSym));
112
113 /* Initialize the fields */
114 D->Id = Id;
115 D->Next = 0;
116 D->Obj = O;
117 D->DefLines = EmptyCollection;
118 D->RefLines = EmptyCollection;
119 D->Expr = 0;
120 D->Size = 0;
121 D->OwnerId = ~0U;
122 D->ImportId = ~0U;
123 D->Name = 0;
124 D->Type = Type;
125 D->AddrSize = AddrSize;
126
127 /* Return the new entry */
128 return D;
129}
130
131
132
133static HLLDbgSym* NewHLLDbgSym (void)
134/* Create a new HLLDbgSym and return it */
135{
136 /* Allocate memory and return it */
137 return xmalloc (sizeof (HLLDbgSym));
138}
139
140
141
142static DbgSym* GetDbgSym (DbgSym* D, long Val)
143/* Check if we find the same debug symbol in the table. If we find it, return
144** a pointer to the other occurrence, if we didn't find it, return NULL.
145*/
146{
147 /* Create the hash. We hash over the symbol value */
148 unsigned Hash = ((Val >> 24) & 0xFF) ^
149 ((Val >> 16) & 0xFF) ^
150 ((Val >> 8) & 0xFF) ^
151 ((Val >> 0) & 0xFF);
152
153 /* Check for this symbol */
154 DbgSym* Sym = DbgSymPool[Hash];
155 while (Sym) {
156 /* Is this symbol identical? */
157 if (Sym->Name == D->Name && EqualExpr (Sym->Expr, D->Expr)) {
158 /* Found */
159 return Sym;
160 }
161
162 /* Next symbol */
163 Sym = Sym->Next;
164 }
165
166 /* This is the first symbol of it's kind */
167 return 0;
168}
169
170
171
172static void InsertDbgSym (DbgSym* D, long Val)
173/* Insert the symbol into the hashed symbol pool */
174{
175 /* Create the hash. We hash over the symbol value */
176 unsigned Hash = ((Val >> 24) & 0xFF) ^
177 ((Val >> 16) & 0xFF) ^
178 ((Val >> 8) & 0xFF) ^
179 ((Val >> 0) & 0xFF);
180
181 /* Insert the symbol */
182 D->Next = DbgSymPool [Hash];
183 DbgSymPool [Hash] = D;
184}
185
186
187
188DbgSym* ReadDbgSym (FILE* F, ObjData* O, unsigned Id)
189/* Read a debug symbol from a file, insert and return it */
190{
191 /* Read the type and address size */
192 unsigned Type = ReadVar (F);
193 unsigned char AddrSize = Read8 (F);
194
195 /* Create a new debug symbol */
196 DbgSym* D = NewDbgSym (Id, Type, AddrSize, O);
197
198 /* Read the id of the owner scope/symbol */
199 D->OwnerId = ReadVar (F);
200
201 /* Read and assign the name */
202 D->Name = MakeGlobalStringId (O, ReadVar (F));
203
204 /* Read the value */
205 if (SYM_IS_EXPR (D->Type)) {
206 D->Expr = ReadExpr (F, O);
207 } else {
208 D->Expr = LiteralExpr (Read32 (F), O);
209 }
210
211 /* Read the size */
212 if (SYM_HAS_SIZE (D->Type)) {
213 D->Size = ReadVar (F);
214 }
215
216 /* If this is an import, the file contains its id */
217 if (SYM_IS_IMPORT (D->Type)) {
218 D->ImportId = ReadVar (F);
219 }
220
221 /* If its an exports, there's also the export id, but we don't remember
222 ** it but use it to let the export point back to us.
223 */
224 if (SYM_IS_EXPORT (D->Type)) {
225 /* Get the export from the export id, then set the our id */
226 GetObjExport (O, ReadVar (F))->DbgSymId = Id;
227 }
228
229 /* Last is the list of line infos for this symbol */
230 ReadLineInfoList (F, O, &D->DefLines);
231 ReadLineInfoList (F, O, &D->RefLines);
232
233 /* Return the new DbgSym */
234 return D;
235}
236
237
238
239HLLDbgSym* ReadHLLDbgSym (FILE* F, ObjData* O, unsigned Id attribute ((unused)))
240/* Read a hll debug symbol from a file, insert and return it */
241{
242 unsigned SC;
243
244 /* Create a new HLLDbgSym */
245 HLLDbgSym* S = NewHLLDbgSym ();
246
247 /* Read the data */
248 S->Flags = ReadVar (F);
249 SC = HLL_GET_SC (S->Flags);
250 S->Name = MakeGlobalStringId (O, ReadVar (F));
251 if (HLL_HAS_SYM (S->Flags)) {
252 S->Sym = GetObjDbgSym (O, ReadVar (F));
253 } else {
254 /* Auto variables aren't attached to asm symbols */
255 S->Sym = 0;
256 }
257 if (SC == HLL_SC_AUTO || SC == HLL_SC_REG) {
258 S->Offs = ReadVar (F);
259 } else {
260 S->Offs = 0;
261 }
262 S->Type = GetTypeId (GetObjString (O, ReadVar (F)));
263 S->ScopeId = ReadVar (F);
264
265 /* Return the (now initialized) hll debug symbol */
266 return S;
267}
268
269
270
271static void ClearDbgSymTable (void)
272/* Clear the debug symbol table */
273{
274 unsigned I;
275 for (I = 0; I < sizeof (DbgSymPool) / sizeof (DbgSymPool[0]); ++I) {
276 DbgSym* Sym = DbgSymPool[I];
277 DbgSymPool[I] = 0;
278 while (Sym) {
279 DbgSym* NextSym = Sym->Next;
280 Sym->Next = 0;
281 Sym = NextSym;
282 }
283 }
284}
285
286
287
288static long GetDbgSymVal (const DbgSym* D)
289/* Get the value of this symbol */
290{
291 CHECK (D->Expr != 0);
292 return GetExprVal (D->Expr);
293}
294
295
296
297static void PrintLineInfo (FILE* F, const Collection* LineInfos, const char* Format)
298/* Output an attribute with line infos */
299{
300 if (CollCount (LineInfos) > 0) {
301 unsigned I;
302 const LineInfo* LI = CollConstAt (LineInfos, 0);
303 fprintf (F, Format, LI->Id);
304 for (I = 1; I < CollCount (LineInfos); ++I) {
305 LI = CollConstAt (LineInfos, I);
306 fprintf (F, "+%u", LI->Id);
307 }
308 }
309}
310
311
312
313unsigned DbgSymCount (void)
314/* Return the total number of debug symbols */
315{
316 /* Walk over all object files */
317 unsigned I;
318 unsigned Count = 0;
319 for (I = 0; I < CollCount (&ObjDataList); ++I) {
320
321 /* Get this object file */
322 const ObjData* O = CollAtUnchecked (&ObjDataList, I);
323
324 /* Count debug symbols */
325 Count += CollCount (&O->DbgSyms);
326 }
327 return Count;
328}
329
330
331
332unsigned HLLDbgSymCount (void)
333/* Return the total number of high level language debug symbols */
334{
335 /* Walk over all object files */
336 unsigned I;
337 unsigned Count = 0;
338 for (I = 0; I < CollCount (&ObjDataList); ++I) {
339
340 /* Get this object file */
341 const ObjData* O = CollAtUnchecked (&ObjDataList, I);
342
343 /* Count debug symbols */
344 Count += CollCount (&O->HLLDbgSyms);
345 }
346 return Count;
347}
348
349
350
351void PrintDbgSyms (FILE* F)
352/* Print the debug symbols in a debug file */
353{
354 unsigned I, J;
355
356 for (I = 0; I < CollCount (&ObjDataList); ++I) {
357
358 /* Get the object file */
359 ObjData* O = CollAtUnchecked (&ObjDataList, I);
360
361 /* Walk through all debug symbols in this module */
362 for (J = 0; J < CollCount (&O->DbgSyms); ++J) {
363
364 /* Get the next debug symbol */
365 const DbgSym* S = CollConstAt (&O->DbgSyms, J);
366
367 /* Emit the base data for the entry */
368 fprintf (F,
369 "sym\tid=%u,name=\"%s\",addrsize=%s",
370 O->SymBaseId + J,
371 GetString (S->Name),
372 AddrSizeToStr ((unsigned char) S->AddrSize));
373
374 /* Emit the size only if we know it */
375 if (S->Size != 0) {
376 fprintf (F, ",size=%u", S->Size);
377 }
378
379 /* For cheap local symbols, add the owner symbol, for others,
380 ** add the owner scope.
381 */
382 if (SYM_IS_STD (S->Type)) {
383 fprintf (F, ",scope=%u", O->ScopeBaseId + S->OwnerId);
384 } else {
385 fprintf (F, ",parent=%u", O->SymBaseId + S->OwnerId);
386 }
387
388 /* Output line infos */
389 PrintLineInfo (F, &S->DefLines, ",def=%u");
390 PrintLineInfo (F, &S->RefLines, ",ref=%u");
391
392 /* If this is an import, output the id of the matching export.
393 ** If this is not an import, output its value and - if we have
394 ** it - the segment.
395 */
396 if (SYM_IS_IMPORT (S->Type)) {
397
398 /* Get the import */
399 const Import* Imp = GetObjImport (O, S->ImportId);
400
401 /* Get the export from the import */
402 const Export* Exp = Imp->Exp;
403
404 /* Output the type */
405 fputs (",type=imp", F);
406
407 /* If this is not a linker generated symbol, and the module
408 ** that contains the export has debug info, output the debug
409 ** symbol id for the export
410 */
411 if (Exp->Obj && OBJ_HAS_DBGINFO (Exp->Obj->Header.Flags)) {
412 fprintf (F, ",exp=%u", Exp->Obj->SymBaseId + Exp->DbgSymId);
413 }
414
415 } else {
416
417 SegExprDesc D;
418
419 /* Get the symbol value */
420 long Val = GetDbgSymVal (S);
421
422 /* Output it */
423 fprintf (F, ",val=0x%lX", Val);
424
425 /* Check for a segmented expression and add the segment id to
426 ** the debug info if we have one.
427 */
428 GetSegExprVal (S->Expr, &D);
429 if (!D.TooComplex && D.Seg != 0) {
430 fprintf (F, ",seg=%u", D.Seg->Id);
431 }
432
433 /* Output the type */
434 fprintf (F, ",type=%s", SYM_IS_LABEL (S->Type)? "lab" : "equ");
435 }
436
437 /* Terminate the output line */
438 fputc ('\n', F);
439 }
440 }
441}
442
443
444
445void PrintHLLDbgSyms (FILE* F)
446/* Print the high level language debug symbols in a debug file */
447{
448 unsigned I, J;
449
450 for (I = 0; I < CollCount (&ObjDataList); ++I) {
451
452 /* Get the object file */
453 ObjData* O = CollAtUnchecked (&ObjDataList, I);
454
455 /* Walk through all hll debug symbols in this module */
456 for (J = 0; J < CollCount (&O->HLLDbgSyms); ++J) {
457
458 /* Get the next debug symbol */
459 const HLLDbgSym* S = CollConstAt (&O->HLLDbgSyms, J);
460
461 /* Get the storage class */
462 unsigned SC = HLL_GET_SC (S->Flags);
463
464 /* Output the base info */
465 fprintf (F, "csym\tid=%u,name=\"%s\",scope=%u,type=%u,sc=",
466 O->HLLSymBaseId + J,
467 GetString (S->Name),
468 O->ScopeBaseId + S->ScopeId,
469 S->Type);
470 switch (SC) {
471 case HLL_SC_AUTO: fputs ("auto", F); break;
472 case HLL_SC_REG: fputs ("reg", F); break;
473 case HLL_SC_STATIC: fputs ("static", F); break;
474 case HLL_SC_EXTERN: fputs ("ext", F); break;
475 default:
476 Error ("Invalid storage class %u for hll symbol", SC);
477 break;
478 }
479
480 /* Output the offset if it is not zero */
481 if (S->Offs) {
482 fprintf (F, ",offs=%d", S->Offs);
483 }
484
485 /* For non auto symbols output the debug symbol id of the asm sym */
486 if (HLL_HAS_SYM (S->Flags)) {
487 fprintf (F, ",sym=%u", O->SymBaseId + S->Sym->Id);
488 }
489
490 /* Terminate the output line */
491 fputc ('\n', F);
492 }
493 }
494}
495
496
497
498void PrintDbgSymLabels (FILE* F)
499/* Print the debug symbols in a VICE label file */
500{
501 unsigned I, J;
502
503 /* Clear the symbol table */
504 ClearDbgSymTable ();
505
506 /* Create labels from all modules we have linked into the output file */
507 for (I = 0; I < CollCount (&ObjDataList); ++I) {
508
509 /* Get the object file */
510 ObjData* O = CollAtUnchecked (&ObjDataList, I);
511
512 /* Walk through all debug symbols in this module */
513 for (J = 0; J < CollCount (&O->DbgSyms); ++J) {
514
515 long Val;
516
517 /* Get the next debug symbol */
518 DbgSym* D = CollAt (&O->DbgSyms, J);
519
520 /* Emit this symbol only if it is a label (ignore equates and imports) */
521 if (SYM_IS_EQUATE (D->Type) || SYM_IS_IMPORT (D->Type)) {
522 continue;
523 }
524
525 /* Get the symbol value */
526 Val = GetDbgSymVal (D);
527
528 /* Lookup this symbol in the table. If it is found in the table, it was
529 ** already written to the file, so don't emit it twice. If it is not in
530 ** the table, insert and output it.
531 */
532 if (GetDbgSym (D, Val) == 0) {
533
534 /* Emit the VICE label line */
535 fprintf (F, "al %06lX .%s\n", Val, GetString (D->Name));
536
537 /* Insert the symbol into the table */
538 InsertDbgSym (D, Val);
539 }
540 }
541 }
542}
543