![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fend.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / src|
Return to fend.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / src |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)fend.c 5.1 (Berkeley) 6/5/85";
9: #endif not lint
10:
11: #include "whoami.h"
12: #include "0.h"
13: #include "tree.h"
14: #include "opcode.h"
15: #include "objfmt.h"
16: #include "align.h"
17: #include "tmps.h"
18:
19: /*
20: * this array keeps the pxp counters associated with
21: * functions and procedures, so that they can be output
22: * when their bodies are encountered
23: */
24: int bodycnts[ DSPLYSZ ];
25:
26: #ifdef PC
27: # include "pc.h"
28: # include <pcc.h>
29: #endif PC
30:
31: #ifdef OBJ
32: int cntpatch;
33: int nfppatch;
34: #endif OBJ
35:
36: #include "tree_ty.h"
37:
38: struct nl *Fp;
39: int pnumcnt;
40: /*
41: * Funcend is called to
42: * finish a block by generating
43: * the code for the statements.
44: * It then looks for unresolved declarations
45: * of labels, procedures and functions,
46: * and cleans up the name list.
47: * For the program, it checks the
48: * semantics of the program
49: * statement (yuchh).
50: */
51: funcend(fp, bundle, endline)
52: struct nl *fp;
53: struct tnode *bundle;
54: int endline;
55: {
56: register struct nl *p;
57: register int i, b;
58: int inp, out;
59: struct tnode *blk;
60: bool chkref;
61: struct nl *iop;
62: char *cp;
63: extern int cntstat;
64: # ifdef PC
65: struct entry_exit_cookie eecookie;
66: # endif PC
67: # ifndef PC
68: int var;
69: # endif PC
70:
71: cntstat = 0;
72: /*
73: * yyoutline();
74: */
75: if (program != NIL)
76: line = program->value[3];
77: blk = bundle->stmnt_blck.stmnt_list;
78: if (fp == NIL) {
79: cbn--;
80: # ifdef PTREE
81: nesting--;
82: # endif PTREE
83: return;
84: }
85: #ifdef OBJ
86: /*
87: * Patch the branch to the
88: * entry point of the function
89: */
90: patch4((PTR_DCL) fp->value[NL_ENTLOC]);
91: /*
92: * Put out the block entrance code and the block name.
93: * HDRSZE is the number of bytes of info in the static
94: * BEG data area exclusive of the proc name. It is
95: * currently defined as:
96: /* struct hdr {
97: /* long framesze; /* number of bytes of local vars */
98: /* long nargs; /* number of bytes of arguments */
99: /* bool tests; /* TRUE => perform runtime tests */
100: /* short offset; /* offset of procedure in source file */
101: /* char name[1]; /* name of active procedure */
102: /* };
103: */
104: # define HDRSZE (2 * sizeof(long) + sizeof(short) + sizeof(bool))
105: var = put(2, ((lenstr(fp->symbol,0) + HDRSZE) << 8)
106: | (cbn == 1 && opt('p') == 0 ? O_NODUMP: O_BEG), (long)0);
107: /*
108: * output the number of bytes of arguments
109: * this is only checked on formal calls.
110: */
111: (void) put(2, O_CASE4, cbn == 1 ? (long)0 : (long)(fp->value[NL_OFFS]-DPOFF2));
112: /*
113: * Output the runtime test mode for the routine
114: */
115: (void) put(2, sizeof(bool) == 2 ? O_CASE2 : O_CASE4, opt('t') ? TRUE : FALSE);
116: /*
117: * Output line number and routine name
118: */
119: (void) put(2, O_CASE2, bundle->stmnt_blck.line_no);
120: putstr(fp->symbol, 0);
121: #endif OBJ
122: #ifdef PC
123: /*
124: * put out the procedure entry code
125: */
126: eecookie.nlp = fp;
127: if ( fp -> class == PROG ) {
128: /*
129: * If there is a label declaration in the main routine
130: * then there may be a non-local goto to it that does
131: * not appear in this module. We have to assume that
132: * such a reference may occur and generate code to
133: * prepare for it.
134: */
135: if ( parts[ cbn ] & LPRT ) {
136: parts[ cbn ] |= ( NONLOCALVAR | NONLOCALGOTO );
137: }
138: codeformain();
139: ftnno = fp -> value[NL_ENTLOC];
140: prog_prologue(&eecookie);
141: stabline(bundle->stmnt_blck.line_no);
142: stabfunc(fp, "program", bundle->stmnt_blck.line_no , (long) 0 );
143: } else {
144: ftnno = fp -> value[NL_ENTLOC];
145: fp_prologue(&eecookie);
146: stabline(bundle->stmnt_blck.line_no);
147: stabfunc(fp, fp->symbol, bundle->stmnt_blck.line_no,
148: (long)(cbn - 1));
149: for ( p = fp -> chain ; p != NIL ; p = p -> chain ) {
150: stabparam( p , p -> value[ NL_OFFS ] , (int) lwidth(p->type));
151: }
152: if ( fp -> class == FUNC ) {
153: /*
154: * stab the function variable
155: */
156: p = fp -> ptr[ NL_FVAR ];
157: stablvar( p , p -> value[ NL_OFFS ] , (int) lwidth( p -> type));
158: }
159: /*
160: * stab local variables
161: * rummage down hash chain links.
162: */
163: for ( i = 0 ; i <= 077 ; i++ ) {
164: for ( p = disptab[ i ] ; p != NIL ; p = p->nl_next) {
165: if ( ( p -> nl_block & 037 ) != cbn ) {
166: break;
167: }
168: /*
169: * stab locals (not parameters)
170: */
171: if ( p -> symbol != NIL ) {
172: if ( p -> class == VAR && p -> value[ NL_OFFS ] < 0 ) {
173: stablvar( p , p -> value[ NL_OFFS ] ,
174: (int) lwidth( p -> type ) );
175: } else if ( p -> class == CONST ) {
176: stabconst( p );
177: }
178: }
179: }
180: }
181: }
182: stablbrac( cbn );
183: /*
184: * ask second pass to allocate known locals
185: */
186: putlbracket(ftnno, &sizes[cbn]);
187: fp_entrycode(&eecookie);
188: #endif PC
189: if ( monflg ) {
190: if ( fp -> value[ NL_CNTR ] != 0 ) {
191: inccnt( fp -> value [ NL_CNTR ] );
192: }
193: inccnt( bodycnts[ fp -> nl_block & 037 ] );
194: }
195: if (fp->class == PROG) {
196: /*
197: * The glorious buffers option.
198: * 0 = don't buffer output
199: * 1 = line buffer output
200: * 2 = 512 byte buffer output
201: */
202: # ifdef OBJ
203: if (opt('b') != 1)
204: (void) put(1, O_BUFF | opt('b') << 8);
205: # endif OBJ
206: # ifdef PC
207: if ( opt( 'b' ) != 1 ) {
208: putleaf( PCC_ICON , 0 , 0
209: , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR ) , "_BUFF" );
210: putleaf( PCC_ICON , opt( 'b' ) , 0 , PCCT_INT , (char *) 0 );
211: putop( PCC_CALL , PCCT_INT );
212: putdot( filename , line );
213: }
214: # endif PC
215: inp = 0;
216: out = 0;
217: for (p = fp->chain; p != NIL; p = p->chain) {
218: if (pstrcmp(p->symbol, input->symbol) == 0) {
219: inp++;
220: continue;
221: }
222: if (pstrcmp(p->symbol, output->symbol) == 0) {
223: out++;
224: continue;
225: }
226: iop = lookup1(p->symbol);
227: if (iop == NIL || bn != cbn) {
228: error("File %s listed in program statement but not declared", p->symbol);
229: continue;
230: }
231: if (iop->class != VAR) {
232: error("File %s listed in program statement but declared as a %s", p->symbol, classes[iop->class]);
233: continue;
234: }
235: if (iop->type == NIL)
236: continue;
237: if (iop->type->class != FILET) {
238: error("File %s listed in program statement but defined as %s",
239: p->symbol, nameof(iop->type));
240: continue;
241: }
242: # ifdef OBJ
243: (void) put(2, O_CON24, text(iop->type) ? 0 : width(iop->type->type));
244: i = lenstr(p->symbol,0);
245: (void) put(2, O_CON24, i);
246: (void) put(2, O_LVCON, i);
247: putstr(p->symbol, 0);
248: (void) put(2, O_LV | bn<<8+INDX, (int)iop->value[NL_OFFS]);
249: (void) put(1, O_DEFNAME);
250: # endif OBJ
251: # ifdef PC
252: putleaf( PCC_ICON , 0 , 0
253: , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR )
254: , "_DEFNAME" );
255: putLV( p -> symbol , bn , iop -> value[NL_OFFS] ,
256: iop -> extra_flags , p2type( iop ) );
257: putCONG( p -> symbol , strlen( p -> symbol )
258: , LREQ );
259: putop( PCC_CM , PCCT_INT );
260: putleaf( PCC_ICON , strlen( p -> symbol )
261: , 0 , PCCT_INT , (char *) 0 );
262: putop( PCC_CM , PCCT_INT );
263: putleaf( PCC_ICON
264: , text(iop->type) ? 0 : width(iop->type->type)
265: , 0 , PCCT_INT , (char *) 0 );
266: putop( PCC_CM , PCCT_INT );
267: putop( PCC_CALL , PCCT_INT );
268: putdot( filename , line );
269: # endif PC
270: }
271: }
272: /*
273: * Process the prog/proc/func body
274: */
275: noreach = FALSE;
276: line = bundle->stmnt_blck.line_no;
277: statlist(blk);
278: # ifdef PTREE
279: {
280: pPointer Body = tCopy( blk );
281:
282: pDEF( PorFHeader[ nesting -- ] ).PorFBody = Body;
283: }
284: # endif PTREE
285: # ifdef OBJ
286: if (cbn== 1 && monflg != FALSE) {
287: patchfil((PTR_DCL) (cntpatch - 2), (long)cnts, 2);
288: patchfil((PTR_DCL) (nfppatch - 2), (long)pfcnt, 2);
289: }
290: # endif OBJ
291: # ifdef PC
292: if ( fp -> class == PROG && monflg ) {
293: putleaf( PCC_ICON , 0 , 0 , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR )
294: , "_PMFLUSH" );
295: putleaf( PCC_ICON , cnts , 0 , PCCT_INT , (char *) 0 );
296: putleaf( PCC_ICON , pfcnt , 0 , PCCT_INT , (char *) 0 );
297: putop( PCC_CM , PCCT_INT );
298: putLV( PCPCOUNT , 0 , 0 , NGLOBAL , PCCT_INT );
299: putop( PCC_CM , PCCT_INT );
300: putop( PCC_CALL , PCCT_INT );
301: putdot( filename , line );
302: }
303: # endif PC
304: /*
305: * Clean up the symbol table displays and check for unresolves
306: */
307: line = endline;
308: if (fp->class == PROG && inp == 0 && (input->nl_flags & (NUSED|NMOD)) != 0) {
309: recovered();
310: error("Input is used but not defined in the program statement");
311: }
312: if (fp->class == PROG && out == 0 && (output->nl_flags & (NUSED|NMOD)) != 0) {
313: recovered();
314: error("Output is used but not defined in the program statement");
315: }
316: b = cbn;
317: Fp = fp;
318: chkref = (syneflg == errcnt[cbn] && opt('w') == 0)?TRUE:FALSE;
319: for (i = 0; i <= 077; i++) {
320: for (p = disptab[i]; p != NIL && (p->nl_block & 037) == b; p = p->nl_next) {
321: /*
322: * Check for variables defined
323: * but not referenced
324: */
325: if (chkref && p->symbol != NIL)
326: switch (p->class) {
327: case FIELD:
328: /*
329: * If the corresponding record is
330: * unused, we shouldn't complain about
331: * the fields.
332: */
333: default:
334: if ((p->nl_flags & (NUSED|NMOD)) == 0) {
335: warning();
336: nerror("%s %s is neither used nor set", classes[p->class], p->symbol);
337: break;
338: }
339: /*
340: * If a var parameter is either
341: * modified or used that is enough.
342: */
343: if (p->class == REF)
344: continue;
345: # ifdef OBJ
346: if ((p->nl_flags & NUSED) == 0) {
347: warning();
348: nerror("%s %s is never used", classes[p->class], p->symbol);
349: break;
350: }
351: # endif OBJ
352: # ifdef PC
353: if (((p->nl_flags & NUSED) == 0) && ((p->extra_flags & NEXTERN) == 0)) {
354: warning();
355: nerror("%s %s is never used", classes[p->class], p->symbol);
356: break;
357: }
358: # endif PC
359: if ((p->nl_flags & NMOD) == 0) {
360: warning();
361: nerror("%s %s is used but never set", classes[p->class], p->symbol);
362: break;
363: }
364: case LABEL:
365: case FVAR:
366: case BADUSE:
367: break;
368: }
369: switch (p->class) {
370: case BADUSE:
371: cp = "s";
372: /* This used to say ud_next
373: that is not a member of nl so
374: i changed it to nl_next,
375: which may be wrong */
376: if (p->chain->nl_next == NIL)
377: cp++;
378: eholdnl();
379: if (p->value[NL_KINDS] & ISUNDEF)
380: nerror("%s undefined on line%s", p->symbol, cp);
381: else
382: nerror("%s improperly used on line%s", p->symbol, cp);
383: pnumcnt = 10;
384: pnums((struct udinfo *) p->chain);
385: pchr('\n');
386: break;
387:
388: case FUNC:
389: case PROC:
390: # ifdef OBJ
391: if ((p->nl_flags & NFORWD))
392: nerror("Unresolved forward declaration of %s %s", classes[p->class], p->symbol);
393: # endif OBJ
394: # ifdef PC
395: if ((p->nl_flags & NFORWD) && ((p->extra_flags & NEXTERN) == 0))
396: nerror("Unresolved forward declaration of %s %s", classes[p->class], p->symbol);
397: # endif PC
398: break;
399:
400: case LABEL:
401: if (p->nl_flags & NFORWD)
402: nerror("label %s was declared but not defined", p->symbol);
403: break;
404: case FVAR:
405: if ((p->nl_flags & NMOD) == 0)
406: nerror("No assignment to the function variable");
407: break;
408: }
409: }
410: /*
411: * Pop this symbol
412: * table slot
413: */
414: disptab[i] = p;
415: }
416:
417: # ifdef OBJ
418: (void) put(1, O_END);
419: # endif OBJ
420: # ifdef PC
421: fp_exitcode(&eecookie);
422: stabrbrac(cbn);
423: putrbracket(ftnno);
424: fp_epilogue(&eecookie);
425: if (fp -> class != PROG) {
426: fp_formalentry(&eecookie);
427: }
428: /*
429: * declare pcp counters, if any
430: */
431: if ( monflg && fp -> class == PROG ) {
432: putprintf( " .data" , 0 );
433: aligndot(PCCT_INT);
434: putprintf( " .comm " , 1 );
435: putprintf( PCPCOUNT , 1 );
436: putprintf( ",%d" , 0 , ( cnts + 1 ) * sizeof (long) );
437: putprintf( " .text" , 0 );
438: }
439: # endif PC
440: #ifdef DEBUG
441: dumpnl(fp->ptr[2], (int) fp->symbol);
442: #endif
443:
444: #ifdef OBJ
445: /*
446: * save the namelist for the debugger pdx
447: */
448:
449: savenl(fp->ptr[2], (int) fp->symbol);
450: #endif
451:
452: /*
453: * Restore the
454: * (virtual) name list
455: * position
456: */
457: nlfree(fp->ptr[2]);
458: /*
459: * Proc/func has been
460: * resolved
461: */
462: fp->nl_flags &= ~NFORWD;
463: /*
464: * Patch the beg
465: * of the proc/func to
466: * the proper variable size
467: */
468: if (Fp == NIL)
469: elineon();
470: # ifdef OBJ
471: patchfil((PTR_DCL) var, leven(-sizes[cbn].om_max), 2);
472: # endif OBJ
473: cbn--;
474: if (inpflist(fp->symbol)) {
475: opop('l');
476: }
477: }
478:
479: #ifdef PC
480: /*
481: * construct the long name of a function based on it's static nesting.
482: * into a caller-supplied buffer (that should be about BUFSIZ big).
483: */
484: sextname( buffer , name , level )
485: char buffer[];
486: char *name;
487: int level;
488: {
489: char *starthere;
490: int i;
491:
492: starthere = &buffer[0];
493: for ( i = 1 ; i < level ; i++ ) {
494: sprintf( starthere , EXTFORMAT , enclosing[ i ] );
495: starthere += strlen( enclosing[ i ] ) + 1;
496: }
497: sprintf( starthere , EXTFORMAT , name );
498: starthere += strlen( name ) + 1;
499: if ( starthere >= &buffer[ BUFSIZ ] ) {
500: panic( "sextname" );
501: }
502: }
503:
504: /*
505: * code for main()
506: */
507: #ifdef vax
508:
509: codeformain()
510: {
511: putprintf(" .text" , 0 );
512: putprintf(" .align 1" , 0 );
513: putprintf(" .globl _main" , 0 );
514: putprintf("_main:" , 0 );
515: putprintf(" .word 0" , 0 );
516: if ( opt ( 't' ) ) {
517: putprintf(" pushl $1" , 0 );
518: } else {
519: putprintf(" pushl $0" , 0 );
520: }
521: putprintf(" calls $1,_PCSTART" , 0 );
522: putprintf(" movl 4(ap),__argc" , 0 );
523: putprintf(" movl 8(ap),__argv" , 0 );
524: putprintf(" calls $0,_program" , 0 );
525: putprintf(" pushl $0" , 0 );
526: putprintf(" calls $1,_PCEXIT" , 0 );
527: }
528:
529: /*
530: * prologue for the program.
531: * different because it
532: * doesn't have formal entry point
533: */
534: prog_prologue(eecookiep)
535: struct entry_exit_cookie *eecookiep;
536: {
537: putprintf(" .text" , 0 );
538: putprintf(" .align 1" , 0 );
539: putprintf(" .globl _program" , 0 );
540: putprintf("_program:" , 0 );
541: /*
542: * register save mask
543: */
544: eecookiep -> savlabel = (int) getlab();
545: putprintf(" .word %s%d", 0, (int) SAVE_MASK_LABEL , eecookiep -> savlabel );
546: }
547:
548: fp_prologue(eecookiep)
549: struct entry_exit_cookie *eecookiep;
550: {
551:
552: sextname( eecookiep -> extname, eecookiep -> nlp -> symbol , cbn - 1 );
553: putprintf( " .text" , 0 );
554: putprintf( " .align 1" , 0 );
555: putprintf( " .globl %s%s", 0, (int) FORMALPREFIX, (int) eecookiep -> extname );
556: putprintf( " .globl %s" , 0 , (int) eecookiep -> extname );
557: putprintf( "%s:" , 0 , (int) eecookiep -> extname );
558: /*
559: * register save mask
560: */
561: eecookiep -> savlabel = (int) getlab();
562: putprintf(" .word %s%d", 0, (int) SAVE_MASK_LABEL , eecookiep -> savlabel );
563: }
564:
565: /*
566: * code before any user code.
567: * or code that is machine dependent.
568: */
569: fp_entrycode(eecookiep)
570: struct entry_exit_cookie *eecookiep;
571: {
572: int ftnno = eecookiep -> nlp -> value[NL_ENTLOC];
573: int proflabel = (int) getlab();
574: int setjmp0 = (int) getlab();
575:
576: /*
577: * top of code; destination of jump from formal entry code.
578: */
579: eecookiep -> toplabel = (int) getlab();
580: (void) putlab( (char *) eecookiep -> toplabel );
581: putprintf(" subl2 $%s%d,sp" , 0 , (int) FRAME_SIZE_LABEL, ftnno );
582: if ( profflag ) {
583: /*
584: * call mcount for profiling
585: */
586: putprintf( " moval " , 1 );
587: putprintf( PREFIXFORMAT , 1 , (int) LABELPREFIX , proflabel );
588: putprintf( ",r0" , 0 );
589: putprintf( " jsb mcount" , 0 );
590: putprintf( " .data" , 0 );
591: putprintf( " .align 2" , 0 );
592: (void) putlab( (char *) proflabel );
593: putprintf( " .long 0" , 0 );
594: putprintf( " .text" , 0 );
595: }
596: /*
597: * if there are nested procedures that access our variables
598: * we must save the display.
599: */
600: if ( parts[ cbn ] & NONLOCALVAR ) {
601: /*
602: * save old display
603: */
604: putprintf( " movq %s+%d,%d(%s)" , 0
605: , (int) DISPLAYNAME , cbn * sizeof(struct dispsave)
606: , DSAVEOFFSET , (int) P2FPNAME );
607: /*
608: * set up new display by saving AP and FP in appropriate
609: * slot in display structure.
610: */
611: putprintf( " movq %s,%s+%d" , 0
612: , (int) P2APNAME , (int) DISPLAYNAME , cbn * sizeof(struct dispsave) );
613: }
614: /*
615: * set underflow checking if runtime tests
616: */
617: if ( opt( 't' ) ) {
618: putprintf( " bispsw $0xe0" , 0 );
619: }
620: /*
621: * zero local variables if checking is on
622: * by calling blkclr( bytes of locals , starting local address );
623: */
624: if ( opt( 't' ) && ( -sizes[ cbn ].om_max ) > DPOFF1 ) {
625: putleaf( PCC_ICON , 0 , 0 , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR )
626: , "_blkclr" );
627: putLV((char *) 0 , cbn , (int) sizes[ cbn ].om_max , NLOCAL , PCCT_CHAR );
628: putleaf( PCC_ICON , (int) (( -sizes[ cbn ].om_max ) - DPOFF1)
629: , 0 , PCCT_INT ,(char *) 0 );
630: putop( PCC_CM , PCCT_INT );
631: putop( PCC_CALL , PCCT_INT );
632: putdot( filename , line );
633: }
634: /*
635: * set up goto vector if non-local goto to this frame
636: */
637: if ( parts[ cbn ] & NONLOCALGOTO ) {
638: putleaf( PCC_ICON , 0 , 0 , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR )
639: , "_setjmp" );
640: putLV( (char *) 0 , cbn , GOTOENVOFFSET , NLOCAL , PCCTM_PTR|PCCT_STRTY );
641: putop( PCC_CALL , PCCT_INT );
642: putleaf( PCC_ICON , 0 , 0 , PCCT_INT , (char *) 0 );
643: putop( PCC_NE , PCCT_INT );
644: putleaf( PCC_ICON , setjmp0 , 0 , PCCT_INT , (char *) 0 );
645: putop( PCC_CBRANCH , PCCT_INT );
646: putdot( filename , line );
647: /*
648: * on non-local goto, setjmp returns with address to
649: * be branched to.
650: */
651: putprintf( " jmp (r0)" , 0 );
652: (void) putlab((char *) setjmp0);
653: }
654: }
655:
656: fp_exitcode(eecookiep)
657: struct entry_exit_cookie *eecookiep;
658: {
659: /*
660: * if there were file variables declared at this level
661: * call PCLOSE( ap ) to clean them up.
662: */
663: if ( dfiles[ cbn ] ) {
664: putleaf( PCC_ICON , 0 , 0 , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR )
665: , "_PCLOSE" );
666: putleaf( PCC_REG , 0 , P2AP , PCCM_ADDTYPE( PCCT_CHAR , PCCTM_PTR ) , (char *) 0 );
667: putop( PCC_CALL , PCCT_INT );
668: putdot( filename , line );
669: }
670: /*
671: * if this is a function,
672: * the function variable is the return value.
673: * if it's a scalar valued function, return scalar,
674: * else, return a pointer to the structure value.
675: */
676: if ( eecookiep-> nlp -> class == FUNC ) {
677: struct nl *fvar = eecookiep-> nlp -> ptr[ NL_FVAR ];
678: long fvartype = p2type( fvar -> type );
679: long label;
680: char labelname[ BUFSIZ ];
681:
682: switch ( classify( fvar -> type ) ) {
683: case TBOOL:
684: case TCHAR:
685: case TINT:
686: case TSCAL:
687: case TDOUBLE:
688: case TPTR:
689: putRV( fvar -> symbol , ( fvar -> nl_block ) & 037 ,
690: fvar -> value[ NL_OFFS ] ,
691: fvar -> extra_flags ,
692: (int) fvartype );
693: putop( PCC_FORCE , (int) fvartype );
694: break;
695: default:
696: label = (int) getlab();
697: sprintf( labelname , PREFIXFORMAT , LABELPREFIX , label );
698: putprintf( " .data" , 0 );
699: aligndot(A_STRUCT);
700: putprintf( " .lcomm %s,%d" , 0 ,
701: (int) labelname , (int) lwidth( fvar -> type ) );
702: putprintf( " .text" , 0 );
703: putleaf( PCC_NAME , 0 , 0 , (int) fvartype , labelname );
704: putLV( fvar -> symbol , ( fvar -> nl_block ) & 037 ,
705: fvar -> value[ NL_OFFS ] ,
706: fvar -> extra_flags ,
707: (int) fvartype );
708: putstrop( PCC_STASG , (int) PCCM_ADDTYPE(fvartype, PCCTM_PTR) ,
709: (int) lwidth( fvar -> type ) ,
710: align( fvar -> type ) );
711: putdot( filename , line );
712: putleaf( PCC_ICON , 0 , 0 , (int) PCCM_ADDTYPE(fvartype, PCCTM_PTR), labelname );
713: putop( PCC_FORCE , (int) PCCM_ADDTYPE(fvartype, PCCTM_PTR) );
714: break;
715: }
716: putdot( filename , line );
717: }
718: /*
719: * if there are nested procedures we must save the display.
720: */
721: if ( parts[ cbn ] & NONLOCALVAR ) {
722: /*
723: * restore old display entry from save area
724: */
725: putprintf( " movq %d(%s),%s+%d" , 0
726: , DSAVEOFFSET , (int) P2FPNAME
727: , (int) DISPLAYNAME , cbn * sizeof(struct dispsave) );
728: }
729: }
730:
731: fp_epilogue(eecookiep)
732: struct entry_exit_cookie *eecookiep;
733: {
734: stabline(line);
735: putprintf(" ret" , 0 );
736: /*
737: * set the register save mask.
738: */
739: putprintf(" .set %s%d,0x%x", 0,
740: (int) SAVE_MASK_LABEL, eecookiep -> savlabel, savmask());
741: }
742:
743: fp_formalentry(eecookiep)
744: struct entry_exit_cookie *eecookiep;
745: {
746:
747: putprintf(" .align 1", 0);
748: putprintf("%s%s:" , 0 , (int) FORMALPREFIX , (int) eecookiep -> extname );
749: putprintf(" .word %s%d", 0, (int) SAVE_MASK_LABEL, eecookiep -> savlabel );
750: putleaf( PCC_ICON , 0 , 0 , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR ) , "_FCALL" );
751: putRV((char *) 0 , cbn ,
752: eecookiep -> nlp -> value[ NL_OFFS ] + sizeof( struct formalrtn * ) ,
753: NPARAM , PCCTM_PTR | PCCT_STRTY );
754: putRV((char *) 0, cbn, eecookiep -> nlp -> value[NL_OFFS], NPARAM, PCCTM_PTR|PCCT_STRTY);
755: putop( PCC_CM , PCCT_INT );
756: putop( PCC_CALL , PCCT_INT );
757: putdot( filename , line );
758: putjbr( (long) eecookiep -> toplabel );
759: }
760: #endif vax
761:
762: #ifdef mc68000
763:
764: codeformain()
765: {
766: putprintf(" .text", 0);
767: putprintf(" .globl _main", 0);
768: putprintf("_main:", 0);
769: putprintf(" link %s,#0", 0, P2FPNAME);
770: if (opt('t')) {
771: putprintf(" pea 1", 0);
772: } else {
773: putprintf(" pea 0", 0);
774: }
775: putprintf(" jbsr _PCSTART", 0);
776: putprintf(" addql #4,sp", 0);
777: putprintf(" movl %s@(8),__argc", 0, P2FPNAME);
778: putprintf(" movl %s@(12),__argv", 0, P2FPNAME);
779: putprintf(" jbsr _program", 0);
780: putprintf(" pea 0", 0);
781: putprintf(" jbsr _PCEXIT", 0);
782: }
783:
784: prog_prologue(eecookiep)
785: struct entry_exit_cookie *eecookiep;
786: {
787: int ftnno = eecookiep -> nlp -> value[NL_ENTLOC];
788:
789: putprintf(" .text", 0);
790: putprintf(" .globl _program", 0);
791: putprintf("_program:", 0);
792: putprintf(" link %s,#0", 0, P2FPNAME);
793: putprintf(" addl #-%s%d,sp", 0, FRAME_SIZE_LABEL, ftnno);
794: /* touch new end of stack, to break more stack space */
795: putprintf(" tstb sp@(-%s%d)", 0, PAGE_BREAK_LABEL, ftnno);
796: putprintf(" moveml #%s%d,sp@", 0, SAVE_MASK_LABEL, ftnno);
797: }
798:
799: fp_prologue(eecookiep)
800: struct entry_exit_cookie *eecookiep;
801: {
802: int ftnno = eecookiep -> nlp -> value[NL_ENTLOC];
803:
804: sextname(eecookiep -> extname, eecookiep -> nlp -> symbol, cbn - 1);
805: putprintf(" .text", 0);
806: putprintf(" .globl %s%s", 0, FORMALPREFIX, eecookiep -> extname);
807: putprintf(" .globl %s", 0, eecookiep -> extname);
808: putprintf("%s:", 0, eecookiep -> extname);
809: putprintf(" link %s,#0", 0, P2FPNAME);
810: putprintf(" addl #-%s%d,sp", 0, FRAME_SIZE_LABEL, ftnno);
811: /* touch new end of stack, to break more stack space */
812: putprintf(" tstb sp@(-%s%d)", 0, PAGE_BREAK_LABEL, ftnno);
813: putprintf(" moveml #%s%d,sp@", 0, SAVE_MASK_LABEL, ftnno);
814: }
815:
816: fp_entrycode(eecookiep)
817: struct entry_exit_cookie *eecookiep;
818: {
819: char *proflabel = getlab();
820: char *setjmp0 = getlab();
821:
822: /*
823: * fill in the label cookie
824: */
825: eecookiep -> toplabel = getlab();
826: (void) putlab(eecookiep -> toplabel);
827: /*
828: * call mcount if we are profiling.
829: */
830: if ( profflag ) {
831: putprintf(" movl #%s%d,a0", 0, LABELPREFIX, proflabel);
832: putprintf(" jsr mcount", 0);
833: putprintf(" .data", 0);
834: putprintf(" .even", 0);
835: (void) putlab(proflabel);
836: putprintf(" .long 0", 0);
837: putprintf(" .text", 0);
838: }
839: /*
840: * if there are nested procedures that access our variables
841: * we must save the display
842: */
843: if (parts[cbn] & NONLOCALVAR) {
844: /*
845: * save the old display
846: */
847: putprintf(" movl %s+%d,%s@(%d)", 0,
848: DISPLAYNAME, cbn * sizeof(struct dispsave),
849: P2FPNAME, DSAVEOFFSET);
850: /*
851: * set up the new display by saving the framepointer
852: * in the display structure.
853: */
854: putprintf(" movl %s,%s+%d", 0,
855: P2FPNAME, DISPLAYNAME, cbn * sizeof(struct dispsave));
856: }
857: /*
858: * zero local variables if checking is on
859: * by calling blkclr( bytes of locals , starting local address );
860: */
861: if ( opt( 't' ) && ( -sizes[ cbn ].om_max ) > DPOFF1 ) {
862: putleaf( PCC_ICON , 0 , 0 , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR )
863: , "_blkclr" );
864: putLV( 0 , cbn , sizes[ cbn ].om_max , NLOCAL , PCCT_CHAR );
865: putleaf( PCC_ICON , ( -sizes[ cbn ].om_max ) - DPOFF1
866: , 0 , PCCT_INT , 0 );
867: putop( PCC_CM , PCCT_INT );
868: putop( PCC_CALL , PCCT_INT );
869: putdot( filename , line );
870: }
871: /*
872: * set up goto vector if non-local goto to this frame
873: */
874: if ( parts[ cbn ] & NONLOCALGOTO ) {
875: putleaf( PCC_ICON , 0 , 0 , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR )
876: , "_setjmp" );
877: putLV( 0 , cbn , GOTOENVOFFSET , NLOCAL , PCCTM_PTR|PCCT_STRTY );
878: putop( PCC_CALL , PCCT_INT );
879: putleaf( PCC_ICON , 0 , 0 , PCCT_INT , 0 );
880: putop( PCC_NE , PCCT_INT );
881: putleaf( PCC_ICON , setjmp0 , 0 , PCCT_INT , 0 );
882: putop( PCC_CBRANCH , PCCT_INT );
883: putdot( filename , line );
884: /*
885: * on non-local goto, setjmp returns with address to
886: * be branched to.
887: */
888: putprintf(" movl d0,a0", 0);
889: putprintf(" jmp a0@", 0);
890: (void) putlab(setjmp0);
891: }
892: }
893:
894: fp_exitcode(eecookiep)
895: struct entry_exit_cookie *eecookiep;
896: {
897: /*
898: * if there were file variables declared at this level
899: * call PCLOSE( ap ) to clean them up.
900: */
901: if ( dfiles[ cbn ] ) {
902: putleaf( PCC_ICON , 0 , 0 , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR )
903: , "_PCLOSE" );
904: putleaf( PCC_REG , 0 , P2AP , PCCM_ADDTYPE( PCCT_CHAR , PCCTM_PTR ) , 0 );
905: putop( PCC_CALL , PCCT_INT );
906: putdot( filename , line );
907: }
908: /*
909: * if this is a function,
910: * the function variable is the return value.
911: * if it's a scalar valued function, return scalar,
912: * else, return a pointer to the structure value.
913: */
914: if ( eecookiep -> nlp -> class == FUNC ) {
915: struct nl *fvar = eecookiep -> nlp -> ptr[ NL_FVAR ];
916: long fvartype = p2type( fvar -> type );
917: char *label;
918: char labelname[ BUFSIZ ];
919:
920: switch ( classify( fvar -> type ) ) {
921: case TBOOL:
922: case TCHAR:
923: case TINT:
924: case TSCAL:
925: case TDOUBLE:
926: case TPTR:
927: putRV( fvar -> symbol , ( fvar -> nl_block ) & 037 ,
928: fvar -> value[ NL_OFFS ] ,
929: fvar -> extra_flags ,
930: fvartype );
931: putop( PCC_FORCE , fvartype );
932: break;
933: default:
934: label = getlab();
935: sprintf( labelname , PREFIXFORMAT , LABELPREFIX , label );
936: putprintf(" .lcomm %s,%d", 0,
937: labelname, lwidth(fvar -> type));
938: putleaf( PCC_NAME , 0 , 0 , fvartype , labelname );
939: putLV( fvar -> symbol , ( fvar -> nl_block ) & 037 ,
940: fvar -> value[ NL_OFFS ] ,
941: fvar -> extra_flags ,
942: fvartype );
943: putstrop( PCC_STASG , PCCM_ADDTYPE(fvartype, PCCTM_PTR) ,
944: lwidth( fvar -> type ) ,
945: align( fvar -> type ) );
946: putdot( filename , line );
947: putleaf( PCC_ICON , 0 , 0 , PCCM_ADDTYPE(fvartype, PCCTM_PTR), labelname );
948: putop( PCC_FORCE , PCCM_ADDTYPE(fvartype, PCCTM_PTR) );
949: break;
950: }
951: putdot( filename , line );
952: }
953: /*
954: * if we saved a display, we must restore it.
955: */
956: if ( parts[ cbn ] & NONLOCALVAR ) {
957: /*
958: * restore old display entry from save area
959: */
960: putprintf(" movl %s@(%d),%s+%d", 0,
961: P2FPNAME, DSAVEOFFSET,
962: DISPLAYNAME, cbn * sizeof(struct dispsave));
963: }
964: }
965:
966: fp_epilogue(eecookiep)
967: struct entry_exit_cookie *eecookiep;
968: {
969: /*
970: * all done by the second pass.
971: */
972: }
973:
974: fp_formalentry(eecookiep)
975: struct entry_exit_cookie *eecookiep;
976: {
977: putprintf( "%s%s:" , 0 , FORMALPREFIX , eecookiep -> extname );
978: putprintf(" link %s,#0", 0, P2FPNAME);
979: putprintf(" addl #-%s%d,sp", 0, FRAME_SIZE_LABEL, ftnno);
980: /* touch new end of stack, to break more stack space */
981: putprintf(" tstb sp@(-%s%d)", 0, PAGE_BREAK_LABEL, ftnno);
982: putprintf(" moveml #%s%d,sp@", 0, SAVE_MASK_LABEL, ftnno);
983: putleaf( PCC_ICON , 0 , 0 , PCCM_ADDTYPE( PCCTM_FTN | PCCT_INT , PCCTM_PTR ) , "_FCALL" );
984: putRV( 0 , cbn ,
985: eecookiep -> nlp -> value[ NL_OFFS ] + sizeof( struct formalrtn * ) ,
986: NPARAM , PCCTM_PTR | PCCT_STRTY );
987: putRV(0, cbn, eecookiep -> nlp -> value[NL_OFFS], NPARAM, PCCTM_PTR|PCCT_STRTY);
988: putop( PCC_CM , PCCT_INT );
989: putop( PCC_CALL , PCCT_INT );
990: putdot( filename , line );
991: putjbr( eecookiep -> toplabel );
992: }
993: #endif mc68000
994: #endif PC
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.