summaryrefslogtreecommitdiff
path: root/src/pic16/pcodeflow.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/pic16/pcodeflow.c')
-rw-r--r--src/pic16/pcodeflow.c351
1 files changed, 351 insertions, 0 deletions
diff --git a/src/pic16/pcodeflow.c b/src/pic16/pcodeflow.c
new file mode 100644
index 0000000..fc8ec86
--- /dev/null
+++ b/src/pic16/pcodeflow.c
@@ -0,0 +1,351 @@
+/*-------------------------------------------------------------------------
+
+ pcodeflow.c - post code generation flow analysis
+
+ Written By - Scott Dattalo scott@dattalo.com
+ Ported to PIC16 By - Martin Dubuc m.dubuc@rogers.com
+
+ This program is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2, or (at your option) any
+ later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+-------------------------------------------------------------------------*/
+/*
+ pcodeflow.c
+
+ The purpose of the code in this file is to analyze the flow of the
+ pCode.
+
+*/
+
+#include <stdio.h>
+
+#include "common.h" // Include everything in the SDCC src directory
+#include "newalloc.h"
+#include "ralloc.h"
+#include "device.h"
+#include "pcode.h"
+#include "pcoderegs.h"
+#include "pcodeflow.h"
+
+#if 0
+
+/*
+ In the section that follows, an exhaustive flow "tree" is built.
+ It's not a tree that's really built, but instead every possible
+ flow path is constructed.
+
+ This is really overkill...
+*/
+
+static set *FlowTree=NULL;
+
+void dbg_dumpFlowTree(set *FlowTree)
+{
+ set *segment;
+ pCodeFlow *pcflow;
+
+ fprintf(stderr,"Flow Tree: \n");
+
+ for(segment = setFirstItem(FlowTree); segment; segment=setNextItem(FlowTree)) {
+
+ fprintf(stderr,"Segment:\n");
+
+ for(pcflow=PCFL(setFirstItem(segment)); pcflow; pcflow=PCFL(setNextItem(segment))) {
+ fprintf(stderr, " 0x%03x",pcflow->pc.seq);
+ }
+ fprintf(stderr,"\n");
+ }
+
+}
+
+
+
+
+/*-----------------------------------------------------------------*
+ * void BuildFlowSegment(set *segment, pCodeFlow *pcflow)
+ *-----------------------------------------------------------------*/
+static void BuildFlowSegment(set *segment, pCodeFlow *pcflow)
+{
+
+ int nNextFlow=0;
+ pCodeFlowLink *pcflowLink=NULL;
+
+ /* Add this flow to the set if it's not in there already */
+ if(isinSet(segment, pcflow)) {
+ addSetHead(&FlowTree, segment);
+ return;
+ }
+
+ addSetHead(&segment, pcflow);
+
+ /* Continue to add contiguous flows */
+
+ while( pcflow->to && ((nNextFlow = elementsInSet(pcflow->to)) == 1)) {
+ pcflowLink = (pCodeFlowLink *)(setFirstItem(pcflow->to));
+ pcflow = pcflowLink->pcflow;
+
+ if(isinSet(segment, pcflow)) {
+ addSetIfnotP(&FlowTree, segment);
+ return;
+ }
+
+ addSetIfnotP(&segment, pcflow);
+
+ }
+
+ /* Branch: for each branch, duplicate the set and recursively call */
+ if(pcflow->to && nNextFlow>=2) {
+ pCodeFlow *pcflow_to;
+
+ set *branch_segment=NULL;
+
+ pcflowLink = (pCodeFlowLink *)(setFirstItem(pcflow->to));
+ pcflow_to = pcflowLink->pcflow;
+
+ addSetIfnotP(&segment, pcflow);
+
+ pcflowLink = (pCodeFlowLink *)(setNextItem(pcflow->to));
+
+ while(pcflowLink) {
+
+ branch_segment = setFromSet(segment);
+ BuildFlowSegment(setFromSet(segment),pcflowLink->pcflow);
+ pcflowLink = (pCodeFlowLink *)(setNextItem(pcflow->to));
+ }
+
+ /* add the first branch to this segment */
+ BuildFlowSegment(segment,pcflow_to);
+
+ }
+
+ addSetIfnotP(&FlowTree, segment);
+
+ /* done */
+}
+
+/*-----------------------------------------------------------------*
+ * void pic16_BuildFlowTree(pBlock *pb)
+ *-----------------------------------------------------------------*/
+void pic16_BuildFlowTree(pBlock *pb)
+{
+ pCodeFlow *pcflow;
+ set *segment;
+
+ FlowTree = newSet();
+
+ /* Start with the first flow object of this pBlock */
+
+ pcflow = PCFL(pic16_findNextpCode(pb->pcHead, PC_FLOW));
+
+ segment = newSet();
+ BuildFlowSegment(segment, pcflow);
+
+ pb->FlowTree = FlowTree;
+
+ dbg_dumpFlowTree(FlowTree);
+}
+
+static void dbg_dumpFlow(pBlock *pb)
+{
+ pCode *pcflow;
+
+ for( pcflow = pic16_findNextpCode(pb->pcHead, PC_FLOW);
+ pcflow != NULL;
+ pcflow = pic16_findNextpCode(pcflow->next, PC_FLOW) ) {
+
+ if(!isPCFL(pcflow))
+ fprintf(stderr, "LinkFlow - pcflow is not a flow object ");
+
+ fprintf(stderr, "Flow: 0x%x",pcflow->seq);
+ if(PCFL(pcflow) && PCFL(pcflow)->ancestor)
+ fprintf(stderr,", ancestor 0x%x\n",
+ PCFL(pcflow)->ancestor->pc.seq);
+ else {
+ pCodeFlowLink *from = (PCFL(pcflow)->from) ? (PCFLINK(setFirstItem(PCFL(pcflow)->from))) : NULL;
+ fprintf(stderr," no ancestor");
+ while(from) {
+ fprintf(stderr," (0x%x)",from->pcflow->pc.seq);
+ from = setNextItem(PCFL(pcflow)->from);
+ }
+ fprintf(stderr,"\n");
+ }
+ }
+}
+#endif
+
+#if 0
+/*-----------------------------------------------------------------*
+ * void BuildFlowSegment(set *segment, pCodeFlow *pcflow)
+ *-----------------------------------------------------------------*/
+static void BuildFlowSegment(pCodeFlow *pcflow)
+{
+ static int recursion=0;
+ pCodeFlow *pcflow_other;
+ set *flowset;
+
+ if(!pcflow)
+ return;
+
+ if(recursion++ > 200) {
+ fprintf(stderr, " exceeded recursion\n");
+ return;
+ }
+
+ fprintf(stderr,"examining 0x%x\n",pcflow->pc.seq);
+
+ if(pcflow->from) {
+
+
+ flowset = pcflow->from;
+
+ if(flowset && flowset->next == NULL) {
+
+ /*
+ There is a flow before this one. In fact, there's
+ exactly one flow before this one (because ->next is
+ NULL). That means all children of this node pass
+ through both this node and the node immediately
+ before this one; i.e. they have the same ancestor.
+ */
+
+ if( (NULL == (pcflow_other = PCFLINK(flowset->item)->pcflow)) ||
+ (NULL == pcflow_other)) {
+ fprintf(stderr,"2 error in flow link\n");
+ exit(1);
+ }
+ pcflow->ancestor = pcflow_other->ancestor ;
+
+ fprintf(stderr,"Assigning ancestor 0x%x from flow 0x%x\n",
+ pcflow->ancestor->pc.seq, pcflow_other->pc.seq);
+
+ } else {
+
+ if(flowset == NULL) {
+
+ /* There are no flows before this one.
+ * If this is not the first flow object in the pBlock then
+ * there's an error */
+
+ if(!pcflow->ancestor) {
+ fprintf(stderr,"error in flow link\n");
+ exit(1);
+
+ }
+
+ } else {
+
+ /* Flow passes to this flow from multiple flows. Let's
+ look at just one of these. If the one we look at has
+ an ancestor, then that's our ancestor too. If the one
+ we look at doesn't have an ancestor, then that means
+ we haven't traversed that branch of the call tree
+ yet - but we will */
+
+ pcflow_other = PCFLINK(flowset->item)->pcflow;
+ if(pcflow_other) {
+ fprintf(stderr, "coming from 0x%x\n",pcflow_other->pc.seq);
+ if( pcflow_other->ancestor)
+ pcflow->ancestor = pcflow_other->ancestor;
+ }
+ }
+
+
+ }
+
+ } else {
+ /* there are no nodes before this one */
+ if(!pcflow->ancestor)
+ fprintf(stderr,"3 Error in flow link\n");
+ }
+
+ /* Now let's recursively expand the call tree */
+
+ if(pcflow->ancestor && pcflow->to) {
+ flowset = pcflow->to;
+ while(flowset) {
+ BuildFlowSegment(PCFLINK(flowset->item)->pcflow);
+ flowset = flowset->next;
+ }
+ }
+
+}
+#endif
+
+void pic16_BuildFlowTree(pBlock *pb)
+{
+ pCodeFlow *first_pcflow, *pcflow;
+
+
+ // fprintf(stderr,"pic16_BuildFlowTree \n");
+
+ first_pcflow = PCFL(pic16_findNextpCode(pb->pcHead, PC_FLOW));
+ if(!first_pcflow)
+ return;
+
+ /* The very first node is like Adam, it's its own ancestor (i.e.
+ * there are no other flows in this pBlock prior to the first one).
+ */
+
+ first_pcflow->ancestor = first_pcflow;
+
+ /* For each flow that has only one predecessor, it's easy to
+ identify the ancestor */
+ pcflow = PCFL(pic16_findNextpCode(first_pcflow->pc.next, PC_FLOW));
+
+ while(pcflow) {
+ if(elementsInSet(pcflow->from) == 1) {
+ pCodeFlowLink *from = PCFLINK(setFirstItem(pcflow->from));
+
+ pcflow->ancestor = from->pcflow;
+ /*
+ fprintf(stderr,"Assigning ancestor 0x%x to flow 0x%x\n",
+ pcflow->ancestor->pc.seq, pcflow->pc.seq);
+ */
+ }
+
+ pcflow = PCFL(pic16_findNextpCode(pcflow->pc.next, PC_FLOW));
+
+ }
+
+ pcflow = PCFL(pic16_findNextpCode(first_pcflow->pc.next, PC_FLOW));
+
+ while(pcflow) {
+ if(elementsInSet(pcflow->from) > 1) {
+ pCodeFlow *min_pcflow;
+ pCodeFlowLink *from = PCFLINK(setFirstItem(pcflow->from));
+
+ min_pcflow = from->pcflow;
+
+ while( (from = setNextItem(pcflow->from)) != NULL) {
+ if(from->pcflow->pc.seq < min_pcflow->pc.seq)
+ min_pcflow = from->pcflow;
+ }
+
+ pcflow->ancestor = min_pcflow;
+ /*
+ fprintf(stderr,"Assigning ancestor 0x%x to flow 0x%x from multiple\n",
+ pcflow->ancestor->pc.seq, pcflow->pc.seq);
+ */
+
+ }
+
+ pcflow = PCFL(pic16_findNextpCode(pcflow->pc.next, PC_FLOW));
+
+ }
+
+ // BuildFlowSegment(pcflow);
+
+ //dbg_dumpFlow(pb);
+
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-08-21 11:04:40 +0000