![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vax.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / usr.bin / f77 / src / f77pass1|
Return to vax.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.bin / f77 / src / f77pass1 |
1.1 root 1: #include "defs.h"
2:
3: #ifdef SDB
4: # include <a.out.h>
5: extern int types2[];
6: # ifndef N_SO
7: # include <stab.h>
8: # endif
9: #endif
10:
11: #include "pccdefs.h"
12:
13:
14: /*
15: VAX-11/780 - SPECIFIC ROUTINES
16: */
17:
18:
19: int maxregvar = MAXREGVAR;
20: int regnum[] = { 10, 9, 8, 7, 6 } ;
21: static int regmask[] = { 0x800, 0xc00, 0xe00, 0xf00, 0xf80, 0xfc0 };
22:
23:
24:
25: ftnint intcon[14] =
26: { 2, 2, 2, 2,
27: 15, 31, 24, 56,
28: -128, -128, 127, 127,
29: 32767, 2147483647 };
30:
31: #if HERE == VAX
32: /* then put in constants in octal */
33: long realcon[6][2] =
34: {
35: { 0200, 0 },
36: { 0200, 0 },
37: { 037777677777, 0 },
38: { 037777677777, 037777777777 },
39: { 032200, 0 },
40: { 022200, 0 }
41: };
42: #else
43: double realcon[6] =
44: {
45: 2.9387358771e-39,
46: 2.938735877055718800e-39
47: 1.7014117332e+38,
48: 1.701411834604692250e+38
49: 5.960464e-8,
50: 1.38777878078144567e-17,
51: };
52: #endif
53:
54:
55:
56:
57: prsave(proflab)
58: int proflab;
59: {
60: if(profileflag)
61: {
62: fprintf(asmfile, "L%d:\t.space\t4\n", proflab);
63: p2pi("\tmovab\tL%d,r0", proflab);
64: p2pass("\tjsb\tmcount");
65: }
66: p2pi("\tsubl2\t$LF%d,sp", procno);
67: }
68:
69:
70:
71: goret(type)
72: int type;
73: {
74: p2pass("\tret");
75: }
76:
77:
78:
79:
80: /*
81: * move argument slot arg1 (relative to ap)
82: * to slot arg2 (relative to ARGREG)
83: */
84:
85: mvarg(type, arg1, arg2)
86: int type, arg1, arg2;
87: {
88: p2pij("\tmovl\t%d(ap),%d(fp)", arg1+ARGOFFSET, arg2+argloc);
89: }
90:
91:
92:
93:
94: prlabel(fp, k)
95: FILEP fp;
96: int k;
97: {
98: fprintf(fp, "L%d:\n", k);
99: }
100:
101:
102:
103: prconi(fp, type, n)
104: FILEP fp;
105: int type;
106: ftnint n;
107: {
108: fprintf(fp, "\t%s\t%ld\n", (type==TYSHORT ? ".word" : ".long"), n);
109: }
110:
111:
112:
113: prcona(fp, a)
114: FILEP fp;
115: ftnint a;
116: {
117: fprintf(fp, "\t.long\tL%ld\n", a);
118: }
119:
120:
121:
122: #ifndef vax
123: prconr(fp, type, x)
124: FILEP fp;
125: int type;
126: float x;
127: {
128: fprintf(fp, "\t%s\t0f%e\n", (type==TYREAL ? ".float" : ".double"), x);
129: }
130: #endif
131:
132: #ifdef vax
133: prconr(fp, type, x)
134: FILEP fp;
135: int type;
136: double x;
137: {
138: /* non-portable cheat to preserve bit patterns */
139: union { double xd; long int xl[2]; } cheat;
140: cheat.xd = x;
141: if(type == TYREAL)
142: {float y = x; fprintf(fp, "\t.long\t0x%X\n", *(long *) &y); }
143: else
144: fprintf(fp, "\t.long\t0x%X,0x%X\n", cheat.xl[0], cheat.xl[1]);
145: }
146: #endif
147:
148:
149:
150: praddr(fp, stg, varno, offset)
151: FILE *fp;
152: int stg, varno;
153: ftnint offset;
154: {
155: char *memname();
156:
157: if(stg == STGNULL)
158: fprintf(fp, "\t.long\t0\n");
159: else
160: {
161: fprintf(fp, "\t.long\t%s", memname(stg,varno));
162: if(offset)
163: fprintf(fp, "+%ld", offset);
164: fprintf(fp, "\n");
165: }
166: }
167:
168:
169:
170:
171: preven(k)
172: int k;
173: {
174: register int lg;
175:
176: if(k > 4)
177: lg = 3;
178: else if(k > 2)
179: lg = 2;
180: else if(k > 1)
181: lg = 1;
182: else
183: return;
184: fprintf(asmfile, "\t.align\t%d\n", lg);
185: }
186:
187:
188:
189:
190: pralign(k)
191: int k;
192: {
193: register int lg;
194:
195: if (k > 4)
196: lg = 3;
197: else if (k > 2)
198: lg = 2;
199: else if (k > 1)
200: lg = 1;
201: else
202: return;
203:
204: fprintf(initfile, "\t.align\t%d\n", lg);
205: return;
206: }
207:
208:
209:
210: vaxgoto(index, nlab, labs)
211: expptr index;
212: register int nlab;
213: struct Labelblock *labs[];
214: {
215: register int i;
216: register int arrlab;
217:
218: putforce(TYINT, index);
219: p2pi("\tcasel\tr0,$1,$%d", nlab-1);
220: p2pi("L%d:", arrlab = newlabel() );
221: for(i = 0; i< nlab ; ++i)
222: if( labs[i] )
223: p2pij("\t.word\tL%d-L%d", labs[i]->labelno, arrlab);
224: }
225:
226:
227: prarif(p, neg, zer, pos)
228: expptr p;
229: int neg, zer, pos;
230: {
231: int type;
232:
233: type = p->headblock.vtype;
234: putforce(type, p);
235: if(type == TYLONG)
236: p2pass("\ttstl\tr0");
237: else if (type == TYSHORT)
238: p2pass("\ttstw\tr0");
239: else
240: p2pass("\ttstd\tr0");
241: p2pi("\tjlss\tL%d", neg);
242: p2pi("\tjeql\tL%d", zer);
243: p2pi("\tjbr\tL%d", pos);
244: }
245:
246:
247:
248:
249: char *memname(stg, mem)
250: int stg, mem;
251: {
252: static char s[20];
253:
254: switch(stg)
255: {
256: case STGCOMMON:
257: case STGEXT:
258: sprintf(s, "_%s", varstr(XL, extsymtab[mem].extname) );
259: break;
260:
261: case STGBSS:
262: case STGINIT:
263: sprintf(s, "v.%d", mem);
264: break;
265:
266: case STGCONST:
267: sprintf(s, "L%d", mem);
268: break;
269:
270: case STGEQUIV:
271: sprintf(s, "q.%d", mem+eqvstart);
272: break;
273:
274: default:
275: badstg("memname", stg);
276: }
277: return(s);
278: }
279:
280:
281:
282:
283: prlocvar(s, len)
284: char *s;
285: ftnint len;
286: {
287: fprintf(asmfile, "\t.lcomm\t%s,%ld\n", s, len);
288: }
289:
290:
291:
292:
293: char *
294: packbytes(cp)
295: register Constp cp;
296: {
297: static char shrt[2];
298: static char lng[4];
299: static char quad[8];
300: static char oct[16];
301:
302: register int type;
303: register int *ip, *jp;
304:
305: switch (cp->vtype)
306: {
307: case TYSHORT:
308: *((short *) shrt) = (short) cp->const.ci;
309: return (shrt);
310:
311: case TYLONG:
312: case TYLOGICAL:
313: case TYREAL:
314: *((int *) lng) = cp->const.ci;
315: return (lng);
316:
317: case TYDREAL:
318: ip = (int *) quad;
319: jp = (int *) &(cp->const.cd[0]);
320: ip[0] = jp[0];
321: ip[1] = jp[1];
322: return (quad);
323:
324: case TYCOMPLEX:
325: ip = (int *) quad;
326: jp = (int *) &(cp->const.cd[0]);
327: ip[0] = jp[0];
328: ip[1] = jp[2];
329: return (quad);
330:
331: case TYDCOMPLEX:
332: ip = (int *) oct;
333: jp = (int *) &(cp->const.cd[0]);
334: *ip++ = *jp++;
335: *ip++ = *jp++;
336: *ip++ = *jp++;
337: *ip = *jp;
338: return (oct);
339:
340: default:
341: badtype("packbytes", cp->vtype);
342: }
343: }
344:
345:
346:
347:
348: prsdata(s, len)
349: register char *s;
350: register int len;
351: {
352: static char *longfmt = "\t.long\t0x%x\n";
353: static char *wordfmt = "\t.word\t0x%x\n";
354: static char *bytefmt = "\t.byte\t0x%x\n";
355:
356: register int i;
357:
358: i = 0;
359: if ((len - i) >= 4)
360: {
361: fprintf(initfile, longfmt, *((int *) s));
362: i += 4;
363: }
364: if ((len - i) >= 2)
365: {
366: fprintf(initfile, wordfmt, 0xffff & (*((short *) (s + i))));
367: i += 2;
368: }
369: if ((len - i) > 0)
370: fprintf(initfile,bytefmt, 0xff & s[i]);
371:
372: return;
373: }
374:
375:
376:
377: prquad(s)
378: char *s;
379: {
380: static char *quadfmt1 = "\t.quad\t0x%x\n";
381: static char *quadfmt2 = "\t.quad\t0x%x%08x\n";
382:
383: if ( *((int *) (s + 4)) == 0 )
384: fprintf(initfile, quadfmt1, *((int *) s));
385: else
386: fprintf(initfile, quadfmt2, *((int *) (s + 4)), *((int *) s));
387:
388: return;
389: }
390:
391:
392:
393: #ifdef NOTDEF
394:
395: /* The code for generating .fill directives has been */
396: /* ifdefed out because of bugs in the UCB VAX assembler. */
397: /* If those bugs are ever fixed (and it seems unlikely), */
398: /* the NOTDEF's should be replaced by UCBVAXASM. */
399:
400:
401: prfill(n, s)
402: int n;
403: register char *s;
404: {
405: static char *fillfmt1 = "\t.fill\t%d,8,0x%x\n";
406: static char *fillfmt2 = "\t.fill\t%d,8,0x%x%08x\n";
407:
408: if (*((int *) (s + 4)) == 0)
409: fprintf(initfile, fillfmt1, n, *((int *) s));
410: else
411: fprintf(initfile, fillfmt2, n, *((int *) (s + 4)), *((int *) s));
412:
413: return;
414: }
415:
416: #endif
417:
418:
419:
420: prext(ep)
421: register struct Extsym *ep;
422: {
423: static char *globlfmt = "\t.globl\t_%s\n";
424: static char *commfmt = "\t.comm\t_%s,%ld\n";
425: static char *spacefmt = "\t.space\t%d\n";
426: static char *align2fmt = "\t.align\t2\n";
427: static char *labelfmt = "_%s:\n";
428:
429: static char *seekerror = "seek error on tmp file";
430: static char *readerror = "read error on tmp file";
431:
432: char *tag;
433: register int leng;
434: long pos;
435: register int i;
436: char oldvalue[8];
437: char newvalue[8];
438: register int n;
439: register int repl;
440:
441: tag = varstr(XL, ep->extname);
442: leng = ep->maxleng;
443:
444: if (leng == 0)
445: {
446: fprintf(asmfile, globlfmt, tag);
447: return;
448: }
449:
450: if (ep->init == NO)
451: {
452: fprintf(asmfile, commfmt, tag, leng);
453: return;
454: }
455:
456: fprintf(asmfile, globlfmt, tag);
457: fprintf(initfile, align2fmt);
458: fprintf(initfile, labelfmt, tag);
459:
460: pos = lseek(cdatafile, ep->initoffset, 0);
461: if (pos == -1)
462: {
463: err(seekerror);
464: done(1);
465: }
466:
467: *((int *) oldvalue) = 0;
468: *((int *) (oldvalue + 4)) = 0;
469: n = read(cdatafile, oldvalue, 8);
470: if (n < 0)
471: {
472: err(readerror);
473: done(1);
474: }
475:
476: if (leng <= 8)
477: {
478: i = leng;
479: while (i > 0 && oldvalue[--i] == '\0') /* SKIP */;
480: if (oldvalue[i] == '\0')
481: fprintf(initfile, spacefmt, leng);
482: else if (leng == 8)
483: prquad(oldvalue);
484: else
485: prsdata(oldvalue, leng);
486:
487: return;
488: }
489:
490: repl = 1;
491: leng -= 8;
492:
493: while (leng >= 8)
494: {
495: *((int *) newvalue) = 0;
496: *((int *) (newvalue + 4)) = 0;
497:
498: n = read(cdatafile, newvalue, 8);
499: if (n < 0)
500: {
501: err(readerror);
502: done(1);
503: }
504:
505: leng -= 8;
506:
507: if (*((int *) oldvalue) == *((int *) newvalue)
508: && *((int *) (oldvalue + 4)) == *((int *) (newvalue + 4)))
509: repl++;
510: else
511: {
512: if (*((int *) oldvalue) == 0
513: && *((int *) (oldvalue + 4)) == 0)
514: fprintf(initfile, spacefmt, 8*repl);
515: else if (repl == 1)
516: prquad(oldvalue);
517: else
518: #ifdef NOTDEF
519: prfill(repl, oldvalue);
520: #else
521: {
522: while (repl-- > 0)
523: prquad(oldvalue);
524: }
525: #endif
526: *((int *) oldvalue) = *((int *) newvalue);
527: *((int *) (oldvalue + 4)) = *((int *) (newvalue + 4));
528: repl = 1;
529: }
530: }
531:
532: *((int *) newvalue) = 0;
533: *((int *) (newvalue + 4)) = 0;
534:
535: if (leng > 0)
536: {
537: n = read(cdatafile, newvalue, leng);
538: if (n < 0)
539: {
540: err(readerror);
541: done(1);
542: }
543: }
544:
545: if (*((int *) (oldvalue + 4)) == 0
546: && *((int *) oldvalue) == 0
547: && *((int *) (newvalue + 4)) == 0
548: && *((int *) newvalue) == 0)
549: {
550: fprintf(initfile, spacefmt, 8*repl + leng);
551: return;
552: }
553:
554: if (*((int *) (oldvalue + 4)) == 0
555: && *((int *) oldvalue) == 0)
556: fprintf(initfile, spacefmt, 8*repl);
557: else if (repl == 1)
558: prquad(oldvalue);
559: else
560: #ifdef NOTDEF
561: prfill(repl, oldvalue);
562: #else
563: {
564: while (repl-- > 0)
565: prquad(oldvalue);
566: }
567: #endif
568:
569: prsdata(newvalue, leng);
570:
571: return;
572: }
573:
574:
575:
576: prlocdata(sname, leng, type, initoffset, inlcomm)
577: char *sname;
578: ftnint leng;
579: int type;
580: long initoffset;
581: char *inlcomm;
582: {
583: static char *seekerror = "seek error on tmp file";
584: static char *readerror = "read error on tmp file";
585:
586: static char *labelfmt = "%s:\n";
587: static char *spacefmt = "\t.space\t%d\n";
588:
589: register int k;
590: register int i;
591: register int repl;
592: register int first;
593: register long pos;
594: register long n;
595: char oldvalue[8];
596: char newvalue[8];
597:
598: *inlcomm = NO;
599:
600: k = leng;
601: first = YES;
602:
603: pos = lseek(vdatafile, initoffset, 0);
604: if (pos == -1)
605: {
606: err(seekerror);
607: done(1);
608: }
609:
610: *((int *) oldvalue) = 0;
611: *((int *) (oldvalue + 4)) = 0;
612: n = read(vdatafile, oldvalue, 8);
613: if (n < 0)
614: {
615: err(readerror);
616: done(1);
617: }
618:
619: if (k <= 8)
620: {
621: i = k;
622: while (i > 0 && oldvalue[--i] == '\0')
623: /* SKIP */ ;
624: if (oldvalue[i] == '\0')
625: {
626: if (SMALLVAR(leng))
627: {
628: pralign(typealign[type]);
629: fprintf(initfile, labelfmt, sname);
630: fprintf(initfile, spacefmt, leng);
631: }
632: else
633: {
634: preven(ALIDOUBLE);
635: prlocvar(sname, leng);
636: *inlcomm = YES;
637: }
638: }
639: else
640: {
641: fprintf(initfile, labelfmt, sname);
642: if (leng == 8)
643: prquad(oldvalue);
644: else
645: prsdata(oldvalue, leng);
646: }
647: return;
648: }
649:
650: repl = 1;
651: k -= 8;
652:
653: while (k >=8)
654: {
655: *((int *) newvalue) = 0;
656: *((int *) (newvalue + 4)) = 0;
657:
658: n = read(vdatafile, newvalue, 8);
659: if (n < 0)
660: {
661: err(readerror);
662: done(1);
663: }
664:
665: k -= 8;
666:
667: if (*((int *) oldvalue) == *((int *) newvalue)
668: && *((int *) (oldvalue + 4)) == *((int *) (newvalue + 4)))
669: repl++;
670: else
671: {
672: if (first == YES)
673: {
674: pralign(typealign[type]);
675: fprintf(initfile, labelfmt, sname);
676: first = NO;
677: }
678:
679: if (*((int *) oldvalue) == 0
680: && *((int *) (oldvalue + 4)) == 0)
681: fprintf(initfile, spacefmt, 8*repl);
682: else
683: {
684: while (repl-- > 0)
685: prquad(oldvalue);
686: }
687: *((int *) oldvalue) = *((int *) newvalue);
688: *((int *) (oldvalue + 4)) = *((int *) (newvalue + 4));
689: repl = 1;
690: }
691: }
692:
693: *((int *) newvalue) = 0;
694: *((int *) (newvalue + 4)) = 0;
695:
696: if (k > 0)
697: {
698: n = read(vdatafile, newvalue, k);
699: if (n < 0)
700: {
701: err(readerror);
702: done(1);
703: }
704: }
705:
706: if (*((int *) (oldvalue + 4)) == 0
707: && *((int *) oldvalue) == 0
708: && *((int *) (newvalue + 4)) == 0
709: && *((int *) newvalue) == 0)
710: {
711: if (first == YES && !SMALLVAR(leng))
712: {
713: prlocvar(sname, leng);
714: *inlcomm = YES;
715: }
716: else
717: {
718: if (first == YES)
719: {
720: pralign(typealign[type]);
721: fprintf(initfile, labelfmt, sname);
722: }
723: fprintf(initfile, spacefmt, 8*repl + k);
724: }
725: return;
726: }
727:
728: if (first == YES)
729: {
730: pralign(typealign[type]);
731: fprintf(initfile, labelfmt, sname);
732: }
733:
734: if (*((int *) (oldvalue + 4)) == 0
735: && *((int *) oldvalue) == 0)
736: fprintf(initfile, spacefmt, 8*repl);
737: else
738: {
739: while (repl-- > 0)
740: prquad(oldvalue);
741: }
742:
743: prsdata(newvalue, k);
744:
745: return;
746: }
747:
748:
749:
750:
751: prendproc()
752: {
753: }
754:
755:
756:
757:
758: prtail()
759: {
760: }
761:
762:
763:
764:
765:
766: prolog(ep, argvec)
767: struct Entrypoint *ep;
768: Addrp argvec;
769: {
770: int i, argslot, proflab;
771: int size;
772: register chainp p;
773: register Namep q;
774: register struct Dimblock *dp;
775: expptr tp;
776:
777: p2pass("\t.align\t1");
778:
779:
780: if(procclass == CLMAIN) {
781: if(fudgelabel)
782: {
783: if(ep->entryname) {
784: p2ps("_%s:", varstr(XL, ep->entryname->extname));
785: p2pi("\t.word\tLWM%d", procno);
786: }
787: putlabel(fudgelabel);
788: fudgelabel = 0;
789: fixlwm();
790: }
791: else
792: {
793: p2pass( "_MAIN_:" );
794: if(ep->entryname == NULL)
795: p2pi("\t.word\tLWM%d", procno);
796: }
797:
798: } else if(ep->entryname)
799: if(fudgelabel)
800: {
801: putlabel(fudgelabel);
802: fudgelabel = 0;
803: fixlwm();
804: }
805: else
806: {
807: p2ps("_%s:", varstr(XL, ep->entryname->extname));
808: p2pi("\t.word\tLWM%d", procno);
809: prsave(newlabel());
810: }
811:
812: if(procclass == CLBLOCK)
813: return;
814: if (anylocals == YES)
815: {
816: char buff[30];
817: sprintf(buff, "\tmovl\t$v.%d,r11", bsslabel);
818: p2pass(buff);
819: }
820: if(argvec)
821: {
822: if (argvec->tag != TADDR) badtag ("prolog",argvec->tag);
823: argloc = argvec->memoffset->constblock.const.ci + SZINT;
824: /* first slot holds count */
825: if(proctype == TYCHAR)
826: {
827: mvarg(TYADDR, 0, chslot);
828: mvarg(TYLENG, SZADDR, chlgslot);
829: argslot = SZADDR + SZLENG;
830: }
831: else if( ISCOMPLEX(proctype) )
832: {
833: mvarg(TYADDR, 0, cxslot);
834: argslot = SZADDR;
835: }
836: else
837: argslot = 0;
838:
839: for(p = ep->arglist ; p ; p =p->nextp)
840: {
841: q = (Namep) (p->datap);
842: mvarg(TYADDR, argslot, q->vardesc.varno);
843: argslot += SZADDR;
844: }
845: for(p = ep->arglist ; p ; p = p->nextp)
846: {
847: q = (Namep) (p->datap);
848: if(q->vtype==TYCHAR && q->vclass!=CLPROC)
849: {
850: if(q->vleng && ! ISCONST(q->vleng) )
851: mvarg(TYLENG, argslot,
852: q->vleng->addrblock.memno);
853: argslot += SZLENG;
854: }
855: }
856: p2pi("\taddl3\t$%d,fp,ap", argloc-ARGOFFSET);
857: p2pi("\tmovl\t$%d,(ap)\n", lastargslot/SZADDR);
858: }
859:
860: for(p = ep->arglist ; p ; p = p->nextp)
861: {
862: q = (Namep) (p->datap);
863: if(dp = q->vdim)
864: {
865: for(i = 0 ; i < dp->ndim ; ++i)
866: if(dp->dims[i].dimexpr)
867: puteq( fixtype(cpexpr(dp->dims[i].dimsize)),
868: fixtype(cpexpr(dp->dims[i].dimexpr)));
869: #ifdef SDB
870: if(sdbflag) {
871: for(i = 0 ; i < dp->ndim ; ++i) {
872: if(dp->dims[i].lbaddr)
873: puteq( fixtype(cpexpr(dp->dims[i].lbaddr)),
874: fixtype(cpexpr(dp->dims[i].lb)));
875: if(dp->dims[i].ubaddr)
876: puteq( fixtype(cpexpr(dp->dims[i].ubaddr)),
877: fixtype(cpexpr(dp->dims[i].ub)));
878:
879: }
880: }
881: #endif
882: size = typesize[ q->vtype ];
883: if(q->vtype == TYCHAR)
884: if( ISICON(q->vleng) )
885: size *= q->vleng->constblock.const.ci;
886: else
887: size = -1;
888:
889: /* on VAX, get more efficient subscripting if subscripts
890: have zero-base, so fudge the argument pointers for arrays.
891: Not done if array bounds are being checked.
892: */
893: if(dp->basexpr)
894: puteq( cpexpr(fixtype(dp->baseoffset)),
895: cpexpr(fixtype(dp->basexpr)));
896: #ifdef SDB
897: if( (! checksubs) && (! sdbflag) )
898: #else
899: if(! checksubs)
900: #endif
901: {
902: if(dp->basexpr)
903: {
904: if(size > 0)
905: tp = (expptr) ICON(size);
906: else
907: tp = (expptr) cpexpr(q->vleng);
908: putforce(TYINT,
909: fixtype( mkexpr(OPSTAR, tp,
910: cpexpr(dp->baseoffset)) ));
911: p2pi("\tsubl2\tr0,%d(ap)",
912: p->datap->nameblock.vardesc.varno +
913: ARGOFFSET);
914: }
915: else if(dp->baseoffset->constblock.const.ci != 0)
916: {
917: char buff[25];
918: if(size > 0)
919: {
920: sprintf(buff, "\tsubl2\t$%ld,%d(ap)",
921: dp->baseoffset->constblock.const.ci * size,
922: p->datap->nameblock.vardesc.varno +
923: ARGOFFSET);
924: }
925: else {
926: putforce(TYINT, mkexpr(OPSTAR, cpexpr(dp->baseoffset),
927: cpexpr(q->vleng) ));
928: sprintf(buff, "\tsubl2\tr0,%d(ap)",
929: p->datap->nameblock.vardesc.varno +
930: ARGOFFSET);
931: }
932: p2pass(buff);
933: }
934: }
935: }
936: }
937:
938: if(typeaddr)
939: puteq( cpexpr(typeaddr), mkaddcon(ep->typelabel) );
940: /* replace to avoid long jump problem
941: putgoto(ep->entrylabel);
942: */
943: p2pi("\tjmp\tL%d", ep->entrylabel);
944: }
945:
946: fixlwm()
947: {
948: extern lwmno;
949: if (lwmno == procno)
950: return;
951: fprintf(asmfile, "\t.set\tLWM%d,0x%x\n",
952: procno, regmask[highregvar]);
953: lwmno = procno;
954: }
955:
956:
957: prhead(fp)
958: FILEP fp;
959: {
960: #if FAMILY==PCC
961: p2triple(P2LBRACKET, ARGREG-highregvar, procno);
962: p2word( (long) (BITSPERCHAR*autoleng) );
963: p2flush();
964: #endif
965: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.