/*-----------------------------------------------------------------*/
static S4O_RET
termScanAtFunc (const lineNode *pl, int rIdx)
{
sym_link *ftype;
bool banked_reg = (rIdx == R0_IDX) || (rIdx == R1_IDX) || (rIdx == R2_IDX);
if (!isFunc (pl))
return S4O_CONTINUE;
// let's assume calls to literally given locations use the default
// most notably : (*(void (*)()) 0) (); see bug 1749275
if (IS_VALOP (IC_LEFT (pl->ic)))
return (options.model == MODEL_HUGE) && banked_reg ? S4O_ABORT : options.all_callee_saves ? S4O_CONTINUE : S4O_TERM;
ftype = OP_SYM_TYPE(IC_LEFT(pl->ic));
if (IS_FUNCPTR (ftype))
ftype = ftype->next;
if (IFFUNC_ISBANKEDCALL(ftype) && banked_reg)
return S4O_ABORT;
if (FUNC_ARGS (ftype) && getSize (FUNC_ARGS (ftype)->type) > 4)
return S4O_ABORT;
if (FUNC_CALLEESAVES(ftype))
return S4O_CONTINUE;
if (FUNC_ISNAKED(ftype))
return S4O_CONTINUE;
return S4O_TERM;
}
static bool
_hasNativeMulFor (iCode * ic, sym_link * left, sym_link * right)
{
sym_link *test = NULL;
int result_size = IS_SYMOP(IC_RESULT(ic)) ? getSize(OP_SYM_TYPE(IC_RESULT(ic))) : 4;
if (ic->op != '*')
{
return FALSE;
}
if (IS_LITERAL (left))
test = left;
else if (IS_LITERAL (right))
test = right;
/* 8x8 unsigned multiplication code is shorter than
call overhead for the multiplication routine. */
else if (IS_CHAR (right) && IS_UNSIGNED (right) && IS_CHAR (left) && IS_UNSIGNED (left) && !IS_GB)
{
return TRUE;
}
/* Same for any multiplication with 8 bit result. */
else if (result_size == 1 && !IS_GB)
{
return TRUE;
}
else
{
return FALSE;
}
if (getSize (test) <= 2)
{
return TRUE;
}
return FALSE;
}
/*-----------------------------------------------------------------*/
static S4O_RET
scan4op (lineNode **pl, const char *pReg, const char *untilOp,
lineNode **plCond)
{
char *p;
int len;
bool isConditionalJump;
int rIdx;
S4O_RET ret;
bool findPushPop;
findPushPop = untilOp && (strcmp (untilOp, "push") == 0 || strcmp (untilOp, "pop") == 0);
/* pReg points to e.g. "ar0"..."ar7" */
len = strlen (pReg);
/* get index into pReg table */
for (rIdx = 0; rIdx < mcs51_nRegs; ++rIdx)
if (strcmp (regs8051[rIdx].name, pReg + 1) == 0)
break;
/* sanity check */
if (rIdx >= mcs51_nRegs)
{
DEADMOVEERROR();
return S4O_ABORT;
}
for (; *pl; *pl = (*pl)->next)
{
if (!(*pl)->line || (*pl)->isDebug || (*pl)->isComment)
continue;
/* don't optimize across inline assembler,
e.g. isLabel doesn't work there */
if ((*pl)->isInline)
return S4O_ABORT;
if ((*pl)->visited)
return S4O_VISITED;
(*pl)->visited = TRUE;
/* found untilOp? */
if (untilOp && strncmp ((*pl)->line, untilOp, strlen (untilOp)) == 0)
{
p = (*pl)->line + strlen (untilOp);
if (*p == '\t' && strncmp (p + 1, pReg, len) == 0)
return S4O_FOUNDOPCODE;
else
{
/* found untilOp but without our pReg */
return S4O_ABORT;
}
}
/* found pReg? */
p = strchr ((*pl)->line, '\t');
if (p)
{
/* skip '\t' */
p++;
/* when looking for push or pop and we find a direct access of sp: abort */
if (findPushPop && strstr (p, "sp"))
return S4O_ABORT;
/* course search */
if (strstr (p, pReg + 1))
{
/* ok, let's have a closer look */
/* does opcode read from pReg? */
if (bitVectBitValue (port->peep.getRegsRead ((*pl)), rIdx))
return S4O_RD_OP;
/* does opcode write to pReg? */
if (bitVectBitValue (port->peep.getRegsWritten ((*pl)), rIdx))
return S4O_WR_OP;
/* we can get here, if the register name is
part of a variable name: ignore it */
}
}
/* found label? */
if ((*pl)->isLabel)
{
const char *start;
char label[SDCC_NAME_MAX + 1];
int len;
if (!isLabelDefinition ((*pl)->line, &start, &len, FALSE))
return S4O_ABORT;
memcpy (label, start, len);
label[len] = '\0';
/* register passing this label */
if (!setLabelRefPassedLabel (label))
{
DEADMOVEERROR();
return S4O_ABORT;
}
continue;
}
/* branch or terminate? */
isConditionalJump = FALSE;
switch ((*pl)->line[0])
{
case 'a':
if (strncmp ("acall", (*pl)->line, 5) == 0)
{
/* for comments see 'lcall' */
ret = termScanAtFunc (*pl, rIdx);
if (ret != S4O_CONTINUE)
return ret;
break;
}
if (strncmp ("ajmp", (*pl)->line, 4) == 0)
{
*pl = findLabel (*pl);
if (!*pl)
return S4O_ABORT;
}
break;
case 'c':
if (strncmp ("cjne", (*pl)->line, 4) == 0)
{
isConditionalJump = TRUE;
break;
}
break;
case 'd':
if (strncmp ("djnz", (*pl)->line, 4) == 0)
{
isConditionalJump = TRUE;
break;
}
break;
case 'j':
if (strncmp ("jmp", (*pl)->line, 3) == 0)
/* "jmp @a+dptr": no chance to trace execution */
return S4O_ABORT;
if (strncmp ("jc", (*pl)->line, 2) == 0 ||
strncmp ("jnc", (*pl)->line, 3) == 0 ||
strncmp ("jz", (*pl)->line, 2) == 0 ||
strncmp ("jnz", (*pl)->line, 3) == 0)
{
isConditionalJump = TRUE;
break;
}
if (strncmp ("jbc", (*pl)->line, 3) == 0 ||
strncmp ("jb", (*pl)->line, 2) == 0 ||
strncmp ("jnb", (*pl)->line, 3) == 0)
{
isConditionalJump = TRUE;
break;
}
break;
case 'l':
if (strncmp ("lcall", (*pl)->line, 5) == 0)
{
const char *p = (*pl)->line+5;
while (*p == ' ' || *p == '\t')
p++;
while (isdigit (*p))
p++;
if (isdigit(p[-1]) && *p == '$') /* at least one digit */
{
/* this is a temp label for a pcall */
*pl = findLabel (*pl);
if (!*pl)
return S4O_ABORT;
break;
}
ret = termScanAtFunc (*pl, rIdx);
/* If it's a 'normal' 'caller save' function call, all
registers have been saved until the 'lcall'. The
'life range' of all registers end at the lcall,
and we can terminate our search.
* If the function is 'banked', the registers r0, r1 and r2
are used to tell the trampoline the destination. After
that their 'life range' ends just like the other registers.
* If it's a 'callee save' function call, registers are saved
by the callee. We've got no information, if the register
might live beyond the lcall. Therefore we've to continue
the search.
*/
if (ret != S4O_CONTINUE)
return ret;
break;
}
if (strncmp ("ljmp", (*pl)->line, 4) == 0)
{
*pl = findLabel (*pl);
if (!*pl)
return S4O_ABORT;
}
break;
case 'p':
if (strncmp ("pop", (*pl)->line, 3) == 0 ||
strncmp ("push", (*pl)->line, 4) == 0)
return S4O_PUSHPOP;
break;
case 'r':
if (strncmp ("reti", (*pl)->line, 4) == 0)
return S4O_TERM;
if (strncmp ("ret", (*pl)->line, 3) == 0)
{
/* pcall uses 'ret' */
if (isFunc (*pl))
{
/* for comments see 'lcall' */
ret = termScanAtFunc (*pl, rIdx);
if (ret != S4O_CONTINUE)
return ret;
break;
}
/* it's a normal function return */
if (!((*pl)->ic) || (IS_SYMOP (IC_LEFT ((*pl)->ic)) &&
IS_FUNC (OP_SYM_TYPE(IC_LEFT ((*pl)->ic))) &&
FUNC_CALLEESAVES (OP_SYM_TYPE(IC_LEFT ((*pl)->ic)))))
return S4O_ABORT;
else
return S4O_TERM;
}
break;
case 's':
if (strncmp ("sjmp", (*pl)->line, 4) == 0)
{
*pl = findLabel (*pl);
if (!*pl)
return S4O_ABORT;
}
break;
default:
break;
} /* switch ((*pl)->line[0]) */
if (isConditionalJump)
{
*plCond = findLabel (*pl);
if (!*plCond)
return S4O_ABORT;
return S4O_CONDJMP;
}
} /* for (; *pl; *pl = (*pl)->next) */
return S4O_ABORT;
}
/*
* Actually emit the initial values in .asm format.
*/
static void
emitIvals(struct dbuf_s *oBuf, symbol *sym, initList *list, long lit, int size)
{
int i;
ast *node;
operand *op;
value *val = NULL;
int inCodeSpace = 0;
char *str = NULL;
int in_code;
assert (size <= sizeof(long));
assert (!list || (list->type == INIT_NODE));
node = list ? list->init.node : NULL;
in_code = emitIvalLabel(oBuf, sym);
if (!in_code)
dbuf_printf (oBuf, "\tdb\t");
if (!node) {
// initialize as zero
for (i = 0; i < size; i++) {
if (in_code) {
dbuf_printf (oBuf, "\tretlw 0x%02x\n", lit & 0xff);
} else {
dbuf_printf (oBuf, "%s0x%02x", (i == 0) ? "" : ", ", lit & 0xff);
}
lit >>= 8;
} // for
if (!in_code)
dbuf_printf (oBuf, "\n");
return;
} // if
op = NULL;
if (constExprTree(node) && (val = constExprValue(node, 0))) {
op = operandFromValue(val);
DEBUGprintf ("%s: constExpr ", __FUNCTION__);
} else if (IS_AST_VALUE(node)) {
op = operandFromAst(node, 0);
} else if (IS_AST_OP(node)) {
str = parseIvalAst(node, &inCodeSpace);
DEBUGprintf("%s: AST_OP: %s\n", __FUNCTION__, str);
op = NULL;
} else {
assert ( !"Unhandled construct in intializer." );
}
if (op) {
aopOp(op, NULL, 1);
assert(AOP(op));
//printOperand(op, of);
}
for (i = 0; i < size; i++) {
char *text;
/*
* FIXME: This is hacky and needs some more thought.
*/
if (op && IS_SYMOP(op) && IS_FUNC(OP_SYM_TYPE(op))) {
/* This branch is introduced to fix #1427663. */
PCOI(AOP(op)->aopu.pcop)->offset+=i;
text = get_op(AOP(op)->aopu.pcop, NULL, 0);
PCOI(AOP(op)->aopu.pcop)->offset-=i;
} else {
text = op ? aopGet(AOP(op), i, 0, 0)
: get_op(newpCodeOpImmd(str, i, 0, inCodeSpace, 0), NULL, 0);
} // if
if (in_code) {
dbuf_printf (oBuf, "\tretlw %s\n", text);
} else {
dbuf_printf (oBuf, "%s%s", (i == 0) ? "" : ", ", text);
}
} // for
if (!in_code)
dbuf_printf (oBuf, "\n");
}
