![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / lib / pcc|
Return to stab.c CVS log | Up to [CSRG BSD Unix] / 42BSD / lib / pcc |
1.1 ! root 1: #ifndef lint ! 2: static char *sccsid ="@(#)stab.c 1.10 (Berkeley) 10/22/83"; ! 3: #endif ! 4: /* ! 5: * Symbolic debugging info interface. ! 6: * ! 7: * Here we generate pseudo-ops that cause the assembler to put ! 8: * symbolic debugging information into the object file. ! 9: */ ! 10: ! 11: #include "mfile1" ! 12: ! 13: #include <sys/types.h> ! 14: #include <a.out.h> ! 15: #include <stab.h> ! 16: ! 17: #define private static ! 18: #define and && ! 19: #define or || ! 20: #define not ! ! 21: #define div / ! 22: #define mod % ! 23: #define nil 0 ! 24: ! 25: #define bytes(bits) ((bits) / SZCHAR) ! 26: #define bsize(p) bytes(dimtab[p->sizoff]) /* size in bytes of a symbol */ ! 27: ! 28: #define NILINDEX -1 ! 29: #define FORWARD -2 ! 30: ! 31: typedef int Boolean; ! 32: ! 33: #define false 0 ! 34: #define true 1 ! 35: ! 36: extern int ddebug; ! 37: extern int gdebug; ! 38: extern char *malloc(); ! 39: ! 40: int stabLCSYM; ! 41: ! 42: /* ! 43: * Flag for producing either sdb or dbx symbol information. ! 44: */ ! 45: int oldway = false; ! 46: ! 47: /* ! 48: * Generate debugging info for a parameter. ! 49: * The offset isn't known when it is first entered into the symbol table ! 50: * since the types are read later. ! 51: */ ! 52: ! 53: fixarg(p) ! 54: struct symtab *p; ! 55: { ! 56: if (oldway) { ! 57: old_fixarg(p); ! 58: } else if (gdebug) { ! 59: printf("\t.stabs\t\"%s:p", p->sname); ! 60: gentype(p); ! 61: printf("\",0x%x,0,%d,%d\n", N_PSYM, bsize(p), bytes(argoff)); ! 62: } ! 63: } ! 64: ! 65: /* ! 66: * Determine if the given symbol is a global array with dimension 0, ! 67: * which only makes sense if it's dimension is to be given later. ! 68: * We therefore currently do not generate symbol information for ! 69: * such entries. ! 70: */ ! 71: ! 72: #define isglobal(class) ( \ ! 73: class == EXTDEF or class == EXTERN or class == STATIC \ ! 74: ) ! 75: ! 76: private Boolean zero_length_array(p) ! 77: register struct symtab *p; ! 78: { ! 79: Boolean b; ! 80: int t; ! 81: ! 82: if (not isglobal(p->sclass)) { ! 83: b = false; ! 84: } else { ! 85: t = p->stype; ! 86: if (ISFTN(t)) { ! 87: t = DECREF(t); ! 88: } ! 89: b = (Boolean) (ISARY(t) and dimtab[p->dimoff] == 0); ! 90: } ! 91: return b; ! 92: } ! 93: ! 94: /* ! 95: * Generate debugging info for a given symbol. ! 96: */ ! 97: ! 98: outstab(sym) ! 99: struct symtab *sym; ! 100: { ! 101: register struct symtab *p; ! 102: char *classname; ! 103: int offset; ! 104: Boolean ignore; ! 105: static Boolean firsttime = true; ! 106: ! 107: if (oldway) { ! 108: old_outstab(sym); ! 109: } else if (gdebug and not zero_length_array(sym)) { ! 110: if (firsttime) { ! 111: firsttime = false; ! 112: inittypes(); ! 113: } ! 114: ignore = false; ! 115: p = sym; ! 116: offset = bytes(p->offset); ! 117: switch (p->sclass) { ! 118: case REGISTER: ! 119: classname = "r"; ! 120: offset = p->offset; ! 121: break; ! 122: ! 123: /* ! 124: * Locals are the default class. ! 125: */ ! 126: case AUTO: ! 127: classname = ""; ! 128: break; ! 129: ! 130: case STATIC: ! 131: if (ISFTN(p->stype)) { ! 132: ignore = true; ! 133: } else if (p->slevel <= 1) { ! 134: classname = "S"; ! 135: } else { ! 136: classname = "V"; ! 137: } ! 138: break; ! 139: ! 140: case EXTDEF: ! 141: case EXTERN: ! 142: if (ISFTN(p->stype)) { ! 143: ignore = true; ! 144: } else { ! 145: classname = "G"; ! 146: } ! 147: break; ! 148: ! 149: case TYPEDEF: ! 150: classname = "t"; ! 151: break; ! 152: ! 153: case PARAM: ! 154: case MOS: ! 155: case MOU: ! 156: case MOE: ! 157: ignore = true; ! 158: break; ! 159: ! 160: case ENAME: ! 161: case UNAME: ! 162: case STNAME: ! 163: entertype(p->stype, NILINDEX, FORWARD, dimtab[p->sizoff + 3]); ! 164: ignore = true; ! 165: break; ! 166: ! 167: default: ! 168: if ((p->sclass&FIELD) == 0) { ! 169: printf("/* no info for %s (%d) */\n", p->sname, p->sclass); ! 170: } ! 171: ignore = true; ! 172: break; ! 173: } ! 174: if (not ignore) { ! 175: printf("\t.stabs\t\"%s:%s", p->sname, classname); ! 176: gentype(p); ! 177: geninfo(p); ! 178: } ! 179: } ! 180: } ! 181: ! 182: /* ! 183: * Since type names are lost in the travels and because C has ! 184: * structural type equivalence we keep a table of type words that ! 185: * we've already seen. The first time we see a type, it is assigned ! 186: * (inline) a number and future references just list that number. ! 187: * Structures, unions, enums, and arrays must be handled carefully ! 188: * since not all the necessary information is in the type word. ! 189: */ ! 190: ! 191: typedef struct Typeid *Typeid; ! 192: ! 193: struct Typeid { ! 194: TWORD tword; ! 195: int tarray; ! 196: int tstruct; ! 197: int tstrtag; ! 198: int tnum; ! 199: Typeid chain; ! 200: }; ! 201: ! 202: #define TABLESIZE 2003 ! 203: ! 204: private int tcount = 1; ! 205: private int t_int, t_char; ! 206: private Typeid typetable[TABLESIZE]; ! 207: ! 208: /* ! 209: * Look for the given type word in the type table. ! 210: */ ! 211: ! 212: private Typeid typelookup(type, arrindex, strindex, strtag) ! 213: TWORD type; ! 214: int arrindex; ! 215: int strindex; ! 216: int strtag; ! 217: { ! 218: register TWORD tword; ! 219: register int i1, i2; ! 220: Typeid t; ! 221: ! 222: t = typetable[type mod TABLESIZE]; ! 223: while (t != nil) { ! 224: if (t->tword == type and ! 225: strindex == t->tstruct and strtag == t->tstrtag) { ! 226: if (arrindex == NILINDEX) { ! 227: break; ! 228: } else { ! 229: tword = type; ! 230: i1 = arrindex; ! 231: i2 = t->tarray; ! 232: while (ISARY(tword) and dimtab[i1] == dimtab[i2]) { ! 233: ++i1; ! 234: ++i2; ! 235: tword >>= TSHIFT; ! 236: } ! 237: if (!ISARY(tword)) { ! 238: break; ! 239: } ! 240: } ! 241: } ! 242: t = t->chain; ! 243: } ! 244: return t; ! 245: } ! 246: ! 247: /* ! 248: * Enter a type word and associated symtab indices into the type table. ! 249: */ ! 250: ! 251: private int entertype(type, arrindex, strindex, strtag) ! 252: TWORD type; ! 253: int arrindex; ! 254: int strindex; ! 255: int strtag; ! 256: { ! 257: register Typeid t; ! 258: register int i; ! 259: ! 260: t = (Typeid) malloc(sizeof(struct Typeid)); ! 261: t->tword = type; ! 262: t->tarray = arrindex; ! 263: t->tstruct = strindex; ! 264: t->tstrtag = strtag; ! 265: t->tnum = tcount; ! 266: ++tcount; ! 267: i = type mod TABLESIZE; ! 268: t->chain = typetable[i]; ! 269: typetable[i] = t; ! 270: return t->tnum; ! 271: } ! 272: ! 273: /* ! 274: * Change the information associated with a type table entry. ! 275: * Since I'm lazy this just creates a new entry with the number ! 276: * as the old one. ! 277: */ ! 278: ! 279: private reentertype(typeid, type, arrindex, strindex, strtag) ! 280: Typeid typeid; ! 281: TWORD type; ! 282: int arrindex; ! 283: int strindex; ! 284: int strtag; ! 285: { ! 286: register Typeid t; ! 287: register int i; ! 288: ! 289: t = (Typeid) malloc(sizeof(struct Typeid)); ! 290: t->tword = type; ! 291: t->tarray = arrindex; ! 292: t->tstruct = strindex; ! 293: t->tstrtag = strtag; ! 294: t->tnum = typeid->tnum; ! 295: i = type mod TABLESIZE; ! 296: t->chain = typetable[i]; ! 297: typetable[i] = t; ! 298: } ! 299: ! 300: /* ! 301: * Initialize type table with predefined types. ! 302: */ ! 303: ! 304: #define builtintype(type) entertype(type, NILINDEX, NILINDEX, NILINDEX) ! 305: ! 306: private inittypes() ! 307: { ! 308: int t; ! 309: ! 310: t_int = builtintype(INT); ! 311: t_char = builtintype(CHAR); ! 312: maketype("int", t_int, t_int, 0x80000000L, 0x7fffffffL); ! 313: maketype("char", t_char, t_char, 0L, 127L); ! 314: maketype("long", builtintype(LONG), t_int, 0x80000000L, 0x7fffffffL); ! 315: maketype("short", builtintype(SHORT), t_int, 0xffff8000L, 0x7fffL); ! 316: maketype("unsigned char", builtintype(UCHAR), t_int, 0L, 255L); ! 317: maketype("unsigned short", builtintype(USHORT), t_int, 0L, 0xffffL); ! 318: maketype("unsigned long", builtintype(ULONG), t_int, 0L, 0xffffffffL); ! 319: maketype("unsigned int", builtintype(UNSIGNED), t_int, 0L, 0xffffffffL); ! 320: maketype("float", builtintype(FLOAT), t_int, 4L, 0L); ! 321: maketype("double", builtintype(DOUBLE), t_int, 8L, 0L); ! 322: t = builtintype(UNDEF); ! 323: printf("\t.stabs\t\"void:t%d=%d", t, t); ! 324: geninfo(nil); ! 325: t = builtintype(FARG); ! 326: printf("\t.stabs\t\"???:t%d=%d", t, t_int); ! 327: geninfo(nil); ! 328: } ! 329: ! 330: /* ! 331: * Generate info for a new range type. ! 332: */ ! 333: ! 334: private maketype(name, tnum, eqtnum, lower, upper) ! 335: char *name; ! 336: int tnum, eqtnum; ! 337: long lower, upper; ! 338: { ! 339: printf("\t.stabs\t\"%s:t%d=r%d;%d;%d;", name, tnum, eqtnum, lower, upper); ! 340: geninfo(nil); ! 341: } ! 342: ! 343: /* ! 344: * Generate debugging information for the given type of the given symbol. ! 345: */ ! 346: ! 347: private gentype(sym) ! 348: struct symtab *sym; ! 349: { ! 350: register struct symtab *p; ! 351: register TWORD t; ! 352: register TWORD basictype; ! 353: register Typeid typeid; ! 354: int i, arrindex, strindex, strtag; ! 355: ! 356: p = sym; ! 357: t = p->stype; ! 358: if (ISFTN(t)) { ! 359: t = DECREF(t); ! 360: } ! 361: basictype = BTYPE(t); ! 362: if (ISARY(t)) { ! 363: arrindex = p->dimoff; ! 364: } else { ! 365: arrindex = NILINDEX; ! 366: } ! 367: if (basictype == STRTY or basictype == UNIONTY or basictype == ENUMTY) { ! 368: strindex = dimtab[p->sizoff + 1]; ! 369: if (strindex == -1) { ! 370: strindex = FORWARD; ! 371: strtag = dimtab[p->sizoff + 3]; ! 372: } else { ! 373: strtag = NILINDEX; ! 374: } ! 375: } else { ! 376: strindex = NILINDEX; ! 377: strtag = NILINDEX; ! 378: } ! 379: i = arrindex; ! 380: typeid = typelookup(t, arrindex, strindex, strtag); ! 381: while (t != basictype and typeid == nil) { ! 382: printf("%d=", entertype(t, i, strindex, strtag)); ! 383: switch (t&TMASK) { ! 384: case PTR: ! 385: printf("*"); ! 386: break; ! 387: ! 388: case FTN: ! 389: printf("f"); ! 390: break; ! 391: ! 392: case ARY: ! 393: printf("ar%d;0;%d;", t_int, dimtab[i++] - 1); ! 394: break; ! 395: } ! 396: t = DECREF(t); ! 397: if (t == basictype) { ! 398: typeid = typelookup(t, NILINDEX, strindex, strtag); ! 399: } else { ! 400: typeid = typelookup(t, i, strindex, strtag); ! 401: } ! 402: } ! 403: if (typeid == nil) { ! 404: if (strindex == FORWARD) { ! 405: typeid = typelookup(t, NILINDEX, FORWARD, dimtab[p->sizoff + 3]); ! 406: if (typeid == nil) { ! 407: cerror("unbelievable forward reference"); ! 408: } ! 409: printf("%d", typeid->tnum); ! 410: } else { ! 411: genstruct(t, NILINDEX, strindex, p->sname, bsize(p)); ! 412: } ! 413: } else { ! 414: printf("%d", typeid->tnum); ! 415: } ! 416: } ! 417: ! 418: /* ! 419: * Generate type information for structures, unions, and enumerations. ! 420: */ ! 421: ! 422: private genstruct(t, structid, index, name, size) ! 423: TWORD t; ! 424: int structid; ! 425: int index; ! 426: char *name; ! 427: int size; ! 428: { ! 429: register int i; ! 430: register struct symtab *field; ! 431: int id; ! 432: ! 433: if (structid == NILINDEX) { ! 434: id = entertype(t, NILINDEX, index, NILINDEX); ! 435: } else { ! 436: id = structid; ! 437: } ! 438: switch (t) { ! 439: case STRTY: ! 440: case UNIONTY: ! 441: printf("%d=%c%d", id, t == STRTY ? 's' : 'u', size); ! 442: i = index; ! 443: while (dimtab[i] != -1) { ! 444: field = &stab[dimtab[i]]; ! 445: printf("%s:", field->sname); ! 446: gentype(field); ! 447: if (field->sclass > FIELD) { ! 448: printf(",%d,%d;", field->offset, field->sclass - FIELD); ! 449: } else { ! 450: printf(",%d,%d;", field->offset, ! 451: tsize(field->stype, field->dimoff, field->sizoff)); ! 452: } ! 453: ++i; ! 454: } ! 455: putchar(';'); ! 456: break; ! 457: ! 458: case ENUMTY: ! 459: printf("%d=e", id); ! 460: i = index; ! 461: while (dimtab[i] != -1) { ! 462: field = &stab[dimtab[i]]; ! 463: printf("%s:%d,", field->sname, field->offset); ! 464: i++; ! 465: } ! 466: putchar(';'); ! 467: break; ! 468: ! 469: default: ! 470: cerror("couldn't find basic type %d for %s\n", t, name); ! 471: break; ! 472: } ! 473: } ! 474: ! 475: /* ! 476: * Generate offset and size info. ! 477: */ ! 478: ! 479: private geninfo(p) ! 480: register struct symtab *p; ! 481: { ! 482: int stabtype; ! 483: ! 484: if (p == nil) { ! 485: printf("\",0x%x,0,0,0\n", N_LSYM); ! 486: } else { ! 487: switch (p->sclass) { ! 488: case EXTERN: ! 489: case EXTDEF: ! 490: if (ISFTN(p->stype)) { ! 491: printf("\",0x%x,0,%d,_%s\n", N_FUN, bsize(p), p->sname); ! 492: } else { ! 493: printf("\",0x%x,0,%d,0\n", N_GSYM, bsize(p)); ! 494: } ! 495: break; ! 496: ! 497: case STATIC: ! 498: stabtype = stabLCSYM ? N_LCSYM : N_STSYM; ! 499: if (ISFTN(p->stype)) { ! 500: printf("\",0x%x,0,%d,_%s\n", N_FUN, bsize(p), p->sname); ! 501: } else if (p->slevel > 1) { ! 502: printf("\",0x%x,0,%d,L%d\n", stabtype, bsize(p), p->offset); ! 503: } else { ! 504: printf("\",0x%x,0,%d,_%s\n", stabtype, bsize(p), p->sname); ! 505: } ! 506: break; ! 507: ! 508: case REGISTER: ! 509: printf("\",0x%x,0,%d,%d\n", N_RSYM, bsize(p), p->offset); ! 510: break; ! 511: ! 512: case PARAM: ! 513: printf("\",0x%x,0,%d,%d\n", N_PSYM, bsize(p), bytes(argoff)); ! 514: break; ! 515: ! 516: default: ! 517: printf("\",0x%x,0,%d,%d\n", N_LSYM, bsize(p), bytes(p->offset)); ! 518: break; ! 519: } ! 520: } ! 521: } ! 522: ! 523: /* ! 524: * Generate information for a newly-defined structure. ! 525: */ ! 526: ! 527: outstruct(szindex, paramindex) ! 528: int szindex, paramindex; ! 529: { ! 530: register Typeid typeid; ! 531: register struct symtab *p; ! 532: register int i, t, strindex; ! 533: ! 534: if (oldway) { ! 535: /* do nothing */; ! 536: } else if (gdebug) { ! 537: i = dimtab[szindex + 3]; ! 538: p = &stab[i]; ! 539: if (p->sname != nil) { ! 540: strindex = dimtab[p->sizoff + 1]; ! 541: typeid = typelookup(p->stype, NILINDEX, FORWARD, i); ! 542: if (typeid == nil) { ! 543: t = 0; ! 544: } else { ! 545: t = typeid->tnum; ! 546: reentertype(typeid, p->stype, NILINDEX, strindex, NILINDEX); ! 547: } ! 548: printf("\t.stabs\t\"%s:T", p->sname); ! 549: genstruct(p->stype, t, strindex, p->sname, bsize(p)); ! 550: geninfo(p); ! 551: } ! 552: } ! 553: } ! 554: ! 555: pstab(name, type) ! 556: char *name; ! 557: int type; ! 558: { ! 559: register int i; ! 560: register char c; ! 561: ! 562: if (!gdebug) { ! 563: return; ! 564: } else if (oldway) { ! 565: old_pstab(name, type); ! 566: return; ! 567: } ! 568: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 569: #ifdef ASSTRINGS ! 570: if ( name[0] == '\0') ! 571: printf("\t.stabn\t"); ! 572: else ! 573: #ifndef FLEXNAMES ! 574: printf("\t.stabs\t\"%.8s\",", name); ! 575: #else ! 576: printf("\t.stabs\t\"%s\",", name); ! 577: #endif ! 578: #else ! 579: printf(" .stab "); ! 580: for(i=0; i<8; i++) ! 581: if (c = name[i]) printf("'%c,", c); ! 582: else printf("0,"); ! 583: #endif ! 584: printf("0%o,", type); ! 585: } ! 586: ! 587: #ifdef STABDOT ! 588: pstabdot(type, value) ! 589: int type; ! 590: int value; ! 591: { ! 592: if ( ! gdebug) { ! 593: return; ! 594: } else if (oldway) { ! 595: old_pstabdot(type, value); ! 596: return; ! 597: } ! 598: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 599: printf("\t.stabd\t"); ! 600: printf("0%o,0,0%o\n",type, value); ! 601: } ! 602: #endif ! 603: ! 604: extern char NULLNAME[8]; ! 605: extern int labelno; ! 606: extern int fdefflag; ! 607: ! 608: psline() ! 609: { ! 610: static int lastlineno; ! 611: register char *cp, *cq; ! 612: register int i; ! 613: ! 614: if (!gdebug) { ! 615: return; ! 616: } else if (oldway) { ! 617: old_psline(); ! 618: return; ! 619: } ! 620: ! 621: cq = ititle; ! 622: cp = ftitle; ! 623: ! 624: while ( *cq ) if ( *cp++ != *cq++ ) goto neq; ! 625: if ( *cp == '\0' ) goto eq; ! 626: ! 627: neq: for (i=0; i<100; i++) ! 628: ititle[i] = '\0'; ! 629: cp = ftitle; ! 630: cq = ititle; ! 631: while ( *cp ) ! 632: *cq++ = *cp++; ! 633: *cq = '\0'; ! 634: *--cq = '\0'; ! 635: #ifndef FLEXNAMES ! 636: for ( cp = ititle+1; *(cp-1); cp += 8 ) { ! 637: pstab(cp, N_SOL); ! 638: if (gdebug) printf("0,0,LL%d\n", labelno); ! 639: } ! 640: #else ! 641: pstab(ititle+1, N_SOL); ! 642: if (gdebug) printf("0,0,LL%d\n", labelno); ! 643: #endif ! 644: *cq = '"'; ! 645: printf("LL%d:\n", labelno++); ! 646: ! 647: eq: if (lineno == lastlineno) return; ! 648: lastlineno = lineno; ! 649: ! 650: if (fdefflag) { ! 651: #ifdef STABDOT ! 652: pstabdot(N_SLINE, lineno); ! 653: #else ! 654: pstab(NULLNAME, N_SLINE); ! 655: printf("0,%d,LL%d\n", lineno, labelno); ! 656: printf("LL%d:\n", labelno++); ! 657: #endif ! 658: } ! 659: } ! 660: ! 661: plcstab(level) ! 662: int level; ! 663: { ! 664: if (!gdebug) { ! 665: return; ! 666: } else if (oldway) { ! 667: old_plcstab(level); ! 668: return; ! 669: } ! 670: #ifdef STABDOT ! 671: pstabdot(N_LBRAC, level); ! 672: #else ! 673: pstab(NULLNAME, N_LBRAC); ! 674: printf("0,%d,LL%d\n", level, labelno); ! 675: printf("LL%d:\n", labelno++); ! 676: #endif ! 677: } ! 678: ! 679: prcstab(level) ! 680: int level; ! 681: { ! 682: if (!gdebug) { ! 683: return; ! 684: } else if (oldway) { ! 685: old_prcstab(level); ! 686: return; ! 687: } ! 688: #ifdef STABDOT ! 689: pstabdot(N_RBRAC, level); ! 690: #else ! 691: pstab(NULLNAME, N_RBRAC); ! 692: printf("0,%d,LL%d\n", level, labelno); ! 693: printf("LL%d:\n", labelno++); ! 694: #endif ! 695: } ! 696: ! 697: pfstab(sname) ! 698: char *sname; ! 699: { ! 700: register struct symtab *p; ! 701: ! 702: if (gdebug) { ! 703: if (oldway) { ! 704: old_pfstab(sname); ! 705: } else { ! 706: p = &stab[lookup(sname, 0)]; ! 707: printf("\t.stabs\t\"%s:", p->sname); ! 708: putchar((p->sclass == STATIC) ? 'f' : 'F'); ! 709: gentype(p); ! 710: geninfo(p); ! 711: } ! 712: } ! 713: } ! 714: ! 715: /* ! 716: * Old way of doing things. ! 717: */ ! 718: ! 719: private old_fixarg(p) ! 720: struct symtab *p; { ! 721: if (gdebug) { ! 722: old_pstab(p->sname, N_PSYM); ! 723: if (gdebug) printf("0,%d,%d\n", p->stype, argoff/SZCHAR); ! 724: old_poffs(p); ! 725: } ! 726: } ! 727: ! 728: private old_outstab(p) ! 729: struct symtab *p; { ! 730: register TWORD ptype; ! 731: register char *pname; ! 732: register char pclass; ! 733: register int poffset; ! 734: ! 735: if (!gdebug) return; ! 736: ! 737: ptype = p->stype; ! 738: pname = p->sname; ! 739: pclass = p->sclass; ! 740: poffset = p->offset; ! 741: ! 742: if (ISFTN(ptype)) { ! 743: return; ! 744: } ! 745: ! 746: switch (pclass) { ! 747: ! 748: case AUTO: ! 749: old_pstab(pname, N_LSYM); ! 750: printf("0,%d,%d\n", ptype, (-poffset)/SZCHAR); ! 751: old_poffs(p); ! 752: return; ! 753: ! 754: case EXTDEF: ! 755: case EXTERN: ! 756: old_pstab(pname, N_GSYM); ! 757: printf("0,%d,0\n", ptype); ! 758: old_poffs(p); ! 759: return; ! 760: ! 761: case STATIC: ! 762: #ifdef LCOMM ! 763: /* stabLCSYM is 1 during nidcl so we can get stab type right */ ! 764: old_pstab(pname, stabLCSYM ? N_LCSYM : N_STSYM); ! 765: #else ! 766: old_pstab(pname, N_STSYM); ! 767: #endif ! 768: if (p->slevel > 1) { ! 769: printf("0,%d,L%d\n", ptype, poffset); ! 770: } else { ! 771: printf("0,%d,%s\n", ptype, exname(pname)); ! 772: } ! 773: old_poffs(p); ! 774: return; ! 775: ! 776: case REGISTER: ! 777: old_pstab(pname, N_RSYM); ! 778: printf("0,%d,%d\n", ptype, poffset); ! 779: old_poffs(p); ! 780: return; ! 781: ! 782: case MOS: ! 783: case MOU: ! 784: old_pstab(pname, N_SSYM); ! 785: printf("0,%d,%d\n", ptype, poffset/SZCHAR); ! 786: old_poffs(p); ! 787: return; ! 788: ! 789: case PARAM: ! 790: /* parameter stab entries are processed in dclargs() */ ! 791: return; ! 792: ! 793: default: ! 794: #ifndef FLEXNAMES ! 795: if (ddebug) printf(" No .stab for %.8s\n", pname); ! 796: #else ! 797: if (ddebug) printf(" No .stab for %s\n", pname); ! 798: #endif ! 799: ! 800: } ! 801: } ! 802: ! 803: private old_pstab(name, type) ! 804: char *name; ! 805: int type; { ! 806: register int i; ! 807: register char c; ! 808: if (!gdebug) return; ! 809: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 810: #ifdef ASSTRINGS ! 811: if ( name[0] == '\0') ! 812: printf("\t.stabn\t"); ! 813: else ! 814: #ifndef FLEXNAMES ! 815: printf("\t.stabs\t\"%.8s\", ", name); ! 816: #else ! 817: printf("\t.stabs\t\"%s\", ", name); ! 818: #endif ! 819: #else ! 820: printf(" .stab "); ! 821: for(i=0; i<8; i++) ! 822: if (c = name[i]) printf("'%c,", c); ! 823: else printf("0,"); ! 824: #endif ! 825: printf("0%o,", type); ! 826: } ! 827: ! 828: #ifdef STABDOT ! 829: private old_pstabdot(type, value) ! 830: int type; ! 831: int value; ! 832: { ! 833: if ( ! gdebug) return; ! 834: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 835: printf("\t.stabd\t"); ! 836: printf("0%o,0,0%o\n",type, value); ! 837: } ! 838: #endif ! 839: ! 840: private old_poffs(p) ! 841: register struct symtab *p; { ! 842: int s; ! 843: if (!gdebug) return; ! 844: if ((s = dimtab[p->sizoff]/SZCHAR) > 1) { ! 845: old_pstab(p->sname, N_LENG); ! 846: printf("1,0,%d\n", s); ! 847: } ! 848: } ! 849: ! 850: private old_psline() { ! 851: static int lastlineno; ! 852: register char *cp, *cq; ! 853: register int i; ! 854: ! 855: if (!gdebug) return; ! 856: ! 857: cq = ititle; ! 858: cp = ftitle; ! 859: ! 860: while ( *cq ) if ( *cp++ != *cq++ ) goto neq; ! 861: if ( *cp == '\0' ) goto eq; ! 862: ! 863: neq: for (i=0; i<100; i++) ! 864: ititle[i] = '\0'; ! 865: cp = ftitle; ! 866: cq = ititle; ! 867: while ( *cp ) ! 868: *cq++ = *cp++; ! 869: *cq = '\0'; ! 870: *--cq = '\0'; ! 871: #ifndef FLEXNAMES ! 872: for ( cp = ititle+1; *(cp-1); cp += 8 ) { ! 873: old_pstab(cp, N_SOL); ! 874: if (gdebug) printf("0,0,LL%d\n", labelno); ! 875: } ! 876: #else ! 877: old_pstab(ititle+1, N_SOL); ! 878: if (gdebug) printf("0,0,LL%d\n", labelno); ! 879: #endif ! 880: *cq = '"'; ! 881: printf("LL%d:\n", labelno++); ! 882: ! 883: eq: if (lineno == lastlineno) return; ! 884: lastlineno = lineno; ! 885: ! 886: if (fdefflag) { ! 887: #ifdef STABDOT ! 888: old_pstabdot(N_SLINE, lineno); ! 889: #else ! 890: old_pstab(NULLNAME, N_SLINE); ! 891: printf("0,%d,LL%d\n", lineno, labelno); ! 892: printf("LL%d:\n", labelno++); ! 893: #endif ! 894: } ! 895: } ! 896: ! 897: private old_plcstab(level) { ! 898: if (!gdebug) return; ! 899: #ifdef STABDOT ! 900: old_pstabdot(N_LBRAC, level); ! 901: #else ! 902: old_pstab(NULLNAME, N_LBRAC); ! 903: printf("0,%d,LL%d\n", level, labelno); ! 904: printf("LL%d:\n", labelno++); ! 905: #endif ! 906: } ! 907: ! 908: private old_prcstab(level) { ! 909: if (!gdebug) return; ! 910: #ifdef STABDOT ! 911: pstabdot(N_RBRAC, level); ! 912: #else ! 913: pstab(NULLNAME, N_RBRAC); ! 914: printf("0,%d,LL%d\n", level, labelno); ! 915: printf("LL%d:\n", labelno++); ! 916: #endif ! 917: } ! 918: ! 919: private old_pfstab(sname) ! 920: char *sname; { ! 921: if (!gdebug) return; ! 922: pstab(sname, N_FUN); ! 923: #ifndef FLEXNAMES ! 924: printf("0,%d,_%.7s\n", lineno, sname); ! 925: #else ! 926: printf("0,%d,_%s\n", lineno, sname); ! 927: #endif ! 928: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.