-------------------------------------------------------------------------*/
#include "common.h"
-#include "SDCCpeeph.h"
-#include "newalloc.h"
-peepRule *rootRules = NULL;
-peepRule *currRule = NULL;
+static peepRule *rootRules = NULL;
+static peepRule *currRule = NULL;
#define HTAB_SIZE 53
typedef struct
}
labelHashEntry;
-hTab *labelHash = NULL;
+static hTab *labelHash = NULL;
+
+static struct
+{
+ allocTrace values;
+ allocTrace labels;
+} _G;
static int hashSymbolName (const char *name);
static void buildLabelRefCountHash (lineNode * head);
#define FBYNAME(x) int x (hTab *vars, lineNode *currPl, lineNode *head, \
const char *cmdLine)
+#if !OPT_DISABLE_PIC
+void peepRules2pCode(peepRule *);
+#endif
+
/*-----------------------------------------------------------------*/
/* pcDistance - afinds a label back ward or forward */
/*-----------------------------------------------------------------*/
return 0;
}
+/*-----------------------------------------------------------------*/
+/* flat24bitModeAndPortDS390 - */
+/*-----------------------------------------------------------------*/
+FBYNAME (flat24bitModeAndPortDS390)
+{
+ return ((strcmp(port->target,"ds390") == 0) &&
+ (options.model == MODEL_FLAT24));
+}
+
+/*-----------------------------------------------------------------*/
+/* portIsDS390 - return true if port is DS390 */
+/*-----------------------------------------------------------------*/
+FBYNAME (portIsDS390)
+{
+ return (strcmp(port->target,"ds390") == 0);
+}
+
/*-----------------------------------------------------------------*/
/* flat24bitMode - will check to see if we are in flat24 mode */
/*-----------------------------------------------------------------*/
return (options.model == MODEL_FLAT24);
}
+/*-----------------------------------------------------------------*/
+/* xramMovcOption - check if using movc to read xram */
+/*-----------------------------------------------------------------*/
+FBYNAME (xramMovcOption)
+{
+ return (options.xram_movc && (strcmp(port->target,"mcs51") == 0));
+}
+
/*-----------------------------------------------------------------*/
/* labelInRange - will check to see if label %5 is within range */
/*-----------------------------------------------------------------*/
if (!lbl)
return FALSE;
- /* if the previous teo instructions are "ljmp"s then don't
+ /* if the previous two instructions are "ljmp"s then don't
do it since it can be part of a jump table */
if (currPl->prev && currPl->prev->prev &&
strstr (currPl->prev->line, "ljmp") &&
"24bitMode", flat24bitMode
}
,
+ {
+ "xramMovcOption", xramMovcOption
+ }
+ ,
{
"labelRefCount", labelRefCount
}
,
+ {
+ "portIsDS390", portIsDS390
+ },
+ {
+ "24bitModeAndPortDS390", flat24bitModeAndPortDS390
+ }
};
int i;
/* don't indent comments & labels */
if (head->line &&
(*head->line == ';' ||
- head->line[strlen (head->line) - 1] == ':'))
+ head->line[strlen (head->line) - 1] == ':')) {
fprintf (of, "%s\n", head->line);
- else
+ } else {
+ if (head->isInline && *head->line=='#') {
+ // comment out preprocessor directives in inline asm
+ fprintf (of, ";");
+ }
fprintf (of, "\t%s\n", head->line);
+ }
head = head->next;
}
}
{
peepRule *pr;
- pr = Safe_calloc (1, sizeof (peepRule));
+ pr = Safe_alloc ( sizeof (peepRule));
pr->match = match;
pr->replace = replace;
pr->restart = restart;
if (cond && *cond)
{
- pr->cond = Safe_calloc (1, strlen (cond) + 1);
+ pr->cond = Safe_alloc ( strlen (cond) + 1);
strcpy (pr->cond, cond);
}
else
{
lineNode *pl;
- pl = Safe_calloc (1, sizeof (lineNode));
- pl->line = Safe_calloc (1, strlen (line) + 1);
+ pl = Safe_alloc ( sizeof (lineNode));
+ pl->line = Safe_alloc ( strlen (line) + 1);
strcpy (pl->line, line);
return pl;
}
/* first get the value of the variable */
vvx = *s;
- /* the value is ended by a ',' or space or newline or null */
+ /* the value is ended by a ',' or space or newline or null or ) */
while (*vvx &&
*vvx != ',' &&
!isspace (*vvx) &&
*vvx != '\n' &&
- *vvx != ':')
+ *vvx != ':' &&
+ *vvx != ')')
{
char ubb = 0;
/* if we find a '(' then we need to balance it */
if (*vvx == ')')
ubb--;
}
+ // include the trailing ')'
+ *vv++ = *vvx++;
}
else
*vv++ = *vvx++;
*s = vvx;
*vv = '\0';
/* got value */
- vvx = Safe_calloc (1, strlen (vval) + 1);
+ vvx = traceAlloc (&_G.values, Safe_alloc(strlen (vval) + 1));
strcpy (vvx, vval);
- hTabAddItem (vtab, key, vvx);
+ hTabAddItem (vtab, key, vvx);
}
/*-----------------------------------------------------------------*/
lineNode *spl; /* source pl */
lineNode *rpl; /* rule peep line */
- hTabClearAll (pr->vars);
/* setToNull((void **) &pr->vars); */
/* pr->vars = newHashTable(100); */
{
lineNode *cl = NULL;
lineNode *pl = NULL, *lhead = NULL;
- char lb[MAX_PATTERN_LEN];
+ /* a long function name and long variable name can evaluate to
+ 4x max pattern length e.g. "mov dptr,((fie_var>>8)<<8)+fie_var" */
+ char lb[MAX_PATTERN_LEN*4];
char *lbp;
lineNode *comment = NULL;
lbp = lb;
l = pl->line;
+
while (*l)
{
/* if the line contains a variable */
l++;
continue;
}
- while (*v)
+ while (*v) {
*lbp++ = *v++;
+ }
l++;
- while (isdigit (*l))
+ while (isdigit (*l)) {
l++;
+ }
continue;
}
*lbp++ = *l++;
(*shead)->prev->next = lhead;
lhead->prev = (*shead)->prev;
}
- else
- *shead = lhead;
+ *shead = lhead;
/* now for the tail */
if (stail && stail->next)
{
{
labelHashEntry *entry;
- entry = Safe_calloc (1, sizeof (labelHashEntry));
+ entry = traceAlloc (&_G.labels, Safe_alloc(sizeof (labelHashEntry)));
memcpy (entry->name, label, labelLen);
entry->name[labelLen] = 0;
#endif
}
+/* How does this work?
+ peepHole
+ For each rule,
+ For each line,
+ Try to match
+ If it matches,
+ replace and restart.
+
+ matchRule
+ matchLine
+
+ Where is stuff allocated?
+
+*/
+
/*-----------------------------------------------------------------*/
/* peepHole - matches & substitutes rules */
/*-----------------------------------------------------------------*/
lineNode *spl;
peepRule *pr;
lineNode *mtail = NULL;
+ bool restart;
+
+#if !OPT_DISABLE_PIC
+ /* The PIC port uses a different peep hole optimizer based on "pCode" */
+ if (TARGET_IS_PIC)
+ return;
+#endif
+
+ assert(labelHash == NULL);
+
+ do
+ {
+ restart = FALSE;
+
+ /* for all rules */
+ for (pr = rootRules; pr; pr = pr->next)
+ {
+ for (spl = *pls; spl; spl = spl->next)
+ {
+ /* if inline assembler then no peep hole */
+ if (spl->isInline)
+ continue;
+
+ mtail = NULL;
+
+ /* Tidy up any data stored in the hTab */
+
+ /* if it matches */
+ if (matchRule (spl, &mtail, pr, *pls))
+ {
+
+ /* then replace */
+ if (spl == *pls)
+ replaceRule (pls, mtail, pr);
+ else
+ replaceRule (&spl, mtail, pr);
+
+ /* if restart rule type then
+ start at the top again */
+ if (pr->restart)
+ {
+ restart = TRUE;
+ }
+ }
+
+ if (pr->vars)
+ {
+ hTabDeleteAll (pr->vars);
+ Safe_free (pr->vars);
+ pr->vars = NULL;
+ }
+
+ freeTrace (&_G.values);
+ }
+ }
+ } while (restart == TRUE);
if (labelHash)
{
hTabDeleteAll (labelHash);
+ freeTrace (&_G.labels);
}
labelHash = NULL;
-
-top:
- /* for all rules */
- for (pr = rootRules; pr; pr = pr->next)
- {
-
- for (spl = *pls; spl; spl = spl->next)
- {
-
- /* if inline assembler then no peep hole */
- if (spl->isInline)
- continue;
-
- mtail = NULL;
-
- /* if it matches */
- if (matchRule (spl, &mtail, pr, *pls))
- {
-
- /* then replace */
- if (spl == *pls)
- replaceRule (pls, mtail, pr);
- else
- replaceRule (&spl, mtail, pr);
-
- /* if restart rule type then
- start at the top again */
- if (pr->restart)
- goto top;
- }
- }
- }
}
}
else
{
- rs = Safe_calloc (1, strlen (lb) + 1);
+ rs = Safe_alloc ( strlen (lb) + 1);
strcpy (rs, lb);
}
nch = 0;
}
else
{
- rs = Safe_calloc (1, strlen (lb) + 1);
+ rs = Safe_alloc ( strlen (lb) + 1);
strcpy (rs, lb);
}
}
}
/*-----------------------------------------------------------------*/
-/* initPeepHole - initiaises the peep hole optimizer stuff */
+/* initPeepHole - initialises the peep hole optimizer stuff */
/*-----------------------------------------------------------------*/
void
initPeepHole ()
readRules (s = readFileIntoBuffer (options.peep_file));
setToNull ((void **) &s);
}
+
+
+#if !OPT_DISABLE_PIC
+ /* Convert the peep rules into pcode.
+ NOTE: this is only support in the PIC port (at the moment)
+ */
+ if (TARGET_IS_PIC) {
+ peepRules2pCode(rootRules);
+ }
+#endif
+
}
projects / fw / sdcc / blobdiff