Semantical Equivalence of the Control Flow Graph and the Program Dependence Graph

TL;DR

This paper establishes an equivalence between control flow graphs and a new class of deterministic program dependence graphs, providing a more general operational semantics that applies beyond well-structured programs.

Contribution

It introduces deterministic PDGs with unique execution outcomes and proves their operational semantics are equivalent to control flow graphs, extending existing semantics.

Findings

Deterministic PDGs have unique final states.

Operational semantics of control flow graphs and deterministic PDGs are equivalent.

Deterministic PDGs include those from well-structured programs.

Abstract

The program dependence graph (PDG) represents data and control dependence between statements in a program. This paper presents an operational semantics of program dependence graphs. Since PDGs exclude artificial order of statements that resides in sequential programs, executions of PDGs are not unique. However, we identified a class of PDGs that have unique final states of executions, called deterministic PDGs. We prove that the operational semantics of control flow graphs is equivalent to that of deterministic PDGs. The class of deterministic PDGs properly include PDGs obtained from well-structured programs. Thus, our operational semantics of PDGs is more general than that of PDGs for well-structured programs, which are already established in literature.

Equations

$$n_{i+1}=\{\begin{array}{ll}p& \mathrm{if}\mathcal{E}(e){\sigma }_i=\mathbf{T}\\ q& \mathrm{if}\mathcal{E}(e){\sigma }_i=\mathbf{F}\end{array}$$

$${\sigma }_{i+1}=\{\begin{array}{ll}{\sigma }_i[x\mapsto \mathcal{E}(e){\sigma }_i]& \mathrm{if}{n}_i=(x:=e)\\ {\sigma }_i& \mathrm{otherwise}\end{array},$$

$$C$$

$$F$$

$$L$$

$$D$$

$$state=(avail,econf)$$

$$G(0)$$

$$G_T(0)$$

$$G_F(0)$$

$$G(3)$$

$$G_T(3)$$

$$G_F(3)$$

$$G(6)$$

$$G_T(6)$$

$$G_F(6)$$

$$N^{\prime }$$

$$C^{\prime }$$

$$F^{\prime }$$

$$L^{\prime }$$

$$D^{\prime }$$

$$N^{\prime }$$

$$C^{\prime }$$

$$F^{\prime }$$

$$L^{\prime }$$

$$D^{\prime }$$

$$N^{\prime }$$

$$C^{\prime }$$

$$F^{\prime }$$

$$L^{\prime }$$

$$D^{\prime }$$

$$Avail=N\times Var⟶Val$$

$$Econf=C\oplus F\oplus L\oplus D⟶\{chk,unchk,act\}.$$

$$\mathcal{E}:N\times Exp⟶(Avail⟶Val).$$

$$\begin{array}[]{lcl}\mathit{condC}(s,n)&\stackrel{{\scriptstyle\mathrm{def}}}{{=}}&\exists c(p,n)\in C.\mathit{ec}(c(p,n))=\mathit{act}\\ &&\wedge(\forall q\in G^{*}(n).q\neq n\Rightarrow\forall c(r,q)\in C.\mathit{ec}(c(r,q))\neq\mathit{act})\\ \mathit{condF}(s,n)&\stackrel{{\scriptstyle\mathrm{def}}}{{=}}&\forall f(p,n)\in F.\mathit{ec}(f(p,n))=\mathit{chk}\\ \mathit{condL}(s,n)&\stackrel{{\scriptstyle\mathrm{def}}}{{=}}&\forall l(n,p)\in L.n\neq p\Rightarrow\mathit{ec}(l(n,p))=\mathit{chk}\\ \mathit{condD}(s,n)&\stackrel{{\scriptstyle\mathrm{def}}}{{=}}&\forall d(p,n)\in D.\mathit{ec}(d(p,n))=\mathit{chk}\end{array}$$

$$Next(s)=\{n|condCFLD(s,n)\}.$$

$$udav(n,av)=\{\begin{array}{l}av[(p,x)\mapsto \mathcal{E}(n,e)av:(n,p)\in F\oplus L]\mathrm{if}n=(x:=e)\\ av\text{otherwise}\end{array},$$

$$udec(n,(av,ec))={ec}^{\prime },$$

$$\forall (p,q)\in C.{ec}_0((p,q))=\{\begin{array}{ll}act& \text{if}p=entry\\ unchk& \text{otherwise}\end{array},$$

$$\forall (p,q)\in F\oplus L\oplus D.{ec}_0((p,q))=unchk$$

$$s_i\stackrel{n_i}{\to }{s}_{i+1}$$

$${av}^{\prime }=udav(n_i,{av}_i)\wedge {ec}^{\prime }=udec(n_i,s_i).$$

$$\forall x\in use(n).\sigma (x)=av(n,x).$$

Full text

1 Introduction

The program dependence graph (PDG) [9, 5, 6] is a kind of an intermediate representation of programs. It is a directed graph whose nodes are program statements and edges represent data dependence or control dependence between them.

The PDG is a useful representation for compiler code optimisation, because many optimisation techniques are based on analyses of data dependence and control dependence between statements in a program [4, 5]. Using PDGs, we can simplify program optimisations, because many optimisations can be carried out by simply scanning PDGs. If optimisation techniques are applied to control flow graphs (CFGs), we need to re-analyse dependence relationships in the program because optimisation changes them. However, if we apply optimisation techniques to PDGs, we do not need to re-analyse dependence relationships because optimisation itself changes them in the PDG. Furthermore, since the PDG excludes artificial order of statements, it is a suitable representation for vectorisation and parallelisation [16, 5, 2].

Although the PDG is a suitable representation for program optimisation, the correctness of such optimisation techniques on PDGs is not well-studied due to the lack of research on semantics of the PDG.

There are a few researches on the semantics of PDGs [11, 3, 13]. Selke [11] introduced a rewriting semantics of a PDG and proved that it is equivalent to the program semantics. Cartwright and Felleisen [3] introduced a denotational semantics of a PDG. They proved that their semantics coincides with that of terminating programs, and also proved that even a PDG corresponding to a non-terminating program can return a result. Ramalingam and Reps [13] presented a formal semantics of program representation graphs (PRG) that are extension of PDGs. A PRG has so-called $\phi$ nodes that determine which definition will be used when the same variable is defined in multiple assignment statements. Thanks to $\phi$ nodes, PRGs can be naturally interpreted as data-flow programs. They define a semantics of a PRG as a function that maps an initial store to a sequence of values for each node, and is given as the least fixed point of a set of mutually recursive equations.

The above semantics of PDGs and PRGs cover only well-structured programs. Conditionals are restricted to the form $(\textbf{if}~{}e~{}\textbf{then}\dots\textbf{else}\dots)$ and loops are restricted to the form $(\textbf{while}~{}e\dots)$. However, not all programs that appear during compiler code optimisation fall into this type of programs. Let us consider a program in Fig. 1 and assume that the expression xy is loop-invariant. Since this loop has a conditional that determines iteration, we cannot directly move the computation of xy outside of the loop. Therefore, we need to transform the loop and move the computation of x*y before the loop as in Fig. 2 [10]. This loop has the form $\textbf{do}\dots\textbf{while}$ and is left out of consideration in the existing semantics of PDGs. Therefore, existing semantics of PDGs are not sufficient to prove correctness of this optimsation technique.

In this paper, we present an operational semantics of PDGs that have more complex control flow structures than that of well-structured programs. In our operational semantics, statements that are independent of each other can be simultaneously executable. Hence, there are many executions for a single PDG. However, PDGs that satisfy certain structural constraints have the same execution results. We call this type of PDGs deterministic PDGs (dPDGs).

Moreover, we prove that our operational semantics of PDGs coincide with that of CFGs for the class of dPDGs. It gurantees that if programs are semantically equivalent to CFGs, they are also semantically equivalent to PDGs. This enables us to use PDGs as a foundation to discuss correctness of several program transformations on PDGs.

This paper is organised as follows. In section 2, we introduce the CFG as a presentation of programs in this paper and its operational semantics. In addition to that, we define several types of dependence between statements in a CFG. In section 3, we define the PDG. Section 4 presents the operational semantics of PDGs. Furthermore, we define the class of deterministic PDGs and prove that PDGs constructed from usual programs are deterministic PDGs. In section 5, we prove that CFGs are semantically equivalent to the corresponding PDGs. The final section offers conclusion and future directions.

This paper is a revised version of the author’s previous works [8, 7] in that definitions are revised and proofs are optimised and rectified.

2 Control flow graph (CFG)

We consider the CFG as a representation of programs. A CFG is a pair $(N,E)$ of a set $N$ of nodes and a set $E\subseteq N\times N$ of edges. The nodes of a CFG are labelled by statements, and the edges of a CFG represent control flow of a program. We only consider three types of statements; an assignment statement ($x:=e$), a conditional statement ($\mathtt{if}~{}e$) and a return statement ($\mathtt{ret}~{}x$). Assignment statements have exactly one successor and conditional statements have exactly two successors. The edges from a conditional statement are labelled differently from each other, that is, either with true or false. A CFG has a unique start node and a unique end node. The start node has no predecessor, while the end node has no successor. Any node in a CFG is reachable from the start node. The last node must be a return statement.

Fig. 3 is an example of a CFG.

Definition 2.1**.**

Let $\mathit{Var}$ be the set of variables and $\mathit{Exp}$ be the set of expressions appearing in a CFG. Let $\mathit{val}$ be the set of values, which contains special values $\mathbf{T}$ and $\mathbf{F}$. A store is a function of the signature $\mathit{Var}\longrightarrow\mathit{Val}$. We write $\mathit{Store}$ for the set of stores. An evaluation function of expressions is $\mathcal{E}:\mathit{Exp}\longrightarrow(\mathit{Store}\longrightarrow\mathit{Val})$.

Definition 2.2**.**

(The operational semantics of CFG) Let $G=(N,E)$ be a CFG. A run is a sequence of stores $\sigma_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}\sigma_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots$ satisfing the following:

$\sigma_{0}$* is a given initial store.* 2. 2.

$n_{0}$* is the initial node of $G$.* 3. 3.

$n_{i+1}$* is a successor of $n_{i}$ in $G$ and determined as follows:*

1. (a)

If $n_{i}$ is an assignment statement, then $n_{i+1}$ is the unique successor of $n_{i}$. 2. (b)

If $n_{i}$ is a conditional statement $(\mathtt{if}~{}e)$, and $(n_{i},p)_{\mathbf{T}}\in E$ and $(n_{i},q)_{\mathbf{F}}\in E$, then

[TABLE] 4. 4.

$\sigma_{i+1}$* is determined as follows:*

[TABLE]

where $\sigma[x\mapsto v]$ is the same as $\sigma$ except it maps $x$ to $v$.

The following theorem is a trivial consequence of the definition.

Theorem 2.1**.**

A run of a CFG is deterministic, that is, for any CFG $G$ and $\sigma_{0}$ there exists the unique run of $G$.

There are several types of dependence between program statements. In the following sections, we define control dependence, data dependence and def-order dependence.

2.1 Control flow dependence

To define control dependence, we first define the notion of post-domination. We add $\mathit{entry}$ node and $\mathit{exit}$ node to a CFG. Entry node is the predecessor of the start node and exit node is the successor of the end node. Entry node has true edge to the start node and false edge to exit node. We call the resulting graph the augmented CFG of an original CFG. Figure 4 is the augmented CFG for the graph in Figure 3.

A path is a sequence of nodes $n_{0}n_{1}n_{2}\dots$ where $\forall i\geq 0.(n_{i},n_{i+1})\in E$. The length of a path is the length of the sequence.

Definition 2.3** (Post-domination).**

Let $s$ and $t$ be nodes in a CFG $G$. We say $t$ post-dominates $s$ iff every path from $s$ contains $t$, and $t$ strictly post-dominates $s$ iff $t$ post-dominates $s$ and $s\neq t$.

Definition 2.4** (Control dependence).**

Let $s$ and $t$ be nodes in a CFG $G$. We say $t$ is control-dependent on $s$ iff there exists a path of length greater than 1 from $s$ to $t$ such that $t$ post-dominates all nodes on that path except $s$, and $t$ does not strictly post-dominate $s$.

The above definitions are slightly modified from usual post-domination and control dependence. The definition of post-domination and control dependence in this paper are called “strong forward domination” and “weak control dependence” [12]. The usual definition is “$s$ post-dominates $t$ if every path from $t$ to the exit node contains $s$”. Our definition omits the underlined phrase.

The difference between the usual definition and our definition appears when a CFG contains a loop. We illustrate this difference using an example CFG in Fig. 4. In this CFG, node 5 is not control-dependent on node 4 in the usual definition since every path from node 4 to the exit node contains node 5, i.e. node 5 post-dominates node 4. However, in our definition, node 5 is control-dependent on node 4 since every path from node 4 does not contain node 5. There exists a path iterating the loop infinitely. Thus, node 5 does not post-dominate node 4. Our definition reflects the intuition that whether node 5 is executed or not depends on the result of condition at node 4.

We discriminate two types of control dependence; true control dependence and false control dependence. Suppose $t$ is control-dependent on $s$. By definition, $s$ has two successors i.e. $s$ is a conditional statement. Let $(s,u)_{\mathbf{T}}\in E$ and $(s,v)_{\mathbf{F}}\in E$. If $u$ is post-dominated by $t$, $t$ is true control-dependent on $s$. If $v$ is post-dominated by $t$, $t$ is false control-dependent on $s$.

We write $\mathit{CD}(s,t)$ to represent that $t$ is control dependent on $s$.

2.2 Data dependence

There are two kinds of data dependence – loop-independent data dependence and loop-carried data dependence. To define these types of dependence, we must define loops formally. We cannot use the definition of natural loops [1] since we treat irreducible control flow graphs.

Definition 2.5** (Loops, back edges).**

Let $G$ be a directed graph. A loop is a strongly connected region in $G$. A back edge of a loop is an edge contained in that loop whose target node have an incoming edge from the outside of that loop.

In Fig. 6, the set of nodes $\{1,2,3,4,5,6\}$ comprises a loop. Back edges for this loop are $(3,4)$ and $(6,1)$. In Fig. 6, the set of nodes $\{1,2,3,4,5\}$ and $\{2,3,4\}$ comprise loops. The back edges for $\{1,2,3,4,5\}$ and $\{2,3,4\}$ are respectively $(5,1)$ and $(4,2)$.

Definition 2.6** (Data dependence).**

Let $G$ be a CFG. Let $s$ and $t$ be nodes in $G$. We say the definition at $s$ reaches $t$ if there exists a variable $w$ such that $s$ defines $w$ and $t$ uses $w$ and there exists a path whose length is more than 1 in $G$ from $s$ to $t$ such that no node except $s$ on that path defines $w$. We call such a path a reaching path from $s$ to $t$. We say $t$ is data-dependent on $s$ if the definition at $s$ reaches $t$. There is a loop-independent data dependence from $s$ to $t$ if $t$ is data dependent on $s$, and i) both $s$ and $t$ are not contained in the same loop or ii) if both $s$ and $t$ are contained in the same loop, there is a reaching path from $s$ to $t$ that does not contain any back edge of the loop. There is a loop-carried data dependence from $s$ to $t$ if both $s$ and $t$ are contained in the same loop, and there exists a reaching path from $s$ to $t$ that contains a back edge of the loop and there is no loop-independent data dependence from $s$ to $t$.

We write $\mathit{LIDD}(s,t)$ and $\mathit{LCDD}(s,t)$ to represent there is a loop-independent data dependence from $s$ to $t$ and there is a loop-carried data dependence from $s$ to $t$, respectively.

2.3 Def-order dependence

Finally we define def-order dependence.

Definition 2.7** (Def-order dependence).**

Let $G$ be a CFG. Let $s$ and $t$ be nodes in $G$. We say $t$ is def-order-dependent on $s$ if there exists a node $u$ which is loop-independently data dependent on both $s$ and $t$, and both $s$ and $t$ define the same variable, and i) there exists a path from $s$ to $t$ and both $s$ and $t$ are not contained in the same loop, or ii) both $s$ and $t$ are contained in the same loop and $t$ is reachable from $s$ without passing any back edge of the loop, or iii) if both $s$ and $t$ are contained in the same loop, and $s$ is reachable from $t$ and $t$ is also reachable from $s$, then such paths must contain back edges of the loop.

Note that in the case of iii), there is also a def-order dependence from $t$ to $s$. We write $\mathit{DefOrd}(s,t)$ to represent $t$ is def-order-dependent on $s$.

3 Program dependence graph (PDG)

The definition of the PDG in this paper depends on the one by Selke [11]. A PDG is a quintaple $(N,C,F,L,D)$ where $N$ is a set of nodes, and $C$, $F$, $L$ and $D$ sets of edges, that is, subsets of $N\times N$. The sets of edges $C$, $F$, $L$ and $D$ respectively represent four types of dependence: control flow dependence, loop-independent data dependence, loop-carried data dependence and def-order dependence. $C$-edges are divided into true edges and false edges.

The subgraph $(N,C)$ is called the control dependence graph (CDG) of a PDG $(N,C,F,L,D)$.

Nodes are labeled with statements as in CFGs. Statements are one of the following: an assignment statement ($x:=e$), a conditional statement ($\mathtt{if}~{}e$) or a return statement ($\mathtt{ret}~{}x$).

If a node is labeled with an assignment statement, then there is no $C$-edges outgoing from that state. If a node is labeled with a conditional statement, then there is no outgoing $F$, $L$ and $D$-edges from that node. If $(p,q)\in F$ or $(p,q)\in L$, there is a variable $w$ that $p$ defines and $q$ uses. If $(p,q)\in D$ then there is a variable $w$ such that both $p$ and $q$ define it and there is a node $u$ such that $(p,u)\in F$ and $(q,u)\in F$. Nodes labeled with $\mathtt{ret}$ statements do not have any outgoing edges.

3.1 Construction of the PDG from a CFG

Let $G=(N,E)$ be a CFG. The PDG corresponding to $G$ is a graph $(N\cup\{\mathit{entry}\},C,F,L,D)$, where, supposing $s$ and $t$ range over $N\cup\{\mathit{entry}\}$,

[TABLE]

Note that the node $\mathit{entry}$ is the root node of the CDG $(N\cup\{\mathit{entry}\},C)$.

Hereafter, we write $c(s,t)$ for an element of $C$, $f(s,t)$ for an element of $F$, $l(s,t)$ for an element of $L$ and $d(s,t)$ for an element of $D$. Furthermore, we discriminate true control dependence and false control dependence in $C$ by writing $ct(s,t)$ and $cf(s,t)$. We also discriminate elements in $F$ and $L$ by explicating a related variable like $f_{x}(s,t)$ and $l_{x}(s,t)$. Fig. 7 presents the PDGand its CDG corresponding to the CFG in Fig. 3.

4 An operational semantics of the PDG

In this section, we present an operational semantics of the PDG. The basic idea is to define states in runs of PDGs as follows.

[TABLE]

$\mathit{avail}$ is a function that takes a node and a variable and return a value. Recall that $\mathit{store}$ is a set of functions taking a variable and return a value. The difference between $\mathit{store}$ and $\mathit{avail}$ is that $\mathit{store}$ is global bindings of variables while $\mathit{avail}$ is local bindings of variables for each node. We do not need global stores since an execution of a statement affects only nodes that are dependent on it.

$\mathit{econf}$ is a function that takes an edge and return the state of the edge. Functions in $\mathit{econf}$ indicate whether nodes are executable or not. For example, if node $n$ is an $\mathtt{if}$ statement and the expression is evaluated to $\mathbf{T}$ then its outgoing $\mathit{ct}$-edges are “activated” and outgoing $\mathit{cf}$-edges are “inactivated.” Whether a node is executable or not is determined by the state of its incoming edges. $\mathit{econf}$ is used to represent a configuration of edges in executions of PDGs.

To define the operational semantics of the PDG, we introduce the following notions on PDGs.

4.1 Preliminary

In order to define the operational semantics of the PDG, we define several notions related to it.

Definition 4.1** (Looping edges).**

Let $G=(N,C,F,L,D)$ be a PDG and $G_{C}=(N,C)$ be the CDG of $G$. Let $R$ be a loop in $G_{C}$. Suppose $\mathit{ct}(p,q)$ (resp. $\mathit{cf}(p,q)$) is a back edge of $R$. The looping edges of $R$ are all $\mathit{ct}$-edges (resp. $\mathit{cf}$-edges) from $p$ whose destinations have predecessors other than $p$.

Note that the notions of loops and back edges are not restricted to the CFG. In the CDG in Figure 7, there is a loop which consists of only node 4. Its back edge is $\mathit{ct}(4,4)$. Therefore, its looping edges are $\mathit{ct}(4,2),\mathit{ct}(4,3)$ and $\mathit{ct}(4,4)$.

We explain the correspondence between loops in a CFG and those in the CDG. Before that, we define iteration statements of loops in the CFG.

Definition 4.2** (Iteration statements).**

An iteration statement of a loop in a CFG is an $\mathtt{if}$ statement in that loop that has outgoing edges to nodes both inside and outside of that loop. It is trivial that for any loop in a CFG, there is at least one iteration statement.

Compare the CFG in Fig. 6 with its corresponding CDG in Fig. 8. We see that there is a loop $\{1,2,3,4,5,6\}$ in Fig. 6 whose back edges are $(3,4)$ and $(6,1)$. Therefore, node 3 and 6 are iteration statements in this program. Meanwhile, the loop existing in Fig. 8 is $\{3,6\}$. Thus, we can see that iteration statements in a CFG will be nodes in a loop in the corresponding CDG. Furthermore, the back edges of the loop $\{3,6\}$ in Fig. 8 are $\mathit{ct}(3,6)$ and $\mathit{ct}(6,3)$. Therefore, the looping edges are $\mathit{ct}(3,4)$, $\mathit{ct}(3,5)$, $\mathit{ct}(3,6)$, $\mathit{ct}(6,1)$, $\mathit{ct}(6,2)$ and $\mathit{ct}(6,3)$. If a node in a loop in a CDG is an iteration statement, then the looping edges outgoing from that node are $C$-edges to the nodes that will be executed when the loop iterates.

Intuitively, looping edges represent control dependence to the statements that will be executed in the next step of the loop.

Definition 4.3**.**

Let $G=(N,C,F,L,D)$ be a PDG. We define $\widehat{C}$ as the set obtained by removing all looping edges from $C$.

Definition 4.4**.**

Let $p$ and $q$ be nodes in a PDG $(N,C,F,L,D)$. We say $q$ is $C$-reachable from $p$ if $q$ is reachable from $q$ by $C$-edges. We say $q$ is $\widehat{C}$-reachable from $p$ if $q$ is reachable from $q$ by $\widehat{C}$-edges. We respectively say a $C$-successor, a $ct$-successor and a $cf$-successor for a successor by a $C$-edge, a $ct$-edge and a $cf$-edge.

Definition 4.5** (Subgraphs).**

Let $G=(N,C,F,L,D)$ be a PDG and $p\in N$. $G(p)=(N^{\prime},C^{\prime},F^{\prime},L^{\prime},D^{\prime})$ is the subgraph of node $p$ defined as follows:

[TABLE]

$G(p)$* is the subgraph that consists of nodes reachable from $p$ by $C$-edges that are not looping edges. Note that $c(p,q)$ itself may be a looping edge. Similarly, we define $G_{T}(p)$ (resp. $G_{F}(p)$) as the subgraph consisting of the nodes $\widehat{C}$-reachable from $ct$-successors (resp. $cf$-successors) of $p$. Formally, $G_{T}(p)=(N^{\prime},C^{\prime},F^{\prime},L^{\prime},D^{\prime})$ is defined as:*

[TABLE]

The definition of $G_{F}(p)$ is obtained from replacing the condition $\mathit{ct}(p,q)\in C$ with $\mathit{cf}(p,q)\in C$. We further define $G^{*}(p)=(N^{\prime},C^{\prime},F^{\prime},L^{\prime},D^{\prime})$ as follows:

[TABLE]

We can similarly define $G_{T}^{*}(p)$ and $G_{F}^{*}(p)$.

Intuitively, $G(p)$ consists of such statements that are at the same iteration level in the corresponding CFG. $G_{T}(p)$ consists of statements that will be executed when $p$ is evaluated to $\mathbf{T}$, and $G_{F}(p)$ consists of statements that will be executed when $p$ is evaluated to $\mathbf{F}$.

Fig. 8 shows subgraphs of the CDG in Fig. 6, where looping edges are $\mathit{ct}(3,4)$, $\mathit{ct}(3,5)$, $\mathit{ct}(3,6)$, $\mathit{ct}(6,1)$, $\mathit{ct}(6,2)$ and $\mathit{ct}(6,3)$.

Using above notions, we define the operational semantics of PDGs.

Definition 4.6**.**

An avail and an econf are respectively members of the following sets of functions $\mathit{Avail}$ and $\mathit{Econf}$:

[TABLE]

Here $\oplus$ is the direct sum. An evaluation function $\mathcal{E}$ is defined as

[TABLE]

A state is a member of $\mathit{State}=\mathit{Avail}\times\mathit{Econf}$.

Although we use the same symbol $\mathcal{E}$ as the evaluation function in definition 2.1, they are easily discriniminated by the signatures.

Definition 4.7** (Executable nodes).**

We first introduce the following predicates. Suppose $s=(\mathit{av},\mathit{ec})$, $\mathit{av}\in\mathit{Avail}$, $\mathit{ec}\in\mathit{Econf}$ and $n$ is a node.

[TABLE]

We write $\mathit{condCFLD}(s,n)$ for $\mathit{condC}(s,n)\wedge\mathit{condF}(s,n)\wedge\mathit{condL}(s,n)\wedge\mathit{condD}(s,n)$. We define function $\mathit{Next}:\mathit{State}\longrightarrow 2^{N}$ as:

[TABLE]

$\mathit{Next}(s)$* represent the executable nodes at state $s$.*

Definition 4.8** (Update function of avails).**

We define function $\mathit{udav}:N\times\mathit{Avail}\longrightarrow\mathit{Avail}$ as follows:

[TABLE]

where $\mathit{av}[(p,x)\mapsto v:(n,p)\in F\oplus L]$ is the same as $\mathit{av}$ except it maps $(p,x)$ to $v$ for each $p$ such that $(n,p)\in F\oplus L$.

Definition 4.9** (Update function of econfs).**

We define function $\mathit{udec}:N\times\mathit{State}\longrightarrow\mathit{Econf}$ as follows:

[TABLE]

where $\mathit{ec}^{\prime}$ is determined according to $n$, $\mathit{av}$ and $\mathit{ec}$ as follows.

• •

$n$* is any type.*

• –

$\mathit{ec}^{\prime}(c(p,n)):=\mathit{unchk}$, if $c(p,n)\in C$.

• –

$\mathit{ec}^{\prime}(l(p,n)):=\mathit{chk}$, if $l(p,n)\in L$.

• •

$n=(x:=e)$.

• –

$\mathit{ec}^{\prime}((n,p)):=\mathit{chk}$, if $(n,p)\in F\oplus D$.

• •

$n=(\mathtt{if}~{}e)$* and $\mathcal{E}(n,e)\mathit{av}=\mathbf{T}$.*

• –

$\mathit{ec}^{\prime}(ct(n,p)):=\mathit{act}$, if $\mathit{ct}(n,p)\in C$.

• –

$\mathit{ec}^{\prime}((q,r)):=\mathit{unchk}$, if $q\in G_{T}(n)-\{n\}$ and $(q,r)\in F\oplus D$.

• –

$\mathit{ec}^{\prime}(l(r,q)):=\mathit{unchk}$, if $q\in G_{T}(n)-\{n\}$, $r\in G_{T}(n)$ and $l(r,q)\in L$.

• –

$\mathit{ec}^{\prime}((q,r)):=\mathit{chk}$, if $q\in G_{F}(n)-G_{T}(n)$ and $(q,r)\in F\oplus D$.

• –

$\mathit{ec}^{\prime}(l(q,r)):=\mathit{unchk}$, if $q\in G_{F}(n)-G_{T}(n)$, $r\not\in G_{F}(n)-G_{T}(n)$ and $l(q,r)\in L$.

• –

$\mathit{ec}^{\prime}(l(r,q)):=\mathit{chk}$, if $q\in G_{F}(n)-G_{T}(n)$, $r\not\in G_{F}(n)-G_{T}(n)$ and $l(r,q)\in L$.

• •

$n=(\mathtt{if}~{}e)$* and $\mathcal{E}(n,e)\mathit{av}=\mathbf{F}$ D This case is the same as the case $\mathcal{E}(n,e)\mathit{av}=\mathbf{T}$. Replace $\mathit{ct}$ with $\mathit{cf}$ and $G_{T}(n)$ with $G_{F}(n)$ in the definition.*

$\mathit{ec}$* and $\mathit{ec}^{\prime}$ coincides on the edges that are not modified according to the rule above.*

Definition 4.10** (Operational semantics of the PDG).**

Let $G=(N,C,F,L,D)$ be a PDG. A run of $G$ is a sequence of states $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots$, where $s_{i}\in\mathit{State}$ and $n_{i}\in N$. Let $s_{i}=(\mathit{av}_{i},\mathit{ec}_{i})$, $\mathit{av}_{0}$ be a given initial avail and $\mathit{ec}_{0}$ be the initial econf defined as follows:

[TABLE]

Then $n_{i}$ and $s_{i+1}$ are determined as follows:

[TABLE]

A run of a PDG is either finite or infinite. If a run is finite and the last state is $s$, then $\mathit{Next}(s)=\emptyset$.

4.2 Deterministic PDG

A PDG does not necessarily have a unique run even if it starts with the same initial state, because it can express programs more expressive than usual sequential ones. However, we can prove that for a specific class of PDGs, called deterministic PDGs (dPDGs), it has runs that end with the same state from the same initial state, if they are finite. In this section, we define the class of dPDGs and prove some properties of it.

We first introduce the notion of the minimal common ancestor (mca).

Definition 4.11** (Minimal common ancestors).**

Let $G=(N,C,F,L,D)$ be a PDG and $p,q\in N$. The minimal common ancestors of nodes $p$ and $q$ are the last nodes of the longest common prefix of the acyclic paths from $\mathit{entry}$ to $p$ and $q$ in $(N,C)$. We write $\mathit{mca}(p,q)$ for the set of minimal common ancestors of $p$ and $q$.

Definition 4.12** (Deterministic PDGs).**

A PDG $G=(N,C,F,L,D)$ is a deterministic PDG if it satisfies the following three conditions where the term $\mathit{LP}$ denotes the set of loops in the CDG $(N,C)$:

$(p,n)\in C\wedge(q,n)\in C$* implies $p\in G^{*}(q)$ or $q\in G^{*}(p)$ or $\forall r\in\mathit{mca}(p,q).\forall Q\in\{\mathbf{T},\mathbf{F}\}.\{p,q\}\not\subseteq G_{Q}^{*}(r)$.* 2. 2.

$f_{x}(p,u)\in F\wedge f_{x}(q,u)\in F\wedge\exists r\in\mathit{mca}(p,q).\exists Q\in\{\mathbf{T},\mathbf{F}\}.\{p,q\}\subseteq G^{*}_{Q}(r)$* implies $d(p,q)\in D\vee d(q,p)\in D$ D* 3. 3.

$(p,q)\in F\oplus D$* implies $\forall R\in\mathit{LP}.\forall r\in R.p\in G(r)\Rightarrow q\in G^{*}(r)$ D*

Condition 1 states that if a node $n$ is control-dependent on both $p$ and $q$, then $p$ and $q$ cannot be executable simultaneously. Fig. 9 illustrates this condition. The outgoing edges from any minimal common ancestor $r$ of $p$ and $q$ must have different labels between the one that leads to $p$ and the one to $q$. Otherwise either $p$ must be controlled by $q$ or $q$ must be controlled by $p$.

Condition 2 states that if $p$ and $q$ define the same variable $x$, have a common $F$-successor and can be executable simultaneously, then there must be a def-order dependence between $p$ and $q$. This is illustrated in Fig. 10. In this case, $p$ and $q$ can be simultaneously executable. If there is no def-order dependence between $p$ and $q$, the value of the variable at node $n$ can be different depending on which node (i.e., $p$ or $q$) is executed first.

Condition 3 states that if there is data dependence from $p$ to $q$ and $p$ is control-dependent on a node $r$ in some loop $R$, then $q$ must be control-dependent on some node in that loop. Fig. 11 depicts the condition, where $r^{\prime}$ corresponds to ’some node’ in the previous sentence (note that $r^{\prime}\in G^{*}(r)$ because both are contained in the same loop). In Fig. 11, if node $q$ is not contained in $G(r^{\prime})$ then whether $q$ satisfies $pcondC$ can be determined independently on a condition of $\mathtt{if}$ statements in $R$. Meanwhile, since $p$ is contained in $G(r)$, executability of $p$ depends on $r$. Since $R$ is a loop, $r$ can be repeated, which implies that $p$ can be repeated many times and the value of a variable used in $q$ may be changed many times. However, as stated above, $q$ can satisfy $\mathit{condC}$ independently on the loop. Therefore, once $p$ is executed and data dependence to $q$ is satisfied, $q$ can be executable. Then the result of execution of the PDG depends on how many times $p$ is repeated when $q$ is executed.

Actually, there are PDGs constructed from CFGs that are not dPDGs. CFGs like the one in Fig. 12 do not satisfy condition 1 of dPDGs, where a back edge from some $\mathtt{if}$ statement comes into a branch.

As for Condition 2 and 3, we can prove that for all CFGs, their PDGs satisfy them.

Theorem 4.1**.**

A PDG constructed from a CFG satisfies Condition 2 and 3 of Definition 4.12.

Proof.

We prove the claim separately.

Condition 2

In the corresponding PDG, suppose that for statements $p,q$ and $u$ and variable $x$ we have $f_{x}(p,u)\in F\wedge f_{x}(q,u)\in F\wedge\exists r\in\mathit{mca}(p,q).\exists Q\in\{\mathbf{T},\mathbf{F}\}.\{p,q\}\subseteq G^{*}_{Q}(r)$. By the definition of loop-independent data dependence, $u$ is reachable from both $p$ and $q$ in the CFG. By the definition of control dependence, both $p$ and $q$ are reachable from a $\mathbf{T}$-successor of $r$ or a $\mathbf{F}$-successor of $r$. Since $r$ is a mca of $p$ and $q$, $p$ is reachable from $q$ or $q$ is reachable from $p$ in the CFG. Then, by the definition of def-order dependence, we have $\mathit{DefOrd}(p,q)$ or $\mathit{DefOrd}(q,p)$.

Condition 3

In the corresponding PDG, suppose that for statements $p$ and $q$ we have $(p,q)\in F\oplus D$, and for a node $r$ in some loop $R$ in the CDG, we have $p\in G(r)$. By Lemma 4.1 (below), a node in a loop in a CDG is an iteration statement in a loop in the corresponding CFG. Therefore, $r$ is an iteration statement in the CFG. Since $(p,q)\in F\oplus D$, $q$ is reachable from $p$ in the CFG. Moreover since $p\in G(r)$, $p$ is reachable from $r$ in the CFG. Thus, $q$ is also reachable from $r$ in the CFG. Since $r$ is an iteration statement of some loop in the CFG, by Lemma 4.2 (below) we have $q\in G^{*}(r)$.

∎

Lemma 4.1**.**

Let $P$ be a CFG and $G$ be the CDG of the corresponding PDG. A node in a loop in $G$ is an iteration statement in a loop in $P$.

Proof.

Let $p$ and $q$ be nodes in a loop $R^{\prime}$ in $G$. By the definition of the loop, $p$ is reachable from $q$ and vice versa in $G$. Since $p$ and $q$ have outgoing $C$-edges, they are $\mathtt{if}$ statements. By the definition of control dependence, if a node is reachable from another node in $G$, it is also reachable in $P$. Thus, $p$ and $q$ are $\mathtt{if}$ statements in some loop $R$ in $P$. In other words, we showed that a node in a loop in $G$ is contained in some loop in $P$. Then there exists at least one loop iteration statement in $R$ by Definition 4.2. We call it $r$. Let $s\in R^{\prime}$ be a statement such that $(s,r)\in C$. By the definition of control dependence, $s$ is not post-dominated by $r$ in $P$, which implies $s$ has an outgoing edge that comes into a node inside $R$ and one that comes into a node outside $R$. Thus, by the definition of the iteration statement, $s$ is an iteration statement. Since $s$ is an iteration statement, any node $s^{\prime}\in R^{\prime}$ such that $(s^{\prime},s)\in C$ is again an iteration statement by the above argument. Thus, we proved that every node in a loop in $G$ is an iteration statement. ∎

Lemma 4.2**.**

Let $P$ be a CFG and $G$ be the CDG of the corresponding PDG. If $p$ is a statement reachable from some node in a loop $R$ in $P$, then for any iteration statement $r\in R$, we have $p\in G^{*}(r)$.

Proof.

If $p$ is a statement in $R$, we have $p\in G(r^{\prime})$ for some iteration statement $r^{\prime}$ of $R$. If $p$ is not a statement in $R$, by the definition of control dependence, $p\in G^{*}(r^{\prime})$ for some iteration statement $r^{\prime}$ of $R$. Here, by Lemma 4.1, any iteration statement $r$ contained in $R$ is contained in a loop in $G$ that contains $r^{\prime}$. Therefore, we have $r^{\prime}\in G^{*}(r)$ and $p\in G^{*}(r)$ holds. ∎

5 Semantical correspondence between CFG and PDG

In this section, we prove the semantical correspondence between a CFG and its corresponding PDG. Here the important assumption is that the PDG should be a dPDG. Hence, our claim is that if the PDG constructed from a CFG is a dPDG, then the results of the executions of the CFG and the PDG coincide. This is derived from the following two properties:

Property 1

There is the same execution order of statements for both a CFG and its corresponding PDG (Theorem 5.1).

Property 2

In a dPDG, every run starting with the same initial state has the same final state (Theorem 5.2).

By these properties, if a PDG corresponding to a CFG is a dPDG, the execution of the CFG and any execution of the PDG have the same final result.

To prove these theorems, we need a number of lemmata. To make the presentation easy and understandable, we introduce some notations. Hereafter, we write $P=(N,E)$ for a CFG, $G=(N\cup\{\mathit{entry}\},C,F,L,D)$ for the corresponding PDG, $\sigma$ or $\sigma_{i}$ for stores and $s=(\mathit{av},\mathit{ec})$ or $s_{i}=(\mathit{av}_{i},\mathit{ec}_{i})$ for states. If $Q\in\{\mathbf{T},\mathbf{F}\}$, we write $\bar{Q}$ for the negation of $Q$. We write $[i,j]$ for the set of integers from $i$ to $j$ and $(i,j)$ for the set of integers from $i+1$ to $j-1$.

We define a relation that represents a state (i.e., store) of a run of a CFG is ‘equal’ to a state of a run of a PDG. Intuitively, it says that a variable used at node $n$ is the same in $\sigma$ and $\mathit{av}$.

Definition 5.1**.**

Let $\sigma$ be a store and $\mathit{av}$ be an avail. Let $N$ be a set of nodes. For $n\in N$, we write $\mathit{use}(n)$ for the set of variables used in $n$. We define a binary relation $\sigma\approx_{n}\mathit{av}$ as follows:

[TABLE]

We simply write $\sigma\approx\mathit{av}$ for $\forall n\in N.\sigma\approx_{n}\mathit{av}$.

Next, we define a notation that represent reachable and unreachable nodes from some node in a CFG.

Definition 5.2**.**

Let $n\in N$. We define the following sets:

[TABLE]

5.1 Proof of Property 1

The fact that a PDG can execute sentences in the same order as the corresponding CFG is executed means that any statement that should be executed next in the CFG is also executable at the current state of the run of the PDG, that is, it satisfies $\mathit{condCFLD}$ (Lemma 5.7). Therefore our first target is to prove this fact.

When a statement is to be executed next in a CFG run, a statement on which it is loop-independently data-dependent or def-order-dependent should have already been executed, or is contained in the branch of some conditional statement that are not executed. The next two lemmata formally describe this fact. They states that if node $q$ is loop-independently data-dependent or def-order-dependent on $p$, $p$ is not reachable from $q$ in the graph obtained by removing all back edges from the CFG.

Lemma 5.1**.**

For all $p,q\in N$, if $\mathit{LIDD}(p,q)$ holds then $p\in\mathit{UR}(q)$ or $p\in\mathit{UR}^{\prime}(q)-\mathit{UR}(q)$ holds.

Proof.

Since $p\in\mathit{UR}(q)$ or $p\in\mathit{UR}^{\prime}(q)-\mathit{UR}(q)$ implies $p\in\mathit{UR}(q)\cup\mathit{UR}^{\prime}(q)$ and $\mathit{UR}(q)\subseteq\mathit{UR}^{\prime}(q)$, we just need to show $p\in\mathit{UR}^{\prime}(q)$. Suppose that $\mathit{LIDD}(p,q)$ and $p\not\in\mathit{UR}^{\prime}(q)$ hold. $p\not\in\mathit{UR}^{\prime}(q)$ is equivalent to $p\in R^{\prime}(q)$. Thus, $p$ is reachable from $q$ without passing any back edge. Since $\mathit{LIDD}(p,q)$ holds, by the definition of loop-independent data dependence, either i) $q$ is reachable from $p$ and $p$ and $q$ are not contained in the same loop, or ii) if $p$ and $q$ are contained in the same loop then there is a reaching path from $q$ to $p$ that does not contain any back edge. However, both cases contradict to $p\in R^{\prime}(q)$. ∎

Lemma 5.2**.**

For all $p,q\in N$, if $\mathit{DefOrd}(p,q)$ holds then $p\in\mathit{UR}(q)$ or $p\in\mathit{UR}^{\prime}(q)-\mathit{UR}(q)$ holds.

Proof.

It is again sufficient to show $p\in\mathit{UR}^{\prime}(q)$. Suppose $DefOrd(p,q)$ and $p\not\in\mathit{UR}^{\prime}(q)$. $p\not\in\mathit{UR}^{\prime}(q)$ is equivalent to $p\in R^{\prime}(q)$. Thus, $p$ is reachable from $q$ without passing any back edge. Since $\mathit{DefOrd}(p,q)$ holds, by the definition of def-order dependence, either i) $q$ is reachable from $p$ and $p$ and $q$ are not contained in the same loop, ii) $p$ and $q$ are contained in the same loop and $q$ is reachable from $p$ without passing any back edge, or iii) $p$ and $q$ are contained in the same loop, $p$ is reachable from $q$ and vice versa, but only by passing back edges. However, either case contradicts to $p\in R^{\prime}(q)$. ∎

The next lemma states that if a run of a PDG corresponds to a run of the corresponding CFG, then at the current state of the run of the PDG, any loop-independent data dependence and def-order dependence from the statements that are already executed in a run of the CFG are satisfied (i.e., the states of the edges are $\mathit{chk}$).

Lemma 5.3**.**

Suppose that there is a run $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k-1}}}{{\to}}s_{k}$ of $G$ that corresponds to a run $\sigma_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}\sigma_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k-1}}}{{\to}}\sigma_{k}$ of $P$, that is to say, $\forall i.\sigma_{i}\approx_{n_{i}}\mathit{av}_{i}$. If $\sigma_{k}\stackrel{{\scriptstyle n_{k}}}{{\to}}\sigma_{k+1}$, the following holds:

[TABLE]

Proof.

Since $\mathit{UR}(n)\subseteq\mathit{UR}^{\prime}(n)$, the target of the proof can be divided into the following two claims.

[TABLE]

We prove this by induction on $k$.

(Base Case) If $k=0$, the claims hold since $\mathit{UR}(n_{0})=\mathit{UR}^{\prime}(n_{0})=\emptyset$.

(Induction Step)

If $n_{k-1}=(x:=e)$, $n_{k}$ has a unique successor.

1. (a)

If $n_{k}$ and $n_{k-1}$ are not contained in the same loop, we have $\mathit{UR}(n_{k})=\mathit{UR}(n_{k-1})\cup\{n_{k-1}\}$. By the induction hypothesis, we have $\forall p\in\mathit{UR}(n_{k-1}).\forall(p,q)\in F\oplus D.\mathit{ec}_{k-1}(p,q)=\mathit{chk}$. By the definition of $\mathit{udec}$, $\mathit{ec}_{k}(n_{k-1},q)=\mathit{chk}$ and $\forall(p,q)\in F\oplus D.p\neq n_{k-1}\Rightarrow\mathit{ec}_{k}(p,q)=\mathit{ec}_{k-1}(p,q)$. Therefore, claim (1) holds. Since $\mathit{UR}^{\prime}(n_{k})=\mathit{UR}(n_{k})$, claim (2) also holds. 2. (b)

If $n_{k}$ and $n_{k-1}$ are contained in the same loop, $\mathit{UR}(n_{k})=\mathit{UR}(n_{k-1})$. Since $n_{k-1}\not\in\mathit{UR}(n_{k})$, by the induction hypothesis and the definition of $\mathit{udec}$, we have $\forall p\in\mathit{UR}(n_{k}).\forall(p,q)\in F\oplus D\Rightarrow\mathit{ec}_{k}(p,q)=\mathit{chk}$. That is, claim (1) holds. Meanwhile, because $\mathit{UR}^{\prime}(n_{k})=\mathit{UR}^{\prime}(n_{k-1})\cup\{n_{k-1}\}$,

[TABLE]

By the induction hypothesis and the definition of $\mathit{udec}$, we have $\forall p\in\mathit{UR}^{\prime}(n_{k-1})-\mathit{UR}(n_{k-1}).(p,q)\in F\oplus D\Rightarrow\mathit{ec}_{k}(p,q)=\mathit{chk}$. Again by the definition of $\mathit{udec}$, $\forall(n_{k-1},q)\in F\oplus D.\mathit{ec}_{k}(n_{k-1},q)=\mathit{chk}$. This implies claim (2). 2. 2.

If $n_{k-1}=(\mathtt{if}e)$, assume that $\mathcal{E}(e)\sigma_{k-1}=\mathcal{E}_{\mathit{av}}(n_{k-1},e)\mathit{av}_{k-1}=\mathbf{T}$. Suppose $(n_{k-1},p_{t})_{\mathbf{T}}\in E$ and $(n_{k-1},p_{f})_{\mathbf{F}}\in E$. Note that $n_{k}=p_{t}$.

1. (a)

If $n_{k}$ and $n_{k-1}$ are not contained in the same loop, $\mathit{UR}(n_{k})=(\mathit{UR}(n_{k-1})\cup\{n_{k-1}\})\cup(R(p_{f})-R(p_{t}))$. Because $\mathit{UR}^{\prime}(n_{k})=\mathit{UR}(n_{k})$, claim (2) immediately holds. We show claim (1). For a statement $p\in\mathit{UR}(n_{k-1})$, by the induction hypothesis we have $(p,q)\in F\oplus D\Rightarrow\mathit{ec}_{k-1}(p,q)=\mathit{chk}$. Since $n_{k-1}$ is an $\mathtt{if}$ statement, there are no $F$- and $D$-edges from $n_{k-1}$. For a statement $p\in R(p_{f})-R(p_{t})$, if $p\in G_{F}(n_{k-1})-G_{T}(n_{k-1})$ then by the definition of $\mathit{udec}$ we have $\forall p\in G_{F}(n_{k-1})-G_{T}(n_{k-1}).(p,q)\in F\oplus D\Rightarrow\mathit{ec}_{k}(p,q)=\mathit{chk}$. If not, that is to say, $p$ is reachable from $n_{k-1}$ only via a looping edge (i.e., in the CDG $G$), we have $(r,p)\in C-\widehat{C}$ for some $r\in G_{F}(n_{k-1})-G_{T}(n_{k-1})$. Then, by the definition of looping edges, there is $o\neq r$ such that $(o,p)\in C$ and $\exists Q\in\{\mathbf{T},\mathbf{F}\}.n_{k-1}\in G_{Q}(o)$ and $p\in G_{Q}(o)$. By Lemma 5.4, we have $p\in\mathit{UR}^{\prime}(n_{k-1})-\mathit{UR}(n_{k-1})$ and we apply the induction hypothesis. 2. (b)

If $n_{k}$ and $n_{k-1}$ are contained in the same loop, $\mathit{UR}(n_{k})=\mathit{UR}(n_{k-1})$. Therefore, claim (1) holds as in case 1-(b). Meanwhile, we have $\mathit{UR}^{\prime}(n_{k})=\mathit{UR}^{\prime}(n_{k-1})\cup\{n_{k-1}\}\cup(R^{\prime}(p_{f})-R^{\prime}(p_{t}))$. Therefore, $\mathit{UR}^{\prime}(n_{k})-\mathit{UR}(n_{k})=(\mathit{UR}^{\prime}(n_{k-1})-\mathit{UR}(n_{k}))\cup(\{n_{k-1}\}-\mathit{UR}(n_{k}))\cup((R^{\prime}(p_{f})-R^{\prime}(p_{t}))-\mathit{UR}(n_{k}))$. By the induction hypothesis and the definition of $\mathit{udec}$, $\forall p\in\mathit{UR}^{\prime}(n_{k-1})-\mathit{UR}(n_{k})).(p,q)\in F\oplus D\Rightarrow\mathit{ec}_{k}(p,q)=\mathit{chk}$. Furthermore, since $\{n_{k-1}\}-\mathit{UR}(n_{k-1})=\{n_{k-1}\}$ and $n_{k-1}$ is an $\mathtt{if}$ statement, there are no $F$- and $D$-edges from $n_{k-1}$. Finally, since $(R^{\prime}(p_{f})-R^{\prime}(p_{t}))-\mathit{UR}(n_{k})=R^{\prime}(p_{f})-R^{\prime}(p_{t})$, for $p\in R^{\prime}(p_{f})-R^{\prime}(p_{t})$ it is trivial that $p\in G_{F}(n_{k-1})-G_{T}(n_{k-1})$. Thus, by the definition of $\mathit{udec}$, claim (2) holds.

∎

The above lemma will be used to prove that when a PDG is executed in the same order as the corresponding CFG is executed, the statements that should be executed next in the CFG satisfy $\mathit{condF}$ and $\mathit{condD}$ at the current state of the run of the PDG.

Lemma 5.4**.**

Suppose that $p$ is an $\mathtt{if}$ statement and has outgoing looping edges whose label is $Q$. We assume $\exists r\neq p.\exists p^{\prime}\in G_{Q^{\prime}}(r).\{p,p^{\prime}\}\subseteq G_{Q^{\prime}}(r)$. If node $q$ is reachable from $p$ only via a looping edge outgoing from $p$, then $q$ is reachable from $p$ only via a back edge in the CFG $P$.

Proof.

Since $Q$-edges from $p$ in $G$ are looping edges, $G_{Q}(p)$ consists of a loop in $P$. Therefore, there is $q^{\prime}$ in the loop that has an incoming edge from the outside of the loop. The reason why such $q^{\prime}$ exists is because there is $r\neq p$ such that $q^{\prime}\in G_{Q^{\prime}}(r)$. By the definition of the back edge, the edge $(p,q^{\prime})_{Q}\in E$ of $P$ is a back edge of the loop. Now assume that a node $q$ in the loop is reachable from $p$ only via a looping edge outgoing from $p$. That means $q$ is reachable from $q^{\prime}$ by the definition of control dependence. Therefore, $q$ is reachable from $p$ only via the back edge $(p,q^{\prime})_{Q}$. ∎

The next lemma states that if there exists a run of $G$ corresponding to the execution of $P$, the states of the $C$-edges outgoing from the statements in the subgraph of the statement that will be executed next in $P$ are not $\mathit{act}$.

Lemma 5.5**.**

Suppose that there is a run $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k-1}}}{{\to}}s_{k}$ of $G$ that corresponds to a run $\sigma_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}\sigma_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k-1}}}{{\to}}\sigma_{k}$ of $P$, that is to say, $\forall i.\sigma_{i}\approx_{n_{i}}\mathit{av}_{i}$. If $\sigma_{k}\stackrel{{\scriptstyle n_{k}}}{{\to}}\sigma_{k+1}$, then $\forall p\in G^{*}(n_{k}).p\neq n_{k}\Rightarrow\forall c(p,q)\in C.ec_{k}(c(p,q))\neq\mathit{act}$.

Proof.

By induction on $k$.

(Base Case) $k=0$. By the definition of the operational semantics of the PDG, we have $\forall(p,q)\in C.\mathit{ec}_{0}(p,q)=\mathit{act}\Rightarrow p=\mathit{entry}$. If $n_{0}$ is not an $\mathtt{if}$ statement, the claim immediately follows. If $n_{0}$ is an $\mathtt{if}$ statement, by the definition of the augmented CFG, it is not the case that $(\mathit{entry},q)\in C$ for some $q\in G^{*}(n_{0})$. Thus, the claim follows.

(Induction Step) Since the claim trivially follows if $n_{k}$ is not an $\mathtt{if}$ statement, we only consider the case where $n_{k}$ is an $\mathtt{if}$ statement. For some $i<k$, we consider the case where there is $n_{i}$ such that $\mathit{CD}(n_{i},n_{k})\wedge\forall j\in(i,k).\neg\mathit{CD}(n_{j},n_{k})$. For $p\in G^{*}(n_{k})$, since $G^{*}(n_{k})\subseteq G^{*}(n_{i})$, by the induction hypothesis, $\mathit{ec}_{i}(c(p,q))\neq\mathit{act}$. Since node $n_{j}$ for any $j\in(i,k)$ does not have a $C$-edge pointing to a node in $G^{*}(n_{k})$, we have $\mathit{ec}_{k}(c(p,q))=\mathit{ec}_{i}(c(p,q))\neq\mathit{chk}$ by the definition of $\mathit{udec}$. ∎

The next lemma states that if there exists a run of $G$ corresponding to the execution of $P$, the loop-carried data dependence from the statement that will be executed next in $P$ is satisfied.

Lemma 5.6**.**

Suppose that there is a run $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k-1}}}{{\to}}s_{k}$ of $G$ that corresponds to a run $\sigma_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}\sigma_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k-1}}}{{\to}}\sigma_{k}$ of $P$, that is to say, $\forall i.\sigma_{i}\approx_{n_{i}}\mathit{av}_{i}$. If $\sigma_{k}\stackrel{{\scriptstyle n_{k}}}{{\to}}\sigma_{k+1}$, then $\forall l(n_{k},q)\in L.\mathit{ec}_{k}(l(n_{k},q))=\mathit{chk}$.

Proof.

If $(n_{k},q)\in L$, by the definition of the loop-carried data dependence, $n_{k}$ and $q$ reside in the same loop and every reaching path from $n_{k}$ to $q$ passes a back edge of the loop. Suppose that $p\in\mathit{mca}(n_{k},q)$ be the last executed minimal common ancestor of $n_{k}$ and $q$. If $q$ was executed during the execution from $p$ to $n_{k}$, the state of $l(n_{k},q)$ turned to be $\mathit{chk}$ according to $\mathit{udec}$. Let $o$ be an arbitrary $\mathtt{if}$ statement executed after $q$’s execution. Then we have $\forall Q\in\{\mathbf{T},\mathbf{F}\}.\{q,n_{k}\}\not\in G_{Q}(o)$. Otherwise, $o$ should have been the last executed minimal common ancestor of $q$ and $n_{k}$. Therefore, if $n_{k}\not\in G(o)$, the state of $l(n_{k},o)$ will not be changed by the execution of $o$. Meanwhile, if we assume $n_{k}\in G_{T}(o)$ (the case of $G_{F}(o)$ is the same), since $n_{k}$ will be executed, the condition of $o$ was evaluated to $\mathbf{T}$. Thus, by the definition of $\mathit{udec}$, the state of $l(n_{k},q)$ will not be changed. As a consequence, we have $\mathit{ec}_{k}(l(n_{k},q))=\mathit{chk}$. If $q$ is not executed during the execution from $p$ to $n_{k}$, there is an $\mathtt{if}$ statement $o$ such that $q\in G(o)$ (note that $o$ may coincide with $p$). If we assume $q\in G_{T}(o)$ (the case of $G_{F}(o)$ is the same), since $q$ was not executed, the condition of $o$ had been evaluated to $\mathbf{F}$ and $q\in G_{F}(o)-G_{T}(o)$. By the same argument as above, we have $\forall Q\in\{\mathbf{T},\mathbf{F}\}.\{q,n_{k}\}\not\in G_{Q}(o)$. By the definition of $\mathit{udec}$, the state of $l(n_{k},q)$ turned to be $\mathit{chk}$ after $o$ was executed. As for the $\mathtt{if}$ statements that will be executed after that, the same argument applies as above and the state of $l(n_{k},q)$ will be unchanged. Thus, we have $\mathit{ec}_{k}(l(n_{k},q))=\mathit{chk}$. ∎

This lemma will be used to show that the statement to be executed next in a run of the CFG satisfies $\mathit{condL}$ in the current state of the run of the PDG.

By using the lemmata 5.3, 5.5 and 5.6, we can show that there is a run of $G$ that has the same execution order as that of $P$.

Lemma 5.7**.**

Suppose that there is a run $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k-1}}}{{\to}}s_{k}$ of $G$ that corresponds to a run $\sigma_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}\sigma_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k-1}}}{{\to}}\sigma_{k}$ of $P$, that is to say, $\forall i.\sigma_{i}\approx_{n_{i}}\mathit{av}_{i}$. If $\sigma_{k}\stackrel{{\scriptstyle n_{k}}}{{\to}}\sigma_{k+1}$, then $n_{k}\in\mathit{Next}(s_{k})$.

Proof.

We show that $\mathit{condCFLD}(s_{k},n_{k})$ is the case.

Proof of $\mathit{condC}(s_{k},n_{k})$.

The predicate $\mathit{condC}(s_{k},n_{k})$ is divided as the following two conjuncts:

[TABLE]

In the following, we prove them individually.

• •

If $n_{k-1}$ is not an $\mathtt{if}$ statement, since $n_{k-1}\in\mathit{Next}(s_{k-1})$, there is an $\mathtt{if}$ statement $q$ such that $\mathit{ec}_{k-1}(c(q,n_{k-1}))=\mathit{act}$. Since $n_{k}$ is the unique successor of $n_{k-1}$, $\exists Q\in\{\mathbf{T},\mathbf{F}\}.\{n_{k-1},n_{k}\}\subseteq G_{Q}(q)$. Therefore, we have $\mathit{ec}_{k-1}(c(q,n_{k}))=\mathit{act}$. Since the execution of $n_{k-1}$ does not change the state of $c(q,n_{k})$ by the definition of $\mathit{udec}$, we have $\mathit{ec}_{k}(c(q,n_{k}))=\mathit{act}$. If $n_{k-1}$ is an $\mathtt{if}$ statement111Here we assume that $n_{k-1}$ has successors $n_{k}$ and the one different from $n_{k}$. Otherwise the above argument applies., $c(n_{k-1},n_{k})\in C$. Since $\sigma_{k}\stackrel{{\scriptstyle n_{k}}}{{\to}}\sigma_{k+1}$ and $\sigma_{k}(e)=\mathcal{E}(n_{k},e)\mathit{av}_{k}$, we have $\mathit{ec}_{k}(c(n_{k},p))=\mathit{act}$ by the definition of $\mathit{udec}$. Thus, conjunct (3) follows.

• •

By Lemma 5.5, conjunct (4) follows.

Proof of $\mathit{condF}(s_{k},n_{k})$.

For all $f(p,n_{k})\in F$, by Lemma 5.1, $p\in\mathit{UR}(n_{k})$ or $p\in\mathit{UR}^{\prime}(n_{k})-\mathit{UR}(n_{k})$ holds. Then, by Lemma 5.3, we have $\mathit{ec}_{k}(f(p,n_{k}))=\mathit{chk}$ and the claim follows.

Proof of $pcondD(s_{k},n_{k})$.

For all $d(p,n_{k})\in F$, by Lemma 5.2, $p\in\mathit{UR}(n_{k})$ or $p\in\mathit{UR}^{\prime}(n_{k})-\mathit{UR}(n_{k})$ holds. Then, by Lemma 5.3, we have $\mathit{ec}_{k}(f(p,n_{k}))=\mathit{chk}$ and the claim follows.

Proof of $\mathit{condL}(s_{k},n_{k})$.

It immediately follows from Lemma 5.6.

∎

By this lemma, the following important theorem is proved. This theorem states that for any run of $P$ there is a corresponding run of $G$.

Theorem 5.1**.**

Suppose $\sigma_{0}\approx\mathit{av}_{0}$. For a run $\sigma_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}\sigma_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k}}}{{\to}}\sigma_{k+1}$ of $P$, there is a run $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k}}}{{\to}}s_{k+1}$ of $G$ that satisfies $\forall i\in[0,k].\sigma_{i}\approx_{n_{i}}\mathit{av}_{i}$.

Proof.

By induction on $k$ .

(Base Case) $k=0$. For a run $\sigma_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}\sigma_{1}$ of $P$, since we know $\sigma_{0}\approx\mathit{av}_{0}$ by the assumption, $n_{0}\in\mathit{Next}(s_{0})$ follows by Lemma 5.7. Henceforth, there is a run $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}$ of $G$. Moreover, by the assumption we have $\sigma_{0}\approx_{n_{0}}\mathit{av}_{0}$.

(Induction Step) By the induction hypothesis, for $P$’s run $\sigma_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}\sigma_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k}}}{{\to}}\sigma_{k+1}$, there is a $G$’s run $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k}}}{{\to}}s_{k+1}$ that satisfies $\forall i\in[0,k].\sigma_{i}\approx_{n_{i}}\mathit{av}_{i}$. Suppose that $\sigma_{k+1}\stackrel{{\scriptstyle n_{k+1}}}{{\to}}\sigma_{k+2}$. By Lemma 5.7, we have $n_{k+1}\in\mathit{Next}(s_{k+1})$. Thus, there is a $G$’s run $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{k}}}{{\to}}s_{k+1}\stackrel{{\scriptstyle n_{k+1}}}{{\to}}s_{k+2}$. We then show $\sigma_{k+1}\approx_{n_{k+1}}\mathit{av}_{k+1}$, that is to say, $\forall x\in\mathit{use}(n_{k+1}).\sigma_{k+1}=\mathit{av}_{k+1}(n_{k+1},x)$. For $x\in\mathit{use}(n_{k+1})$, if an assignment statement defining $x$ is executed between $n_{0}$ and $n_{k}$, then let the last one among such statements be $n_{j}=(x:=e)$. Then we have $(n_{j},n_{k+1})\in F\oplus L$. By the definition of $\mathit{udav}$, $\mathit{av}_{k+1}(n_{k+1},x)=\mathcal{E}(n_{j},e)\mathit{av}_{j}$ holds. Since we have $\sigma_{j}\approx_{n_{j}}\mathit{av}_{j}$ by the induction hypothesis, $\mathcal{E}(e)\sigma_{j}=\mathcal{E}(n_{j},e)\mathit{av}_{j}$ follows. Meanwhile, by the operational semantics of the CFG, we have $\sigma_{j+1}(x)=\mathcal{E}(e)\sigma_{j}$. Hence, $\sigma_{j+1}(x)=\mathit{av}_{j+1}(n_{k+1},x)$. Since no assignment statements defining $x$ are executed between $n_{j}$ and $n_{k-1}$, we have $\sigma_{j+1}(x)=\sigma_{k+1}(x)$ and $\mathit{av}_{j+1}(n_{k+1},x)=\mathit{av}_{k+1}(n_{k+1},x)$. Therefore, $\sigma_{k+1}(x)=\mathit{av}_{k+1}(n_{k+1},x)$ follows. If no assignment statements defining $x$ are executed between $n_{0}$ and $n_{k}$, then we have $\sigma_{k+1}(x)=\sigma_{0}(x)$ and $\mathit{av}_{k+1}(n_{k+1},x)=\mathit{av}_{0}(n_{k+1},x)$. Since $\sigma_{0}\approx\mathit{av}_{0}$ from the assumption, $\sigma_{k+1}(x)=\mathit{av}_{k+1}(n_{k+1},x)$ follows. ∎

5.2 Proof of Property 2

Next we prove Property 2. Property 2 says that all runs of a dPDG starting with the same initial state end with the same final state (if they terminate). This property is derived from confluence of the runs of a dPDG (Lemma 5.17) which says if there are multiple executable statements in a run of a dPDG, the order of execution does not change the final result. This property is proved by the fact that an execution of a statement does not affect executability and the execution results of the other statements that are simultaneously executable in the dPDG (Lemma 5.10, 5.11, 5.13 and 5.15). Other lemmata are used to prove the above lemmata or Theorem 5.2.

The next lemma states that two executable nodes at a run of a PDG are contained in the subgraph of the same truth value of some $\mathtt{if}$ statement.

Lemma 5.8**.**

Let $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots$ be a run of a PDG. Suppose $c(o_{1},p)\in C$, $c(o_{2},q)\in C$, $p\not\in G^{*}(q)$ and $q\not\in G^{*}(p)$. For any $i$, if $\mathit{ec}_{i}(o_{1},p)=\mathit{ec}_{i}(o_{2},q)=\mathit{act}$ then $\exists r\in\mathit{mca}(p,q).\exists Q\in\{\mathbf{T},\mathbf{F}\}.\{p,q\}\subseteq G^{*}_{Q}(r)$.

Proof.

By induction on $i$.

(Base Case) If $i=0$, $o_{1}=o_{2}=\mathit{entry}$. Obviously, $\{p,q\}\subseteq G_{T}(\mathit{entry})$. Since $\mathit{mca}(p,q)=\{\mathit{entry}\}$, the claim holds.

(Induction Step)

If $\mathit{ec}_{i-1}(o_{1},p)=\mathit{ec}_{i-1}(o_{2},q)=\mathit{act}$, by the induction hypothesis the claim holds. 2. 2.

If $\mathit{ec}_{i-1}(o_{1},p)\neq\mathit{act}$ and $\mathit{ec}_{i-1}(o_{2},p)\neq\mathit{act}$, then by the definition of $\mathit{udec}$ and $\mathit{condC}$, $o_{1}=o_{2}=n_{i-1}$ and $\exists Q\in\{\mathbf{T},\mathbf{F}\}.\{p,q\}\subseteq G_{Q}^{*}(n_{i-1})$ must be the case. Here suppose $n_{i-1}\not\in\mathit{mca}(p,q)$, then in the CDG either $p$ or $q$ must lie on a path from $\mathit{entry}$ to $n_{i-1}$. This contradicts to either $q\in G^{*}(p)$ or $p\in G^{*}(q)$. Henceforth, $n_{i-1}\in\mathit{mca}(p,q)$. 3. 3.

If $\mathit{ec}_{i-1}(o_{1},p)=\mathit{act}$ and $\mathit{ec}_{i-1}(o_{2},p)\neq\mathit{act}$, then $n_{i-1}=o_{2}$ and must be some $(o,o_{2})\in C$ such that $\mathit{ec}_{i-1}(o,o_{2})=\mathit{act}$ by the definition of $\mathit{udec}$ and $\mathit{condC}$. By the induction hypothesis, there is $r_{1}\in\mathit{mca}(p,o_{2})$ and $Q\in\{\mathbf{T},\mathbf{F}\}$ such that $\{p,o_{2}\}\subseteq G^{*}_{Q}(r_{1})$. Since $(o_{2},q)\in C$, we have $\{p,q\}\subseteq G^{*}_{Q}(r_{1})$. If we assume that $r_{1}\not\in\mathit{mca}(p,q)$, either $p$ or $q$ must lie on a path from $\mathit{entry}$ to $r_{1}$ in the CDG. This contradicts to either $q\in G^{*}(p)$ or $p\in G^{*}(q)$. Henceforth, $n_{i-1}\in\mathit{mca}(p,q)$.

∎

Lemma 5.9**.**

Let $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots$ be a run of a PDG. For any $p$ and $q$ ($p\neq q$), if $\{p,q\}\subseteq\mathit{Next}(s_{i})$, then $p\not\in G^{*}(q)$ and $q\not\in G^{*}(p)$.

Proof.

$p\in G^{*}(q)$ contradicts to the second conjunct of the predicate $\mathit{condC}$. $q\in G^{*}(p)$ does the same. ∎

Lemma 5.10**.**

Let $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots$ be a run of a PDG. For any $p$ and $q$ ($p\neq q$), if $\{p,q\}\subseteq\mathit{Next}(s_{i})$ then there are no $F$- and $L$-edges between $p$ and $q$.

Proof.

We split the proof into the following cases.

• •

Let $(p,q)\in F$. Since $p\in\mathit{Next}(s_{i})$, there is $(o,p)\in C$ such that $\mathit{ec}_{i}(o,p)=\mathit{act}$. Therefore, there is some $j<i$ such that $n_{j}=o$ and $\forall k\in(j,i).\mathit{ec}_{k}(o,p)=\mathit{act}$ (this implies $p$ is not executed between $s_{j}$ and $s_{i}$). By the definition of $\mathit{udec}$, $\mathit{ec}_{j+1}(f(p,q))=\mathit{unchk}$. Furthermore, by the definition of $\mathit{condC}$, we have $\forall k\in(j,i).p\not\in G(n_{k})$ since $\mathit{ec}_{k}(o,p)=\mathit{act}$. Therefore, $\mathit{ec}_{i}(f(p,q))=\mathit{ec}_{j+1}(f(p,q))=\mathit{unchk}$. This contradicts to $q\in Next(s_{i})$.

• •

Let $(p,q)\in L$. Since $q\in\mathit{Next}(s_{i})$, there is $(o,q)\in C$ such that $\mathit{ec}_{i}(o,q)=\mathit{act}$. Therefore, there is some $j<i$ such that $n_{j}=o$ and $\forall k\in(j,i).\mathit{ec}_{k}(o,q)=\mathit{act}$ (this implies $q$ is not executed between $s_{j}$ and $s_{i}$). By the definition of $\mathit{udec}$, $\mathit{ec}_{j+1}(l(p,q))=\mathit{unchk}$. Furthermore, by the definition of $\mathit{condC}$, we have $\forall k\in(j,i).q\not\in G(n_{k})$ since $\mathit{ec}_{k}(o,q)=\mathit{act}$. Therefore, $\mathit{ec}_{i}(l(p,q))=\mathit{ec}_{j+1}(l(p,q))=\mathit{unchk}$. This contradicts to $p\in Next(s_{i})$.

• •

The proofs of the cases for $(q,p)\in F$ and $(q,p)\in L$ are the same as above.

∎

Lemma 5.11**.**

Let $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots$ be a run of a deterministic PDG. For any $p$ and $q$ ($p\neq q$), if $f_{x}(p,n)\in F$ and $f_{x}(q,n)\in F$ for some $n$, then $\{p,q\}\not\subseteq\mathit{Next}(s_{i})$ holds.

Proof.

Suppose $\{p,q\}\subseteq\mathit{Next}(s_{i})$. Since $p$ and $q$ are assignment statements, we know $p\not\in G^{*}(q)$ and $q\not\in G^{*}(p)$. By Lemma 5.8, there must be some $r\in\mathit{mca}(p,q)$ and $Q\in\{\mathbf{T},\mathbf{F}\}$ such that $\{p,q\}\subseteq G^{*}_{Q}(r)$. Then, by the condition of the dPDG, either $d(p,q)\in D$ or $d(q,p)\in D$ holds. We consider the case $d(p,q)\in D$. Since $p\in\mathit{Next}(s_{i})$, there is $(o,p)\in C$ such that $\mathit{ec}_{i}(o,p)=\mathit{act}$. Therefore, there is some $j<i$ such that $n_{j}=o$ and $\forall k\in(j,i).\mathit{ec}_{k}(o,p)=\mathit{act}$ (this implies $p$ is not executed between $s_{j}$ and $s_{i}$). By the definition of $\mathit{udec}$, $\mathit{ec}_{j+1}(d(p,q))=\mathit{unchk}$. Furthermore, by the definition of $\mathit{condC}$, we have $\forall k\in(j,i).p\not\in G(n_{k})$ since $\mathit{ec}_{k}(o,p)=\mathit{act}$. Therefore, $\mathit{ec}_{i}(d(p,q))=\mathit{ec}_{j+1}(d(p,q))=\mathit{unchk}$. This contradicts to $q\in Next(s_{i})$. ∎

Lemma 5.12**.**

If $o\in G^{*}(p)$ and $p\not\in G^{*}(q)$ and $q\not\in G^{*}(p)$, then $\mathit{mca}(p,q)\subseteq\mathit{mca}(o,q)$ holds.

Proof.

Since CDGs are connected and $\mathit{entry}$ is the root, there is a non-cyclic path $\pi=\mathit{entry}\dots r$ in the CDG. Suppose $r\in\mathit{mca}(p,q)$. By the definition of the mca, we have two non-cyclic paths $\pi_{1}=\pi\dots p$ and $\pi_{2}=\pi\dots q$. Since $o\in G^{*}(p)$, there is a non-cyclic path $\pi_{3}=\pi_{1}\dots o$. Here since the longest common prefix of $\pi_{1}$ and $\pi_{2}$ is $\pi$, and $q\not\in G^{*}(p)$ and $p\not\in G^{*}(q)$, we have $r\neq p$ and $r\neq q$. Therefore, the longest common prefix of $\pi_{2}$ and $\pi_{3}$ is $\pi$. This shows $r\in\mathit{mca}(o,q)$. ∎

The next lemma states that for a run of a dPDG, if there are two executable statements, the execution of one node does not affect the condition $\mathit{condC}$ of the other.

Lemma 5.13**.**

Let $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots$ be a run of a dPDG. For any $p$ and $q(p\neq q)$, we assume $\{p,q\}\subseteq\mathit{Next}(s_{i})$. If $s_{i}\stackrel{{\scriptstyle q}}{{\to}}s_{i+1}$, the following holds:

[TABLE]

Proof.

Suppose that claim (5) is violated by the execution of $q$. By the definition of $\mathit{udec}$, there exists some $r\in G^{*}(p)$ such that $(q,r)\in C$. Since $\{p,q\}\subseteq\mathit{Next}(s_{i})$, by Lemma 5.9, we have $p\not\in G^{*}(q)$ and $q\not\in G^{*}(p)$. By Lemma 5.8, there exists some $u\in\mathit{mca}(p,q)$ and $Q\in\{\mathbf{T},\mathbf{F}\}$ such that $\{p,q\}\subseteq G_{Q}^{*}(u)$. Meanwhile, since $r\in G^{*}(p)$ and $(q,r)\in C$, there exists some $o\in G^{*}(p)-G^{*}(q)$ such that $r\in G^{*}(o)$. That is to say, we have $r\in G^{*}(o)$ and $r\in G^{*}(q)$. This implies $\forall v\in\mathit{mca}(o,q).\forall Q\in\{\mathbf{T},\mathbf{F}\}.\{o,q\}\not\subseteq G_{Q}^{*}(v)$ from the first condition of the dPDG. However, by Lemma 5.12, we have $u\in\mathit{mca}(p,q)\subseteq\mathit{mca}(o,q)$ which leads to contradiction. ∎

Lemma 5.14**.**

Let $s_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots$ be a run of a dPDG and $q\in\mathit{Next}(s_{i})$. For $o\in G(q)$ such that $(o,p)\in F\oplus D$, we assume $\mathit{ec}_{i}(o,p)=\mathit{chk}$. Then $q$ has an outgoing looping edge.

Proof.

We assume that all $C$-edges from $q$ are not looping edges. Since $q\in\mathit{Next}(s_{i})$, there is $(r,q)\in C$ such that $\mathit{ec}_{i}(r,q)=\mathit{act}$. Therefore, there is some $j<i$ such that $n_{j}=r$ and $\forall k\in(j,i).\mathit{ec}_{k}(r,q)=\mathit{act}$. Suppose $q\in G_{T}(r)$ (the case of $G_{F}(r)$ is the same) D Since $C$-edges from $q$ are not looping edges, we have $G(q)\subseteq G_{T}(r)$. Therefore, $\forall o\in G(q).\forall(o,p)\in F\oplus D.\mathit{ec}_{j+1}(o,p)=\mathit{unchk}$ by the definition of $\mathit{udec}$. Since $r\in\mathit{Next}(s_{j})$, there are no $C$-edges pointing to a node in $G(r)$ whose states are $\mathit{act}$ at state $s_{j}$. Moreover, since $G(q)\subseteq G_{T}(r)$, there are no $C$-edges pointing to a node in $G(q)$ whose states are $\mathit{act}$ at state $s_{j+1}$. Thus, $q\in\mathit{Next}(s_{j+1})$. If $s_{j+1}\stackrel{{\scriptstyle v}}{{\to}}s_{j+2}$ (i.e., $\{q,v\}\subseteq\mathit{Next}(s_{j+1})$), by applying Lemma 5.13 we have $\forall o\in G^{*}(q).o\neq q\Rightarrow\forall(w,o)\in C.\mathit{ec}_{j+2}(w,o)\neq\mathit{act}$. By repeating this argument, we have $\forall o\in G^{*}(q).\forall(w,o)\in C.\mathit{ec}_{k}(w,o)\neq\mathit{act}$ for any $k\in(j,i]$. That is to say, no $o\in G(p)$ is executed between $s_{j}$ and $s_{i}$. Therefore, $\forall o\in G(q).\forall(o,p)\in F\oplus D.\mathit{ec}_{i}(o,p)=\mathit{ec}_{j+1}(o,p)=\mathit{unchk}$, which leads to contradiction. ∎

The next lemma states that if there are multiple executable statements in a run of a dPDG, execution of one statement does not interfere with executability of the other statements.

Lemma 5.15**.**

Let $s$ be a state in a run of a dPDG. For all $p,q\in\mathit{Next}(s)$ such that $p\neq q$, if $s\stackrel{{\scriptstyle q}}{{\to}}s^{\prime}$, then $p\in\mathit{Next}(s^{\prime})$ holds.

Proof.

We show $\mathit{condCFLD}(s^{\prime},p)$ holds. We divide the proof by the type of $q$.

If $q$ is an assignment statement, the change of the econf caused by the execution of $q$ does not affect the value of the predicates $\mathit{condC}$, $\mathit{condF}$ and $\mathit{condD}$. Moreover, by Lemma 5.10, $\{p,q\}\subseteq\mathit{Next}(s)$ implies that there are no $L$-edges between $p$ and $q$. Therefore we have $\mathit{condCFLD}(s^{\prime},p)$ and $p\in\mathit{Next}(s^{\prime})$. 2. 2.

Suppose $q$ is an $\mathtt{if}$ statement ($\mathtt{if}e$). We prove each condition individually.

Proof of $\mathit{condC}(s^{\prime},p)$.

Since $\mathit{condC}(s,p)$ holds, there is $(o,p)\in C$ that satisfies $\mathit{ec}(o,p)=\mathit{act}$. If the execution of $q$ brings $\mathit{ec}^{\prime}(o,p)\neq\mathit{act}$, then $o\in G(q)$ by the definition of $\mathit{udec}$. This, however, contradicts to $\mathit{condC}(s,q)$ since it implies $p\in G^{*}(q)$. Therefore, the first conjunct of $\mathit{condC}(s^{\prime},p)$ holds. The second conjunct follows from Lemma 5.13.

Proof of $\mathit{condF}(s^{\prime},p)$.

Assume that the execution of $q$ causes violation of $\mathit{condF}(s^{\prime},p)$. We consider the case $\mathcal{E}(q,e)\mathit{av}=\mathbf{T}$ (The case of $\mathbf{F}$ is the same). By the definition of $\mathit{udec}$, there must be some $r\in G_{T}(q)-\{q\}$ such that $(r,p)\in F$ and $\mathit{ec}(r,p)=\mathit{chk}$222Note that $q$’s execution brings $\mathit{ec}^{\prime}(r,p)=\mathit{unchk}$, thus $p$ becomes unexecutable at state $s^{\prime}$.. Thus, by Lemma 5.14, $q$ has outgoing looping edges. That is, $q$ is contained in some loop in the CDG by the definition of looping edges. By the third condition of the dPDG, then, $p\in G^{*}(q)$ is the case, which contradicts to $\mathit{condC}(s,q)$.

Proof of $\mathit{condD}(s^{\prime},p)$.

The same as the proof of $\mathit{condF}(s^{\prime},p)$.

Proof of $\mathit{condL}(s^{\prime},p)$.

Assume that the execution of $q$ causes violation of $\mathit{condL}(s^{\prime},p)$. That is, for some $l(p,r)\in L$, $\mathit{ec}^{\prime}(l(p,r))=\mathit{unchk}$. We consider the case $\mathcal{E}(q,e)\mathit{av}=\mathbf{T}$ (The case of $\mathbf{F}$ is the same). By the definition of $\mathit{udec}$, we have $r\in G_{T}(q)-\{q\}$ and $p\in G_{T}(q)$. This contradicts to $\mathit{condC}(s,q)$.

∎

Lemma 5.16**.**

Let $s$ be a state of a run of a dPDG. If $\{p,q\}\subseteq\mathit{Next}(s)$, then $G(p)\cap G(q)=\emptyset$ holds.

Proof.

Assume $G(p)\cap G(q)\neq\emptyset$. Since $\{p,q\}\subseteq\mathit{Next}(s)$, we have $p\not\in G^{*}(q)$ and $q\not\in G^{*}(p)$ by Lemma 5.9. Thus, for some $o_{1}\in G(p)-G(q)$ and $o_{2}\in G(q)-G(p)$, there is $o\in G(p)\cap G(q)$ such that $(o_{1},o)\in C$ and $(o_{2},o)\in C$. Since $\{p,q\}\subseteq\mathit{Next}(s)$, there is $r\in\mathit{mca}(p,q)$ and $Q\in\{\mathbf{T},\mathbf{F}\}$ such that $\{p,q\}\subseteq G_{Q}^{*}(r)$ by Lemma 5.8. Since $o_{1}\in G(p)-G(q)$ and $o_{2}\in G(q)-G(p)$, we have $o_{1}\not\in G^{*}(q)$ and $o_{2}\not\in G^{*}(p)$. By applying Lemma 5.12 twice, we have $r\in\mathit{mca}(o_{1},o_{2})$ which implies $\{o_{1},o_{2}\}\subseteq G_{Q}^{*}(r)$. This contradicts to the first condition of the dPDG. ∎

The next lemma states that if there are two executable statements, the final result of the execution of them are independent of the execution order.

Lemma 5.17**.**

Let $s$ be a state of a run of a dPDG. If $\{p,q\}\subseteq\mathit{Next}(s)$, the following holds:

[TABLE]

Proof.

Suppose $s\stackrel{{\scriptstyle p}}{{\to}}s_{1}\stackrel{{\scriptstyle q}}{{\to}}s_{2}$ and $s\stackrel{{\scriptstyle q}}{{\to}}s_{1}^{\prime}\stackrel{{\scriptstyle p}}{{\to}}s_{2}^{\prime}$. We split the proof by the type of $p$ and $q$.

Both $p$ and $q$ are respectively assignment statements $x:=e_{1}$ and $y:=e_{2}$. Since the execution order of $p$ and $q$ do not change the final result of the econf, we have $\mathit{ec}_{2}=\mathit{ec}_{2}^{\prime}$. If $x\neq y$, we can easily see $\mathit{av}_{2}=\mathit{av}_{2}^{\prime}$ by the definition of $\mathit{udav}$. We consider the case $x=y$. If there exists $u$ such that $f_{x}(p,u)\in F$ and $f_{x}(q,u)\in F$, it should be $\{p,q\}\not\subseteq\mathit{Next}(s)$ by Lemma 5.11 and leads to contradiction. Therefore, $\{n~{}|~{}(p,n)\in F\oplus L\}\cap\{n~{}|~{}(q,n)\in F\oplus L\}=\emptyset$. By Lemma 5.10 we have $(p,q)\not\in F\oplus L$ and $(q,p)\not\in F\oplus L$, which yields $\mathit{av}_{2}=\mathit{av}_{2}^{\prime}$. 2. 2.

$p$ is an assignment statement $x:=e_{1}$ and $q$ is an $\mathtt{if}$ statement $\mathtt{if}e_{2}$. By Lemma 5.9, we have $p\not\in G^{*}(q)$, and thus $\mathit{ec}_{2}=\mathit{ec}_{2}^{\prime}$. Furthermore, we have the following:

[TABLE]

Since $\mathit{av}_{1}^{\prime}=\mathit{av}$, and $(p,q)\not\in F\oplus L$ holds by Lemma 5.10, we conclude $\mathit{av}_{2}=\mathit{av}_{2}^{\prime}$. 3. 3.

Both $p$ and $q$ are respectively $\mathtt{if}$ statements $\mathtt{if}e_{1}$ and $\mathtt{if}e_{2}$. By the definition of $\mathit{udav}$, we obviously have $\mathit{av}_{2}=\mathit{av}_{2}^{\prime}$. By Lemma 5.9, we have $p\not\in G^{*}(q)$ and $q\not\in G^{*}(p)$. By Lemma 5.16, we have $G(p)\cap G(q)=\emptyset$. Therefore, we conclude $\mathit{ec}_{2}=\mathit{ec}_{2}^{\prime}$.

∎

By the above lemmata, we finally prove the following theorem, which states that executions of a dPDG reach the same final sate regardless of execution orders of statements.

Theorem 5.2**.**

Let $s$ be a state of a run of a dPDG. If there is a finite run $s\stackrel{{\scriptstyle n}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{m}}}{{\to}}s_{m}$, all runs from state $s$ have the length $m+1$ and end with $s_{m}$.

Proof.

By induction on $m$.

(Base) The claim is trivial for $m=0$.

(Induction) Suppose that there is a run $s\stackrel{{\scriptstyle p}}{{\to}}s_{1}\stackrel{{\scriptstyle}}{{\to}}\dots\stackrel{{\scriptstyle}}{{\to}}s_{m}$ of the length $m+1$ starting with $s$. Suppose $\mathit{Next}(s)=\{p,p_{0},\dots,p_{j}\}$. By Lemma 5.15, we have $\{p_{0},\dots,p_{j}\}\subseteq\mathit{Next}(s_{1})$. Since we have a run $s_{1}\stackrel{{\scriptstyle}}{{\to}}\dots\stackrel{{\scriptstyle}}{{\to}}s_{m}$ starting from $s_{1}$ whose length is $m$, all runs from state $s_{1}$ have the length $m$ and end with $s_{m}$ by the induction hypothesis. Therefore, for all $i\in[0,j]$, there is a finite run $s_{1}\stackrel{{\scriptstyle p_{i}}}{{\to}}s_{2}^{i}\to\dots\to s_{m}$ of the length $m$. Since we have $s_{0}\stackrel{{\scriptstyle p}}{{\to}}s_{1}\stackrel{{\scriptstyle p_{i}}}{{\to}}s_{2}^{i}$ by Lemma 5.17, there is $s_{1}^{i}$ such that $s_{0}\stackrel{{\scriptstyle p_{i}}}{{\to}}s_{1}^{i}\stackrel{{\scriptstyle p}}{{\to}}s_{2}^{i}$. This implies there is a run starting with $s_{1}^{i}$, ending with $s_{m}$ and whose length is $m$. By the induction hypothesis, all runs from state $s_{1}^{i}$ have the length $m$ and end with $s_{m}$. Since $i$ is arbitrary, all runs from $s$ have the length $m+1$ and end with $s_{m}$. ∎

5.3 Equivalence of the operational semantics of CFG and PDG

Finally, we arrive at the equivalence of the operational semantics of the CFG and the PDG.

Theorem 5.3**.**

Let $P$ be a CFG and $G$ be the corresponding PDG. Suppose $\sigma_{0}\approx\mathit{av}_{0}$ and $G$ is a dPDG. If there is a finite run $\sigma_{0}\stackrel{{\scriptstyle n_{0}}}{{\to}}\sigma_{1}\stackrel{{\scriptstyle n_{1}}}{{\to}}\dots\stackrel{{\scriptstyle n_{m}}}{{\to}}\sigma_{m}$ of $P$ where $n_{m}=(\mathtt{ret}~{}x)$, there is a finite run $s_{0}\stackrel{{\scriptstyle n_{0}^{\prime}}}{{\to}}s_{1}\stackrel{{\scriptstyle n_{1}^{\prime}}}{{\to}}\dots\stackrel{{\scriptstyle n_{m}^{\prime}}}{{\to}}s_{m}$ of $G$ and $\sigma_{m}(x)=\mathit{av}_{m}(n_{m},x)$.

Proof.

By Theorem 5.1 and 5.2. ∎

6 Conclusion

In this paper, we proposed an operational semantics of the PDG that applies even to unstructured programs. In our operational semantics, a PDG has the same execution sequence as the corresponding CFG (Theorem 5.1). We identified the class of deterministic PDGs (dPDGs) and proved that every run of a dPDG starting with the same initial state end with the same final state (Theorem 5.2). These facts lead to the semantical equivalence between the CFG and the PDG (Theorem 5.3).

We expect that our operational semantics will be used to formally discuss correctness of program optimisation techniques based on PDG transformations. Since optimised PDGs should be translated into CFGs, there are some algorithms that translate PDGs into CFGs [14, 15, 17]. However, there are cases where optimised PDGs do not have corresponding CFGs. Thus, those algorithms duplicate some nodes or insert artificial conditional statements. Nevertheless, correctness of such transformations are not formally proved. One possible reason is that such PDGs are usually not well-structured and the existing PDG semantics cannot be applied. Since our semantics can be applied to such programs, it will be helpful to prove the correctness of such algorithms.

Another interesting research direction is to prove semantical equivalence between concurrent programs and PDGs. This enables to formally discuss correctness of algorithms that construct concurrent programs from PDGs.