This is the mail archive of the
gcc@gcc.gnu.org
mailing list for the GCC project.
Re: c-gimplify.c:gimplify_decl_stmt
On Jun 6, 2004, at 3:13 PM, Eric Christopher wrote:
On Sun, 2004-06-06 at 12:07, Richard Kenner wrote:
The comments in front of the funciton reference variables inside the
function, which is wrong.
I don't know that this is "wrong" as long as it's useful.
Describing the
algorithm or high level stuff that's needed to understand the
function.
No, it's confusing.
Comments *before* the function are supposed to explain the
*specification*
of the function, which means what a *caller* of the function needs to
know.
I disagree. There's nothing at all wrong with describing the function
itself and what it does and how it works. I've just taken a look at the
comment and it does appear to be split along specification and
description boundaries. Seems very useful to me. I've often wanted this
for other functions. Also, it seems a good way to keep functions small
and to the point - otherwise we get fold (). :)
I agree completely with you.
For example, I have the following above compute_antic in gvn-pre:
/* Compute the ANTIC set for BLOCK.
ANTIC_OUT[BLOCK] = intersection of ANTIC_IN[b] for each b in
succ(BLOCK), if
succs(BLOCK) > 1
ANTIC_OUT[BLOCK] = phi_translate (ANTIC_IN[succ(BLOCK)]) if
succs(BLOCK) == 1
ANTIC_IN[BLOCK] = clean(ANTIC_OUT[BLOCK] U EXP_GEN[BLOCK] -
TMP_GEN[BLOCK])
*/
static void
compute_antic (basic_block BLOCK)
Under richard's view, it appears this would simply be something like
/* Compute the ANTIC set for BLOCK
BLOCK is the basic block to compute the ANTIC set for.
Returns nothing. */
This tells you absolutely nothing interesting about the function.
Keeping the exact details about how the algorithm works doesn't belong
somewhere like the top of the file, it belongs near the code that
performs it.
Of course, in this case (before someone complains you need a general
description of the algorithm workings), i have a general overview of
the algorithm at the top of the file that includes :
Next, we generate the ANTIC sets. ANTIC is a backwards dataflow
problem. These sets represent the anticipatable expressions. An
expression is anticipatable in a given block if it could be
generated in that block. This means that if we had to perform an
insertion in that block, of the value of that expression, we could.
Calculating the ANTIC sets requires phi translation of expressions,
because the flow goes backwards through phis. We must iterate to a
fixpoint of the ANTIC sets, because we have a kill set.
Even in SSA form, values are not live over the entire function,
only from their definition point onwards. So we have to remove
values from the ANTIC set once we go past the definition point of
the leaders that make them up. compute_antic performs all of this
computation.
Note it doesn't exactly say *how* we compute ANTIC, that's the stuff
right above compute_antic.