From c1b27a13ae2525785746ac6a05bb263a95afccf7 Mon Sep 17 00:00:00 2001 From: Danila Fedorin Date: Sun, 1 Dec 2024 22:16:02 -0800 Subject: [PATCH] Add a draft post on forward analysis Signed-off-by: Danila Fedorin --- content/blog/00_spa_agda_intro.md | 3 +- content/blog/01_spa_agda_lattices.md | 1 + content/blog/08_spa_agda_forward/index.md | 424 ++++++++++++++++++ .../blog/08_spa_agda_forward/plusminus.png | Bin 0 -> 42474 bytes 4 files changed, 427 insertions(+), 1 deletion(-) create mode 100644 content/blog/08_spa_agda_forward/index.md create mode 100644 content/blog/08_spa_agda_forward/plusminus.png diff --git a/content/blog/00_spa_agda_intro.md b/content/blog/00_spa_agda_intro.md index 601710f..cb9890c 100644 --- a/content/blog/00_spa_agda_intro.md +++ b/content/blog/00_spa_agda_intro.md @@ -106,4 +106,5 @@ Here are the posts that I’ve written so far for this series: * {{< draftlink "Our Programming Language" "05_spa_agda_semantics" >}} * {{< draftlink "Control Flow Graphs" "06_spa_agda_cfg" >}} * {{< draftlink "Connecting Semantics and Control Flow Graphs" "07_spa_agda_semantics_and_cfg" >}} -* {{< draftlink "A Verified Forward Analysis" "08_spa_forward" >}} +* {{< draftlink "Forward Analysis" "08_spa_forward" >}} +* {{< draftlink "Verifying the Forward Analysis" "09_spa_verified_forward" >}} diff --git a/content/blog/01_spa_agda_lattices.md b/content/blog/01_spa_agda_lattices.md index 69ebbb7..6fc1b88 100644 --- a/content/blog/01_spa_agda_lattices.md +++ b/content/blog/01_spa_agda_lattices.md @@ -79,6 +79,7 @@ a less specific output! The more you know going in, the more you should know coming out. Similarly, when given less specific / vaguer information, the analysis shouldn't produce a more specific answer -- how could it do that? This leads us to come up with the following rule: +{#define-monotonicity} {{< latex >}} \textbf{if}\ \text{input}_1 \le \text{input}_2, diff --git a/content/blog/08_spa_agda_forward/index.md b/content/blog/08_spa_agda_forward/index.md new file mode 100644 index 0000000..f9bbaf1 --- /dev/null +++ b/content/blog/08_spa_agda_forward/index.md @@ -0,0 +1,424 @@ +--- +title: "Implementing and Verifying \"Static Program Analysis\" in Agda, Part 8: Forward Analysis" +series: "Static Program Analysis in Agda" +description: "In this post, I use the monotone lattice framework and verified CFGs to define a sign analysis" +date: 2024-12-01T15:09:07-08:00 +tags: ["Agda", "Programming Languages"] +draft: true +--- + +In the previous post, I showed that the Control Flow graphs we built of our +programs match how they are really executed. This means that we can rely +on these graphs to compute program information. In this post, we finally +get to compute that information. Let's jump right into it! + +### Choosing a Lattice +A lot of this time, we have been [talking about lattices]({{< relref "01_spa_agda_lattices" >}}), +particularly [lattices of finite height]({{< relref "03_spa_agda_fixed_height" >}}). +These structures represent things we know about the program, and provide operators +like \((\sqcup)\) and \((\sqcap)\) that help us combine such knowledge. + +The forward analysis code I present here will work with any finite-height +lattice, with the additional constraint that equivalence of lattices +is decidable, which comes from [the implementation of the fixed-point algorithm]({{< relref "04_spa_agda_fixedpoint" >}}), +in which we routinely check if a function's output is the same as its input. + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 4 8 >}} + +The finite-height lattice `L` is intended to describe the state of a single +variable. +One example of a lattice that can be used as `L` is our +sign lattice. We've been using the sign lattice in our examples [from the very beginning]({{< relref "01_spa_agda_lattices#lattices" >}}), +and we will stick with it for the purposes of this explanation. However, this +lattice alone does not describe our program, since it only talks about a single +sign; programs have lots of variables, all of which can have different signs! +So, we might go one step further and define a map lattice from variables to +their signs: + +{{< latex >}} +\text{Variable} \to \text{Sign} +{{< /latex >}} + +We [have seen]({{< relref "02_spa_agda_combining_lattices#the-map-lattice" >}}) +that we can turn any lattice \(L\) into a map lattice \(A \to L\), for any +type of keys \(A\). In this case, we will define \(A \triangleq \text{Variable}\), +and \(L \triangleq \text{Sign}\). The +[sign lattice has a finite height]({{< relref "02_spa_agda_combining_lattices#the-map-lattice" >}}), +and I've proven that, as long as we pick a finite set of keys, [map lattices +\(A \to L\) have a finite height if \(L\) has a finite height]({{< relref "03_spa_agda_fixed_height#fixed-height-of-the-map-lattice" >}}). +Since a program's text is finite, \(\text{Variable}\) is a finite set, and +we have ourselves a finite-height lattice \(\text{Variable} \to \text{Sign}\). + +We're on the right track, but even the lattice we have so far is not sufficient. +That's because variables have different signs at different points in the program! +You might initialize a variable with `x = 1`, making it positive, and then +go on to compute some arbitrary function using loops and conditionals. For +each variable, we need to keep track of its sign at various points in the code. +When we [defined Control Flow Graphs]({{< relref "06_spa_agda_cfg" >}}), we +split our programs into sequences of statements that are guaranteed to execute +together --- basic blocks. For our analysis, we'll keep per-variable for +each basic block in the program. Since basic blocks are nodes in the Control Flow +Graph of our program, our whole lattice will be as follows: + +{{< latex >}} +\text{Info} \triangleq \text{NodeId} \to (\text{Variable} \to \text{Sign}) +{{< /latex >}} + +We follow the same logic we just did for the variable-sign lattice; since +\(\text{Variable} \to \text{Sign}\) is a lattice of finite height, and since +\(\text{NodeId}\) is a finite set, the whole \(\text{Info}\) map will be +a lattice with a finite height. + +Notice that both the sets of \(\text{Variable}\) and \(\text{NodeId}\) depend +on the program in question. The lattice we use is slightly different for +each input program! We can use Agda's parameterized modules to automaitcally +parameterize all our functions over programs: + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 36 37 >}} + +Now, let's make the informal descriptions above into code, by instantiating +our map lattice modules. First, I invoked the code for the smaller variable-sign +lattice. This ended up being quite long, so that I could rename variables I +brought into scope. I will collapse the relevant code block; suffice to say +that I used the suffix `v` (e.g., renaming `_⊔_` to `_⊔ᵛ_`) for properties +and operators to do with variable-sign maps (in Agda: `VariableValuesFiniteMap`). + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 41 82 "" "**(Click here to expand the module uses for variable-sign maps)**" >}} + +I then used this lattice as an argument to the map module again, to +construct the top-level \(\text{Info}\) lattice (in Agda: `StateVariablesFiniteMap`). +This also required a fair bit of code, most of it to do with renaming. + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 85 112 "" "**(Click here to expand the module uses for the top-level lattice)**" >}} + +### Constructing a Monotone Function + +We now have a lattice in hand; the next step is to define a function over +this lattice. For us to be able to use the fixed-point algorithm on this +function, it will need to be [monotonic]({{< relref "01_spa_agda_lattices#define-monotonicity" >}}). + +Our goal with static analysis is to compute information about our program; that's +what we want the function to do. When the lattice we're using is the sign lattice, +we're trying to determine the signs of each of the variables in various parts +of the program. How do we go about this? + +Each piece of code in the program might change a variable's sign. For instance, +if `x` has sign \(0\), and we run the statement `x = x - 1`, the sign of +`x` will be \(-\). If we have an expression `y + z`, we can use the signs of +`y` and `z` to compute the sign of the whole thing. This is a form +of [abstract interpretation](https://en.wikipedia.org/wiki/Abstract_interpretation), +in which we almost-run the program, but forget some details (e.g., the +exact values of `x`, `y`, and `z`, leaving only their signs). The exact details +of how this partial evaluation is done are analysis-specific; in general, we +simply require an analysis to provide an evaluator. We will define +[an evaluator for the sign lattice below](#instantiating-with-the-sign-lattice). + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 166 167 >}} + +From this, we know how each statement and basic block will change variables +in the function. But we have described them process as "if a variable has +sign X, it becomes sign Y" -- how do we know what sign a variable has _before_ +the code runs? Fortunately, the Control Flow Graph tells us exactly +what code could be executed before any given basic block. Recall that edges +in the graph describe all possible jumps that could occur; thus, for any +node, the incoming edges describe all possible blocks that can precede it. +This is why we spent all that time [defining the `predecessors` function]({{< relref "06_spa_agda_cfg#additional-functions" >}}). + +We proceed as follows: for any given node, find its predecessors. By accessing +our \(\text{Info}\) map for each predecessor, we can determine our current +best guess of variable signs at that point, in the form of a \(\text{Variable} \to \text{Sign}\) +map (more generally, \(\text{Variable} \to L\) map in an arbitrary analysis). +We know that any of these predecessors could've been the previous point of +execution; if a variable `x` has sign \(+\) in one predecessor and \(-\) +in another, it can be either one or the other when we start executing the +current block. Early on, we saw that [the \((\sqcup)\) operator models disjunction +("A or B")]({{< relref "01_spa_agda_lattices#lub-glub-or-and" >}}). So, we apply +\((\sqcup)\) to the variable-sign maps of all predecessors. The +[reference _Static Program Analysis_ text](https://cs.au.dk/~amoeller/spa/) +calls this operation \(\text{JOIN}\): + +{{< latex >}} +\textit{JOIN}(v) = \bigsqcup_{w \in \textit{pred}(v)} \llbracket w \rrbracket +{{< /latex >}} + +The Agda implementation uses a `foldr`: + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 139 140 >}} + +Computing the "combined incoming states" for any node is a monotonic function. +This follows from the monotonicity of \((\sqcup)\) --- in both arguments --- +and the definition of `foldr`. + +{{< codelines "agda" "agda-spa/Lattice.agda" 143 151 "" "**(Click here to expand the general proof)**" >}} + +From this, we can formally state that \(\text{JOIN}\) is monotonic. Note that +the input and output lattices are different: the input lattice is the lattice +of variable states at each block, and the output lattice is a single variable-sign +map, representing the combined preceding state at a given node. + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 145 149 >}} + +Above, the `m₁≼m₂⇒m₁[ks]≼m₂[ks]` lemma states that for two maps with the same +keys, where one map is less than another, all the values for any subset of keys +`ks` are pairwise less than each other (i.e. `m₁[k]≼m₂[k]`, and `m₁[l]≼m₂[l]`, etc.). +This follows from the definition of "less than" for maps. +{#less-than-lemma} + +So those are the two pieces: first, join all the preceding states, then use +the abstract interpretation function. I opted to do both of these in bulk: + +1. Take an initial \(\text{Info}\) map, and update every basic block's entry + to be the join of its predecessors. +2. In the new joined map, each key now contains the variable state at + the beginning of the block; so, apply the abstract interpretation function + via `eval` to each key, computing the state at the end of the block. + +I chose to do these in bulk because this way, after each application of +the function, we have updated each block with exactly one round of information. +The alternative --- which is specified in the reference text --- is to update +one key at a time. The difference there is that updates to later keys might be +"tainted" by updates to keys that came before them. This is probably fine +(and perhaps more efficient, in that it "moves faster"), but it's harder to +reason about. + +#### Generalized Update + +To implement bulk assignment, I needed to implement the source text's +Exercise 4.26: + +> __Exercise 4.26__: Recall that \(f[a \leftarrow x]\) denotes the function that is identical to +> \(f\) except that it maps \(a\) to \(x\). Assume \(f : L_1 \to (A \to L_2)\) +> and \(g : L_1 \to L_2\) are monotone functions where \(L_1\) and \(L_2\) are +> lattices and \(A\) is a set, and let \(a \in A\). (Note that the codomain of +> \(f\) is a map lattice.) +> +> Show that the function \(h : L_1 \to (A \to L_2)\) +> defined by \(h(x) = f(x)[a \leftarrow g(x)]\) is monotone. + +In fact, I generalized this statement to update several keys at once, as follows: + +{{< latex >}} +h(x) = f(x)[a_1 \leftarrow g(a_1, x),\ ...,\ a_n \leftarrow g(a_n, x)] +{{< /latex >}} + +I called this operation "generalized update". + +At first, the exercise may not obviously correspond to the bulk operation +I've described. Particularly confusing is the fact that it has two lattices, +\(L_1\) and \(L_2\). In fact, the exercise results in a very general theorem; +we can exploit a more concrete version of the theorem by setting +\(L_1 \triangleq A \to L_2\), resulting in an overal signature for \(f\) and \(h\): + +{{< latex >}} +f : (A \to L_2) \to (A \to L_2) +{{< /latex >}} + +In other words, if we give the entire operation in Exercise 4.26 a type, +it would look like this: + +{{< latex >}} +\text{ex}_{4.26} : \underbrace{K}_{\text{value of}\ a} \to \underbrace{(\text{Map} \to V)}_{\text{updater}} \to \underbrace{\text{Map} \to \text{Map}}_{f} \to \underbrace{\text{Map} \to \text{Map}}_{h} +{{< /latex >}} + +That's still more general than we need it. This here allows us to modify +any map-to-map function by updating a certain key in that function. If we +_just_ want to update keys (as we do for the purposes of static analysis), +we can recover a simpler version by setting \(f \triangleq id\), which +results in an updater \(h(x) = x[a \leftarrow g(x)]\), and a signature for +the exercise: + +{{< latex >}} +\text{ex}_{4.26} : \underbrace{K}_{\text{value of}\ a} \to \underbrace{(\text{Map} \to V)}_{\text{updater}\ g} \to \underbrace{\text{Map}}_{\text{old map}} \to \underbrace{\text{Map}}_{\text{updated map}} +{{< /latex >}} + +This looks just like Haskell's [`Data.Map.adjust` function](https://hackage.haskell.org/package/containers-0.4.0.0/docs/src/Data-Map.html#adjust), except that it +can take the entire map into consideration when updating a key. + +My generalized version takes in a list of keys to update, and makes the updater +accept a key so that its behavior can be specialized for each entry it changes. +The sketch of the implementation is in the `_updating_via_` function from +the `Map` module, and its helper `transform`. Here, I collapse its definition, +since it's not particularly important. + +{{< codelines "agda" "agda-spa/Lattice/Map.agda" 926 931 "" "**(Click here to see the definition of `transform`)**" >}} + +The proof of monotonicity --- which is the solution to the exercise --- is +actually quite complicated. I will omit its description, and show it here +in another collapsed block. + +{{< codelines "agda" "agda-spa/Lattice/Map.agda" 1042 1105 "" "**(Click here to see the proof of monotonicity of \(h\))**" >}} + +Given a proof of the exercise, all that's left is to instantiate the theorem +with the argument I described. Specifically: + +* \(L_1 \triangleq \text{Info} \triangleq \text{NodeId} \to (\text{Variable} \to \text{Sign})\) +* \(L_2 \triangleq \text{Variable} \to \text{Sign} \) +* \(A \triangleq \text{NodeId}\) +* \(f \triangleq \text{id} \triangleq x \mapsto x\) +* \(g(k, m) = \text{JOIN}(k, m)\) + +In the equation for \(g\), I explicitly insert the map \(m\) instead of leaving +it implicit as the textbook does. In Agda, this instantiation for joining +all predecessor looks like this (using `states` as the list of keys to update, +indicating that we should update _every_ key): + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 152 157 >}} + +And the one for evaluating all programs looks like this: + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 215 220 >}} + +Actually, we haven't yet seen that `updateVariablesFromStmt`. This is +a function that we can define using the user-provided abtract interpretation +`eval`. Specifically, it handles the job of updating the sign of a variable +once it has been assigned to (or doing nothing if the statement is a no-op). + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 191 193 >}} + +The `updateVariablesFromExpression` is now new, and it is yet another map update, +which changes the sign of a variable `k` to be the one we get from running +`eval` on it. Map updates are instances of the generalized update; this +time, the updater \(g\) is `eval`. The exercise requires the updater to be +monotonic, which constrains the user-provided evaluation function to be +monotonic too. + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 173 181 >}} + +We finally write the `analyze` function as the composition of the two bulk updates: + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 226 232 >}} + +### Instantiating with the Sign Lattice +Thus far, I've been talking about the sign lattice throughout, but implementing +the Agda code in terms of a general lattice `L` and evaluation function `eval`. +In order to actually run the Agda code, we do need to provide an `eval` function, +which implements the logic we used above, in which a zero-sign variable \(x\) +minus one was determined to be negative. For binary operators specifically, +I've used the table provided in the textbook; here they are: + +{{< figure src="plusminus.png" caption="Cayley tables for abstract interpretation of plus and minus" >}} + +These are pretty much common sense: +* A positive plus a positive is still positive, so \(+\ \hat{+}\ + = +\) +* A positive plus any sign could be any sign still, so \(+\ \hat{+}\ \top = \top\) +* Any sign plus "impossible" is impossible, so \(\top\ \hat{+} \bot = \bot\). +* etc. + +The Agda encoding for the plus function is as follows, and the one for minus +is similar. + +{{< codelines "agda" "agda-spa/Analysis/Sign.agda" 76 94 >}} + +As the comment in the block says, it would be incredibly tedious to verify +the monotonicity of these tables, since you would have to consider roughly +125 cases _per argument_: for each (fixed) sign \(s\) and two other signs +\(s_1 \le s_2\), we'd need to show that \(s\ \hat{+}\ s_1 \le s\ \hat{+}\ s_2\). +I therefore commit the _faux pas_ of using `postulate`. Fortunately, the proof +of monotonicity is not used for the execution of the program, so we will +get away with this, barring any meddling kids. + +From this, all that's left is to show that for any expression `e`, the +evaluation function: + +{{< latex >}} +\text{eval} : \text{Expr} \to (\text{Variable} \to \text{Sign}) \to \text{Sign} +{{< /latex >}} + +is monotonic. It's defined straightforwardly and very much like an evaluator / +interpreter, suggesting that "abstract interpretation" is the correct term here. + +{{< codelines "agda" "agda-spa/Analysis/Sign.agda" 176 184 >}} + +Thought it won't happen, it was easier to just handle the case where there's +an undefined variable; I give it "any sign". Otherwise, the function simply +consults the sign tables for `+` or `-`, as well as the known signs of the +variables. For natural number literals, it assigns `0` the "zero" sign, and +any other natural number the "\(+\)". + +To prove monotonicity, we need to consider two variable maps (one less than +the other), and show that the abstract interpretation respects that ordering. +This boils down to the fact that the `plus` and `minus` tables are monotonic +in both arguments (thus, if their sub-expressions are evaluated monotonically +given an environment, then so is the whole addition or subtraction), and +to the fact that for two maps `m₁ ≼ m₂`, the values at corresponding keys +are similarly ordered: `m₁[k] ≼ m₂[k]`. We [saw that above](#less-than-lemma). + +{{< codelines "agda" "agda-spa/Analysis/Sign.agda" 186 223 "" "**(Click to expand the proof that the evaluation function for signs is monotonic)**" >}} + +That's all we need. With this, I just instantiate the `Forward` module we have +been working with, and make use of the `result`. I also used a `show` +function (which I defined) to stringify that output. + +{{< codelines "agda" "agda-spa/Analysis/Sign.agda" 225 229 >}} + +But wait, `result`? We haven't seen a result just yet. That's the last piece, +and it involves finally making use of the fixed-point algorithm. + +### Invoking the Fixed Point Algorithm +Our \(\text{Info}\) lattice is of finite height, and the function we have defined +is monotonic (by virtue of being constructed only from map updates, which +are monotonic by Exercise 4.26, and from function composition, which preserves +monotonicity). We can therefore apply the fixed-point-algorithm, and compute +the least fixed point: + +{{< codelines "agda" "agda-spa/Analysis/Forward.agda" 235 238 >}} + +With this, `analyze` is the result of our forward analysis! + +In a `Main.agda` file, I invoked this analysis on a sample program: + +```Agda +testCode : Stmt +testCode = + ⟨ "zero" ← (# 0) ⟩ then + ⟨ "pos" ← ((` "zero") Expr.+ (# 1)) ⟩ then + ⟨ "neg" ← ((` "zero") Expr.- (# 1)) ⟩ then + ⟨ "unknown" ← ((` "pos") Expr.+ (` "neg")) ⟩ + +testProgram : Program +testProgram = record + { rootStmt = testCode + } + +open WithProg testProgram using (output; analyze-correct) + +main = run {0ℓ} (putStrLn output) +``` + +The result is verbose, since it shows variable signs for each statement +in the program. However, the key is the last basic block, which shows +the variables at the end of the program. It reads: + +``` +{"neg" ↦ -, "pos" ↦ +, "unknown" ↦ ⊤, "zero" ↦ 0, } +``` + +### Verifying the Analysis +We now have a general framework for running forward analyses: you provide +an abstract interpretation function for expressions, as well as a proof +that this function is monotonic, and you get an Agda function that takes +a program and tells you the variable states at every point. If your abstract +interpretation function is for determining the signs of expressions, the +final result is an analysis that determines all possible signs for all variables, +anywhere in the code. It's pretty easy to instantiate this framework with +another type of forward analysis --- in fact, by switching the +`plus` function to one that uses `AboveBelow ℤ`, rather than `AboveBelow Sign`: + +```Agda +plus : ConstLattice → ConstLattice → ConstLattice +plus ⊥ᶜ _ = ⊥ᶜ +plus _ ⊥ᶜ = ⊥ᶜ +plus ⊤ᶜ _ = ⊤ᶜ +plus _ ⊤ᶜ = ⊤ᶜ +plus [ z₁ ]ᶜ [ z₂ ]ᶜ = [ z₁ Int.+ z₂ ]ᶜ +``` + +we can defined a constant-propagation analysis. + +However, we haven't proved our analysis correct, and we haven't yet made use of +the CFG-semantics equivalence that we +[proved in the previous section]({{< relref "07_spa_agda_semantics_and_cfg" >}}). +I was hoping to get to it in this post, but there was just too much to +cover. So, I will get to that in the next post, where we will make use +of the remaining machinery to demonstrate that the output of our analyzer +matches reality. diff --git a/content/blog/08_spa_agda_forward/plusminus.png b/content/blog/08_spa_agda_forward/plusminus.png new file mode 100644 index 0000000000000000000000000000000000000000..cecf094dbea118f4b9ba840d514bc2c58b1c59b7 GIT binary patch literal 42474 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 Pz`)??>gTe~DWM4fvQnMj literal 0 HcmV?d00001