Context Navigation

source: mainline/uspace/app/pcc/arch/pdp10/local2.c@ 6037308

Visit:

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

Last change on this file since 6037308 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: 27.0 KB

Rev	Line
[a7de7182]	1	/* $Id: local2.c,v 1.102 2008/11/22 16:12:25 ragge Exp $ */
	2	/*
	3	* Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se).
	4	* All rights reserved.
	5	*
	6	* Redistribution and use in source and binary forms, with or without
	7	* modification, are permitted provided that the following conditions
	8	* are met:
	9	* 1. Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* 2. Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	* 3. The name of the author may not be used to endorse or promote products
	15	* derived from this software without specific prior written permission
	16	*
	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	27	*/
	28
	29
	30	# include "pass2.h"
	31	# include <ctype.h>
	32
	33	# define putstr(s) fputs((s), stdout)
	34
	35	void acon(FILE , NODE p);
	36	int argsize(NODE *p);
	37	void genargs(NODE *p);
	38
	39	static int offlab;
	40	int offarg;
	41	static int addto;
	42	static int regoff[16];
	43
	44	void
	45	deflab(int label)
	46	{
	47	printf(LABFMT ":\n", label);
	48	}
	49
	50	void
	51	prologue(struct interpass_prolog *ipp)
	52	{
	53	int i, j;
	54
	55	if (ipp->ipp_vis)
	56	printf(" .globl %s\n", ipp->ipp_name);
	57	printf("%s:\n", ipp->ipp_name);
	58	addto = p2maxautooff;
	59	if (addto >= AUTOINIT/SZCHAR)
	60	addto -= AUTOINIT/SZCHAR;
	61	addto /= SZINT/SZCHAR; /* use words here */
	62	printf(" push %s,%s\n",rnames[STKREG], rnames[FPREG]);
	63	printf(" move %s,%s\n", rnames[FPREG],rnames[STKREG]);
	64
	65	for (i = ipp->ipp_regs[0], j = 0; i ; i >>= 1, j++) {
	66	if (i & 1)
	67	regoff[j] = addto++;
	68	}
	69	if (addto)
	70	printf(" addi %s,0%o\n", rnames[STKREG], addto);
	71
	72	for (i = ipp->ipp_regs[0], j = 0; i ; i >>= 1, j++) {
	73	if (i & 1)
	74	printf(" movem %s,%d(%s)\n",
	75	rnames[j], regoff[j], rnames[STKREG]);
	76	}
	77	}
	78
	79	void
	80	eoftn(struct interpass_prolog *ipp)
	81	{
	82	int i, j;
	83
	84	if (ipp->ipp_ip.ip_lbl == 0)
	85	return; /* no code needs to be generated */
	86	for (i = ipp->ipp_regs[0], j = 0; i ; i >>= 1, j++) {
	87	if (i & 1)
	88	printf(" move %s,%d(%s)\n",
	89	rnames[j], regoff[j], rnames[STKREG]);
	90	}
	91	printf(" move %s,%s\n", rnames[STKREG], rnames[FPREG]);
	92	printf(" pop %s,%s\n", rnames[STKREG], rnames[FPREG]);
	93	printf(" popj %s,\n", rnames[STKREG]);
	94	}
	95
	96	#if 0
	97	void
	98	prologue(int regs, int autos)
	99	{
	100	int i, addto;
	101
	102	offlab = getlab2();
	103	if (regs < 0 \|\| autos < 0) {
	104	/*
	105	* non-optimized code, jump to epilogue for code generation.
	106	*/
	107	ftlab1 = getlab2();
	108	ftlab2 = getlab2();
	109	printf(" jrst L%d\n", ftlab1);
	110	printf("L%d:\n", ftlab2);
	111	} else {
	112	/*
	113	* We here know what register to save and how much to
	114	* add to the stack.
	115	*/
	116	autos = autos + (SZINT-1);
	117	addto = (autos - AUTOINIT)/SZINT + (MAXRVAR-regs);
	118	if (addto \|\| gflag) {
	119	printf(" push %s,%s\n",rnames[017], rnames[016]);
	120	printf(" move %s,%s\n", rnames[016],rnames[017]);
	121	for (i = regs; i < MAXRVAR; i++) {
	122	int db = ((i+1) < MAXRVAR);
	123	printf(" %smovem %s,0%o(%s)\n",
	124	db ? "d" : "",
	125	rnames[i+1], i+1-regs, rnames[016]);
	126	if (db)
	127	i++;
	128	}
	129	if (addto)
	130	printf(" addi %s,0%o\n", rnames[017], addto);
	131	} else
	132	offarg = 1;
	133	}
	134	}
	135
	136	/*
	137	* End of block.
	138	*/
	139	void
	140	eoftn(int regs, int autos, int retlab)
	141	{
	142	register OFFSZ spoff; /* offset from stack pointer */
	143	int i;
	144
	145	spoff = autos + (SZINT-1);
	146	if (spoff >= AUTOINIT)
	147	spoff -= AUTOINIT;
	148	spoff /= SZINT;
	149	/* return from function code */
	150	printf("L%d:\n", retlab);
	151	if (gflag \|\| isoptim == 0 \|\| autos != AUTOINIT \|\| regs != MAXRVAR) {
	152	for (i = regs; i < MAXRVAR; i++) {
	153	int db = ((i+1) < MAXRVAR);
	154	printf(" %smove %s,0%o(%s)\n", db ? "d" : "",
	155	rnames[i+1], i+1-regs, rnames[016]);
	156	if (db)
	157	i++;
	158	}
	159	printf(" move %s,%s\n", rnames[017], rnames[016]);
	160	printf(" pop %s,%s\n", rnames[017], rnames[016]);
	161	}
	162	printf(" popj %s,\n", rnames[017]);
	163
	164	/* Prolog code */
	165	if (isoptim == 0) {
	166	printf("L%d:\n", ftlab1);
	167	printf(" push %s,%s\n", rnames[017], rnames[016]);
	168	printf(" move %s,%s\n", rnames[016], rnames[017]);
	169	for (i = regs; i < MAXRVAR; i++) {
	170	int db = ((i+1) < MAXRVAR);
	171	printf(" %smovem %s,0%o(%s)\n", db ? "d" : "",
	172	rnames[i+1], i+1-regs, rnames[016]);
	173	spoff++;
	174	if (db)
	175	i++, spoff++;
	176	}
	177	if (spoff)
	178	printf(" addi %s,0%llo\n", rnames[017], spoff);
	179	printf(" jrst L%d\n", ftlab2);
	180	}
	181	printf(" .set " LABFMT ",0%o\n", offlab, MAXRVAR-regs);
	182	offarg = isoptim = 0;
	183	}
	184	#endif
	185
	186	/*
	187	* add/sub/...
	188	*
	189	* Param given:
	190	* R - Register
	191	* M - Memory
	192	* C - Constant
	193	*/
	194	void
	195	hopcode(int f, int o)
	196	{
	197	cerror("hopcode: f %d %d", f, o);
	198	}
	199
	200	char *
	201	rnames[] = { /* keyed to register number tokens */
	202	"%0", "%1", "%2", "%3", "%4", "%5", "%6", "%7",
	203	"%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",
	204	"%0", "%1", "%2", "%3", "%4", "%5", "%6", "%7",
	205	"%10", "%11", "%12", "%13", "%14", "%15",
	206	};
	207
	208	int
	209	tlen(p) NODE *p;
	210	{
	211	switch(p->n_type) {
	212	case CHAR:
	213	case UCHAR:
	214	return(1);
	215
	216	case SHORT:
	217	case USHORT:
	218	return(SZSHORT/SZCHAR);
	219
	220	case DOUBLE:
	221	return(SZDOUBLE/SZCHAR);
	222
	223	case INT:
	224	case UNSIGNED:
	225	case LONG:
	226	case ULONG:
	227	return(SZINT/SZCHAR);
	228
	229	case LONGLONG:
	230	case ULONGLONG:
	231	return SZLONGLONG/SZCHAR;
	232
	233	default:
	234	if (!ISPTR(p->n_type))
	235	cerror("tlen type %d not pointer");
	236	return SZPOINT(0)/SZCHAR;
	237	}
	238	}
	239
	240	static char *
	241	binskip[] = {
	242	"e", /* jumpe */
	243	"n", /* jumpn */
	244	"le", /* jumple */
	245	"l", /* jumpl */
	246	"ge", /* jumpge */
	247	"g", /* jumpg */
	248	};
	249
	250	/*
	251	* Extract the higher 36 bits from a longlong.
	252	*/
	253	static CONSZ
	254	gethval(CONSZ lval)
	255	{
	256	CONSZ hval = (lval >> 35) & 03777777777LL;
	257
	258	if ((hval & 03000000000LL) == 03000000000LL) {
	259	hval \|= 0777000000000LL;
	260	} else if ((hval & 03000000000LL) == 02000000000LL) {
	261	hval &= 01777777777LL;
	262	hval \|= 0400000000000LL;
	263	}
	264	return hval;
	265	}
	266
	267	/*
	268	* Do a binary comparision, and jump accordingly.
	269	*/
	270	static void
	271	twocomp(NODE *p)
	272	{
	273	int o = p->n_op;
	274	extern int negrel[];
	275	int isscon = 0, iscon = p->n_right->n_op == ICON;
	276
	277	if (o < EQ \|\| o > GT)
	278	cerror("bad binary conditional branch: %s", opst[o]);
	279
	280	if (iscon && p->n_right->n_name[0] != 0) {
	281	printf(" cam%s ", binskip[negrel[o-EQ]-EQ]);
	282	adrput(stdout, getlr(p, 'L'));
	283	putchar(',');
	284	printf("[ .long ");
	285	adrput(stdout, getlr(p, 'R'));
	286	putchar(']');
	287	printf("\n jrst L%d\n", p->n_label);
	288	return;
	289	}
	290	if (iscon)
	291	isscon = p->n_right->n_lval >= 0 &&
	292	p->n_right->n_lval < 01000000;
	293
	294	printf(" ca%c%s ", iscon && isscon ? 'i' : 'm',
	295	binskip[negrel[o-EQ]-EQ]);
	296	adrput(stdout, getlr(p, 'L'));
	297	putchar(',');
	298	if (iscon && (isscon == 0)) {
	299	printf("[ .long ");
	300	adrput(stdout, getlr(p, 'R'));
	301	putchar(']');
	302	} else
	303	adrput(stdout, getlr(p, 'R'));
	304	printf("\n jrst L%d\n", p->n_label);
	305	}
	306
	307	/*
	308	* Compare byte/word pointers.
	309	* XXX - do not work for highest bit set in address
	310	*/
	311	static void
	312	ptrcomp(NODE *p)
	313	{
	314	printf(" rot "); adrput(stdout, getlr(p, 'L')); printf(",6\n");
	315	printf(" rot "); adrput(stdout, getlr(p, 'R')); printf(",6\n");
	316	twocomp(p);
	317	}
	318
	319	/*
	320	* Do a binary comparision of two long long, and jump accordingly.
	321	* XXX - can optimize for constants.
	322	*/
	323	static void
	324	twollcomp(NODE *p)
	325	{
	326	int o = p->n_op;
	327	int iscon = p->n_right->n_op == ICON;
	328	int m = 0; /* XXX gcc */
	329
	330	if (o < EQ \|\| o > GT)
	331	cerror("bad long long conditional branch: %s", opst[o]);
	332
	333	/* Special strategy for equal/not equal */
	334	if (o == EQ \|\| o == NE) {
	335	if (o == EQ)
	336	m = getlab2();
	337	printf(" came ");
	338	upput(getlr(p, 'L'), SZLONG);
	339	putchar(',');
	340	if (iscon)
	341	printf("[ .long ");
	342	upput(getlr(p, 'R'), SZLONG);
	343	if (iscon)
	344	putchar(']');
	345	printf("\n jrst L%d\n", o == EQ ? m : p->n_label);
	346	printf(" cam%c ", o == EQ ? 'n' : 'e');
	347	adrput(stdout, getlr(p, 'L'));
	348	putchar(',');
	349	if (iscon)
	350	printf("[ .long ");
	351	adrput(stdout, getlr(p, 'R'));
	352	if (iscon)
	353	putchar(']');
	354	printf("\n jrst L%d\n", p->n_label);
	355	if (o == EQ)
	356	printf("L%d:\n", m);
	357	return;
	358	}
	359	/* First test highword */
	360	printf(" cam%ce ", o == GT \|\| o == GE ? 'l' : 'g');
	361	adrput(stdout, getlr(p, 'L'));
	362	putchar(',');
	363	if (iscon)
	364	printf("[ .long ");
	365	adrput(stdout, getlr(p, 'R'));
	366	if (iscon)
	367	putchar(']');
	368	printf("\n jrst L%d\n", p->n_label);
	369
	370	/* Test equality */
	371	printf(" came ");
	372	adrput(stdout, getlr(p, 'L'));
	373	putchar(',');
	374	if (iscon)
	375	printf("[ .long ");
	376	adrput(stdout, getlr(p, 'R'));
	377	if (iscon)
	378	putchar(']');
	379	printf("\n jrst L%d\n", m = getlab2());
	380
	381	/* Test lowword. Only works with pdp10 format for longlongs */
	382	printf(" cam%c%c ", o == GT \|\| o == GE ? 'l' : 'g',
	383	o == LT \|\| o == GT ? 'e' : ' ');
	384	upput(getlr(p, 'L'), SZLONG);
	385	putchar(',');
	386	if (iscon)
	387	printf("[ .long ");
	388	upput(getlr(p, 'R'), SZLONG);
	389	if (iscon)
	390	putchar(']');
	391	printf("\n jrst L%d\n", p->n_label);
	392	printf("L%d:\n", m);
	393	}
	394
	395	/*
	396	* Print the correct instruction for constants.
	397	*/
	398	static void
	399	constput(NODE *p)
	400	{
	401	CONSZ val = p->n_right->n_lval;
	402	int reg = p->n_left->n_rval;
	403
	404	/* Only numeric constant */
	405	if (p->n_right->n_name[0] == '\0') {
	406	if (val == 0) {
	407	printf("movei %s,0", rnames[reg]);
	408	} else if ((val & 0777777000000LL) == 0) {
	409	printf("movei %s,0%llo", rnames[reg], val);
	410	} else if ((val & 0777777) == 0) {
	411	printf("hrlzi %s,0%llo", rnames[reg], val >> 18);
	412	} else {
	413	printf("move %s,[ .long 0%llo]", rnames[reg],
	414	szty(p->n_right->n_type) > 1 ? val :
	415	val & 0777777777777LL);
	416	}
	417	/* Can have more tests here, hrloi etc */
	418	return;
	419	} else {
	420	printf("xmovei %s,%s", rnames[reg], p->n_right->n_name);
	421	if (val)
	422	printf("+" CONFMT, val);
	423	}
	424	}
	425
	426	/*
	427	* Return true if the constant can be bundled in an instruction (immediate).
	428	*/
	429	static int
	430	oneinstr(NODE *p)
	431	{
	432	if (p->n_name[0] != '\0')
	433	return 0;
	434	if ((p->n_lval & 0777777000000ULL) != 0)
	435	return 0;
	436	return 1;
	437	}
	438
	439	/*
	440	* Emit a halfword or byte instruction, from OREG to REG.
	441	* Sign extension must also be done here.
	442	*/
	443	static void
	444	emitshort(NODE *p)
	445	{
	446	CONSZ off = p->n_lval;
	447	TWORD type = p->n_type;
	448	int reg = p->n_rval;
	449	int issigned = !ISUNSIGNED(type);
	450	int ischar = type == CHAR \|\| type == UCHAR;
	451	int reg1 = getlr(p, '1')->n_rval;
	452
	453	if (off < 0) { /* argument, use move instead */
	454	printf(" move ");
	455	} else if (off == 0 && p->n_name[0] == 0) {
	456	printf(" ldb %s,%s\n", rnames[reg1], rnames[reg]);
	457	/* XXX must sign extend here even if not necessary */
	458	switch (type) {
	459	case CHAR:
	460	printf(" lsh %s,033\n", rnames[reg1]);
	461	printf(" ash %s,-033\n", rnames[reg1]);
	462	break;
	463	case SHORT:
	464	printf(" hrre %s,%s\n",
	465	rnames[reg1], rnames[reg1]);
	466	break;
	467	}
	468	return;
	469	} else if (ischar) {
	470	if (off >= 0700000000000LL && p->n_name[0] != '\0') {
	471	cerror("emitsh");
	472	/* reg contains index integer */
	473	// if (!istreg(reg))
	474	// cerror("emitshort !istreg");
	475	printf(" adjbp %s,[ .long 0%llo+%s ]\n",
	476	rnames[reg], off, p->n_name);
	477	printf(" ldb ");
	478	adrput(stdout, getlr(p, '1'));
	479	printf(",%s\n", rnames[reg]);
	480	goto signe;
	481	}
	482	printf(" ldb ");
	483	adrput(stdout, getlr(p, '1'));
	484	if (off)
	485	printf(",[ .long 0%02o11%02o%06o ]\n",
	486	(int)(27-(9*(off&3))), reg, (int)off/4);
	487	else
	488	printf(",%s\n", rnames[reg]);
	489	signe: if (issigned) {
	490	printf(" lsh ");
	491	adrput(stdout, getlr(p, '1'));
	492	printf(",033\n ash ");
	493	adrput(stdout, getlr(p, '1'));
	494	printf(",-033\n");
	495	}
	496	return;
	497	} else {
	498	printf(" h%cr%c ", off & 1 ? 'r' : 'l',
	499	issigned ? 'e' : 'z');
	500	}
	501	p->n_lval /= (ischar ? 4 : 2);
	502	adrput(stdout, getlr(p, '1'));
	503	putchar(',');
	504	adrput(stdout, getlr(p, 'L'));
	505	putchar('\n');
	506	}
	507
	508	/*
	509	* Store a short from a register. Destination is a OREG.
	510	*/
	511	static void
	512	storeshort(NODE *p)
	513	{
	514	NODE *l = p->n_left;
	515	CONSZ off = l->n_lval;
	516	int reg = l->n_rval;
	517	int ischar = BTYPE(p->n_type) == CHAR \|\| BTYPE(p->n_type) == UCHAR;
	518
	519	if (l->n_op == NAME) {
	520	if (ischar) {
	521	printf(" dpb ");
	522	adrput(stdout, getlr(p, 'R'));
	523	printf(",[ .long 0%02o%010o+%s ]\n",
	524	070+((int)off&3), (int)(off/4), l->n_name);
	525	return;
	526	}
	527	printf(" hr%cm ", off & 1 ? 'r' : 'l');
	528	l->n_lval /= 2;
	529	adrput(stdout, getlr(p, 'R'));
	530	putchar(',');
	531	adrput(stdout, getlr(p, 'L'));
	532	putchar('\n');
	533	return;
	534	}
	535
	536	if (off \|\| reg == FPREG) { /* Can emit halfword instructions */
	537	if (off < 0) { /* argument, use move instead */
	538	printf(" movem ");
	539	} else if (ischar) {
	540	printf(" dpb ");
	541	adrput(stdout, getlr(p, '1'));
	542	printf(",[ .long 0%02o11%02o%06o ]\n",
	543	(int)(27-(9*(off&3))), reg, (int)off/4);
	544	return;
	545	} else {
	546	printf(" hr%cm ", off & 1 ? 'r' : 'l');
	547	}
	548	l->n_lval /= 2;
	549	adrput(stdout, getlr(p, 'R'));
	550	putchar(',');
	551	adrput(stdout, getlr(p, 'L'));
	552	} else {
	553	printf(" dpb ");
	554	adrput(stdout, getlr(p, 'R'));
	555	putchar(',');
	556	l = getlr(p, 'L');
	557	l->n_op = REG;
	558	adrput(stdout, l);
	559	l->n_op = OREG;
	560	}
	561	putchar('\n');
	562	}
	563
	564	/*
	565	* Multiply a register with a constant.
	566	*/
	567	static void
	568	imuli(NODE *p)
	569	{
	570	NODE *r = p->n_right;
	571
	572	if (r->n_lval >= 0 && r->n_lval <= 0777777) {
	573	printf(" imuli ");
	574	adrput(stdout, getlr(p, 'L'));
	575	printf(",0%llo\n", r->n_lval);
	576	} else {
	577	printf(" imul ");
	578	adrput(stdout, getlr(p, 'L'));
	579	printf(",[ .long 0%llo ]\n", r->n_lval & 0777777777777LL);
	580	}
	581	}
	582
	583	/*
	584	* Divide a register with a constant.
	585	*/
	586	static void
	587	idivi(NODE *p)
	588	{
	589	NODE *r = p->n_right;
	590
	591	if (r->n_lval >= 0 && r->n_lval <= 0777777) {
	592	printf(" idivi ");
	593	adrput(stdout, getlr(p, '1'));
	594	printf(",0%llo\n", r->n_lval);
	595	} else {
	596	printf(" idiv ");
	597	adrput(stdout, getlr(p, '1'));
	598	printf(",[ .long 0%llo ]\n", r->n_lval & 0777777777777LL);
	599	}
	600	}
	601
	602	/*
	603	* move a constant into a register.
	604	*/
	605	static void
	606	xmovei(NODE *p)
	607	{
	608	/*
	609	* Trick: If this is an unnamed constant, just move it directly,
	610	* otherwise use xmovei to get section number.
	611	*/
	612	if (p->n_name[0] == '\0' \|\| p->n_lval > 0777777) {
	613	printf(" ");
	614	zzzcode(p, 'D');
	615	putchar(' ');
	616	adrput(stdout, getlr(p, '1'));
	617	putchar(',');
	618	zzzcode(p, 'E');
	619	} else {
	620	printf(" xmovei ");
	621	adrput(stdout, getlr(p, '1'));
	622	printf(",%s", p->n_name);
	623	if (p->n_lval != 0)
	624	printf("+0%llo", p->n_lval);
	625	}
	626	putchar('\n');
	627	}
	628
	629	static void
	630	printcon(NODE *p)
	631	{
	632	CONSZ cz;
	633
	634	p = p->n_left;
	635	if (p->n_lval >= 0700000000000LL) {
	636	/* converted to pointer in clocal() */
	637	conput(0, p);
	638	return;
	639	}
	640	if (p->n_lval == 0 && p->n_name[0] == '\0') {
	641	putchar('0');
	642	return;
	643	}
	644	if (BTYPE(p->n_type) == CHAR \|\| BTYPE(p->n_type) == UCHAR)
	645	cz = (p->n_lval/4) \| ((p->n_lval & 3) << 30);
	646	else
	647	cz = (p->n_lval/2) \| (((p->n_lval & 1) + 5) << 30);
	648	cz \|= 0700000000000LL;
	649	printf("0%llo", cz);
	650	if (p->n_name[0] != '\0')
	651	printf("+%s", p->n_name);
	652	}
	653
	654	static void
	655	putcond(NODE *p)
	656	{
	657	char c = 0; / XXX gcc */
	658
	659	switch (p->n_op) {
	660	case EQ: c = "e"; break;
	661	case NE: c = "n"; break;
	662	case LE: c = "le"; break;
	663	case LT: c = "l"; break;
	664	case GT: c = "g"; break;
	665	case GE: c = "ge"; break;
	666	default:
	667	cerror("putcond");
	668	}
	669	printf("%s", c);
	670	}
	671
	672	void
	673	zzzcode(NODE *p, int c)
	674	{
	675	NODE *l;
	676	CONSZ hval;
	677
	678	switch (c) {
	679	case 'A': /* ildb right arg */
	680	adrput(stdout, p->n_left->n_left);
	681	break;
	682
	683	case 'B': /* remove from stack after subroutine call */
	684	if (p->n_qual)
	685	printf(" subi %%17,0%o\n", p->n_qual);
	686	break;
	687
	688	case 'C':
	689	constput(p);
	690	break;
	691
	692	case 'D': /* Find out which type of const load insn to use */
	693	if (p->n_op != ICON)
	694	cerror("zzzcode not ICON");
	695	if (p->n_name[0] == '\0') {
	696	if ((p->n_lval <= 0777777) && (p->n_lval > 0))
	697	printf("movei");
	698	else if ((p->n_lval & 0777777) == 0)
	699	printf("hrlzi");
	700	else
	701	printf("move");
	702	} else
	703	printf("move");
	704	break;
	705
	706	case 'E': /* Print correct constant expression */
	707	if (p->n_name[0] == '\0') {
	708	if ((p->n_lval <= 0777777) && (p->n_lval > 0)){
	709	printf("0%llo", p->n_lval);
	710	} else if ((p->n_lval & 0777777) == 0) {
	711	printf("0%llo", p->n_lval >> 18);
	712	} else {
	713	if (p->n_lval < 0)
	714	printf("[ .long -0%llo]", -p->n_lval);
	715	else
	716	printf("[ .long 0%llo]", p->n_lval);
	717	}
	718	} else {
	719	if (p->n_lval == 0)
	720	printf("[ .long %s]", p->n_name);
	721	else
	722	printf("[ .long %s+0%llo]",
	723	p->n_name, p->n_lval);
	724	}
	725	break;
	726
	727	case 'G': /* structure argument */
	728	printf(" addl %%17,0%o\n", p->n_stsize/(SZINT/SZCHAR));
	729	printf(" foo...\n");
	730	break;
	731
	732	case 'P':
	733	p = getlr(p, 'R');
	734	/* FALLTHROUGH */
	735	case 'O':
	736	/*
	737	* Print long long expression.
	738	*/
	739	hval = gethval(p->n_lval);
	740	printf("[ .long 0%llo,0%llo", hval,
	741	(p->n_lval & 0377777777777LL) \| (hval & 0400000000000LL));
	742	if (p->n_name[0] != '\0')
	743	printf("+%s", p->n_name);
	744	printf(" ]");
	745	break;
	746
	747	case 'F': /* Print an "opsimp" instruction based on its const type */
	748	hopcode(oneinstr(p->n_right) ? 'C' : 'R', p->n_op);
	749	break;
	750
	751	case 'H': /* Print a small constant */
	752	p = p->n_right;
	753	printf("0%llo", p->n_lval & 0777777);
	754	break;
	755
	756	case 'Q': /* two-param long long comparisions */
	757	twollcomp(p);
	758	break;
	759
	760	case 'R': /* two-param conditionals */
	761	twocomp(p);
	762	break;
	763
	764	case 'U':
	765	emitshort(p);
	766	break;
	767
	768	case 'V':
	769	storeshort(p);
	770	break;
	771
	772	case 'Z':
	773	ptrcomp(p);
	774	break;
	775
	776	case 'a':
	777	imuli(p);
	778	break;
	779
	780	case 'b':
	781	idivi(p);
	782	break;
	783
	784	case 'c':
	785	xmovei(p);
	786	break;
	787
	788	case 'd':
	789	printcon(p);
	790	break;
	791
	792	case 'e':
	793	putcond(p);
	794	break;
	795
	796	case 'g':
	797	if (p->n_right->n_op != OREG \|\| p->n_right->n_lval != 0)
	798	comperr("bad Zg oreg");
	799	printf("%s", rnames[p->n_right->n_rval]);
	800	break;
	801
	802	#if 0
	803	case '1': /* double upput */
	804	p = getlr(p, '1');
	805	p->n_rval += 2;
	806	adrput(stdout, p);
	807	p->n_rval -= 2;
	808	break;
	809	#endif
	810
	811	case 'i': /* Write instruction for short load from name */
	812	l = getlr(p, 'L');
	813	printf(" h%cr%c %s,%s+" CONFMT "\n",
	814	l->n_lval & 1 ? 'r' : 'l',
	815	ISUNSIGNED(p->n_type) ? 'z' : 'e',
	816	rnames[getlr(p, '1')->n_rval],
	817	l->n_name, l->n_lval >> 1);
	818	break;
	819
	820	default:
	821	cerror("zzzcode %c", c);
	822	}
	823	}
	824
	825	/* set up temporary registers */
	826	void
	827	setregs()
	828	{
	829	fregs = 7; /* 7 free regs on PDP10 (1-7) */
	830	}
	831
	832	/ARGSUSED/
	833	int
	834	rewfld(NODE *p)
	835	{
	836	return(1);
	837	}
	838
	839	int
	840	fldexpand(NODE p, int cookie, char *cp)
	841	{
	842	return 0;
	843	}
	844
	845	int
	846	flshape(NODE *p)
	847	{
	848	register int o = p->n_op;
	849
	850	return (o == REG \|\| o == NAME \|\| o == ICON \|\|
	851	(o == OREG && (!R2TEST(p->n_rval) \|\| tlen(p) == 1)));
	852	}
	853
	854	/* INTEMP shapes must not contain any temporary registers */
	855	int
	856	shtemp(NODE *p)
	857	{
	858	return(0);
	859	}
	860
	861	int
	862	shumul(NODE *p, int order)
	863	{
	864	register int o;
	865
	866	if (x2debug) {
	867	int val;
	868	printf("shumul(%p)\n", p);
	869	eprint(p, 0, &val, &val);
	870	}
	871
	872	o = p->n_op;
	873	#if 0
	874	if (o == NAME \|\| (o == OREG && !R2TEST(p->n_rval)) \|\| o == ICON)
	875	return(STARNM);
	876	#endif
	877
	878	#if 0
	879	if ((o == INCR) &&
	880	(p->n_left->n_op == REG && p->n_right->n_op == ICON) &&
	881	p->n_right->n_name[0] == '\0') {
	882	switch (p->n_type) {
	883	case CHAR\|PTR:
	884	case UCHAR\|PTR:
	885	o = 1;
	886	break;
	887
	888	case SHORT\|PTR:
	889	case USHORT\|PTR:
	890	o = 2;
	891	break;
	892
	893	case INT\|PTR:
	894	case UNSIGNED\|PTR:
	895	case LONG\|PTR:
	896	case ULONG\|PTR:
	897	case FLOAT\|PTR:
	898	o = 4;
	899	break;
	900
	901	case DOUBLE\|PTR:
	902	case LONGLONG\|PTR:
	903	case ULONGLONG\|PTR:
	904	o = 8;
	905	break;
	906
	907	default:
	908	if (ISPTR(p->n_type) &&
	909	ISPTR(DECREF(p->n_type))) {
	910	o = 4;
	911	break;
	912	} else
	913	return(0);
	914	}
	915	return( 0);
	916	}
	917	#endif
	918	return( SRNOPE );
	919	}
	920
	921	void
	922	adrcon(CONSZ val)
	923	{
	924	cerror("adrcon: val %llo\n", val);
	925	}
	926
	927	void
	928	conput(FILE fp, NODE p)
	929	{
	930	switch (p->n_op) {
	931	case ICON:
	932	if (p->n_lval != 0) {
	933	acon(stdout, p);
	934	if (p->n_name[0] != '\0')
	935	putchar('+');
	936	}
	937	if (p->n_name[0] != '\0')
	938	printf("%s", p->n_name);
	939	if (p->n_name[0] == '\0' && p->n_lval == 0)
	940	putchar('0');
	941	return;
	942
	943	case REG:
	944	putstr(rnames[p->n_rval]);
	945	return;
	946
	947	default:
	948	cerror("illegal conput");
	949	}
	950	}
	951
	952	/ARGSUSED/
	953	void
	954	insput(NODE *p)
	955	{
	956	cerror("insput");
	957	}
	958
	959	/*
	960	* Write out the upper address, like the upper register of a 2-register
	961	* reference, or the next memory location.
	962	*/
	963	void
	964	upput(NODE *p, int size)
	965	{
	966
	967	size /= SZLONG;
	968	switch (p->n_op) {
	969	case REG:
	970	putstr(rnames[p->n_rval + size]);
	971	break;
	972
	973	case NAME:
	974	case OREG:
	975	p->n_lval += size;
	976	adrput(stdout, p);
	977	p->n_lval -= size;
	978	break;
	979	case ICON:
	980	printf(CONFMT, p->n_lval >> (36 * size));
	981	break;
	982	default:
	983	cerror("upput bad op %d size %d", p->n_op, size);
	984	}
	985	}
	986
	987	void
	988	adrput(FILE fp, NODE p)
	989	{
	990	int r;
	991	/* output an address, with offsets, from p */
	992
	993	if (p->n_op == FLD)
	994	p = p->n_left;
	995
	996	switch (p->n_op) {
	997
	998	case NAME:
	999	if (p->n_name[0] != '\0')
	1000	fputs(p->n_name, fp);
	1001	if (p->n_lval != 0)
	1002	fprintf(fp, "+" CONFMT, p->n_lval & 0777777777777LL);
	1003	return;
	1004
	1005	case OREG:
	1006	r = p->n_rval;
	1007	#if 0
	1008	if (R2TEST(r)) { /* double indexing */
	1009	register int flags;
	1010
	1011	flags = R2UPK3(r);
	1012	if (flags & 1)
	1013	putc('*', fp);
	1014	if (flags & 4)
	1015	putc('-', fp);
	1016	if (p->n_lval != 0 \|\| p->n_name[0] != '\0')
	1017	acon(p);
	1018	if (R2UPK1(r) != 100)
	1019	printf("(%s)", rnames[R2UPK1(r)]);
	1020	if (flags & 2)
	1021	putchar('+');
	1022	printf("[%s]", rnames[R2UPK2(r)]);
	1023	return;
	1024	}
	1025	#endif
	1026	if (R2TEST(r))
	1027	cerror("adrput: unwanted double indexing: r %o", r);
	1028	if (p->n_rval != FPREG && p->n_lval < 0 && p->n_name[0]) {
	1029	fprintf(fp, "%s", p->n_name);
	1030	acon(fp, p);
	1031	fprintf(fp, "(%s)", rnames[p->n_rval]);
	1032	return;
	1033	}
	1034	if (p->n_lval < 0 && p->n_rval == FPREG && offarg) {
	1035	p->n_lval -= offarg-2; acon(fp, p); p->n_lval += offarg-2;
	1036	} else if (p->n_lval != 0)
	1037	acon(fp, p);
	1038	if (p->n_name[0] != '\0')
	1039	fprintf(fp, "%s%s", p->n_lval ? "+" : "", p->n_name);
	1040	if (p->n_lval > 0 && p->n_rval == FPREG && offlab)
	1041	fprintf(fp, "+" LABFMT, offlab);
	1042	if (p->n_lval < 0 && p->n_rval == FPREG && offarg)
	1043	fprintf(fp, "(017)");
	1044	else
	1045	fprintf(fp, "(%s)", rnames[p->n_rval]);
	1046	return;
	1047	case ICON:
	1048	/* addressable value of the constant */
	1049	if (p->n_lval > 0) {
	1050	acon(fp, p);
	1051	if (p->n_name[0] != '\0')
	1052	putc('+', fp);
	1053	}
	1054	if (p->n_name[0] != '\0')
	1055	fprintf(fp, "%s", p->n_name);
	1056	if (p->n_lval < 0)
	1057	acon(fp, p);
	1058	if (p->n_name[0] == '\0' && p->n_lval == 0)
	1059	putc('0', fp);
	1060	return;
	1061
	1062	case REG:
	1063	fputs(rnames[p->n_rval], fp);
	1064	return;
	1065
	1066	default:
	1067	cerror("illegal address, op %d", p->n_op);
	1068	return;
	1069
	1070	}
	1071	}
	1072
	1073	/*
	1074	* print out a constant
	1075	*/
	1076	void
	1077	acon(FILE fp, NODE p)
	1078	{
	1079	if (p->n_lval < 0 && p->n_lval > -0777777777777ULL)
	1080	fprintf(fp, "-" CONFMT, -p->n_lval);
	1081	else
	1082	fprintf(fp, CONFMT, p->n_lval);
	1083	}
	1084
	1085	/* printf conditional and unconditional branches */
	1086	void
	1087	cbgen(int o,int lab)
	1088	{
	1089	}
	1090
	1091	/*
	1092	* Do some local optimizations that must be done after optim is called.
	1093	*/
	1094	static void
	1095	optim2(NODE p, void arg)
	1096	{
	1097	int op = p->n_op;
	1098	int m, ml;
	1099	NODE *l;
	1100
	1101	/* Remove redundant PCONV's */
	1102	if (op == PCONV) {
	1103	l = p->n_left;
	1104	m = BTYPE(p->n_type);
	1105	ml = BTYPE(l->n_type);
	1106	if ((m == INT \|\| m == LONG \|\| m == LONGLONG \|\| m == FLOAT \|\|
	1107	m == DOUBLE \|\| m == STRTY \|\| m == UNIONTY \|\|
	1108	m == UNSIGNED \|\| m == ULONG \|\| m == ULONGLONG) &&
	1109	(ml == INT \|\| ml == LONG \|\| ml == LONGLONG \|\| ml == FLOAT \|\|
	1110	ml == DOUBLE \|\| ml == STRTY \|\| ml == UNIONTY \|\|
	1111	ml == UNSIGNED \|\| ml == ULONG \|\|
	1112	ml == ULONGLONG) && ISPTR(l->n_type)) {
	1113	p = l;
	1114	nfree(l);
	1115	op = p->n_op;
	1116	} else
	1117	if (ISPTR(DECREF(p->n_type)) &&
	1118	(l->n_type == INCREF(STRTY))) {
	1119	p = l;
	1120	nfree(l);
	1121	op = p->n_op;
	1122	} else
	1123	if (ISPTR(DECREF(l->n_type)) &&
	1124	(p->n_type == INCREF(INT) \|\|
	1125	p->n_type == INCREF(STRTY) \|\|
	1126	p->n_type == INCREF(UNSIGNED))) {
	1127	p = l;
	1128	nfree(l);
	1129	op = p->n_op;
	1130	}
	1131
	1132	}
	1133	/* Add constands, similar to the one in optim() */
	1134	if (op == PLUS && p->n_right->n_op == ICON) {
	1135	l = p->n_left;
	1136	if (l->n_op == PLUS && l->n_right->n_op == ICON &&
	1137	(p->n_right->n_name[0] == '\0' \|\|
	1138	l->n_right->n_name[0] == '\0')) {
	1139	l->n_right->n_lval += p->n_right->n_lval;
	1140	if (l->n_right->n_name[0] == '\0')
	1141	l->n_right->n_name = p->n_right->n_name;
	1142	nfree(p->n_right);
	1143	p = l;
	1144	nfree(l);
	1145	}
	1146	}
	1147
	1148	/* Convert "PTR undef" (void ) to "PTR uchar" /
	1149	/* XXX - should be done in MI code */
	1150	if (BTYPE(p->n_type) == VOID)
	1151	p->n_type = (p->n_type & ~BTMASK) \| UCHAR;
	1152	if (op == ICON) {
	1153	if ((p->n_type == (PTR\|CHAR) \|\| p->n_type == (PTR\|UCHAR))
	1154	&& p->n_lval == 0 && p->n_name[0] != '\0')
	1155	p->n_lval = 0700000000000LL;
	1156	if ((p->n_type == (PTR\|SHORT) \|\| p->n_type == (PTR\|USHORT))
	1157	&& p->n_lval == 0 && p->n_name[0] != '\0')
	1158	p->n_lval = 0750000000000LL;
	1159	}
	1160	if (op == MINUS) {
	1161	if ((p->n_left->n_type == (PTR\|CHAR) \|\|
	1162	p->n_left->n_type == (PTR\|UCHAR)) &&
	1163	(p->n_right->n_type == (PTR\|CHAR) \|\|
	1164	p->n_right->n_type == (PTR\|UCHAR))) {
	1165	l = talloc();
	1166	l->n_op = SCONV;
	1167	l->n_type = INT;
	1168	l->n_left = p->n_right;
	1169	p->n_right = l;
	1170	l = talloc();
	1171	l->n_op = SCONV;
	1172	l->n_type = INT;
	1173	l->n_left = p->n_left;
	1174	p->n_left = l;
	1175	}
	1176	}
	1177	}
	1178
	1179	void
	1180	myreader(struct interpass *ipole)
	1181	{
	1182	struct interpass *ip;
	1183
	1184	DLIST_FOREACH(ip, ipole, qelem) {
	1185	if (ip->type != IP_NODE)
	1186	continue;
	1187	walkf(ip->ip_node, optim2, 0);
	1188	}
	1189
	1190	if (x2debug) {
	1191	printf("myreader final tree:\n");
	1192	printip(ipole);
	1193	}
	1194	}
	1195
	1196	/*
	1197	* Remove some PCONVs after OREGs are created.
	1198	*/
	1199	static void
	1200	pconv2(NODE p, void arg)
	1201	{
	1202	NODE *q;
	1203
	1204	if (p->n_op == PLUS) {
	1205	if (p->n_type == (PTR\|SHORT) \|\| p->n_type == (PTR\|USHORT)) {
	1206	if (p->n_right->n_op != ICON)
	1207	return;
	1208	if (p->n_left->n_op != PCONV)
	1209	return;
	1210	if (p->n_left->n_left->n_op != OREG)
	1211	return;
	1212	q = p->n_left->n_left;
	1213	nfree(p->n_left);
	1214	p->n_left = q;
	1215	/*
	1216	* This will be converted to another OREG later.
	1217	*/
	1218	}
	1219	}
	1220	}
	1221
	1222	void
	1223	mycanon(NODE *p)
	1224	{
	1225	walkf(p, pconv2, 0);
	1226	}
	1227
	1228	/*
	1229	* Remove last goto.
	1230	*/
	1231	void
	1232	myoptim(struct interpass *ip)
	1233	{
	1234	}
	1235
	1236	/*
	1237	* Return a class suitable for a specific type.
	1238	*/
	1239	int
	1240	gclass(TWORD t)
	1241	{
	1242	return (szty(t) == 2 ? CLASSB : CLASSA);
	1243	}
	1244
	1245	static int
	1246	argsiz(NODE *p)
	1247	{
	1248	TWORD t = p->n_type;
	1249
	1250	if (t == STRTY \|\| t == UNIONTY)
	1251	return p->n_stsize/(SZINT/SZCHAR);
	1252	return szty(t);
	1253	}
	1254
	1255	/*
	1256	* Calculate argument sizes.
	1257	*/
	1258	void
	1259	lastcall(NODE *p)
	1260	{
	1261	NODE *op = p;
	1262	int size = 0;
	1263
	1264	p->n_qual = 0;
	1265	if (p->n_op != CALL && p->n_op != FORTCALL && p->n_op != STCALL)
	1266	return;
	1267	for (p = p->n_right; p->n_op == CM; p = p->n_left)
	1268	if (p->n_right->n_op != ASSIGN)
	1269	size += argsiz(p->n_right);
	1270	if (p->n_op != ASSIGN)
	1271	size += argsiz(p);
	1272	op->n_qual = size; /* XXX */
	1273	}
	1274
	1275	void
	1276	rmove(int s, int d, TWORD t)
	1277	{
	1278	printf(" %smove %s,%s\n",
	1279	(s > 017 ? "d" : ""), rnames[d], rnames[s]);
	1280	}
	1281
	1282	/*
	1283	* For class c, find worst-case displacement of the number of
	1284	* registers in the array r[] indexed by class.
	1285	*/
	1286	int
	1287	COLORMAP(int c, int *r)
	1288	{
	1289	int num;
	1290
	1291	switch (c) {
	1292	case CLASSA:
	1293	/* there are 13 classa, so min 6 classb are needed to block */
	1294	num = r[CLASSB] * 2;
	1295	num += r[CLASSA];
	1296	return num < 13;
	1297	case CLASSB:
	1298	/* 7 classa may block all classb */
	1299	num = r[CLASSB] + r[CLASSA];
	1300	return num < 7;
	1301	}
	1302	comperr("COLORMAP");
	1303	return 0; /* XXX gcc */
	1304	}
	1305
	1306	/*
	1307	* Target-dependent command-line options.
	1308	*/
	1309	void
	1310	mflags(char *str)
	1311	{
	1312	}
	1313	/*
	1314	* Do something target-dependent for xasm arguments.
	1315	* Supposed to find target-specific constraints and rewrite them.
	1316	*/
	1317	int
	1318	myxasm(struct interpass ip, NODE p)
	1319	{
	1320	return 0;
	1321	}

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

Download in other formats: