OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [ChangeLog.ptr] - Blame information for rev 826

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
2007-06-14  Andrew Pinski  
2
 
3
        Merge mainline, revision 125733
4
 
5
2007-06-14  Andrew Pinski  
6
 
7
        * tree-vrp.c (compare_values_warnv): Fix spelling/grammer
8
        mistakes
9
        (extract_range_from_binary_expr): Likewise.
10
        * doc/c-tree.texi (POINTER_PLUS_EXPR): Likewise.
11
        * tree-ssa-loop-niter.c (assert_loop_rolls_lt): Add vertical
12
        whitespace.
13
        * tree-pretty-print.c (op_symbol_code ):
14
        Change print out to "+".
15
        * tree-scalar-evolution.c (instantiate_parameters_1):
16
        Use chrec_type instead of TREE_TYPE.
17
        * builtins.c (expand_builtin_strcat): Fix vertical whitespace.
18
        (std_expand_builtin_va_start): Fix whitespace.
19
        (fold_builtin_strstr): Use size_int instead of build_int_cst (sizetype.
20
        (fold_builtin_strchr): Likewise.
21
        (fold_builtin_strrchr): Likewise.
22
        (fold_builtin_strpbrk): Likewise.
23
        * fold-const.c (try_move_mult_to_index): Fix spelling/grammer
24
        mistakes.
25
        (fold_to_nonsharp_ineq_using_bound): Merge the two ifs at the end.
26
        (fold_binary): Fix spelling/grammer mistakes.
27
        * tree-ssa-ccp.c (maybe_fold_stmt_addition): Assert that only
28
        a POINTER_PLUS_EXPR is passed in.
29
        * tree-ssa-loop-ivopts.c (determine_base_object):
30
        Fix spelling/grammer mistakes.
31
        * expr.c (expand_expr_real_1): Likewise.
32
        * tree-data-ref.c (split_constant_offset): Likewise.
33
        * c-typeck.c (build_unary_op): Use fold_convert instead of convert
34
        for converting to sizetype.
35
        * tree.def (POINTER_PLUS_EXPR): Fix comment.
36
        * tree-ssa-forwprop.c (forward_propagate_addr_expr_1):
37
        Fix spelling/grammer mistakes.
38
        (phiprop_insert_phi): Likewise.
39
        * c-common.c (pointer_int_sum): Remove FIXME about
40
        POINTER_MINUS_EXPR.
41
 
42
2007-06-13  Andrew Pinski  
43
 
44
        * expr.c (expand_expr_real_1 ): Remove assert
45
        for checking the modes of the operands are the same.
46
 
47
2007-06-12  Andrew Pinski  
48
 
49
        * config/sparc/sparc.c (sparc_gimplify_va_arg): Use POINTER_PLUS_EXPR
50
        instead of PLUS_EXPR when the operand was a pointer.  Don't create a
51
        BIT_AND_EXPR for pointer types.
52
 
53
2007-06-12  Andrew Pinski  
54
 
55
        * config/mips/mips.c (mips_va_start): Use POINTER_PLUS_EXPR
56
        for pointers.
57
        (mips_gimplify_va_arg_expr): Likewise.
58
        Don't create BIT_AND_EXPR in a pointer type.
59
 
60
2007-06-12  Andrew Pinski  
61
 
62
        Merge mainline, revision 125658
63
 
64
2007-06-11  Andrew Pinski  
65
 
66
        Merge mainline, revision 125611
67
 
68
2007-06-07  Andrew Pinski  
69
 
70
        * matrix-reorg.c (collect_data_for_malloc_call): Stmt
71
        will now only be either INDIRECT_REF and POINTER_PLUS_EXPR.
72
        Offset only holds something for PLUS_EXPR.
73
        (ssa_accessed_in_tree): Handle POINTER_PLUS_EXPR just as
74
        a PLUS_EXPR.
75
        (analyze_transpose): POINTER_PLUS_EXPR will only show up now
76
        and not PLUS_EXPR.
77
        (analyze_accesses_for_modify_stmt): Likewise.
78
        Remove comment about the type being integral type as it is
79
        wrong now.
80
        (analyze_matrix_accesses): Handle POINTER_PLUS_EXPR as
81
        PLUS_EXPR.
82
        (transform_access_sites): POINTER_PLUS_EXPR will only show up now
83
        and not PLUS_EXPR.
84
        Correct the type which the artimentic is done in (is now
85
        sizetype).
86
        Reindent one loop.
87
 
88
2007-06-07  Andrew Pinski  
89
 
90
        * config/ia64/ia64.c (ia64_gimplify_va_arg): Use
91
        POINTER_PLUS_EXPR for pointers and create the
92
        BIT_AND_EXPR in sizetype.
93
        * config/s390/s390.c (s390_va_start): Use POINTER_PLUS_EXPR
94
        for pointers instead of PLUS_EXPR.
95
        (s390_gimplify_va_arg): Likewise.
96
 
97
2007-06-07  Andrew Pinski  
98
 
99
        * config/frv/frv.c (frv_expand_builtin_va_start): Use sizetype
100
        with make_tree, instead of a pointer type.
101
        * config/pa/pa.c (reloc_needed): Handle POINTER_PLUS_EXPR
102
        as PLUS_EXPR/MINUS_EXPR.
103
        (hppa_gimplify_va_arg_expr): Don't create MINUS_EXPR or
104
        PLUS_EXPR for pointers, instead use POINTER_PLUS_EXPR.
105
        Don't use BIT_AND_EXPR on a pointer type, convert the
106
        expression to sizetype first.
107
 
108
2007-06-06  Andrew Pinski  
109
 
110
        * tree-ssa-forwprop.c
111
        (forward_propagate_addr_into_variable_array_index):
112
        Don't expect a statement for the size 1 case.
113
        Use the offset variable for the size 1 case.
114
        Look through use-def chains to find the mutliply
115
        for the non size 1 case.
116
        (forward_propagate_addr_expr_1): Call
117
        forward_propagate_addr_into_variable_array_index with
118
        the SSA_NAME instead of the statement.
119
 
120
2007-06-06  Andrew Pinski  
121
 
122
        PR tree-opt/32225
123
        * tree-scalar-evolution.c (follow_ssa_edge_in_rhs 
124
        POINTER_PLUS_EXPR>): Do not change type_rhs.
125
        (follow_ssa_edge_in_rhs ):
126
        Use the code of the orginal expression instead of just PLUS_EXPR.
127
        Also use type_rhs where TREE_TYPE (rhs) was used (reverting back
128
        to the trunk).
129
 
130
2007-06-03  Andrew Pinski  
131
 
132
        * tree-predcom.c (ref_at_iteration): If we have a pointer
133
        type do the multiplication in sizetype.
134
 
135
2007-06-01  Andrew Pinski  
136
 
137
        Merge mainline, revision 125285
138
 
139
2007-05-31  Andrew Pinski  
140
 
141
        * tree-vrp.c (extract_range_from_binary_expr): Handle
142
        MIN_EXPR/MAX_EXPR for pointers type.
143
 
144
        PR tree-opt/32167
145
        * tree-chrec.c (chrec_fold_plus): When either
146
        operand is zero, convert the other operand.
147
 
148
2007-05-30  Andrew Pinski  
149
 
150
        * builtins.c (std_expand_builtin_va_start): Use
151
        sizetype for the call to make_tree and then convert
152
        to the pointer type.
153
 
154
2007-05-30  Andrew Pinski  
155
 
156
        PR tree-op/32145
157
        * tree-vrp.c (extract_range_from_assert): Create
158
        POINTER_PLUS_EXPR for pointer types.
159
 
160
        PR tree-opt/32144
161
        * tree-chrec.c (chrec_fold_plus_poly_poly): If the
162
        first chrec is a pointer type, then the second should
163
        be sizetype and not the first's type.
164
 
165
2007-05-28  Andrew Pinski  
166
 
167
        * fold-const.c (try_move_mult_to_index):
168
        Say why we strip the nops.
169
        (fold_unary ): Remove
170
        TODO as we cannot get that case.
171
        * tree-chrec.c (chrec_fold_plus):
172
        Cleanup the code to chose which
173
        tree code is used.
174
        (chrec_convert_rhs): Add comment on
175
        why the increment is sizetype for
176
        pointers.
177
        * tree-mudflap.c (mf_xform_derefs_1):
178
        Use size_int instead of build_int_cst.
179
        * tree-ssa-loop-prefetch.c (issue_prefetch_ref): Likewise.
180
 
181
2007-05-21  Andrew Pinski  
182
 
183
        PR tree-opt/32015
184
        * tree.c (build2_stat): Make sure that
185
        MULT_EXPR is not used with pointers.
186
        * tree-chrec.c (chrec_apply): Use chrec_convert_rhs
187
        on the argument x instead of chrec_convert.
188
 
189
2007-05-20  Kaz Kojima  
190
 
191
        * config/sh/sh.c (sh_va_start): Call make_tree with sizetype
192
        and convert its result to a pointer type.  Use POINTER_PLUS_EXPR
193
        for the pointer additions and also use size_int for the offsets.
194
        (sh_gimplify_va_arg_expr): Use POINTER_PLUS_EXPR for the pointer
195
        additions and also use size_int for the offsets.  Perform
196
        BIT_AND_EXPR on sizetype arguments.
197
 
198
2007-05-15  Andrew Pinski  
199
 
200
        * tree-ssa-forwprop (forward_propagate_addr_into_variable_array_index):
201
        Don't expect there to be a cast for the index as that
202
        does not exist anymore.
203
        (forward_propagate_addr_expr_1): Check for
204
        POINTER_PLUS_EXPR instead of PLUS_EXPR.
205
        Don't check for the first operand of the
206
        POINTER_PLUS_EXPR was the index as it
207
        cannot be.
208
 
209
2007-05-15  Richard Guenther  
210
 
211
        * config/i386/i386.c (ix86_gimplify_va_arg): Use POINTER_PLUS_EXPR,
212
        perform BIT_AND_EXPR on sizetype arguments.
213
 
214
2007-05-15  Andrew Pinski  
215
 
216
        * config/rs6000/rs6000.c (rs6000_va_start): Use POINTER_PLUS_EXPR
217
        instead of PLUS_EXPR for pointer addition.
218
        (rs6000_va_start): Likewise.
219
        Also use sizetype for the offset.
220
        * tree-stdarg.c (va_list_counter_bump): Check for PLUS_EXPR
221
        and POINTER_PLUS_EXPR.
222
        (check_va_list_escapes): Likewise.
223
 
224
2007-05-14  Andrew Pinski  
225
 
226
        * config/i386/i386.c (ix86_va_start): Use POINTER_PLUS_EXPR
227
        for the pointer addition and also use size_int/sizetype
228
        for the offset.
229
        (ix86_gimplify_va_arg): Likewise.
230
 
231
2007-05-14  Andrew Pinski  
232
 
233
        Merge mainline, revision 124657
234
        * tree-data-ref.c (split_constant_offset): Handle
235
        POINTER_PLUS_EXPR
236
        exactly the same as PLUS_EXPR/MINUS_EXPR except for the offset
237
        needs to be calcuated using PLUS_EXPR instead of
238
        POINTER_PLUS_EXPR.
239
        * builtins.c (fold_builtin_memchr): Use POINTER_PLUS_EXPR
240
        instead of PLUS_EXPR for adding to a pointer.
241
 
242
2006-05-15  Zdenek Dvorak 
243
 
244
        * tree-ssa-loop-ivopts.c (determine_base_object): Abort for PLUS_EXPR
245
        in pointer type.
246
 
247
2007-05-12  Andrew Pinski  
248
 
249
        * tree-ssa-address.c (tree_mem_ref_addr): When adding
250
        the offset to the base, use POINTER_PLUS_EXPR.
251
 
252
2007-05-12  Andrew Pinski  
253
 
254
        * expr.c (expand_expr_addr_expr_1): Call expand_expr
255
        for the offset with the modifier as EXPAND_INITIALIZER
256
        if the modifier is EXPAND_INITIALIZER.
257
        (expand_expr_real_1 ): Don't force to
258
        a register if we had an overflow.
259
 
260
2007-05-10  Andrew Pinski  
261
 
262
        Merge mainline, revision 124602.
263
 
264
        * fold-const.c  (extract_array_ref): Make sure the offset
265
        is converted to sizetype.
266
        (try_move_mult_to_index): Strip the NOPs from the offset.
267
        (fold_binary ): Convert the second
268
        operand to sizetype before calling try_move_mult_to_index.
269
        * tree-ssa-loop-niter.c (number_of_iterations_lt_to_ne):
270
        For pointer types, use sizetype when
271
        creating MINUS_EXPR/PLUS_EXPRs.
272
        * tree-ssa-ccp.c (maybe_fold_stmt_indirect): Make sure
273
        the offset is converted to sizetype.
274
 
275
2007-05-11  Andrew Pinski  
276
 
277
        * config/spu/spu.c (spu_va_start): Create POINTER_PLUS_EXPR
278
        instead of PLUS_EXPR when doing addition on pointer
279
        types.  Use sizetype for the second operand.
280
        (spu_gimplify_va_arg_expr): Likewise.
281
        * tree-ssa.c (tree_ssa_useless_type_conversion_1):
282
        Convert the MIN/MAX of the inner type to the outer
283
        type before comparing them.
284
 
285
2007-05-09  Andrew Pinski  
286
            Zdenek Dvorak  
287
 
288
        * fold-const.c  (fold_to_nonsharp_ineq_using_bound): Don't
289
        use a pointer type for MINUS_EXPR.
290
        (fold_binary ): Fold (PTR0 p+ A) - (PTR1 p+ B)
291
        into (PTR0 - PTR1) + (A - B). Fold (PTR0 p+ A) - PTR1 into
292
        (PTR0 - PTR1) + A iff (PTR0 - PTR1) simplifies.
293
        * tree-chrec.c (chrec_fold_plus_poly_poly): For
294
        POINTER_PLUS_EXPR, use a different right hand side type.
295
        Handle POINTER_PLUS_EXPR like PLUS_EXPR.
296
        (chrec_fold_plus_1): Likewise.
297
        (convert_affine_scev): Likewise.
298
        (chrec_convert_aggressive): Likewise.
299
        (chrec_fold_plus): For pointer types, use POINTER_PLUS_EXPR
300
        instead of PLUS_EXPR.
301
        (reset_evolution_in_loop): For pointer types, the new_evol
302
        should be sizetype.
303
        (chrec_convert_rhs): New function.
304
        * tree-chrec.h (chrec_convert_rhs): New prototype.
305
        (build_polynomial_chrec): For pointer types, the right hand
306
        side should be sizetype and not the same as the left hand side.
307
        * tree-scalar-evolution.c (add_to_evolution_1): Convert the
308
        increment using chrec_convert_rhs instead of chrec_convert.
309
        (follow_ssa_edge_in_rhs): Handle POINTER_PLUS_EXPR like
310
        PLUS_EXPR except for the right hand side's type will be
311
        sizetype.
312
        (interpret_rhs_modify_stmt): Handle POINTER_PLUS_EXPR.
313
        (fold_used_pointer_cast): Kill.
314
        (pointer_offset_p): Kill.
315
        (fold_used_pointer): Kill.
316
        (pointer_used_p): Kill.
317
        (analyze_scalar_evolution_1 ): Don't
318
        call fold_used_pointer.
319
        (instantiate_parameters_1): Convert the increment
320
        using chrec_convert_rhs instead of chrec_convert.
321
        Handle POINTER_PLUS_EXPR as PLUS_EXPR.
322
        * tree-ssa-loop-niter.c (split_to_var_and_offset): Handle
323
        POINTER_PLUS_EXPR as PLUS_EXPR.
324
        (assert_loop_rolls_lt): For pointer types, use sizetype when
325
        creating MINUS_EXPR/PLUS_EXPRs.
326
        (number_of_iterations_le): Likewise.
327
        (expand_simple_operations): POINTER_PLUS_EXPR are simple also.
328
        (derive_constant_upper_bound): Handle POINTER_PLUS_EXPR just
329
        like PLUS_EXPR and MINUS_EXPR.
330
        * tree-data-ref.c (analyze_offset_expr): Likewise.
331
        (address_analysis): Handle POINTER_PLUS_EXPR as PLUS_EXPR.
332
        (analyze_offset): Handle POINTER_PLUS_EXPR also.
333
        (create_data_ref): Convert the increment
334
        using chrec_convert_rhs instead of chrec_convert.
335
        * tree-vect-transform.c (vect_update_ivs_after_vectorizer):
336
        For pointer types, create POINTER_PLUS_EXPR instead of
337
        PLUS_EXPR and also create MULT_EXPR in sizetype.
338
 
339
2007-05-07  Andrew Pinski  
340
 
341
        * builtins.c (std_gimplify_va_arg_expr): Use fold_build2 for
342
        the creating of POINTER_PLUS_EXPR.  For the BIT_AND_EXPR, cast
343
        the operands to sizetype first and then cast the BIT_AND_EXPR
344
        back to the pointer type.
345
        * tree-ssa-address.c (create_mem_ref): Create A
346
        POINTER_PLUS_EXPR for one case.
347
        * tree.c (const_hash_1): Handle POINTER_PLUS_EXPR same as
348
        PLUS_EXPR.
349
        (compare_constant): Likewise.
350
        (copy_constant): Likewise.
351
        (compute_reloc_for_constant): Likewise.
352
        (output_addressed_constants): Likewise.
353
 
354
2007-05-07  Andrew Pinski  
355
 
356
        * tree.def (POINTER_PLUS_EXPR): The second operand
357
        is of type sizetype and not ssizetype.
358
        * doc/c-tree.texi (POINTER_PLUS_EXPR): Document.
359
 
360
2007-05-06  Andrew Pinski  
361
 
362
        * tree-mudflap.c (mf_xform_derefs_1 ):
363
        Add a conversion of ofs to sizetype.
364
        (mf_decl_eligible_p): Reformat for length issues.
365
        (mf_xform_derefs_1): Likewise.
366
 
367
2007-05-06  Andrew Pinski  
368
 
369
        * tree.c (build2_stat): Check to make sure the
370
        second operand is compatiable with sizetype.
371
 
372
2007-05-06  Andrew Pinski  
373
 
374
        * tree-cfg.c (verify_expr): Change error
375
        message about sizetype to be correct.
376
 
377
2007-05-06  Andrew Pinski  
378
 
379
        Merge mainline, revision 124478.
380
        * fold-const.c (fold_unary): Handle for (T1)(X op Y),
381
        only p+ as that is the only as that can be handled for
382
        binary operators now.  Add a TODO for non pointer type
383
        op's.
384
        * gimplifier.c (gimplify_expr): Don't special case
385
        PLUS_EXPR.  Special case POINTER_PLUS_EXPR instead,
386
        remove check for pointer type as it will always be
387
        a pointer type now.
388
 
389
2007-05-04  Andrew Pinski  
390
 
391
        * tree-vrp.c (extract_range_from_binary_expr): Handle
392
        POINTER_PLUS_EXPRs.  Assert POINTER_PLUS_EXPR is
393
        the only expression for pointer types.
394
        * tree-vect-transform.c (vect_gen_niters_for_prolog_loop):
395
        Add a cast when creating byte_misalign.
396
 
397
2007-05-04  Andrew Pinski  
398
 
399
        * fold-const.c (fold_binary );
400
        Add comment on why you get INT +p INT.
401
        (fold_binary ): Add folding of PTR+INT into
402
        PTR p+ INT.
403
        * dwarf2out.c (loc_descriptor_from_tree_1):
404
        Handle POINT_PLUS_EXPR as a PLUS_EXPR.
405
 
406
2007-05-04  Andrew Pinski  
407
 
408
        * tree-vrp.c  (compare_values_warnv): Convert val2 to
409
        the type of val1.
410
        * fold-const.c (extract_array_ref): Look for
411
        POINTER_PLUS_EXPR instead of PLUS_EXPR's.
412
        * tree-ssa-ccp.c (maybe_fold_stmt_indirect): Likewise.
413
 
414
2007-05-02  Andrew Pinski  
415
 
416
        * c-format.c (check_format_arg): Handle POINTER_PLUS_EXPR
417
        instead of PLUS_EXPR of pointer types.
418
 
419
2007-05-02  Andrew Pinski  
420
 
421
        * fold-const.c (try_move_mult_to_index): Remove code argument
422
        and replace all uses with PLUS_EXPR.
423
        (fold_binary ): Remove code argument.
424
        (fold_binary ): Don't call try_move_mult_to_index.
425
        (fold_binary ): Likewise.
426
        * tree-ssa-ccp.c (maybe_fold_stmt_indirect): Remove subtraction
427
        case as it is always addition now.
428
        (fold_stmt_r): Don't handle PLUS_EXPR/MINUS_EXPR specially.
429
        Handle POINTER_PLUS_EXPR like PLUS_EXPR was handled before.
430
 
431
2007-05-01  Andrew Pinski  
432
 
433
        Merge mainline, revision 124343.
434
        * tree-vect-transform.c (bump_vector_ptr): Create a POINTER_PLUS_EXPR
435
        instead of PLUS_EXPR for the pointer increment statement.
436
        * expr.c (expand_expr_real_1): Add FIXME/assert for the unhandle case
437
        where the modes of the two operands are different.
438
 
439
2007-02-25  Andrew Pinski  
440
 
441
        Merge mainline, revision 122323.
442
 
443
2006-12-14  Zdenek Dvorak 
444
 
445
        Merge mainline, revision 119860.
446
 
447
2006-11-23  Andrew Pinski  
448
 
449
        * tree.def (POINTER_PLUS_EXPR): New tree code.
450
        * tree-pretty-print.c (dump_generic_node): Handle
451
        POINTER_PLUS_EXPR.
452
        (op_prio): Likewise.
453
        (op_symbol_1): Likewise.
454
        * optabs.c (optab_for_tree_code): Likewise.
455
        * tree-ssa-loop-manip.c (create_iv): Handle pointer base
456
        specially.
457
        * tree-tailcall.c (process_assignment): Mention
458
        POINTER_PLUS_EXPR in a TODO comment.
459
        * tree.c (build2_stat): Assert when trying to use PLUS_EXPR or
460
        MINUS_EXPR with a pointer. Also assert for POINTER_PLUS_EXPR
461
        not used with a pointer and an integer type.
462
        *  tree-scalar-evolution.c (fold_used_pointer): Mention
463
        POINTER_PLUS_EXPR is what this needs to handle.
464
        * builtins.c (get_pointer_alignment): Handle POINTER_PLUS_EXPR
465
        instead of PLUS_EXPR.
466
        (expand_builtin_strcat): Create a POINTER_PLUS_EXPR instead of
467
        PLUS_EXPR for pointers.
468
        (std_gimplify_va_arg_expr): Likewise.
469
        (fold_builtin_memory_op): Likewise.
470
        (fold_builtin_strstr): Likewise.
471
        (fold_builtin_strchr): Likewise.
472
        (fold_builtin_strrchr): Likewise.
473
        (fold_builtin_strpbrk): Likewise.
474
        (expand_builtin_memory_chk): Likewise.
475
        (fold_builtin_memory_chk): Likewise.
476
        * fold-const.c (build_range_check): Handle pointer types
477
        specially.
478
        (fold_to_nonsharp_ineq_using_bound): Likewise.
479
        (fold_binary): Handle simple POINTER_PLUS_EXPR cases.
480
        (tree_expr_nonnegative_p): Handle POINTER_PLUS_EXPR.
481
        (tree_expr_nonzero_p): Likewise.
482
        (fold_indirect_ref_1): Look at POINTER_PLUS_EXPR instead
483
        of PLUS_EXPR for the complex expression folding.
484
        * tree-ssa-loop-ivopts.c (determine_base_object): Handle
485
        POINTER_PLUS_EXPR.
486
        (tree_to_aff_combination): Likewise.
487
        (force_expr_to_var_cost): Likewise.
488
        (force_expr_to_var_cost): Likewise. Create a POINTER_PLUS_EXPR
489
        instead of PLUS_EXPR for pointers.
490
        * c-format.c (check_format_arg): Mention this should be handling
491
        POINTER_PLUS_EXPR.
492
        * tree-stdarg.c (va_list_counter_bump): Handle POINTER_PLUS_EXPR
493
        instead of PLUS_EXPR.
494
        (check_va_list_escapes): Likewise.
495
        (check_all_va_list_escapes): Likewise.
496
        * expr.c (expand_expr_real_1): Handle POINTER_PLUS_EXPR.
497
        (string_constant): Likewise.
498
        * tree-ssa-address.c (add_to_parts): Create a POINTER_PLUS_EXPR
499
        instead of PLUS_EXPR for pointers.
500
        (most_expensive_mult_to_index): Likewise.
501
        (addr_to_parts): Use the correct type for the index.
502
        * c-typeck.c (build_unary_op): For pointers create the increment
503
        as a sizetype. Create a POINTER_PLUS_EXPR instead of PLUS_EXPR
504
        for pointers.
505
        * gimplify.c (gimplify_self_mod_expr): Create a
506
        POINTER_PLUS_EXPR instead of PLUS_EXPR for pointers.
507
        (gimplify_omp_atomic_fetch_op): Handle POINTER_PLUS_EXPR.
508
        * tree-mudflap.c (mf_xform_derefs_1): Create a
509
        POINTER_PLUS_EXPR instead of PLUS_EXPR for pointers.
510
        * tree-ssa-forwprop.c (forward_propagate_addr_expr_1): Add a
511
        note this should be handling POINTER_PLUS_EXPR.
512
        * varasm.c (initializer_constant_valid_p): Handle
513
        POINTER_PLUS_EXPR.
514
        * tree-ssa-loop-prefetch.c (idx_analyze_ref):  Handle
515
        POINTER_PLUS_EXPR instead of PLUS_EXPR.
516
        (issue_prefetch_ref): Create a POINTER_PLUS_EXPR instead
517
        of PLUS_EXPR for pointers.
518
        * tree-vect-transform.c (vect_create_addr_base_for_vector_ref):
519
        Likewise.
520
        * tree-inline.c (estimate_num_insns_1): Handle
521
        POINTER_PLUS_EXPR.
522
        * tree-object-size.c (plus_expr_object_size): Handle
523
        POINTER_PLUS_EXPR instead of PLUS_EXPR.  Removing all the extra
524
        code which is trying to figure out which side is a pointer and
525
        is the index.
526
        (check_for_plus_in_loops_1): Likewise.
527
        (check_for_plus_in_loops): Likewise.
528
        * c-common.c (pointer_int_sum): Create a
529
        POINTER_PLUS_EXPR instead of PLUS_EXPR for pointers.
530
        * tree-ssa-structalias.c (handle_ptr_arith): Handle
531
        only POINTER_PLUS_EXPR.  Removing all the extra
532
        code which is trying to figure out which side is a pointer and
533
        is the index.
534
        * tree-cfg.c (verify_expr): Add extra checking for pointers and
535
        PLUS_EXPR and MINUS_EXPR.
536
        Also add checking to make sure the operands of POINTER_PLUS_EXPR
537
        are correct.
538
 
539
 
540
Copyright (C) 2006, 2007 Free Software Foundation, Inc.
541
 
542
Copying and distribution of this file, with or without modification,
543
are permitted in any medium without royalty provided the copyright
544
notice and this notice are preserved.

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.