This is the mail archive of the
gcc@gcc.gnu.org
mailing list for the GCC project.
Re: RFA: Adding a location_t (or pointer) to tree_exp for 3.4 only.
On Tue, Oct 07, 2003 at 08:32:31PM +0200, Carlo Wood wrote:
> While the above patch is enough to garantee correct compilation
> (despite the wrapping of CALL_EXPR inside a WFL) for the simple
> test case, it is NOT enough in general. When using this compiler
> to compile a big C++ source file, the following additional
> locations were printed that need manual checking before we can
> be sure that the wrapping doesn't do any harm (see patch above
> for tree.h so see where TREE_CODE: is printed):
>
> TREE_CODE: ../../../gcc/gcc-mainline/gcc/builtins.c:5331
> TREE_CODE: ../../../gcc/gcc-mainline/gcc/c-common.c:1234
[..snip..]
Because those file names do not say much - except that
there are still a lot to check - here is a list of the
actual source lines plus a little context.
It proves that expressions with file locations get all
over the code and will need special handling at many
places, although not at all places listed here of course.
gtype-cp.h:217 gt_ggc_m_9tree_node ((*x).generic.exp.common.type);
gtype-cp.h:218:===> switch (TREE_CODE ((tree) &(*x)))
gtype-cp.h:219 {
--
gtype-cp.h:240 size_t i1;
gtype-cp.h:241:===> for (i1 = 0; i1 < (size_t)(TREE_CODE_LENGTH (TREE_CODE ((tree) &(*x)))); i1++) {
gtype-cp.h:242 gt_ggc_m_9tree_node ((*x).generic.exp.operands[i1]);
--
builtins.c:5330:
builtins.c:5331:===> if (TREE_CODE (t) != CALL_EXPR
builtins.c:5332 || TREE_CODE (TREE_OPERAND (t, 0)) != ADDR_EXPR)
--
c-common.c:1233
c-common.c:1234:===> if ((TREE_CODE (value) == INTEGER_CST
c-common.c:1235:===> || (TREE_CODE (value) == COMPLEX_CST
c-common.c:1236 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
--
c-common.c:1242 }
c-common.c:1243:===> else if ((TREE_CODE (value) == REAL_CST
c-common.c:1244:===> || (TREE_CODE (value) == COMPLEX_CST
c-common.c:1245 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
--
c-common.c:1251 }
c-common.c:1252:===> else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
c-common.c:1253 {
--
c-common.c:2253 if (!real1 && !real2
c-common.c:2254:===> && TREE_CODE (primop1) == INTEGER_CST
c-common.c:2255 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
--
c-common.c:2601
c-common.c:2602:===> if (TREE_CODE (expr) == ERROR_MARK)
c-common.c:2603 return expr;
--
c-common.c:2626:
c-common.c:2627:===> switch (TREE_CODE (expr))
c-common.c:2628 {
--
convert.c:84 but 2.0 is double constant. */
convert.c:85:===> if (TREE_CODE (exp) == REAL_CST)
convert.c:86 {
--
convert.c:101:
convert.c:102:===> if (TREE_CODE (exp) != NOP_EXPR)
convert.c:103 return exp;
--
convert.c:203 if (itype != type && FLOAT_TYPE_P (type))
convert.c:204:===> switch (TREE_CODE (expr))
convert.c:205 {
--
convert.c:286
convert.c:287:===> enum tree_code ex_form = TREE_CODE (expr);
convert.c:288 tree intype = TREE_TYPE (expr);
--
cp/cvt.c:701 about this since it is so bad. */
cp/cvt.c:702:===> if (TREE_CODE (expr) == FUNCTION_DECL)
cp/cvt.c:703 fn = expr;
cp/cvt.c:704:===> else if (TREE_CODE (expr) == ADDR_EXPR
cp/cvt.c:705 && TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL)
--
cp/cvt.c:807 return expr;
cp/cvt.c:808:===> switch (TREE_CODE (expr))
cp/cvt.c:809 {
--
cp/cvt.c:889
cp/cvt.c:890:===> if (TREE_CODE (probe) == ADDR_EXPR)
cp/cvt.c:891 probe = TREE_OPERAND (expr, 0);
--
cp/decl.c:7547 {
cp/decl.c:7548:===> if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
cp/decl.c:7549 {
--
cp/decl.c:7572 type = TREE_TYPE (decl);
cp/decl.c:7573:===> if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
cp/decl.c:7574 TREE_TYPE (init) = type;
--
cp/decl.c:7612 dont_use_constructor:
cp/decl.c:7613:===> if (TREE_CODE (init) != TREE_VEC)
cp/decl.c:7614 init = store_init_value (decl, init);
--
cp/decl.c:7874:
cp/decl.c:7875:===> if (init && TREE_CODE (init) == NAMESPACE_DECL)
cp/decl.c:7876 {
--
cp/decl.c:14366
cp/decl.c:14367:===> switch (TREE_CODE (&t->generic))
cp/decl.c:14368 {
--
cp/semantics.c:1194
cp/semantics.c:1195:===> if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expr))))
cp/semantics.c:1196 /* This inhibits warnings in c_common_truthvalue_conversion. */
--
cp/semantics.c:1198:
cp/semantics.c:1199:===> if (TREE_CODE (expr) == OFFSET_REF)
cp/semantics.c:1200 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
--
cp/tree.c:348:
cp/tree.c:349:===> if (TREE_CODE (init) == TARGET_EXPR)
cp/tree.c:350 return init;
--
cp/tree.c:881 /* A baselink is also considered an overloaded function. */
cp/tree.c:882:===> if (TREE_CODE (x) == OFFSET_REF)
cp/tree.c:883 x = TREE_OPERAND (x, 1);
cp/tree.c:884:===> if (BASELINK_P (x))
cp/tree.c:885 x = BASELINK_FUNCTIONS (x);
cp/tree.c:886:===> return (TREE_CODE (x) == FUNCTION_DECL
cp/tree.c:887:===> || TREE_CODE (x) == TEMPLATE_ID_EXPR
cp/tree.c:888:===> || DECL_FUNCTION_TEMPLATE_P (x)
cp/tree.c:889:===> || TREE_CODE (x) == OVERLOAD);
cp/tree.c:890
--
cp/tree.c:895 /* A baselink is also considered an overloaded function. */
cp/tree.c:896:===> if (TREE_CODE (x) == OFFSET_REF)
cp/tree.c:897 x = TREE_OPERAND (x, 1);
cp/tree.c:898:===> if (BASELINK_P (x))
cp/tree.c:899 x = BASELINK_FUNCTIONS (x);
cp/tree.c:900
cp/tree.c:901:===> return ((TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x))
cp/tree.c:902:===> || DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
cp/tree.c:903:===> || TREE_CODE (x) == TEMPLATE_ID_EXPR);
cp/tree.c:904
--
cp/typeck2.c:328 }
cp/typeck2.c:329:===> else if (TREE_CODE (init) == TREE_LIST
cp/typeck2.c:330 && TREE_TYPE (init) != unknown_type_node)
--
cp/typeck2.c:352:
cp/typeck2.c:353:===> if (TREE_CODE (value) == ERROR_MARK)
cp/typeck2.c:354 ;
--
cp/typeck2.c:399:
cp/typeck2.c:400:===> if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST
cp/typeck2.c:401 && TREE_VALUE (init) == error_mark_node))
--
cp/typeck2.c:403:
cp/typeck2.c:404:===> if (TREE_CODE (init) == ERROR_MARK)
cp/typeck2.c:405 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
--
cp/typeck2.c:415 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
cp/typeck2.c:416:===> if (TREE_CODE (init) == NON_LVALUE_EXPR)
cp/typeck2.c:417 init = TREE_OPERAND (init, 0);
cp/typeck2.c:418:
cp/typeck2.c:419:===> raw_constructor = (TREE_CODE (init) == CONSTRUCTOR
cp/typeck2.c:420 && TREE_HAS_CONSTRUCTOR (init));
--
cp/typeck2.c:503 }
cp/typeck2.c:504:===> while (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
cp/typeck2.c:505 {
--
cp/typeck.c:1289 /* Constants can be used directly unless they're not loadable. */
cp/typeck.c:1290:===> if (TREE_CODE (exp) == CONST_DECL)
cp/typeck.c:1291 exp = DECL_INITIAL (exp);
--
cp/typeck.c:1425:
cp/typeck.c:1426:===> if (TREE_CODE (exp) == STRING_CST)
cp/typeck.c:1427 {
--
cp/typeck.c:2827 it was unsigned. */
cp/typeck.c:2828:===> shorten = ((TREE_CODE (op0) == NOP_EXPR
cp/typeck.c:2829 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
--
cp/typeck.c:3151 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
cp/typeck.c:3152:===> else if (TREE_CODE (arg0) == INTEGER_CST
cp/typeck.c:3153 && (unsigned1 || !uns)
--
cp/typeck.c:3293:
cp/typeck.c:3294:===> if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
cp/typeck.c:3295:===> ^ (TREE_CODE (primop1) == BIT_NOT_EXPR))
cp/typeck.c:3296 {
--
cp/typeck.c:4405 if (TREE_CODE (type) != REFERENCE_TYPE
cp/typeck.c:4406:===> && TREE_CODE (expr) == NOP_EXPR
cp/typeck.c:4407 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
--
cp/typeck.c:4757 if (TREE_CODE (type) != REFERENCE_TYPE
cp/typeck.c:4758:===> && TREE_CODE (value) == NOP_EXPR
cp/typeck.c:4759 && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
--
cp/typeck.c:4865 /* Ignore any integer overflow caused by the cast. */
cp/typeck.c:4866:===> if (TREE_CODE (value) == INTEGER_CST)
cp/typeck.c:4867 {
--
cp/typeck.c:5181 NULL_TREE, 0);
cp/typeck.c:5182:===> if (TREE_CODE (newrhs) == CALL_EXPR
cp/typeck.c:5183 && TYPE_NEEDS_CONSTRUCTING (lhstype))
--
cp/typeck.c:5189 expanded without a target. */
cp/typeck.c:5190:===> if (TREE_CODE (newrhs) == TARGET_EXPR)
cp/typeck.c:5191 newrhs = build (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
--
cp/typeck.c:5542 {
cp/typeck.c:5543:===> if (TREE_CODE (expr) == INTEGER_CST
cp/typeck.c:5544 && TREE_NEGATED_INT (expr))
--
cp/typeck.c:5809 {
cp/typeck.c:5810:===> if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
cp/typeck.c:5811 whats_returned = TREE_OPERAND (whats_returned, 1);
cp/typeck.c:5812:===> else if (TREE_CODE (whats_returned) == CONVERT_EXPR
cp/typeck.c:5813:===> || TREE_CODE (whats_returned) == NON_LVALUE_EXPR
cp/typeck.c:5814:===> || TREE_CODE (whats_returned) == NOP_EXPR)
cp/typeck.c:5815 whats_returned = TREE_OPERAND (whats_returned, 0);
--
cp/typeck.c:5819:
cp/typeck.c:5820:===> if (TREE_CODE (whats_returned) != ADDR_EXPR)
cp/typeck.c:5821 return;
--
cp/typeck.c:5986 || current_function_return_value == retval)
cp/typeck.c:5987:===> && TREE_CODE (retval) == VAR_DECL
cp/typeck.c:5988 && DECL_CONTEXT (retval) == current_function_decl
--
cp/typeck.c:6027 else if (! current_function_returns_struct
cp/typeck.c:6028:===> && TREE_CODE (retval) == TARGET_EXPR
cp/typeck.c:6029 && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
--
fold-const.c:975:
fold-const.c:976:===> if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST)
fold-const.c:977 *litp = in;
fold-const.c:978:===> else if (TREE_CODE (in) == code
fold-const.c:979 || (! FLOAT_TYPE_P (TREE_TYPE (in))
--
fold-const.c:983 affected, so we can't. */
fold-const.c:984:===> && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
fold-const.c:985 || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
--
fold-const.c:1861:
fold-const.c:1862:===> if (TREE_CODE (arg0) != TREE_CODE (arg1)
fold-const.c:1863 /* This is needed for conversions and for COMPONENT_REF.
--
fold-const.c:1940:
fold-const.c:1941:===> switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
fold-const.c:1942 {
--
fold-const.c:2004 case 'e':
fold-const.c:2005:===> switch (TREE_CODE (arg0))
fold-const.c:2006 {
--
fold-const.c:2130
fold-const.c:2131:===> enum tree_code code = TREE_CODE (arg);
fold-const.c:2132 char class = TREE_CODE_CLASS (code);
--
fold-const.c:2335 tree type = TREE_TYPE (arg);
fold-const.c:2336:===> enum tree_code code = TREE_CODE (arg);
fold-const.c:2337:
--
fold-const.c:2999 {
fold-const.c:3000:===> code = TREE_CODE (exp);
fold-const.c:3001:
--
fold-const.c:3228 /* If EXP is a constant, we can evaluate whether this is true or false. */
fold-const.c:3229:===> if (TREE_CODE (exp) == INTEGER_CST)
fold-const.c:3230 {
--
fold-const.c:4151 tree type = TREE_TYPE (t);
fold-const.c:4152:===> enum tree_code tcode = TREE_CODE (t);
fold-const.c:4153 tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
--
fold-const.c:4903 if ((code == NE_EXPR || code == EQ_EXPR)
fold-const.c:4904:===> && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
fold-const.c:4905 && integer_pow2p (TREE_OPERAND (arg0, 1)))
--
fold-const.c:4989:
fold-const.c:4990:===> if (TREE_CODE (arg1) == INTEGER_CST)
fold-const.c:4991 return 0;
fold-const.c:4992:===> if (TREE_CODE (arg0) == INTEGER_CST)
fold-const.c:4993 return 1;
fold-const.c:4994:
fold-const.c:4995:===> if (TREE_CODE (arg1) == REAL_CST)
fold-const.c:4996 return 0;
fold-const.c:4997:===> if (TREE_CODE (arg0) == REAL_CST)
fold-const.c:4998 return 1;
fold-const.c:4999:
fold-const.c:5000:===> if (TREE_CODE (arg1) == COMPLEX_CST)
fold-const.c:5001 return 0;
fold-const.c:5002:===> if (TREE_CODE (arg0) == COMPLEX_CST)
fold-const.c:5003 return 1;
--
fold-const.c:5065:
fold-const.c:5066:===> if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
fold-const.c:5067 subop = TREE_REALPART (arg0);
--
fold-const.c:5070:
fold-const.c:5071:===> if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
fold-const.c:5072:===> && TREE_CODE (subop) != REAL_CST)
fold-const.c:5073 /* Note that TREE_CONSTANT isn't enough:
--
fold-const.c:5099:
fold-const.c:5100:===> if (TREE_CODE (op) == COMPLEX_CST)
fold-const.c:5101 subop = TREE_REALPART (op);
--
fold-const.c:5104:
fold-const.c:5105:===> if (TREE_CODE (subop) != INTEGER_CST
fold-const.c:5106:===> && TREE_CODE (subop) != REAL_CST)
fold-const.c:5107 /* Note that TREE_CONSTANT isn't enough:
--
fold-const.c:5146 || code == EQ_EXPR || code == NE_EXPR)
fold-const.c:5147:===> && ((truth_value_p (TREE_CODE (arg0))
fold-const.c:5148 && (truth_value_p (TREE_CODE (arg1))
--
fold-const.c:5150 && integer_onep (TREE_OPERAND (arg1, 1)))))
fold-const.c:5151:===> || (truth_value_p (TREE_CODE (arg1))
fold-const.c:5152 && (truth_value_p (TREE_CODE (arg0))
--
fold-const.c:5168 {
fold-const.c:5169:===> if (TREE_CODE (arg0) == COMPOUND_EXPR)
fold-const.c:5170 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
fold-const.c:5171 fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
fold-const.c:5172:===> else if (TREE_CODE (arg0) == COND_EXPR)
fold-const.c:5173 {
--
fold-const.c:5213 }
fold-const.c:5214:===> else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
fold-const.c:5215 return fold (build (COND_EXPR, type, arg0,
--
fold-const.c:5219 else if (TREE_CODE_CLASS (code) == '<'
fold-const.c:5220:===> && TREE_CODE (arg0) == COMPOUND_EXPR)
fold-const.c:5221 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
--
fold-const.c:5223 else if (TREE_CODE_CLASS (code) == '<'
fold-const.c:5224:===> && TREE_CODE (arg1) == COMPOUND_EXPR)
fold-const.c:5225 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
--
fold-const.c:5229 {
fold-const.c:5230:===> if (TREE_CODE (arg1) == COMPOUND_EXPR
fold-const.c:5231 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg1, 0))
--
fold-const.c:5235 arg0, TREE_OPERAND (arg1, 1))));
fold-const.c:5236:===> else if ((TREE_CODE (arg1) == COND_EXPR
fold-const.c:5237:===> || (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
fold-const.c:5238 && TREE_CODE_CLASS (code) != '<'))
--
fold-const.c:5246 /*cond_first_p=*/0);
fold-const.c:5247:===> else if (TREE_CODE (arg0) == COMPOUND_EXPR)
fold-const.c:5248 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
fold-const.c:5249 fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
fold-const.c:5250:===> else if ((TREE_CODE (arg0) == COND_EXPR
fold-const.c:5251:===> || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
fold-const.c:5252 && TREE_CODE_CLASS (code) != '<'))
--
fold-const.c:5285 /* Handle cases of two conversions in a row. */
fold-const.c:5286:===> if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
fold-const.c:5287:===> || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
fold-const.c:5288 {
--
fold-const.c:5363:
fold-const.c:5364:===> if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
fold-const.c:5365 && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
--
fold-const.c:5386 && TREE_CODE (TREE_TYPE (t)) != BOOLEAN_TYPE
fold-const.c:5387:===> && TREE_CODE (TREE_OPERAND (t, 0)) == BIT_AND_EXPR
fold-const.c:5388 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 1)) == INTEGER_CST)
--
fold-const.c:5620 /* (-A) + B -> B - A */
fold-const.c:5621:===> if (TREE_CODE (arg0) == NEGATE_EXPR)
fold-const.c:5622 return fold (build (MINUS_EXPR, type, arg1, TREE_OPERAND (arg0, 0)));
--
fold-const.c:5631 simplifications. */
fold-const.c:5632:===> if (TREE_CODE (arg0) == BIT_AND_EXPR
fold-const.c:5633 && TREE_CODE (arg1) == BIT_AND_EXPR
--
fold-const.c:5646 take advantage of the factoring cases below. */
fold-const.c:5647:===> if ((TREE_CODE (arg0) == PLUS_EXPR
fold-const.c:5648 && TREE_CODE (arg1) == MULT_EXPR)
--
fold-const.c:5678:
fold-const.c:5679:===> if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
fold-const.c:5680 {
--
fold-const.c:5814 enum tree_code code0, code1;
fold-const.c:5815:===> code0 = TREE_CODE (arg0);
fold-const.c:5816 code1 = TREE_CODE (arg1);
--
fold-const.c:6064 /* (-A) * (-B) -> A * B */
fold-const.c:6065:===> if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
fold-const.c:6066 return fold (build (MULT_EXPR, type,
--
fold-const.c:6068 negate_expr (arg1)));
fold-const.c:6069:===> if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
fold-const.c:6070 return fold (build (MULT_EXPR, type,
--
fold-const.c:6769 return non_lvalue (convert (type, arg1));
fold-const.c:6770:===> if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
fold-const.c:6771 /* Preserve sequence points. */
--
fold-const.c:6793 might change the truth-value of A. */
fold-const.c:6794:===> if (TREE_CODE (arg0) == TREE_CODE (arg1)
fold-const.c:6795 && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
--
fold-const.c:6909 /* (-a) CMP (-b) -> b CMP a */
fold-const.c:6910:===> if (TREE_CODE (arg0) == NEGATE_EXPR
fold-const.c:6911 && TREE_CODE (arg1) == NEGATE_EXPR)
--
fold-const.c:6920 /* (-a) CMP CST -> a swap(CMP) (-CST) */
fold-const.c:6921:===> if (TREE_CODE (arg0) == NEGATE_EXPR)
fold-const.c:6922 return
--
fold-const.c:7006:
fold-const.c:7007:===> if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
fold-const.c:7008 {
--
fold-const.c:7076 }
fold-const.c:7077:===> else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
fold-const.c:7078 {
--
fold-const.c:7142 optimizations involving comparisons with non-negative constants. */
fold-const.c:7143:===> if (TREE_CODE (arg1) == INTEGER_CST
fold-const.c:7144:===> && TREE_CODE (arg0) != INTEGER_CST
fold-const.c:7145 && tree_int_cst_sgn (arg1) > 0)
--
fold-const.c:7166:
fold-const.c:7167:===> if (TREE_CODE (arg1) == INTEGER_CST
fold-const.c:7168 && ! TREE_CONSTANT_OVERFLOW (arg1)
--
fold-const.c:7286 if ((code == EQ_EXPR || code == NE_EXPR)
fold-const.c:7287:===> && TREE_CODE (arg1) == INTEGER_CST
fold-const.c:7288:===> && (TREE_CODE (arg0) == PLUS_EXPR
fold-const.c:7289:===> || TREE_CODE (arg0) == MINUS_EXPR)
fold-const.c:7290 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
--
fold-const.c:7298 else if ((code == EQ_EXPR || code == NE_EXPR)
fold-const.c:7299:===> && TREE_CODE (arg0) == NEGATE_EXPR
fold-const.c:7300 && TREE_CODE (arg1) == INTEGER_CST
--
fold-const.c:7308 else if ((code == NE_EXPR || code == EQ_EXPR)
fold-const.c:7309:===> && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
fold-const.c:7310 return fold (build (code, type,
--
fold-const.c:7316 else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
fold-const.c:7317:===> && TREE_CODE (arg0) == NOP_EXPR
fold-const.c:7318 && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
--
fold-const.c:7326 constant, we can simplify it. */
fold-const.c:7327:===> else if (TREE_CODE (arg1) == INTEGER_CST
fold-const.c:7328:===> && (TREE_CODE (arg0) == MIN_EXPR
fold-const.c:7329:===> || TREE_CODE (arg0) == MAX_EXPR)
fold-const.c:7330 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
--
fold-const.c:7354 if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
fold-const.c:7355:===> && TREE_CODE (arg0) == BIT_AND_EXPR)
fold-const.c:7356 {
--
fold-const.c:7388 && ! TREE_UNSIGNED (TREE_TYPE (arg0))
fold-const.c:7389:===> && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
fold-const.c:7390:===> || TREE_CODE (arg0) == CEIL_MOD_EXPR
fold-const.c:7391:===> || TREE_CODE (arg0) == FLOOR_MOD_EXPR
fold-const.c:7392:===> || TREE_CODE (arg0) == ROUND_MOD_EXPR)
fold-const.c:7393 && integer_pow2p (TREE_OPERAND (arg0, 1)))
--
fold-const.c:7405 if (code == NE_EXPR && integer_zerop (arg1)
fold-const.c:7406:===> && TREE_CODE (arg0) == BIT_AND_EXPR
fold-const.c:7407 && integer_onep (TREE_OPERAND (arg0, 1)))
--
fold-const.c:7412 if ((code == EQ_EXPR || code == NE_EXPR)
fold-const.c:7413:===> && TREE_CODE (arg0) == BIT_AND_EXPR
fold-const.c:7414 && integer_pow2p (TREE_OPERAND (arg0, 1))
--
fold-const.c:7427 if ((code == EQ_EXPR || code == NE_EXPR)
fold-const.c:7428:===> && TREE_CODE (arg0) == BIT_AND_EXPR
fold-const.c:7429 && TREE_CODE (arg1) == INTEGER_CST
--
fold-const.c:7444 if ((code == EQ_EXPR || code == NE_EXPR)
fold-const.c:7445:===> && TREE_CODE (arg0) == BIT_IOR_EXPR
fold-const.c:7446 && TREE_CODE (arg1) == INTEGER_CST
--
fold-const.c:7528:
fold-const.c:7529:===> if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
fold-const.c:7530 {
--
fold-const.c:7617 /* If this is a comparison of a field, we may be able to simplify it. */
fold-const.c:7618:===> if (((TREE_CODE (arg0) == COMPONENT_REF
fold-const.c:7619 && (*lang_hooks.can_use_bit_fields_p) ())
fold-const.c:7620:===> || TREE_CODE (arg0) == BIT_FIELD_REF)
fold-const.c:7621 && (code == EQ_EXPR || code == NE_EXPR)
--
fold-const.c:7665 && integer_zerop (arg1)
fold-const.c:7666:===> && TREE_CODE (arg0) == CALL_EXPR)
fold-const.c:7667 {
--
fold-const.c:7712 otherwise return T. */
fold-const.c:7713:===> if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
fold-const.c:7714 {
--
fold-const.c:7736 /* Two real constants can be compared explicitly. */
fold-const.c:7737:===> else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
fold-const.c:7738 {
--
fold-const.c:7773 so all simple results must be passed through pedantic_non_lvalue. */
fold-const.c:7774:===> if (TREE_CODE (arg0) == INTEGER_CST)
fold-const.c:7775 return pedantic_non_lvalue
--
fold-const.c:7784:
fold-const.c:7785:===> if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
fold-const.c:7786 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
--
fold-const.c:7947 if (INTEGRAL_TYPE_P (type)
fold-const.c:7948:===> && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
fold-const.c:7949 && TREE_CODE (arg2) == INTEGER_CST)
--
tree.c:587:
tree.c:588:===> return ((TREE_CODE (expr) == INTEGER_CST
tree.c:589 && ! TREE_CONSTANT_OVERFLOW (expr)
--
tree.c:591 && TREE_INT_CST_HIGH (expr) == 0)
tree.c:592:===> || (TREE_CODE (expr) == COMPLEX_CST
tree.c:593 && integer_zerop (TREE_REALPART (expr))
--
tree.c:604:
tree.c:605:===> return ((TREE_CODE (expr) == INTEGER_CST
tree.c:606 && ! TREE_CONSTANT_OVERFLOW (expr)
--
tree.c:608 && TREE_INT_CST_HIGH (expr) == 0)
tree.c:609:===> || (TREE_CODE (expr) == COMPLEX_CST
tree.c:610 && integer_onep (TREE_REALPART (expr))
--
tree.c:811:
tree.c:812:===> return ((TREE_CODE (expr) == REAL_CST
tree.c:813 && ! TREE_CONSTANT_OVERFLOW (expr)
tree.c:814 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
tree.c:815:===> || (TREE_CODE (expr) == COMPLEX_CST
tree.c:816 && real_zerop (TREE_REALPART (expr))
--
tree.c:826:
tree.c:827:===> return ((TREE_CODE (expr) == REAL_CST
tree.c:828 && ! TREE_CONSTANT_OVERFLOW (expr)
tree.c:829 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
tree.c:830:===> || (TREE_CODE (expr) == COMPLEX_CST
tree.c:831 && real_onep (TREE_REALPART (expr))
--
tree.c:856:
tree.c:857:===> return ((TREE_CODE (expr) == REAL_CST
tree.c:858 && ! TREE_CONSTANT_OVERFLOW (expr)
tree.c:859 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1))
tree.c:860:===> || (TREE_CODE (expr) == COMPLEX_CST
tree.c:861 && real_minus_onep (TREE_REALPART (expr))
--
tree.c:1473
tree.c:1474:===> enum tree_code code = TREE_CODE (t);
tree.c:1475:
--
tree.c:1885:
tree.c:1886:===> switch (TREE_CODE (exp))
tree.c:1887 {
--
tree.c:1912 the situation. */
tree.c:1913:===> if ((int) TREE_CODE (exp) >= (int) LAST_AND_UNUSED_TREE_CODE)
tree.c:1914 return -1;
tree.c:1915:
tree.c:1916:===> nops = first_rtl_op (TREE_CODE (exp));
tree.c:1917 for (i = 0; i < nops; i++)
--
tree.c:1919 {
tree.c:1920:===> int type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
tree.c:1921 if (type == 'e' || type == '<' || type == '1' || type == '2'
--
tree.c:4128:
tree.c:4129:===> while (TREE_CODE (op) == NOP_EXPR)
tree.c:4130 {
--
tree.c:4168:
tree.c:4169:===> if (TREE_CODE (op) == COMPONENT_REF
tree.c:4170 /* Since type_for_size always gives an integer type. */
--
tree-inline.c:427 ifndef INLINER_FOR_JAVA
tree-inline.c:428:===> if (TREE_CODE (*tp) == RETURN_STMT && id->ret_label)
tree-inline.c:429 else /* INLINER_FOR_JAVA */
--
tree-inline.c:491 endif
tree-inline.c:492:===> else if (TREE_CODE (*tp) == SAVE_EXPR)
tree-inline.c:493 remap_save_expr (tp, id->decl_map, VARRAY_TREE (id->fns, 0),
tree-inline.c:494 walk_subtrees);
tree-inline.c:495:===> else if (TREE_CODE (*tp) == UNSAVE_EXPR)
tree-inline.c:496 /* UNSAVE_EXPRs should not be generated until expansion time. */
--
tree-inline.c:500 can write out debugging information for the inlined variables. */
tree-inline.c:501:===> else if (TREE_CODE (*tp) == SCOPE_STMT && !id->in_target_cleanup_p)
tree-inline.c:502 copy_scope_stmt (tp, walk_subtrees, id);
--
tree-inline.c:530 {
tree-inline.c:531:===> if (TREE_CODE (*tp) == MODIFY_EXPR
tree-inline.c:532 && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1)
--
tree-inline.c:553 }
tree-inline.c:554:===> else if (TREE_CODE (*tp) == ADDR_EXPR
tree-inline.c:555 && ((*lang_hooks.tree_inlining.auto_var_in_fn_p)
--
tree-inline.c:579 original node was expanded already. */
tree-inline.c:580:===> if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
tree-inline.c:581 {
--
tree-inline.c:889:
tree-inline.c:890:===> switch (TREE_CODE (node))
tree-inline.c:891 {
--
Carlo Wood <carlo@alinoe.com>