1 #ifndef lint 2 static char *sccsid ="@(#)stab.c 1.6 (Berkeley) 12/10/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 } 934