![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to db6.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / db|
Return to db6.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / db |
1.1 ! root 1: /* ! 2: * db/db6.c ! 3: * A debugger. ! 4: * Symbol handling. ! 5: */ ! 6: ! 7: #include <canon.h> ! 8: #include "db.h" ! 9: ! 10: /* ! 11: * In earlier versions of db, a SYM included an id hash, a type and a symbol ! 12: * table index, but not did not include the symbol id[] itself. ! 13: * This allowed db to handle lots of symbols in a small address space, ! 14: * but each symbol lookup required reading the symbol again from ! 15: * the symbol table in the program file (i.e. from the disk). ! 16: * Since memory is no longer as critical an issue, now db stores the id[] ! 17: * as part of the SYM and symbol lookup does not need to access the file. ! 18: */ ! 19: ! 20: /* ! 21: * Given a value 'm' in segment 's', find the closest symbol below. ! 22: * Return a pointer to the symbol, or NULL if none. ! 23: * In COFF, with a flat address space, the segment can be ignored. ! 24: * In l.out, where the same address can represent a code or a data item, ! 25: * it had better not be ignored. ! 26: */ ! 27: SYM * ! 28: findsym(s, addr) int s; ADDR_T addr; ! 29: { ! 30: register int n; ! 31: register SYM *hp, *sp; ! 32: ! 33: dbprintf(("findsym(%d, %lX):\n", s, addr)); ! 34: sp = (SYM *)NULL; ! 35: if (sfp == (FILE *)NULL) ! 36: return sp; /* no symbols */ ! 37: for (n = 0; n < NHASH; n++) { /* search all hash buckets */ ! 38: for (hp = symhash[n]; hp != (SYM *)NULL; hp = hp->s_next) { ! 39: ! 40: dbprintf(("findsym: (%d, %lX) id=%s @ (%d, %lX)\n", s, addr, hp->s_id, hp->s_segn, hp->s_addr)); ! 41: if (IS_LOUT && hp->s_segn != s) ! 42: continue; /* segment mismatch */ ! 43: ! 44: /* If below and better than previous best guess... */ ! 45: if (hp->s_addr <= addr ! 46: && (sp==(SYM *)NULL || hp->s_addr > sp->s_addr)) { ! 47: sp = hp; /* best so far */ ! 48: dbprintf((" best so far: %s addr=%lX s=%d\n", sp->s_id, sp->s_addr, sp->s_segn)); ! 49: if (sp->s_addr == addr) ! 50: return sp; /* gotcha! */ ! 51: } ! 52: } ! 53: } ! 54: return sp; /* NULL or best guess */ ! 55: } ! 56: ! 57: /* ! 58: * Hash a symbol name. ! 59: * The '_' character has no effect on the hash, so "foo" and "foo_" hash ! 60: * to the same value; this is convenient for l.out symbol lookup, ! 61: * where is_symbol() understands "foo" to mean "foo_" if there is no "foo". ! 62: */ ! 63: int ! 64: hash(id) register char *id; ! 65: { ! 66: register int c, h; ! 67: ! 68: for (h = 0; (c = *id++) != 0; ) ! 69: if (c != '_') ! 70: h += c; ! 71: return h % NHASH; ! 72: } ! 73: ! 74: /* ! 75: * See if the given symbol is a special symbol "d", "i" or "u". ! 76: */ ! 77: int ! 78: is_special(sp) register SYM *sp; ! 79: { ! 80: register int s; ! 81: ! 82: if (sp->s_id[1] != '\0') ! 83: return 0; ! 84: switch (sp->s_id[0]) { ! 85: case 'd': s = DSEG; break; ! 86: case 'i': s = ISEG; break; ! 87: case 'u': s = USEG; break; ! 88: default: return 0; ! 89: } ! 90: sp->s_addr = 0; ! 91: sp->s_segn = s; ! 92: return 1; ! 93: } ! 94: ! 95: /* ! 96: * Find the value of a symbol. ! 97: * Return 1 on success, 0 on failure. ! 98: * For l.out, "foo" matches "foo_" if "foo" is not found. ! 99: */ ! 100: int ! 101: is_symbol(sp) SYM *sp; ! 102: { ! 103: register char *cp; ! 104: register SYM *hp; ! 105: register int len; ! 106: ! 107: dbprintf(("is_symbol(%s): ")); ! 108: cp = sp->s_id; ! 109: for (hp = symhash[hash(cp)]; hp != (SYM *)NULL; hp = hp->s_next) { ! 110: if (strcmp(cp, hp->s_id) == 0) { ! 111: dbprintf(("addr=%lX segn=%d\n", hp->s_addr, hp->s_segn)); ! 112: sp->s_addr = hp->s_addr; ! 113: sp->s_segn = hp->s_segn; ! 114: return 1; ! 115: } ! 116: } ! 117: ! 118: /* The symbol was not found. If l.out, try again with trailing '_'. */ ! 119: if (IS_LOUT) { ! 120: len = strlen(cp); ! 121: for (hp = symhash[hash(cp)]; hp != (SYM *)NULL; hp = hp->s_next) { ! 122: if (strncmp(cp, hp->s_id, len) == 0 ! 123: && hp->s_id[len] == '_' ! 124: && hp->s_id[len+1] == '\0') { ! 125: dbprintf(("(%s) addr=%lX segn=%d\n", hp->s_id, hp->s_addr, hp->s_segn)); ! 126: sp->s_addr = hp->s_addr; ! 127: sp->s_segn = hp->s_segn; ! 128: return 1; ! 129: } ! 130: } ! 131: } ! 132: dbprintf((" is_symbol(): %s not found\n", cp)); ! 133: return 0; ! 134: } ! 135: ! 136: /* ! 137: * Allocate a new SYM with the given id, address and segment. ! 138: * Initialize it and link it into the hash chain. ! 139: * db.h declares char s_id[1], but the nalloc() call below ! 140: * leaves room for the actual id char s_id[len+1]. ! 141: */ ! 142: void ! 143: new_sym(id, addr, s) char *id; ADDR_T addr; int s; ! 144: { ! 145: register int len, h; ! 146: register SYM *sp; ! 147: ! 148: h = hash(id); ! 149: len = strlen(id); /* len+1 is s_id len with NUL */ ! 150: dbprintf(("new_sym(%s, %x, %lX) len=%d hash=%x\n", id, type, addr, len, h)); ! 151: sp = (SYM *)nalloc(sizeof(SYM) + len, "symbol"); ! 152: sp->s_next = symhash[h]; ! 153: symhash[h] = sp; ! 154: sp->s_addr = addr; ! 155: sp->s_segn = s; ! 156: strcpy(sp->s_id, id); ! 157: } ! 158: ! 159: /* ! 160: * Read COFF symbols. ! 161: */ ! 162: int ! 163: read_coff_sym() ! 164: { ! 165: SYMENT coffsym; ! 166: long n; ! 167: register int len, segn; ! 168: char *strtab; ! 169: SCNHDR *shp; ! 170: ! 171: dbprintf(("read_coff_sym()\n")); ! 172: ! 173: /* Read the COFF string table. */ ! 174: strtab = read_strtab(); ! 175: ! 176: /* Read the COFF section headers. */ ! 177: len = coff_hdr.f_nscns * sizeof(SCNHDR); ! 178: shp = (SCNHDR *)nalloc(len, "COFF section headers"); ! 179: if (fseek(sfp, (long)(sizeof(FILEHDR) + coff_hdr.f_opthdr), SEEK_SET) == -1 ! 180: || fread(shp, len, 1, sfp) != 1) ! 181: return printe("Cannot read section headers"); ! 182: ! 183: /* Read symbols. */ ! 184: if (fseek(sfp, (long)coff_hdr.f_symptr, SEEK_SET) == -1) ! 185: return printe("COFF symbol seek failed"); ! 186: for (nsyms = 0, n = coff_hdr.f_nsyms; n--; ) { ! 187: /* Read a COFF symbol. */ ! 188: if (fread(&coffsym, sizeof(SYMENT), 1, sfp) != 1) ! 189: return printe("Cannot read COFF symbol"); ! 190: switch (coffsym.n_sclass) { ! 191: case C_EXT: ! 192: case C_EXTDEF: ! 193: break; ! 194: default: ! 195: continue; ! 196: } ! 197: /* Ignore undefined and absolute symbols. */ ! 198: if (coffsym.n_scnum == N_UNDEF || coffsym.n_scnum == N_ABS) ! 199: continue; ! 200: ! 201: switch((int)shp[coffsym.n_scnum-1].s_flags) { ! 202: case STYP_TEXT: segn = ISEG; break; ! 203: case STYP_DATA: ! 204: case STYP_BSS: segn = DSEG; break; ! 205: default: ! 206: panic("Unallowed section flags 0x%lX for symbol in section %d", ! 207: shp[coffsym.n_scnum-1].s_flags, coffsym.n_scnum-1); ! 208: } ! 209: ++nsyms; ! 210: new_sym(symName(&coffsym, strtab), coffsym.n_value, segn); ! 211: } ! 212: dbprintf(("COFF nsyms=%d\n", nsyms)); ! 213: if (strtab != NULL) ! 214: nfree(strtab); ! 215: nfree(shp); ! 216: return 1; ! 217: } ! 218: ! 219: /* ! 220: * Read l.out symbols. ! 221: */ ! 222: int ! 223: read_lout_sym(symseek) long symseek; ! 224: { ! 225: register int n, segn; ! 226: struct ldsym lds; ! 227: char id[NCPLN+1]; ! 228: ! 229: if (fseek(sfp, symseek, SEEK_SET) == -1) ! 230: return printr("Cannot seek to l.out symbols"); ! 231: for (n = nsyms; n--; ) { ! 232: /* Read an l.out symbol. */ ! 233: if (fread(&lds, sizeof(struct ldsym), 1, sfp) != 1) ! 234: return printr("Cannot read l.out symbol"); ! 235: canint(lds.ls_type); ! 236: switch(lds.ls_type & LR_SEG) { ! 237: case L_ABS: ! 238: case L_SHRI: ! 239: case L_PRVI: ! 240: case L_BSSI: ! 241: segn = ISEG; ! 242: break; ! 243: case L_SHRD: ! 244: case L_PRVD: ! 245: case L_BSSD: ! 246: segn = DSEG; ! 247: break; ! 248: default: ! 249: dbprintf(("Unexpected l.out segment %d\n", lds.ls_type & LR_SEG)); ! 250: continue; ! 251: } ! 252: canvaddr(lds.ls_addr); ! 253: strncpy(id, lds.ls_id, NCPLN); ! 254: id[NCPLN] = '\0'; ! 255: new_sym(id, (ADDR_T)lds.ls_addr, segn); ! 256: } ! 257: dbprintf(("l.out nsyms=%d\n", nsyms)); ! 258: return 1; ! 259: } ! 260: ! 261: /* ! 262: * Read the COFF string table. ! 263: * Return a pointer to the allocated table, or NULL if empty. ! 264: */ ! 265: char * ! 266: read_strtab() ! 267: { ! 268: register unsigned int len; ! 269: int llen; ! 270: char *strtab; ! 271: ! 272: dbprintf(("read_strtab()\n")); ! 273: len = llen = sizeof(SYMENT) * coff_hdr.f_nsyms; ! 274: if (len == 0) ! 275: return NULL; /* no symbols */ ! 276: if (llen != len) ! 277: panic("COFF symbol table too big"); ! 278: ! 279: /* Seek to strtab length. */ ! 280: if (fseek(sfp, coff_hdr.f_symptr+len, SEEK_SET) == -1 ! 281: || fread(&llen, sizeof(llen), 1, sfp) != 1) ! 282: llen = 0; ! 283: if (llen == 0) ! 284: return NULL; /* no string table */ ! 285: len = llen -= 4; ! 286: if (len != llen) ! 287: panic("COFF string table too big"); ! 288: strtab = nalloc((int)len, "COFF string table"); ! 289: if (fread(strtab, len, 1, sfp) != 1) { ! 290: printe("Cannot read symbol string table"); ! 291: return NULL; ! 292: } ! 293: return strtab; ! 294: } ! 295: ! 296: /* ! 297: * Given a COFF symbol table entry, return its NUL-terminated name. ! 298: */ ! 299: char * ! 300: symName(sym, strtab) SYMENT *sym; char *strtab; ! 301: { ! 302: static char work[SYMNMLEN+1]; ! 303: ! 304: if (sym->n_zeroes == 0) ! 305: return strtab + sym->n_offset - 4; /* name in string table */ ! 306: ! 307: /* Copy name from n_name to make sure it's NUL-terminated. */ ! 308: memcpy(work, sym->n_name, SYMNMLEN); ! 309: work[SYMNMLEN] = '\0'; ! 310: return work; ! 311: } ! 312: ! 313: /* ! 314: * Read a symbol and return its value in the given 'VAL' structure. ! 315: * The symbol name can contain alphanumeric characters and '_'; ! 316: * a leading '%' indicates a register name. ! 317: */ ! 318: int ! 319: symval(vp) VAL *vp; ! 320: { ! 321: register int c; ! 322: register char *cp; ! 323: int regf; ! 324: static SYM *sp; ! 325: static int sym_len = 128; ! 326: ! 327: /* Allocate a SYM first time through. */ ! 328: if (sp == (SYM *)NULL) ! 329: sp = (SYM *)nalloc(sizeof(SYM)+sym_len+1, "symbol id buffer"); ! 330: ! 331: /* Read the symbol name into the SYM id[] buffer. */ ! 332: for (regf = 0, cp = sp->s_id; ; cp++) { ! 333: c = getn(); ! 334: /* Allow leading '%' to indicate register name. */ ! 335: if (cp==sp->s_id && c=='%') { ! 336: c = getn(); ! 337: ++regf; ! 338: } ! 339: if (!isascii(c) || (!isalnum(c) && c!= '_')) ! 340: break; ! 341: if (cp == &sp->s_id[sym_len]) { ! 342: register SYM *sp2; ! 343: ! 344: /* Grow the symbol id buffer when required. */ ! 345: sp2 = (SYM *)nalloc(sizeof(SYM)+sym_len+sym_len+1, "symbol id buffer"); ! 346: strncpy(sp2->s_id, sp->s_id, sym_len); ! 347: cp = &sp2->s_id[sym_len]; ! 348: sym_len += sym_len; ! 349: nfree(sp); ! 350: sp = sp2; ! 351: } ! 352: *cp = c; ! 353: } ! 354: *cp = '\0'; ! 355: ungetn(c); ! 356: if (regf) { ! 357: if (is_reg(sp) == 0) ! 358: return printe("Register not found"); ! 359: } else if (!is_special(sp) && !is_symbol(sp) && !is_reg(sp)) ! 360: return printe("Symbol not found"); ! 361: ! 362: /* Copy the value and segment to vp. */ ! 363: vp->v_nval = (long)sp->s_addr; ! 364: vp->v_segn = sp->s_segn; ! 365: vp->v_flag = VSEGN; ! 366: return 1; ! 367: } ! 368: ! 369: /* end of db/db6.c */ ! 370:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.