![[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] / 43BSDTahoe / lib / old_compiler / pcc / pcc.tahoe|
Return to stab.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / pcc / pcc.tahoe |
1.1 ! root 1: #ifndef lint ! 2: static char *sccsid ="@(#)stab.c 1.4 (Berkeley) 7/31/86"; ! 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 "pass1.h" ! 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 (i == NILINDEX && ISARY(t)) { ! 398: i = p->dimoff; ! 399: } ! 400: if (t == basictype) { ! 401: typeid = typelookup(t, NILINDEX, strindex, strtag); ! 402: } else { ! 403: typeid = typelookup(t, i, strindex, strtag); ! 404: } ! 405: } ! 406: if (typeid == nil) { ! 407: if (strindex == FORWARD) { ! 408: typeid = typelookup(t, NILINDEX, FORWARD, dimtab[p->sizoff + 3]); ! 409: if (typeid == nil) { ! 410: cerror("unbelievable forward reference"); ! 411: } ! 412: printf("%d", typeid->tnum); ! 413: } else { ! 414: genstruct(t, NILINDEX, strindex, p->sname, bsize(p)); ! 415: } ! 416: } else { ! 417: printf("%d", typeid->tnum); ! 418: } ! 419: } ! 420: ! 421: /* ! 422: * Generate type information for structures, unions, and enumerations. ! 423: */ ! 424: ! 425: private genstruct(t, structid, index, name, size) ! 426: TWORD t; ! 427: int structid; ! 428: int index; ! 429: char *name; ! 430: int size; ! 431: { ! 432: register int i; ! 433: register struct symtab *field; ! 434: int id; ! 435: ! 436: if (structid == NILINDEX) { ! 437: id = entertype(t, NILINDEX, index, NILINDEX); ! 438: } else { ! 439: id = structid; ! 440: } ! 441: switch (t) { ! 442: case STRTY: ! 443: case UNIONTY: ! 444: printf("%d=%c%d", id, t == STRTY ? 's' : 'u', size); ! 445: i = index; ! 446: while (dimtab[i] != -1) { ! 447: field = &stab[dimtab[i]]; ! 448: printf("%s:", field->sname); ! 449: gentype(field); ! 450: if (field->sclass > FIELD) { ! 451: printf(",%d,%d;", field->offset, field->sclass - FIELD); ! 452: } else { ! 453: printf(",%d,%d;", field->offset, ! 454: tsize(field->stype, field->dimoff, field->sizoff)); ! 455: } ! 456: ++i; ! 457: } ! 458: putchar(';'); ! 459: break; ! 460: ! 461: case ENUMTY: ! 462: printf("%d=e", id); ! 463: i = index; ! 464: while (dimtab[i] != -1) { ! 465: field = &stab[dimtab[i]]; ! 466: printf("%s:%d,", field->sname, field->offset); ! 467: i++; ! 468: } ! 469: putchar(';'); ! 470: break; ! 471: ! 472: default: ! 473: cerror("couldn't find basic type %d for %s\n", t, name); ! 474: break; ! 475: } ! 476: } ! 477: ! 478: /* ! 479: * Generate offset and size info. ! 480: */ ! 481: ! 482: private geninfo(p) ! 483: register struct symtab *p; ! 484: { ! 485: int stabtype; ! 486: ! 487: if (p == nil) { ! 488: printf("\",0x%x,0,0,0\n", N_LSYM); ! 489: } else { ! 490: switch (p->sclass) { ! 491: case EXTERN: ! 492: case EXTDEF: ! 493: if (ISFTN(p->stype)) { ! 494: printf("\",0x%x,0,%d,_%s\n", N_FUN, bsize(p), p->sname); ! 495: } else { ! 496: printf("\",0x%x,0,%d,0\n", N_GSYM, bsize(p)); ! 497: } ! 498: break; ! 499: ! 500: case STATIC: ! 501: stabtype = stabLCSYM ? N_LCSYM : N_STSYM; ! 502: if (ISFTN(p->stype)) { ! 503: printf("\",0x%x,0,%d,_%s\n", N_FUN, bsize(p), p->sname); ! 504: } else if (p->slevel > 1) { ! 505: printf("\",0x%x,0,%d,L%d\n", stabtype, bsize(p), p->offset); ! 506: } else { ! 507: printf("\",0x%x,0,%d,_%s\n", stabtype, bsize(p), p->sname); ! 508: } ! 509: break; ! 510: ! 511: case REGISTER: ! 512: printf("\",0x%x,0,%d,%d\n", N_RSYM, bsize(p), p->offset); ! 513: break; ! 514: ! 515: case PARAM: ! 516: printf("\",0x%x,0,%d,%d\n", N_PSYM, bsize(p), bytes(argoff)); ! 517: break; ! 518: ! 519: default: ! 520: printf("\",0x%x,0,%d,%d\n", N_LSYM, bsize(p), bytes(p->offset)); ! 521: break; ! 522: } ! 523: } ! 524: } ! 525: ! 526: /* ! 527: * Generate information for a newly-defined structure. ! 528: */ ! 529: ! 530: outstruct(szindex, paramindex) ! 531: int szindex, paramindex; ! 532: { ! 533: register Typeid typeid; ! 534: register struct symtab *p; ! 535: register int i, t, strindex; ! 536: ! 537: if (oldway) { ! 538: /* do nothing */; ! 539: } else if (gdebug) { ! 540: i = dimtab[szindex + 3]; ! 541: if (i != NILINDEX && (p = &stab[i])->sname != nil) { ! 542: strindex = dimtab[p->sizoff + 1]; ! 543: typeid = typelookup(p->stype, NILINDEX, FORWARD, i); ! 544: if (typeid == nil) { ! 545: t = 0; ! 546: } else { ! 547: t = typeid->tnum; ! 548: reentertype(typeid, p->stype, NILINDEX, strindex, NILINDEX); ! 549: } ! 550: printf("\t.stabs\t\"%s:T", p->sname); ! 551: genstruct(p->stype, t, strindex, p->sname, bsize(p)); ! 552: geninfo(p); ! 553: } ! 554: } ! 555: } ! 556: ! 557: pstab(name, type) ! 558: char *name; ! 559: int type; ! 560: { ! 561: register int i; ! 562: register char c; ! 563: ! 564: if (!gdebug) { ! 565: return; ! 566: } else if (oldway) { ! 567: old_pstab(name, type); ! 568: return; ! 569: } ! 570: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 571: #ifdef ASSTRINGS ! 572: if ( name[0] == '\0') ! 573: printf("\t.stabn\t"); ! 574: else ! 575: #ifndef FLEXNAMES ! 576: printf("\t.stabs\t\"%.8s\",", name); ! 577: #else ! 578: printf("\t.stabs\t\"%s\",", name); ! 579: #endif ! 580: #else ! 581: printf(" .stab "); ! 582: for(i=0; i<8; i++) ! 583: if (c = name[i]) printf("'%c,", c); ! 584: else printf("0,"); ! 585: #endif ! 586: printf("0%o,", type); ! 587: } ! 588: ! 589: #ifdef STABDOT ! 590: pstabdot(type, value) ! 591: int type; ! 592: int value; ! 593: { ! 594: if ( ! gdebug) { ! 595: return; ! 596: } else if (oldway) { ! 597: old_pstabdot(type, value); ! 598: return; ! 599: } ! 600: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 601: printf("\t.stabd\t"); ! 602: printf("0%o,0,0%o\n",type, value); ! 603: } ! 604: #endif ! 605: ! 606: extern char NULLNAME[8]; ! 607: extern int labelno; ! 608: extern int fdefflag; ! 609: ! 610: psline() ! 611: { ! 612: static int lastlineno; ! 613: register char *cp, *cq; ! 614: register int i; ! 615: ! 616: if (!gdebug) { ! 617: return; ! 618: } else if (oldway) { ! 619: old_psline(); ! 620: return; ! 621: } ! 622: ! 623: cq = ititle; ! 624: cp = ftitle; ! 625: ! 626: while ( *cq ) if ( *cp++ != *cq++ ) goto neq; ! 627: if ( *cp == '\0' ) goto eq; ! 628: ! 629: neq: for (i=0; i<100; i++) ! 630: ititle[i] = '\0'; ! 631: cp = ftitle; ! 632: cq = ititle; ! 633: while ( *cp ) ! 634: *cq++ = *cp++; ! 635: *cq = '\0'; ! 636: *--cq = '\0'; ! 637: #ifndef FLEXNAMES ! 638: for ( cp = ititle+1; *(cp-1); cp += 8 ) { ! 639: pstab(cp, N_SOL); ! 640: if (gdebug) printf("0,0,LL%d\n", labelno); ! 641: } ! 642: #else ! 643: pstab(ititle+1, N_SOL); ! 644: if (gdebug) printf("0,0,LL%d\n", labelno); ! 645: #endif ! 646: *cq = '"'; ! 647: printf("LL%d:\n", labelno++); ! 648: ! 649: eq: if (lineno == lastlineno) return; ! 650: lastlineno = lineno; ! 651: ! 652: if (fdefflag) { ! 653: #ifdef STABDOT ! 654: pstabdot(N_SLINE, lineno); ! 655: #else ! 656: pstab(NULLNAME, N_SLINE); ! 657: printf("0,%d,LL%d\n", lineno, labelno); ! 658: printf("LL%d:\n", labelno++); ! 659: #endif ! 660: } ! 661: } ! 662: ! 663: plcstab(level) ! 664: int level; ! 665: { ! 666: if (!gdebug) { ! 667: return; ! 668: } else if (oldway) { ! 669: old_plcstab(level); ! 670: return; ! 671: } ! 672: #ifdef STABDOT ! 673: pstabdot(N_LBRAC, level); ! 674: #else ! 675: pstab(NULLNAME, N_LBRAC); ! 676: printf("0,%d,LL%d\n", level, labelno); ! 677: printf("LL%d:\n", labelno++); ! 678: #endif ! 679: } ! 680: ! 681: prcstab(level) ! 682: int level; ! 683: { ! 684: if (!gdebug) { ! 685: return; ! 686: } else if (oldway) { ! 687: old_prcstab(level); ! 688: return; ! 689: } ! 690: #ifdef STABDOT ! 691: pstabdot(N_RBRAC, level); ! 692: #else ! 693: pstab(NULLNAME, N_RBRAC); ! 694: printf("0,%d,LL%d\n", level, labelno); ! 695: printf("LL%d:\n", labelno++); ! 696: #endif ! 697: } ! 698: ! 699: pfstab(sname) ! 700: char *sname; ! 701: { ! 702: register struct symtab *p; ! 703: ! 704: if (gdebug) { ! 705: if (oldway) { ! 706: old_pfstab(sname); ! 707: } else { ! 708: p = &stab[lookup(sname, 0)]; ! 709: printf("\t.stabs\t\"%s:", p->sname); ! 710: putchar((p->sclass == STATIC) ? 'f' : 'F'); ! 711: gentype(p); ! 712: geninfo(p); ! 713: } ! 714: } ! 715: } ! 716: ! 717: /* ! 718: * Old way of doing things. ! 719: */ ! 720: ! 721: private old_fixarg(p) ! 722: struct symtab *p; { ! 723: if (gdebug) { ! 724: old_pstab(p->sname, N_PSYM); ! 725: if (gdebug) printf("0,%d,%d\n", p->stype, argoff/SZCHAR); ! 726: old_poffs(p); ! 727: } ! 728: } ! 729: ! 730: private old_outstab(p) ! 731: struct symtab *p; { ! 732: register TWORD ptype; ! 733: register char *pname; ! 734: register char pclass; ! 735: register int poffset; ! 736: ! 737: if (!gdebug) return; ! 738: ! 739: ptype = p->stype; ! 740: pname = p->sname; ! 741: pclass = p->sclass; ! 742: poffset = p->offset; ! 743: ! 744: if (ISFTN(ptype)) { ! 745: return; ! 746: } ! 747: ! 748: switch (pclass) { ! 749: ! 750: case AUTO: ! 751: old_pstab(pname, N_LSYM); ! 752: printf("0,%d,%d\n", ptype, (-poffset)/SZCHAR); ! 753: old_poffs(p); ! 754: return; ! 755: ! 756: case EXTDEF: ! 757: case EXTERN: ! 758: old_pstab(pname, N_GSYM); ! 759: printf("0,%d,0\n", ptype); ! 760: old_poffs(p); ! 761: return; ! 762: ! 763: case STATIC: ! 764: #ifdef LCOMM ! 765: /* stabLCSYM is 1 during nidcl so we can get stab type right */ ! 766: old_pstab(pname, stabLCSYM ? N_LCSYM : N_STSYM); ! 767: #else ! 768: old_pstab(pname, N_STSYM); ! 769: #endif ! 770: if (p->slevel > 1) { ! 771: printf("0,%d,L%d\n", ptype, poffset); ! 772: } else { ! 773: printf("0,%d,%s\n", ptype, exname(pname)); ! 774: } ! 775: old_poffs(p); ! 776: return; ! 777: ! 778: case REGISTER: ! 779: old_pstab(pname, N_RSYM); ! 780: printf("0,%d,%d\n", ptype, poffset); ! 781: old_poffs(p); ! 782: return; ! 783: ! 784: case MOS: ! 785: case MOU: ! 786: old_pstab(pname, N_SSYM); ! 787: printf("0,%d,%d\n", ptype, poffset/SZCHAR); ! 788: old_poffs(p); ! 789: return; ! 790: ! 791: case PARAM: ! 792: /* parameter stab entries are processed in dclargs() */ ! 793: return; ! 794: ! 795: default: ! 796: #ifndef FLEXNAMES ! 797: if (ddebug) printf(" No .stab for %.8s\n", pname); ! 798: #else ! 799: if (ddebug) printf(" No .stab for %s\n", pname); ! 800: #endif ! 801: ! 802: } ! 803: } ! 804: ! 805: private old_pstab(name, type) ! 806: char *name; ! 807: int type; { ! 808: register int i; ! 809: register char c; ! 810: if (!gdebug) return; ! 811: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 812: #ifdef ASSTRINGS ! 813: if ( name[0] == '\0') ! 814: printf("\t.stabn\t"); ! 815: else ! 816: #ifndef FLEXNAMES ! 817: printf("\t.stabs\t\"%.8s\", ", name); ! 818: #else ! 819: printf("\t.stabs\t\"%s\", ", name); ! 820: #endif ! 821: #else ! 822: printf(" .stab "); ! 823: for(i=0; i<8; i++) ! 824: if (c = name[i]) printf("'%c,", c); ! 825: else printf("0,"); ! 826: #endif ! 827: printf("0%o,", type); ! 828: } ! 829: ! 830: #ifdef STABDOT ! 831: private old_pstabdot(type, value) ! 832: int type; ! 833: int value; ! 834: { ! 835: if ( ! gdebug) return; ! 836: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 837: printf("\t.stabd\t"); ! 838: printf("0%o,0,0%o\n",type, value); ! 839: } ! 840: #endif ! 841: ! 842: private old_poffs(p) ! 843: register struct symtab *p; { ! 844: int s; ! 845: if (!gdebug) return; ! 846: if ((s = dimtab[p->sizoff]/SZCHAR) > 1) { ! 847: old_pstab(p->sname, N_LENG); ! 848: printf("1,0,%d\n", s); ! 849: } ! 850: } ! 851: ! 852: private old_psline() { ! 853: static int lastlineno; ! 854: register char *cp, *cq; ! 855: register int i; ! 856: ! 857: if (!gdebug) return; ! 858: ! 859: cq = ititle; ! 860: cp = ftitle; ! 861: ! 862: while ( *cq ) if ( *cp++ != *cq++ ) goto neq; ! 863: if ( *cp == '\0' ) goto eq; ! 864: ! 865: neq: for (i=0; i<100; i++) ! 866: ititle[i] = '\0'; ! 867: cp = ftitle; ! 868: cq = ititle; ! 869: while ( *cp ) ! 870: *cq++ = *cp++; ! 871: *cq = '\0'; ! 872: *--cq = '\0'; ! 873: #ifndef FLEXNAMES ! 874: for ( cp = ititle+1; *(cp-1); cp += 8 ) { ! 875: old_pstab(cp, N_SOL); ! 876: if (gdebug) printf("0,0,LL%d\n", labelno); ! 877: } ! 878: #else ! 879: old_pstab(ititle+1, N_SOL); ! 880: if (gdebug) printf("0,0,LL%d\n", labelno); ! 881: #endif ! 882: *cq = '"'; ! 883: printf("LL%d:\n", labelno++); ! 884: ! 885: eq: if (lineno == lastlineno) return; ! 886: lastlineno = lineno; ! 887: ! 888: if (fdefflag) { ! 889: #ifdef STABDOT ! 890: old_pstabdot(N_SLINE, lineno); ! 891: #else ! 892: old_pstab(NULLNAME, N_SLINE); ! 893: printf("0,%d,LL%d\n", lineno, labelno); ! 894: printf("LL%d:\n", labelno++); ! 895: #endif ! 896: } ! 897: } ! 898: ! 899: private old_plcstab(level) { ! 900: if (!gdebug) return; ! 901: #ifdef STABDOT ! 902: old_pstabdot(N_LBRAC, level); ! 903: #else ! 904: old_pstab(NULLNAME, N_LBRAC); ! 905: printf("0,%d,LL%d\n", level, labelno); ! 906: printf("LL%d:\n", labelno++); ! 907: #endif ! 908: } ! 909: ! 910: private old_prcstab(level) { ! 911: if (!gdebug) return; ! 912: #ifdef STABDOT ! 913: pstabdot(N_RBRAC, level); ! 914: #else ! 915: pstab(NULLNAME, N_RBRAC); ! 916: printf("0,%d,LL%d\n", level, labelno); ! 917: printf("LL%d:\n", labelno++); ! 918: #endif ! 919: } ! 920: ! 921: private old_pfstab(sname) ! 922: char *sname; { ! 923: if (!gdebug) return; ! 924: pstab(sname, N_FUN); ! 925: #ifndef FLEXNAMES ! 926: printf("0,%d,_%.7s\n", lineno, sname); ! 927: #else ! 928: printf("0,%d,_%s\n", lineno, sname); ! 929: #endif ! 930: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.