1 /* 2 * Aic7xxx SCSI host adapter firmware asssembler symbol table implementation 3 * 4 * Copyright (c) 1997 Justin T. Gibbs. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions, and the following disclaimer, 12 * without modification, immediately at the beginning of the file. 13 * 2. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $Id: aicasm_symbol.c,v 1.5 1998/09/15 07:24:17 gibbs Exp $ 29 */ 30 31 32 #include <sys/types.h> 33 34 #include <db.h> 35 #include <fcntl.h> 36 #include <stdio.h> 37 #include <stdlib.h> 38 #include <string.h> 39 #include <sysexits.h> 40 41 #include "aicasm_symbol.h" 42 #include "aicasm.h" 43 44 static DB *symtable; 45 46 symbol_t * 47 symbol_create(name) 48 char *name; 49 { 50 symbol_t *new_symbol; 51 52 new_symbol = (symbol_t *)malloc(sizeof(symbol_t)); 53 if (new_symbol == NULL) { 54 perror("Unable to create new symbol"); 55 exit(EX_SOFTWARE); 56 } 57 memset(new_symbol, 0, sizeof(*new_symbol)); 58 new_symbol->name = strdup(name); 59 new_symbol->type = UNINITIALIZED; 60 return (new_symbol); 61 } 62 63 void 64 symbol_delete(symbol) 65 symbol_t *symbol; 66 { 67 if (symtable != NULL) { 68 DBT key; 69 70 key.data = symbol->name; 71 key.size = strlen(symbol->name); 72 symtable->del(symtable, &key, /*flags*/0); 73 } 74 switch(symbol->type) { 75 case SCBLOC: 76 case SRAMLOC: 77 case REGISTER: 78 if (symbol->info.rinfo != NULL) 79 free(symbol->info.rinfo); 80 break; 81 case ALIAS: 82 if (symbol->info.ainfo != NULL) 83 free(symbol->info.ainfo); 84 break; 85 case MASK: 86 case BIT: 87 if (symbol->info.minfo != NULL) { 88 symlist_free(&symbol->info.minfo->symrefs); 89 free(symbol->info.minfo); 90 } 91 break; 92 case DOWNLOAD_CONST: 93 case CONST: 94 if (symbol->info.cinfo != NULL) 95 free(symbol->info.cinfo); 96 break; 97 case LABEL: 98 if (symbol->info.linfo != NULL) 99 free(symbol->info.linfo); 100 break; 101 case UNINITIALIZED: 102 default: 103 break; 104 } 105 free(symbol->name); 106 free(symbol); 107 } 108 109 void 110 symtable_open() 111 { 112 symtable = dbopen(/*filename*/NULL, 113 O_CREAT | O_NONBLOCK | O_RDWR, /*mode*/0, DB_HASH, 114 /*openinfo*/NULL); 115 116 if (symtable == NULL) { 117 perror("Symbol table creation failed"); 118 exit(EX_SOFTWARE); 119 /* NOTREACHED */ 120 } 121 } 122 123 void 124 symtable_close() 125 { 126 if (symtable != NULL) { 127 DBT key; 128 DBT data; 129 130 while (symtable->seq(symtable, &key, &data, R_FIRST) == 0) { 131 symbol_t *stored_ptr; 132 133 memcpy(&stored_ptr, data.data, sizeof(stored_ptr)); 134 symbol_delete(stored_ptr); 135 } 136 symtable->close(symtable); 137 } 138 } 139 140 /* 141 * The semantics of get is to return an uninitialized symbol entry 142 * if a lookup fails. 143 */ 144 symbol_t * 145 symtable_get(name) 146 char *name; 147 { 148 symbol_t *stored_ptr; 149 DBT key; 150 DBT data; 151 int retval; 152 153 key.data = (void *)name; 154 key.size = strlen(name); 155 156 if ((retval = symtable->get(symtable, &key, &data, /*flags*/0)) != 0) { 157 if (retval == -1) { 158 perror("Symbol table get operation failed"); 159 exit(EX_SOFTWARE); 160 /* NOTREACHED */ 161 } else if (retval == 1) { 162 /* Symbol wasn't found, so create a new one */ 163 symbol_t *new_symbol; 164 165 new_symbol = symbol_create(name); 166 data.data = &new_symbol; 167 data.size = sizeof(new_symbol); 168 if (symtable->put(symtable, &key, &data, 169 /*flags*/0) !=0) { 170 perror("Symtable put failed"); 171 exit(EX_SOFTWARE); 172 } 173 return (new_symbol); 174 } else { 175 perror("Unexpected return value from db get routine"); 176 exit(EX_SOFTWARE); 177 /* NOTREACHED */ 178 } 179 } 180 memcpy(&stored_ptr, data.data, sizeof(stored_ptr)); 181 return (stored_ptr); 182 } 183 184 symbol_node_t * 185 symlist_search(symlist, symname) 186 symlist_t *symlist; 187 char *symname; 188 { 189 symbol_node_t *curnode; 190 191 curnode = symlist->slh_first; 192 while(curnode != NULL) { 193 if (strcmp(symname, curnode->symbol->name) == 0) 194 break; 195 curnode = curnode->links.sle_next; 196 } 197 return (curnode); 198 } 199 200 void 201 symlist_add(symlist, symbol, how) 202 symlist_t *symlist; 203 symbol_t *symbol; 204 int how; 205 { 206 symbol_node_t *newnode; 207 208 newnode = (symbol_node_t *)malloc(sizeof(symbol_node_t)); 209 if (newnode == NULL) { 210 stop("symlist_add: Unable to malloc symbol_node", EX_SOFTWARE); 211 /* NOTREACHED */ 212 } 213 newnode->symbol = symbol; 214 if (how == SYMLIST_SORT) { 215 symbol_node_t *curnode; 216 int mask; 217 218 mask = FALSE; 219 switch(symbol->type) { 220 case REGISTER: 221 case SCBLOC: 222 case SRAMLOC: 223 break; 224 case BIT: 225 case MASK: 226 mask = TRUE; 227 break; 228 default: 229 stop("symlist_add: Invalid symbol type for sorting", 230 EX_SOFTWARE); 231 /* NOTREACHED */ 232 } 233 234 curnode = symlist->slh_first; 235 if (curnode == NULL 236 || (mask && (curnode->symbol->info.minfo->mask > 237 newnode->symbol->info.minfo->mask)) 238 || (!mask && (curnode->symbol->info.rinfo->address > 239 newnode->symbol->info.rinfo->address))) { 240 SLIST_INSERT_HEAD(symlist, newnode, links); 241 return; 242 } 243 244 while (1) { 245 if (curnode->links.sle_next == NULL) { 246 SLIST_INSERT_AFTER(curnode, newnode, 247 links); 248 break; 249 } else { 250 symbol_t *cursymbol; 251 252 cursymbol = curnode->links.sle_next->symbol; 253 if ((mask && (cursymbol->info.minfo->mask > 254 symbol->info.minfo->mask)) 255 || (!mask &&(cursymbol->info.rinfo->address > 256 symbol->info.rinfo->address))){ 257 SLIST_INSERT_AFTER(curnode, newnode, 258 links); 259 break; 260 } 261 } 262 curnode = curnode->links.sle_next; 263 } 264 } else { 265 SLIST_INSERT_HEAD(symlist, newnode, links); 266 } 267 } 268 269 void 270 symlist_free(symlist) 271 symlist_t *symlist; 272 { 273 symbol_node_t *node1, *node2; 274 275 node1 = symlist->slh_first; 276 while (node1 != NULL) { 277 node2 = node1->links.sle_next; 278 free(node1); 279 node1 = node2; 280 } 281 SLIST_INIT(symlist); 282 } 283 284 void 285 symlist_merge(symlist_dest, symlist_src1, symlist_src2) 286 symlist_t *symlist_dest; 287 symlist_t *symlist_src1; 288 symlist_t *symlist_src2; 289 { 290 symbol_node_t *node; 291 292 *symlist_dest = *symlist_src1; 293 while((node = symlist_src2->slh_first) != NULL) { 294 SLIST_REMOVE_HEAD(symlist_src2, links); 295 SLIST_INSERT_HEAD(symlist_dest, node, links); 296 } 297 298 /* These are now empty */ 299 SLIST_INIT(symlist_src1); 300 SLIST_INIT(symlist_src2); 301 } 302 303 void 304 symtable_dump(ofile) 305 FILE *ofile; 306 { 307 /* 308 * Sort the registers by address with a simple insertion sort. 309 * Put bitmasks next to the first register that defines them. 310 * Put constants at the end. 311 */ 312 symlist_t registers; 313 symlist_t masks; 314 symlist_t constants; 315 symlist_t download_constants; 316 symlist_t aliases; 317 318 SLIST_INIT(®isters); 319 SLIST_INIT(&masks); 320 SLIST_INIT(&constants); 321 SLIST_INIT(&download_constants); 322 SLIST_INIT(&aliases); 323 324 if (symtable != NULL) { 325 DBT key; 326 DBT data; 327 int flag = R_FIRST; 328 329 while (symtable->seq(symtable, &key, &data, flag) == 0) { 330 symbol_t *cursym; 331 332 memcpy(&cursym, data.data, sizeof(cursym)); 333 switch(cursym->type) { 334 case REGISTER: 335 case SCBLOC: 336 case SRAMLOC: 337 symlist_add(®isters, cursym, SYMLIST_SORT); 338 break; 339 case MASK: 340 case BIT: 341 symlist_add(&masks, cursym, SYMLIST_SORT); 342 break; 343 case CONST: 344 if (cursym->info.cinfo->define == FALSE) { 345 symlist_add(&constants, cursym, 346 SYMLIST_INSERT_HEAD); 347 } 348 break; 349 case DOWNLOAD_CONST: 350 symlist_add(&download_constants, cursym, 351 SYMLIST_INSERT_HEAD); 352 break; 353 case ALIAS: 354 symlist_add(&aliases, cursym, 355 SYMLIST_INSERT_HEAD); 356 break; 357 default: 358 break; 359 } 360 flag = R_NEXT; 361 } 362 363 /* Put in the masks and bits */ 364 while (masks.slh_first != NULL) { 365 symbol_node_t *curnode; 366 symbol_node_t *regnode; 367 char *regname; 368 369 curnode = masks.slh_first; 370 SLIST_REMOVE_HEAD(&masks, links); 371 372 regnode = 373 curnode->symbol->info.minfo->symrefs.slh_first; 374 regname = regnode->symbol->name; 375 regnode = symlist_search(®isters, regname); 376 SLIST_INSERT_AFTER(regnode, curnode, links); 377 } 378 379 /* Add the aliases */ 380 while (aliases.slh_first != NULL) { 381 symbol_node_t *curnode; 382 symbol_node_t *regnode; 383 char *regname; 384 385 curnode = aliases.slh_first; 386 SLIST_REMOVE_HEAD(&aliases, links); 387 388 regname = curnode->symbol->info.ainfo->parent->name; 389 regnode = symlist_search(®isters, regname); 390 SLIST_INSERT_AFTER(regnode, curnode, links); 391 } 392 393 /* Output what we have */ 394 fprintf(ofile, 395 "/* 396 * DO NOT EDIT - This file is automatically generated. 397 */\n"); 398 while (registers.slh_first != NULL) { 399 symbol_node_t *curnode; 400 u_int8_t value; 401 char *tab_str; 402 char *tab_str2; 403 404 curnode = registers.slh_first; 405 SLIST_REMOVE_HEAD(®isters, links); 406 switch(curnode->symbol->type) { 407 case REGISTER: 408 case SCBLOC: 409 case SRAMLOC: 410 fprintf(ofile, "\n"); 411 value = curnode->symbol->info.rinfo->address; 412 tab_str = "\t"; 413 tab_str2 = "\t\t"; 414 break; 415 case ALIAS: 416 { 417 symbol_t *parent; 418 419 parent = curnode->symbol->info.ainfo->parent; 420 value = parent->info.rinfo->address; 421 tab_str = "\t"; 422 tab_str2 = "\t\t"; 423 break; 424 } 425 case MASK: 426 case BIT: 427 value = curnode->symbol->info.minfo->mask; 428 tab_str = "\t\t"; 429 tab_str2 = "\t"; 430 break; 431 default: 432 value = 0; /* Quiet compiler */ 433 tab_str = NULL; 434 tab_str2 = NULL; 435 stop("symtable_dump: Invalid symbol type " 436 "encountered", EX_SOFTWARE); 437 break; 438 } 439 fprintf(ofile, "#define%s%-16s%s0x%02x\n", 440 tab_str, curnode->symbol->name, tab_str2, 441 value); 442 free(curnode); 443 } 444 fprintf(ofile, "\n\n"); 445 446 while (constants.slh_first != NULL) { 447 symbol_node_t *curnode; 448 449 curnode = constants.slh_first; 450 SLIST_REMOVE_HEAD(&constants, links); 451 fprintf(ofile, "#define\t%-8s\t0x%02x\n", 452 curnode->symbol->name, 453 curnode->symbol->info.cinfo->value); 454 free(curnode); 455 } 456 457 458 fprintf(ofile, "\n\n/* Downloaded Constant Definitions */\n"); 459 460 while (download_constants.slh_first != NULL) { 461 symbol_node_t *curnode; 462 463 curnode = download_constants.slh_first; 464 SLIST_REMOVE_HEAD(&download_constants, links); 465 fprintf(ofile, "#define\t%-8s\t0x%02x\n", 466 curnode->symbol->name, 467 curnode->symbol->info.cinfo->value); 468 free(curnode); 469 } 470 } 471 } 472 473