li.zhe.hua marked an inline comment as done.
li.zhe.hua added inline comments.
================
Comment at:
clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp:168-169
+// back edge block. (That is, all paths from the entry block to the back edge
+// block must go through `Block`.) It also means that there are only two
+// predecessors; the other is along the path from the entry block to `Block`.
+static const CFGBlock *findBackEdge(const CFGBlock *Block) {
----------------
xazax.hun wrote:
> Is this also true when we have multiple `continue` statements in the loop?
Yes. The end of the loop, and each of the `continue` statements, target the
back edge block. They all get funneled through that back edge to `Block`, such
that `Block` only has two predecessors. However, I haven't verified this in the
CFG code, only by not finding a counterexample.
================
Comment at:
clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp:228-234
+ // If we are at the start of a loop, we will have two precessors, but we
don't
+ // want to join these two predecessors. Instead, we want to take the back
edge
+ // block (i.e. the result of the previous iteration) and use that directly as
+ // the input block.
+ //
+ // For the first iteration of loop, the "zeroth" iteration state is set up by
+ // `prepareBackEdges`.
----------------
xazax.hun wrote:
> Could you elaborate on this? Let's consider this loop:
>
> ```
> Pred
> |
> v
> LoopHeader <---BackEdge
> ```
>
> Do we ignore the state coming from `Pred` on purpose? Is that sound?
>
> I would expect the analysis to always compute `join(PredState,
> BackEdgeState)`, and I would expect the widening to happen between the
> previous iteration of `BackEdgeState` and the current iteration of
> `BackEdgeState`. So, I wonder if we already invoke the widening operator
> along back edges, wouldn't the regular logic work just fine? Do I miss
> something?
>
> Do we ignore the state coming from `Pred` on purpose? Is that sound?
We don't, and this is what the comment
```
// For the first iteration of loop, the "zeroth" iteration state is set up by
// `prepareBackEdges`.
```
failed to explain. After transferring `PredState`, we copy `PredState` into
`BackEdgeState`, which is done in `prepareBackEdges`.
> I would expect the analysis to always compute `join(PredState, BackEdgeState)`
I'm not sure I see that we should always join `PredState` and `BackEdgeState`.
Execution doesn't go from `Pred` into the Nth iteration of the loop, it only
goes from `Pred` into the first iteration of the loop, e.g. the predecessor for
the 4th iteration of the loop is only the back-edge from the 3rd iteration of
the loop, not `Pred`.
Let me know if this makes sense.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D131646/new/
https://reviews.llvm.org/D131646
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
