1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45#include <sys/types.h>
46
47#ifdef __linux__
48#include "aicdb.h"
49#else
50#include <db.h>
51#endif
52#include <fcntl.h>
53#include <inttypes.h>
54#include <regex.h>
55#include <stdio.h>
56#include <stdlib.h>
57#include <string.h>
58#include <sysexits.h>
59
60#include "aicasm_symbol.h"
61#include "aicasm.h"
62
63static DB *symtable;
64
65symbol_t *
66symbol_create(char *name)
67{
68 symbol_t *new_symbol;
69
70 new_symbol = (symbol_t *)malloc(sizeof(symbol_t));
71 if (new_symbol == NULL) {
72 perror("Unable to create new symbol");
73 exit(EX_SOFTWARE);
74 }
75 memset(new_symbol, 0, sizeof(*new_symbol));
76 new_symbol->name = strdup(name);
77 if (new_symbol->name == NULL)
78 stop("Unable to strdup symbol name", EX_SOFTWARE);
79 new_symbol->type = UNINITIALIZED;
80 return (new_symbol);
81}
82
83void
84symbol_delete(symbol_t *symbol)
85{
86 if (symtable != NULL) {
87 DBT key;
88
89 key.data = symbol->name;
90 key.size = strlen(symbol->name);
91 symtable->del(symtable, &key, 0);
92 }
93 switch(symbol->type) {
94 case SCBLOC:
95 case SRAMLOC:
96 case REGISTER:
97 if (symbol->info.rinfo != NULL)
98 free(symbol->info.rinfo);
99 break;
100 case ALIAS:
101 if (symbol->info.ainfo != NULL)
102 free(symbol->info.ainfo);
103 break;
104 case MASK:
105 case FIELD:
106 case ENUM:
107 case ENUM_ENTRY:
108 if (symbol->info.finfo != NULL) {
109 symlist_free(&symbol->info.finfo->symrefs);
110 free(symbol->info.finfo);
111 }
112 break;
113 case DOWNLOAD_CONST:
114 case CONST:
115 if (symbol->info.cinfo != NULL)
116 free(symbol->info.cinfo);
117 break;
118 case LABEL:
119 if (symbol->info.linfo != NULL)
120 free(symbol->info.linfo);
121 break;
122 case UNINITIALIZED:
123 default:
124 break;
125 }
126 free(symbol->name);
127 free(symbol);
128}
129
130void
131symtable_open()
132{
133 symtable = dbopen(NULL,
134 O_CREAT | O_NONBLOCK | O_RDWR, 0, DB_HASH,
135 NULL);
136
137 if (symtable == NULL) {
138 perror("Symbol table creation failed");
139 exit(EX_SOFTWARE);
140
141 }
142}
143
144void
145symtable_close()
146{
147 if (symtable != NULL) {
148 DBT key;
149 DBT data;
150
151 while (symtable->seq(symtable, &key, &data, R_FIRST) == 0) {
152 symbol_t *stored_ptr;
153
154 memcpy(&stored_ptr, data.data, sizeof(stored_ptr));
155 symbol_delete(stored_ptr);
156 }
157 symtable->close(symtable);
158 }
159}
160
161
162
163
164
165symbol_t *
166symtable_get(char *name)
167{
168 symbol_t *stored_ptr;
169 DBT key;
170 DBT data;
171 int retval;
172
173 key.data = (void *)name;
174 key.size = strlen(name);
175
176 if ((retval = symtable->get(symtable, &key, &data, 0)) != 0) {
177 if (retval == -1) {
178 perror("Symbol table get operation failed");
179 exit(EX_SOFTWARE);
180
181 } else if (retval == 1) {
182
183 symbol_t *new_symbol;
184
185 new_symbol = symbol_create(name);
186 data.data = &new_symbol;
187 data.size = sizeof(new_symbol);
188 if (symtable->put(symtable, &key, &data,
189 0) !=0) {
190 perror("Symtable put failed");
191 exit(EX_SOFTWARE);
192 }
193 return (new_symbol);
194 } else {
195 perror("Unexpected return value from db get routine");
196 exit(EX_SOFTWARE);
197
198 }
199 }
200 memcpy(&stored_ptr, data.data, sizeof(stored_ptr));
201 return (stored_ptr);
202}
203
204symbol_node_t *
205symlist_search(symlist_t *symlist, char *symname)
206{
207 symbol_node_t *curnode;
208
209 curnode = SLIST_FIRST(symlist);
210 while(curnode != NULL) {
211 if (strcmp(symname, curnode->symbol->name) == 0)
212 break;
213 curnode = SLIST_NEXT(curnode, links);
214 }
215 return (curnode);
216}
217
218void
219symlist_add(symlist_t *symlist, symbol_t *symbol, int how)
220{
221 symbol_node_t *newnode;
222
223 newnode = (symbol_node_t *)malloc(sizeof(symbol_node_t));
224 if (newnode == NULL) {
225 stop("symlist_add: Unable to malloc symbol_node", EX_SOFTWARE);
226
227 }
228 newnode->symbol = symbol;
229 if (how == SYMLIST_SORT) {
230 symbol_node_t *curnode;
231 int field;
232
233 field = FALSE;
234 switch(symbol->type) {
235 case REGISTER:
236 case SCBLOC:
237 case SRAMLOC:
238 break;
239 case FIELD:
240 case MASK:
241 case ENUM:
242 case ENUM_ENTRY:
243 field = TRUE;
244 break;
245 default:
246 stop("symlist_add: Invalid symbol type for sorting",
247 EX_SOFTWARE);
248
249 }
250
251 curnode = SLIST_FIRST(symlist);
252 if (curnode == NULL
253 || (field
254 && (curnode->symbol->type > newnode->symbol->type
255 || (curnode->symbol->type == newnode->symbol->type
256 && (curnode->symbol->info.finfo->value >
257 newnode->symbol->info.finfo->value))))
258 || (!field && (curnode->symbol->info.rinfo->address >
259 newnode->symbol->info.rinfo->address))) {
260 SLIST_INSERT_HEAD(symlist, newnode, links);
261 return;
262 }
263
264 while (1) {
265 if (SLIST_NEXT(curnode, links) == NULL) {
266 SLIST_INSERT_AFTER(curnode, newnode,
267 links);
268 break;
269 } else {
270 symbol_t *cursymbol;
271
272 cursymbol = SLIST_NEXT(curnode, links)->symbol;
273 if ((field
274 && (cursymbol->type > symbol->type
275 || (cursymbol->type == symbol->type
276 && (cursymbol->info.finfo->value >
277 symbol->info.finfo->value))))
278 || (!field
279 && (cursymbol->info.rinfo->address >
280 symbol->info.rinfo->address))) {
281 SLIST_INSERT_AFTER(curnode, newnode,
282 links);
283 break;
284 }
285 }
286 curnode = SLIST_NEXT(curnode, links);
287 }
288 } else {
289 SLIST_INSERT_HEAD(symlist, newnode, links);
290 }
291}
292
293void
294symlist_free(symlist_t *symlist)
295{
296 symbol_node_t *node1, *node2;
297
298 node1 = SLIST_FIRST(symlist);
299 while (node1 != NULL) {
300 node2 = SLIST_NEXT(node1, links);
301 free(node1);
302 node1 = node2;
303 }
304 SLIST_INIT(symlist);
305}
306
307void
308symlist_merge(symlist_t *symlist_dest, symlist_t *symlist_src1,
309 symlist_t *symlist_src2)
310{
311 symbol_node_t *node;
312
313 *symlist_dest = *symlist_src1;
314 while((node = SLIST_FIRST(symlist_src2)) != NULL) {
315 SLIST_REMOVE_HEAD(symlist_src2, links);
316 SLIST_INSERT_HEAD(symlist_dest, node, links);
317 }
318
319
320 SLIST_INIT(symlist_src1);
321 SLIST_INIT(symlist_src2);
322}
323
324void
325aic_print_file_prologue(FILE *ofile)
326{
327
328 if (ofile == NULL)
329 return;
330
331 fprintf(ofile,
332"/*\n"
333" * DO NOT EDIT - This file is automatically generated\n"
334" * from the following source files:\n"
335" *\n"
336"%s */\n",
337 versions);
338}
339
340void
341aic_print_include(FILE *dfile, char *include_file)
342{
343
344 if (dfile == NULL)
345 return;
346 fprintf(dfile, "\n#include \"%s\"\n\n", include_file);
347}
348
349void
350aic_print_reg_dump_types(FILE *ofile)
351{
352 if (ofile == NULL)
353 return;
354
355 fprintf(ofile,
356"typedef int (%sreg_print_t)(u_int, u_int *, u_int);\n"
357"typedef struct %sreg_parse_entry {\n"
358" char *name;\n"
359" uint8_t value;\n"
360" uint8_t mask;\n"
361"} %sreg_parse_entry_t;\n"
362"\n",
363 prefix, prefix, prefix);
364}
365
366static void
367aic_print_reg_dump_start(FILE *dfile, symbol_node_t *regnode)
368{
369 if (dfile == NULL)
370 return;
371
372 fprintf(dfile,
373"static %sreg_parse_entry_t %s_parse_table[] = {\n",
374 prefix,
375 regnode->symbol->name);
376}
377
378static void
379aic_print_reg_dump_end(FILE *ofile, FILE *dfile,
380 symbol_node_t *regnode, u_int num_entries)
381{
382 char *lower_name;
383 char *letter;
384
385 lower_name = strdup(regnode->symbol->name);
386 if (lower_name == NULL)
387 stop("Unable to strdup symbol name", EX_SOFTWARE);
388
389 for (letter = lower_name; *letter != '\0'; letter++)
390 *letter = tolower(*letter);
391
392 if (dfile != NULL) {
393 if (num_entries != 0)
394 fprintf(dfile,
395"\n"
396"};\n"
397"\n");
398
399 fprintf(dfile,
400"int\n"
401"%s%s_print(u_int regvalue, u_int *cur_col, u_int wrap)\n"
402"{\n"
403" return (%sprint_register(%s%s, %d, \"%s\",\n"
404" 0x%02x, regvalue, cur_col, wrap));\n"
405"}\n"
406"\n",
407 prefix,
408 lower_name,
409 prefix,
410 num_entries != 0 ? regnode->symbol->name : "NULL",
411 num_entries != 0 ? "_parse_table" : "",
412 num_entries,
413 regnode->symbol->name,
414 regnode->symbol->info.rinfo->address);
415 }
416
417 fprintf(ofile,
418"#if AIC_DEBUG_REGISTERS\n"
419"%sreg_print_t %s%s_print;\n"
420"#else\n"
421"#define %s%s_print(regvalue, cur_col, wrap) \\\n"
422" %sprint_register(NULL, 0, \"%s\", 0x%02x, regvalue, cur_col, wrap)\n"
423"#endif\n"
424"\n",
425 prefix,
426 prefix,
427 lower_name,
428 prefix,
429 lower_name,
430 prefix,
431 regnode->symbol->name,
432 regnode->symbol->info.rinfo->address);
433}
434
435static void
436aic_print_reg_dump_entry(FILE *dfile, symbol_node_t *curnode)
437{
438 int num_tabs;
439
440 if (dfile == NULL)
441 return;
442
443 fprintf(dfile,
444" { \"%s\",",
445 curnode->symbol->name);
446
447 num_tabs = 3 - (strlen(curnode->symbol->name) + 5) / 8;
448
449 while (num_tabs-- > 0)
450 fputc('\t', dfile);
451 fprintf(dfile, "0x%02x, 0x%02x }",
452 curnode->symbol->info.finfo->value,
453 curnode->symbol->info.finfo->mask);
454}
455
456void
457symtable_dump(FILE *ofile, FILE *dfile)
458{
459
460
461
462
463
464 symlist_t registers;
465 symlist_t masks;
466 symlist_t constants;
467 symlist_t download_constants;
468 symlist_t aliases;
469 symlist_t exported_labels;
470 symbol_node_t *curnode;
471 symbol_node_t *regnode;
472 DBT key;
473 DBT data;
474 int flag;
475 u_int i;
476
477 if (symtable == NULL)
478 return;
479
480 SLIST_INIT(®isters);
481 SLIST_INIT(&masks);
482 SLIST_INIT(&constants);
483 SLIST_INIT(&download_constants);
484 SLIST_INIT(&aliases);
485 SLIST_INIT(&exported_labels);
486 flag = R_FIRST;
487 while (symtable->seq(symtable, &key, &data, flag) == 0) {
488 symbol_t *cursym;
489
490 memcpy(&cursym, data.data, sizeof(cursym));
491 switch(cursym->type) {
492 case REGISTER:
493 case SCBLOC:
494 case SRAMLOC:
495 symlist_add(®isters, cursym, SYMLIST_SORT);
496 break;
497 case MASK:
498 case FIELD:
499 case ENUM:
500 case ENUM_ENTRY:
501 symlist_add(&masks, cursym, SYMLIST_SORT);
502 break;
503 case CONST:
504 symlist_add(&constants, cursym,
505 SYMLIST_INSERT_HEAD);
506 break;
507 case DOWNLOAD_CONST:
508 symlist_add(&download_constants, cursym,
509 SYMLIST_INSERT_HEAD);
510 break;
511 case ALIAS:
512 symlist_add(&aliases, cursym,
513 SYMLIST_INSERT_HEAD);
514 break;
515 case LABEL:
516 if (cursym->info.linfo->exported == 0)
517 break;
518 symlist_add(&exported_labels, cursym,
519 SYMLIST_INSERT_HEAD);
520 break;
521 default:
522 break;
523 }
524 flag = R_NEXT;
525 }
526
527
528 aic_print_file_prologue(ofile);
529 aic_print_reg_dump_types(ofile);
530 aic_print_file_prologue(dfile);
531 aic_print_include(dfile, stock_include_file);
532 SLIST_FOREACH(curnode, ®isters, links) {
533
534 switch(curnode->symbol->type) {
535 case REGISTER:
536 case SCBLOC:
537 case SRAMLOC:
538 {
539 symlist_t *fields;
540 symbol_node_t *fieldnode;
541 int num_entries;
542
543 num_entries = 0;
544 fields = &curnode->symbol->info.rinfo->fields;
545 SLIST_FOREACH(fieldnode, fields, links) {
546 if (num_entries == 0)
547 aic_print_reg_dump_start(dfile,
548 curnode);
549 else if (dfile != NULL)
550 fputs(",\n", dfile);
551 num_entries++;
552 aic_print_reg_dump_entry(dfile, fieldnode);
553 }
554 aic_print_reg_dump_end(ofile, dfile,
555 curnode, num_entries);
556 }
557 default:
558 break;
559 }
560 }
561
562
563 while (SLIST_FIRST(&masks) != NULL) {
564 char *regname;
565
566 curnode = SLIST_FIRST(&masks);
567 SLIST_REMOVE_HEAD(&masks, links);
568
569 regnode = SLIST_FIRST(&curnode->symbol->info.finfo->symrefs);
570 regname = regnode->symbol->name;
571 regnode = symlist_search(®isters, regname);
572 SLIST_INSERT_AFTER(regnode, curnode, links);
573 }
574
575
576 while (SLIST_FIRST(&aliases) != NULL) {
577 char *regname;
578
579 curnode = SLIST_FIRST(&aliases);
580 SLIST_REMOVE_HEAD(&aliases, links);
581
582 regname = curnode->symbol->info.ainfo->parent->name;
583 regnode = symlist_search(®isters, regname);
584 SLIST_INSERT_AFTER(regnode, curnode, links);
585 }
586
587
588 while (SLIST_FIRST(®isters) != NULL) {
589 symbol_node_t *curnode;
590 u_int value;
591 char *tab_str;
592 char *tab_str2;
593
594 curnode = SLIST_FIRST(®isters);
595 SLIST_REMOVE_HEAD(®isters, links);
596 switch(curnode->symbol->type) {
597 case REGISTER:
598 case SCBLOC:
599 case SRAMLOC:
600 fprintf(ofile, "\n");
601 value = curnode->symbol->info.rinfo->address;
602 tab_str = "\t";
603 tab_str2 = "\t\t";
604 break;
605 case ALIAS:
606 {
607 symbol_t *parent;
608
609 parent = curnode->symbol->info.ainfo->parent;
610 value = parent->info.rinfo->address;
611 tab_str = "\t";
612 tab_str2 = "\t\t";
613 break;
614 }
615 case MASK:
616 case FIELD:
617 case ENUM:
618 case ENUM_ENTRY:
619 value = curnode->symbol->info.finfo->value;
620 tab_str = "\t\t";
621 tab_str2 = "\t";
622 break;
623 default:
624 value = 0;
625 tab_str = NULL;
626 tab_str2 = NULL;
627 stop("symtable_dump: Invalid symbol type "
628 "encountered", EX_SOFTWARE);
629 break;
630 }
631 fprintf(ofile, "#define%s%-16s%s0x%02x\n",
632 tab_str, curnode->symbol->name, tab_str2,
633 value);
634 free(curnode);
635 }
636 fprintf(ofile, "\n\n");
637
638 while (SLIST_FIRST(&constants) != NULL) {
639 symbol_node_t *curnode;
640
641 curnode = SLIST_FIRST(&constants);
642 SLIST_REMOVE_HEAD(&constants, links);
643 fprintf(ofile, "#define\t%-8s\t0x%02x\n",
644 curnode->symbol->name,
645 curnode->symbol->info.cinfo->value);
646 free(curnode);
647 }
648
649
650 fprintf(ofile, "\n\n/* Downloaded Constant Definitions */\n");
651
652 for (i = 0; SLIST_FIRST(&download_constants) != NULL; i++) {
653 symbol_node_t *curnode;
654
655 curnode = SLIST_FIRST(&download_constants);
656 SLIST_REMOVE_HEAD(&download_constants, links);
657 fprintf(ofile, "#define\t%-8s\t0x%02x\n",
658 curnode->symbol->name,
659 curnode->symbol->info.cinfo->value);
660 free(curnode);
661 }
662 fprintf(ofile, "#define\tDOWNLOAD_CONST_COUNT\t0x%02x\n", i);
663
664 fprintf(ofile, "\n\n/* Exported Labels */\n");
665
666 while (SLIST_FIRST(&exported_labels) != NULL) {
667 symbol_node_t *curnode;
668
669 curnode = SLIST_FIRST(&exported_labels);
670 SLIST_REMOVE_HEAD(&exported_labels, links);
671 fprintf(ofile, "#define\tLABEL_%-8s\t0x%02x\n",
672 curnode->symbol->name,
673 curnode->symbol->info.linfo->address);
674 free(curnode);
675 }
676}
677
678
