Context Navigation

source: mainline/uspace/app/pcc/arch/vax/local2.c@ a837544

Visit:

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since a837544 was a7de7182, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 14 years ago
Added pcc source tree (contents of pcc-1.0.0.tgz)
Property mode set to `100644`
File size: 19.9 KB

Line
1	/* $Id: local2.c,v 1.11 2008/11/22 16:12:25 ragge Exp $ */
2	/*
3	* Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	*
9	* Redistributions of source code and documentation must retain the above
10	* copyright notice, this list of conditions and the following disclaimer.
11	* Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditionsand the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.
14	* All advertising materials mentioning features or use of this software
15	* must display the following acknowledgement:
16	* This product includes software developed or owned by Caldera
17	* International, Inc.
18	* Neither the name of Caldera International, Inc. nor the names of other
19	* contributors may be used to endorse or promote products derived from
20	* this software without specific prior written permission.
21	*
22	* USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
23	* INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
24	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26	* DISCLAIMED. IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE
27	* FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30	* HOWEVER CAUSED AND ON ANY THEORY OFLIABILITY, WHETHER IN CONTRACT,
31	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
32	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33	* POSSIBILITY OF SUCH DAMAGE.
34	*/
35
36	# include "pass2.h"
37	# include "ctype.h"
38	/* a lot of the machine dependent parts of the second pass */
39
40	static void prtype(NODE *n);
41	static void acon(NODE *p);
42
43	/*
44	* Print out the prolog assembler.
45	* addto and regoff are already calculated.
46	*/
47	void
48	prologue(struct interpass_prolog *ipp)
49	{
50	if (ipp->ipp_vis)
51	printf(" .globl %s\n", ipp->ipp_name);
52	printf(" .align 4\n");
53	printf("%s:\n", ipp->ipp_name);
54	printf(" .word 0x%x\n", ipp->ipp_regs[0]);
55	if (p2maxautooff)
56	printf(" subl2 $%d,%%sp\n", p2maxautooff);
57	}
58
59	/*
60	* Called after all instructions in a function are emitted.
61	* Generates code for epilog here.
62	*/
63	void
64	eoftn(struct interpass_prolog *ipp)
65	{
66	if (ipp->ipp_ip.ip_lbl == 0)
67	return; /* no code needs to be generated */
68	printf(" ret\n");
69	}
70
71	struct hoptab { int opmask; char * opstring; } ioptab[] = {
72
73	{ PLUS, "add", },
74	{ MINUS, "sub", },
75	{ MUL, "mul", },
76	{ DIV, "div", },
77	{ OR, "bis", },
78	{ ER, "xor", },
79	{ AND, "bic", },
80	{ -1, "" },
81	};
82
83	void
84	hopcode( f, o ){
85	/* output the appropriate string from the above table */
86
87	register struct hoptab *q;
88
89	for( q = ioptab; q->opmask>=0; ++q ){
90	if( q->opmask == o ){
91	printf( "%s", q->opstring );
92	/* tbl
93	if( f == 'F' ) printf( "e" );
94	else if( f == 'D' ) printf( "d" );
95	tbl */
96	/* tbl */
97	switch( f ) {
98	case 'L':
99	case 'W':
100	case 'B':
101	case 'D':
102	case 'F':
103	printf("%c", tolower(f));
104	break;
105
106	}
107	/* tbl */
108	return;
109	}
110	}
111	cerror( "no hoptab for %s", opst[o] );
112	}
113
114	char *
115	rnames[] = { /* keyed to register number tokens */
116
117	"r0", "r1", "r2", "r3", "r4", "r5",
118	"r6", "r7", "r8", "r9", "r10", "r11",
119	"ap", "fp", "sp", "pc",
120	/* The concatenated regs has the name of the lowest */
121	"r0", "r1", "r2", "r3", "r4", "r5",
122	"r6", "r7", "r8", "r9", "r10"
123	};
124
125	int
126	tlen(p) NODE *p;
127	{
128	switch(p->n_type) {
129	case CHAR:
130	case UCHAR:
131	return(1);
132
133	case SHORT:
134	case USHORT:
135	return(2);
136
137	case DOUBLE:
138	case LDOUBLE:
139	case LONGLONG:
140	case ULONGLONG:
141	return(8);
142
143	default:
144	return(4);
145	}
146	}
147
148	static int
149	mixtypes(NODE p, NODE q)
150	{
151	TWORD tp, tq;
152
153	tp = p->n_type;
154	tq = q->n_type;
155
156	return( (tp==FLOAT \|\| tp==DOUBLE) !=
157	(tq==FLOAT \|\| tq==DOUBLE) );
158	}
159
160	void
161	prtype(NODE *n)
162	{
163	switch (n->n_type)
164	{
165	case DOUBLE:
166	printf("d");
167	return;
168
169	case FLOAT:
170	printf("f");
171	return;
172
173	case LONG:
174	case ULONG:
175	case INT:
176	case UNSIGNED:
177	printf("l");
178	return;
179
180	case SHORT:
181	case USHORT:
182	printf("w");
183	return;
184
185	case CHAR:
186	case UCHAR:
187	printf("b");
188	return;
189
190	default:
191	if ( !ISPTR( n->n_type ) ) cerror("zzzcode- bad type");
192	else {
193	printf("l");
194	return;
195	}
196	}
197	}
198
199	void
200	zzzcode( p, c ) register NODE *p; {
201	int m;
202	int val;
203	switch( c ){
204
205	case 'N': /* logical ops, turned into 0-1 */
206	/* use register given by register 1 */
207	cbgen( 0, m=getlab2());
208	deflab( p->n_label );
209	printf( " clrl %s\n", rnames[getlr( p, '1' )->n_rval] );
210	deflab( m );
211	return;
212
213	case 'A':
214	{
215	register NODE l, r;
216
217	if (xdebug) e2print(p, 0, &val, &val);
218	r = getlr(p, 'R');
219	if (optype(p->n_op) == LTYPE \|\| p->n_op == UMUL) {
220	l = resc;
221	l->n_type = (r->n_type==FLOAT \|\| r->n_type==DOUBLE ? DOUBLE : INT);
222	} else
223	l = getlr(p, 'L');
224	if (r->n_op == ICON && r->n_name[0] == '\0') {
225	if (r->n_lval == 0) {
226	printf("clr");
227	prtype(l);
228	printf(" ");
229	adrput(stdout, l);
230	return;
231	}
232	if (r->n_lval < 0 && r->n_lval >= -63) {
233	printf("mneg");
234	prtype(l);
235	r->n_lval = -r->n_lval;
236	goto ops;
237	}
238	r->n_type = (r->n_lval < 0 ?
239	(r->n_lval >= -128 ? CHAR
240	: (r->n_lval >= -32768 ? SHORT
241	: INT )) : r->n_type);
242	r->n_type = (r->n_lval >= 0 ?
243	(r->n_lval <= 63 ? INT
244	: ( r->n_lval <= 127 ? CHAR
245	: (r->n_lval <= 255 ? UCHAR
246	: (r->n_lval <= 32767 ? SHORT
247	: (r->n_lval <= 65535 ? USHORT
248	: INT ))))) : r->n_type );
249	}
250	if (l->n_op == REG && l->n_type != FLOAT && l->n_type != DOUBLE)
251	l->n_type = INT;
252	if (!mixtypes(l,r))
253	{
254	if (tlen(l) == tlen(r))
255	{
256	printf("mov");
257	prtype(l);
258	goto ops;
259	}
260	else if (tlen(l) > tlen(r) && ISUNSIGNED(r->n_type))
261	{
262	printf("movz");
263	}
264	else
265	{
266	printf("cvt");
267	}
268	}
269	else
270	{
271	printf("cvt");
272	}
273	prtype(r);
274	prtype(l);
275	ops:
276	printf(" ");
277	adrput(stdout, r);
278	printf(",");
279	adrput(stdout, l);
280	return;
281	}
282
283	case 'C': /* num words pushed on arg stack */
284	if (p->n_op == STCALL \|\| p->n_op == USTCALL)
285	p->n_qual++;
286	printf("$%d", p->n_qual);
287	break;
288
289	case 'D': /* INCR and DECR */
290	zzzcode(p->n_left, 'A');
291	printf("\n ");
292
293	#if 0
294	case 'E': /* INCR and DECR, FOREFF */
295	if (p->n_right->n_lval == 1)
296	{
297	printf("%s", (p->n_op == INCR ? "inc" : "dec") );
298	prtype(p->n_left);
299	printf(" ");
300	adrput(stdout, p->n_left);
301	return;
302	}
303	printf("%s", (p->n_op == INCR ? "add" : "sub") );
304	prtype(p->n_left);
305	printf("2 ");
306	adrput(stdout, p->n_right);
307	printf(",");
308	adrput(p->n_left);
309	return;
310	#endif
311
312	case 'F': /* register type of right operand */
313	{
314	register NODE *n;
315	extern int xdebug;
316	register int ty;
317
318	n = getlr( p, 'R' );
319	ty = n->n_type;
320
321	if (xdebug) printf("->%d<-", ty);
322
323	if ( ty==DOUBLE) printf("d");
324	else if ( ty==FLOAT ) printf("f");
325	else printf("l");
326	return;
327	}
328
329	case 'J': /* jump or ret? */
330	{
331	extern struct interpass_prolog *epp;
332	struct interpass *ip =
333	DLIST_PREV((struct interpass *)epp, qelem);
334	if (ip->type != IP_DEFLAB \|\|
335	ip->ip_lbl != getlr(p, 'L')->n_lval)
336	expand(p, FOREFF, "jbr LL");
337	else
338	printf("ret");
339	}
340	break;
341
342	case 'L': /* type of left operand */
343	case 'R': /* type of right operand */
344	{
345	register NODE *n;
346	extern int xdebug;
347
348	n = getlr ( p, c);
349	if (xdebug) printf("->%d<-", n->n_type);
350
351	prtype(n);
352	return;
353	}
354
355	case 'Z': /* complement mask for bit instr */
356	printf("$%Ld", ~p->n_right->n_lval);
357	return;
358
359	case 'U': /* 32 - n, for unsigned right shifts */
360	printf("$" CONFMT, 32 - p->n_right->n_lval );
361	return;
362
363	case 'T': /* rounded structure length for arguments */
364	{
365	int size;
366
367	size = p->n_stsize;
368	SETOFF( size, 4);
369	printf("$%d", size);
370	return;
371	}
372
373	case 'S': /* structure assignment */
374	{
375	register NODE l, r;
376	register int size;
377
378	l = r = NULL; /* XXX gcc */
379	if( p->n_op == STASG ){
380	l = p->n_left;
381	r = p->n_right;
382
383	}
384	else if( p->n_op == STARG ){ /* store an arg into a temporary */
385	l = getlr( p, '3' );
386	r = p->n_left;
387	}
388	else cerror( "STASG bad" );
389
390	if( r->n_op == ICON ) r->n_op = NAME;
391	else if( r->n_op == REG ) r->n_op = OREG;
392	else if( r->n_op != OREG ) cerror( "STASG-r" );
393
394	size = p->n_stsize;
395
396	if( size <= 0 \|\| size > 65535 )
397	cerror("structure size <0=0 or >65535");
398
399	switch(size) {
400	case 1:
401	printf(" movb ");
402	break;
403	case 2:
404	printf(" movw ");
405	break;
406	case 4:
407	printf(" movl ");
408	break;
409	case 8:
410	printf(" movq ");
411	break;
412	default:
413	printf(" movc3 $%d,", size);
414	break;
415	}
416	adrput(stdout, r);
417	printf(",");
418	adrput(stdout, l);
419	printf("\n");
420
421	if( r->n_op == NAME ) r->n_op = ICON;
422	else if( r->n_op == OREG ) r->n_op = REG;
423
424	}
425	break;
426
427	default:
428	comperr("illegal zzzcode '%c'", c);
429	}
430	}
431
432	void
433	rmove( int rt,int rs, TWORD t ){
434	printf( " %s %s,%s\n",
435	(t==FLOAT ? "movf" : (t==DOUBLE ? "movd" : "movl")),
436	rnames[rs], rnames[rt] );
437	}
438
439	#if 0
440	setregs(){ /* set up temporary registers */
441	fregs = 6; /* tbl- 6 free regs on VAX (0-5) */
442	;
443	}
444
445	szty(t){ /* size, in registers, needed to hold thing of type t */
446	return( (t==DOUBLE\|\|t==FLOAT) ? 2 : 1 );
447	}
448	#endif
449
450	int
451	rewfld( p ) NODE *p; {
452	return(1);
453	}
454
455	#if 0
456	callreg(p) NODE *p; {
457	return( R0 );
458	}
459
460	base( p ) register NODE *p; {
461	register int o = p->op;
462
463	if( (o==ICON && p->name[0] != '\0')) return( 100 ); /* ie no base reg */
464	if( o==REG ) return( p->rval );
465	if( (o==PLUS \|\| o==MINUS) && p->left->op == REG && p->right->op==ICON)
466	return( p->left->rval );
467	if( o==OREG && !R2TEST(p->rval) && (p->type==INT \|\| p->type==UNSIGNED \|\| ISPTR(p->type)) )
468	return( p->rval + 0200*1 );
469	if( o==INCR && p->left->op==REG ) return( p->left->rval + 0200*2 );
470	if( o==ASG MINUS && p->left->op==REG) return( p->left->rval + 0200*4 );
471	if( o==UNARY MUL && p->left->op==INCR && p->left->left->op==REG
472	&& (p->type==INT \|\| p->type==UNSIGNED \|\| ISPTR(p->type)) )
473	return( p->left->left->rval + 0200*(1+2) );
474	return( -1 );
475	}
476
477	offset( p, tyl ) register NODE *p; int tyl; {
478
479	if( tyl==1 && p->op==REG && (p->type==INT \|\| p->type==UNSIGNED) ) return( p->rval );
480	if( (p->op==LS && p->left->op==REG && (p->left->type==INT \|\| p->left->type==UNSIGNED) &&
481	(p->right->op==ICON && p->right->name[0]=='\0')
482	&& (1<<p->right->lval)==tyl))
483	return( p->left->rval );
484	return( -1 );
485	}
486	#endif
487
488	#if 0
489	void
490	makeor2( p, q, b, o) register NODE p, q; register int b, o; {
491	register NODE *t;
492	NODE *f;
493
494	p->n_op = OREG;
495	f = p->n_left; /* have to free this subtree later */
496
497	/* init base */
498	switch (q->n_op) {
499	case ICON:
500	case REG:
501	case OREG:
502	t = q;
503	break;
504
505	case MINUS:
506	q->n_right->n_lval = -q->n_right->n_lval;
507	case PLUS:
508	t = q->n_right;
509	break;
510
511	case UMUL:
512	t = q->n_left->n_left;
513	break;
514
515	default:
516	cerror("illegal makeor2");
517	t = NULL; /* XXX gcc */
518	}
519
520	p->n_lval = t->n_lval;
521	p->n_name = t->n_name;
522
523	/* init offset */
524	p->n_rval = R2PACK( (b & 0177), o, (b>>7) );
525
526	tfree(f);
527	return;
528	}
529
530	int
531	canaddr( p ) NODE *p; {
532	register int o = p->n_op;
533
534	if( o==NAME \|\| o==REG \|\| o==ICON \|\| o==OREG \|\| (o==UMUL && shumul(p->n_left, STARNM\|SOREG)) ) return(1);
535	return(0);
536	}
537
538	shltype( o, p ) register NODE *p; {
539	return( o== REG \|\| o == NAME \|\| o == ICON \|\| o == OREG \|\| ( o==UMUL && shumul(p->n_left, STARNM\|SOREG)) );
540	}
541	#endif
542
543	int
544	fldexpand(NODE p, int cookie, char *cp)
545	{
546	return 0;
547	}
548
549	int
550	flshape( p ) register NODE *p; {
551	return( p->n_op == REG \|\| p->n_op == NAME \|\| p->n_op == ICON \|\|
552	(p->n_op == OREG && (!R2TEST(p->n_rval) \|\| tlen(p) == 1)) );
553	}
554
555	int
556	shtemp( p ) register NODE *p; {
557	if( p->n_op == STARG ) p = p->n_left;
558	return( p->n_op==NAME \|\| p->n_op ==ICON \|\| p->n_op == OREG \|\| (p->n_op==UMUL && shumul(p->n_left, STARNM\|SOREG)) );
559	}
560
561	int
562	shumul( p, shape ) register NODE *p; int shape; {
563	register int o;
564	extern int xdebug;
565
566	if (xdebug) {
567	printf("\nshumul:op=%d,lop=%d,rop=%d", p->n_op, p->n_left->n_op, p->n_right->n_op);
568	printf(" prname=%s,plty=%d, prlval=%lld\n", p->n_right->n_name, p->n_left->n_type, p->n_right->n_lval);
569	}
570
571
572	o = p->n_op;
573	if( o == NAME \|\| (o == OREG && !R2TEST(p->n_rval)) \|\| o == ICON )
574	if (shape & STARNM)
575	return SRDIR;
576
577	#ifdef notyet
578	if( ( o == INCR \|\| o == ASG MINUS ) &&
579	( p->n_left->n_op == REG && p->n_right->n_op == ICON ) &&
580	p->n_right->n_name[0] == '\0' )
581	{
582	switch (p->n_left->n_type)
583	{
584	case CHAR\|PTR:
585	case UCHAR\|PTR:
586	o = 1;
587	break;
588
589	case SHORT\|PTR:
590	case USHORT\|PTR:
591	o = 2;
592	break;
593
594	case INT\|PTR:
595	case UNSIGNED\|PTR:
596	case LONG\|PTR:
597	case ULONG\|PTR:
598	case FLOAT\|PTR:
599	o = 4;
600	break;
601
602	case DOUBLE\|PTR:
603	o = 8;
604	break;
605
606	default:
607	if ( ISPTR(p->n_left->n_type) ) {
608	o = 4;
609	break;
610	}
611	else return(0);
612	}
613	return( p->n_right->n_lval == o ? STARREG : 0);
614	}
615	#endif
616
617	return( SRNOPE );
618	}
619
620	void
621	adrcon( val ) CONSZ val; {
622	printf( "$" );
623	printf( CONFMT, val );
624	}
625
626	void
627	conput(FILE fp, NODE p)
628	{
629	switch( p->n_op ){
630
631	case ICON:
632	acon( p );
633	return;
634
635	case REG:
636	printf( "%s", rnames[p->n_rval] );
637	return;
638
639	default:
640	cerror( "illegal conput" );
641	}
642	}
643
644	void
645	insput( p ) register NODE *p; {
646	cerror( "insput" );
647	}
648
649	void
650	upput( p , size) register NODE *p; {
651	cerror( "upput" );
652	}
653
654	void
655	adrput(FILE fp, NODE p)
656	{
657	register int r;
658	/* output an address, with offsets, from p */
659
660	if( p->n_op == FLD ){
661	p = p->n_left;
662	}
663	switch( p->n_op ){
664
665	case NAME:
666	acon( p );
667	return;
668
669	case ICON:
670	/* addressable value of the constant */
671	if (p->n_name[0] == '\0') /* uses xxxab */
672	printf("$");
673	acon(p);
674	return;
675
676	case REG:
677	printf( "%s", rnames[p->n_rval] );
678	return;
679
680	case OREG:
681	r = p->n_rval;
682	if( R2TEST(r) ){ /* double indexing */
683	register int flags;
684
685	flags = R2UPK3(r);
686	if( flags & 1 ) printf("*");
687	if( flags & 4 ) printf("-");
688	if( p->n_lval != 0 \|\| p->n_name[0] != '\0' ) acon(p);
689	if( R2UPK1(r) != 100) printf( "(%s)", rnames[R2UPK1(r)] );
690	if( flags & 2 ) printf("+");
691	printf( "[%s]", rnames[R2UPK2(r)] );
692	return;
693	}
694	if( r == AP ){ /* in the argument region */
695	if( p->n_lval <= 0 \|\| p->n_name[0] != '\0' ) werror( "bad arg temp" );
696	printf( CONFMT, p->n_lval );
697	printf( "(ap)" );
698	return;
699	}
700	if( p->n_lval != 0 \|\| p->n_name[0] != '\0') acon( p );
701	printf( "(%s)", rnames[p->n_rval] );
702	return;
703
704	case UMUL:
705	/* STARNM or STARREG found */
706	if( tshape(p, STARNM) ) {
707	printf( "*" );
708	adrput(0, p->n_left);
709	}
710	else { /* STARREG - really auto inc or dec */
711	register NODE *q;
712
713	/* tbl
714	p = p->n_left;
715	p->n_left->n_op = OREG;
716	if( p->n_op == INCR ) {
717	adrput( p->n_left );
718	printf( "+" );
719	}
720	else {
721	printf( "-" );
722	adrput( p->n_left );
723	}
724	tbl */
725	#ifdef notyet
726	printf("%c(%s)%c", (p->n_left->n_op==INCR ? '\0' : '-'),
727	rnames[p->n_left->n_left->n_rval],
728	(p->n_left->n_op==INCR ? '+' : '\0') );
729	#else
730	printf("%c(%s)%c", '-',
731	rnames[p->n_left->n_left->n_rval],
732	'\0' );
733	#endif
734	p->n_op = OREG;
735	p->n_rval = p->n_left->n_left->n_rval;
736	q = p->n_left;
737	#ifdef notyet
738
739	p->n_lval = (p->n_left->n_op == INCR ? -p->n_left->n_right->n_lval : 0);
740	#else
741	p->n_lval = 0;
742	#endif
743	p->n_name[0] = '\0';
744	tfree(q);
745	}
746	return;
747
748	default:
749	cerror( "illegal address" );
750	return;
751	}
752
753	}
754
755	/*
756	* print out a constant
757	*/
758	void
759	acon(NODE *p)
760	{
761
762	if (p->n_name[0] == '\0') {
763	printf(CONFMT, p->n_lval);
764	} else if( p->n_lval == 0 ) {
765	printf("%s", p->n_name);
766	} else {
767	printf("%s+", p->n_name);
768	printf(CONFMT, p->n_lval);
769	}
770	}
771
772	#if 0
773	genscall( p, cookie ) register NODE *p; {
774	/* structure valued call */
775	return( gencall( p, cookie ) );
776	}
777
778	/* tbl */
779	int gc_numbytes;
780	/* tbl */
781
782	gencall( p, cookie ) register NODE *p; {
783	/* generate the call given by p */
784	register NODE p1, ptemp;
785	register temp, temp1;
786	register m;
787
788	if( p->right ) temp = argsize( p->right );
789	else temp = 0;
790
791	if( p->op == STCALL \|\| p->op == UNARY STCALL ){
792	/* set aside room for structure return */
793
794	if( p->stsize > temp ) temp1 = p->stsize;
795	else temp1 = temp;
796	}
797
798	if( temp > maxargs ) maxargs = temp;
799	SETOFF(temp1,4);
800
801	if( p->right ){ /* make temp node, put offset in, and generate args */
802	ptemp = talloc();
803	ptemp->op = OREG;
804	ptemp->lval = -1;
805	ptemp->rval = SP;
806	ptemp->name[0] = '\0';
807	ptemp->rall = NOPREF;
808	ptemp->su = 0;
809	genargs( p->right, ptemp );
810	nfree(ptemp);
811	}
812
813	p1 = p->left;
814	if( p1->op != ICON ){
815	if( p1->op != REG ){
816	if( p1->op != OREG \|\| R2TEST(p1->rval) ){
817	if( p1->op != NAME ){
818	order( p1, INAREG );
819	}
820	}
821	}
822	}
823
824	/*
825	if( p1->op == REG && p->rval == R5 ){
826	cerror( "call register overwrite" );
827	}
828	*/
829	/* tbl
830	setup gc_numbytes so reference to ZC works */
831
832	gc_numbytes = temp;
833	/* tbl */
834
835	p->op = UNARY CALL;
836	m = match( p, INTAREG\|INTBREG );
837	/* tbl
838	switch( temp ) {
839	case 0:
840	break;
841	case 2:
842	printf( " tst (sp)+\n" );
843	break;
844	case 4:
845	printf( " cmp (sp)+,(sp)+\n" );
846	break;
847	default:
848	printf( " add $%d,sp\n", temp);
849	}
850	tbl */
851	return(m != MDONE);
852	}
853	#endif
854
855	static char *
856	ccbranches[] = {
857	"jeql",
858	"jneq",
859	"jleq",
860	"jlss",
861	"jgeq",
862	"jgtr",
863	"jlequ",
864	"jlssu",
865	"jgequ",
866	"jgtru",
867	};
868
869	/*
870	* printf conditional and unconditional branches
871	*/
872	void
873	cbgen(int o, int lab)
874	{
875
876	if (o == 0) {
877	printf(" jbr " LABFMT "\n", lab);
878	} else {
879	if (o > UGT)
880	comperr("bad conditional branch: %s", opst[o]);
881	printf("\t%s\t" LABFMT "\n", ccbranches[o-EQ], lab);
882	}
883	}
884
885	static void
886	optim2(NODE p, void arg)
887	{
888	/* do local tree transformations and optimizations */
889
890	register NODE *r;
891
892	switch( p->n_op ) {
893
894	case AND:
895	/* commute L and R to eliminate compliments and constants */
896	if( (p->n_left->n_op==ICON&&p->n_left->n_name[0]==0) \|\| p->n_left->n_op==COMPL ) {
897	r = p->n_left;
898	p->n_left = p->n_right;
899	p->n_right = r;
900	}
901	#if 0
902	case ASG AND:
903	/* change meaning of AND to ~R&L - bic on pdp11 */
904	r = p->n_right;
905	if( r->op==ICON && r->name[0]==0 ) { /* compliment constant */
906	r->lval = ~r->lval;
907	}
908	else if( r->op==COMPL ) { /* ~~A => A */
909	r->op = FREE;
910	p->right = r->left;
911	}
912	else { /* insert complement node */
913	p->right = talloc();
914	p->right->op = COMPL;
915	p->right->rall = NOPREF;
916	p->right->type = r->type;
917	p->right->left = r;
918	p->right->right = NULL;
919	}
920	break;
921	#endif
922	}
923	}
924
925	void
926	myreader(struct interpass *ipole)
927	{
928	struct interpass *ip;
929
930	DLIST_FOREACH(ip, ipole, qelem) {
931	if (ip->type != IP_NODE)
932	continue;
933	walkf(ip->ip_node, optim2, 0);
934	}
935	}
936
937	void
938	mycanon(NODE *p)
939	{
940	}
941
942	void
943	myoptim(struct interpass *ip)
944	{
945	}
946
947	/*
948	* Return argument size in regs.
949	*/
950	static int
951	argsiz(NODE *p)
952	{
953	TWORD t = p->n_type;
954
955	if (t == STRTY \|\| t == UNIONTY)
956	return p->n_stsize/(SZINT/SZCHAR);
957	return szty(t);
958	}
959
960	/*
961	* Last chance to do something before calling a function.
962	*/
963	void
964	lastcall(NODE *p)
965	{
966	NODE *op = p;
967	int size = 0;
968
969	/* Calculate argument sizes */
970	p->n_qual = 0;
971	if (p->n_op != CALL && p->n_op != FORTCALL && p->n_op != STCALL)
972	return;
973	for (p = p->n_right; p->n_op == CM; p = p->n_left)
974	size += argsiz(p->n_right);
975	size += argsiz(p);
976	op->n_qual = size; /* XXX */
977	}
978
979	/*
980	* Return a class suitable for a specific type.
981	*/
982	int
983	gclass(TWORD t)
984	{
985	return (szty(t) == 2 ? CLASSB : CLASSA);
986	}
987
988	/*
989	* For class c, find worst-case displacement of the number of
990	* registers in the array r[] indexed by class.
991	*/
992	int
993	COLORMAP(int c, int *r)
994	{
995	int num;
996
997	switch (c) {
998	case CLASSA:
999	/* there are 12 classa, so min 6 classb are needed to block */
1000	num = r[CLASSB] * 2;
1001	num += r[CLASSA];
1002	return num < 12;
1003	case CLASSB:
1004	/* 6 classa may block all classb */
1005	num = r[CLASSB] + r[CLASSA];
1006	return num < 6;
1007	}
1008	comperr("COLORMAP");
1009	return 0; /* XXX gcc */
1010	}
1011
1012	/*
1013	* Special shapes.
1014	*/
1015	int
1016	special(NODE *p, int shape)
1017	{
1018	return SRNOPE;
1019	}
1020
1021	/*
1022	* Target-dependent command-line options.
1023	*/
1024	void
1025	mflags(char *str)
1026	{
1027	}
1028	/*
1029	* Do something target-dependent for xasm arguments.
1030	* Supposed to find target-specific constraints and rewrite them.
1031	*/
1032	int
1033	myxasm(struct interpass ip, NODE p)
1034	{
1035	return 0;
1036	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: