+2004-09-18 Kazu Hirata <kazu@cs.umass.edu>
+
+ * alias.c, crtstuff.c, dbxout.c, domwalk.c, domwalk.h, gcc.c,
+ gcse.c, global.c, lambda-code.c, loop.c, mips-tdump.c,
+ optabs.h, predict.c, reg-stack.c, regclass.c, sched-rgn.c,
+ tree-optimize.c, tree-ssa-dom.c, tree-ssa-forwprop.c,
+ tree-ssa-operands.c, tree-ssa-phiopt.c,
+ tree-ssa-threadupdate.c: Fix comment typos.
+
2004-09-18 Kazu Hirata <kazu@cs.umass.edu>
* config/darwin-c.c, config/arc/arc.c, config/arc/arc.md,
/* Return true when INSN possibly modify memory contents of MEM
- (ie address can be modified). */
+ (i.e. address can be modified). */
bool
memory_modified_in_insn_p (rtx mem, rtx insn)
{
but not its definition.
Making TARGET_WEAK_ATTRIBUTE conditional seems like a good solution until
- one thinks about scaling to larger problems -- ie, the condition under
+ one thinks about scaling to larger problems -- i.e., the condition under
which TARGET_WEAK_ATTRIBUTE is active will eventually get far too
complicated.
{
case VOID_TYPE:
case LANG_TYPE:
- /* For a void type, just define it as itself; ie, "5=5".
+ /* For a void type, just define it as itself; i.e., "5=5".
This makes us consider it defined
without saying what it is. The debugger will make it
a void type when the reference is seen, and nothing will
[ Note this walker can also walk the post-dominator tree, which is
- defined in a similar manner. ie, block B1 is said to post-dominate
+ defined in a similar manner. i.e., block B1 is said to post-dominate
block B2 if all paths from B2 to the exit block must pass through
B1. ]
struct dom_walk_data
{
- /* This is the direction of the dominator tree we want to walk. ie,
+ /* This is the direction of the dominator tree we want to walk. i.e.,
if it is set to CDI_DOMINATORS, then we walk the dominator tree,
if it is set to CDI_POST_DOMINATORS, then we walk the post
dominator tree. */
}
else
/* Catch the case where a spec string contains something like
- '%{foo:%*}'. ie there is no * in the pattern on the left
+ '%{foo:%*}'. i.e. there is no * in the pattern on the left
hand side of the :. */
error ("spec failure: '%%*' has not been initialized by pattern match");
break;
/* This is a list of expressions which are MEMs and will be used by load
or store motion.
Load motion tracks MEMs which aren't killed by
- anything except itself. (ie, loads and stores to a single location).
+ anything except itself. (i.e., loads and stores to a single location).
We can then allow movement of these MEM refs with a little special
allowance. (all stores copy the same value to the reaching reg used
for the loads). This means all values used to store into memory must have
struct expr *set1 = 0;
/* Loops are not possible here. To get a loop we would need two sets
- available at the start of the block containing INSN. ie we would
+ available at the start of the block containing INSN. i.e. we would
need two sets like this available at the start of the block:
(set (reg X) (reg Y))
if (! REG_P (src))
break;
- /* Follow the copy chain, ie start another iteration of the loop
+ /* Follow the copy chain, i.e. start another iteration of the loop
and see if we have an available copy into SRC. */
regno = REGNO (src);
}
evaluates X.
3. Either X or Y is not evaluated on the path to P
- (ie it is used uninitialized) and thus the
+ (i.e. it is used uninitialized) and thus the
conflict can be ignored.
In cases #1 and #2 the conflict will be recorded when we
innermost loop body.
If S is a program statement, then
- ie
+ i.e.
DO I = 1, 20
S1
DO J = 1, 20
matrix T is legal when applied to a loop nest with a set of
lexicographically non-negative distance vectors RDG if and only if
for each vector d in RDG, (T.d >= 0) is lexicographically positive.
- ie.: if and only if it transforms the lexicographically positive
+ i.e.: if and only if it transforms the lexicographically positive
distance vectors to lexicographically positive vectors. Note that
a unimodular matrix must transform the zero vector (and only it) to
the zero vector." S.Muchnick. */
}
/* X is a value modified by an INSN that references a biv inside a loop
- exit test (ie, X is somehow related to the value of the biv). If X
+ exit test (i.e., X is somehow related to the value of the biv). If X
is a pseudo that is used more than once, then the biv is (effectively)
used more than once. DATA is a pointer to a loop_regs structure. */
/*
* Snarf up any array bounds in the correct order. Arrays
* store 5 successive words in the aux. table:
- * word 0 RNDXR to type of the bounds (ie, int)
+ * word 0 RNDXR to type of the bounds (i.e., int)
* word 1 Current file descriptor index
* word 2 low bound
* word 3 high bound (or -1 if [])
int first_array = i;
int j;
- /* Print array bounds reversed (ie, in the order the C
+ /* Print array bounds reversed (i.e., in the order the C
programmer writes them). C is such a fun language.... */
while (i < 5 && qualifiers[i+1].type == tq_Array)
\f
typedef rtx (*rtxfun) (rtx);
-/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
+/* Indexed by the rtx-code for a conditional (e.g. EQ, LT,...)
gives the gen_function to make a branch to test that condition. */
extern rtxfun bcc_gen_fctn[NUM_RTX_CODE];
-/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
+/* Indexed by the rtx-code for a conditional (e.g. EQ, LT,...)
gives the insn code to make a store-condition insn
to test that condition. */
&& !last_basic_block_p (e->dest))
predict_edge_def (e, PRED_EARLY_RETURN, TAKEN);
- /* Look for block we are guarding (ie we dominate it,
+ /* Look for block we are guarding (i.e. we dominate it,
but it doesn't postdominate us). */
if (e->dest != EXIT_BLOCK_PTR && e->dest != bb
&& dominated_by_p (CDI_DOMINATORS, e->dest, e->src)
&& !last_basic_block_p (e->dest))
predict_edge_def (e, PRED_EARLY_RETURN, TAKEN);
- /* Look for block we are guarding (ie we dominate it,
+ /* Look for block we are guarding (i.e. we dominate it,
but it doesn't postdominate us). */
if (e->dest != EXIT_BLOCK_PTR && e->dest != bb
&& dominated_by_p (CDI_DOMINATORS, e->dest, e->src)
asm ("foo" : "=t" (a) : "f" (b));
This asm says that input B is not popped by the asm, and that
- the asm pushes a result onto the reg-stack, ie, the stack is one
+ the asm pushes a result onto the reg-stack, i.e., the stack is one
deeper after the asm than it was before. But, it is possible that
reload will think that it can use the same reg for both the input and
the output, if input B dies in this insn.
Insert any needed insns before or after INSN, as indicated by
WHERE. OLD is the original stack layout, and NEW is the desired
- form. OLD is updated to reflect the code emitted, ie, it will be
+ form. OLD is updated to reflect the code emitted, i.e., it will be
the same as NEW upon return.
This function will not preserve block_end[]. But that information
win = address_operand (op, GET_MODE (op));
/* We know this operand is an address, so we want it to be
allocated to a register that can be the base of an
- address, ie BASE_REG_CLASS. */
+ address, i.e. BASE_REG_CLASS. */
classes[i]
= reg_class_subunion[(int) classes[i]]
[(int) MODE_BASE_REG_CLASS (VOIDmode)];
win = 1;
/* We know this operand is an address, so we want it to
be allocated to a register that can be the base of an
- address, ie BASE_REG_CLASS. */
+ address, i.e. BASE_REG_CLASS. */
classes[i]
= reg_class_subunion[(int) classes[i]]
[(int) MODE_BASE_REG_CLASS (VOIDmode)];
d b
The algorithm in the DFS traversal may not mark B & D as part
- of the loop (ie they will not have max_hdr set to A).
+ of the loop (i.e. they will not have max_hdr set to A).
We know they can not be loop latches (else they would have
had max_hdr set since they'd have a backedge to a dominator
}
\f
-/* update recursivly all inlined_to pointers of functions
+/* Update recursively all inlined_to pointers of functions
inlined into NODE to INLINED_TO. */
static void
update_inlined_to_pointers (struct cgraph_node *node,
optimizations are not performed.
Note carefully we do not propagate information through each statement
- in the block. ie, if we know variable X has a value defined of
+ in the block. i.e., if we know variable X has a value defined of
[0, 25] and we encounter Y = X + 1, we do not track a value range
for Y (which would be [1, 26] if we cared). Similarly we do not
constrain values as we encounter narrowing typecasts, etc. */
/* We really want to avoid unnecessary computations of range
info. So all ranges are computed lazily; this avoids a
- lot of unnecessary work. ie, we record the conditional,
+ lot of unnecessary work. i.e., we record the conditional,
but do not process how it constrains the variable's
potential values until we know that processing the condition
could be helpful.
tree op1 = TREE_OPERAND (cond, 1);
/* Special case comparing booleans against a constant as we know
- the value of OP0 on both arms of the branch. ie, we can record
+ the value of OP0 on both arms of the branch. i.e., we can record
an equivalence for OP0 rather than COND. */
if ((TREE_CODE (cond) == EQ_EXPR || TREE_CODE (cond) == NE_EXPR)
&& TREE_CODE (op0) == SSA_NAME
Right now we only bother forward propagating into COND_EXPRs since those
are relatively common cases where forward propagation creates valid
- gimple code without the expression needing to fold. ie
+ gimple code without the expression needing to fold. i.e.
bb0:
x = a COND b;
variable, and that same variable occurs in the same operands cache, then
the new cache vector will also get the same SSA_NAME.
- ie, if a stmt had a VUSE of 'a_5', and 'a' occurs in the new operand
+ i.e., if a stmt had a VUSE of 'a_5', and 'a' occurs in the new operand
vector for VUSE, then the new vector will also be modified such that
it contains 'a_5' rather than 'a'.
basic_block *);
/* This pass eliminates PHI nodes which can be trivially implemented as
- an assignment from a conditional expression. ie if we have something
+ an assignment from a conditional expression. i.e. if we have something
like:
bb0:
one or more in-edges to B to instead reach the destination of an
out-edge from B while preserving any side effects in B.
- ie, given A->B and B->C, change A->B to be A->C yet still preserve the
+ i.e., given A->B and B->C, change A->B to be A->C yet still preserve the
side effects of executing B.
1. Make a copy of B (including its outgoing edges and statements). Call
projects / gcc.git / commitdiff