![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to optim.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / common|
Return to optim.c CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / common |
1.1 root 1: /* @(#) optim.c: 1.3 1/12/84 */
2:
3: # include "mfile1.h"
4:
5: # define ISCON(p) (p->in.op==ICON)
6:
7: int opdebug = 0;
8: NODE *doptim();
9:
10: NODE *
11: aadjust( p, adj )
12: register NODE *p;
13: register adj;
14: {
15: /* try to adjust p by adj bits */
16: register NODE *q;
17: adj = BITOOR(adj);
18: switch( p->tn.op )
19: {
20: case ICON:
21: p->tn.lval += adj;
22: return( p );
23: default:
24: /* construct a + node */
25: mkplus:
26: return( block( PLUS, p, bcon(adj), p->fn.type,
27: p->fn.cdim, p->fn.csiz ) );
28: case PLUS:
29: q = p->in.right;
30: if( q->tn.op != ICON ) goto mkplus;
31: q->tn.lval += adj;
32: return( p );
33: case MINUS:
34: q = p->in.right;
35: if( q->tn.op != ICON ) goto mkplus;
36: q->tn.lval -= adj;
37: return( p );
38: }
39: }
40:
41: adjust( p, adj )
42: register NODE *p;
43: register adj;
44: {
45: /* handle adjustment of scalars by adj bits */
46:
47: switch( p->tn.op )
48: {
49: case NAME:
50: case VAUTO:
51: case VPARAM:
52: p->tn.lval += BITOOR(adj);
53: return( 1 );
54: case STAR:
55: p->in.left = aadjust( p->in.left, adj );
56: return( 1 );
57: default:
58: return( 0 );
59: }
60: }
61:
62: # ifdef NOSIMPSTR
63: # ifndef MYSIMPSTR
64: simpstr( d, s )
65: {
66: return( STRTY );
67: }
68: # endif
69: # else
70: TWORD
71: simpstr( d, s )
72: {
73: /* return STRTY if not, and CHAR, INT, SHORT, or LONG if simple */
74: register sz, al;
75:
76: sz = tsize( STRTY, d, s );
77: al = talign( STRTY, s );
78: if( sz == SZINT /*&& !( al % ALINT)*/ ) return( INT );
79: else if( sz == SZCHAR /*&& !( al % ALCHAR)*/ ) return( CHAR );
80: else if( sz == SZLONG /*&& !( al % ALLONG)*/ ) return( LONG );
81: else if( sz == SZSHORT /*&& !( al % ALSHORT)*/ ) return( SHORT );
82: return( STRTY );
83: }
84: # endif
85:
86: tydown( p )
87: NODE *p;
88: {
89: /* reflect the type of p downwards, as appropriate */
90: /* the type is typically getting smaller */
91: /* returns 1 if it makes a real change */
92:
93: TWORD t;
94: NODE *l, *r;
95: int flag;
96:
97: #ifndef NODBG
98: if( opdebug )
99: {
100: printf( "tydown(%d) called with:\n", p-node );
101: eprint( p );
102: }
103: #endif
104: t = p->tn.type;
105: if( ISPTR(t) || ISARY(t) ) return(0);
106:
107: /* work these types down into the tree */
108:
109: flag = 0;
110:
111: switch( p->tn.op )
112: {
113:
114: case AND:
115: case OR:
116: case PLUS:
117: case MINUS:
118: case ER:
119: case COMOP:
120: #ifndef NODBG
121: if( opdebug )
122: {
123: printf( "tydown:\n" );
124: eprint( p );
125: }
126: #endif
127: r = p->in.right;
128: if( bigsize(r->tn.type) > bigsize(p->tn.type ) )
129: {
130: r = makety( r, t, 0, (int) t );
131: tydown( r );
132: p->in.right = doptim( r );
133: #ifndef NODBG
134: if( opdebug )
135: {
136: printf( "tydown(%d), after doptim(R):\n",
137: p-node );
138: eprint(p);
139: }
140: #endif
141: flag = 1;
142: }
143: if( p->tn.op == COMOP ) return( flag );
144: /* FALLTHRU */
145:
146: case UNARY MINUS:
147: case COMPL:
148: l = p->in.left;
149: if( bigsize(l->tn.type) > bigsize(p->tn.type ) )
150: {
151: l = makety( l, t, 0, (int) t );
152: tydown( l );
153: p->in.left = doptim( l );
154: #ifndef NODBG
155: if( opdebug )
156: {
157: printf( "tydown(%d), after doptim(L):\n",
158: p-node );
159: eprint(p);
160: }
161: #endif
162: flag = 1;
163: }
164: return(flag);
165: }
166: return( 0 ); /* no change */
167: }
168:
169: # ifndef MYCONVERT
170: NODE *
171: sconvert( p )
172: register NODE *p;
173: {
174: register TWORD t, lt;
175: register NODE *l;
176: register o;
177:
178: /* optimize CONV nodes */
179: /* the unsigned-ness is ignored */
180: /* if the CONV involves floats or doubles, retain unless null */
181: /* if the CONV makes things bigger, retain */
182: /* if the CONV keeps things the same size, just paint the type */
183: /* if the CONV makes things smaller, adjust the addressing with
184: ** memory references, and paint the new type
185: */
186: /* if a pointer is being converted, convert as if it were PTRTYPE */
187: /* finally, if CONV converts a constant, do it in place */
188: again:
189: #ifndef NODBG
190: if( opdebug )
191: {
192: printf( "sconvert(%d) called:\n", p-node );
193: eprint( p );
194: }
195: #endif
196: if( p->tn.op != CONV ) cerror( "sconvert" );
197: l = p->in.left;
198: t = p->tn.type;
199: lt = l->tn.type;
200: o = l->tn.op;
201:
202: if( o == FCON )
203: {
204: /* for a floating point const, paint type,
205: ** round when it is output */
206: if( t == FLOAT || t == DOUBLE ) goto paint;
207: /* otherwise, convert it to long and treat as long conversion */
208: l->tn.op = ICON;
209: l->tn.lval = l->fpn.dval; /* MACHINE-DEPENDENT CONVERSION */
210: l->tn.rval = NONAME;
211: goto icon;
212: }
213:
214: if( o==CONV && cbigger( l ) )
215: {
216: merge:
217: p->in.left = l->in.left;
218: l->tn.op = FREE;
219: tydown( p );
220: goto again;
221: }
222: if( t == lt && (t == DOUBLE || t == FLOAT) )
223: goto paint; /* float over float, double over double */
224: if( t==FLOAT || t==DOUBLE || t == VOID
225: || lt==FLOAT || lt==DOUBLE ) return( p );
226:
227: if( ISUNSIGNED(t) ) t = DEUNSIGN(t);
228: if( ISUNSIGNED(lt) ) lt = DEUNSIGN(lt);
229: if( ISPTR(lt) )
230: # ifdef MEMONLY
231: if( o==STAR || o==NAME || o==VAUTO || o==VPARAM )
232: # endif
233: lt = PTRTYPE;
234: if( t == lt ) goto paint;
235: if( ISPTR(lt) || ISARY(lt) ) return(p);
236:
237: if( o == ICON )
238: {
239: icon:
240: l->tn.lval = ccast( l->tn.lval, p->tn.type );
241: paint:
242: l->tn.type = p->tn.type;
243: l->fn.csiz = p->fn.csiz;
244: l->fn.cdim = p->fn.cdim;
245: p->tn.op = FREE;
246: if( tydown(l) )
247: {
248: l = doptim(l);
249: }
250: return( l );
251: }
252: if( cbigger(p) ) return( p );
253: /* p makes things smaller */
254: if( o==CONV )
255: {
256: /* two conversions in a row: the second makes things smaller */
257: /* make them into one */
258: goto merge;
259: }
260: if( o==STAR || o==NAME || o==VAUTO || o==VPARAM )
261: {
262: /* memory reference: determine the adjustment */
263: # ifdef RTOLBYTES
264: # ifdef LOWINT
265: if( lt == LONG ) if( !adjust( l, LOWINT )) cerror( "adj" );
266: # endif
267: # else
268: register adj = 0;
269: if( lt == LONG ) adj = SZLONG;
270: else if( lt == INT ) adj = SZINT;
271: else if( lt == SHORT ) adj = SZSHORT;
272: else cerror( "sconv:lt 0%o", lt );
273: if( t == INT ) adj -= SZINT;
274: else if( t == SHORT ) adj -= SZSHORT;
275: else if( t == CHAR ) adj -= SZCHAR;
276: else cerror( "sconv:t 0%o", t );
277: # ifdef LOWINT
278: if( lt == LONG ) adj += LOWINT;
279: # endif
280: if( adj ) if( !adjust( l, adj ) ) cerror( "adj1" );
281: # endif
282: }
283:
284: /* other cases are where it is computed into a reg; */
285: /* simply paint the type */
286: /* must avoid clobbering the type for assignment nodes */
287: /* however, we must copy (e.g., apply the CONV) for register vars */
288: /* also, can't paint type over fields */
289: if( o == REG || asgop(o) || o == FLD ) return( p );
290: goto paint;
291: }
292: # endif
293:
294: NODE *
295: pvconvert( p )
296: register NODE *p;
297: {
298: /* p is a CONV node; convert */
299: /* this does something only when the descendent is not a ptr */
300: register NODE *l;
301: register int o;
302: l = p->in.left;
303: if( ISPTR( l->tn.type ) ) return( clocal(p) );
304: # ifdef MEMONLY
305: o = l->tn.op;
306: if( o==STAR || o==NAME || o==VAUTO || o==VPARAM || o==ICON )
307: # endif
308: {
309: /* optimize this reference */
310: /* sconvert and optimize to PTRTYPE */
311: l = makety( l, PTRTYPE, 0, PTRTYPE );
312: if( l->tn.op == CONV ) l = sconvert( l );
313: l->tn.type = p->tn.type;
314: l->fn.cdim = p->fn.cdim;
315: l->fn.csiz = p->fn.csiz;
316: p->tn.op = FREE;
317: p = l;
318: }
319: return( clocal(p) );
320: }
321:
322: NODE *
323: fortarg( p )
324: register NODE *p;
325: {
326: /* fortran function arguments */
327:
328: if( p->in.op == CM )
329: {
330: p->in.left = fortarg( p->in.left );
331: p->in.right = fortarg( p->in.right );
332: return(p);
333: }
334: while( ISPTR(p->in.type) )
335: {
336: p = buildtree( STAR, p, NIL );
337: }
338: return( optim(p) );
339: }
340:
341: /* mapping relationals when the sides are reversed */
342: short revrel[] =
343: {
344: EQ, NE, GE, GT, LE, LT, UGE, UGT, ULE, ULT
345: };
346:
347: #ifndef NODBG
348: #define REPORT(x) if(opdebug){printf( "optim did\n"); eprint(x);}
349: #else
350: # define REPORT(x)
351: #endif
352: NODE *
353: doptim(p)
354: register NODE *p;
355: {
356: /* local optimizations, most of which are machine independent */
357: /* doptim is called for each node by optim; it assumes that
358: ** the children of p are already optimized
359: */
360: /* p is not a leaf */
361: register NODE *l, *r, *sp;
362: register o, i;
363: register TWORD t;
364:
365: #ifndef NODBG
366: if( opdebug )
367: {
368: printf( "doptim called on:\n" );
369: eprint(p);
370: }
371: #endif
372:
373: if( (t=BTYPE(p->in.type))==ENUMTY || t==MOETY ) econvert(p);
374: switch( optype( o = p->tn.op ) )
375: {
376: case BITYPE:
377: r = p->in.right;
378: /* FALLTHRU */
379: case UTYPE:
380: l = p->in.left;
381: break;
382: case LTYPE:
383: /* nothing more to do (after doing the enum stuff) */
384: return( p );
385: }
386: sp = conval( p );
387: /* return only if conval did something */
388: if( sp != p ) return( doptim(sp) );
389: #ifndef NODBG
390: if( opdebug )
391: {
392: printf( "doptim works on:\n" );
393: eprint(p);
394: }
395: #endif
396: switch(o)
397: {
398: case COMOP: /* maybe simpstr changed the type of the right */
399: if(p->in.type != r->in.type) {
400: p->in.type = r->in.type;
401: /* anything else? */
402: REPORT(p);
403: }
404: return(p);
405: case CONV:
406: /* someday, make pvconvert and sconvert the same */
407: return( ISPTR(p->tn.type)?pvconvert(p):sconvert(p) );
408: case ASG PLUS:
409: case ASG MINUS:
410: case ASG AND:
411: case ASG OR:
412: case ASG ER:
413: case ASG LS:
414: case ASG RS:
415: case ASG MUL:
416: case ASG DIV:
417: case ASG MOD:
418: /* if conversion ops on the lhs, transfer them to the rhs */
419: t = l->in.type;
420:
421: /* (CONV A) op= B into A op= (CONV B)
422: ** this only holds if the result depends only on the
423: ** low order part of B (e.g., that part of B that
424: ** is the width of A
425: ** this is not true for /=, %=, or floats */
426:
427: if( l->tn.op == CONV && t!=FLOAT && t!=DOUBLE
428: && o!=ASG DIV && o != ASG MOD )
429: {
430: p->in.left = l->in.left;
431: l->tn.op = FREE;
432: l = l->in.left;
433: r = makety( r, p->in.type, p->fn.cdim, p->fn.csiz );
434: p->in.right = doptim( r );
435: }
436: if( !nncon(r) ) break; /* no more optimization */
437: /* get rid of 0 ops that don't change anything... */
438: if( !r->tn.lval && (o==ASG PLUS || o==ASG MINUS || o==ASG OR ||
439: o==ASG ER || o==ASG LS || o==ASG RS) )
440: {
441: /* the answer is the lhs */
442: goto bless;
443: }
444: if( r->tn.lval == 1 && (o==ASG MUL || o==ASG DIV) )
445: {
446: /* the answer is the lhs */
447: goto bless;
448: }
449: if( (i = ispow2( r->tn.lval ))>=0 && o==ASG MUL )
450: {
451: o = p->in.op = ASG LS;
452: r->tn.lval = i;
453: }
454: break;
455: case LS:
456: case RS:
457: if( !nncon(r) || r->tn.lval )
458: break; /* do nothing */
459: goto bless; /* shifts by 0 */
460: case FORTCALL:
461: p->in.right = fortarg( r );
462: break;
463: case UNARY AND:
464: switch( l->tn.op )
465: {
466: case STAR:
467: /* fake up to use setuleft */
468: l->tn.op = FREE;
469: l=l->in.left;
470: goto setuleft;
471: case VAUTO:
472: case VPARAM:
473: case TEMP:
474: /* the next two lines come from short structs */
475: case CALL:
476: case UNARY CALL:
477: break;
478:
479: case RNODE:
480: # ifdef ARGSRET
481: /* RNODE disappears if structure simple */
482: if( simpstr( p->fn.cdim, p->fn.csiz ) == STRTY )
483: {
484: /* complicated: make it look like first arg */
485: l->tn.op = VPARAM;
486: l->tn.lval = BITOOR(ARGINIT);
487: l->tn.rval = NONAME;
488: }
489: break;
490: #else
491: # ifdef STATSRET
492: /* simple structures will disappear */
493: if( simpstr( p->fn.cdim, p->fn.csiz ) != STRTY ) break;
494: /* otherwise, make & RNODE into ICON for static area */
495: l->tn.rval = -strftn;
496: # else
497: break; /* & of RNODE is just fine */
498: #endif
499: #endif
500: case NAME:
501: # ifdef ANDABLE
502: if( !ANDABLE(l) ) return(p);
503: # endif
504: l->tn.op = ICON;
505: setuleft:
506: /* set the type of lhs with the type of the top */
507: l->in.type = p->in.type;
508: l->fn.cdim = p->fn.cdim;
509: l->fn.csiz = p->fn.csiz;
510: p->in.op = FREE;
511: REPORT(l);
512: return( l );
513: default:
514: cerror( "& error" );
515: }
516: break;
517: case STCALL:
518: case UNARY STCALL:
519: /* use l in case return type overwritten */
520: t = simpstr( l->fn.cdim, l->fn.csiz );
521: if( t != STRTY )
522: {
523: /* take some care to keep the types OK */
524: /* the type of the return might well have been
525: ** overwritten by (say) a structure reference
526: */
527: /* MAY NOT BE QUITE RIGHT IF TWO FLAVORS OF PTR */
528: l = p;
529: p->tn.type = DECREF( p->tn.type );
530: p = buildtree( UNARY AND, l, NIL );
531: if( o == STCALL ) l->tn.op = CALL;
532: else l->tn.op = UNARY CALL;
533: l->fn.type = l->fn.csiz = t;
534: l->fn.cdim = 0;
535: }
536: break;
537: case STAR:
538: if( p->tn.type == STRTY || p->tn.type == UNIONTY )
539: {
540: p->tn.op = FREE;
541: REPORT(l);
542: return( l );
543: }
544: if( l->tn.op == UNARY AND && !callop(l->in.left->tn.op) )
545: {
546: /* & of call used in structure optimization */
547: /* fake up to use setuleft */
548: l->tn.op = FREE;
549: l = l->in.left;
550: goto setuleft;
551: }
552: if( l->tn.op != ICON ) break;
553: l->tn.op = NAME;
554: goto setuleft;
555: case MINUS:
556: if( !nncon(r) ) break;
557: r->tn.lval = - r->tn.lval;
558: o = p->in.op = PLUS;
559: case MUL:
560: case PLUS:
561: case AND:
562: case OR:
563: case ER:
564: /* commutative ops; for now, just collect constants */
565: /* someday, do it right */
566: if( o==r->tn.op || nncon(l) || ( ISCON(l) && !ISCON(r) ) )
567: {
568: /* make ops tower to the left, not the right */
569: /* also, put constants on the right */
570: sp = l;
571: l = p->in.left = r;
572: r = p->in.right = sp;
573: }
574: /* do (A + C1) + C2, etc. */
575: /* the number of special cases is horrifying */
576: /* many bugs have been found here; this code is very cautious */
577: /* (A + C1) + C2, where C2 can be a ptr, C1 not */
578: if( o==PLUS && l->tn.op==PLUS && ISCON(r) &&
579: nncon(l->in.right) )
580: {
581: p->in.left = l->in.left;
582: l->tn.op = FREE;
583: l = l->in.right;
584: r->tn.lval += l->tn.lval;
585: l->tn.op = FREE;
586: return( doptim( p ) );
587: }
588: /* (A + C1) + C2, where C1 can be a ptr, C2 not */
589: if( o==PLUS && l->tn.op==PLUS && nncon(r) &&
590: ISCON(l->in.right) )
591: {
592: l->in.right->tn.lval += r->tn.lval;
593: goto bless; /* return l as the result */
594: }
595: /* (A - C1) + C2, where C2 can be a ptr, C1 not */
596: if( o==PLUS && l->tn.op==MINUS && ISCON(r) &&
597: nncon(l->in.right) )
598: {
599: p->in.left = l->in.left;
600: l->tn.op = FREE;
601: l = l->in.right;
602: r->tn.lval -= l->tn.lval;
603: l->tn.op = FREE;
604: return( doptim( p ) );
605: }
606: /* (&A)+C */
607: if( o==PLUS && l->tn.op == UNARY AND && ISCON(r) )
608: {
609: switch( l->in.left->tn.op )
610: {
611: case NAME:
612: case VPARAM:
613: case VAUTO:
614: l->in.left->tn.lval += r->tn.lval;
615: goto bless;
616: }
617: }
618: /* change muls to shifts */
619: if( o==MUL && nncon(r) && (i=ispow2(r->tn.lval))>=0)
620: {
621: if( i == 0 )
622: {
623: /* multiplication by 1 */
624: bless:
625: /* return l, with the type of p */
626: l = makety( l, p->tn.type, p->fn.cdim,
627: p->fn.csiz );
628: r->tn.op = FREE;
629: p->tn.op = FREE;
630: /* if a conversion op was added, optimize */
631: l = doptim( l );
632: #ifndef NODBG
633: if( opdebug )
634: {
635: printf( "optim replaces op1 (%d) by:\n",
636: p-node );
637: eprint(l);
638: }
639: #endif
640: return( l );
641: }
642: o = p->in.op = LS;
643: r->tn.lval = i;
644: }
645: /* change +'s of negative consts back to - */
646: if( o==PLUS && nncon(r) && r->tn.lval<0 )
647: {
648: r->tn.lval = -r->tn.lval;
649: o = p->in.op = MINUS;
650: }
651: if( nncon(r) && !r->tn.lval && (o==PLUS||o==MINUS) )
652: {
653: /* get rid of add or subtract of 0 */
654: goto bless;
655: }
656: # ifdef PTRLEFT
657: if( o==PLUS && ISPTR(p->tn.type) && ISPTR(r->tn.type)
658: # ifdef CONSRIGHT
659: && r->tn.op != ICON
660: # endif
661: )
662: {
663: sp = l;
664: p->in.left = r;
665: p->in.right = sp;
666: }
667: # endif
668: # ifdef PTRRIGHT
669: if( o==PLUS && ISPTR(p->tn.type) && ISPTR(l->tn.type)
670: # ifdef CONSRIGHT
671: && r->tn.op != ICON
672: # endif
673: )
674: {
675: sp = l;
676: p->in.left = r;
677: p->in.right = sp;
678: }
679: # endif
680: break;
681: case DIV:
682: if( nncon( r ) && r->tn.lval == 1 ) goto bless;
683: break;
684: case EQ:
685: case NE:
686: case LT:
687: case LE:
688: case GT:
689: case GE:
690: case ULT:
691: case ULE:
692: case UGT:
693: case UGE:
694: if( ISCON(l) && !ISCON(r) )
695: {
696: /* exchange operands */
697: p->in.op = revrel[p->in.op - EQ ];
698: sp = l;
699: l = p->in.left = r;
700: r = p->in.right = sp;
701: }
702: break;
703: case STASG:
704: if( (t=simpstr( p->fn.cdim, p->fn.csiz ) ) != STRTY )
705: {
706: /* rewrite = as simpler */
707: if( ISPTR(r->tn.type) )
708: {
709: r = buildtree( STAR, r, NIL );
710: r->fn.type = r->fn.csiz = t;
711: r->fn.cdim = 0;
712: p->in.right = r = doptim( r );
713: }
714: l = buildtree( STAR, l, NIL );
715: l->fn.type = l->fn.csiz = t;
716: l->fn.cdim = 0;
717: p->in.left = l = doptim( l );
718: p->fn.type = p->fn.csiz = t;
719: p->fn.cdim = 0;
720: p->fn.op = ASSIGN;
721: return( p );
722: }
723: case STARG:
724: if( (t=simpstr( p->fn.cdim, p->fn.csiz ) ) != STRTY )
725: {
726: /* rewrite as simpler */
727: if( ISPTR(l->fn.type) )
728: {
729: l = buildtree( STAR, l, NIL );
730: l->fn.type = l->fn.csiz = t;
731: l->fn.cdim = 0;
732: p->in.left = l = doptim( l );
733: }
734: p->fn.type = p->fn.csiz = (t==LONG ? LONG : INT);
735: p->fn.cdim = 0;
736: p->fn.op = FUNARG;
737: return( p );
738: }
739: # ifdef ENDSTRUCT
740: p->in.left = aadjust( l, p->stn.stsize );
741: # endif
742: break;
743: }
744: return(p);
745: }
746:
747: NODE *
748: optim( p )
749: register NODE *p;
750: {
751: switch( optype( p->tn.op ) )
752: {
753: case BITYPE:
754: p->in.right = optim( p->in.right );
755: /* FALLTHRU */
756: case UTYPE:
757: p->in.left = optim( p->in.left );
758: }
759: return( doptim( p ) );
760: }
761:
762: ispow2( c )
763: register CONSZ c;
764: {
765: register i;
766: if( c <= 0 || (c&(c-1)) ) return(-1);
767: for( i=0; c>1; ++i) c >>= 1;
768: return(i);
769: }
770:
771: nncon( p )
772: register NODE *p;
773: {
774: /* is p a constant without a name */
775: return( p->tn.op == ICON && p->tn.rval == NONAME && !ISPTR(p->tn.type));
776: }
777:
778: /* some routines for debugging and tree transformation */
779: #ifndef MYOFFCON
780: NODE *
781: offcon( off, t, d, s )
782: OFFSZ off;
783: TWORD t;
784: {
785: /* return a node, for structure references, which is suitable for
786: ** being added to a pointer of type t, in order to be off bits offset
787: ** into a structure
788: */
789: register NODE *p;
790:
791: /* t, d, and s are the type, dimension offset, and size offset */
792: /* in general they may be necessary for offcon */
793: p = bcon(0);
794: p->tn.lval = BITOOR(off);
795: p->fn.type = p->fn.csiz = PTRTYPE;
796: return(p);
797: }
798: # endif
799:
800: bccode()
801: {
802: /* called just before executing code */
803: /* beware: called several times if there is auto. initialization */
804: # ifdef MYBCCODE
805: MYBCCODE;
806: # endif
807: p2bbeg( autooff, regvar );
808: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.