1 #ifndef lint 2 static char *sccsid ="@(#)stab.c 1.12 (Berkeley) 03/27/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 p = &stab[i]; 542 if (p->sname != nil) { 543 strindex = dimtab[p->sizoff + 1]; 544 typeid = typelookup(p->stype, NILINDEX, FORWARD, i); 545 if (typeid == nil) { 546 t = 0; 547 } else { 548 t = typeid->tnum; 549 reentertype(typeid, p->stype, NILINDEX, strindex, NILINDEX); 550 } 551 printf("\t.stabs\t\"%s:T", p->sname); 552 genstruct(p->stype, t, strindex, p->sname, bsize(p)); 553 geninfo(p); 554 } 555 } 556 } 557 558 pstab(name, type) 559 char *name; 560 int type; 561 { 562 register int i; 563 register char c; 564 565 if (!gdebug) { 566 return; 567 } else if (oldway) { 568 old_pstab(name, type); 569 return; 570 } 571 /* locctr(PROG); /* .stabs must appear in .text for c2 */ 572 #ifdef ASSTRINGS 573 if ( name[0] == '\0') 574 printf("\t.stabn\t"); 575 else 576 #ifndef FLEXNAMES 577 printf("\t.stabs\t\"%.8s\",", name); 578 #else 579 printf("\t.stabs\t\"%s\",", name); 580 #endif 581 #else 582 printf(" .stab "); 583 for(i=0; i<8; i++) 584 if (c = name[i]) printf("'%c,", c); 585 else printf("0,"); 586 #endif 587 printf("0%o,", type); 588 } 589 590 #ifdef STABDOT 591 pstabdot(type, value) 592 int type; 593 int value; 594 { 595 if ( ! gdebug) { 596 return; 597 } else if (oldway) { 598 old_pstabdot(type, value); 599 return; 600 } 601 /* locctr(PROG); /* .stabs must appear in .text for c2 */ 602 printf("\t.stabd\t"); 603 printf("0%o,0,0%o\n",type, value); 604 } 605 #endif 606 607 extern char NULLNAME[8]; 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 register int i; 810 register char c; 811 if (!gdebug) return; 812 /* locctr(PROG); /* .stabs must appear in .text for c2 */ 813 #ifdef ASSTRINGS 814 if ( name[0] == '\0') 815 printf("\t.stabn\t"); 816 else 817 #ifndef FLEXNAMES 818 printf("\t.stabs\t\"%.8s\", ", name); 819 #else 820 printf("\t.stabs\t\"%s\", ", name); 821 #endif 822 #else 823 printf(" .stab "); 824 for(i=0; i<8; i++) 825 if (c = name[i]) printf("'%c,", c); 826 else printf("0,"); 827 #endif 828 printf("0%o,", type); 829 } 830 831 #ifdef STABDOT 832 private old_pstabdot(type, value) 833 int type; 834 int value; 835 { 836 if ( ! gdebug) return; 837 /* locctr(PROG); /* .stabs must appear in .text for c2 */ 838 printf("\t.stabd\t"); 839 printf("0%o,0,0%o\n",type, value); 840 } 841 #endif 842 843 private old_poffs(p) 844 register struct symtab *p; { 845 int s; 846 if (!gdebug) return; 847 if ((s = dimtab[p->sizoff]/SZCHAR) > 1) { 848 old_pstab(p->sname, N_LENG); 849 printf("1,0,%d\n", s); 850 } 851 } 852 853 private old_psline() { 854 static int lastlineno; 855 register char *cp, *cq; 856 register int i; 857 858 if (!gdebug) return; 859 860 cq = ititle; 861 cp = ftitle; 862 863 while ( *cq ) if ( *cp++ != *cq++ ) goto neq; 864 if ( *cp == '\0' ) goto eq; 865 866 neq: for (i=0; i<100; i++) 867 ititle[i] = '\0'; 868 cp = ftitle; 869 cq = ititle; 870 while ( *cp ) 871 *cq++ = *cp++; 872 *cq = '\0'; 873 *--cq = '\0'; 874 #ifndef FLEXNAMES 875 for ( cp = ititle+1; *(cp-1); cp += 8 ) { 876 old_pstab(cp, N_SOL); 877 if (gdebug) printf("0,0,LL%d\n", labelno); 878 } 879 #else 880 old_pstab(ititle+1, N_SOL); 881 if (gdebug) printf("0,0,LL%d\n", labelno); 882 #endif 883 *cq = '"'; 884 printf("LL%d:\n", labelno++); 885 886 eq: if (lineno == lastlineno) return; 887 lastlineno = lineno; 888 889 if (fdefflag) { 890 #ifdef STABDOT 891 old_pstabdot(N_SLINE, lineno); 892 #else 893 old_pstab(NULLNAME, N_SLINE); 894 printf("0,%d,LL%d\n", lineno, labelno); 895 printf("LL%d:\n", labelno++); 896 #endif 897 } 898 } 899 900 private old_plcstab(level) { 901 if (!gdebug) return; 902 #ifdef STABDOT 903 old_pstabdot(N_LBRAC, level); 904 #else 905 old_pstab(NULLNAME, N_LBRAC); 906 printf("0,%d,LL%d\n", level, labelno); 907 printf("LL%d:\n", labelno++); 908 #endif 909 } 910 911 private old_prcstab(level) { 912 if (!gdebug) return; 913 #ifdef STABDOT 914 pstabdot(N_RBRAC, level); 915 #else 916 pstab(NULLNAME, N_RBRAC); 917 printf("0,%d,LL%d\n", level, labelno); 918 printf("LL%d:\n", labelno++); 919 #endif 920 } 921 922 private old_pfstab(sname) 923 char *sname; { 924 if (!gdebug) return; 925 pstab(sname, N_FUN); 926 #ifndef FLEXNAMES 927 printf("0,%d,_%.7s\n", lineno, sname); 928 #else 929 printf("0,%d,_%s\n", lineno, sname); 930 #endif 931 } 932