Ejemplo n.º 1
0
/*
 Checks whether the long stack identifier is equivalent to the source or destination operands
 of pIcode and pIcode+1 (ie. these are LOW_LEVEL icodes at present).
 If so, returns the rhs and lhs of this instruction.

 @longId    : long stack identifier
 @pIcode    : ptr to first LOW_LEVEL icode instruction
 @i         : idx into local identifier table for longId
 @idx       : idx into icode array
 @pProc     : ptr to current procedure record
 @rhs, lhs  : return expressions if successful.
*/
bool checkLongRegEq(struct _longId longId, PICODE pIcode, int i, int idx, PPROC pProc,
                    COND_EXPR **rhs, COND_EXPR **lhs, int off)
{
    PMEM pmHdst, pmLdst, pmHsrc, pmLsrc; // pointers to LOW_LEVEL icodes

    pmHdst = &pIcode->ll.dst;
    pmLdst = &(pIcode + off)->ll.dst;
    pmHsrc = &pIcode->ll.src;
    pmLsrc = &(pIcode + off)->ll.src;

    if ((longId.h == pmHdst->regi) && (longId.l == pmLdst->regi)) {
        *lhs = idCondExpLongIdx(i);
        if ((pIcode->ll.flg & NO_SRC) != NO_SRC)
            *rhs = idCondExpLong(&pProc->localId, SRC, pIcode, HIGH_FIRST, idx, USE, off);
        return true;
    } else if ((longId.h == pmHsrc->regi) && (longId.l == pmLsrc->regi)) {
        *lhs = idCondExpLong(&pProc->localId, DST, pIcode, HIGH_FIRST, idx, DEF, off);
        *rhs = idCondExpLongIdx(i);
        return true;
    }

    return false;
}
Ejemplo n.º 2
0
Archivo: PROCS.C Proyecto: 8l/dcc
void newRegArg (PPROC pproc, PICODE picode, PICODE ticode)
/* Updates the argument table by including the register(s) (ie. lhs of
 * picode) and the actual expression (ie. rhs of picode).
 * Note: register(s) are only included once in the table.   */
{ COND_EXPR *lhs;
  PSTKFRAME ps, ts;
  ID *id;
  Int i, tidx;
  boolT regExist;
  condId type;
  PPROC tproc;
  byte regL, regH;		/* Registers involved in arguments */

	/* Flag ticode as having register arguments */
	tproc = ticode->ic.hl.oper.call.proc;
	tproc->flg |= REG_ARGS;

	/* Get registers and index into target procedure's local list */
	ps = ticode->ic.hl.oper.call.args;
	ts = &tproc->args;
	lhs = picode->ic.hl.oper.asgn.lhs;
	type = lhs->expr.ident.idType;
	if (type == REGISTER)
	{
		regL = pproc->localId.id[lhs->expr.ident.idNode.regiIdx].id.regi;
		if (regL < rAL)
			tidx = newByteWordRegId (&tproc->localId, TYPE_WORD_SIGN, regL);
		else
			tidx = newByteWordRegId (&tproc->localId, TYPE_BYTE_SIGN, regL);
	}
	else if (type == LONG_VAR)
	{
		regL = pproc->localId.id[lhs->expr.ident.idNode.longIdx].id.longId.l;
		regH = pproc->localId.id[lhs->expr.ident.idNode.longIdx].id.longId.h;
		tidx = newLongRegId (&tproc->localId, TYPE_LONG_SIGN, regH, regL, 0);
	}

	/* Check if register argument already on the formal argument list */
	regExist = FALSE;
	for (i = 0; i < ts->csym; i++)
	{
		if (type == REGISTER)
		{
			if ((ts->sym[i].regs != NULL) && 
				(ts->sym[i].regs->expr.ident.idNode.regiIdx == tidx))
			{
				regExist = TRUE;
				i = ts->csym;
			}
		}
		else if (type == LONG_VAR)
		{
			if ((ts->sym[i].regs != NULL) && 
				(ts->sym[i].regs->expr.ident.idNode.longIdx == tidx))
			{
				regExist = TRUE;
				i = ts->csym;
			}
		}
	}

	/* Do ts (formal arguments) */
	if (regExist == FALSE)
	{
    	if (ts->csym == ts->alloc) 
    	{
			ts->alloc += 5;
        	ts->sym = allocVar(ts->sym, ts->alloc * sizeof(STKSYM));
    	}
    	sprintf (ts->sym[ts->csym].name, "arg%ld", ts->csym);
		if (type == REGISTER)
		{
			if (regL < rAL)
			{
    			ts->sym[ts->csym].type = TYPE_WORD_SIGN;
    			ts->sym[ts->csym].regs = idCondExpRegIdx (tidx, WORD_REG);
			}
			else
			{
				ts->sym[ts->csym].type = TYPE_BYTE_SIGN;
    			ts->sym[ts->csym].regs = idCondExpRegIdx (tidx, BYTE_REG);
			}
			sprintf (tproc->localId.id[tidx].name, "arg%ld", ts->csym);
		}
		else if (type == LONG_VAR)
		{
    		ts->sym[ts->csym].regs = idCondExpLongIdx (tidx);
    		ts->sym[ts->csym].type = TYPE_LONG_SIGN; 
			sprintf (tproc->localId.id[tidx].name, "arg%ld", ts->csym);
			propLongId (&tproc->localId, regL, regH,
										tproc->localId.id[tidx].name);
		}

		ts->csym++;
		ts->numArgs++;
	}

	/* Do ps (actual arguments) */
    if (ps->csym == ps->alloc) 
    {
        ps->alloc += 5;
        ps->sym = allocVar(ps->sym, ps->alloc * sizeof(STKSYM));
    }
    sprintf (ps->sym[ps->csym].name, "arg%ld", ps->csym);
    ps->sym[ps->csym].actual = picode->ic.hl.oper.asgn.rhs;
    ps->sym[ps->csym].regs = lhs;

	/* Mask off high and low register(s) in picode */
	switch (type) {
	  case REGISTER:	
		id = &pproc->localId.id[lhs->expr.ident.idNode.regiIdx];
		picode->du.def &= maskDuReg[id->id.regi];
		if (id->id.regi < rAL)
    		ps->sym[ps->csym].type = TYPE_WORD_SIGN;
		else
			ps->sym[ps->csym].type = TYPE_BYTE_SIGN;
		break;
	  case LONG_VAR: 
		id = &pproc->localId.id[lhs->expr.ident.idNode.longIdx];
		picode->du.def &= maskDuReg[id->id.longId.h];
		picode->du.def &= maskDuReg[id->id.longId.l];
    	ps->sym[ps->csym].type = TYPE_LONG_SIGN; 
		break;
	}

	ps->csym++;
	ps->numArgs++;
}