13192Smckusick /* Copyright (c) 1979 Regents of the University of California */ 23192Smckusick 3*7646Speter static char sccsid[] = "@(#)fend.c 1.11 08/02/82"; 43192Smckusick 53192Smckusick #include "whoami.h" 63192Smckusick #include "0.h" 73192Smckusick #include "tree.h" 83192Smckusick #include "opcode.h" 93192Smckusick #include "objfmt.h" 103192Smckusick #include "align.h" 113192Smckusick 123192Smckusick /* 133192Smckusick * this array keeps the pxp counters associated with 143192Smckusick * functions and procedures, so that they can be output 153192Smckusick * when their bodies are encountered 163192Smckusick */ 173192Smckusick int bodycnts[ DSPLYSZ ]; 183192Smckusick 193192Smckusick #ifdef PC 203192Smckusick # include "pc.h" 213192Smckusick # include "pcops.h" 223192Smckusick #endif PC 233192Smckusick 243192Smckusick #ifdef OBJ 253192Smckusick int cntpatch; 263192Smckusick int nfppatch; 273192Smckusick #endif OBJ 283192Smckusick 293192Smckusick struct nl *Fp; 303192Smckusick int pnumcnt; 313192Smckusick /* 323192Smckusick * Funcend is called to 333192Smckusick * finish a block by generating 343192Smckusick * the code for the statements. 353192Smckusick * It then looks for unresolved declarations 363192Smckusick * of labels, procedures and functions, 373192Smckusick * and cleans up the name list. 383192Smckusick * For the program, it checks the 393192Smckusick * semantics of the program 403192Smckusick * statement (yuchh). 413192Smckusick */ 423192Smckusick funcend(fp, bundle, endline) 433192Smckusick struct nl *fp; 443192Smckusick int *bundle; 453192Smckusick int endline; 463192Smckusick { 473192Smckusick register struct nl *p; 483192Smckusick register int i, b; 493192Smckusick int var, inp, out, *blk; 503192Smckusick bool chkref; 513192Smckusick struct nl *iop; 523192Smckusick char *cp; 533192Smckusick extern int cntstat; 543192Smckusick # ifdef PC 553363Speter int savlabel = getlab(); 563363Speter int toplabel = getlab(); 573363Speter int botlabel = getlab(); 583649Speter int proflabel = getlab(); 593363Speter char extname[ BUFSIZ ]; 603192Smckusick # endif PC 613192Smckusick 623192Smckusick cntstat = 0; 633192Smckusick /* 643192Smckusick * yyoutline(); 653192Smckusick */ 663192Smckusick if (program != NIL) 673192Smckusick line = program->value[3]; 683192Smckusick blk = bundle[2]; 693192Smckusick if (fp == NIL) { 703192Smckusick cbn--; 713192Smckusick # ifdef PTREE 723192Smckusick nesting--; 733192Smckusick # endif PTREE 743192Smckusick return; 753192Smckusick } 763192Smckusick #ifdef OBJ 773192Smckusick /* 783192Smckusick * Patch the branch to the 793192Smckusick * entry point of the function 803192Smckusick */ 813192Smckusick patch4(fp->entloc); 823192Smckusick /* 833192Smckusick * Put out the block entrance code and the block name. 843192Smckusick * HDRSZE is the number of bytes of info in the static 853192Smckusick * BEG data area exclusive of the proc name. It is 863192Smckusick * currently defined as: 873192Smckusick /* struct hdr { 883192Smckusick /* long framesze; /* number of bytes of local vars */ 893192Smckusick /* long nargs; /* number of bytes of arguments */ 903192Smckusick /* bool tests; /* TRUE => perform runtime tests */ 913192Smckusick /* short offset; /* offset of procedure in source file */ 923192Smckusick /* char name[1]; /* name of active procedure */ 933192Smckusick /* }; 943192Smckusick */ 953192Smckusick # define HDRSZE (2 * sizeof(long) + sizeof(short) + sizeof(bool)) 963192Smckusick var = put(2, ((lenstr(fp->symbol,0) + HDRSZE) << 8) 973192Smckusick | (cbn == 1 && opt('p') == 0 ? O_NODUMP: O_BEG), (long)0); 983192Smckusick /* 993192Smckusick * output the number of bytes of arguments 1003192Smckusick * this is only checked on formal calls. 1013192Smckusick */ 1023192Smckusick put(2, O_CASE4, cbn == 1 ? (long)0 : (long)(fp->value[NL_OFFS]-DPOFF2)); 1033192Smckusick /* 1043192Smckusick * Output the runtime test mode for the routine 1053192Smckusick */ 1063192Smckusick put(2, sizeof(bool) == 2 ? O_CASE2 : O_CASE4, opt('t') ? TRUE : FALSE); 1073192Smckusick /* 1083192Smckusick * Output line number and routine name 1093192Smckusick */ 1103192Smckusick put(2, O_CASE2, bundle[1]); 1113192Smckusick putstr(fp->symbol, 0); 1123192Smckusick #endif OBJ 1133192Smckusick #ifdef PC 1143192Smckusick /* 1153192Smckusick * put out the procedure entry code 1163192Smckusick */ 1173192Smckusick if ( fp -> class == PROG ) { 1183192Smckusick putprintf( " .text" , 0 ); 1193192Smckusick putprintf( " .align 1" , 0 ); 1203192Smckusick putprintf( " .globl _main" , 0 ); 1213192Smckusick putprintf( "_main:" , 0 ); 1223192Smckusick putprintf( " .word 0" , 0 ); 1235677Smckusic if ( opt ( 't' ) ) { 1245677Smckusic putprintf( " pushl $1" , 0 ); 1255677Smckusic } else { 1265677Smckusic putprintf( " pushl $0" , 0 ); 1275677Smckusic } 1285677Smckusic putprintf( " calls $1,_PCSTART" , 0 ); 1293192Smckusick putprintf( " movl 4(ap),__argc" , 0 ); 1303192Smckusick putprintf( " movl 8(ap),__argv" , 0 ); 1313192Smckusick putprintf( " calls $0,_program" , 0 ); 132*7646Speter putprintf( " pushl $0" , 0 ); 133*7646Speter putprintf( " calls $1,_PCEXIT" , 0 ); 1343192Smckusick ftnno = fp -> entloc; 1353192Smckusick putprintf( " .text" , 0 ); 1363192Smckusick putprintf( " .align 1" , 0 ); 1373192Smckusick putprintf( " .globl _program" , 0 ); 1383192Smckusick putprintf( "_program:" , 0 ); 1393192Smckusick stabfunc( "program" , fp -> class , bundle[1] , 0 ); 1403192Smckusick } else { 1413192Smckusick ftnno = fp -> entloc; 1423192Smckusick putprintf( " .text" , 0 ); 1433192Smckusick putprintf( " .align 1" , 0 ); 1443367Speter sextname( extname , fp -> symbol , cbn - 1 ); 1453428Speter putprintf( " .globl %s%s" , 0 , FORMALPREFIX , extname ); 1463363Speter putprintf( " .globl %s" , 0 , extname ); 1473363Speter putprintf( "%s:" , 0 , extname ); 1483192Smckusick stabfunc( fp -> symbol , fp -> class , bundle[1] , cbn - 1 ); 1493192Smckusick for ( p = fp -> chain ; p != NIL ; p = p -> chain ) { 1503192Smckusick stabparam( p -> symbol , p2type( p -> type ) 1513192Smckusick , p -> value[ NL_OFFS ] , lwidth( p -> type ) ); 1523192Smckusick } 1533192Smckusick if ( fp -> class == FUNC ) { 1543192Smckusick /* 1553192Smckusick * stab the function variable 1563192Smckusick */ 1573192Smckusick p = fp -> ptr[ NL_FVAR ]; 1583192Smckusick stablvar( p -> symbol , p2type( p -> type ) , cbn 1593192Smckusick , p -> value[ NL_OFFS ] , lwidth( p -> type ) ); 1603192Smckusick } 1613192Smckusick /* 1623192Smckusick * stab local variables 1633192Smckusick * rummage down hash chain links. 1643192Smckusick */ 1653192Smckusick for ( i = 0 ; i <= 077 ; i++ ) { 1663192Smckusick for ( p = disptab[ i ] ; p != NIL ; p = p->nl_next) { 1673192Smckusick if ( ( p -> nl_block & 037 ) != cbn ) { 1683192Smckusick break; 1693192Smckusick } 1703192Smckusick /* 1713192Smckusick * stab local variables 1723192Smckusick * that's named variables, but not params 1733192Smckusick */ 1743192Smckusick if ( ( p -> symbol != NIL ) 1753192Smckusick && ( p -> class == VAR ) 1763192Smckusick && ( p -> value[ NL_OFFS ] < 0 ) ) { 1773192Smckusick stablvar( p -> symbol , p2type( p -> type ) , cbn 1783192Smckusick , p -> value[ NL_OFFS ] , lwidth( p -> type ) ); 1793192Smckusick } 1803192Smckusick } 1813192Smckusick } 1823192Smckusick } 1833192Smckusick stablbrac( cbn ); 1843192Smckusick /* 1853192Smckusick * register save mask 1863192Smckusick */ 1873279Smckusic putprintf( " .word " , 1 ); 1883279Smckusic putprintf( PREFIXFORMAT , 0 , LABELPREFIX , savlabel ); 1893192Smckusick putjbr( botlabel ); 1903192Smckusick putlab( toplabel ); 1913192Smckusick if ( profflag ) { 1923192Smckusick /* 1933192Smckusick * call mcount for profiling 1943192Smckusick */ 1953649Speter putprintf( " moval " , 1 ); 1963649Speter putprintf( PREFIXFORMAT , 1 , LABELPREFIX , proflabel ); 1973649Speter putprintf( ",r0" , 0 ); 1983192Smckusick putprintf( " jsb mcount" , 0 ); 1993192Smckusick putprintf( " .data" , 0 ); 2003192Smckusick putprintf( " .align 2" , 0 ); 2013649Speter putlab( proflabel ); 2023192Smckusick putprintf( " .long 0" , 0 ); 2033192Smckusick putprintf( " .text" , 0 ); 2043192Smckusick } 2053192Smckusick /* 2063192Smckusick * set up unwind exception vector. 2073192Smckusick */ 2083192Smckusick putprintf( " moval %s,%d(%s)" , 0 2093192Smckusick , UNWINDNAME , UNWINDOFFSET , P2FPNAME ); 2103192Smckusick /* 2113192Smckusick * save address of display entry, for unwind. 2123192Smckusick */ 2133192Smckusick putprintf( " moval %s+%d,%d(%s)" , 0 2143192Smckusick , DISPLAYNAME , cbn * sizeof(struct dispsave) 2153192Smckusick , DPTROFFSET , P2FPNAME ); 2163192Smckusick /* 2173192Smckusick * save old display 2183192Smckusick */ 2193192Smckusick putprintf( " movq %s+%d,%d(%s)" , 0 2203192Smckusick , DISPLAYNAME , cbn * sizeof(struct dispsave) 2213192Smckusick , DSAVEOFFSET , P2FPNAME ); 2223192Smckusick /* 2233192Smckusick * set up new display by saving AP and FP in appropriate 2243192Smckusick * slot in display structure. 2253192Smckusick */ 2263192Smckusick putprintf( " movq %s,%s+%d" , 0 2273192Smckusick , P2APNAME , DISPLAYNAME , cbn * sizeof(struct dispsave) ); 2283192Smckusick /* 2295677Smckusic * set underflow checking if runtime tests 2305677Smckusic */ 2315677Smckusic if ( opt( 't' ) ) { 2325677Smckusic putprintf( " bispsw $0xe0" , 0 ); 2335677Smckusic } 2345677Smckusic /* 2353192Smckusick * ask second pass to allocate known locals 2363192Smckusick */ 2373192Smckusick putlbracket( ftnno , -sizes[ cbn ].om_max ); 2383192Smckusick /* 2393192Smckusick * and zero them if checking is on 2403192Smckusick * by calling blkclr( bytes of locals , starting local address ); 2413192Smckusick */ 2423301Smckusic if ( opt( 't' ) && ( -sizes[ cbn ].om_max ) > DPOFF1 ) { 2433301Smckusic putleaf( P2ICON , 0 , 0 , ADDTYPE( P2FTN | P2INT , P2PTR ) 2443301Smckusic , "_blkclr" ); 2453301Smckusic putleaf( P2ICON , ( -sizes[ cbn ].om_max ) - DPOFF1 2463301Smckusic , 0 , P2INT , 0 ); 2473837Speter putLV( 0 , cbn , sizes[ cbn ].om_max , NLOCAL , P2CHAR ); 2483301Smckusic putop( P2LISTOP , P2INT ); 2493301Smckusic putop( P2CALL , P2INT ); 2503301Smckusic putdot( filename , line ); 2513192Smckusick } 2523192Smckusick #endif PC 2533192Smckusick if ( monflg ) { 2543192Smckusick if ( fp -> value[ NL_CNTR ] != 0 ) { 2553192Smckusick inccnt( fp -> value [ NL_CNTR ] ); 2563192Smckusick } 2573192Smckusick inccnt( bodycnts[ fp -> nl_block & 037 ] ); 2583192Smckusick } 2593192Smckusick if (fp->class == PROG) { 2603192Smckusick /* 2613192Smckusick * The glorious buffers option. 2623192Smckusick * 0 = don't buffer output 2633192Smckusick * 1 = line buffer output 2643192Smckusick * 2 = 512 byte buffer output 2653192Smckusick */ 2663192Smckusick # ifdef OBJ 2673192Smckusick if (opt('b') != 1) 2683192Smckusick put(1, O_BUFF | opt('b') << 8); 2693192Smckusick # endif OBJ 2703192Smckusick # ifdef PC 2713192Smckusick if ( opt( 'b' ) != 1 ) { 2723192Smckusick putleaf( P2ICON , 0 , 0 2733192Smckusick , ADDTYPE( P2FTN | P2INT , P2PTR ) , "_BUFF" ); 2743192Smckusick putleaf( P2ICON , opt( 'b' ) , 0 , P2INT , 0 ); 2753192Smckusick putop( P2CALL , P2INT ); 2763192Smckusick putdot( filename , line ); 2773192Smckusick } 2783192Smckusick # endif PC 2793192Smckusick out = 0; 2803192Smckusick for (p = fp->chain; p != NIL; p = p->chain) { 2813192Smckusick if (strcmp(p->symbol, "input") == 0) { 2823192Smckusick inp++; 2833192Smckusick continue; 2843192Smckusick } 2853192Smckusick if (strcmp(p->symbol, "output") == 0) { 2863192Smckusick out++; 2873192Smckusick continue; 2883192Smckusick } 2893192Smckusick iop = lookup1(p->symbol); 2903192Smckusick if (iop == NIL || bn != cbn) { 2913192Smckusick error("File %s listed in program statement but not declared", p->symbol); 2923192Smckusick continue; 2933192Smckusick } 2943192Smckusick if (iop->class != VAR) { 2953192Smckusick error("File %s listed in program statement but declared as a %s", p->symbol, classes[iop->class]); 2963192Smckusick continue; 2973192Smckusick } 2983192Smckusick if (iop->type == NIL) 2993192Smckusick continue; 3003192Smckusick if (iop->type->class != FILET) { 3013192Smckusick error("File %s listed in program statement but defined as %s", 3023192Smckusick p->symbol, nameof(iop->type)); 3033192Smckusick continue; 3043192Smckusick } 3053192Smckusick # ifdef OBJ 3063192Smckusick put(2, O_CON24, text(iop->type) ? 0 : width(iop->type->type)); 3073192Smckusick i = lenstr(p->symbol,0); 3083192Smckusick put(2, O_CON24, i); 3093192Smckusick put(2, O_LVCON, i); 3103192Smckusick putstr(p->symbol, 0); 3113192Smckusick put(2, O_LV | bn<<8+INDX, (int)iop->value[NL_OFFS]); 3123192Smckusick put(1, O_DEFNAME); 3133192Smckusick # endif OBJ 3143192Smckusick # ifdef PC 3153192Smckusick putleaf( P2ICON , 0 , 0 3163192Smckusick , ADDTYPE( P2FTN | P2INT , P2PTR ) 3173192Smckusick , "_DEFNAME" ); 3183837Speter putLV( p -> symbol , bn , iop -> value[NL_OFFS] , 3193837Speter iop -> extra_flags , p2type( iop ) ); 3203192Smckusick putCONG( p -> symbol , strlen( p -> symbol ) 3213192Smckusick , LREQ ); 3223192Smckusick putop( P2LISTOP , P2INT ); 3233192Smckusick putleaf( P2ICON , strlen( p -> symbol ) 3243192Smckusick , 0 , P2INT , 0 ); 3253192Smckusick putop( P2LISTOP , P2INT ); 3263192Smckusick putleaf( P2ICON 3273192Smckusick , text(iop->type) ? 0 : width(iop->type->type) 3283192Smckusick , 0 , P2INT , 0 ); 3293192Smckusick putop( P2LISTOP , P2INT ); 3303192Smckusick putop( P2CALL , P2INT ); 3313192Smckusick putdot( filename , line ); 3323192Smckusick # endif PC 3333192Smckusick } 3343192Smckusick if (out == 0 && fp->chain != NIL) { 3353192Smckusick recovered(); 3363192Smckusick error("The file output must appear in the program statement file list"); 3373192Smckusick } 3383192Smckusick } 3393192Smckusick /* 3403192Smckusick * Process the prog/proc/func body 3413192Smckusick */ 3423192Smckusick noreach = 0; 3433192Smckusick line = bundle[1]; 3443192Smckusick statlist(blk); 3453192Smckusick # ifdef PTREE 3463192Smckusick { 3473192Smckusick pPointer Body = tCopy( blk ); 3483192Smckusick 3493192Smckusick pDEF( PorFHeader[ nesting -- ] ).PorFBody = Body; 3503192Smckusick } 3513192Smckusick # endif PTREE 3523192Smckusick # ifdef OBJ 3533192Smckusick if (cbn== 1 && monflg != 0) { 3543192Smckusick patchfil(cntpatch - 2, (long)cnts, 2); 3553192Smckusick patchfil(nfppatch - 2, (long)pfcnt, 2); 3563192Smckusick } 3573192Smckusick # endif OBJ 3583192Smckusick # ifdef PC 3593192Smckusick if ( fp -> class == PROG && monflg ) { 3603192Smckusick putleaf( P2ICON , 0 , 0 , ADDTYPE( P2FTN | P2INT , P2PTR ) 3613192Smckusick , "_PMFLUSH" ); 3623192Smckusick putleaf( P2ICON , cnts , 0 , P2INT , 0 ); 3633192Smckusick putleaf( P2ICON , pfcnt , 0 , P2INT , 0 ); 3643192Smckusick putop( P2LISTOP , P2INT ); 3653837Speter putLV( PCPCOUNT , 0 , 0 , NGLOBAL , P2INT ); 3663192Smckusick putop( P2LISTOP , P2INT ); 3673192Smckusick putop( P2CALL , P2INT ); 3683192Smckusick putdot( filename , line ); 3693192Smckusick } 3703192Smckusick # endif PC 3713192Smckusick if (fp->class == PROG && inp == 0 && (input->nl_flags & (NUSED|NMOD)) != 0) { 3723192Smckusick recovered(); 3733192Smckusick error("Input is used but not defined in the program statement"); 3743192Smckusick } 3753192Smckusick /* 3763192Smckusick * Clean up the symbol table displays and check for unresolves 3773192Smckusick */ 3783192Smckusick line = endline; 3793192Smckusick b = cbn; 3803192Smckusick Fp = fp; 3813192Smckusick chkref = syneflg == errcnt[cbn] && opt('w') == 0; 3823192Smckusick for (i = 0; i <= 077; i++) { 3833192Smckusick for (p = disptab[i]; p != NIL && (p->nl_block & 037) == b; p = p->nl_next) { 3843192Smckusick /* 3853192Smckusick * Check for variables defined 3863192Smckusick * but not referenced 3873192Smckusick */ 3883192Smckusick if (chkref && p->symbol != NIL) 3893192Smckusick switch (p->class) { 3903192Smckusick case FIELD: 3913192Smckusick /* 3923192Smckusick * If the corresponding record is 3933192Smckusick * unused, we shouldn't complain about 3943192Smckusick * the fields. 3953192Smckusick */ 3963192Smckusick default: 3973192Smckusick if ((p->nl_flags & (NUSED|NMOD)) == 0) { 3983192Smckusick warning(); 3993192Smckusick nerror("%s %s is neither used nor set", classes[p->class], p->symbol); 4003192Smckusick break; 4013192Smckusick } 4023192Smckusick /* 4033192Smckusick * If a var parameter is either 4043192Smckusick * modified or used that is enough. 4053192Smckusick */ 4063192Smckusick if (p->class == REF) 4073192Smckusick continue; 4083192Smckusick # ifdef OBJ 4093192Smckusick if ((p->nl_flags & NUSED) == 0) { 4103192Smckusick warning(); 4113192Smckusick nerror("%s %s is never used", classes[p->class], p->symbol); 4123192Smckusick break; 4133192Smckusick } 4143192Smckusick # endif OBJ 4153192Smckusick # ifdef PC 4163837Speter if (((p->nl_flags & NUSED) == 0) && ((p->extra_flags & NEXTERN) == 0)) { 4173192Smckusick warning(); 4183192Smckusick nerror("%s %s is never used", classes[p->class], p->symbol); 4193192Smckusick break; 4203192Smckusick } 4213192Smckusick # endif PC 4223192Smckusick if ((p->nl_flags & NMOD) == 0) { 4233192Smckusick warning(); 4243192Smckusick nerror("%s %s is used but never set", classes[p->class], p->symbol); 4253192Smckusick break; 4263192Smckusick } 4273192Smckusick case LABEL: 4283192Smckusick case FVAR: 4293192Smckusick case BADUSE: 4303192Smckusick break; 4313192Smckusick } 4323192Smckusick switch (p->class) { 4333192Smckusick case BADUSE: 4343192Smckusick cp = "s"; 4353192Smckusick if (p->chain->ud_next == NIL) 4363192Smckusick cp++; 4373192Smckusick eholdnl(); 4383192Smckusick if (p->value[NL_KINDS] & ISUNDEF) 4393192Smckusick nerror("%s undefined on line%s", p->symbol, cp); 4403192Smckusick else 4413192Smckusick nerror("%s improperly used on line%s", p->symbol, cp); 4423192Smckusick pnumcnt = 10; 4433192Smckusick pnums(p->chain); 4443192Smckusick pchr('\n'); 4453192Smckusick break; 4463192Smckusick 4473192Smckusick case FUNC: 4483192Smckusick case PROC: 4493192Smckusick # ifdef OBJ 4503192Smckusick if ((p->nl_flags & NFORWD)) 4513192Smckusick nerror("Unresolved forward declaration of %s %s", classes[p->class], p->symbol); 4523192Smckusick # endif OBJ 4533192Smckusick # ifdef PC 4543837Speter if ((p->nl_flags & NFORWD) && ((p->extra_flags & NEXTERN) == 0)) 4553192Smckusick nerror("Unresolved forward declaration of %s %s", classes[p->class], p->symbol); 4563192Smckusick # endif PC 4573192Smckusick break; 4583192Smckusick 4593192Smckusick case LABEL: 4603192Smckusick if (p->nl_flags & NFORWD) 4613192Smckusick nerror("label %s was declared but not defined", p->symbol); 4623192Smckusick break; 4633192Smckusick case FVAR: 4643192Smckusick if ((p->nl_flags & NMOD) == 0) 4653192Smckusick nerror("No assignment to the function variable"); 4663192Smckusick break; 4673192Smckusick } 4683192Smckusick } 4693192Smckusick /* 4703192Smckusick * Pop this symbol 4713192Smckusick * table slot 4723192Smckusick */ 4733192Smckusick disptab[i] = p; 4743192Smckusick } 4753192Smckusick 4763192Smckusick # ifdef OBJ 4773192Smckusick put(1, O_END); 4783192Smckusick # endif OBJ 4793192Smckusick # ifdef PC 4803192Smckusick /* 4813192Smckusick * if there were file variables declared at this level 4823192Smckusick * call pclose( &__disply[ cbn ] ) to clean them up. 4833192Smckusick */ 4843192Smckusick if ( dfiles[ cbn ] ) { 4853192Smckusick putleaf( P2ICON , 0 , 0 , ADDTYPE( P2FTN | P2INT , P2PTR ) 4863192Smckusick , "_PCLOSE" ); 4873837Speter putRV( DISPLAYNAME , 0 , cbn * sizeof( struct dispsave ) , 4883837Speter NGLOBAL , P2PTR | P2CHAR ); 4893192Smckusick putop( P2CALL , P2INT ); 4903192Smckusick putdot( filename , line ); 4913192Smckusick } 4923192Smckusick /* 4933192Smckusick * if this is a function, 4943192Smckusick * the function variable is the return value. 4953192Smckusick * if it's a scalar valued function, return scalar, 4963192Smckusick * else, return a pointer to the structure value. 4973192Smckusick */ 4983192Smckusick if ( fp -> class == FUNC ) { 4993192Smckusick struct nl *fvar = fp -> ptr[ NL_FVAR ]; 5003192Smckusick long fvartype = p2type( fvar -> type ); 5013192Smckusick long label; 5023192Smckusick char labelname[ BUFSIZ ]; 5033192Smckusick 5043192Smckusick switch ( classify( fvar -> type ) ) { 5053192Smckusick case TBOOL: 5063192Smckusick case TCHAR: 5073192Smckusick case TINT: 5083192Smckusick case TSCAL: 5093192Smckusick case TDOUBLE: 5103192Smckusick case TPTR: 5113837Speter putRV( fvar -> symbol , ( fvar -> nl_block ) & 037 , 5123837Speter fvar -> value[ NL_OFFS ] , 5133837Speter fvar -> extra_flags , 5143837Speter fvartype ); 5153192Smckusick break; 5163192Smckusick default: 5173192Smckusick label = getlab(); 5183192Smckusick sprintf( labelname , PREFIXFORMAT , 5193192Smckusick LABELPREFIX , label ); 5203192Smckusick putprintf( " .data" , 0 ); 5213192Smckusick putprintf( " .lcomm %s,%d" , 0 , 5223192Smckusick labelname , lwidth( fvar -> type ) ); 5233192Smckusick putprintf( " .text" , 0 ); 5243192Smckusick putleaf( P2NAME , 0 , 0 , fvartype , labelname ); 5253837Speter putLV( fvar -> symbol , ( fvar -> nl_block ) & 037 , 5263837Speter fvar -> value[ NL_OFFS ] , 5273837Speter fvar -> extra_flags , 5283837Speter fvartype ); 5293192Smckusick putstrop( P2STASG , fvartype , lwidth( fvar -> type ) , 5303192Smckusick align( fvar -> type ) ); 5313192Smckusick putdot( filename , line ); 5323192Smckusick putleaf( P2ICON , 0 , 0 , fvartype , labelname ); 5333192Smckusick break; 5343192Smckusick } 5353192Smckusick putop( P2FORCE , fvartype ); 5363192Smckusick putdot( filename , line ); 5373192Smckusick } 5383192Smckusick /* 5393192Smckusick * restore old display entry from save area 5403192Smckusick */ 5413192Smckusick 5423192Smckusick putprintf( " movq %d(%s),%s+%d" , 0 5433192Smckusick , DSAVEOFFSET , P2FPNAME 5443192Smckusick , DISPLAYNAME , cbn * sizeof(struct dispsave) ); 5453192Smckusick stabrbrac( cbn ); 5463192Smckusick putprintf( " ret" , 0 ); 5473192Smckusick /* 5483192Smckusick * let the second pass allocate locals 5493279Smckusic * and registers 5503192Smckusick */ 5513279Smckusic putprintf( " .set " , 1 ); 5523279Smckusic putprintf( PREFIXFORMAT , 1 , LABELPREFIX , savlabel ); 5533279Smckusic putprintf( ", 0x%x" , 0 , savmask() ); 5543192Smckusick putlab( botlabel ); 5553192Smckusick putprintf( " subl2 $LF%d,sp" , 0 , ftnno ); 5563192Smckusick putrbracket( ftnno ); 5573192Smckusick putjbr( toplabel ); 5583192Smckusick /* 5593428Speter * put down the entry point for formal calls 5603428Speter * the arguments for FCALL have been passed to us 5613428Speter * as hidden parameters after the regular arguments. 5623428Speter */ 5633428Speter if ( fp -> class != PROG ) { 5643428Speter putprintf( "%s%s:" , 0 , FORMALPREFIX , extname ); 5653428Speter putprintf( " .word " , 1 ); 5663428Speter putprintf( PREFIXFORMAT , 0 , LABELPREFIX , savlabel ); 5673428Speter putleaf( P2ICON , 0 , 0 , ADDTYPE( P2FTN | P2INT , P2PTR ) , 5683428Speter "_FCALL" ); 5693428Speter putRV( 0 , cbn , 5703428Speter fp -> value[ NL_OFFS ] + sizeof( struct formalrtn * ) , 5713837Speter NPARAM , 5723428Speter P2PTR | P2STRTY ); 5733837Speter putRV( 0 , cbn , fp -> value[ NL_OFFS ] , 5743837Speter NPARAM , P2PTR|P2STRTY ); 5753428Speter putop( P2LISTOP , P2INT ); 5763428Speter putop( P2CALL , P2INT ); 5773428Speter putdot( filename , line ); 5783428Speter putjbr( botlabel ); 5793428Speter } 5803428Speter /* 5813192Smckusick * declare pcp counters, if any 5823192Smckusick */ 5833192Smckusick if ( monflg && fp -> class == PROG ) { 5843192Smckusick putprintf( " .data" , 0 ); 5853192Smckusick putprintf( " .comm " , 1 ); 5863192Smckusick putprintf( PCPCOUNT , 1 ); 5873192Smckusick putprintf( ",%d" , 0 , ( cnts + 1 ) * sizeof (long) ); 5883192Smckusick putprintf( " .text" , 0 ); 5893192Smckusick } 5903192Smckusick # endif PC 5913192Smckusick #ifdef DEBUG 5923192Smckusick dumpnl(fp->ptr[2], fp->symbol); 5933192Smckusick #endif 5945654Slinton 5955654Slinton #ifdef OBJ 5963192Smckusick /* 5975654Slinton * save the namelist for the debugger pdx 5985654Slinton */ 5995654Slinton 6005654Slinton savenl(fp->ptr[2], fp->symbol); 6015654Slinton #endif 6025654Slinton 6035654Slinton /* 6043192Smckusick * Restore the 6053192Smckusick * (virtual) name list 6063192Smckusick * position 6073192Smckusick */ 6083192Smckusick nlfree(fp->ptr[2]); 6093192Smckusick /* 6103192Smckusick * Proc/func has been 6113192Smckusick * resolved 6123192Smckusick */ 6133192Smckusick fp->nl_flags &= ~NFORWD; 6143192Smckusick /* 6153192Smckusick * Patch the beg 6163192Smckusick * of the proc/func to 6173192Smckusick * the proper variable size 6183192Smckusick */ 6193192Smckusick if (Fp == NIL) 6203192Smckusick elineon(); 6213192Smckusick # ifdef OBJ 6223192Smckusick patchfil(var, (long)(-sizes[cbn].om_max), 2); 6233192Smckusick # endif OBJ 6243192Smckusick cbn--; 6253192Smckusick if (inpflist(fp->symbol)) { 6263192Smckusick opop('l'); 6273192Smckusick } 6283192Smckusick } 6293363Speter 6303363Speter #ifdef PC 6313363Speter /* 6323363Speter * construct the long name of a function based on it's static nesting. 6333363Speter * into a caller-supplied buffer (that should be about BUFSIZ big). 6343363Speter */ 6353363Speter sextname( buffer , name , level ) 6363363Speter char buffer[]; 6373363Speter char *name; 6383363Speter int level; 6393363Speter { 6403363Speter char *starthere; 6413363Speter int i; 6423363Speter 6433363Speter starthere = &buffer[0]; 6443363Speter for ( i = 1 ; i < level ; i++ ) { 6453363Speter sprintf( starthere , EXTFORMAT , enclosing[ i ] ); 6463363Speter starthere += strlen( enclosing[ i ] ) + 1; 6473363Speter } 6483367Speter sprintf( starthere , EXTFORMAT , name ); 6493367Speter starthere += strlen( name ) + 1; 6503363Speter if ( starthere >= &buffer[ BUFSIZ ] ) { 6513363Speter panic( "sextname" ); 6523363Speter } 6533363Speter } 6543363Speter #endif PC 655