![[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] / 43BSDReno / libexec / pcc / ccom.vax|
Return to stab.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / libexec / pcc / ccom.vax |
1.1 ! root 1: #ifndef lint ! 2: static char *sccsid ="@(#)stab.c 1.13 (Berkeley) 12/11/87"; ! 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: Boolean ignore; ! 104: static Boolean firsttime = true; ! 105: ! 106: if (oldway) { ! 107: old_outstab(sym); ! 108: } else if (gdebug and not zero_length_array(sym)) { ! 109: if (firsttime) { ! 110: firsttime = false; ! 111: inittypes(); ! 112: } ! 113: ignore = false; ! 114: p = sym; ! 115: switch (p->sclass) { ! 116: case REGISTER: ! 117: classname = "r"; ! 118: break; ! 119: ! 120: /* ! 121: * Locals are the default class. ! 122: */ ! 123: case AUTO: ! 124: classname = ""; ! 125: break; ! 126: ! 127: case STATIC: ! 128: if (ISFTN(p->stype)) { ! 129: ignore = true; ! 130: } else if (p->slevel <= 1) { ! 131: classname = "S"; ! 132: } else { ! 133: classname = "V"; ! 134: } ! 135: break; ! 136: ! 137: case EXTDEF: ! 138: case EXTERN: ! 139: if (ISFTN(p->stype)) { ! 140: ignore = true; ! 141: } else { ! 142: classname = "G"; ! 143: } ! 144: break; ! 145: ! 146: case TYPEDEF: ! 147: classname = "t"; ! 148: break; ! 149: ! 150: case PARAM: ! 151: case MOS: ! 152: case MOU: ! 153: case MOE: ! 154: ignore = true; ! 155: break; ! 156: ! 157: case ENAME: ! 158: case UNAME: ! 159: case STNAME: ! 160: (void) entertype(p->stype, NILINDEX, FORWARD, dimtab[p->sizoff + 3]); ! 161: ignore = true; ! 162: break; ! 163: ! 164: default: ! 165: if ((p->sclass&FIELD) == 0) { ! 166: printf("/* no info for %s (%d) */\n", p->sname, p->sclass); ! 167: } ! 168: ignore = true; ! 169: break; ! 170: } ! 171: if (not ignore) { ! 172: printf("\t.stabs\t\"%s:%s", p->sname, classname); ! 173: gentype(p); ! 174: geninfo(p); ! 175: } ! 176: } ! 177: } ! 178: ! 179: /* ! 180: * Since type names are lost in the travels and because C has ! 181: * structural type equivalence we keep a table of type words that ! 182: * we've already seen. The first time we see a type, it is assigned ! 183: * (inline) a number and future references just list that number. ! 184: * Structures, unions, enums, and arrays must be handled carefully ! 185: * since not all the necessary information is in the type word. ! 186: */ ! 187: ! 188: typedef struct Typeid *Typeid; ! 189: ! 190: struct Typeid { ! 191: TWORD tword; ! 192: int tarray; ! 193: int tstruct; ! 194: int tstrtag; ! 195: int tnum; ! 196: Typeid chain; ! 197: }; ! 198: ! 199: #define TABLESIZE 2003 ! 200: ! 201: private int tcount = 1; ! 202: private int t_int, t_char; ! 203: private Typeid typetable[TABLESIZE]; ! 204: ! 205: /* ! 206: * Look for the given type word in the type table. ! 207: */ ! 208: ! 209: private Typeid typelookup(type, arrindex, strindex, strtag) ! 210: TWORD type; ! 211: int arrindex; ! 212: int strindex; ! 213: int strtag; ! 214: { ! 215: register TWORD tword; ! 216: register int i1, i2; ! 217: Typeid t; ! 218: ! 219: t = typetable[type mod TABLESIZE]; ! 220: while (t != nil) { ! 221: if (t->tword == type and ! 222: strindex == t->tstruct and strtag == t->tstrtag) { ! 223: if (arrindex == NILINDEX) { ! 224: break; ! 225: } else { ! 226: tword = type; ! 227: i1 = arrindex; ! 228: i2 = t->tarray; ! 229: while (ISARY(tword) and dimtab[i1] == dimtab[i2]) { ! 230: ++i1; ! 231: ++i2; ! 232: tword >>= TSHIFT; ! 233: } ! 234: if (!ISARY(tword)) { ! 235: break; ! 236: } ! 237: } ! 238: } ! 239: t = t->chain; ! 240: } ! 241: return t; ! 242: } ! 243: ! 244: /* ! 245: * Enter a type word and associated symtab indices into the type table. ! 246: */ ! 247: ! 248: private int entertype(type, arrindex, strindex, strtag) ! 249: TWORD type; ! 250: int arrindex; ! 251: int strindex; ! 252: int strtag; ! 253: { ! 254: register Typeid t; ! 255: register int i; ! 256: ! 257: t = (Typeid) malloc(sizeof(struct Typeid)); ! 258: t->tword = type; ! 259: t->tarray = arrindex; ! 260: t->tstruct = strindex; ! 261: t->tstrtag = strtag; ! 262: t->tnum = tcount; ! 263: ++tcount; ! 264: i = type mod TABLESIZE; ! 265: t->chain = typetable[i]; ! 266: typetable[i] = t; ! 267: return t->tnum; ! 268: } ! 269: ! 270: /* ! 271: * Change the information associated with a type table entry. ! 272: * Since I'm lazy this just creates a new entry with the number ! 273: * as the old one. ! 274: */ ! 275: ! 276: private reentertype(typeid, type, arrindex, strindex, strtag) ! 277: Typeid typeid; ! 278: TWORD type; ! 279: int arrindex; ! 280: int strindex; ! 281: int strtag; ! 282: { ! 283: register Typeid t; ! 284: register int i; ! 285: ! 286: t = (Typeid) malloc(sizeof(struct Typeid)); ! 287: t->tword = type; ! 288: t->tarray = arrindex; ! 289: t->tstruct = strindex; ! 290: t->tstrtag = strtag; ! 291: t->tnum = typeid->tnum; ! 292: i = type mod TABLESIZE; ! 293: t->chain = typetable[i]; ! 294: typetable[i] = t; ! 295: } ! 296: ! 297: /* ! 298: * Initialize type table with predefined types. ! 299: */ ! 300: ! 301: #define builtintype(type) entertype(type, NILINDEX, NILINDEX, NILINDEX) ! 302: ! 303: private inittypes() ! 304: { ! 305: int t; ! 306: ! 307: t_int = builtintype(INT); ! 308: t_char = builtintype(CHAR); ! 309: maketype("int", t_int, t_int, 0x80000000L, 0x7fffffffL); ! 310: maketype("char", t_char, t_char, 0L, 127L); ! 311: maketype("long", builtintype(LONG), t_int, 0x80000000L, 0x7fffffffL); ! 312: maketype("short", builtintype(SHORT), t_int, 0xffff8000L, 0x7fffL); ! 313: maketype("unsigned char", builtintype(UCHAR), t_int, 0L, 255L); ! 314: maketype("unsigned short", builtintype(USHORT), t_int, 0L, 0xffffL); ! 315: maketype("unsigned long", builtintype(ULONG), t_int, 0L, 0xffffffffL); ! 316: maketype("unsigned int", builtintype(UNSIGNED), t_int, 0L, 0xffffffffL); ! 317: maketype("float", builtintype(FLOAT), t_int, 4L, 0L); ! 318: maketype("double", builtintype(DOUBLE), t_int, 8L, 0L); ! 319: t = builtintype(UNDEF); ! 320: printf("\t.stabs\t\"void:t%d=%d", t, t); ! 321: geninfo((struct symtab *)nil); ! 322: t = builtintype(FARG); ! 323: printf("\t.stabs\t\"???:t%d=%d", t, t_int); ! 324: geninfo((struct symtab *)nil); ! 325: } ! 326: ! 327: /* ! 328: * Generate info for a new range type. ! 329: */ ! 330: ! 331: private maketype(name, tnum, eqtnum, lower, upper) ! 332: char *name; ! 333: int tnum, eqtnum; ! 334: long lower, upper; ! 335: { ! 336: printf("\t.stabs\t\"%s:t%d=r%d;%d;%d;", name, tnum, eqtnum, lower, upper); ! 337: geninfo((struct symtab *)nil); ! 338: } ! 339: ! 340: /* ! 341: * Generate debugging information for the given type of the given symbol. ! 342: */ ! 343: ! 344: private gentype(sym) ! 345: struct symtab *sym; ! 346: { ! 347: register struct symtab *p; ! 348: register TWORD t; ! 349: register TWORD basictype; ! 350: register Typeid typeid; ! 351: int i, arrindex, strindex, strtag; ! 352: ! 353: p = sym; ! 354: t = p->stype; ! 355: if (ISFTN(t)) { ! 356: t = DECREF(t); ! 357: } ! 358: basictype = BTYPE(t); ! 359: if (ISARY(t)) { ! 360: arrindex = p->dimoff; ! 361: } else { ! 362: arrindex = NILINDEX; ! 363: } ! 364: if (basictype == STRTY or basictype == UNIONTY or basictype == ENUMTY) { ! 365: strindex = dimtab[p->sizoff + 1]; ! 366: if (strindex == -1) { ! 367: strindex = FORWARD; ! 368: strtag = dimtab[p->sizoff + 3]; ! 369: } else { ! 370: strtag = NILINDEX; ! 371: } ! 372: } else { ! 373: strindex = NILINDEX; ! 374: strtag = NILINDEX; ! 375: } ! 376: i = arrindex; ! 377: typeid = typelookup(t, arrindex, strindex, strtag); ! 378: while (t != basictype and typeid == nil) { ! 379: printf("%d=", entertype(t, i, strindex, strtag)); ! 380: switch (t&TMASK) { ! 381: case PTR: ! 382: printf("*"); ! 383: break; ! 384: ! 385: case FTN: ! 386: printf("f"); ! 387: break; ! 388: ! 389: case ARY: ! 390: printf("ar%d;0;%d;", t_int, dimtab[i++] - 1); ! 391: break; ! 392: } ! 393: t = DECREF(t); ! 394: if (i == NILINDEX && ISARY(t)) { ! 395: i = p->dimoff; ! 396: } ! 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: /*ARGSUSED*/ ! 528: outstruct(szindex, paramindex) ! 529: int szindex, paramindex; ! 530: { ! 531: register Typeid typeid; ! 532: register struct symtab *p; ! 533: register int i, t, strindex; ! 534: ! 535: if (oldway) { ! 536: /* do nothing */; ! 537: } else if (gdebug) { ! 538: if ((i = dimtab[szindex + 3]) >= 0 && (p = &stab[i])->sname != nil) { ! 539: strindex = dimtab[p->sizoff + 1]; ! 540: typeid = typelookup(p->stype, NILINDEX, FORWARD, i); ! 541: if (typeid == nil) { ! 542: t = 0; ! 543: } else { ! 544: t = typeid->tnum; ! 545: reentertype(typeid, p->stype, NILINDEX, strindex, NILINDEX); ! 546: } ! 547: printf("\t.stabs\t\"%s:T", p->sname); ! 548: genstruct(p->stype, t, strindex, p->sname, bsize(p)); ! 549: geninfo(p); ! 550: } ! 551: } ! 552: } ! 553: ! 554: pstab(name, type) ! 555: char *name; ! 556: int type; ! 557: { ! 558: #ifndef ASSTRINGS ! 559: register int i; ! 560: register char c; ! 561: #endif ! 562: ! 563: if (!gdebug) { ! 564: return; ! 565: } else if (oldway) { ! 566: old_pstab(name, type); ! 567: return; ! 568: } ! 569: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 570: #ifdef ASSTRINGS ! 571: if ( name[0] == '\0') ! 572: printf("\t.stabn\t"); ! 573: else ! 574: #ifndef FLEXNAMES ! 575: printf("\t.stabs\t\"%.8s\",", name); ! 576: #else ! 577: printf("\t.stabs\t\"%s\",", name); ! 578: #endif ! 579: #else ! 580: printf(" .stab "); ! 581: for(i=0; i<8; i++) ! 582: if (c = name[i]) printf("'%c,", c); ! 583: else printf("0,"); ! 584: #endif ! 585: printf("0%o,", type); ! 586: } ! 587: ! 588: #ifdef STABDOT ! 589: pstabdot(type, value) ! 590: int type; ! 591: int value; ! 592: { ! 593: if ( ! gdebug) { ! 594: return; ! 595: } else if (oldway) { ! 596: old_pstabdot(type, value); ! 597: return; ! 598: } ! 599: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 600: printf("\t.stabd\t"); ! 601: printf("0%o,0,0%o\n",type, value); ! 602: } ! 603: #endif ! 604: ! 605: #ifndef STABDOT ! 606: extern char NULLNAME[8]; ! 607: #endif ! 608: extern int labelno; ! 609: extern int fdefflag; ! 610: ! 611: psline() ! 612: { ! 613: static int lastlineno; ! 614: register char *cp, *cq; ! 615: register int i; ! 616: ! 617: if (!gdebug) { ! 618: return; ! 619: } else if (oldway) { ! 620: old_psline(); ! 621: return; ! 622: } ! 623: ! 624: cq = ititle; ! 625: cp = ftitle; ! 626: ! 627: while ( *cq ) if ( *cp++ != *cq++ ) goto neq; ! 628: if ( *cp == '\0' ) goto eq; ! 629: ! 630: neq: for (i=0; i<100; i++) ! 631: ititle[i] = '\0'; ! 632: cp = ftitle; ! 633: cq = ititle; ! 634: while ( *cp ) ! 635: *cq++ = *cp++; ! 636: *cq = '\0'; ! 637: *--cq = '\0'; ! 638: #ifndef FLEXNAMES ! 639: for ( cp = ititle+1; *(cp-1); cp += 8 ) { ! 640: pstab(cp, N_SOL); ! 641: if (gdebug) printf("0,0,LL%d\n", labelno); ! 642: } ! 643: #else ! 644: pstab(ititle+1, N_SOL); ! 645: if (gdebug) printf("0,0,LL%d\n", labelno); ! 646: #endif ! 647: *cq = '"'; ! 648: printf("LL%d:\n", labelno++); ! 649: ! 650: eq: if (lineno == lastlineno) return; ! 651: lastlineno = lineno; ! 652: ! 653: if (fdefflag) { ! 654: #ifdef STABDOT ! 655: pstabdot(N_SLINE, lineno); ! 656: #else ! 657: pstab(NULLNAME, N_SLINE); ! 658: printf("0,%d,LL%d\n", lineno, labelno); ! 659: printf("LL%d:\n", labelno++); ! 660: #endif ! 661: } ! 662: } ! 663: ! 664: plcstab(level) ! 665: int level; ! 666: { ! 667: if (!gdebug) { ! 668: return; ! 669: } else if (oldway) { ! 670: old_plcstab(level); ! 671: return; ! 672: } ! 673: #ifdef STABDOT ! 674: pstabdot(N_LBRAC, level); ! 675: #else ! 676: pstab(NULLNAME, N_LBRAC); ! 677: printf("0,%d,LL%d\n", level, labelno); ! 678: printf("LL%d:\n", labelno++); ! 679: #endif ! 680: } ! 681: ! 682: prcstab(level) ! 683: int level; ! 684: { ! 685: if (!gdebug) { ! 686: return; ! 687: } else if (oldway) { ! 688: old_prcstab(level); ! 689: return; ! 690: } ! 691: #ifdef STABDOT ! 692: pstabdot(N_RBRAC, level); ! 693: #else ! 694: pstab(NULLNAME, N_RBRAC); ! 695: printf("0,%d,LL%d\n", level, labelno); ! 696: printf("LL%d:\n", labelno++); ! 697: #endif ! 698: } ! 699: ! 700: pfstab(sname) ! 701: char *sname; ! 702: { ! 703: register struct symtab *p; ! 704: ! 705: if (gdebug) { ! 706: if (oldway) { ! 707: old_pfstab(sname); ! 708: } else { ! 709: p = &stab[lookup(sname, 0)]; ! 710: printf("\t.stabs\t\"%s:", p->sname); ! 711: putchar((p->sclass == STATIC) ? 'f' : 'F'); ! 712: gentype(p); ! 713: geninfo(p); ! 714: } ! 715: } ! 716: } ! 717: ! 718: /* ! 719: * Old way of doing things. ! 720: */ ! 721: ! 722: private old_fixarg(p) ! 723: struct symtab *p; { ! 724: if (gdebug) { ! 725: old_pstab(p->sname, N_PSYM); ! 726: if (gdebug) printf("0,%d,%d\n", p->stype, argoff/SZCHAR); ! 727: old_poffs(p); ! 728: } ! 729: } ! 730: ! 731: private old_outstab(p) ! 732: struct symtab *p; { ! 733: register TWORD ptype; ! 734: register char *pname; ! 735: register char pclass; ! 736: register int poffset; ! 737: ! 738: if (!gdebug) return; ! 739: ! 740: ptype = p->stype; ! 741: pname = p->sname; ! 742: pclass = p->sclass; ! 743: poffset = p->offset; ! 744: ! 745: if (ISFTN(ptype)) { ! 746: return; ! 747: } ! 748: ! 749: switch (pclass) { ! 750: ! 751: case AUTO: ! 752: old_pstab(pname, N_LSYM); ! 753: printf("0,%d,%d\n", ptype, (-poffset)/SZCHAR); ! 754: old_poffs(p); ! 755: return; ! 756: ! 757: case EXTDEF: ! 758: case EXTERN: ! 759: old_pstab(pname, N_GSYM); ! 760: printf("0,%d,0\n", ptype); ! 761: old_poffs(p); ! 762: return; ! 763: ! 764: case STATIC: ! 765: #ifdef LCOMM ! 766: /* stabLCSYM is 1 during nidcl so we can get stab type right */ ! 767: old_pstab(pname, stabLCSYM ? N_LCSYM : N_STSYM); ! 768: #else ! 769: old_pstab(pname, N_STSYM); ! 770: #endif ! 771: if (p->slevel > 1) { ! 772: printf("0,%d,L%d\n", ptype, poffset); ! 773: } else { ! 774: printf("0,%d,%s\n", ptype, exname(pname)); ! 775: } ! 776: old_poffs(p); ! 777: return; ! 778: ! 779: case REGISTER: ! 780: old_pstab(pname, N_RSYM); ! 781: printf("0,%d,%d\n", ptype, poffset); ! 782: old_poffs(p); ! 783: return; ! 784: ! 785: case MOS: ! 786: case MOU: ! 787: old_pstab(pname, N_SSYM); ! 788: printf("0,%d,%d\n", ptype, poffset/SZCHAR); ! 789: old_poffs(p); ! 790: return; ! 791: ! 792: case PARAM: ! 793: /* parameter stab entries are processed in dclargs() */ ! 794: return; ! 795: ! 796: default: ! 797: #ifndef FLEXNAMES ! 798: if (ddebug) printf(" No .stab for %.8s\n", pname); ! 799: #else ! 800: if (ddebug) printf(" No .stab for %s\n", pname); ! 801: #endif ! 802: ! 803: } ! 804: } ! 805: ! 806: private old_pstab(name, type) ! 807: char *name; ! 808: int type; { ! 809: #ifndef ASSTRINGS ! 810: register int i; ! 811: register char c; ! 812: #endif ! 813: if (!gdebug) return; ! 814: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 815: #ifdef ASSTRINGS ! 816: if ( name[0] == '\0') ! 817: printf("\t.stabn\t"); ! 818: else ! 819: #ifndef FLEXNAMES ! 820: printf("\t.stabs\t\"%.8s\", ", name); ! 821: #else ! 822: printf("\t.stabs\t\"%s\", ", name); ! 823: #endif ! 824: #else ! 825: printf(" .stab "); ! 826: for(i=0; i<8; i++) ! 827: if (c = name[i]) printf("'%c,", c); ! 828: else printf("0,"); ! 829: #endif ! 830: printf("0%o,", type); ! 831: } ! 832: ! 833: #ifdef STABDOT ! 834: private old_pstabdot(type, value) ! 835: int type; ! 836: int value; ! 837: { ! 838: if ( ! gdebug) return; ! 839: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 840: printf("\t.stabd\t"); ! 841: printf("0%o,0,0%o\n",type, value); ! 842: } ! 843: #endif ! 844: ! 845: private old_poffs(p) ! 846: register struct symtab *p; { ! 847: int s; ! 848: if (!gdebug) return; ! 849: if ((s = dimtab[p->sizoff]/SZCHAR) > 1) { ! 850: old_pstab(p->sname, N_LENG); ! 851: printf("1,0,%d\n", s); ! 852: } ! 853: } ! 854: ! 855: private old_psline() { ! 856: static int lastlineno; ! 857: register char *cp, *cq; ! 858: register int i; ! 859: ! 860: if (!gdebug) return; ! 861: ! 862: cq = ititle; ! 863: cp = ftitle; ! 864: ! 865: while ( *cq ) if ( *cp++ != *cq++ ) goto neq; ! 866: if ( *cp == '\0' ) goto eq; ! 867: ! 868: neq: for (i=0; i<100; i++) ! 869: ititle[i] = '\0'; ! 870: cp = ftitle; ! 871: cq = ititle; ! 872: while ( *cp ) ! 873: *cq++ = *cp++; ! 874: *cq = '\0'; ! 875: *--cq = '\0'; ! 876: #ifndef FLEXNAMES ! 877: for ( cp = ititle+1; *(cp-1); cp += 8 ) { ! 878: old_pstab(cp, N_SOL); ! 879: if (gdebug) printf("0,0,LL%d\n", labelno); ! 880: } ! 881: #else ! 882: old_pstab(ititle+1, N_SOL); ! 883: if (gdebug) printf("0,0,LL%d\n", labelno); ! 884: #endif ! 885: *cq = '"'; ! 886: printf("LL%d:\n", labelno++); ! 887: ! 888: eq: if (lineno == lastlineno) return; ! 889: lastlineno = lineno; ! 890: ! 891: if (fdefflag) { ! 892: #ifdef STABDOT ! 893: old_pstabdot(N_SLINE, lineno); ! 894: #else ! 895: old_pstab(NULLNAME, N_SLINE); ! 896: printf("0,%d,LL%d\n", lineno, labelno); ! 897: printf("LL%d:\n", labelno++); ! 898: #endif ! 899: } ! 900: } ! 901: ! 902: private old_plcstab(level) { ! 903: if (!gdebug) return; ! 904: #ifdef STABDOT ! 905: old_pstabdot(N_LBRAC, level); ! 906: #else ! 907: old_pstab(NULLNAME, N_LBRAC); ! 908: printf("0,%d,LL%d\n", level, labelno); ! 909: printf("LL%d:\n", labelno++); ! 910: #endif ! 911: } ! 912: ! 913: private old_prcstab(level) { ! 914: if (!gdebug) return; ! 915: #ifdef STABDOT ! 916: pstabdot(N_RBRAC, level); ! 917: #else ! 918: pstab(NULLNAME, N_RBRAC); ! 919: printf("0,%d,LL%d\n", level, labelno); ! 920: printf("LL%d:\n", labelno++); ! 921: #endif ! 922: } ! 923: ! 924: private old_pfstab(sname) ! 925: char *sname; { ! 926: if (!gdebug) return; ! 927: pstab(sname, N_FUN); ! 928: #ifndef FLEXNAMES ! 929: printf("0,%d,_%.7s\n", lineno, sname); ! 930: #else ! 931: printf("0,%d,_%s\n", lineno, sname); ! 932: #endif ! 933: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.