自学教程：C++ tempnode函数代码示例

voidbfcode(struct symtab **sp, int n){	struct symtab *sp2;	NODE *p, *q;	int i;	if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {		/* Move return address into temporary */		p = tempnode(0, INT, 0, 0);		strtemp = regno(p);		q = block(REG, 0, 0, INT, 0, 0);		regno(q) = R1;		ecomp(buildtree(ASSIGN, p, q));	}	if (xtemps == 0)		return;	/* put arguments in temporaries */	for (i = 0; i < n; i++) {		if (sp[i]->stype == STRTY || sp[i]->stype == UNIONTY ||		    cisreg(sp[i]->stype) == 0)			continue;		if (cqual(sp[i]->stype, sp[i]->squal) & VOL)			continue;		sp2 = sp[i];		p = tempnode(0, sp[i]->stype, sp[i]->sdf, sp[i]->sap);		p = buildtree(ASSIGN, p, nametree(sp2));		sp[i]->soffset = regno(p->n_left);		sp[i]->sflags |= STNODE;		ecomp(p);	}}

/* * Evaluate AND/OR/ER.  p1 and p2 are pointers to ti struct. */static NODE *gcc_andorer(int op, NODE *p1, NODE *p2){	char *n = tistack();	NODE *p, *t1, *t2, *p3;	t1 = tempnode(0, p1->n_type, p1->n_df, p1->n_ap);	t2 = tempnode(0, p2->n_type, p2->n_df, p2->n_ap);	p1 = buildtree(ASSIGN, ccopy(t1), p1);	p2 = buildtree(ASSIGN, ccopy(t2), p2);	p = buildtree(COMOP, p1, p2);	p3 = buildtree(ADDROF, eve(bdty(NAME, n)), NIL);	p1 = buildtree(ASSIGN, structref(ccopy(p3), STREF, hiti),	    buildtree(op, structref(ccopy(t1), STREF, hiti),	    structref(ccopy(t2), STREF, hiti)));	p = buildtree(COMOP, p, p1);	p1 = buildtree(ASSIGN, structref(ccopy(p3), STREF, loti),	    buildtree(op, structref(t1, STREF, loti),	    structref(t2, STREF, loti)));	p = buildtree(COMOP, p, p1);	p = buildtree(COMOP, p, buildtree(UMUL, p3, NIL));	return p;}

/* setup a float param on the stack * used by bfcode() */static voidparam_float(struct symtab *sym, int *argofsp, int dotemps){	NODE *p, *q, *t;	int tmpnr;	/*	 * we have to dump the float from the general register	 * into a temp, since the register allocator doesn't like	 * floats to be in CLASSA.  This may not work for -xtemps.	 */	t = tempnode(0, INT, 0, 0);	tmpnr = regno(t);	q = block(REG, NIL, NIL, INT, 0, 0);	q->n_rval = R0 + (*argofsp)++;	p = buildtree(ASSIGN, t, q);	ecomp(p);	if (dotemps) {		sym->soffset = tmpnr;		sym->sflags |= STNODE;	} else {		q = tempnode(tmpnr, sym->stype, sym->sdf, sym->sap);		p = nametree(sym);		p = buildtree(ASSIGN, p, q);		ecomp(p);	}}

voidefcode(void){	TWORD t;	NODE *p, *q;	/* code for the end of a function */	if (cftnsp->stype != STRTY+FTN && cftnsp->stype != UNIONTY+FTN)		return;	t = PTR+BTYPE(cftnsp->stype);	/* Create struct assignment */	q = tempnode(strtemp, t, 0, cftnsp->sap);	q = buildtree(UMUL, q, NIL);	p = block(REG, NIL, NIL, t, 0, cftnsp->sap);	regno(p) = R0;	p = buildtree(UMUL, p, NIL);	p = buildtree(ASSIGN, q, p);	ecomp(p);	/* put hidden arg in r0 on return */	q = tempnode(strtemp, INT, 0, 0);	p = block(REG, NIL, NIL, INT, 0, 0);	regno(p) = R0;        ecomp(buildtree(ASSIGN, p, q));}

static NODE *builtin_va_arg(const struct bitable *bt, NODE *a){    NODE *p, *q, *r, *rv;    int sz, nodnum;    /* create a copy to a temp node of current ap */    p = ccopy(a->n_left);    q = tempnode(0, p->n_type, p->n_df, p->n_ap);    nodnum = regno(q);    rv = buildtree(ASSIGN, q, p);    r = a->n_right;    sz = (int)tsize(r->n_type, r->n_df, r->n_ap)/SZCHAR;    /* add one to ap */#ifdef BACKAUTO    rv = buildtree(COMOP, rv , buildtree(PLUSEQ, a->n_left, bcon(sz)));#else#error fix wrong eval order in builtin_va_arg    ecomp(buildtree(MINUSEQ, a->n_left, bcon(sz)));#endif    nfree(a->n_right);    nfree(a);    r = tempnode(nodnum, INCREF(r->n_type), r->n_df, r->n_ap);    return buildtree(COMOP, rv, buildtree(UMUL, r, NIL));}

voidbfcode(struct symtab **sp, int cnt){	int i, off;	NODE *p, *q;	struct symtab *sym;	/* Process the first six arguments. */	for (i=0; i < cnt && i < 6; i++) {		sym = sp[i];		q = block(REG, NIL, NIL, sym->stype, sym->sdf, sym->sap);		q->n_rval = RETREG_PRE(sym->stype) + i;		p = tempnode(0, sym->stype, sym->sdf, sym->sap);		sym->soffset = regno(p);		sym->sflags |= STNODE;		p = buildtree(ASSIGN, p, q);		ecomp(p);	}	/* Process the remaining arguments. */	for (off = V9RESERVE; i < cnt; i++) {		sym = sp[i];		p = tempnode(0, sym->stype, sym->sdf, sym->sap);		off = ALIGN(off, (tlen(p) - 1));		sym->soffset = off * SZCHAR;		off += tlen(p);		p = buildtree(ASSIGN, p, nametree(sym));		sym->soffset = regno(p->n_left);		sym->sflags |= STNODE;		ecomp(p);	}}

/* * code for the end of a function * deals with struct return here */voidefcode(void){	NODE *p, *q;	int tempnr;	int ty;	if (cftnsp->stype != STRTY+FTN && cftnsp->stype != UNIONTY+FTN)		return;	ty = cftnsp->stype - FTN;	q = block(REG, NIL, NIL, INCREF(ty), 0, cftnsp->sap);	q->n_rval = V0;	p = tempnode(0, INCREF(ty), 0, cftnsp->sap);	tempnr = regno(p);	p = buildtree(ASSIGN, p, q);	ecomp(p);	q = tempnode(tempnr, INCREF(ty), 0, cftnsp->sap);	q = buildtree(UMUL, q, NIL);	p = tempnode(rvnr, INCREF(ty), 0, cftnsp->sap);	p = buildtree(UMUL, p, NIL);	p = buildtree(ASSIGN, p, q);	ecomp(p);	q = tempnode(rvnr, INCREF(ty), 0, cftnsp->sap);	p = block(REG, NIL, NIL, INCREF(ty), 0, cftnsp->sap);	p->n_rval = V0;	p = buildtree(ASSIGN, p, q);	ecomp(p);}

static NODE *moveargs(NODE *p, int *regp){        NODE *r, **rp;	int lastreg;	int reg;        if (p->n_op == CM) {                p->n_left = moveargs(p->n_left, regp);                r = p->n_right;		rp = &p->n_right;        } else {		r = p;		rp = &p;	} 	lastreg = A0 + nargregs - 1;        reg = *regp;	if (reg > lastreg && r->n_op != STARG)		*rp = block(FUNARG, r, NIL, r->n_type, r->n_df, r->n_ap);	else if (r->n_op == STARG) {		*rp = movearg_struct(r, p, regp);	} else if (DEUNSIGN(r->n_type) == LONGLONG) {		*rp = movearg_64bit(r, regp);	} else if (r->n_type == DOUBLE || r->n_type == LDOUBLE) {		/* XXX bounce in and out of temporary to change to longlong */		NODE *t1 = tempnode(0, LONGLONG, 0, 0);		int tmpnr = regno(t1);		NODE *t2 = tempnode(tmpnr, r->n_type, r->n_df, r->n_ap);		t1 =  movearg_64bit(t1, regp);		r = block(ASSIGN, t2, r, r->n_type, r->n_df, r->n_ap);		if (p->n_op == CM) {			p->n_left = buildtree(CM, p->n_left, t1);			p->n_right = r;		} else {			p = buildtree(CM, t1, r);		}	} else if (r->n_type == FLOAT) {		/* XXX bounce in and out of temporary to change to int */		NODE *t1 = tempnode(0, INT, 0, 0);		int tmpnr = regno(t1);		NODE *t2 = tempnode(tmpnr, r->n_type, r->n_df, r->n_ap);		t1 =  movearg_32bit(t1, regp);		r = block(ASSIGN, t2, r, r->n_type, r->n_df, r->n_ap);		if (p->n_op == CM) {			p->n_left = buildtree(CM, p->n_left, t1);			p->n_right = r;		} else {			p = buildtree(CM, t1, r);		}	} else {		*rp = movearg_32bit(r, regp);	}	return p;}

/* * code for the end of a function * deals with struct return here * The return value is in (or pointed to by) RETREG. */voidefcode(void){	struct symtab *sp;	extern int gotnr;	TWORD t;	NODE *p, *r, *l;	int typ, ssz, rno;	gotnr = 0;	/* new number for next fun */	sp = cftnsp;	t = DECREF(sp->stype);	if (t != STRTY && t != UNIONTY)		return;	/* XXX should have one routine for this */	ngpr = nsse = 0;	if ((typ = argtyp(t, sp->sdf, sp->sap)) == STRREG || typ == STRCPX) {		/* Cast to long pointer and move to the registers */		/* XXX can overrun struct size */		/* XXX check carefully for SSE members */		if ((ssz = tsize(t, sp->sdf, sp->sap)) > SZLONG*2)			cerror("efcode1");		if (typ == STRCPX) {			t = DOUBLE;			rno = XMM0;		} else {			t = LONG;			rno = RAX;		}		if (ssz > SZLONG) {			p = block(REG, NIL, NIL, INCREF(t), 0, 0);			regno(p) = RAX;			p = buildtree(UMUL, buildtree(PLUS, p, bcon(1)), NIL);			ecomp(movtoreg(p, rno+1));		}		p = block(REG, NIL, NIL, INCREF(t), 0, 0);		regno(p) = RAX;		p = buildtree(UMUL, p, NIL);		ecomp(movtoreg(p, rno));	} else if (typ == STRMEM) {		r = block(REG, NIL, NIL, INCREF(t), sp->sdf, sp->sap);		regno(r) = RAX;		r = buildtree(UMUL, r, NIL);		l = tempnode(stroffset, INCREF(t), sp->sdf, sp->sap);		l = buildtree(UMUL, l, NIL);		ecomp(buildtree(ASSIGN, l, r));		l = block(REG, NIL, NIL, LONG, 0, 0);		regno(l) = RAX;		r = tempnode(stroffset, LONG, 0, 0);		ecomp(buildtree(ASSIGN, l, r));	} else		cerror("efcode");}

NODE *mips_builtin_va_arg(NODE *f, NODE *a, TWORD t){	NODE *p, *q, *r;	int sz, tmpnr;	/* check num args and type */	if (a == NULL || a->n_op != CM || a->n_left->n_op == CM ||	    !ISPTR(a->n_left->n_type) || a->n_right->n_op != TYPE)		goto bad;	r = a->n_right;	/* get type size */	sz = tsize(r->n_type, r->n_df, r->n_ap) / SZCHAR;	if (sz < SZINT/SZCHAR) {		werror("%s%s promoted to int when passed through ...",			r->n_type & 1 ? "unsigned " : "",			DEUNSIGN(r->n_type) == SHORT ? "short" : "char");		sz = SZINT/SZCHAR;	}	/* alignment */	p = tcopy(a->n_left);	if (sz > SZINT/SZCHAR && r->n_type != UNIONTY && r->n_type != STRTY) {		p = buildtree(PLUS, p, bcon(7));		p = block(AND, p, bcon(-8), p->n_type, p->n_df, p->n_ap);	}	/* create a copy to a temp node */	q = tempnode(0, p->n_type, p->n_df, p->n_ap);	tmpnr = regno(q);	p = buildtree(ASSIGN, q, p);	q = tempnode(tmpnr, p->n_type, p->n_df,p->n_ap);	q = buildtree(PLUS, q, bcon(sz));	q = buildtree(ASSIGN, a->n_left, q);	q = buildtree(COMOP, p, q);	nfree(a->n_right);	nfree(a);	nfree(f); 	p = tempnode(tmpnr, INCREF(r->n_type), r->n_df, r->n_ap);	p = buildtree(UMUL, p, NIL);	p = buildtree(COMOP, q, p);	return p;bad:	uerror("bad argument to __builtin_va_arg");	return bcon(0);}

/* * Sort arglist so that register assignments ends up last. */static intargsort(NODE *p){	NODE *q, *r;	int rv = 0;	if (p->n_op != CM) {		if (p->n_op == ASSIGN && p->n_left->n_op == REG &&		    coptype(p->n_right->n_op) != LTYPE) {			q = tempnode(0, p->n_type, p->n_df, p->n_ap);			r = ccopy(q);			p->n_right = buildtree(COMOP,			    buildtree(ASSIGN, q, p->n_right), r);		}		return rv;	}	if (p->n_right->n_op == CM) {		/* fixup for small structs in regs */		q = p->n_right->n_left;		p->n_right->n_left = p->n_left;		p->n_left = p->n_right;		p->n_right = p->n_left->n_right;		p->n_left->n_right = q;	}	if (p->n_right->n_op == ASSIGN && p->n_right->n_left->n_op == REG &&	    coptype(p->n_right->n_right->n_op) != LTYPE) {		/* move before everything to avoid reg trashing */		q = tempnode(0, p->n_right->n_type,		    p->n_right->n_df, p->n_right->n_ap);		r = ccopy(q);		p->n_right->n_right = buildtree(COMOP,		    buildtree(ASSIGN, q, p->n_right->n_right), r);	}	if (p->n_right->n_op == ASSIGN && p->n_right->n_left->n_op == REG) {		if (p->n_left->n_op == CM &&		    p->n_left->n_right->n_op == STASG) {			q = p->n_left->n_right;			p->n_left->n_right = p->n_right;			p->n_right = q;			rv = 1;		} else if (p->n_left->n_op == STASG) {			q = p->n_left;			p->n_left = p->n_right;			p->n_right = q;			rv = 1;		}	}	return rv | argsort(p->n_left);}

/* * replace an alloca function with direct allocation on stack. * return a destination temp node. */static NODE *builtin_alloca(const struct bitable *bt, NODE *a){    NODE *t, *u;#ifdef notyet    if (xnobuiltins)        return NULL;#endif    t = tempnode(0, VOID|PTR, 0, 0);    u = tempnode(regno(t), VOID|PTR, 0, 0);    spalloc(t, a, SZCHAR);    return u;}

/* * The "initial exec" tls model. */static NODE *tlsinitialexec(NODE *p){	NODE *q, *r, *s;	char *s1, *s2;	/*	 * movq %fs:0,%rax	 * addq [email
C++ temporarily_use_uid函数代码示例
C++ tempfree函数代码示例