![[BACK]](/icons/back.gif){kind=icon}
Return to aicasm_symbol.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / microcode / aic7xxx|
Return to aicasm_symbol.c CVS log | Up to [local] / sys / dev / microcode / aic7xxx |
1.1 nbrk 1: /* $OpenBSD: aicasm_symbol.c,v 1.9 2003/12/24 23:27:55 krw Exp $ */
2: /* $NetBSD: aicasm_symbol.c,v 1.4 2003/07/14 15:42:40 lukem Exp $ */
3:
4: /*
5: * Aic7xxx SCSI host adapter firmware asssembler symbol table implementation
6: *
7: * Copyright (c) 1997 Justin T. Gibbs.
8: * Copyright (c) 2002 Adaptec Inc.
9: * All rights reserved.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions, and the following disclaimer,
16: * without modification.
17: * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18: * substantially similar to the "NO WARRANTY" disclaimer below
19: * ("Disclaimer") and any redistribution must be conditioned upon
20: * including a substantially similar Disclaimer requirement for further
21: * binary redistribution.
22: * 3. Neither the names of the above-listed copyright holders nor the names
23: * of any contributors may be used to endorse or promote products derived
24: * from this software without specific prior written permission.
25: *
26: * Alternatively, this software may be distributed under the terms of the
27: * GNU General Public License ("GPL") version 2 as published by the Free
28: * Software Foundation.
29: *
30: * NO WARRANTY
31: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35: * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40: * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41: * POSSIBILITY OF SUCH DAMAGES.
42: *
43: * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_symbol.c,v 1.23 2003/01/20 18:01:37 gibbs Exp $
44: */
45:
46: #include <sys/cdefs.h>
47: /* __RCSID("$NetBSD: aicasm_symbol.c,v 1.4 2003/07/14 15:42:40 lukem Exp $"); */
48:
49: #include <sys/types.h>
50:
51: #ifdef __linux__
52: #include "aicdb.h"
53: #else
54: #include <db.h>
55: #endif
56: #include <fcntl.h>
57: #include <inttypes.h>
58: #include <regex.h>
59: #include <stdio.h>
60: #include <stdlib.h>
61: #include <string.h>
62: #include <sysexits.h>
63:
64: #include "aicasm_symbol.h"
65: #include "aicasm.h"
66:
67: static DB *symtable;
68:
69: symbol_t *
70: symbol_create(char *name)
71: {
72: symbol_t *new_symbol;
73:
74: new_symbol = (symbol_t *)malloc(sizeof(symbol_t));
75: if (new_symbol == NULL) {
76: perror("Unable to create new symbol");
77: exit(EX_SOFTWARE);
78: }
79: memset(new_symbol, 0, sizeof(*new_symbol));
80: new_symbol->name = strdup(name);
81: if (new_symbol->name == NULL)
82: stop("Unable to strdup symbol name", EX_SOFTWARE);
83: new_symbol->type = UNINITIALIZED;
84: return (new_symbol);
85: }
86:
87: void
88: symbol_delete(symbol_t *symbol)
89: {
90: if (symtable != NULL) {
91: DBT key;
92:
93: key.data = symbol->name;
94: key.size = strlen(symbol->name);
95: symtable->del(symtable, &key, /*flags*/0);
96: }
97: switch(symbol->type) {
98: case SCBLOC:
99: case SRAMLOC:
100: case REGISTER:
101: if (symbol->info.rinfo != NULL)
102: free(symbol->info.rinfo);
103: break;
104: case ALIAS:
105: if (symbol->info.ainfo != NULL)
106: free(symbol->info.ainfo);
107: break;
108: case MASK:
109: case FIELD:
110: case ENUM:
111: case ENUM_ENTRY:
112: if (symbol->info.finfo != NULL) {
113: symlist_free(&symbol->info.finfo->symrefs);
114: free(symbol->info.finfo);
115: }
116: break;
117: case DOWNLOAD_CONST:
118: case CONST:
119: if (symbol->info.cinfo != NULL)
120: free(symbol->info.cinfo);
121: break;
122: case LABEL:
123: if (symbol->info.linfo != NULL)
124: free(symbol->info.linfo);
125: break;
126: case UNINITIALIZED:
127: default:
128: break;
129: }
130: free(symbol->name);
131: free(symbol);
132: }
133:
134: void
135: symtable_open()
136: {
137: symtable = dbopen(/*filename*/NULL,
138: O_CREAT | O_NONBLOCK | O_RDWR, /*mode*/0, DB_HASH,
139: /*openinfo*/NULL);
140:
141: if (symtable == NULL) {
142: perror("Symbol table creation failed");
143: exit(EX_SOFTWARE);
144: /* NOTREACHED */
145: }
146: }
147:
148: void
149: symtable_close()
150: {
151: if (symtable != NULL) {
152: DBT key;
153: DBT data;
154:
155: while (symtable->seq(symtable, &key, &data, R_FIRST) == 0) {
156: symbol_t *stored_ptr;
157:
158: memcpy(&stored_ptr, data.data, sizeof(stored_ptr));
159: symbol_delete(stored_ptr);
160: }
161: symtable->close(symtable);
162: }
163: }
164:
165: /*
166: * The semantics of get is to return an uninitialized symbol entry
167: * if a lookup fails.
168: */
169: symbol_t *
170: symtable_get(char *name)
171: {
172: symbol_t *stored_ptr;
173: DBT key;
174: DBT data;
175: int retval;
176:
177: key.data = (void *)name;
178: key.size = strlen(name);
179:
180: if ((retval = symtable->get(symtable, &key, &data, /*flags*/0)) != 0) {
181: if (retval == -1) {
182: perror("Symbol table get operation failed");
183: exit(EX_SOFTWARE);
184: /* NOTREACHED */
185: } else if (retval == 1) {
186: /* Symbol wasn't found, so create a new one */
187: symbol_t *new_symbol;
188:
189: new_symbol = symbol_create(name);
190: data.data = &new_symbol;
191: data.size = sizeof(new_symbol);
192: if (symtable->put(symtable, &key, &data,
193: /*flags*/0) !=0) {
194: perror("Symtable put failed");
195: exit(EX_SOFTWARE);
196: }
197: return (new_symbol);
198: } else {
199: perror("Unexpected return value from db get routine");
200: exit(EX_SOFTWARE);
201: /* NOTREACHED */
202: }
203: }
204: memcpy(&stored_ptr, data.data, sizeof(stored_ptr));
205: return (stored_ptr);
206: }
207:
208: symbol_node_t *
209: symlist_search(symlist_t *symlist, char *symname)
210: {
211: symbol_node_t *curnode;
212:
213: curnode = SLIST_FIRST(symlist);
214: while(curnode != NULL) {
215: if (strcmp(symname, curnode->symbol->name) == 0)
216: break;
217: curnode = SLIST_NEXT(curnode, links);
218: }
219: return (curnode);
220: }
221:
222: void
223: symlist_add(symlist_t *symlist, symbol_t *symbol, int how)
224: {
225: symbol_node_t *newnode;
226:
227: newnode = (symbol_node_t *)malloc(sizeof(symbol_node_t));
228: if (newnode == NULL) {
229: stop("symlist_add: Unable to malloc symbol_node", EX_SOFTWARE);
230: /* NOTREACHED */
231: }
232: newnode->symbol = symbol;
233: if (how == SYMLIST_SORT) {
234: symbol_node_t *curnode;
235: int field;
236:
237: field = FALSE;
238: switch(symbol->type) {
239: case REGISTER:
240: case SCBLOC:
241: case SRAMLOC:
242: break;
243: case FIELD:
244: case MASK:
245: case ENUM:
246: case ENUM_ENTRY:
247: field = TRUE;
248: break;
249: default:
250: stop("symlist_add: Invalid symbol type for sorting",
251: EX_SOFTWARE);
252: /* NOTREACHED */
253: }
254:
255: curnode = SLIST_FIRST(symlist);
256: if (curnode == NULL
257: || (field
258: && (curnode->symbol->type > newnode->symbol->type
259: || (curnode->symbol->type == newnode->symbol->type
260: && (curnode->symbol->info.finfo->value >
261: newnode->symbol->info.finfo->value))))
262: || (!field && (curnode->symbol->info.rinfo->address >
263: newnode->symbol->info.rinfo->address))) {
264: SLIST_INSERT_HEAD(symlist, newnode, links);
265: return;
266: }
267:
268: while (1) {
269: if (SLIST_NEXT(curnode, links) == NULL) {
270: SLIST_INSERT_AFTER(curnode, newnode,
271: links);
272: break;
273: } else {
274: symbol_t *cursymbol;
275:
276: cursymbol = SLIST_NEXT(curnode, links)->symbol;
277: if ((field
278: && (cursymbol->type > symbol->type
279: || (cursymbol->type == symbol->type
280: && (cursymbol->info.finfo->value >
281: symbol->info.finfo->value))))
282: || (!field
283: && (cursymbol->info.rinfo->address >
284: symbol->info.rinfo->address))) {
285: SLIST_INSERT_AFTER(curnode, newnode,
286: links);
287: break;
288: }
289: }
290: curnode = SLIST_NEXT(curnode, links);
291: }
292: } else {
293: SLIST_INSERT_HEAD(symlist, newnode, links);
294: }
295: }
296:
297: void
298: symlist_free(symlist_t *symlist)
299: {
300: symbol_node_t *node1, *node2;
301:
302: node1 = SLIST_FIRST(symlist);
303: while (node1 != NULL) {
304: node2 = SLIST_NEXT(node1, links);
305: free(node1);
306: node1 = node2;
307: }
308: SLIST_INIT(symlist);
309: }
310:
311: void
312: symlist_merge(symlist_t *symlist_dest, symlist_t *symlist_src1,
313: symlist_t *symlist_src2)
314: {
315: symbol_node_t *node;
316:
317: *symlist_dest = *symlist_src1;
318: while((node = SLIST_FIRST(symlist_src2)) != NULL) {
319: SLIST_REMOVE_HEAD(symlist_src2, links);
320: SLIST_INSERT_HEAD(symlist_dest, node, links);
321: }
322:
323: /* These are now empty */
324: SLIST_INIT(symlist_src1);
325: SLIST_INIT(symlist_src2);
326: }
327:
328: void
329: aic_print_file_prologue(FILE *ofile)
330: {
331:
332: if (ofile == NULL)
333: return;
334:
335: fprintf(ofile,
336: "/*\n"
337: " * DO NOT EDIT - This file is automatically generated\n"
338: " * from the following source files:\n"
339: " *\n"
340: "%s */\n",
341: versions);
342: }
343:
344: void
345: aic_print_include(FILE *dfile, char *include_file)
346: {
347:
348: if (dfile == NULL)
349: return;
350: fprintf(dfile, "\n#include \"%s\"\n\n", include_file);
351: }
352:
353: void
354: aic_print_reg_dump_types(FILE *ofile)
355: {
356: if (ofile == NULL)
357: return;
358:
359: fprintf(ofile,
360: "typedef int (%sreg_print_t)(u_int, u_int *, u_int);\n"
361: "typedef struct %sreg_parse_entry {\n"
362: " char *name;\n"
363: " uint8_t value;\n"
364: " uint8_t mask;\n"
365: "} %sreg_parse_entry_t;\n"
366: "\n",
367: prefix, prefix, prefix);
368: }
369:
370: static void
371: aic_print_reg_dump_start(FILE *dfile, symbol_node_t *regnode)
372: {
373: if (dfile == NULL)
374: return;
375:
376: fprintf(dfile,
377: "static %sreg_parse_entry_t %s_parse_table[] = {\n",
378: prefix,
379: regnode->symbol->name);
380: }
381:
382: static void
383: aic_print_reg_dump_end(FILE *ofile, FILE *dfile,
384: symbol_node_t *regnode, u_int num_entries)
385: {
386: char *lower_name;
387: char *letter;
388:
389: lower_name = strdup(regnode->symbol->name);
390: if (lower_name == NULL)
391: stop("Unable to strdup symbol name", EX_SOFTWARE);
392:
393: for (letter = lower_name; *letter != '\0'; letter++)
394: *letter = tolower(*letter);
395:
396: if (dfile != NULL) {
397: if (num_entries != 0)
398: fprintf(dfile,
399: "\n"
400: "};\n"
401: "\n");
402:
403: fprintf(dfile,
404: "int\n"
405: "%s%s_print(u_int regvalue, u_int *cur_col, u_int wrap)\n"
406: "{\n"
407: " return (%sprint_register(%s%s, %d, \"%s\",\n"
408: " 0x%02x, regvalue, cur_col, wrap));\n"
409: "}\n"
410: "\n",
411: prefix,
412: lower_name,
413: prefix,
414: num_entries != 0 ? regnode->symbol->name : "NULL",
415: num_entries != 0 ? "_parse_table" : "",
416: num_entries,
417: regnode->symbol->name,
418: regnode->symbol->info.rinfo->address);
419: }
420:
421: fprintf(ofile,
422: "#if AIC_DEBUG_REGISTERS\n"
423: "%sreg_print_t %s%s_print;\n"
424: "#else\n"
425: "#define %s%s_print(regvalue, cur_col, wrap) \\\n"
426: " %sprint_register(NULL, 0, \"%s\", 0x%02x, regvalue, cur_col, wrap)\n"
427: "#endif\n"
428: "\n",
429: prefix,
430: prefix,
431: lower_name,
432: prefix,
433: lower_name,
434: prefix,
435: regnode->symbol->name,
436: regnode->symbol->info.rinfo->address);
437: }
438:
439: static void
440: aic_print_reg_dump_entry(FILE *dfile, symbol_node_t *curnode)
441: {
442: int num_tabs;
443:
444: if (dfile == NULL)
445: return;
446:
447: fprintf(dfile,
448: " { \"%s\",",
449: curnode->symbol->name);
450:
451: num_tabs = 3 - (strlen(curnode->symbol->name) + 5) / 8;
452:
453: while (num_tabs-- > 0)
454: fputc('\t', dfile);
455: fprintf(dfile, "0x%02x, 0x%02x }",
456: curnode->symbol->info.finfo->value,
457: curnode->symbol->info.finfo->mask);
458: }
459:
460: void
461: symtable_dump(FILE *ofile, FILE *dfile)
462: {
463: /*
464: * Sort the registers by address with a simple insertion sort.
465: * Put bitmasks next to the first register that defines them.
466: * Put constants at the end.
467: */
468: symlist_t registers;
469: symlist_t masks;
470: symlist_t constants;
471: symlist_t download_constants;
472: symlist_t aliases;
473: symlist_t exported_labels;
474: symbol_node_t *curnode;
475: symbol_node_t *regnode;
476: DBT key;
477: DBT data;
478: int flag;
479: u_int i;
480:
481: if (symtable == NULL)
482: return;
483:
484: SLIST_INIT(®isters);
485: SLIST_INIT(&masks);
486: SLIST_INIT(&constants);
487: SLIST_INIT(&download_constants);
488: SLIST_INIT(&aliases);
489: SLIST_INIT(&exported_labels);
490: flag = R_FIRST;
491: while (symtable->seq(symtable, &key, &data, flag) == 0) {
492: symbol_t *cursym;
493:
494: memcpy(&cursym, data.data, sizeof(cursym));
495: switch(cursym->type) {
496: case REGISTER:
497: case SCBLOC:
498: case SRAMLOC:
499: symlist_add(®isters, cursym, SYMLIST_SORT);
500: break;
501: case MASK:
502: case FIELD:
503: case ENUM:
504: case ENUM_ENTRY:
505: symlist_add(&masks, cursym, SYMLIST_SORT);
506: break;
507: case CONST:
508: symlist_add(&constants, cursym,
509: SYMLIST_INSERT_HEAD);
510: break;
511: case DOWNLOAD_CONST:
512: symlist_add(&download_constants, cursym,
513: SYMLIST_INSERT_HEAD);
514: break;
515: case ALIAS:
516: symlist_add(&aliases, cursym,
517: SYMLIST_INSERT_HEAD);
518: break;
519: case LABEL:
520: if (cursym->info.linfo->exported == 0)
521: break;
522: symlist_add(&exported_labels, cursym,
523: SYMLIST_INSERT_HEAD);
524: break;
525: default:
526: break;
527: }
528: flag = R_NEXT;
529: }
530:
531: /* Register dianostic functions/declarations first. */
532: aic_print_file_prologue(ofile);
533: aic_print_reg_dump_types(ofile);
534: aic_print_file_prologue(dfile);
535: aic_print_include(dfile, stock_include_file);
536: SLIST_FOREACH(curnode, ®isters, links) {
537:
538: switch(curnode->symbol->type) {
539: case REGISTER:
540: case SCBLOC:
541: case SRAMLOC:
542: {
543: symlist_t *fields;
544: symbol_node_t *fieldnode;
545: int num_entries;
546:
547: num_entries = 0;
548: fields = &curnode->symbol->info.rinfo->fields;
549: SLIST_FOREACH(fieldnode, fields, links) {
550: if (num_entries == 0)
551: aic_print_reg_dump_start(dfile,
552: curnode);
553: else if (dfile != NULL)
554: fputs(",\n", dfile);
555: num_entries++;
556: aic_print_reg_dump_entry(dfile, fieldnode);
557: }
558: aic_print_reg_dump_end(ofile, dfile,
559: curnode, num_entries);
560: }
561: default:
562: break;
563: }
564: }
565:
566: /* Fold in the masks and bits */
567: while (SLIST_FIRST(&masks) != NULL) {
568: char *regname;
569:
570: curnode = SLIST_FIRST(&masks);
571: SLIST_REMOVE_HEAD(&masks, links);
572:
573: regnode = SLIST_FIRST(&curnode->symbol->info.finfo->symrefs);
574: regname = regnode->symbol->name;
575: regnode = symlist_search(®isters, regname);
576: SLIST_INSERT_AFTER(regnode, curnode, links);
577: }
578:
579: /* Add the aliases */
580: while (SLIST_FIRST(&aliases) != NULL) {
581: char *regname;
582:
583: curnode = SLIST_FIRST(&aliases);
584: SLIST_REMOVE_HEAD(&aliases, links);
585:
586: regname = curnode->symbol->info.ainfo->parent->name;
587: regnode = symlist_search(®isters, regname);
588: SLIST_INSERT_AFTER(regnode, curnode, links);
589: }
590:
591: /* Output generated #defines. */
592: while (SLIST_FIRST(®isters) != NULL) {
593: symbol_node_t *curnode;
594: u_int value;
595: char *tab_str;
596: char *tab_str2;
597:
598: curnode = SLIST_FIRST(®isters);
599: SLIST_REMOVE_HEAD(®isters, links);
600: switch(curnode->symbol->type) {
601: case REGISTER:
602: case SCBLOC:
603: case SRAMLOC:
604: fprintf(ofile, "\n");
605: value = curnode->symbol->info.rinfo->address;
606: tab_str = "\t";
607: tab_str2 = "\t\t";
608: break;
609: case ALIAS:
610: {
611: symbol_t *parent;
612:
613: parent = curnode->symbol->info.ainfo->parent;
614: value = parent->info.rinfo->address;
615: tab_str = "\t";
616: tab_str2 = "\t\t";
617: break;
618: }
619: case MASK:
620: case FIELD:
621: case ENUM:
622: case ENUM_ENTRY:
623: value = curnode->symbol->info.finfo->value;
624: tab_str = "\t\t";
625: tab_str2 = "\t";
626: break;
627: default:
628: value = 0; /* Quiet compiler */
629: tab_str = NULL;
630: tab_str2 = NULL;
631: stop("symtable_dump: Invalid symbol type "
632: "encountered", EX_SOFTWARE);
633: break;
634: }
635: fprintf(ofile, "#define%s%-16s%s0x%02x\n",
636: tab_str, curnode->symbol->name, tab_str2,
637: value);
638: free(curnode);
639: }
640: fprintf(ofile, "\n\n");
641:
642: while (SLIST_FIRST(&constants) != NULL) {
643: symbol_node_t *curnode;
644:
645: curnode = SLIST_FIRST(&constants);
646: SLIST_REMOVE_HEAD(&constants, links);
647: fprintf(ofile, "#define\t%-8s\t0x%02x\n",
648: curnode->symbol->name,
649: curnode->symbol->info.cinfo->value);
650: free(curnode);
651: }
652:
653:
654: fprintf(ofile, "\n\n/* Downloaded Constant Definitions */\n");
655:
656: for (i = 0; SLIST_FIRST(&download_constants) != NULL; i++) {
657: symbol_node_t *curnode;
658:
659: curnode = SLIST_FIRST(&download_constants);
660: SLIST_REMOVE_HEAD(&download_constants, links);
661: fprintf(ofile, "#define\t%-8s\t0x%02x\n",
662: curnode->symbol->name,
663: curnode->symbol->info.cinfo->value);
664: free(curnode);
665: }
666: fprintf(ofile, "#define\tDOWNLOAD_CONST_COUNT\t0x%02x\n", i);
667:
668: fprintf(ofile, "\n\n/* Exported Labels */\n");
669:
670: while (SLIST_FIRST(&exported_labels) != NULL) {
671: symbol_node_t *curnode;
672:
673: curnode = SLIST_FIRST(&exported_labels);
674: SLIST_REMOVE_HEAD(&exported_labels, links);
675: fprintf(ofile, "#define\tLABEL_%-8s\t0x%02x\n",
676: curnode->symbol->name,
677: curnode->symbol->info.linfo->address);
678: free(curnode);
679: }
680: }
681: