Context Navigation

source: mainline/uspace/app/pcc/arch/mips/local2.c@ 48fa501

Visit:

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

Last change on this file since 48fa501 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: 30.7 KB

Rev	Line
[a7de7182]	1	/* $Id: local2.c,v 1.25 2008/12/03 22:23:38 gmcgarry 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	* MIPS port by Jan Enoksson (janeno-1@student.ltu.se) and
	31	* Simon Olsson (simols-1@student.ltu.se) 2005.
	32	*/
	33
	34	#include <ctype.h>
	35	#include <string.h>
	36	#include <stdlib.h>
	37	#include <assert.h>
	38
	39	#include "pass1.h"
	40	#include "pass2.h"
	41
	42	#ifdef TARGET_BIG_ENDIAN
	43	int bigendian = 1;
	44	#else
	45	int bigendian = 0;
	46	#endif
	47
	48	int nargregs = MIPS_O32_NARGREGS;
	49
	50	static int argsiz(NODE *p);
	51
	52	void
	53	deflab(int label)
	54	{
	55	printf(LABFMT ":\n", label);
	56	}
	57
	58	static int regoff[32];
	59	static TWORD ftype;
	60
	61	/*
	62	* calculate stack size and offsets
	63	*/
	64	static int
	65	offcalc(struct interpass_prolog * ipp)
	66	{
	67	int i, j, addto;
	68
	69	addto = p2maxautooff;
	70
	71	for (i = ipp->ipp_regs[0], j = 0; i; i >>= 1, j++) {
	72	if (i & 1) {
	73	addto += SZINT / SZCHAR;
	74	regoff[j] = addto;
	75	}
	76	}
	77
	78	/* round to 8-byte boundary */
	79	addto += 7;
	80	addto &= ~7;
	81
	82	return addto;
	83	}
	84
	85	/*
	86	* Print out the prolog assembler.
	87	*/
	88	void
	89	prologue(struct interpass_prolog * ipp)
	90	{
	91	int addto;
	92	int i, j;
	93
	94	ftype = ipp->ipp_type;
	95	printf("\t.align 2\n");
	96	if (ipp->ipp_vis)
	97	printf("\t.globl %s\n", ipp->ipp_name);
	98	printf("\t.ent %s\n", ipp->ipp_name);
	99	printf("%s:\n", ipp->ipp_name);
	100
	101	addto = offcalc(ipp);
	102
	103	/* for the moment, just emit this PIC stuff - NetBSD does it */
	104	printf("\t.frame %s,%d,%s\n", rnames[FP], ARGINIT/SZCHAR, rnames[RA]);
	105	printf("\t.set noreorder\n");
	106	printf("\t.cpload $25\t# pseudo-op to load GOT ptr into $25\n");
	107	printf("\t.set reorder\n");
	108
	109	printf("\tsubu %s,%s,%d\n", rnames[SP], rnames[SP], ARGINIT/SZCHAR);
	110	/* for the moment, just emit PIC stuff - NetBSD does it */
	111	printf("\t.cprestore 8\t# pseudo-op to store GOT ptr at 8(sp)\n");
	112
	113	printf("\tsw %s,4(%s)\n", rnames[RA], rnames[SP]);
	114	printf("\tsw %s,(%s)\n", rnames[FP], rnames[SP]);
	115	printf("\tmove %s,%s\n", rnames[FP], rnames[SP]);
	116
	117	#ifdef notyet
	118	/* profiling */
	119	if (pflag) {
	120	printf("\t.set noat\n");
	121	printf("\tmove %s,%s\t# save current return address\n",
	122	rnames[AT], rnames[RA]);
	123	printf("\tsubu %s,%s,8\t# _mcount pops 2 words from stack\n",
	124	rnames[SP], rnames[SP]);
	125	printf("\tjal %s\n", exname("_mcount"));
	126	printf("\tnop\n");
	127	printf("\t.set at\n");
	128	}
	129	#endif
	130
	131	if (addto)
	132	printf("\tsubu %s,%s,%d\n", rnames[SP], rnames[SP], addto);
	133
	134	for (i = ipp->ipp_regs[0], j = 0; i; i >>= 1, j++)
	135	if (i & 1)
	136	fprintf(stdout, "\tsw %s,-%d(%s) # save permanent\n",
	137	rnames[j], regoff[j], rnames[FP]);
	138
	139	}
	140
	141	void
	142	eoftn(struct interpass_prolog * ipp)
	143	{
	144	int i, j;
	145	int addto;
	146
	147	addto = offcalc(ipp);
	148
	149	if (ipp->ipp_ip.ip_lbl == 0)
	150	return; /* no code needs to be generated */
	151
	152	/* return from function code */
	153	for (i = ipp->ipp_regs[0], j = 0; i; i >>= 1, j++) {
	154	if (i & 1)
	155	fprintf(stdout, "\tlw %s,-%d(%s)\n\tnop\n",
	156	rnames[j], regoff[j], rnames[FP]);
	157	}
	158
	159	printf("\taddiu %s,%s,%d\n", rnames[SP], rnames[FP], ARGINIT/SZCHAR);
	160	printf("\tlw %s,%d(%s)\n", rnames[RA], 4-ARGINIT/SZCHAR, rnames[SP]);
	161	printf("\tlw %s,%d(%s)\n", rnames[FP], 0-ARGINIT/SZCHAR, rnames[SP]);
	162
	163	printf("\tjr %s\n", rnames[RA]);
	164	printf("\tnop\n");
	165
	166	#ifdef USE_GAS
	167	printf("\t.end %s\n", ipp->ipp_name);
	168	printf("\t.size %s,.-%s\n", ipp->ipp_name, ipp->ipp_name);
	169	#endif
	170	}
	171
	172	/*
	173	* add/sub/...
	174	*
	175	* Param given:
	176	*/
	177	void
	178	hopcode(int f, int o)
	179	{
	180	char *str;
	181
	182	switch (o) {
	183	case EQ:
	184	str = "beqz"; /* pseudo-op */
	185	break;
	186	case NE:
	187	str = "bnez"; /* pseudo-op */
	188	break;
	189	case ULE:
	190	case LE:
	191	str = "blez";
	192	break;
	193	case ULT:
	194	case LT:
	195	str = "bltz";
	196	break;
	197	case UGE:
	198	case GE:
	199	str = "bgez";
	200	break;
	201	case UGT:
	202	case GT:
	203	str = "bgtz";
	204	break;
	205	case PLUS:
	206	str = "add";
	207	break;
	208	case MINUS:
	209	str = "sub";
	210	break;
	211	case AND:
	212	str = "and";
	213	break;
	214	case OR:
	215	str = "or";
	216	break;
	217	case ER:
	218	str = "xor";
	219	break;
	220	default:
	221	comperr("hopcode2: %d", o);
	222	str = 0; /* XXX gcc */
	223	}
	224
	225	printf("%s%c", str, f);
	226	}
	227
	228	char *
	229	rnames[] = {
	230	#ifdef USE_GAS
	231	/* gnu assembler */
	232	"$zero", "$at", "$2", "$3", "$4", "$5", "$6", "$7",
	233	"$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
	234	"$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
	235	"$24", "$25",
	236	"$kt0", "$kt1", "$gp", "$sp", "$fp", "$ra",
	237	"$2!!$3!!",
	238	"$4!!$5!!", "$5!!$6!!", "$6!!$7!!", "$7!!$8!!",
	239	"$8!!$9!!", "$9!!$10!", "$10!$11!", "$11!$12!",
	240	"$12!$13!", "$13!$14!", "$14!$15!", "$15!$24!", "$24!$25!",
	241	"$16!$17!", "$17!$18!", "$18!$19!", "$19!$20!",
	242	"$20!$21!", "$21!$22!", "$22!$23!",
	243	#else
	244	/* mips assembler */
	245	"$zero", "$at", "$v0", "$v1", "$a0", "$a1", "$a2", "$a3",
	246	"$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7",
	247	"$s0", "$s1", "$s2", "$s3", "$s4", "$s5", "$s6", "$s7",
	248	"$t8", "$t9",
	249	"$k0", "$k1", "$gp", "$sp", "$fp", "$ra",
	250	"$v0!$v1!",
	251	"$a0!$a1!", "$a1!$a2!", "$a2!$a3!", "$a3!$t0!",
	252	"$t0!$t1!", "$t1!$t2!", "$t2!$t3!", "$t3!$t4!",
	253	"$t4!$t5!", "$t5!$t6!", "$t6!$t7!", "$t7!$t8!", "$t8!$t9!",
	254	"$s0!$s1!", "$s1!$s2!", "$s2!$s3!", "$s3!$s4!",
	255	"$s4!$s5!", "$s5!$s6!", "$s6!$s7!",
	256	#endif
	257	"$f0!$f1!", "$f2!$f3!", "$f4!$f5!", "$f6!$f7!",
	258	"$f8!$f9!", "$f10$f11", "$f12$f13", "$f14$f15",
	259	"$f16$f17", "$f18$f19", "$f20$f21", "$f22$f23",
	260	"$f24$f25", "$f26$f27", "$f28$f29", "$f30$f31",
	261	};
	262
	263	char *
	264	rnames_n32[] = {
	265	/* mips assembler */
	266	"$zero", "$at", "$v0", "$v1", "$a0", "$a1", "$a2", "$a3",
	267	"$a4", "$a5", "$a6", "$a7", "$t0", "$t1", "$t2", "$t3",
	268	"$s0", "$s1", "$s2", "$s3", "$s4", "$s5", "$s6", "$s7",
	269	"$t8", "$t9",
	270	"$k0", "$k1", "$gp", "$sp", "$fp", "$ra",
	271	"$v0!$v1!",
	272	"$a0!$a1!", "$a1!$a2!", "$a2!$a3!", "$a3!$a4!",
	273	"$a4!$a5!", "$a5!$a6!", "$a6!$a7!", "$a7!$t0!",
	274	"$t0!$t1!", "$t1!$t2!", "$t2!$t3!", "$t3!$t8!", "$t8!$t9!",
	275	"$s0!$s1!", "$s1!$s2!", "$s2!$s3!", "$s3!$s4!",
	276	"$s4!$s5!", "$s5!$s6!", "$s6!$s7!",
	277	"$f0!$f1!", "$f2!$f3!", "$f4!$f5!", "$f6!$f7!",
	278	"$f8!$f9!", "$f10$f11", "$f12$f13", "$f14$f15",
	279	"$f16$f17", "$f18$f19", "$f20$f21", "$f22$f23",
	280	"$f24$f25", "$f26$f27", "$f28$f29", "$f30$f31",
	281	};
	282
	283	int
	284	tlen(NODE *p)
	285	{
	286	switch (p->n_type) {
	287	case CHAR:
	288	case UCHAR:
	289	return (1);
	290
	291	case SHORT:
	292	case USHORT:
	293	return (SZSHORT / SZCHAR);
	294
	295	case DOUBLE:
	296	return (SZDOUBLE / SZCHAR);
	297
	298	case INT:
	299	case UNSIGNED:
	300	case LONG:
	301	case ULONG:
	302	return (SZINT / SZCHAR);
	303
	304	case LONGLONG:
	305	case ULONGLONG:
	306	return SZLONGLONG / SZCHAR;
	307
	308	default:
	309	if (!ISPTR(p->n_type))
	310	comperr("tlen type %d not pointer");
	311	return SZPOINT(p->n_type) / SZCHAR;
	312	}
	313	}
	314
	315
	316	/*
	317	* Push a structure on stack as argument.
	318	*/
	319	static void
	320	starg(NODE *p)
	321	{
	322	//assert(p->n_rval == A1);
	323	printf("\tsubu %s,%s,%d\n", rnames[SP], rnames[SP], p->n_stsize);
	324	/* A0 = dest, A1 = src, A2 = len */
	325	printf("\tmove %s,%s\n", rnames[A0], rnames[SP]);
	326	printf("\tli %s,%d\t# structure size\n", rnames[A2], p->n_stsize);
	327	printf("\tsubu %s,%s,16\n", rnames[SP], rnames[SP]);
	328	printf("\tjal %s\t# structure copy\n", exname("memcpy"));
	329	printf("\tnop\n");
	330	printf("\taddiu %s,%s,16\n", rnames[SP], rnames[SP]);
	331	}
	332
	333	/*
	334	* Structure assignment.
	335	*/
	336	static void
	337	stasg(NODE *p)
	338	{
	339	assert(p->n_right->n_rval == A1);
	340	/* A0 = dest, A1 = src, A2 = len */
	341	printf("\tli %s,%d\t# structure size\n", rnames[A2], p->n_stsize);
	342	if (p->n_left->n_op == OREG) {
	343	printf("\taddiu %s,%s," CONFMT "\t# dest address\n",
	344	rnames[A0], rnames[p->n_left->n_rval],
	345	p->n_left->n_lval);
	346	} else if (p->n_left->n_op == NAME) {
	347	printf("\tla %s,", rnames[A0]);
	348	adrput(stdout, p->n_left);
	349	printf("\n");
	350	}
	351	printf("\tsubu %s,%s,16\n", rnames[SP], rnames[SP]);
	352	printf("\tjal %s\t# structure copy\n", exname("memcpy"));
	353	printf("\tnop\n");
	354	printf("\taddiu %s,%s,16\n", rnames[SP], rnames[SP]);
	355	}
	356
	357	static void
	358	shiftop(NODE *p)
	359	{
	360	NODE *r = p->n_right;
	361	TWORD ty = p->n_type;
	362
	363	if (p->n_op == LS && r->n_op == ICON && r->n_lval < 32) {
	364	expand(p, INBREG, "\tsrl A1,AL,");
	365	printf(CONFMT "\t# 64-bit left-shift\n", 32 - r->n_lval);
	366	expand(p, INBREG, "\tsll U1,UL,AR\n");
	367	expand(p, INBREG, "\tor U1,U1,A1\n");
	368	expand(p, INBREG, "\tsll A1,AL,AR\n");
	369	} else if (p->n_op == LS && r->n_op == ICON && r->n_lval < 64) {
	370	expand(p, INBREG, "\tli A1,0\t# 64-bit left-shift\n");
	371	expand(p, INBREG, "\tsll U1,AL,");
	372	printf(CONFMT "\n", r->n_lval - 32);
	373	} else if (p->n_op == LS && r->n_op == ICON) {
	374	expand(p, INBREG, "\tli A1,0\t# 64-bit left-shift\n");
	375	expand(p, INBREG, "\tli U1,0\n");
	376	} else if (p->n_op == RS && r->n_op == ICON && r->n_lval < 32) {
	377	expand(p, INBREG, "\tsll U1,UL,");
	378	printf(CONFMT "\t# 64-bit right-shift\n", 32 - r->n_lval);
	379	expand(p, INBREG, "\tsrl A1,AL,AR\n");
	380	expand(p, INBREG, "\tor A1,A1,U1\n");
	381	if (ty == LONGLONG)
	382	expand(p, INBREG, "\tsra U1,UL,AR\n");
	383	else
	384	expand(p, INBREG, "\tsrl U1,UL,AR\n");
	385	} else if (p->n_op == RS && r->n_op == ICON && r->n_lval < 64) {
	386	if (ty == LONGLONG) {
	387	expand(p, INBREG, "\tsra U1,UL,31\t# 64-bit right-shift\n");
	388	expand(p, INBREG, "\tsra A1,UL,");
	389	}else {
	390	expand(p, INBREG, "\tli U1,0\t# 64-bit right-shift\n");
	391	expand(p, INBREG, "\tsrl A1,UL,");
	392	}
	393	printf(CONFMT "\n", r->n_lval - 32);
	394	} else if (p->n_op == LS && r->n_op == ICON) {
	395	expand(p, INBREG, "\tli A1,0\t# 64-bit right-shift\n");
	396	expand(p, INBREG, "\tli U1,0\n");
	397	} else {
	398	comperr("shiftop");
	399	}
	400	}
	401
	402	/*
	403	* http://gcc.gnu.org/onlinedocs/gccint/Soft-float-library-routines.html#Soft-float-library-routines
	404	*/
	405	static void
	406	fpemulop(NODE *p)
	407	{
	408	NODE *l = p->n_left;
	409	char *ch = NULL;
	410
	411	if (p->n_op == PLUS && p->n_type == FLOAT) ch = "addsf3";
	412	else if (p->n_op == PLUS && p->n_type == DOUBLE) ch = "adddf3";
	413	else if (p->n_op == PLUS && p->n_type == LDOUBLE) ch = "addtf3";
	414
	415	else if (p->n_op == MINUS && p->n_type == FLOAT) ch = "subsf3";
	416	else if (p->n_op == MINUS && p->n_type == DOUBLE) ch = "subdf3";
	417	else if (p->n_op == MINUS && p->n_type == LDOUBLE) ch = "subtf3";
	418
	419	else if (p->n_op == MUL && p->n_type == FLOAT) ch = "mulsf3";
	420	else if (p->n_op == MUL && p->n_type == DOUBLE) ch = "muldf3";
	421	else if (p->n_op == MUL && p->n_type == LDOUBLE) ch = "multf3";
	422
	423	else if (p->n_op == DIV && p->n_type == FLOAT) ch = "divsf3";
	424	else if (p->n_op == DIV && p->n_type == DOUBLE) ch = "divdf3";
	425	else if (p->n_op == DIV && p->n_type == LDOUBLE) ch = "divtf3";
	426
	427	else if (p->n_op == UMINUS && p->n_type == FLOAT) ch = "negsf2";
	428	else if (p->n_op == UMINUS && p->n_type == DOUBLE) ch = "negdf2";
	429	else if (p->n_op == UMINUS && p->n_type == LDOUBLE) ch = "negtf2";
	430
	431	else if (p->n_op == EQ && l->n_type == FLOAT) ch = "eqsf2";
	432	else if (p->n_op == EQ && l->n_type == DOUBLE) ch = "eqdf2";
	433	else if (p->n_op == EQ && l->n_type == LDOUBLE) ch = "eqtf2";
	434
	435	else if (p->n_op == NE && l->n_type == FLOAT) ch = "nesf2";
	436	else if (p->n_op == NE && l->n_type == DOUBLE) ch = "nedf2";
	437	else if (p->n_op == NE && l->n_type == LDOUBLE) ch = "netf2";
	438
	439	else if (p->n_op == GE && l->n_type == FLOAT) ch = "gesf2";
	440	else if (p->n_op == GE && l->n_type == DOUBLE) ch = "gedf2";
	441	else if (p->n_op == GE && l->n_type == LDOUBLE) ch = "getf2";
	442
	443	else if (p->n_op == LE && l->n_type == FLOAT) ch = "lesf2";
	444	else if (p->n_op == LE && l->n_type == DOUBLE) ch = "ledf2";
	445	else if (p->n_op == LE && l->n_type == LDOUBLE) ch = "letf2";
	446
	447	else if (p->n_op == GT && l->n_type == FLOAT) ch = "gtsf2";
	448	else if (p->n_op == GT && l->n_type == DOUBLE) ch = "gtdf2";
	449	else if (p->n_op == GT && l->n_type == LDOUBLE) ch = "gttf2";
	450
	451	else if (p->n_op == LT && l->n_type == FLOAT) ch = "ltsf2";
	452	else if (p->n_op == LT && l->n_type == DOUBLE) ch = "ltdf2";
	453	else if (p->n_op == LT && l->n_type == LDOUBLE) ch = "lttf2";
	454
	455	else if (p->n_op == SCONV && p->n_type == FLOAT) {
	456	if (l->n_type == DOUBLE) ch = "truncdfsf2";
	457	else if (l->n_type == LDOUBLE) ch = "trunctfsf2";
	458	else if (l->n_type == ULONGLONG) ch = "floatdisf"; /**/
	459	else if (l->n_type == LONGLONG) ch = "floatdisf";
	460	else if (l->n_type == LONG) ch = "floatsisf";
	461	else if (l->n_type == ULONG) ch = "floatunsisf";
	462	else if (l->n_type == INT) ch = "floatsisf";
	463	else if (l->n_type == UNSIGNED) ch = "floatunsisf";
	464	} else if (p->n_op == SCONV && p->n_type == DOUBLE) {
	465	if (l->n_type == FLOAT) ch = "extendsfdf2";
	466	else if (l->n_type == LDOUBLE) ch = "trunctfdf2";
	467	else if (l->n_type == ULONGLONG) ch = "floatunsdidf";
	468	else if (l->n_type == LONGLONG) ch = "floatdidf";
	469	else if (l->n_type == LONG) ch = "floatsidf";
	470	else if (l->n_type == ULONG) ch = "floatunsidf";
	471	else if (l->n_type == INT) ch = "floatsidf";
	472	else if (l->n_type == UNSIGNED) ch = "floatunsidf";
	473	} else if (p->n_op == SCONV && p->n_type == LDOUBLE) {
	474	if (l->n_type == FLOAT) ch = "extendsftf2";
	475	else if (l->n_type == DOUBLE) ch = "extenddfdf2";
	476	else if (l->n_type == ULONGLONG) ch = "floatunsdidf";
	477	else if (l->n_type == LONGLONG) ch = "floatdidf";
	478	else if (l->n_type == LONG) ch = "floatsidf";
	479	else if (l->n_type == ULONG) ch = "floatunssidf";
	480	else if (l->n_type == INT) ch = "floatsidf";
	481	else if (l->n_type == UNSIGNED) ch = "floatunsidf";
	482	} else if (p->n_op == SCONV && p->n_type == ULONGLONG) {
	483	if (l->n_type == FLOAT) ch = "fixunssfdi";
	484	else if (l->n_type == DOUBLE) ch = "fixunsdfdi";
	485	else if (l->n_type == LDOUBLE) ch = "fixunsdfdi";
	486	} else if (p->n_op == SCONV && p->n_type == LONGLONG) {
	487	if (l->n_type == FLOAT) ch = "fixsfdi";
	488	else if (l->n_type == DOUBLE) ch = "fixdfdi";
	489	else if (l->n_type == LDOUBLE) ch = "fixdfdi";
	490	} else if (p->n_op == SCONV && p->n_type == LONG) {
	491	if (l->n_type == FLOAT) ch = "fixsfsi";
	492	else if (l->n_type == DOUBLE) ch = "fixdfsi";
	493	else if (l->n_type == LDOUBLE) ch = "fixdfsi";
	494	} else if (p->n_op == SCONV && p->n_type == ULONG) {
	495	if (l->n_type == FLOAT) ch = "fixunssfsi";
	496	else if (l->n_type == DOUBLE) ch = "fixunsdfsi";
	497	else if (l->n_type == LDOUBLE) ch = "fixunsdfsi";
	498	} else if (p->n_op == SCONV && p->n_type == INT) {
	499	if (l->n_type == FLOAT) ch = "fixsfsi";
	500	else if (l->n_type == DOUBLE) ch = "fixdfsi";
	501	else if (l->n_type == LDOUBLE) ch = "fixdfsi";
	502	} else if (p->n_op == SCONV && p->n_type == UNSIGNED) {
	503	if (l->n_type == FLOAT) ch = "fixunssfsi";
	504	else if (l->n_type == DOUBLE) ch = "fixunsdfsi";
	505	else if (l->n_type == LDOUBLE) ch = "fixunsdfsi";
	506	}
	507
	508	if (ch == NULL) comperr("ZF: op=0x%x (%d)\n", p->n_op, p->n_op);
	509
	510	if (p->n_op == SCONV) {
	511	if (l->n_type == FLOAT) {
	512	printf("\tmfc1 %s,", rnames[A0]);
	513	adrput(stdout, l);
	514	printf("\n\tnop\n");
	515	} else if (l->n_type == DOUBLE \|\| l->n_type == LDOUBLE) {
	516	printf("\tmfc1 %s,", rnames[A1]);
	517	upput(l, 0);
	518	printf("\n\tnop\n");
	519	printf("\tmfc1 %s,", rnames[A0]);
	520	adrput(stdout, l);
	521	printf("\n\tnop\n");
	522	}
	523	} else {
	524	comperr("ZF: incomplete softfloat - put args in registers");
	525	}
	526
	527	printf("\tjal __%s\t# softfloat operation\n", exname(ch));
	528	printf("\tnop\n");
	529
	530	if (p->n_op >= EQ && p->n_op <= GT)
	531	printf("\tcmp %s,0\n", rnames[V0]);
	532	}
	533
	534	/*
	535	* http://gcc.gnu.org/onlinedocs/gccint/Integer-library-routines.html#Integer-library-routines
	536	*/
	537	static void
	538	emulop(NODE *p)
	539	{
	540	char *ch = NULL;
	541
	542	if (p->n_op == LS && DEUNSIGN(p->n_type) == LONGLONG) ch = "ashldi3";
	543	else if (p->n_op == LS && (DEUNSIGN(p->n_type) == LONG \|\|
	544	DEUNSIGN(p->n_type) == INT))
	545	ch = "ashlsi3";
	546
	547	else if (p->n_op == RS && p->n_type == ULONGLONG) ch = "lshrdi3";
	548	else if (p->n_op == RS && (p->n_type == ULONG \|\| p->n_type == INT))
	549	ch = "lshrsi3";
	550
	551	else if (p->n_op == RS && p->n_type == LONGLONG) ch = "ashrdi3";
	552	else if (p->n_op == RS && (p->n_type == LONG \|\| p->n_type == INT))
	553	ch = "ashrsi3";
	554
	555	else if (p->n_op == DIV && p->n_type == LONGLONG) ch = "divdi3";
	556	else if (p->n_op == DIV && (p->n_type == LONG \|\| p->n_type == INT))
	557	ch = "divsi3";
	558
	559	else if (p->n_op == DIV && p->n_type == ULONGLONG) ch = "udivdi3";
	560	else if (p->n_op == DIV && (p->n_type == ULONG \|\|
	561	p->n_type == UNSIGNED))
	562	ch = "udivsi3";
	563
	564	else if (p->n_op == MOD && p->n_type == LONGLONG) ch = "moddi3";
	565	else if (p->n_op == MOD && (p->n_type == LONG \|\| p->n_type == INT))
	566	ch = "modsi3";
	567
	568	else if (p->n_op == MOD && p->n_type == ULONGLONG) ch = "umoddi3";
	569	else if (p->n_op == MOD && (p->n_type == ULONG \|\|
	570	p->n_type == UNSIGNED))
	571	ch = "umodsi3";
	572
	573	else if (p->n_op == MUL && p->n_type == LONGLONG) ch = "muldi3";
	574	else if (p->n_op == MUL && (p->n_type == LONG \|\| p->n_type == INT))
	575	ch = "mulsi3";
	576
	577	else if (p->n_op == UMINUS && p->n_type == LONGLONG) ch = "negdi2";
	578	else if (p->n_op == UMINUS && p->n_type == LONG) ch = "negsi2";
	579
	580	else ch = 0, comperr("ZE");
	581	printf("\tsubu %s,%s,16\n", rnames[SP], rnames[SP]);
	582	printf("\tjal __%s\t# emulated operation\n", exname(ch));
	583	printf("\tnop\n");
	584	printf("\taddiu %s,%s,16\n", rnames[SP], rnames[SP]);
	585	}
	586
	587	/*
	588	* Emit code to compare two longlong numbers.
	589	*/
	590	static void
	591	twollcomp(NODE *p)
	592	{
	593	int o = p->n_op;
	594	int s = getlab2();
	595	int e = p->n_label;
	596	int cb1, cb2;
	597
	598	if (o >= ULE)
	599	o -= (ULE-LE);
	600	switch (o) {
	601	case NE:
	602	cb1 = 0;
	603	cb2 = NE;
	604	break;
	605	case EQ:
	606	cb1 = NE;
	607	cb2 = 0;
	608	break;
	609	case LE:
	610	case LT:
	611	cb1 = GT;
	612	cb2 = LT;
	613	break;
	614	case GE:
	615	case GT:
	616	cb1 = LT;
	617	cb2 = GT;
	618	break;
	619
	620	default:
	621	cb1 = cb2 = 0; /* XXX gcc */
	622	}
	623	if (p->n_op >= ULE)
	624	cb1 += 4, cb2 += 4;
	625	expand(p, 0, "\tsub A1,UL,UR\t# compare 64-bit values (upper)\n");
	626	if (cb1) {
	627	printf("\t");
	628	hopcode(' ', cb1);
	629	expand(p, 0, "A1");
	630	printf("," LABFMT "\n", s);
	631	printf("\tnop\n");
	632	}
	633	if (cb2) {
	634	printf("\t");
	635	hopcode(' ', cb2);
	636	expand(p, 0, "A1");
	637	printf("," LABFMT "\n", e);
	638	printf("\tnop\n");
	639	}
	640	expand(p, 0, "\tsub A1,AL,AR\t# (and lower)\n");
	641	printf("\t");
	642	hopcode(' ', o);
	643	expand(p, 0, "A1");
	644	printf("," LABFMT "\n", e);
	645	printf("\tnop\n");
	646	deflab(s);
	647	}
	648
	649	static void
	650	fpcmpops(NODE *p)
	651	{
	652	NODE *l = p->n_left;
	653
	654	switch (p->n_op) {
	655	case EQ:
	656	if (l->n_type == FLOAT)
	657	expand(p, 0, "\tc.eq.s AL,AR\n");
	658	else
	659	expand(p, 0, "\tc.eq.d AL,AR\n");
	660	expand(p, 0, "\tnop\n\tbc1t LC\n");
	661	break;
	662	case NE:
	663	if (l->n_type == FLOAT)
	664	expand(p, 0, "\tc.eq.s AL,AR\n");
	665	else
	666	expand(p, 0, "\tc.eq.d AL,AR\n");
	667	expand(p, 0, "\tnop\n\tbc1f LC\n");
	668	break;
	669	case LT:
	670	if (l->n_type == FLOAT)
	671	expand(p, 0, "\tc.lt.s AL,AR\n");
	672	else
	673	expand(p, 0, "\tc.lt.d AL,AR\n");
	674	expand(p, 0, "\tnop\n\tbc1t LC\n");
	675	break;
	676	case GE:
	677	if (l->n_type == FLOAT)
	678	expand(p, 0, "\tc.lt.s AL,AR\n");
	679	else
	680	expand(p, 0, "\tc.lt.d AL,AR\n");
	681	expand(p, 0, "\tnop\n\tbc1f LC\n");
	682	break;
	683	case LE:
	684	if (l->n_type == FLOAT)
	685	expand(p, 0, "\tc.le.s AL,AR\n");
	686	else
	687	expand(p, 0, "\tc.le.d AL,AR\n");
	688	expand(p, 0, "\tnop\n\tbc1t LC\n");
	689	break;
	690	case GT:
	691	if (l->n_type == FLOAT)
	692	expand(p, 0, "\tc.le.s AL,AR\n");
	693	else
	694	expand(p, 0, "\tc.le.d AL,AR\n");
	695	expand(p, 0, "\tnop\n\tbc1f LC\n");
	696	break;
	697	}
	698	printf("\tnop\n\tnop\n");
	699	}
	700
	701	void
	702	zzzcode(NODE * p, int c)
	703	{
	704	int sz;
	705
	706	switch (c) {
	707
	708	case 'C': /* remove arguments from stack after subroutine call */
	709	sz = p->n_qual > 16 ? p->n_qual : 16;
	710	printf("\taddiu %s,%s,%d\n", rnames[SP], rnames[SP], sz);
	711	break;
	712
	713	case 'D': /* long long comparison */
	714	twollcomp(p);
	715	break;
	716
	717	case 'E': /* emit emulated ops */
	718	emulop(p);
	719	break;
	720
	721	case 'F': /* emit emulate floating point ops */
	722	fpemulop(p);
	723	break;
	724
	725	case 'G': /* emit hardware floating-point compare op */
	726	fpcmpops(p);
	727	break;
	728
	729	case 'H': /* structure argument */
	730	starg(p);
	731	break;
	732
	733	case 'I': /* high part of init constant */
	734	if (p->n_name[0] != '\0')
	735	comperr("named highword");
	736	fprintf(stdout, CONFMT, (p->n_lval >> 32) & 0xffffffff);
	737	break;
	738
	739	case 'O': /* 64-bit left and right shift operators */
	740	shiftop(p);
	741	break;
	742
	743	case 'Q': /* emit struct assign */
	744	stasg(p);
	745	break;
	746
	747	default:
	748	comperr("zzzcode %c", c);
	749	}
	750	}
	751
	752	/* ARGSUSED */
	753	int
	754	rewfld(NODE * p)
	755	{
	756	return (1);
	757	}
	758
	759	int
	760	fldexpand(NODE p, int cookie, char *cp)
	761	{
	762	CONSZ val;
	763
	764	if (p->n_op == ASSIGN)
	765	p = p->n_left;
	766	switch (**cp) {
	767	case 'S':
	768	printf("%d", UPKFSZ(p->n_rval));
	769	break;
	770	case 'H':
	771	printf("%d", UPKFOFF(p->n_rval));
	772	break;
	773	case 'M':
	774	case 'N':
	775	val = (CONSZ)1 << UPKFSZ(p->n_rval);
	776	--val;
	777	val <<= UPKFOFF(p->n_rval);
	778	printf("0x%llx", (**cp == 'M' ? val : ~val) & 0xffffffff);
	779	break;
	780	default:
	781	comperr("fldexpand");
	782	}
	783	return 1;
	784	}
	785
	786	/*
	787	* Does the bitfield shape match?
	788	*/
	789	int
	790	flshape(NODE * p)
	791	{
	792	int o = p->n_op;
	793
	794	if (o == OREG \|\| o == REG \|\| o == NAME)
	795	return SRDIR; /* Direct match */
	796	if (o == UMUL && shumul(p->n_left, SOREG))
	797	return SROREG; /* Convert into oreg */
	798	return SRREG; /* put it into a register */
	799	}
	800
	801	/* INTEMP shapes must not contain any temporary registers */
	802	/* XXX should this go away now? */
	803	int
	804	shtemp(NODE * p)
	805	{
	806	return 0;
	807	#if 0
	808	int r;
	809
	810	if (p->n_op == STARG)
	811	p = p->n_left;
	812
	813	switch (p->n_op) {
	814	case REG:
	815	return (!istreg(p->n_rval));
	816
	817	case OREG:
	818	r = p->n_rval;
	819	if (R2TEST(r)) {
	820	if (istreg(R2UPK1(r)))
	821	return (0);
	822	r = R2UPK2(r);
	823	}
	824	return (!istreg(r));
	825
	826	case UMUL:
	827	p = p->n_left;
	828	return (p->n_op != UMUL && shtemp(p));
	829	}
	830
	831	if (optype(p->n_op) != LTYPE)
	832	return (0);
	833	return (1);
	834	#endif
	835	}
	836
	837	void
	838	adrcon(CONSZ val)
	839	{
	840	printf(CONFMT, val);
	841	}
	842
	843	void
	844	conput(FILE fp, NODE p)
	845	{
	846	int val = p->n_lval;
	847
	848	switch (p->n_op) {
	849	case ICON:
	850	if (p->n_name[0] != '\0') {
	851	fprintf(fp, "%s", p->n_name);
	852	if (p->n_lval)
	853	fprintf(fp, "+%d", val);
	854	} else
	855	fprintf(fp, "%d", val);
	856	return;
	857
	858	default:
	859	comperr("illegal conput");
	860	}
	861	}
	862
	863	/* ARGSUSED */
	864	void
	865	insput(NODE * p)
	866	{
	867	comperr("insput");
	868	}
	869
	870	/*
	871	* Print lower or upper name of 64-bit register.
	872	*/
	873	static void
	874	print_reg64name(FILE *fp, int rval, int hi)
	875	{
	876	int off = 4 * (hi != 0);
	877	char *regname = rnames[rval];
	878
	879	fprintf(fp, "%c%c",
	880	regname[off],
	881	regname[off + 1]);
	882	if (regname[off + 2] != '!')
	883	fputc(regname[off + 2], fp);
	884	if (regname[off + 3] != '!')
	885	fputc(regname[off + 3], fp);
	886	}
	887
	888	/*
	889	* Write out the upper address, like the upper register of a 2-register
	890	* reference, or the next memory location.
	891	*/
	892	void
	893	upput(NODE * p, int size)
	894	{
	895
	896	size /= SZCHAR;
	897	switch (p->n_op) {
	898	case REG:
	899	if (GCLASS(p->n_rval) == CLASSB \|\| GCLASS(p->n_rval) == CLASSC)
	900	print_reg64name(stdout, p->n_rval, 1);
	901	else
	902	fputs(rnames[p->n_rval], stdout);
	903	break;
	904
	905	case NAME:
	906	case OREG:
	907	p->n_lval += size;
	908	adrput(stdout, p);
	909	p->n_lval -= size;
	910	break;
	911	case ICON:
	912	fprintf(stdout, CONFMT, p->n_lval >> 32);
	913	break;
	914	default:
	915	comperr("upput bad op %d size %d", p->n_op, size);
	916	}
	917	}
	918
	919	void
	920	adrput(FILE * io, NODE * p)
	921	{
	922	int r;
	923	/* output an address, with offsets, from p */
	924
	925	if (p->n_op == FLD)
	926	p = p->n_left;
	927
	928	switch (p->n_op) {
	929
	930	case NAME:
	931	if (p->n_name[0] != '\0')
	932	fputs(p->n_name, io);
	933	if (p->n_lval != 0)
	934	fprintf(io, "+" CONFMT, p->n_lval);
	935	return;
	936
	937	case OREG:
	938	r = p->n_rval;
	939
	940	if (p->n_lval)
	941	fprintf(io, "%d", (int) p->n_lval);
	942
	943	fprintf(io, "(%s)", rnames[p->n_rval]);
	944	return;
	945	case ICON:
	946	/* addressable value of the constant */
	947	conput(io, p);
	948	return;
	949
	950	case REG:
	951	if (GCLASS(p->n_rval) == CLASSB \|\| GCLASS(p->n_rval) == CLASSC)
	952	print_reg64name(io, p->n_rval, 0);
	953	else
	954	fputs(rnames[p->n_rval], io);
	955	return;
	956
	957	default:
	958	comperr("illegal address, op %d, node %p", p->n_op, p);
	959	return;
	960
	961	}
	962	}
	963
	964	/* printf conditional and unconditional branches */
	965	void
	966	cbgen(int o, int lab)
	967	{
	968	}
	969
	970	void
	971	myreader(struct interpass * ipole)
	972	{
	973	}
	974
	975	#if 0
	976	/*
	977	* Calculate the stack size for arguments
	978	*/
	979	static int stacksize;
	980
	981	static void
	982	calcstacksize(NODE p, void arg)
	983	{
	984	int sz;
	985
	986	printf("op=%d\n", p->n_op);
	987
	988	if (p->n_op != CALL && p->n_op != STCALL)
	989	return;
	990
	991	sz = argsiz(p->n_right);
	992	if (sz > stacksize)
	993	stacksize = sz;
	994
	995	#ifdef PCC_DEBUG
	996	if (x2debug)
	997	printf("stacksize: %d\n", stacksize);
	998	#endif
	999	}
	1000	#endif
	1001
	1002	/*
	1003	* If we're big endian, then all OREG loads of a type
	1004	* larger than the destination, must have the
	1005	* offset changed to point to the correct bytes in memory.
	1006	*/
	1007	static void
	1008	offchg(NODE p, void arg)
	1009	{
	1010	NODE *l;
	1011
	1012	if (p->n_op != SCONV)
	1013	return;
	1014
	1015	l = p->n_left;
	1016
	1017	if (l->n_op != OREG)
	1018	return;
	1019
	1020	switch (l->n_type) {
	1021	case SHORT:
	1022	case USHORT:
	1023	if (DEUNSIGN(p->n_type) == CHAR)
	1024	l->n_lval += 1;
	1025	break;
	1026	case LONG:
	1027	case ULONG:
	1028	case INT:
	1029	case UNSIGNED:
	1030	if (DEUNSIGN(p->n_type) == CHAR)
	1031	l->n_lval += 3;
	1032	else if (DEUNSIGN(p->n_type) == SHORT)
	1033	l->n_lval += 2;
	1034	break;
	1035	case LONGLONG:
	1036	case ULONGLONG:
	1037	if (DEUNSIGN(p->n_type) == CHAR)
	1038	l->n_lval += 7;
	1039	else if (DEUNSIGN(p->n_type) == SHORT)
	1040	l->n_lval += 6;
	1041	else if (DEUNSIGN(p->n_type) == INT \|\|
	1042	DEUNSIGN(p->n_type) == LONG)
	1043	l->n_lval += 4;
	1044	break;
	1045	default:
	1046	comperr("offchg: unknown type");
	1047	break;
	1048	}
	1049	}
	1050
	1051	/*
	1052	* Remove some PCONVs after OREGs are created.
	1053	*/
	1054	static void
	1055	pconv2(NODE * p, void *arg)
	1056	{
	1057	NODE *q;
	1058
	1059	if (p->n_op == PLUS) {
	1060	if (p->n_type == (PTR \| SHORT) \|\| p->n_type == (PTR \| USHORT)) {
	1061	if (p->n_right->n_op != ICON)
	1062	return;
	1063	if (p->n_left->n_op != PCONV)
	1064	return;
	1065	if (p->n_left->n_left->n_op != OREG)
	1066	return;
	1067	q = p->n_left->n_left;
	1068	nfree(p->n_left);
	1069	p->n_left = q;
	1070	/*
	1071	* This will be converted to another OREG later.
	1072	*/
	1073	}
	1074	}
	1075	}
	1076
	1077	void
	1078	mycanon(NODE * p)
	1079	{
	1080	walkf(p, pconv2, 0);
	1081	}
	1082
	1083	void
	1084	myoptim(struct interpass * ipole)
	1085	{
	1086	struct interpass *ip;
	1087
	1088	#ifdef PCC_DEBUG
	1089	if (x2debug)
	1090	printf("myoptim:\n");
	1091	#endif
	1092
	1093	#if 0
	1094	stacksize = 0;
	1095	#endif
	1096
	1097	DLIST_FOREACH(ip, ipole, qelem) {
	1098	if (ip->type != IP_NODE)
	1099	continue;
	1100	if (bigendian)
	1101	walkf(ip->ip_node, offchg, 0);
	1102	#if 0
	1103	walkf(ip->ip_node, calcstacksize, 0);
	1104	#endif
	1105	}
	1106	}
	1107
	1108	/*
	1109	* Move data between registers. While basic registers aren't a problem,
	1110	* we have to handle the special case of overlapping composite registers.
	1111	*/
	1112	void
	1113	rmove(int s, int d, TWORD t)
	1114	{
	1115	switch (t) {
	1116	case LONGLONG:
	1117	case ULONGLONG:
	1118	if (s == d+1) {
	1119	/* dh = sl, copy low word first */
	1120	printf("\tmove ");
	1121	print_reg64name(stdout, d, 0);
	1122	printf(",");
	1123	print_reg64name(stdout, s, 0);
	1124	printf("\t# 64-bit rmove\n");
	1125	printf("\tmove ");
	1126	print_reg64name(stdout, d, 1);
	1127	printf(",");
	1128	print_reg64name(stdout, s, 1);
	1129	printf("\n");
	1130	} else {
	1131	/* copy high word first */
	1132	printf("\tmove ");
	1133	print_reg64name(stdout, d, 1);
	1134	printf(",");
	1135	print_reg64name(stdout, s, 1);
	1136	printf(" # 64-bit rmove\n");
	1137	printf("\tmove ");
	1138	print_reg64name(stdout, d, 0);
	1139	printf(",");
	1140	print_reg64name(stdout, s, 0);
	1141	printf("\n");
	1142	}
	1143	break;
	1144	case FLOAT:
	1145	case DOUBLE:
	1146	case LDOUBLE:
	1147	if (t == FLOAT)
	1148	printf("\tmov.s ");
	1149	else
	1150	printf("\tmov.d ");
	1151	print_reg64name(stdout, d, 0);
	1152	printf(",");
	1153	print_reg64name(stdout, s, 0);
	1154	printf("\t# float/double rmove\n");
	1155	break;
	1156	default:
	1157	printf("\tmove %s,%s\t# default rmove\n", rnames[d], rnames[s]);
	1158	}
	1159	}
	1160
	1161
	1162	/*
	1163	* For class c, find worst-case displacement of the number of
	1164	* registers in the array r[] indexed by class.
	1165	*
	1166	* On MIPS, we have:
	1167	*
	1168	* 32 32-bit registers (8 reserved)
	1169	* 26 64-bit pseudo registers (1 unavailable)
	1170	* 16 floating-point register pairs
	1171	*/
	1172	int
	1173	COLORMAP(int c, int *r)
	1174	{
	1175	int num = 0;
	1176
	1177	switch (c) {
	1178	case CLASSA:
	1179	num += r[CLASSA];
	1180	num += 2*r[CLASSB];
	1181	return num < 24;
	1182	case CLASSB:
	1183	num += 2*r[CLASSB];
	1184	num += r[CLASSA];
	1185	return num < 25;
	1186	case CLASSC:
	1187	num += r[CLASSC];
	1188	return num < 6;
	1189	}
	1190	comperr("COLORMAP");
	1191	return 0; /* XXX gcc */
	1192	}
	1193
	1194	/*
	1195	* Return a class suitable for a specific type.
	1196	*/
	1197	int
	1198	gclass(TWORD t)
	1199	{
	1200	if (t == LONGLONG \|\| t == ULONGLONG)
	1201	return CLASSB;
	1202	if (t >= FLOAT && t <= LDOUBLE)
	1203	return CLASSC;
	1204	return CLASSA;
	1205	}
	1206
	1207	/*
	1208	* Calculate argument sizes.
	1209	*/
	1210	void
	1211	lastcall(NODE *p)
	1212	{
	1213	int sz;
	1214
	1215	#ifdef PCC_DEBUG
	1216	if (x2debug)
	1217	printf("lastcall:\n");
	1218	#endif
	1219
	1220	p->n_qual = 0;
	1221	if (p->n_op != CALL && p->n_op != FORTCALL && p->n_op != STCALL)
	1222	return;
	1223
	1224	sz = argsiz(p->n_right);
	1225
	1226	if ((sz > 4*nargregs) && (sz & 7) != 0) {
	1227	printf("\tsubu %s,%s,4\t# align stack\n",
	1228	rnames[SP], rnames[SP]);
	1229	sz += 4;
	1230	assert((sz & 7) == 0);
	1231	}
	1232
	1233	p->n_qual = sz; /* XXX */
	1234	}
	1235
	1236	static int
	1237	argsiz(NODE *p)
	1238	{
	1239	TWORD t;
	1240	int size = 0;
	1241	int sz = 0;
	1242
	1243	if (p->n_op == CM) {
	1244	size = argsiz(p->n_left);
	1245	p = p->n_right;
	1246	}
	1247
	1248	t = p->n_type;
	1249	if (t < LONGLONG \|\| t > BTMASK)
	1250	sz = 4;
	1251	else if (DEUNSIGN(t) == LONGLONG)
	1252	sz = 8;
	1253	else if (t == DOUBLE \|\| t == LDOUBLE)
	1254	sz = 8;
	1255	else if (t == FLOAT)
	1256	sz = 4;
	1257	else if (t == STRTY \|\| t == UNIONTY)
	1258	sz = p->n_stsize;
	1259
	1260	if (p->n_type == STRTY \|\| p->n_type == UNIONTY) {
	1261	return (size + sz);
	1262	}
	1263
	1264	/* alignment */
	1265	if (sz == 8 && (size & 7) != 0)
	1266	sz += 4;
	1267
	1268	// printf("size=%d, sz=%d -> %d\n", size, sz, size + sz);
	1269	return (size + sz);
	1270	}
	1271
	1272	/*
	1273	* Special shapes.
	1274	*/
	1275	int
	1276	special(NODE *p, int shape)
	1277	{
	1278	int o = p->n_op;
	1279	switch(shape) {
	1280	case SPCON:
	1281	if (o == ICON && p->n_name[0] == 0 &&
	1282	(p->n_lval & ~0xffff) == 0)
	1283	return SRDIR;
	1284	break;
	1285	}
	1286
	1287	return SRNOPE;
	1288	}
	1289
	1290	/*
	1291	* Target-dependent command-line options.
	1292	*/
	1293	void
	1294	mflags(char *str)
	1295	{
	1296	if (strcasecmp(str, "big-endian") == 0) {
	1297	bigendian = 1;
	1298	} else if (strcasecmp(str, "little-endian") == 0) {
	1299	bigendian = 0;
	1300	} else {
	1301	fprintf(stderr, "unknown m option '%s'\n", str);
	1302	exit(1);
	1303	}
	1304
	1305	#if 0
	1306	else if (strcasecmp(str, "ips2")) {
	1307	} else if (strcasecmp(str, "ips2")) {
	1308	} else if (strcasecmp(str, "ips3")) {
	1309	} else if (strcasecmp(str, "ips4")) {
	1310	} else if (strcasecmp(str, "hard-float")) {
	1311	} else if (strcasecmp(str, "soft-float")) {
	1312	} else if (strcasecmp(str, "abi=32")) {
	1313	nargregs = MIPS_O32_NARGREGS;
	1314	} else if (strcasecmp(str, "abi=n32")) {
	1315	nargregs = MIPS_N32_NARGREGS;
	1316	} else if (strcasecmp(str, "abi=64")) {
	1317	nargregs = MIPS_N32_NARGREGS;
	1318	}
	1319	#endif
	1320	}
	1321	/*
	1322	* Do something target-dependent for xasm arguments.
	1323	* Supposed to find target-specific constraints and rewrite them.
	1324	*/
	1325	int
	1326	myxasm(struct interpass ip, NODE p)
	1327	{
	1328	return 0;
	1329	}

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

Download in other formats: