annotate gcc/cp/ChangeLog-2007 @ 120:f93fa5091070

fix conv1.c
author mir3636
date Thu, 08 Mar 2018 14:53:42 +0900
parents 04ced10e8804
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
111
kono
parents:
diff changeset
1 2007-12-20 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2
kono
parents:
diff changeset
3 PR c++/34111
kono
parents:
diff changeset
4 * call.c (standard_conversion): Derived-to-base is considered a
kono
parents:
diff changeset
5 standard conversion.
kono
parents:
diff changeset
6
kono
parents:
diff changeset
7 2007-12-19 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
8
kono
parents:
diff changeset
9 PR c++/34513
kono
parents:
diff changeset
10 * parser.c (cp_parser_omp_parallel): For non-combined parallel
kono
parents:
diff changeset
11 call cp_parser_statement rather than
kono
parents:
diff changeset
12 cp_parser_already_scoped_statement.
kono
parents:
diff changeset
13
kono
parents:
diff changeset
14 2007-12-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
15
kono
parents:
diff changeset
16 PR c++/34206
kono
parents:
diff changeset
17 * pt.c (tsubst_aggr_type): Do nothing if the type already doesn't
kono
parents:
diff changeset
18 use template parms.
kono
parents:
diff changeset
19 (dependent_type_p_r): Handle the domain of an array.
kono
parents:
diff changeset
20
kono
parents:
diff changeset
21 2007-12-18 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
22 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
23
kono
parents:
diff changeset
24 PR c++/32565
kono
parents:
diff changeset
25 PR c++/33943
kono
parents:
diff changeset
26 PR c++/33965
kono
parents:
diff changeset
27 * pt.c (template_template_parm_bindings_ok_p): New; verifies
kono
parents:
diff changeset
28 bindings of template template parameters after all template
kono
parents:
diff changeset
29 arguments have been deduced.
kono
parents:
diff changeset
30 (coerce_template_parms): Don't complain when COMPLAIN doesn't
kono
parents:
diff changeset
31 include tf_error.
kono
parents:
diff changeset
32 (fn_type_unification): Use template_template_parm_bindings_ok_p.
kono
parents:
diff changeset
33 (unify): Deal with variadic, bound template template parameters.
kono
parents:
diff changeset
34 (get_class_bindings): Use template_template_parm_bindings_ok_p.
kono
parents:
diff changeset
35
kono
parents:
diff changeset
36 2007-12-18 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
37
kono
parents:
diff changeset
38 PR c++/34488
kono
parents:
diff changeset
39 * decl.c (grokdeclarator): Reject friend sfk_constructor
kono
parents:
diff changeset
40 FUNCTION_TYPE.
kono
parents:
diff changeset
41
kono
parents:
diff changeset
42 2007-12-17 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
43
kono
parents:
diff changeset
44 PR c/34506
kono
parents:
diff changeset
45 * parser.c (cp_parser_omp_all_clauses): Accept optional comma
kono
parents:
diff changeset
46 in between clauses.
kono
parents:
diff changeset
47
kono
parents:
diff changeset
48 2007-12-15 Alexandre Oliva <aoliva@redhat.com>
kono
parents:
diff changeset
49
kono
parents:
diff changeset
50 PR debug/7081
kono
parents:
diff changeset
51 * cp-lang.c (cp_classify_record): New.
kono
parents:
diff changeset
52 (LANG_HOOKS_CLASSIFY_RECORD): Override.
kono
parents:
diff changeset
53
kono
parents:
diff changeset
54 2007-12-11 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
55
kono
parents:
diff changeset
56 PR c++/34238
kono
parents:
diff changeset
57 * decl2.c (cp_write_global_declarations): Revert 2007-11-22 change.
kono
parents:
diff changeset
58
kono
parents:
diff changeset
59 PR c++/34364
kono
parents:
diff changeset
60 * rtti.c (build_dynamic_cast): Call convert_from_reference even for
kono
parents:
diff changeset
61 dynamic_cast in a template.
kono
parents:
diff changeset
62
kono
parents:
diff changeset
63 2007-12-10 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
64
kono
parents:
diff changeset
65 PR c++/34059
kono
parents:
diff changeset
66 * typeck.c (build_class_member_access_expr): Compute MEMBER_SCOPE from
kono
parents:
diff changeset
67 MEMBER's BASELINK_ACCESS_BINFO instead of its BASELINK_BINFO.
kono
parents:
diff changeset
68
kono
parents:
diff changeset
69 2007-12-10 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
70
kono
parents:
diff changeset
71 PR c++/34395
kono
parents:
diff changeset
72 * error.c (dump_type_prefix, dump_type_suffix): Handle
kono
parents:
diff changeset
73 TYPE_PACK_EXPANSION.
kono
parents:
diff changeset
74
kono
parents:
diff changeset
75 PR c++/34394
kono
parents:
diff changeset
76 * error.c (dump_expr): Handle ABS_EXPR.
kono
parents:
diff changeset
77
kono
parents:
diff changeset
78 2007-12-09 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
79
kono
parents:
diff changeset
80 PR c++/34178
kono
parents:
diff changeset
81 PR c++/34340
kono
parents:
diff changeset
82 * repo.c (repo_emit_p): Return 2 for DECL_INTEGRAL_CONSTANT_VAR_P
kono
parents:
diff changeset
83 in class scope rather than DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P.
kono
parents:
diff changeset
84 Return 2 also if DECL_EXPLICIT_INSTANTIATION.
kono
parents:
diff changeset
85 * decl2.c (import_export_decl): Don't make VAR_DECLs import_p when
kono
parents:
diff changeset
86 flag_use_repository and repo_emit_p returned 2.
kono
parents:
diff changeset
87
kono
parents:
diff changeset
88 2007-12-06 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
89
kono
parents:
diff changeset
90 PR c++/34336
kono
parents:
diff changeset
91 * tree.c (stabilize_call, stabilize_init): Do nothing if
kono
parents:
diff changeset
92 processing_template_decl.
kono
parents:
diff changeset
93
kono
parents:
diff changeset
94 2007-12-05 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
95
kono
parents:
diff changeset
96 PR c++/34271
kono
parents:
diff changeset
97 * semantics.c (finish_decltype_type): For SCOPE_REF issue an
kono
parents:
diff changeset
98 error instead of assertion failure.
kono
parents:
diff changeset
99 * parser.c (cp_parser_decltype): If closing paren is not found,
kono
parents:
diff changeset
100 return error_mark_node.
kono
parents:
diff changeset
101
kono
parents:
diff changeset
102 2007-12-04 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
103
kono
parents:
diff changeset
104 PR c++/34101
kono
parents:
diff changeset
105 * name-lookup.c (arg_assoc_template_arg): Recurse on argument
kono
parents:
diff changeset
106 packs.
kono
parents:
diff changeset
107 (arg_assoc_type): We don't need to handle TYPE_ARGUMENT_PACK here,
kono
parents:
diff changeset
108 since arg_assoc_template_arg will deal with them (better).
kono
parents:
diff changeset
109
kono
parents:
diff changeset
110 2007-12-04 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
111
kono
parents:
diff changeset
112 PR c++/33509
kono
parents:
diff changeset
113 * pt.c (tsubst_exception_specification): Handle substitutions into
kono
parents:
diff changeset
114 member templates, where tsubst_pack_expansion returns a
kono
parents:
diff changeset
115 TYPE_PACK_EXPANSION.
kono
parents:
diff changeset
116
kono
parents:
diff changeset
117 2007-12-04 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
118
kono
parents:
diff changeset
119 PR c++/33091
kono
parents:
diff changeset
120 * pt.c (unify_pack_expansion): If we didn't deduce any actual
kono
parents:
diff changeset
121 bindings for the template parameter pack, don't try to keep the
kono
parents:
diff changeset
122 empty deduced arguments.
kono
parents:
diff changeset
123 (unify): If a parameter is a template-id whose template argument
kono
parents:
diff changeset
124 list contains a pack expansion that is not at the end, then we
kono
parents:
diff changeset
125 cannot unify against that template-id.
kono
parents:
diff changeset
126
kono
parents:
diff changeset
127 2007-12-02 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
128
kono
parents:
diff changeset
129 PR c++/34061
kono
parents:
diff changeset
130 * pt.c (current_template_args): Use error_operand_p.
kono
parents:
diff changeset
131
kono
parents:
diff changeset
132 2007-12-02 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
133
kono
parents:
diff changeset
134 PR c++/34273
kono
parents:
diff changeset
135 * error.c (dump_decl): Handle TREE_BINFO.
kono
parents:
diff changeset
136
kono
parents:
diff changeset
137 2007-12-01 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
138
kono
parents:
diff changeset
139 PR c++/8171
kono
parents:
diff changeset
140 * typeck.c (build_binary_op): Add conversion of pointers to function
kono
parents:
diff changeset
141 members appearing as operands to the equality operators.
kono
parents:
diff changeset
142
kono
parents:
diff changeset
143 2007-11-30 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
144
kono
parents:
diff changeset
145 PR c++/34275
kono
parents:
diff changeset
146 * error.c (dump_expr): Handle OBJ_TYPE_REF.
kono
parents:
diff changeset
147
kono
parents:
diff changeset
148 2007-11-29 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
149
kono
parents:
diff changeset
150 PR c++/34270
kono
parents:
diff changeset
151 * tree.c (lvalue_p_1) <case COND_EXPR>: Handle x ?: y
kono
parents:
diff changeset
152 in templates.
kono
parents:
diff changeset
153 * typeck.c (is_bitfield_expr_with_lowered_type) <case COND_EXPR>:
kono
parents:
diff changeset
154 Likewise.
kono
parents:
diff changeset
155
kono
parents:
diff changeset
156 PR c++/34267
kono
parents:
diff changeset
157 PR c++/34268
kono
parents:
diff changeset
158 * parser.c (cp_parser_decltype): Don't call finish_id_expression
kono
parents:
diff changeset
159 on ~type.
kono
parents:
diff changeset
160 * semantics.c (finish_decltype_type): Issue error on types, TYPE_DECLs
kono
parents:
diff changeset
161 and ~type early.
kono
parents:
diff changeset
162
kono
parents:
diff changeset
163 2007-11-27 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
164
kono
parents:
diff changeset
165 PR tree-optimization/34181
kono
parents:
diff changeset
166 * method.c (use_thunk): Don't inline the call in the thunk.
kono
parents:
diff changeset
167
kono
parents:
diff changeset
168 PR c++/34213
kono
parents:
diff changeset
169 * tree.c (decl_linkage): Static data members and static member
kono
parents:
diff changeset
170 functions in anonymous ns classes are lk_external.
kono
parents:
diff changeset
171
kono
parents:
diff changeset
172 2007-11-26 Andreas Krebbel <krebbel1@de.ibm.com>
kono
parents:
diff changeset
173
kono
parents:
diff changeset
174 PR c++/34081
kono
parents:
diff changeset
175 * decl.c (start_preparsed_function): Pass
kono
parents:
diff changeset
176 processing_template_decl for the new allocate_struct_function
kono
parents:
diff changeset
177 parameter.
kono
parents:
diff changeset
178
kono
parents:
diff changeset
179 2007-11-25 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
180
kono
parents:
diff changeset
181 * decl.c (poplevel): Use BLOCK_CHAIN.
kono
parents:
diff changeset
182
kono
parents:
diff changeset
183 2007-11-24 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
184
kono
parents:
diff changeset
185 * typeck.c (delta_from_ptrmemfunc): New function.
kono
parents:
diff changeset
186 (get_member_function_from_ptrfunc): Call delta_from_ptrmemfunc.
kono
parents:
diff changeset
187 (build_binary_op): Call delta_from_ptrmemfunc.
kono
parents:
diff changeset
188
kono
parents:
diff changeset
189 2007-11-23 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
190
kono
parents:
diff changeset
191 PR c++/30293
kono
parents:
diff changeset
192 PR c++/30294
kono
parents:
diff changeset
193 * decl.c (cp_finish_decl): Disallow variable or field
kono
parents:
diff changeset
194 definitions if extern "Java" aggregates.
kono
parents:
diff changeset
195 (grokparms): Disallow parameters with extern "Java"
kono
parents:
diff changeset
196 aggregates.
kono
parents:
diff changeset
197 (check_function_type): Disallow function return values
kono
parents:
diff changeset
198 with extern "Java" aggregates.
kono
parents:
diff changeset
199 * init.c (build_new_1): Disallow placement new with
kono
parents:
diff changeset
200 extern "Java" aggregates.
kono
parents:
diff changeset
201
kono
parents:
diff changeset
202 2007-11-23 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
203 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
204
kono
parents:
diff changeset
205 PR c++/5310
kono
parents:
diff changeset
206 * call.c (convert_like_real): Build a zero constant when __null is
kono
parents:
diff changeset
207 converted to an integer type.
kono
parents:
diff changeset
208
kono
parents:
diff changeset
209 2007-11-22 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
210
kono
parents:
diff changeset
211 PR c++/34094
kono
parents:
diff changeset
212 * decl2.c (cp_write_global_declarations): Issue error about static
kono
parents:
diff changeset
213 data members in anonymous namespace which are declared and used,
kono
parents:
diff changeset
214 but not defined.
kono
parents:
diff changeset
215
kono
parents:
diff changeset
216 2007-11-20 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
217
kono
parents:
diff changeset
218 PR c++/34089
kono
parents:
diff changeset
219 * parser.c (cp_parser_class_head): Reject function template ids.
kono
parents:
diff changeset
220
kono
parents:
diff changeset
221 PR c++/28879
kono
parents:
diff changeset
222 * tree.c (build_cplus_array_type_1): Don't pass any VLA types
kono
parents:
diff changeset
223 when processing_template_decl to build_array_type.
kono
parents:
diff changeset
224
kono
parents:
diff changeset
225 PR c++/33962
kono
parents:
diff changeset
226 * pt.c (more_specialized_fn): Don't segfault if one or
kono
parents:
diff changeset
227 both argument list end with ellipsis.
kono
parents:
diff changeset
228
kono
parents:
diff changeset
229 2007-11-18 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
230
kono
parents:
diff changeset
231 PR c++/30988
kono
parents:
diff changeset
232 * semantics.c (finish_call_expr): Set
kono
parents:
diff changeset
233 current_function_returns_abnormally if fn is noreturn FUNCTION_DECL
kono
parents:
diff changeset
234 or OVERLOAD with all noreturn functions.
kono
parents:
diff changeset
235
kono
parents:
diff changeset
236 2007-11-16 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
237
kono
parents:
diff changeset
238 PR c++/34100
kono
parents:
diff changeset
239 * pt.c (apply_late_template_attributes): Do nothing if decl's type is
kono
parents:
diff changeset
240 error_mark_node.
kono
parents:
diff changeset
241
kono
parents:
diff changeset
242 2007-11-13 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
243
kono
parents:
diff changeset
244 PR c++/34054
kono
parents:
diff changeset
245 PR c++/34056
kono
parents:
diff changeset
246 PR c++/34057
kono
parents:
diff changeset
247 PR c++/34058
kono
parents:
diff changeset
248 PR c++/34060
kono
parents:
diff changeset
249 * pt.c (find_parameter_packs_r): If ppd->set_packs_to_error,
kono
parents:
diff changeset
250 set to error_mark_node the outermost POINTER_TYPE to the pack if
kono
parents:
diff changeset
251 it is seen in a POINTER_TYPE.
kono
parents:
diff changeset
252 (push_template_decl_real): If check_for_bare_parameter_packs
kono
parents:
diff changeset
253 fails for function return type, set the return type to
kono
parents:
diff changeset
254 integer_type_node. If check_for_bare_parameter_packs failed
kono
parents:
diff changeset
255 for non-function, return error_mark_node.
kono
parents:
diff changeset
256
kono
parents:
diff changeset
257 PR c++/29225
kono
parents:
diff changeset
258 * call.c (build_new_op): Call resolve_args before calling
kono
parents:
diff changeset
259 build_over_call.
kono
parents:
diff changeset
260
kono
parents:
diff changeset
261 2007-11-11 Tom Tromey <tromey@redhat.com>
kono
parents:
diff changeset
262
kono
parents:
diff changeset
263 PR c++/17577:
kono
parents:
diff changeset
264 * lex.c (handle_pragma_implementation): Use cpp_included_before.
kono
parents:
diff changeset
265
kono
parents:
diff changeset
266 2007-11-12 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
267
kono
parents:
diff changeset
268 PR c++/8570
kono
parents:
diff changeset
269 * pt.c (redeclare_class_template): Update error message. Use a
kono
parents:
diff changeset
270 note to show the previous declaration.
kono
parents:
diff changeset
271 (tsubst_friend_class): Use the location of the friend template as
kono
parents:
diff changeset
272 the input location before calling redeclare_class_template.
kono
parents:
diff changeset
273
kono
parents:
diff changeset
274 2007-11-11 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
275
kono
parents:
diff changeset
276 PR c++/34068
kono
parents:
diff changeset
277 * semantics.c (finish_pseudo_destructor_expr): Handle
kono
parents:
diff changeset
278 object == error_mark_node.
kono
parents:
diff changeset
279
kono
parents:
diff changeset
280 2007-11-10 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
281
kono
parents:
diff changeset
282 PR c++/32241
kono
parents:
diff changeset
283 * pt.c (tsubst_copy_and_build) <case COMPONENT_REF>: If object_type
kono
parents:
diff changeset
284 is not scalar type, let finish_class_member_access_expr handle
kono
parents:
diff changeset
285 diagnostics. Pass BIT_NOT_EXPR argument to
kono
parents:
diff changeset
286 finish_pseudo_destructor_expr. Handle SCOPE_REF properly.
kono
parents:
diff changeset
287
kono
parents:
diff changeset
288 2007-11-09 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
289
kono
parents:
diff changeset
290 PR c++/33510
kono
parents:
diff changeset
291 * decl.c (cp_complete_array_type): If any of the initializer
kono
parents:
diff changeset
292 elements are pack expansions, don't compute the array size yet.
kono
parents:
diff changeset
293
kono
parents:
diff changeset
294 2007-11-08 Andrew Pinski <pinskia@gmail.com>
kono
parents:
diff changeset
295
kono
parents:
diff changeset
296 PR c++/30297:
kono
parents:
diff changeset
297 * tree.c (decl_linkage): Fields have no linkage.
kono
parents:
diff changeset
298
kono
parents:
diff changeset
299 2007-11-08 Daniel Jacobowitz <dan@codesourcery.com>
kono
parents:
diff changeset
300
kono
parents:
diff changeset
301 * class.c (build_ctor_vtbl_group): Lay out the new type and decl.
kono
parents:
diff changeset
302
kono
parents:
diff changeset
303 2007-11-07 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
304
kono
parents:
diff changeset
305 PR c++/33045
kono
parents:
diff changeset
306 PR c++/33837
kono
parents:
diff changeset
307 PR c++/33838
kono
parents:
diff changeset
308 * semantics.c (finish_decltype_type): See through INDIRECT_REFs.
kono
parents:
diff changeset
309 Be careful with ERROR_MARK_NODEs.
kono
parents:
diff changeset
310 * parser.c (cp_parser_check_access_in_redeclaration): Handle NULL
kono
parents:
diff changeset
311 argument.
kono
parents:
diff changeset
312
kono
parents:
diff changeset
313 2007-11-07 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
314
kono
parents:
diff changeset
315 PR c++/33501
kono
parents:
diff changeset
316 * call.c (build_over_call): Don't check TREE_ADDRESSABLE
kono
parents:
diff changeset
317 on incomplete type.
kono
parents:
diff changeset
318
kono
parents:
diff changeset
319 2007-11-06 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
320
kono
parents:
diff changeset
321 PR c++/33977
kono
parents:
diff changeset
322 PR c++/33886
kono
parents:
diff changeset
323 * tree.c (c_build_qualified_type): Define bridge to
kono
parents:
diff changeset
324 cp_build_qualified_type.
kono
parents:
diff changeset
325
kono
parents:
diff changeset
326 2007-11-06 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
327
kono
parents:
diff changeset
328 PR c++/31439
kono
parents:
diff changeset
329 PR c++/32114
kono
parents:
diff changeset
330 PR c++/32115
kono
parents:
diff changeset
331 PR c++/32125
kono
parents:
diff changeset
332 PR c++/32126
kono
parents:
diff changeset
333 PR c++/32127
kono
parents:
diff changeset
334 PR c++/32128
kono
parents:
diff changeset
335 PR c++/32253
kono
parents:
diff changeset
336 PR c++/32566
kono
parents:
diff changeset
337 * typeck.c (check_return_expr): Pass address of retval to
kono
parents:
diff changeset
338 check_for_bare_parameter_packs.
kono
parents:
diff changeset
339 * class.c (build_base_field): Tolerate bases that have no layout
kono
parents:
diff changeset
340 due to errors.
kono
parents:
diff changeset
341 (end_of_base): Ditto.
kono
parents:
diff changeset
342 * tree.c (canonical_type_variant): Be careful with
kono
parents:
diff changeset
343 ERROR_MARK_NODE.
kono
parents:
diff changeset
344 * cp-tree.h (check_for_bare_parameter_packs): Now accepts a
kono
parents:
diff changeset
345 tree*.
kono
parents:
diff changeset
346 * pt.c (find_parameter_pack_data): Add set_packs_to_error field,
kono
parents:
diff changeset
347 which states whether parameter packs should be replaced with
kono
parents:
diff changeset
348 ERROR_MARK_NODE.
kono
parents:
diff changeset
349 (find_parameter_packs_r): Pass addresses to cp_walk_tree wherever
kono
parents:
diff changeset
350 possible. If set_packs_to_error is set true, replace the parameter
kono
parents:
diff changeset
351 pack with ERROR_MARK_NODE. Manage our own pointer sets.
kono
parents:
diff changeset
352 (uses_parameter_packs): Don't set parameter packs to
kono
parents:
diff changeset
353 ERROR_MARK_NODE.
kono
parents:
diff changeset
354 (check_for_bare_parameter_packs): Now takes a pointer to a tree,
kono
parents:
diff changeset
355 which may be modified (if it is a parameter pack). Instructs
kono
parents:
diff changeset
356 find_parameter_packs_r to replace parameter packs with
kono
parents:
diff changeset
357 ERROR_MARK_NODE (so that they won't cause errors later on).
kono
parents:
diff changeset
358 (process_template_parm): Pass pointer to
kono
parents:
diff changeset
359 check_for_bare_parameter_packs.
kono
parents:
diff changeset
360 (process_partial_specialization): Replace pack expansions before
kono
parents:
diff changeset
361 the end of the template argument list with ERROR_MARK_NODE.
kono
parents:
diff changeset
362 (push_template_decl_real): Pass pointer to
kono
parents:
diff changeset
363 check_for_bare_parameter_packs. Replace parameter packs not at the
kono
parents:
diff changeset
364 end of the template parameter list with ERROR_MARK_NODE.
kono
parents:
diff changeset
365 (convert_template_argument): Be more careful about using DECL_NAME
kono
parents:
diff changeset
366 on only declarations.
kono
parents:
diff changeset
367 (unify): Can't unify against ERROR_MARK_NODE.
kono
parents:
diff changeset
368 * semantics.c (finish_cond): Pass pointer to
kono
parents:
diff changeset
369 check_for_bare_parameter_packs.
kono
parents:
diff changeset
370 (finish_expr_stmt): Ditto.
kono
parents:
diff changeset
371 (finish_for_expr): Ditto.
kono
parents:
diff changeset
372 (finish_switch_cond): Pass pointer to
kono
parents:
diff changeset
373 check_for_bare_parameter_packs, and call it before we put the
kono
parents:
diff changeset
374 condition into the statement.
kono
parents:
diff changeset
375 (finish_mem_initializers): Pass pointer to
kono
parents:
diff changeset
376 check_for_bare_parameter_packs.
kono
parents:
diff changeset
377 (finish_member_declaration): Ditto.
kono
parents:
diff changeset
378 * parser.c (cp_parser_base_clause): Ditto.
kono
parents:
diff changeset
379
kono
parents:
diff changeset
380 2007-11-06 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
381
kono
parents:
diff changeset
382 PR target/33168
kono
parents:
diff changeset
383 * decl.c (cp_finish_decl): Call make_rtl_for_nonlocal_decl already
kono
parents:
diff changeset
384 with the final TREE_READONLY flag in place. processing_template_decl
kono
parents:
diff changeset
385 is known to be 0 in this part of function.
kono
parents:
diff changeset
386
kono
parents:
diff changeset
387 PR c++/33894
kono
parents:
diff changeset
388 * cp-tree.h: Update comment - TYPE_LANG_FLAG_0 is not
kono
parents:
diff changeset
389 OMP_ATOMIC_DEPENDENT_P in OMP_ATOMIC.
kono
parents:
diff changeset
390 * pt.c (tsubst_expr): Assert OMP_ATOMIC_DEPENDENT_P.
kono
parents:
diff changeset
391 * semantics.c (finish_omp_atomic): Revert most of the
kono
parents:
diff changeset
392 2007-02-05 changes, just keep the new representation of
kono
parents:
diff changeset
393 OMP_ATOMIC_DEPENDENT_P OMP_ATOMIC.
kono
parents:
diff changeset
394
kono
parents:
diff changeset
395 2007-11-05 H.J. Lu <hongjiu.lu@intel.com>
kono
parents:
diff changeset
396
kono
parents:
diff changeset
397 PR c++/33871
kono
parents:
diff changeset
398 * decl2.c (constrain_visibility): Clear DECL_ONE_ONLY if marked
kono
parents:
diff changeset
399 local.
kono
parents:
diff changeset
400
kono
parents:
diff changeset
401 2007-11-05 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
402
kono
parents:
diff changeset
403 PR c++/33996
kono
parents:
diff changeset
404 PR c++/33235
kono
parents:
diff changeset
405 PR c++/33930
kono
parents:
diff changeset
406 * typeck.c (merge_types): Don't lose rvalue references when
kono
parents:
diff changeset
407 merging types.
kono
parents:
diff changeset
408 * call.c (build_over_call): Don't elide move constructors just
kono
parents:
diff changeset
409 because the copy constructor is trivial (!).
kono
parents:
diff changeset
410 (compare_ics): If comparing cv-qualifiers fails, we can still order
kono
parents:
diff changeset
411 based on binding lvalues vs. rvalues.
kono
parents:
diff changeset
412
kono
parents:
diff changeset
413 2007-11-05 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
414
kono
parents:
diff changeset
415 PR c++/33939
kono
parents:
diff changeset
416 * pt.c (unify_pack_expansion): bring handling of function call
kono
parents:
diff changeset
417 arguments into line with type_unification_real.
kono
parents:
diff changeset
418
kono
parents:
diff changeset
419 2007-11-05 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
420
kono
parents:
diff changeset
421 * typeck.c (build_binary_op): Use pedwarn instead of error for
kono
parents:
diff changeset
422 consistency.
kono
parents:
diff changeset
423
kono
parents:
diff changeset
424 2007-11-05 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
425
kono
parents:
diff changeset
426 PR c++/33836
kono
parents:
diff changeset
427 * parser.c (cp_parser_unary_expression): For &&label call
kono
parents:
diff changeset
428 cp_parser_non_integral_constant_expression and return error_mark_node
kono
parents:
diff changeset
429 if it returned true.
kono
parents:
diff changeset
430
kono
parents:
diff changeset
431 PR c++/33969
kono
parents:
diff changeset
432 * decl.c (grokdeclarator): Don't call build_memfn_type if type
kono
parents:
diff changeset
433 is neither FUNCTION_TYPE nor METHOD_TYPE.
kono
parents:
diff changeset
434
kono
parents:
diff changeset
435 2007-11-02 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
436
kono
parents:
diff changeset
437 PR c++/33516
kono
parents:
diff changeset
438 * parser.c (cp_parser_nested_name_specifier_opt): Use
kono
parents:
diff changeset
439 TYPE_MAIN_VARIANT (new_scope) as scope if new_scope is an incomplete
kono
parents:
diff changeset
440 typedef of currently open class.
kono
parents:
diff changeset
441
kono
parents:
diff changeset
442 2007-11-02 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
443
kono
parents:
diff changeset
444 PR c++/33495
kono
parents:
diff changeset
445 * error.c (dump_expr): Deal specially with statements.
kono
parents:
diff changeset
446
kono
parents:
diff changeset
447 2007-11-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
448
kono
parents:
diff changeset
449 PR c++/30897
kono
parents:
diff changeset
450 * pt.c (push_template_decl_real): Set DECL_CONTEXT on template
kono
parents:
diff changeset
451 template parms.
kono
parents:
diff changeset
452 (lookup_template_class): Use it to get the outer template args
kono
parents:
diff changeset
453 for instantiating one.
kono
parents:
diff changeset
454
kono
parents:
diff changeset
455 PR c++/29236
kono
parents:
diff changeset
456 * pt.c (reduce_template_parm_level): tsubst the parameters
kono
parents:
diff changeset
457 of a template template parm.
kono
parents:
diff changeset
458
kono
parents:
diff changeset
459 2007-11-01 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
460
kono
parents:
diff changeset
461 PR c++/33955
kono
parents:
diff changeset
462 * pt.c (find_parameter_packs_r): Handle TYPENAME_TYPE.
kono
parents:
diff changeset
463
kono
parents:
diff changeset
464 2007-11-01 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
465
kono
parents:
diff changeset
466 PR c++/32384
kono
parents:
diff changeset
467 * parser.c (cp_parser_postfix_dot_deref_expression): If
kono
parents:
diff changeset
468 POSTFIX_EXPRESSION is type dependent, try to parse it as pseudo dtor
kono
parents:
diff changeset
469 first and if that succeeds and type is SCALAR_TYPE_P, create
kono
parents:
diff changeset
470 PSEUDO_DTOR_EXPR.
kono
parents:
diff changeset
471
kono
parents:
diff changeset
472 PR c++/32260
kono
parents:
diff changeset
473 * rtti.c (enum_tinfo_kind): Fix TK_TYPE_INFO_TYPE comment.
kono
parents:
diff changeset
474 (typeid_ok_p): Use the same alias set for abi::__type_info_pseudo
kono
parents:
diff changeset
475 as for std::type_info.
kono
parents:
diff changeset
476
kono
parents:
diff changeset
477 2007-10-31 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
478
kono
parents:
diff changeset
479 PR c++/33494
kono
parents:
diff changeset
480 * cxx-pretty-print.c (pp_cxx_typeid_expression,
kono
parents:
diff changeset
481 pp_cxx_delete_expression): Change to static linkage.
kono
parents:
diff changeset
482 * cxx-pretty-print.h: Adjust declarations.
kono
parents:
diff changeset
483 * error.c (dump_expr, case EXPR_PACK_EXPANSION, TYPEID_EXPR,
kono
parents:
diff changeset
484 MEMBER_REF, DOTSTAR_EXPR, DELETE_EXPR, VEC_DELETE_EXPR,
kono
parents:
diff changeset
485 MODOP_EXPR): Forward to pp_expression.
kono
parents:
diff changeset
486
kono
parents:
diff changeset
487 * cxx-pretty-print.c (pp_cxx_expression, case NON_DEPENDENT_EXPR):
kono
parents:
diff changeset
488 Fix typo.
kono
parents:
diff changeset
489
kono
parents:
diff changeset
490 2007-10-31 Christian Bruel <christian.bruel@st.com>
kono
parents:
diff changeset
491 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
492
kono
parents:
diff changeset
493 PR c++/19531
kono
parents:
diff changeset
494 * typeck.c (check_return_expr): Don't set named_return_value_okay_p
kono
parents:
diff changeset
495 if retval is volatile.
kono
parents:
diff changeset
496
kono
parents:
diff changeset
497 2007-10-30 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
498
kono
parents:
diff changeset
499 PR c++/33616
kono
parents:
diff changeset
500 * decl2.c (build_offset_ref_call_from_tree): Call
kono
parents:
diff changeset
501 build_non_dependent_expr on object prior to building ADDR_EXPR from it
kono
parents:
diff changeset
502 if FN is DOTSTAR_EXPR.
kono
parents:
diff changeset
503
kono
parents:
diff changeset
504 2007-10-30 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
505
kono
parents:
diff changeset
506 PR c++/31993
kono
parents:
diff changeset
507 PR c++/32252
kono
parents:
diff changeset
508 * pt.c (find_parameter_packs_r): Fix typo in comment.
kono
parents:
diff changeset
509 (convert_template_argument): Look at the pattern of a pack
kono
parents:
diff changeset
510 expansion to determine what kind of entity we're converting.
kono
parents:
diff changeset
511 (coerce_template_parameter_pack): When we have coerced a non-type
kono
parents:
diff changeset
512 template parameter pack, substitute into the type of that pack.
kono
parents:
diff changeset
513 (tsubst_pack_expansion): When our substitution of a parameter pack
kono
parents:
diff changeset
514 is a "trivial" substitution of itself, just substitute into the
kono
parents:
diff changeset
515 pack expansion rather than actually expanding.
kono
parents:
diff changeset
516
kono
parents:
diff changeset
517 2007-10-29 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
518
kono
parents:
diff changeset
519 PR c++/33841
kono
parents:
diff changeset
520 * class.c (check_bitfield_decl): Don't set field's type to error_mark_node
kono
parents:
diff changeset
521 for non-integral type bitfields. Return true if bitfield is correct, false
kono
parents:
diff changeset
522 error has been diagnosed.
kono
parents:
diff changeset
523 (check_field_decls): If check_bitfield_decl returned false, call also
kono
parents:
diff changeset
524 check_field_decl.
kono
parents:
diff changeset
525
kono
parents:
diff changeset
526 2007-10-28 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
527 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
528
kono
parents:
diff changeset
529 PR c++/30659
kono
parents:
diff changeset
530 * pt.c (do_decl_instantiation): If the VAR_DECL is not a
kono
parents:
diff changeset
531 class member error out and return.
kono
parents:
diff changeset
532
kono
parents:
diff changeset
533 2007-10-27 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
534
kono
parents:
diff changeset
535 * error.c (reinit_cxx_pp): Initialize cxx_pp->enclosing_scope
kono
parents:
diff changeset
536 to current_function_decl rather than 0.
kono
parents:
diff changeset
537
kono
parents:
diff changeset
538 PR c++/33844
kono
parents:
diff changeset
539 * cxx-pretty-print.c (pp_cxx_pm_expression) <case MEMBER_REF>: Print
kono
parents:
diff changeset
540 ->* rather than .*.
kono
parents:
diff changeset
541 * error.c (dump_expr): Handle MEMBER_REF and DOTSTAR_EXPR.
kono
parents:
diff changeset
542
kono
parents:
diff changeset
543 2007-10-27 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
544
kono
parents:
diff changeset
545 PR c++/5247
kono
parents:
diff changeset
546 * call.c (convert_default_arg): Detect recursion.
kono
parents:
diff changeset
547
kono
parents:
diff changeset
548 2007-10-27 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
549
kono
parents:
diff changeset
550 PR c++/33842
kono
parents:
diff changeset
551 * cxx-pretty-print.h (pp_cxx_offsetof_expression): New prototype.
kono
parents:
diff changeset
552 * cxx-pretty-print.c (pp_cxx_primary_expression): Handle
kono
parents:
diff changeset
553 OFFSETOF_EXPR.
kono
parents:
diff changeset
554 (pp_cxx_offsetof_expression_1, pp_cxx_offsetof_expression): New
kono
parents:
diff changeset
555 functions.
kono
parents:
diff changeset
556 * error.c (dump_expr): Handle OFFSETOF_EXPR.
kono
parents:
diff changeset
557
kono
parents:
diff changeset
558 2007-10-26 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
559
kono
parents:
diff changeset
560 PR c++/24791
kono
parents:
diff changeset
561 * pt.c (get_template_info): New fn.
kono
parents:
diff changeset
562 (template_class_depth): Use it.
kono
parents:
diff changeset
563 (push_template_decl_real): Check that the template args of the
kono
parents:
diff changeset
564 definition match the args of the previous declaration.
kono
parents:
diff changeset
565
kono
parents:
diff changeset
566 2007-10-26 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
567
kono
parents:
diff changeset
568 PR c++/31988
kono
parents:
diff changeset
569 * decl2.c (coerce_new_type): Do not allow a default argument for
kono
parents:
diff changeset
570 the first parameter.
kono
parents:
diff changeset
571
kono
parents:
diff changeset
572 2007-10-26 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
573
kono
parents:
diff changeset
574 PR c++/33839
kono
parents:
diff changeset
575 * parser.c (cp_parser_decltype): Return ERROR_MARK_NODE if we
kono
parents:
diff changeset
576 don't see the leading '('. Only lookup names if we get an
kono
parents:
diff changeset
577 IDENTIFIER_NODE.
kono
parents:
diff changeset
578
kono
parents:
diff changeset
579 2007-10-26 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
580
kono
parents:
diff changeset
581 PR c++/33744
kono
parents:
diff changeset
582 * parser.c (cp_parser_parenthesized_expression_list): Set
kono
parents:
diff changeset
583 greater_than_is_operator_p to true in between the parens.
kono
parents:
diff changeset
584
kono
parents:
diff changeset
585 2007-10-26 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
586
kono
parents:
diff changeset
587 PR c++/31747
kono
parents:
diff changeset
588 * decl.c (grokdeclarator): In case of conflicting specifiers
kono
parents:
diff changeset
589 just return error_mark_node.
kono
parents:
diff changeset
590
kono
parents:
diff changeset
591 2007-10-26 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
592
kono
parents:
diff changeset
593 * expr.c (cxx_expand_expr): Removed.
kono
parents:
diff changeset
594 * cp-tree.h (exx_expand_expr): Removed.
kono
parents:
diff changeset
595 * cp-objcp-common.h (LANK_HOOKS_EXPAND_EXPR): Replace cxx_expand_expr
kono
parents:
diff changeset
596 with c_expand_expr.
kono
parents:
diff changeset
597
kono
parents:
diff changeset
598 2007-10-25 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
599
kono
parents:
diff changeset
600 PR c++/33843
kono
parents:
diff changeset
601 * cxx-pretty-print.c (pp_cxx_unqualified_id): Deal with BIT_NOT_EXPR.
kono
parents:
diff changeset
602
kono
parents:
diff changeset
603 2007-10-23 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
604
kono
parents:
diff changeset
605 PR c++/25950 (DR 391)
kono
parents:
diff changeset
606 * call.c (struct conversion): Remove check_copy_constructor_p.
kono
parents:
diff changeset
607 (reference_binding): Always bind a reference directly to a
kono
parents:
diff changeset
608 compatible class rvalue. Pass down LOOKUP_NO_TEMP_BIND during
kono
parents:
diff changeset
609 temporary creation.
kono
parents:
diff changeset
610 (check_constructor_callable): Remove.
kono
parents:
diff changeset
611 (convert_like_real): Don't call it.
kono
parents:
diff changeset
612 (initialize_reference): Don't call check_constructor_callable.
kono
parents:
diff changeset
613 (standard_conversion): Check LOOKUP_NO_CONVERSION instead of
kono
parents:
diff changeset
614 LOOKUP_CONSTRUCTOR_CALLABLE. Don't require a temporary for base
kono
parents:
diff changeset
615 conversions if LOOKUP_NO_TEMP_BIND.
kono
parents:
diff changeset
616 (implicit_conversion): Pass through LOOKUP_NO_TEMP_BIND.
kono
parents:
diff changeset
617 (build_user_type_conversion_1): Pass through LOOKUP_NO_TEMP_BIND for
kono
parents:
diff changeset
618 second conversion.
kono
parents:
diff changeset
619 * cp-tree.h (LOOKUP_CONSTRUCTOR_CALLABLE): Remove.
kono
parents:
diff changeset
620
kono
parents:
diff changeset
621 2007-10-22 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
622
kono
parents:
diff changeset
623 PR c++/33372
kono
parents:
diff changeset
624 * semantics.c (finish_omp_clauses): Check !type_dependent_expression_p
kono
parents:
diff changeset
625 before checking if its type is integral.
kono
parents:
diff changeset
626
kono
parents:
diff changeset
627 2007-10-22 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
628
kono
parents:
diff changeset
629 PR c++/33620
kono
parents:
diff changeset
630 * class.c (finish_struct_bits): Copy TYPE_ATTRIBUTES.
kono
parents:
diff changeset
631 * pt.c (apply_late_template_attributes): Splice out dependent
kono
parents:
diff changeset
632 attributes from DECL_ATTRIBUTES.
kono
parents:
diff changeset
633
kono
parents:
diff changeset
634 * decl.c (cxx_maybe_build_cleanup): Use build_address.
kono
parents:
diff changeset
635
kono
parents:
diff changeset
636 2007-10-17 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
637
kono
parents:
diff changeset
638 * typeck.c (build_binary_op) : Use appropriate warning option
kono
parents:
diff changeset
639 instead of unnamed warning.
kono
parents:
diff changeset
640
kono
parents:
diff changeset
641 2007-10-16 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
642
kono
parents:
diff changeset
643 PR c++/31446
kono
parents:
diff changeset
644 * pt.c (current_template_args): Do not change TREE_LIST elements
kono
parents:
diff changeset
645 with a TREE_VALUE of error_mark_node.
kono
parents:
diff changeset
646
kono
parents:
diff changeset
647 2007-10-16 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
648
kono
parents:
diff changeset
649 * typeck.c (cp_apply_type_quals_to_decl): Expand documentation.
kono
parents:
diff changeset
650 * decl.c (start_decl): Tidy.
kono
parents:
diff changeset
651 (start_decl_1): Call cp_apply_type_quals_to_decl after completing
kono
parents:
diff changeset
652 the type.
kono
parents:
diff changeset
653 (grokdeclarator): Clarify comment.
kono
parents:
diff changeset
654
kono
parents:
diff changeset
655 2007-10-14 Andrew Pinski <pinskia@gmail.com>
kono
parents:
diff changeset
656
kono
parents:
diff changeset
657 PR c++/30303
kono
parents:
diff changeset
658 * decl.c (grokfndecl): Return NULL after the "definition of
kono
parents:
diff changeset
659 implicitly-declared" error happened.
kono
parents:
diff changeset
660
kono
parents:
diff changeset
661 2007-10-12 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
662
kono
parents:
diff changeset
663 PR c++/26698
kono
parents:
diff changeset
664 * call.c (build_user_type_conversion_1): Do not consider conversion
kono
parents:
diff changeset
665 functions to convert a (possibly cv-qualified) object to the (possibly
kono
parents:
diff changeset
666 cv-qualified) same object type (or a reference to it), to a (possibly
kono
parents:
diff changeset
667 cv-qualified) base class of that type (or a reference to it).
kono
parents:
diff changeset
668
kono
parents:
diff changeset
669 2007-10-12 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
670
kono
parents:
diff changeset
671 * pt.c (tsubst): Use template_parm_level_and_index.
kono
parents:
diff changeset
672
kono
parents:
diff changeset
673 2007-10-12 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
674
kono
parents:
diff changeset
675 PR c++/32121
kono
parents:
diff changeset
676 * parser.c (cp_parser_compound_statement): Handle label-declarations
kono
parents:
diff changeset
677 at the beginning of the compound statement.
kono
parents:
diff changeset
678 (cp_parser_block_declaration): Issue diagnostics about __label__
kono
parents:
diff changeset
679 not at the beginning of a block.
kono
parents:
diff changeset
680
kono
parents:
diff changeset
681 2007-10-11 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
682
kono
parents:
diff changeset
683 PR c++/33461
kono
parents:
diff changeset
684 * pt.c (coerce_template_parameter_pack): Do not pass error_mark_node
kono
parents:
diff changeset
685 to convert_template_argument.
kono
parents:
diff changeset
686 (coerce_template_parms): Return error_mark_node after fixed-length
kono
parents:
diff changeset
687 error.
kono
parents:
diff changeset
688 (tsubst_decl): Check for error_mark_node the return value of the
kono
parents:
diff changeset
689 first tsubst in 'case VAR_DECL'.
kono
parents:
diff changeset
690
kono
parents:
diff changeset
691 2007-10-08 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
692
kono
parents:
diff changeset
693 * typeck2.c (digest_init): Call cplus_expand_constant after
kono
parents:
diff changeset
694 convert_for_initialization.
kono
parents:
diff changeset
695 * cp-objcp-common.h (LANG_HOOKS_EXPAND_CONSTANT): Removed.
kono
parents:
diff changeset
696 * expr.c (cplus_expand_constant): Updated function description.
kono
parents:
diff changeset
697
kono
parents:
diff changeset
698 2007-10-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
699
kono
parents:
diff changeset
700 PR c++/20416
kono
parents:
diff changeset
701 * call.c (initialize_reference): Handle local static reference
kono
parents:
diff changeset
702 temps properly.
kono
parents:
diff changeset
703
kono
parents:
diff changeset
704 2007-10-03 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
705
kono
parents:
diff changeset
706 PR c++/32470
kono
parents:
diff changeset
707 * name-lookup.c (push_namespace_with_attrs): Fold back into...
kono
parents:
diff changeset
708 (push_namespace): Here.
kono
parents:
diff changeset
709 (handle_namespace_attrs): New fn for the attr code.
kono
parents:
diff changeset
710 (leave_scope): Don't pop_visibility.
kono
parents:
diff changeset
711 * name-lookup.h (struct cp_binding_level): Remove has_visibility.
kono
parents:
diff changeset
712 * parser.c (cp_parser_namespace_definition): Call
kono
parents:
diff changeset
713 handle_namespace_attrs and pop_visibility as appropriate.
kono
parents:
diff changeset
714
kono
parents:
diff changeset
715 PR c++/11756
kono
parents:
diff changeset
716 * mangle.c (write_type) [TYPEOF_TYPE]: Just sorry.
kono
parents:
diff changeset
717
kono
parents:
diff changeset
718 2007-10-03 Alexandre Oliva <aoliva@redhat.com>
kono
parents:
diff changeset
719
kono
parents:
diff changeset
720 * decl.c (duplicate_decls): Preserve linkage flags for mere
kono
parents:
diff changeset
721 redeclarations of gnu_inline definitions.
kono
parents:
diff changeset
722
kono
parents:
diff changeset
723 2007-10-03 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
724
kono
parents:
diff changeset
725 PR c++/15764
kono
parents:
diff changeset
726 * decl.c (wrap_cleanups_r): New fn.
kono
parents:
diff changeset
727 (wrap_temporary_cleanups): New fn.
kono
parents:
diff changeset
728 (initialize_local_var): Call it.
kono
parents:
diff changeset
729
kono
parents:
diff changeset
730 2007-09-29 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
731
kono
parents:
diff changeset
732 PR c++/33094
kono
parents:
diff changeset
733 * decl.c (make_rtl_for_nonlocal_decl): It's ok for a member
kono
parents:
diff changeset
734 constant to not have DECL_EXTERNAL if it's file-local.
kono
parents:
diff changeset
735
kono
parents:
diff changeset
736 2007-09-28 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
737
kono
parents:
diff changeset
738 Revert
kono
parents:
diff changeset
739 2007-09-27 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
740
kono
parents:
diff changeset
741 * typeck2.c (digest_init): Call cplus_expand_constant after
kono
parents:
diff changeset
742 convert_for_initialization.
kono
parents:
diff changeset
743 * cp-objcp-common.h (LANG_HOOKS_EXPAND_CONSTANT): Removed.
kono
parents:
diff changeset
744 * expr.c (cplus_expand_constant): Updated function description.
kono
parents:
diff changeset
745
kono
parents:
diff changeset
746 2007-09-28 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
747
kono
parents:
diff changeset
748 PR c++/10179
kono
parents:
diff changeset
749 * class.c (layout_empty_base): Take rli parameter, update
kono
parents:
diff changeset
750 rli->record_align if empty base has user-specified alignment.
kono
parents:
diff changeset
751 (build_base_field): Pass rli to it.
kono
parents:
diff changeset
752
kono
parents:
diff changeset
753 2007-09-28 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
754
kono
parents:
diff changeset
755 PR c++/33213
kono
parents:
diff changeset
756 * error.c (dump_decl): Deal with TYPE_PACK_EXPANSION.
kono
parents:
diff changeset
757
kono
parents:
diff changeset
758 2007-09-28 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
759
kono
parents:
diff changeset
760 PR c++/33118
kono
parents:
diff changeset
761 * error.c (dump_expr): Deal with ARGUMENT_PACK_SELECT.
kono
parents:
diff changeset
762 (dump_type): Use dump_template_argument for TYPE_ARGUMENT_PACK.
kono
parents:
diff changeset
763 (dump_parameters): Just call dump_type for argument packs too.
kono
parents:
diff changeset
764
kono
parents:
diff changeset
765 2007-09-28 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
766
kono
parents:
diff changeset
767 PR c++/31434
kono
parents:
diff changeset
768 * tree.c (cp_build_qualified_type_real): Handle TYPE_PACK_EXPANSION
kono
parents:
diff changeset
769 qualification by creating qualified PACK_EXPANSION_PATTERN and
kono
parents:
diff changeset
770 then calling make_pack_expansion on it.
kono
parents:
diff changeset
771
kono
parents:
diff changeset
772 2007-09-27 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
773
kono
parents:
diff changeset
774 * typeck2.c (digest_init): Call cplus_expand_constant after
kono
parents:
diff changeset
775 convert_for_initialization.
kono
parents:
diff changeset
776 * cp-objcp-common.h (LANG_HOOKS_EXPAND_CONSTANT): Removed.
kono
parents:
diff changeset
777 * expr.c (cplus_expand_constant): Updated function description.
kono
parents:
diff changeset
778
kono
parents:
diff changeset
779 2007-09-27 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
780
kono
parents:
diff changeset
781 PR c++/33571
kono
parents:
diff changeset
782 * decl2.c (is_late_template_attribute): Don't crash on unknown
kono
parents:
diff changeset
783 attribute.
kono
parents:
diff changeset
784
kono
parents:
diff changeset
785 2007-09-27 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
786
kono
parents:
diff changeset
787 PR c++/33493
kono
parents:
diff changeset
788 * error.c (dump_expr): Deal with DELETE_EXPR and VEC_DELETE_EXPR.
kono
parents:
diff changeset
789 * cxx-pretty-print.c (pp_cxx_delete_expression): Add missing
kono
parents:
diff changeset
790 spaces in the formatting.
kono
parents:
diff changeset
791 * cxx-pretty-print.h (pp_cxx_delete_expression): Declare.
kono
parents:
diff changeset
792
kono
parents:
diff changeset
793 2007-09-27 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
794
kono
parents:
diff changeset
795 * error.c (cxx_print_error_function): Add third argument, pass
kono
parents:
diff changeset
796 it over to lhd_print_error_function.
kono
parents:
diff changeset
797 (cp_print_error_function): If diagnostic->abstract_origin, print
kono
parents:
diff changeset
798 virtual backtrace.
kono
parents:
diff changeset
799 * cp-tree.h (struct diagnostic_info): New forward decl.
kono
parents:
diff changeset
800 (cxx_print_error_function): Add third argument.
kono
parents:
diff changeset
801
kono
parents:
diff changeset
802 2007-09-25 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
803
kono
parents:
diff changeset
804 PR c++/33207
kono
parents:
diff changeset
805 * name-lookup.c (pushtag): Do not create an implicit typedef before
kono
parents:
diff changeset
806 the associated type declaration is known to be valid.
kono
parents:
diff changeset
807
kono
parents:
diff changeset
808 2007-09-25 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
809
kono
parents:
diff changeset
810 * tree.c (cxx_printable_name): Compare FUNCTION_DECL uids
kono
parents:
diff changeset
811 rather than pointers.
kono
parents:
diff changeset
812
kono
parents:
diff changeset
813 2007-09-24 Danny Smith <dannysmith@user.sourceforge.net>
kono
parents:
diff changeset
814
kono
parents:
diff changeset
815 PR c++/14688
kono
parents:
diff changeset
816 * search.c (check_final_overrider): Fail if
kono
parents:
diff changeset
817 targetm.comp_type_attributes returns 0.
kono
parents:
diff changeset
818
kono
parents:
diff changeset
819 2007-09-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
820
kono
parents:
diff changeset
821 PR c++/33239
kono
parents:
diff changeset
822 * pt.c (resolve_typename_type): Don't look things up in the original
kono
parents:
diff changeset
823 template if it would mean losing template arguments.
kono
parents:
diff changeset
824
kono
parents:
diff changeset
825 2007-09-24 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
826
kono
parents:
diff changeset
827 PR c++/33506
kono
parents:
diff changeset
828 * cp-tree.h (cxx_type_hash_eq): New prototype.
kono
parents:
diff changeset
829 * cp-objcp-common.h (LANG_HOOKS_TYPE_HASH_EQ): Redefine.
kono
parents:
diff changeset
830 * tree.c (cxx_type_hash_eq): New function.
kono
parents:
diff changeset
831
kono
parents:
diff changeset
832 2007-09-24 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
833
kono
parents:
diff changeset
834 PR c++/33185
kono
parents:
diff changeset
835 * tree.c (cp_build_qualified_type_real): Build a canonical
kono
parents:
diff changeset
836 ARRAY_TYPE if the original ARRAY_TYPE was not a canonical type.
kono
parents:
diff changeset
837
kono
parents:
diff changeset
838 2007-09-24 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
839
kono
parents:
diff changeset
840 PR c++/33112
kono
parents:
diff changeset
841 PR c++/33185
kono
parents:
diff changeset
842 * tree.c (cplus_array_compare): Compare pointers, not types.
kono
parents:
diff changeset
843 (build_cplus_array_type_1): Store new array type into the hash
kono
parents:
diff changeset
844 table before building the canonical type; build the canonical type
kono
parents:
diff changeset
845 correctly.
kono
parents:
diff changeset
846 (cp_build_qualified_type_real): Put all of the array types with
kono
parents:
diff changeset
847 cv-qualified element types into the C++ array hash table, built as
kono
parents:
diff changeset
848 variants of the unqualified versions.
kono
parents:
diff changeset
849
kono
parents:
diff changeset
850 2007-09-23 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
851
kono
parents:
diff changeset
852 PR c++/16370
kono
parents:
diff changeset
853 * decl.c (grokdeclarator): Look through implicit TYPE_DECLs
kono
parents:
diff changeset
854 for deprecation warnings.
kono
parents:
diff changeset
855
kono
parents:
diff changeset
856 2007-09-22 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
857
kono
parents:
diff changeset
858 PR c++/15269
kono
parents:
diff changeset
859 * call.c (build_over_call): Warn about deprecated virtuals.
kono
parents:
diff changeset
860
kono
parents:
diff changeset
861 PR c++/19407
kono
parents:
diff changeset
862 * cp-tree.h (ATTR_IS_DEPENDENT): New macro.
kono
parents:
diff changeset
863 (MAYBE_TAGGED_TYPE_P): Remove.
kono
parents:
diff changeset
864 * pt.c (apply_late_template_attributes): Check ATTR_IS_DEPENDENT
kono
parents:
diff changeset
865 instead of calling is_late_template_attribute again.
kono
parents:
diff changeset
866 (tsubst_decl) [TYPE_DECL]: Just check if the name is the tag.
kono
parents:
diff changeset
867 (tsubst): A typedef is a TYPE_NAME != TYPE_MAIN_DECL.
kono
parents:
diff changeset
868 Don't crash on typedefs from non-template classes.
kono
parents:
diff changeset
869 * decl2.c (grokfield): Don't sorry about attrs on template parms.
kono
parents:
diff changeset
870 (is_late_template_attribute): All attributes applied to template
kono
parents:
diff changeset
871 parms or typename types are dependent. Static.
kono
parents:
diff changeset
872 (splice_template_attributes): Pass decl through.
kono
parents:
diff changeset
873 (save_template_attributes): Likewise.
kono
parents:
diff changeset
874
kono
parents:
diff changeset
875 2007-09-20 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
876
kono
parents:
diff changeset
877 PR c++/33496
kono
parents:
diff changeset
878 * pt.c (tsubst_copy) <case SIZEOF_EXPR>: Handle error_mark_node
kono
parents:
diff changeset
879 returned from tsubst_pack_expansion.
kono
parents:
diff changeset
880 (tsubst_copy_and_build) <case SIZEOF_EXPR>: Likewise.
kono
parents:
diff changeset
881 (tsubst_copy_and_build) <case CONSTRUCTOR>: Likewise.
kono
parents:
diff changeset
882
kono
parents:
diff changeset
883 2007-09-20 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
884
kono
parents:
diff changeset
885 PR c++/33460
kono
parents:
diff changeset
886 * semantics.c (finish_id_expression): Use consistently
kono
parents:
diff changeset
887 context_for_name_lookup.
kono
parents:
diff changeset
888 * decl.c (fixup_anonymous_aggr): Fix error message for
kono
parents:
diff changeset
889 anonymous struct (vs union).
kono
parents:
diff changeset
890
kono
parents:
diff changeset
891 2007-09-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
892
kono
parents:
diff changeset
893 PR c++/7586
kono
parents:
diff changeset
894 * pt.c (tsubst): Handle typedefs by looking for the specialization.
kono
parents:
diff changeset
895 (retrieve_specialization): Only tagged types use
kono
parents:
diff changeset
896 DECL_TEMPLATE_INSTANTIATIONS.
kono
parents:
diff changeset
897 (instantiate_class_template): Push nested classes too.
kono
parents:
diff changeset
898 (tsubst_decl) [TYPE_DECL]: Only check for canonical decl for
kono
parents:
diff changeset
899 tagged types.
kono
parents:
diff changeset
900 * cp-tree.h (MAYBE_TAGGED_TYPE_P): New macro.
kono
parents:
diff changeset
901 * init.c (is_aggr_type): Remove redundant tests.
kono
parents:
diff changeset
902 * class.c (push_nested_class): Use CLASS_TYPE_P.
kono
parents:
diff changeset
903
kono
parents:
diff changeset
904 2007-09-20 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
905
kono
parents:
diff changeset
906 PR c++/33459
kono
parents:
diff changeset
907 * init.c (build_zero_init): If, recursively, build_zero_init
kono
parents:
diff changeset
908 returns a NULL_TREE, do not append it to the VEC of constructors.
kono
parents:
diff changeset
909
kono
parents:
diff changeset
910 2007-09-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
911
kono
parents:
diff changeset
912 PR c++/17743
kono
parents:
diff changeset
913 * pt.c (apply_late_template_attributes): Set processing_template_decl.
kono
parents:
diff changeset
914 (tsubst_decl) [TYPE_DECL]: Preserve naming typedef, pass
kono
parents:
diff changeset
915 ATTR_FLAG_TYPE_IN_PLACE.
kono
parents:
diff changeset
916 (tsubst): Do unqualified lookup to find typedefs from current class.
kono
parents:
diff changeset
917 [ARRAY_TYPE]: Propagate alignment info.
kono
parents:
diff changeset
918 * decl2.c (is_late_template_attribute): Only defer handling of
kono
parents:
diff changeset
919 attribute aligned if the expression is dependent.
kono
parents:
diff changeset
920 (save_template_attributes): If we're deferring any attributes,
kono
parents:
diff changeset
921 make this a naming typedef.
kono
parents:
diff changeset
922
kono
parents:
diff changeset
923 2007-09-18 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
924
kono
parents:
diff changeset
925 PR c++/33462 (again)
kono
parents:
diff changeset
926 * cxx-pretty-print.c (pp_cxx_va_arg_expression): Print
kono
parents:
diff changeset
927 va_arg instead of __builtin_va_arg.
kono
parents:
diff changeset
928
kono
parents:
diff changeset
929 2007-09-18 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
930
kono
parents:
diff changeset
931 PR c++/33462
kono
parents:
diff changeset
932 * cxx-pretty-print.c (pp_cxx_va_arg_expression): Add.
kono
parents:
diff changeset
933 (pp_cxx_primary_expression): Use it.
kono
parents:
diff changeset
934 * cxx-pretty-print.h (pp_cxx_va_arg_expression): Declare.
kono
parents:
diff changeset
935 * error.c (dump_expr): Use it.
kono
parents:
diff changeset
936
kono
parents:
diff changeset
937 2007-09-18 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
938
kono
parents:
diff changeset
939 PR c++/33463
kono
parents:
diff changeset
940 * cxx-pretty-print.c (pp_cxx_postfix_expression): Split
kono
parents:
diff changeset
941 out case TYPEID_EXPR to...
kono
parents:
diff changeset
942 (pp_cxx_typeid_expression): ... here; use pp_cxx_left_paren
kono
parents:
diff changeset
943 and pp_cxx_right_paren.
kono
parents:
diff changeset
944 * cxx-pretty-print.h (pp_cxx_typeid_expression): Declare.
kono
parents:
diff changeset
945 * error.c (dump_expr): Use it.
kono
parents:
diff changeset
946
kono
parents:
diff changeset
947 2007-09-18 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
948
kono
parents:
diff changeset
949 PR c++/33464
kono
parents:
diff changeset
950 * cxx-pretty-print.c (pp_cxx_trait_expression): Add.
kono
parents:
diff changeset
951 (pp_cxx_primary_expression): Use it.
kono
parents:
diff changeset
952 * cxx-pretty-print.h (pp_cxx_trait_expression): Declare.
kono
parents:
diff changeset
953 * error.c (dump_expr): Use it.
kono
parents:
diff changeset
954
kono
parents:
diff changeset
955 2007-09-16 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
956
kono
parents:
diff changeset
957 PR c++/33124
kono
parents:
diff changeset
958 * init.c (build_new): Remove warning for zero-element
kono
parents:
diff changeset
959 allocations.
kono
parents:
diff changeset
960
kono
parents:
diff changeset
961 2007-09-16 Nathan Sidwell <nathan@codesourcery.com>
kono
parents:
diff changeset
962
kono
parents:
diff changeset
963 PR c++/32756
kono
parents:
diff changeset
964 * call.c (maybe_handle_implicit_object): Set this_p, clear
kono
parents:
diff changeset
965 rvaluedness_matches_p.
kono
parents:
diff changeset
966 (compare_ics): Do not compare rvaluedness matching when one of the
kono
parents:
diff changeset
967 operands is an implicit object.
kono
parents:
diff changeset
968
kono
parents:
diff changeset
969 2007-09-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
970
kono
parents:
diff changeset
971 PR c++/17743, c++/19163
kono
parents:
diff changeset
972 * decl2.c (is_late_template_attribute): New fn.
kono
parents:
diff changeset
973 (splice_template_attributes, save_template_attributes): New fns.
kono
parents:
diff changeset
974 (cplus_decl_attributes): Call save_template_attributes.
kono
parents:
diff changeset
975 * pt.c (apply_late_template_attributes): New fn.
kono
parents:
diff changeset
976 (instantiate_class_template, tsubst_decl): Use it.
kono
parents:
diff changeset
977 * cp-tree.h: Declare is_late_template_attribute.
kono
parents:
diff changeset
978
kono
parents:
diff changeset
979 2007-09-13 Tom Tromey <tromey@redhat.com>
kono
parents:
diff changeset
980
kono
parents:
diff changeset
981 * parser.c (cp_lexer_new_main): Don't use
kono
parents:
diff changeset
982 c_lex_return_raw_strings.
kono
parents:
diff changeset
983 (cp_lexer_get_preprocessor_token): Update. Add special case when
kono
parents:
diff changeset
984 lexer is NULL.
kono
parents:
diff changeset
985
kono
parents:
diff changeset
986 2007-09-11 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
987
kono
parents:
diff changeset
988 * method.c (use_thunk): Use tree_rest_of_compilation
kono
parents:
diff changeset
989 * cp-objecp-common.h (LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION): Kill.
kono
parents:
diff changeset
990 (LANG_HOOKS_CALLGRAPH_EMIT_ASSOCIATED_THUNKS): Define.
kono
parents:
diff changeset
991 * cp-tree.h (expand_body): Kill.
kono
parents:
diff changeset
992 (emit_associated_thunks): Declare.
kono
parents:
diff changeset
993 * semantics.c (emit_associated_thunks): Export.
kono
parents:
diff changeset
994 (expand_body): Kill.
kono
parents:
diff changeset
995
kono
parents:
diff changeset
996 2007-09-09 David Daney <ddaney@avtrex.com>
kono
parents:
diff changeset
997
kono
parents:
diff changeset
998 PR c++/33324
kono
parents:
diff changeset
999 * init.c (build_new_1): Use POINTER_PLUS_EXPR instead of MINUS_EXPR
kono
parents:
diff changeset
1000 to calculate cookie_ptr.
kono
parents:
diff changeset
1001
kono
parents:
diff changeset
1002 2007-09-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1003
kono
parents:
diff changeset
1004 PR c++/33342
kono
parents:
diff changeset
1005 * pt.c (most_specialized_class): Set processing_template_decl
kono
parents:
diff changeset
1006 while tsubsting partial spec args.
kono
parents:
diff changeset
1007
kono
parents:
diff changeset
1008 2007-09-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1009
kono
parents:
diff changeset
1010 * decl2.c (get_guard): Copy visibility from the guarded variable.
kono
parents:
diff changeset
1011
kono
parents:
diff changeset
1012 2007-09-06 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
1013
kono
parents:
diff changeset
1014 * semantics.c (expand_body): Do not mark arguments of clones used.
kono
parents:
diff changeset
1015
kono
parents:
diff changeset
1016 2007-09-06 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1017
kono
parents:
diff changeset
1018 PR c++/32674
kono
parents:
diff changeset
1019 * decl.c (cp_finish_decl): When processing_template_decl,
kono
parents:
diff changeset
1020 deal correctly with init as TREE_LIST.
kono
parents:
diff changeset
1021
kono
parents:
diff changeset
1022 2007-09-06 Tom Tromey <tromey@redhat.com>
kono
parents:
diff changeset
1023
kono
parents:
diff changeset
1024 * decl.c (finish_function): Put return's location on line zero of
kono
parents:
diff changeset
1025 file.
kono
parents:
diff changeset
1026
kono
parents:
diff changeset
1027 2007-09-05 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1028
kono
parents:
diff changeset
1029 PR c++/15745
kono
parents:
diff changeset
1030 * except.c (prepare_eh_type): Use type_decays_to.
kono
parents:
diff changeset
1031
kono
parents:
diff changeset
1032 PR c++/15097
kono
parents:
diff changeset
1033 * init.c (build_delete): Use build_headof to get the address of the
kono
parents:
diff changeset
1034 complete object if we aren't using the deleting destructor.
kono
parents:
diff changeset
1035 * rtti.c (build_headof): No longer static.
kono
parents:
diff changeset
1036 * cp-tree.h: Declare it.
kono
parents:
diff changeset
1037
kono
parents:
diff changeset
1038 2007-09-06 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1039
kono
parents:
diff changeset
1040 * decl.c (duplicate_decls): Set TREE_NOTHROW on __builtin_XX
kono
parents:
diff changeset
1041 decl if a prototype for XX is provided with throw().
kono
parents:
diff changeset
1042
kono
parents:
diff changeset
1043 PR c++/33289
kono
parents:
diff changeset
1044 * decl.c (builtin_function_1): Set DECL_ANTICIPATED also
kono
parents:
diff changeset
1045 on __*_chk non-__builtin_* decls.
kono
parents:
diff changeset
1046
kono
parents:
diff changeset
1047 2007-09-05 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1048
kono
parents:
diff changeset
1049 PR c++/30302
kono
parents:
diff changeset
1050 * semantics.c (finish_id_expression): Use context_for_name_lookup
kono
parents:
diff changeset
1051 insted of DECL_CONTEXT, to see through anonymous structs and unions.
kono
parents:
diff changeset
1052 * class.c (finish_struct_anon): Deal correctly with anonymous
kono
parents:
diff changeset
1053 structs (vs unions, as GNU extension) in error messages.
kono
parents:
diff changeset
1054
kono
parents:
diff changeset
1055 2007-09-05 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
1056
kono
parents:
diff changeset
1057 * sematics.c (expand_body): Remove unnecesary import_export_decl
kono
parents:
diff changeset
1058 call, DECL_EXTERNAL checks and current_function_decl saving.
kono
parents:
diff changeset
1059
kono
parents:
diff changeset
1060 2007-09-05 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1061
kono
parents:
diff changeset
1062 PR c++/29731 (again)
kono
parents:
diff changeset
1063 * parser.c (cp_parser_primary_expression): Return error_mark_node
kono
parents:
diff changeset
1064 when a statement-expression is found in a template-argument list.
kono
parents:
diff changeset
1065
kono
parents:
diff changeset
1066 2007-09-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1067
kono
parents:
diff changeset
1068 * except.c (initialize_handler_parm): Use
kono
parents:
diff changeset
1069 fold_build_cleanup_point_expr.
kono
parents:
diff changeset
1070
kono
parents:
diff changeset
1071 PR c++/31419
kono
parents:
diff changeset
1072 * call.c (reference_binding): Don't look for user-defined conversions
kono
parents:
diff changeset
1073 to the same type.
kono
parents:
diff changeset
1074
kono
parents:
diff changeset
1075 PR c++/31411
kono
parents:
diff changeset
1076 * except.c (initialize_handler_parm): Put a CLEANUP_POINT_EXPR inside
kono
parents:
diff changeset
1077 the MUST_NOT_THROW_EXPR.
kono
parents:
diff changeset
1078
kono
parents:
diff changeset
1079 2007-09-04 Richard Sandiford <richard@codesourcery.com>
kono
parents:
diff changeset
1080
kono
parents:
diff changeset
1081 * decl.c (cp_finish_decl): Call determine_visibility before
kono
parents:
diff changeset
1082 make_rtl_for_nonlocal_decl.
kono
parents:
diff changeset
1083
kono
parents:
diff changeset
1084 2007-09-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1085
kono
parents:
diff changeset
1086 PR c++/14032
kono
parents:
diff changeset
1087 * pt.c (most_specialized_class): Substitute outer template
kono
parents:
diff changeset
1088 arguments into the arguments of a member template partial
kono
parents:
diff changeset
1089 specialization.
kono
parents:
diff changeset
1090 (strip_innermost_template_args): New fn.
kono
parents:
diff changeset
1091
kono
parents:
diff changeset
1092 2007-09-03 Daniel Jacobowitz <dan@codesourcery.com>
kono
parents:
diff changeset
1093
kono
parents:
diff changeset
1094 * Make-lang.in (g++spec.o): Remove SHLIB_MULTILIB.
kono
parents:
diff changeset
1095
kono
parents:
diff changeset
1096 2007-09-03 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
kono
parents:
diff changeset
1097
kono
parents:
diff changeset
1098 * call.c (name_as_c_string): Supply a TYPE for CONST_CAST.
kono
parents:
diff changeset
1099 * decl.c (cp_make_fname_decl): Likewise,
kono
parents:
diff changeset
1100 * parser.c (cp_parser_string_literal): Likewise,
kono
parents:
diff changeset
1101 * tree.c (pod_type_p, zero_init_p): Use CONST_CAST_TREE.
kono
parents:
diff changeset
1102 * typeck.c (cp_type_quals, cp_type_readonly, cp_has_mutable_p):
kono
parents:
diff changeset
1103 Likewise,
kono
parents:
diff changeset
1104
kono
parents:
diff changeset
1105 2007-09-02 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1106
kono
parents:
diff changeset
1107 PR c++/33208
kono
parents:
diff changeset
1108 * typeck.c (build_unary_op): Fix error message for
kono
parents:
diff changeset
1109 Boolean expression as operand to operator--.
kono
parents:
diff changeset
1110
kono
parents:
diff changeset
1111 2007-09-01 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
kono
parents:
diff changeset
1112
kono
parents:
diff changeset
1113 * tree.c (pod_type_p, zero_init_p): Use strip_array_types.
kono
parents:
diff changeset
1114 * typeck.c (cp_type_quals, cp_type_readonly, cp_has_mutable_p):
kono
parents:
diff changeset
1115 Likewise.
kono
parents:
diff changeset
1116
kono
parents:
diff changeset
1117 2007-08-31 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
1118
kono
parents:
diff changeset
1119 PR c++/32597
kono
parents:
diff changeset
1120 * init.c (build_default_init): Make extern.
kono
parents:
diff changeset
1121 * cp-tree.h (build_default_init): Declare here.
kono
parents:
diff changeset
1122 * pt.c (tsubst_expr): When the instantiation of the initializer of
kono
parents:
diff changeset
1123 a variable results in an empty list, default-initialize the
kono
parents:
diff changeset
1124 variable.
kono
parents:
diff changeset
1125 (tsubst_copy_and_build): When the instantiation of the initializer
kono
parents:
diff changeset
1126 in a new expression results in an empty initializer list,
kono
parents:
diff changeset
1127 default-initialize it.
kono
parents:
diff changeset
1128
kono
parents:
diff changeset
1129 2007-08-31 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
1130
kono
parents:
diff changeset
1131 * mangle.c (write_type): Change mangling of rvalue reference from
kono
parents:
diff changeset
1132 `RR' to `O'.
kono
parents:
diff changeset
1133
kono
parents:
diff changeset
1134 2007-08-31 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1135
kono
parents:
diff changeset
1136 * decl.c (duplicate_decls): Remove duplicated line.
kono
parents:
diff changeset
1137
kono
parents:
diff changeset
1138 2007-08-31 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1139
kono
parents:
diff changeset
1140 PR c++/33210
kono
parents:
diff changeset
1141 * cxx-pretty-print.c (pp_cxx_unqualified_id): Deal with
kono
parents:
diff changeset
1142 BOUND_TEMPLATE_TEMPLATE_PARM.
kono
parents:
diff changeset
1143
kono
parents:
diff changeset
1144 2007-08-31 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1145
kono
parents:
diff changeset
1146 PR c++/32113
kono
parents:
diff changeset
1147 * search.c (lookup_member): Check the name argument for
kono
parents:
diff changeset
1148 error_mark_node.
kono
parents:
diff changeset
1149
kono
parents:
diff changeset
1150 2007-08-31 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1151
kono
parents:
diff changeset
1152 PR c++/33212
kono
parents:
diff changeset
1153 * parser.c (cp_parser_trait_expr): Check rerurn value of
kono
parents:
diff changeset
1154 cp_parser_type_id.
kono
parents:
diff changeset
1155
kono
parents:
diff changeset
1156 2007-08-30 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
1157
kono
parents:
diff changeset
1158 * cvt.c (cp_convert_to_pointer): Remove force parameter. Call
kono
parents:
diff changeset
1159 convert_ptrmem for pointer to member conversions.
kono
parents:
diff changeset
1160 (convert_to_pointer_force): Update cp_convert_to_pointer call.
kono
parents:
diff changeset
1161 (ocp_convert): Update cp_convert_to_pointer call.
kono
parents:
diff changeset
1162 * typeck.c (convert_ptrmem): Add conditional for null pointers to
kono
parents:
diff changeset
1163 members.
kono
parents:
diff changeset
1164 (build_static_cast_1): Check can_convert for conversions in either
kono
parents:
diff changeset
1165 direction.
kono
parents:
diff changeset
1166 (get_delta_difference_1): New function.
kono
parents:
diff changeset
1167 (get_delta_difference): Refactor to call get_delta_difference_1.
kono
parents:
diff changeset
1168
kono
parents:
diff changeset
1169 2007-08-30 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1170
kono
parents:
diff changeset
1171 * decl.c (start_preparsed_function): Set
kono
parents:
diff changeset
1172 DECL_DISREGARD_INLINE_LIMITS for GNU_INLINE_P functions.
kono
parents:
diff changeset
1173
kono
parents:
diff changeset
1174 2007-08-28 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1175
kono
parents:
diff changeset
1176 PR c++/33209
kono
parents:
diff changeset
1177 * error.c (dump_expr): Deal with TEMPLATE_TYPE_PARM and
kono
parents:
diff changeset
1178 BOUND_TEMPLATE_TEMPLATE_PARM.
kono
parents:
diff changeset
1179
kono
parents:
diff changeset
1180 2007-08-28 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1181
kono
parents:
diff changeset
1182 PR c++/32596
kono
parents:
diff changeset
1183 PR c++/32400
kono
parents:
diff changeset
1184 * pt.c (check_explicit_specialization): Set DECL_INTERFACE_KNOWN
kono
parents:
diff changeset
1185 and DECL_NOT_REALLY_EXTERN if tmpl_func is not public.
kono
parents:
diff changeset
1186
kono
parents:
diff changeset
1187 2007-08-27 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1188
kono
parents:
diff changeset
1189 PR c++/29000
kono
parents:
diff changeset
1190 * pt.c (build_non_dependent_expr, type_dependent_expression_p):
kono
parents:
diff changeset
1191 Look inside STMT_EXPR.
kono
parents:
diff changeset
1192 * semantics.c (stmt_expr_value_expr): New fn.
kono
parents:
diff changeset
1193 * cp-tree.h: Declare it.
kono
parents:
diff changeset
1194
kono
parents:
diff changeset
1195 PR c++/28558
kono
parents:
diff changeset
1196 * decl.c (groktypename): Ignore attributes applied to class type.
kono
parents:
diff changeset
1197
kono
parents:
diff changeset
1198 2007-08-28 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1199
kono
parents:
diff changeset
1200 * decl.c (duplicate_decls): Merge DECL_DISREGARD_INLINE_LIMITS.
kono
parents:
diff changeset
1201
kono
parents:
diff changeset
1202 2007-08-28 Gabriel Dos Reis <gdr@integrable-solutions.net>
kono
parents:
diff changeset
1203
kono
parents:
diff changeset
1204 * error.c (dump_expr): Handle COMPLEX_CST.
kono
parents:
diff changeset
1205 * cxx-pretty-print.c (pp_cxx_primary_expression): Likewise.
kono
parents:
diff changeset
1206 (pp_cxx_expression): Likewise.
kono
parents:
diff changeset
1207
kono
parents:
diff changeset
1208 2007-08-27 Alexandre Oliva <aoliva@redhat.com>
kono
parents:
diff changeset
1209
kono
parents:
diff changeset
1210 * decl.c (GNU_INLINE_P): New.
kono
parents:
diff changeset
1211 (duplicate_decls): Handle gnu_inline. Merge attributes and
kono
parents:
diff changeset
1212 some flags in overriding definitions.
kono
parents:
diff changeset
1213 (redeclaration_error_message): Handle gnu_inline.
kono
parents:
diff changeset
1214 (start_preparsed_function): Likewise.
kono
parents:
diff changeset
1215
kono
parents:
diff changeset
1216 2007-08-25 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
kono
parents:
diff changeset
1217
kono
parents:
diff changeset
1218 * call.c (sufficient_parms_p): Constify.
kono
parents:
diff changeset
1219 * class.c (same_signature_p): Likewise.
kono
parents:
diff changeset
1220 * cp-gimplify.c (is_invisiref_parm,
kono
parents:
diff changeset
1221 cxx_omp_privatize_by_reference): Likewise.
kono
parents:
diff changeset
1222 * cp-objcp-common.c (has_c_linkage): Likewise.
kono
parents:
diff changeset
1223 * cp-tree.h (NON_THUNK_FUNCTION_CHECK, THUNK_FUNCTION_CHECK,
kono
parents:
diff changeset
1224 sufficient_parms_p, same_signature_p, copy_fn_p, move_fn_p,
kono
parents:
diff changeset
1225 grok_ctor_properties, nothrow_libfn_p, skip_artificial_parms_for,
kono
parents:
diff changeset
1226 num_artificial_parms_for, comp_template_parms,
kono
parents:
diff changeset
1227 template_parameter_pack_p, any_dependent_template_arguments_p,
kono
parents:
diff changeset
1228 any_type_dependent_arguments_p, any_value_dependent_elements_p,
kono
parents:
diff changeset
1229 repo_export_class_p, cxx_omp_privatize_by_reference, pod_type_p,
kono
parents:
diff changeset
1230 zero_init_p, member_p, cp_lvalue_kind,
kono
parents:
diff changeset
1231 builtin_valid_in_constant_expr_p, decl_anon_ns_mem_p,
kono
parents:
diff changeset
1232 varargs_function_p, is_dummy_object, special_function_kind,
kono
parents:
diff changeset
1233 string_conv_p, type_unknown_p, comp_except_specs, compparms,
kono
parents:
diff changeset
1234 comp_cv_qualification, is_bitfield_expr_with_lowered_type,
kono
parents:
diff changeset
1235 unlowered_expr_type, ptr_reasonably_similar, cp_type_readonly,
kono
parents:
diff changeset
1236 cp_has_mutable_p, at_least_as_qualified_p,
kono
parents:
diff changeset
1237 invalid_nonstatic_memfn_p, lvalue_or_else, lvalue_p): Likewise.
kono
parents:
diff changeset
1238 * decl.c (copy_fn_p, move_fn_p, grok_ctor_properties): Likewise.
kono
parents:
diff changeset
1239 * except.c (nothrow_libfn_p): Likewise.
kono
parents:
diff changeset
1240 * method.c (skip_artificial_parms_for, num_artificial_parms_for):
kono
parents:
diff changeset
1241 Likewise.
kono
parents:
diff changeset
1242 * pt.c (comp_template_parms, template_parameter_pack_p,
kono
parents:
diff changeset
1243 any_type_dependent_arguments_p, any_value_dependent_elements_p,
kono
parents:
diff changeset
1244 any_dependent_template_arguments_p): Likewise.
kono
parents:
diff changeset
1245 * repo.c (repo_export_class_p): Likewise.
kono
parents:
diff changeset
1246 * semantics.c (anon_aggr_type_p): Likewise.
kono
parents:
diff changeset
1247 * tree.c (lvalue_p_1, real_lvalue_p, lvalue_p,
kono
parents:
diff changeset
1248 builtin_valid_in_constant_expr_p, decl_anon_ns_mem_p,
kono
parents:
diff changeset
1249 varargs_function_p, member_p, is_dummy_object, pod_type_p,
kono
parents:
diff changeset
1250 zero_init_p, special_function_p): Likewise.
kono
parents:
diff changeset
1251 * typeck.c (comp_array_types, type_unknown_p, comp_except_specs,
kono
parents:
diff changeset
1252 comp_array_types, at_least_as_qualified_p, comp_cv_qualification,
kono
parents:
diff changeset
1253 compparms, invalid_nonstatic_memfn_p,
kono
parents:
diff changeset
1254 is_bitfield_expr_with_lowered_type, unlowered_expr_type,
kono
parents:
diff changeset
1255 string_conv_p, ptr_reasonably_similar, cp_type_readonly,
kono
parents:
diff changeset
1256 cp_has_mutable_p, lvalue_or_else): Likewise.
kono
parents:
diff changeset
1257
kono
parents:
diff changeset
1258 2007-08-25 Paolo Bonzini <bonzini@gnu.org>
kono
parents:
diff changeset
1259
kono
parents:
diff changeset
1260 * decl.c (cp_tree_node_structure): Kill TINST_LEVEL case.
kono
parents:
diff changeset
1261 * cp-objcp-common.c (cp_tree_size): Ditto.
kono
parents:
diff changeset
1262 * tree.c (cp_walk_subtrees): Ditto
kono
parents:
diff changeset
1263 * cp-tree.def (TINST_LEVEL): Go away.
kono
parents:
diff changeset
1264 * cp-tree.h (struct tinst_level_s): Rename to struct tinst_level,
kono
parents:
diff changeset
1265 move together with other non-tree structs.
kono
parents:
diff changeset
1266 (enum cp_tree_node_structure_enum): Nuke TS_CP_TINST_LEVEL.
kono
parents:
diff changeset
1267 (union lang_tree_node): Eliminate tinst_level field.
kono
parents:
diff changeset
1268 (TINST_DECL, TINST_LOCATION, TINST_IN_SYSTEM_HEADER_P): Annihilate.
kono
parents:
diff changeset
1269 (current_instantiation, outermost_tinst_level): Return
kono
parents:
diff changeset
1270 a "struct tinst_level *".
kono
parents:
diff changeset
1271
kono
parents:
diff changeset
1272 * error.c (print_instantiation_partial_context): Change second
kono
parents:
diff changeset
1273 parameter to a "struct tinst_level *". Replace accessor macros
kono
parents:
diff changeset
1274 with field access.
kono
parents:
diff changeset
1275 (print_instantiation_full_context): Likewise.
kono
parents:
diff changeset
1276 * lex.c (in_main_input_context): Likewise.
kono
parents:
diff changeset
1277
kono
parents:
diff changeset
1278 * pt.c (struct pending_templates): New.
kono
parents:
diff changeset
1279 (pending_templates, last_pending_template): Use it as a type.
kono
parents:
diff changeset
1280 (current_tinst_level): Change typo to "struct tinst_level *"
kono
parents:
diff changeset
1281 (reopen_tinst_level): Accept "struct tinst_level *", return decl.
kono
parents:
diff changeset
1282 (add_pending_template): Construct a "struct pending_template".
kono
parents:
diff changeset
1283 Replace TINST_LEVEL accessor macros with field access.
kono
parents:
diff changeset
1284 (push_tinst_level): Likewise, using GGC_NEW instead of make_node.
kono
parents:
diff changeset
1285 (pop_tinst_level): Likewise.
kono
parents:
diff changeset
1286 (instantiate_pending_templates): Likewise. Factor common code used
kono
parents:
diff changeset
1287 when an instantiation has been done.
kono
parents:
diff changeset
1288 (outermost_tinst_level): Replace tree_last with loop.
kono
parents:
diff changeset
1289 (current_instantiation): Return a "struct tinst_level *".
kono
parents:
diff changeset
1290
kono
parents:
diff changeset
1291 2007-08-24 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
1292
kono
parents:
diff changeset
1293 * name-lookup.c (add_decl_to_level): Remove addition to vtables chain.
kono
parents:
diff changeset
1294 * name-lookup.h (cp_binding_level): Remove vtables member.
kono
parents:
diff changeset
1295
kono
parents:
diff changeset
1296 2007-08-24 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1297
kono
parents:
diff changeset
1298 * tree.c (cp_cannot_inline_tree_fn): Remove.
kono
parents:
diff changeset
1299 * cp-tree.h (cp_cannot_inline_tree_fn): Likewise.
kono
parents:
diff changeset
1300 * cp-objcp-common.h (LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN):
kono
parents:
diff changeset
1301 Remove define.
kono
parents:
diff changeset
1302
kono
parents:
diff changeset
1303 2007-08-24 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1304
kono
parents:
diff changeset
1305 PR c++/32567
kono
parents:
diff changeset
1306 * typeck.c (build_unary_op) <case PREINCREMENT_EXPR>: Return
kono
parents:
diff changeset
1307 error_mark_node right away if build_expr_type_conversion
kono
parents:
diff changeset
1308 returned it.
kono
parents:
diff changeset
1309
kono
parents:
diff changeset
1310 PR c++/32898
kono
parents:
diff changeset
1311 * name-lookup.c (set_decl_namespace): lookup_qualified_name failure
kono
parents:
diff changeset
1312 is error_mark_node rather than NULL_TREE.
kono
parents:
diff changeset
1313 * pt.c (check_explicit_specialization): Likewise.
kono
parents:
diff changeset
1314
kono
parents:
diff changeset
1315 PR c++/31941
kono
parents:
diff changeset
1316 * error.c (resolve_virtual_fun_from_obj_type_ref): Handle
kono
parents:
diff changeset
1317 TARGET_VTABLE_USES_DESCRIPTORS targets properly.
kono
parents:
diff changeset
1318
kono
parents:
diff changeset
1319 2007-08-22 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1320
kono
parents:
diff changeset
1321 PR c++/29365
kono
parents:
diff changeset
1322 * pt.c (outermost_tinst_level): New function.
kono
parents:
diff changeset
1323 * lex.c (in_main_input_context): New function.
kono
parents:
diff changeset
1324 * cp-tree.h: Declare it.
kono
parents:
diff changeset
1325 * decl2.c (constrain_class_visibility): Use it to avoid warning
kono
parents:
diff changeset
1326 about uses of the anonymous namespace in the main input file.
kono
parents:
diff changeset
1327
kono
parents:
diff changeset
1328 2007-08-21 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1329
kono
parents:
diff changeset
1330 * init.c (build_new_1): Use get_target_expr instead of save_expr.
kono
parents:
diff changeset
1331
kono
parents:
diff changeset
1332 2007-08-20 Pawel Sikora <pluto@pld-linux.org>
kono
parents:
diff changeset
1333
kono
parents:
diff changeset
1334 PR c++/7302
kono
parents:
diff changeset
1335 * class.c (finish_struct_1): Warn when a class has virtual
kono
parents:
diff changeset
1336 functions and accessible non-virtual destructor.
kono
parents:
diff changeset
1337
kono
parents:
diff changeset
1338 2007-08-20 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1339
kono
parents:
diff changeset
1340 PR c++/22369
kono
parents:
diff changeset
1341 PR c++/22451
kono
parents:
diff changeset
1342 * call.c (build_new_method_call): Convert initializer to
kono
parents:
diff changeset
1343 the basetype.
kono
parents:
diff changeset
1344 * init.c (build_aggr_init): Do not fiddle with types.
kono
parents:
diff changeset
1345 (build_vec_delete_1): Use correct type for POINTER_PLUS_EXPR.
kono
parents:
diff changeset
1346 * except.c (build_throw): Do not drop qualifiers for the
kono
parents:
diff changeset
1347 pointer type.
kono
parents:
diff changeset
1348 * typeck.c (get_member_function_from_ptrfunc): Do not
kono
parents:
diff changeset
1349 fiddle with types, instead convert.
kono
parents:
diff changeset
1350 (build_ptrmemfunc1): Convert to the target type for
kono
parents:
diff changeset
1351 initialization.
kono
parents:
diff changeset
1352 (gfc_trans_allocate): Convert result to target type.
kono
parents:
diff changeset
1353 * cp-objcp-common.c (cxx_get_alias_set): Pointers to
kono
parents:
diff changeset
1354 pointer-to-member structures shall have alias set zero as well.
kono
parents:
diff changeset
1355
kono
parents:
diff changeset
1356 2007-08-20 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1357
kono
parents:
diff changeset
1358 * cp-objcp-common.h (LANG_HOOKS_TREE_INLINING_AUTO_VAR_IN_FN_P):
kono
parents:
diff changeset
1359 Remove.
kono
parents:
diff changeset
1360 * cp-tree.h (cp_auto_var_in_fn_p): Remove.
kono
parents:
diff changeset
1361 (nonstatic_local_decl_p): Likewise.
kono
parents:
diff changeset
1362 * tree.c (cp_auto_var_in_fn_p): Remove.
kono
parents:
diff changeset
1363 * decl.c (nonstatic_local_decl_p): Remove.
kono
parents:
diff changeset
1364
kono
parents:
diff changeset
1365 2007-08-20 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1366
kono
parents:
diff changeset
1367 * cp-objcp-common.h (LANG_HOOKS_TREE_INLINING_WALK_SUBTREES):
kono
parents:
diff changeset
1368 Remove define.
kono
parents:
diff changeset
1369 * tree.h (cp_walk_tree): New define to walk_tree_1 with
kono
parents:
diff changeset
1370 cp_walk_subtrees lh parameter.
kono
parents:
diff changeset
1371 (cp_walk_tree_without_duplicates): New define to
kono
parents:
diff changeset
1372 walk_tree_without_duplicates_1 with cp_walk_subtrees lh parameter.
kono
parents:
diff changeset
1373 * tree.c (count_trees): Call
kono
parents:
diff changeset
1374 cp_walk_tree_without_duplicates.
kono
parents:
diff changeset
1375 (verify_stmt_tree): Call cp_walk_tree.
kono
parents:
diff changeset
1376 (break_out_target_exprs): Likewise.
kono
parents:
diff changeset
1377 (WALK_SUBTREE): Likewise.
kono
parents:
diff changeset
1378 * cp-gimplify.c (cp_genericize): Likewise.
kono
parents:
diff changeset
1379 * cp-pt.c (find_parameter_packs_r): Likewise.
kono
parents:
diff changeset
1380 (uses_parameter_packs): Likewise.
kono
parents:
diff changeset
1381 (make_pack_expansion): Likewise.
kono
parents:
diff changeset
1382 (check_for_bare_parameter_packs): Likewise.
kono
parents:
diff changeset
1383 (for_each_template_parm): Likewise.
kono
parents:
diff changeset
1384 * decl.c (check_default_argument): Call
kono
parents:
diff changeset
1385 cp_walk_tree_without_duplicates.
kono
parents:
diff changeset
1386 * except.c (build_throw): Likewise.
kono
parents:
diff changeset
1387 * decl2.c (type_visibility): Likewise.
kono
parents:
diff changeset
1388 * semantics.c (expand_or_defer_fn): Likewise.
kono
parents:
diff changeset
1389 (finalize_nrv): Call cp_walk_tree.
kono
parents:
diff changeset
1390
kono
parents:
diff changeset
1391 2007-08-20 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1392
kono
parents:
diff changeset
1393 PR c++/33025
kono
parents:
diff changeset
1394 * init.c (build_new_1): Rename placement_var variable to placement_expr.
kono
parents:
diff changeset
1395 Initialize it with save_expr rather than get_temp_regvar.
kono
parents:
diff changeset
1396
kono
parents:
diff changeset
1397 2007-08-17 Andrew Pinski <andrew_pinski@playstation.sony.com>
kono
parents:
diff changeset
1398
kono
parents:
diff changeset
1399 PR c++/28989
kono
parents:
diff changeset
1400 * tree.c (lvalue_p_1 <case SAVE_EXPR>): SAVE_EXPRs are never
kono
parents:
diff changeset
1401 lvalues.
kono
parents:
diff changeset
1402
kono
parents:
diff changeset
1403 2007-08-17 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
1404
kono
parents:
diff changeset
1405 PR c++/31749
kono
parents:
diff changeset
1406 * name-lookup.c (do_nonmember_using_decl): Shift implicit type
kono
parents:
diff changeset
1407 declarations into appropriate slots for comparison. Fix type
kono
parents:
diff changeset
1408 comparison.
kono
parents:
diff changeset
1409
kono
parents:
diff changeset
1410 2007-08-17 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1411
kono
parents:
diff changeset
1412 PR c++/32112
kono
parents:
diff changeset
1413 * error.c (dump_decl): Deal with UNBOUND_CLASS_TEMPLATE.
kono
parents:
diff changeset
1414 * cxx-pretty-print.c (pp_cxx_unqualified_id): Likewise.
kono
parents:
diff changeset
1415
kono
parents:
diff changeset
1416 2007-08-17 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1417
kono
parents:
diff changeset
1418 PR c++/32870
kono
parents:
diff changeset
1419 * parser.c (cp_parser_class_head): Improve error message.
kono
parents:
diff changeset
1420
kono
parents:
diff changeset
1421 2007-08-16 Seongbae Park <seongbae.park@gmail.com>
kono
parents:
diff changeset
1422
kono
parents:
diff changeset
1423 * pt.c (instantiate_decl): Set input_location
kono
parents:
diff changeset
1424 for the function end.
kono
parents:
diff changeset
1425
kono
parents:
diff changeset
1426 2007-08-16 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
kono
parents:
diff changeset
1427
kono
parents:
diff changeset
1428 * cp-objcp-common.c (cxx_warn_unused_global_decl, cp_expr_size):
kono
parents:
diff changeset
1429 Constify.
kono
parents:
diff changeset
1430 * cp-tree.h (local_variable_p, nonstatic_local_decl_p,
kono
parents:
diff changeset
1431 class_tmpl_impl_spec_p, cp_auto_var_in_fn_p, cp_type_quals,
kono
parents:
diff changeset
1432 cxx_incomplete_type_diagnostic, cxx_incomplete_type_error,
kono
parents:
diff changeset
1433 cxx_warn_unused_global_decl, cp_expr_size): Likewise.
kono
parents:
diff changeset
1434 * decl.c (local_variable_p, nonstatic_local_decl_p): Likewise.
kono
parents:
diff changeset
1435 * tree.c (class_tmpl_impl_spec_p, cp_auto_var_in_fn_p): Likewise.
kono
parents:
diff changeset
1436 * typeck.c (cp_type_quals): Likewise.
kono
parents:
diff changeset
1437 * typeck2.c (cxx_incomplete_type_diagnostic,
kono
parents:
diff changeset
1438 cxx_incomplete_type_error): Likewise.
kono
parents:
diff changeset
1439
kono
parents:
diff changeset
1440 2007-08-16 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1441
kono
parents:
diff changeset
1442 PR c++/31132
kono
parents:
diff changeset
1443 * pt.c (tsubst_friend_function): When check_classfn
kono
parents:
diff changeset
1444 returns error_mark_node likewise return it.
kono
parents:
diff changeset
1445
kono
parents:
diff changeset
1446 2007-08-15 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1447
kono
parents:
diff changeset
1448 PR c++/32992
kono
parents:
diff changeset
1449 * typeck.c (check_return_expr): Don't NRV optimize vars in
kono
parents:
diff changeset
1450 anonymous unions.
kono
parents:
diff changeset
1451 * decl.c (finish_function): Comment fix.
kono
parents:
diff changeset
1452
kono
parents:
diff changeset
1453 2007-08-15 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1454
kono
parents:
diff changeset
1455 PR c++/33035
kono
parents:
diff changeset
1456 * pt.c (push_template_decl_real): Depending on TYPE_P
kono
parents:
diff changeset
1457 use either TYPE_CONTEXT or DECL_CONTEXT.
kono
parents:
diff changeset
1458
kono
parents:
diff changeset
1459 2007-08-14 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
1460
kono
parents:
diff changeset
1461 * semantics.c (finish_omp_clauses): Strip a NOP_EXPR if
kono
parents:
diff changeset
1462 constructors and destructors return this.
kono
parents:
diff changeset
1463
kono
parents:
diff changeset
1464 2007-08-14 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1465
kono
parents:
diff changeset
1466 PR c++/27211
kono
parents:
diff changeset
1467 * decl2.c (check_classfn): Return error_mark_node in case of error;
kono
parents:
diff changeset
1468 in that case, do not call add_method.
kono
parents:
diff changeset
1469 * decl.c (start_decl): Deal with check_classfn returning
kono
parents:
diff changeset
1470 error_mark_node.
kono
parents:
diff changeset
1471 (grokfndecl): Likewise.
kono
parents:
diff changeset
1472 * pt.c (tsubst_friend_function): Likewise.
kono
parents:
diff changeset
1473
kono
parents:
diff changeset
1474 2007-08-14 Andrew Pinski <pinskia@gmail.com>
kono
parents:
diff changeset
1475
kono
parents:
diff changeset
1476 PR c++/30428
kono
parents:
diff changeset
1477 * typeck.c (build_binary_op): Disallow vector float types with
kono
parents:
diff changeset
1478 BIT_IOR_EXPR, BIT_AND_EXPR, and BIT_XOR_EXPR.
kono
parents:
diff changeset
1479
kono
parents:
diff changeset
1480 2007-08-11 Ian Lance Taylor <iant@google.com>
kono
parents:
diff changeset
1481
kono
parents:
diff changeset
1482 * cp-objcp-common.c (cxx_get_alias_set): Change return type to
kono
parents:
diff changeset
1483 alias_set_type.
kono
parents:
diff changeset
1484 * cp-tree.h (cxx_get_alias_set): Update declaration.
kono
parents:
diff changeset
1485
kono
parents:
diff changeset
1486 2007-08-10 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
1487
kono
parents:
diff changeset
1488 * name-lookup.c (do_nonmember_using_decl): Print an error for ambiguous
kono
parents:
diff changeset
1489 type lookups.
kono
parents:
diff changeset
1490 (ambiguous_decl): Construct tree of ambiguous types. Remove extaneous
kono
parents:
diff changeset
1491 function parameter.
kono
parents:
diff changeset
1492 (unqualified_namespace_lookup): Fix ambiguous_decl call.
kono
parents:
diff changeset
1493 (lookup_using_namespace): Fix ambiguous_decl call.
kono
parents:
diff changeset
1494 (qualified_lookup_using_namespace): Fix ambiguous_decl call.
kono
parents:
diff changeset
1495
kono
parents:
diff changeset
1496 2007-08-10 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
kono
parents:
diff changeset
1497
kono
parents:
diff changeset
1498 * call.c (name_as_c_string): Use CONST_CAST.
kono
parents:
diff changeset
1499 * decl.c (build_decl): Likewise.
kono
parents:
diff changeset
1500 * parser.c (cp_parser_string_literal): Likewise.
kono
parents:
diff changeset
1501
kono
parents:
diff changeset
1502 2007-08-10 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1503
kono
parents:
diff changeset
1504 PR c++/17763
kono
parents:
diff changeset
1505 * error.c (dump_expr): Consistently use the *_cxx_*
kono
parents:
diff changeset
1506 variants of the pretty-print functions.
kono
parents:
diff changeset
1507
kono
parents:
diff changeset
1508 2007-08-10 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1509
kono
parents:
diff changeset
1510 PR c++/22256
kono
parents:
diff changeset
1511 * decl.c (check_special_function_return_type): Just error
kono
parents:
diff changeset
1512 on return type specified for conversion operator.
kono
parents:
diff changeset
1513
kono
parents:
diff changeset
1514 2007-08-09 Daniel Berlin <dberlin@dberlin.org>
kono
parents:
diff changeset
1515
kono
parents:
diff changeset
1516 * typeck2.c (readonly_error): Handle general expressions.
kono
parents:
diff changeset
1517 * error.c (dump_expr): Handle POINTER_PLUS_EXPR
kono
parents:
diff changeset
1518
kono
parents:
diff changeset
1519 2007-08-06 Dan Hipschman <dsh@google.com>
kono
parents:
diff changeset
1520
kono
parents:
diff changeset
1521 * method.c (use_thunk): Use DECL_NAME instead of DECL_RTL to
kono
parents:
diff changeset
1522 access function name.
kono
parents:
diff changeset
1523
kono
parents:
diff changeset
1524 2007-08-04 Alfred Minarik <a.minarik@aon.at>
kono
parents:
diff changeset
1525
kono
parents:
diff changeset
1526 PR pch/13676
kono
parents:
diff changeset
1527 * lang-specs.h: Add .hp, .hxx, .hpp, .h, .HPP, .tcc as c++ header.
kono
parents:
diff changeset
1528 * g++spec.c (lang_specific_driver): Check them.
kono
parents:
diff changeset
1529
kono
parents:
diff changeset
1530 2007-08-06 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1531
kono
parents:
diff changeset
1532 PR c++/19532
kono
parents:
diff changeset
1533 * pt.c (inline_needs_template_parms): Fix comment; change return type
kono
parents:
diff changeset
1534 to bool.
kono
parents:
diff changeset
1535
kono
parents:
diff changeset
1536 2007-08-05 Volker Reichelt <v.reichelt@netcologne.de>
kono
parents:
diff changeset
1537
kono
parents:
diff changeset
1538 Revert:
kono
parents:
diff changeset
1539 2007-03-26 Dirk Mueller <dmueller@suse.de>
kono
parents:
diff changeset
1540
kono
parents:
diff changeset
1541 * parser.c (cp_parser_member_declaration): Pedwarn
kono
parents:
diff changeset
1542 about stray semicolons after member declarations.
kono
parents:
diff changeset
1543
kono
parents:
diff changeset
1544 2007-08-02 Lee Millward <lee.millward@gmail.com>
kono
parents:
diff changeset
1545
kono
parents:
diff changeset
1546 PR c++/30849
kono
parents:
diff changeset
1547 PR c++/30850
kono
parents:
diff changeset
1548 PR c++/30851
kono
parents:
diff changeset
1549 * parser.c (cp_parser_asm_definition): Detect and discard asm
kono
parents:
diff changeset
1550 statements with invalid inputs or outputs.
kono
parents:
diff changeset
1551 (cp_parser_asm_operand_list): Return error mark node if any
kono
parents:
diff changeset
1552 of the operands are invalid. Adjust documentation.
kono
parents:
diff changeset
1553
kono
parents:
diff changeset
1554 2007-08-02 Nick Clifton <nickc@redhat.com>
kono
parents:
diff changeset
1555
kono
parents:
diff changeset
1556 * typeck.c: Change copyright header to refer to version 3 of the
kono
parents:
diff changeset
1557 GNU General Public License and to point readers at the COPYING3
kono
parents:
diff changeset
1558 file and the FSF's license web page.
kono
parents:
diff changeset
1559 * optimize.c, lang-specs.h, init.c, class.c, repo.c, decl.c,
kono
parents:
diff changeset
1560 config-lang.in, cp-tree.def, call.c, decl.h, ptree.c,
kono
parents:
diff changeset
1561 Make-lang.in, method.c, rtti.c, cp-objcp-common.c, g++spec.c,
kono
parents:
diff changeset
1562 cp-objcp-common.h, except.c, error.c, operators.def, cvt.c,
kono
parents:
diff changeset
1563 tree.c, mangle.c, cp-tree.h, dump.c, search.c, friend.c, expr.c,
kono
parents:
diff changeset
1564 cp-gimplify.c, cxx-pretty-print.c, cp-lang.c, typeck2.c, pt.c,
kono
parents:
diff changeset
1565 cxx-pretty-print.h, semantics.c, name-lookup.c, lex.c, decl2.c,
kono
parents:
diff changeset
1566 name-lookup.h, parser.c: Likewise.
kono
parents:
diff changeset
1567
kono
parents:
diff changeset
1568 2007-08-01 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
kono
parents:
diff changeset
1569
kono
parents:
diff changeset
1570 PR middle-end/32668
kono
parents:
diff changeset
1571 * call.c (magic_varargs_p): Honor the "type generic" attribute.
kono
parents:
diff changeset
1572
kono
parents:
diff changeset
1573 2007-07-30 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1574
kono
parents:
diff changeset
1575 PR c++/32108
kono
parents:
diff changeset
1576 * semantics.c (finish_label_stmt): Reject the __label__
kono
parents:
diff changeset
1577 extension outside function scopes.
kono
parents:
diff changeset
1578
kono
parents:
diff changeset
1579 2007-07-29 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
kono
parents:
diff changeset
1580
kono
parents:
diff changeset
1581 * parser.c (eof_token): Un-constify.
kono
parents:
diff changeset
1582 (cp_lexer_new_main, cp_lexer_new_from_tokens, VEC_alloc,
kono
parents:
diff changeset
1583 cp_lexer_consume_token, cp_lexer_purge_token): Remove spurious
kono
parents:
diff changeset
1584 casts.
kono
parents:
diff changeset
1585
kono
parents:
diff changeset
1586 2007-07-28 Kazu Hirata <kazu@codesourcery.com>
kono
parents:
diff changeset
1587
kono
parents:
diff changeset
1588 * pt.c, tree.c, typeck2.c: Fix comment typos.
kono
parents:
diff changeset
1589
kono
parents:
diff changeset
1590 2007-07-28 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
1591 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
1592
kono
parents:
diff changeset
1593 PR c++/30917
kono
parents:
diff changeset
1594 * name-lookup.c (lookup_name_real): Non namespace-scope bindings can be
kono
parents:
diff changeset
1595 hidden due to friend declarations in local classes.
kono
parents:
diff changeset
1596
kono
parents:
diff changeset
1597 2007-07-27 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
1598
kono
parents:
diff changeset
1599 * typeck.c (structural_comptypes): Compare DECLTYPE_TYPE nodes.
kono
parents:
diff changeset
1600 * cp-tree.def (DECLTYPE_TYPE): New.
kono
parents:
diff changeset
1601 * error.c (dump_type): Dump DECLTYPE_TYPE nodes.
kono
parents:
diff changeset
1602 (dump_type_prefix): Ditto.
kono
parents:
diff changeset
1603 (dump_type_suffix): Ditto.
kono
parents:
diff changeset
1604 * tree.c (DECLTYPE_TYPE): Walk DECLTYPE_TYPE nodes.
kono
parents:
diff changeset
1605 * mangle.c (write_type): Handle DECLTYPE_TYPE.
kono
parents:
diff changeset
1606 * cp-tree.h (IS_AGGR_TYPE): DECLTYPE_TYPE nodes can be aggregate
kono
parents:
diff changeset
1607 types.
kono
parents:
diff changeset
1608 (DECLTYPE_TYPE_EXPR): New.
kono
parents:
diff changeset
1609 (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P): New.
kono
parents:
diff changeset
1610 (finish_declared_type): Declare.
kono
parents:
diff changeset
1611 * cxx-pretty-print.c (pp_cxx_type_specifier_seq): Print
kono
parents:
diff changeset
1612 DECLTYPE_TYPE nodes.
kono
parents:
diff changeset
1613 (pp_cxx_type_id): Ditto.
kono
parents:
diff changeset
1614 * pt.c (for_each_template_parm_r): Walk DECLTYPE_TYPE children.
kono
parents:
diff changeset
1615 (tsubst): Substitute into a DECLTYPE_TYPE node.
kono
parents:
diff changeset
1616 (tsubst_copy): Ditto.
kono
parents:
diff changeset
1617 (unify): Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
kono
parents:
diff changeset
1618 nodes.
kono
parents:
diff changeset
1619 (dependent_type_p_r): DECLTYPE_TYPE types are always dependent.
kono
parents:
diff changeset
1620 * semantics.c (finish_typeof): TYPEOF_TYPE types need to use
kono
parents:
diff changeset
1621 structural equality (because we can't hash the expressions).
kono
parents:
diff changeset
1622 (finish_declared_type): New.
kono
parents:
diff changeset
1623 * lex.c (reswords): Add "decltype" keyword.
kono
parents:
diff changeset
1624 * parser.c cp_lexer_next_token_is_decl_specifier_keyword
kono
parents:
diff changeset
1625 (cp_parser_postfix_expression): Add member_access_only_p to
kono
parents:
diff changeset
1626 restrict postfix expression to member access expressions.
kono
parents:
diff changeset
1627 (cp_parser_unary_expression): Update call to
kono
parents:
diff changeset
1628 cp_parser_postfix_expression to reflect new parameter.
kono
parents:
diff changeset
1629 (cp_parser_declared_type): New.
kono
parents:
diff changeset
1630 (cp_parser_simple_type_specifier): Parse decltype types.
kono
parents:
diff changeset
1631
kono
parents:
diff changeset
1632 2007-07-27 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
1633
kono
parents:
diff changeset
1634 PR c++/32346
kono
parents:
diff changeset
1635 * call.c (convert_for_arg_passing): Only widen bitfields to their
kono
parents:
diff changeset
1636 declared types if necessary.
kono
parents:
diff changeset
1637
kono
parents:
diff changeset
1638 2007-07-25 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
kono
parents:
diff changeset
1639
kono
parents:
diff changeset
1640 * parser.c (cp_parser_string_literal, cp_parser_sizeof_operand):
kono
parents:
diff changeset
1641 Constify.
kono
parents:
diff changeset
1642
kono
parents:
diff changeset
1643 2007-07-25 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
kono
parents:
diff changeset
1644
kono
parents:
diff changeset
1645 * decl.c (typename_hash, typename_compare): Constify.
kono
parents:
diff changeset
1646 * mangle.c (hash_type, compare_type): Likewise.
kono
parents:
diff changeset
1647 * pt.c (eq_local_specializations, hash_local_specialization):
kono
parents:
diff changeset
1648 Likewise.
kono
parents:
diff changeset
1649 * tree.c (cplus_array_hash, cplus_array_compare, list_hash_eq,
kono
parents:
diff changeset
1650 list_hash): Likewise.
kono
parents:
diff changeset
1651 * typeck2.c (pat_compare): Likewise.
kono
parents:
diff changeset
1652
kono
parents:
diff changeset
1653 2007-07-24 Nathan Sidwell <nathan@codesourcery.com>
kono
parents:
diff changeset
1654
kono
parents:
diff changeset
1655 * method.c (implicitly_declare_fn): Increase alignment if member
kono
parents:
diff changeset
1656 function pointer format requires it.
kono
parents:
diff changeset
1657
kono
parents:
diff changeset
1658 2007-07-24 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1659
kono
parents:
diff changeset
1660 PR c++/29001
kono
parents:
diff changeset
1661 * typeck.c (check_return_expr): Do not pass a null argument
kono
parents:
diff changeset
1662 to null_ptr_cst_p.
kono
parents:
diff changeset
1663
kono
parents:
diff changeset
1664 2007-07-24 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1665
kono
parents:
diff changeset
1666 PR c++/32561
kono
parents:
diff changeset
1667 * decl.c (redeclaration_error_message): Call DECL_ANON_UNION_VAR_P
kono
parents:
diff changeset
1668 only on VAR_DECL.
kono
parents:
diff changeset
1669
kono
parents:
diff changeset
1670 2007-07-22 Nathan Sidwell <nathan@codesourcery.com>
kono
parents:
diff changeset
1671
kono
parents:
diff changeset
1672 PR c++/32839
kono
parents:
diff changeset
1673 * typeck.c (convert_arguments): Only use default args if we have
kono
parents:
diff changeset
1674 a function decl.
kono
parents:
diff changeset
1675
kono
parents:
diff changeset
1676 PR c++/30818
kono
parents:
diff changeset
1677 * typeck.c (structural_comptypes): No need to check
kono
parents:
diff changeset
1678 resolve_typename_type return value here.
kono
parents:
diff changeset
1679 * cp-tree.h (TYPENAME_IS_RESOLVING_P): New.
kono
parents:
diff changeset
1680 * pt.c (resolve_typename_type): Follow typename typedefs. Return
kono
parents:
diff changeset
1681 original type rather than error_mark_node in case of failure.
kono
parents:
diff changeset
1682 * parser.c (cp_parser_nested_name_specifier_opt): Adjust
kono
parents:
diff changeset
1683 resolve_typename_type result check.
kono
parents:
diff changeset
1684 (cp_parser_direct_declarator, cp_parser_head,
kono
parents:
diff changeset
1685 cp_parser_constructor_declarator_p): Likewise.
kono
parents:
diff changeset
1686
kono
parents:
diff changeset
1687 2007-07-12 Kazu Hirata <kazu@codesourcery.com>
kono
parents:
diff changeset
1688
kono
parents:
diff changeset
1689 * pt.c (template_parms_variadic_p): Remove.
kono
parents:
diff changeset
1690 * cp-tree.h: Remove the prototype for template_parms_variadic_p.
kono
parents:
diff changeset
1691
kono
parents:
diff changeset
1692 2007-07-12 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1693
kono
parents:
diff changeset
1694 PR c++/30854
kono
parents:
diff changeset
1695 * error.c (dump_expr) <case AGGR_INIT_EXPR>: Pass true as last
kono
parents:
diff changeset
1696 argument to dump_aggr_init_expr_args instead of false.
kono
parents:
diff changeset
1697
kono
parents:
diff changeset
1698 2007-07-11 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
1699
kono
parents:
diff changeset
1700 * typeck.c (comptypes): When USE_CANONICAL_TYPES, use the
kono
parents:
diff changeset
1701 canonical types; otherwise, fall back to structural type
kono
parents:
diff changeset
1702 comparisons. If ENABLE_CHECKING and USE_CANONICAL_TYPES, give an
kono
parents:
diff changeset
1703 internal compiler error if the canonical types are wrong.
kono
parents:
diff changeset
1704
kono
parents:
diff changeset
1705 2007-07-11 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1706
kono
parents:
diff changeset
1707 PR c++/32560
kono
parents:
diff changeset
1708 * parser.c (cp_parser_make_indirect_declarator): When the
kono
parents:
diff changeset
1709 the code argument is ERROR_MARK return cp_error_declarator.
kono
parents:
diff changeset
1710
kono
parents:
diff changeset
1711 2007-07-09 Geoffrey Keating <geoffk@apple.com>
kono
parents:
diff changeset
1712
kono
parents:
diff changeset
1713 PR 32617
kono
parents:
diff changeset
1714 * decl.c (cxx_init_decl_processing): Don't set
kono
parents:
diff changeset
1715 force_align_functions_log.
kono
parents:
diff changeset
1716 (grokfndecl): Honour ptrmemfunc_vbit_in_pfn.
kono
parents:
diff changeset
1717 * typeck.c (cxx_alignof_expr): When alignof is used on a plain
kono
parents:
diff changeset
1718 FUNCTION_DECL, return its alignment.
kono
parents:
diff changeset
1719
kono
parents:
diff changeset
1720 2007-07-09 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1721
kono
parents:
diff changeset
1722 * decl.c (start_preparsed_function): Do not promote return type.
kono
parents:
diff changeset
1723
kono
parents:
diff changeset
1724 2007-07-08 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1725
kono
parents:
diff changeset
1726 PR c++/30535
kono
parents:
diff changeset
1727 * pt.c (unify): Never pass error_mark_node to template_decl_level.
kono
parents:
diff changeset
1728
kono
parents:
diff changeset
1729 2007-07-07 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
1730
kono
parents:
diff changeset
1731 PR c++/32232
kono
parents:
diff changeset
1732 * pt.c (resolve_overloaded_unification): Robustify. Return a
kono
parents:
diff changeset
1733 bool, not an int.
kono
parents:
diff changeset
1734 (type_unification_real): Adjust accordingly.
kono
parents:
diff changeset
1735
kono
parents:
diff changeset
1736 2007-07-06 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1737
kono
parents:
diff changeset
1738 * init.c (build_new_1): Use the correct pointer type.
kono
parents:
diff changeset
1739 * typeck2.c (build_m_component_ref): Likewise.
kono
parents:
diff changeset
1740
kono
parents:
diff changeset
1741 2007-07-05 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
1742
kono
parents:
diff changeset
1743 PR c++/32245
kono
parents:
diff changeset
1744 * init.c (build_zero_init): Always build an initializer for
kono
parents:
diff changeset
1745 non-static storage.
kono
parents:
diff changeset
1746 * typeck2.c (build_functional_cast): Use build_zero_init.
kono
parents:
diff changeset
1747
kono
parents:
diff changeset
1748 PR c++/32251
kono
parents:
diff changeset
1749 * init.c (build_new_1): Always pass the allocation function to
kono
parents:
diff changeset
1750 build_op_delete_call.
kono
parents:
diff changeset
1751 * call.c (build_op_delete_call): Handle operator delete with a
kono
parents:
diff changeset
1752 variable-argument list. Do not issue an error when no matching
kono
parents:
diff changeset
1753 deallocation function is available for a new operator.
kono
parents:
diff changeset
1754
kono
parents:
diff changeset
1755 PR c++/31992
kono
parents:
diff changeset
1756 * cp-tree.h (any_value_dependent_elements_p): Declare it.
kono
parents:
diff changeset
1757 * decl.c (value_dependent_init_p): New function.
kono
parents:
diff changeset
1758 (cp_finish_decl): Use it.
kono
parents:
diff changeset
1759 * pt.c (value_dependent_expression_p): Use
kono
parents:
diff changeset
1760 any_value_dependent_elements_p.
kono
parents:
diff changeset
1761 * parser.c (cp_parser_primary_expression): Add comment about
kono
parents:
diff changeset
1762 treating dependent qualified names as integral
kono
parents:
diff changeset
1763 constant-expressions.
kono
parents:
diff changeset
1764
kono
parents:
diff changeset
1765 2007-07-04 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
1766
kono
parents:
diff changeset
1767 * decl.c (build_ptrmemfunc_type): Always use structural equality
kono
parents:
diff changeset
1768 tests when comparing pointer-to-member-function types, because the
kono
parents:
diff changeset
1769 handling of TYPE_GET_PTRMEMFUNC_TYPE currently defeats canonical
kono
parents:
diff changeset
1770 types.
kono
parents:
diff changeset
1771
kono
parents:
diff changeset
1772 2007-07-03 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
1773
kono
parents:
diff changeset
1774 * init.c (build_new): Tweak comment.
kono
parents:
diff changeset
1775
kono
parents:
diff changeset
1776 2007-06-29 Dave Brolley <brolley@redhat.com>
kono
parents:
diff changeset
1777
kono
parents:
diff changeset
1778 PR c++/31743
kono
parents:
diff changeset
1779 * parser.c (cp_parser_new_type_id): Don't reduce a named array
kono
parents:
diff changeset
1780 type to its base type and number of elements here.
kono
parents:
diff changeset
1781 * init.c (build_new): Call complete_type_or_else to ensure that the
kono
parents:
diff changeset
1782 type is complete and to issue a diagnostic if it is not.
kono
parents:
diff changeset
1783 (build_new_1): Don't call complete_type_or_else here.
kono
parents:
diff changeset
1784
kono
parents:
diff changeset
1785 2007-07-03 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1786
kono
parents:
diff changeset
1787 PR c++/32609
kono
parents:
diff changeset
1788 * class.c (fixed_type_or_null): Re-lookup the hashtable slot
kono
parents:
diff changeset
1789 after recursing.
kono
parents:
diff changeset
1790
kono
parents:
diff changeset
1791 2007-07-02 Simon Baldwin <simonb@google.com>
kono
parents:
diff changeset
1792
kono
parents:
diff changeset
1793 * parser.c (cp_parser_elaborated_type_specifier): Added a warning
kono
parents:
diff changeset
1794 for inner-style nested forward declarations that don't declare
kono
parents:
diff changeset
1795 anything useful.
kono
parents:
diff changeset
1796
kono
parents:
diff changeset
1797 2007-07-02 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1798
kono
parents:
diff changeset
1799 PR c++/31748
kono
parents:
diff changeset
1800 * semantics.c (finish_omp_clauses): Use %qD instead of %qE for
kono
parents:
diff changeset
1801 DECL_P in not a variable and appears more than once error messages.
kono
parents:
diff changeset
1802
kono
parents:
diff changeset
1803 2007-07-01 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
1804
kono
parents:
diff changeset
1805 * name-lookup.c (ambiguous_decl): Fix case when new->value is hidden.
kono
parents:
diff changeset
1806 (select_decl): Remove function.
kono
parents:
diff changeset
1807 (unqualified_namespace_lookup): Populate binding by calling
kono
parents:
diff changeset
1808 ambiguous_decl. Remove select_decl call.
kono
parents:
diff changeset
1809 (lookup_qualified_name): Remove select_decl call.
kono
parents:
diff changeset
1810 * decl.c (lookup_and_check_tag): Check for ambiguous references.
kono
parents:
diff changeset
1811 * parser.c (cp_parser_elaborated_type_specifier): Skip redundant error
kono
parents:
diff changeset
1812 generation when name lookup is ambiguous.
kono
parents:
diff changeset
1813
kono
parents:
diff changeset
1814 2007-06-29 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
1815
kono
parents:
diff changeset
1816 PR c++/31724
kono
parents:
diff changeset
1817 * init.c (build_new_1): Use structural equality on the copy of the
kono
parents:
diff changeset
1818 array type.
kono
parents:
diff changeset
1819
kono
parents:
diff changeset
1820 2007-06-28 Geoffrey Keating <geoffk@apple.com>
kono
parents:
diff changeset
1821
kono
parents:
diff changeset
1822 * decl2.c (determine_visibility): Implement
kono
parents:
diff changeset
1823 flag_visibility_ms_compat effect on type info.
kono
parents:
diff changeset
1824 * decl.c (cxx_init_decl_processing): Implement
kono
parents:
diff changeset
1825 global effect of flag_visibility_ms_compat.
kono
parents:
diff changeset
1826
kono
parents:
diff changeset
1827 2007-06-28 Geoffrey Keating <geoffk@apple.com>
kono
parents:
diff changeset
1828
kono
parents:
diff changeset
1829 * decl2.c (start_objects): Mark constructor-running function
kono
parents:
diff changeset
1830 as artificial.
kono
parents:
diff changeset
1831
kono
parents:
diff changeset
1832 2007-06-26 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
1833
kono
parents:
diff changeset
1834 PR c++/32111
kono
parents:
diff changeset
1835 * decl.c (grokdeclarator): Reset friendp for member functions declared
kono
parents:
diff changeset
1836 friend of their own class.
kono
parents:
diff changeset
1837
kono
parents:
diff changeset
1838 2007-06-23 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
1839
kono
parents:
diff changeset
1840 * decl2.c (determine_visibility): Don't look for dllexport here.
kono
parents:
diff changeset
1841 (determine_visibility_from_class): Tidy.
kono
parents:
diff changeset
1842
kono
parents:
diff changeset
1843 2007-06-18 Simon Baldwin <simonb@google.com>
kono
parents:
diff changeset
1844
kono
parents:
diff changeset
1845 PR c++/31923
kono
parents:
diff changeset
1846 * parser.c (cp_parser_single_declaration): Added check for storage
kono
parents:
diff changeset
1847 class other than sc_none in parsed declaration, and a flag to indicate
kono
parents:
diff changeset
1848 if the call is part of an explicit template specialization parse.
kono
parents:
diff changeset
1849 * (cp_parser_explicit_specialization): Specialization check flag added
kono
parents:
diff changeset
1850 to call to cp_parser_single_declaration(), set true.
kono
parents:
diff changeset
1851 * (cp_parser_template_declaration_after_export): Specialization check
kono
parents:
diff changeset
1852 flag added to call to cp_parser_single_declaration(), set false.
kono
parents:
diff changeset
1853 * pt.c (check_explicit_specialization): Added code to copy visiblity
kono
parents:
diff changeset
1854 and linkage from the templated function to the explicit specialization.
kono
parents:
diff changeset
1855
kono
parents:
diff changeset
1856 2007-06-15 Andrew Pinski <andrew_pinski@playstation.sony.com>
kono
parents:
diff changeset
1857
kono
parents:
diff changeset
1858 * typeck.c (build_binary_op): For templates build the
kono
parents:
diff changeset
1859 expression in pieces to avoid the assert in build2_stat.
kono
parents:
diff changeset
1860 (get_member_function_from_ptrfunc):
kono
parents:
diff changeset
1861 Change over to using POINTER_PLUS_EXPR and convert
kono
parents:
diff changeset
1862 the second operand to sizetype.
kono
parents:
diff changeset
1863 * typeck2.c (build_m_component_ref): Likewise.
kono
parents:
diff changeset
1864 * init.c (expand_virtual_init): Create a POINTER_PLUS_EXPR
kono
parents:
diff changeset
1865 instead of PLUS_EXPR for pointers.
kono
parents:
diff changeset
1866 (build_new_1): Likewise.
kono
parents:
diff changeset
1867 (build_vec_delete_1): Likewise.
kono
parents:
diff changeset
1868 (build_vec_delete): Likewise.
kono
parents:
diff changeset
1869 * class.c (build_base_path): Likewise.
kono
parents:
diff changeset
1870 (build_base_path): Likewise.
kono
parents:
diff changeset
1871 (convert_to_base_statically): Likewise.
kono
parents:
diff changeset
1872 (fixed_type_or_null): Handle POINTER_PLUS_EXPR.
kono
parents:
diff changeset
1873 (get_vtbl_decl_for_binfo): Handle POINTER_PLUS_EXPR
kono
parents:
diff changeset
1874 instead of PLUS_EXPR.
kono
parents:
diff changeset
1875 (dfs_accumulate_vtbl_inits): Create a POINTER_PLUS_EXPR
kono
parents:
diff changeset
1876 instead of PLUS_EXPR for pointers.
kono
parents:
diff changeset
1877 * call.c (build_special_member_call): Likewise.
kono
parents:
diff changeset
1878 * rtti.c (build_headof): Likewise.
kono
parents:
diff changeset
1879 Use sizetype instead of ptrdiff_type_node.
kono
parents:
diff changeset
1880 (tinfo_base_init): Create a POINTER_PLUS_EXPR
kono
parents:
diff changeset
1881 instead of PLUS_EXPR for pointers.
kono
parents:
diff changeset
1882 * except.c (expand_start_catch_block): Do a
kono
parents:
diff changeset
1883 NEGATIVE and then a POINTER_PLUS_EXPR instead
kono
parents:
diff changeset
1884 of a MINUS_EXPR.
kono
parents:
diff changeset
1885 * cp-gimplify.c (cxx_omp_clause_apply_fn): Convert
kono
parents:
diff changeset
1886 PLUS_EXPR on pointer types over to use
kono
parents:
diff changeset
1887 POINTER_PLUS_EXPR and remove the conversion
kono
parents:
diff changeset
1888 to the pointer types.
kono
parents:
diff changeset
1889 * method.c (thunk_adjust): Use POINTER_PLUS_EXPR for
kono
parents:
diff changeset
1890 adding to a pointer type. Use size_int instead of
kono
parents:
diff changeset
1891 ssize_int. Convert the index to sizetype before
kono
parents:
diff changeset
1892 adding it to the pointer.
kono
parents:
diff changeset
1893
kono
parents:
diff changeset
1894 2007-06-15 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
1895
kono
parents:
diff changeset
1896 * cp-tree.h (DECL_VAR_MARKED_P): Remove.
kono
parents:
diff changeset
1897 (DECL_ANON_UNION_VAR_P): New macro.
kono
parents:
diff changeset
1898 * class.c (fixed_type_or_null): Tidy. Use a hash table, rather
kono
parents:
diff changeset
1899 than DECL_VAR_MARKED_P, to keep track of which variables we have
kono
parents:
diff changeset
1900 seen.
kono
parents:
diff changeset
1901 * decl.c (redeclaration_error_message): Complain about redeclaring
kono
parents:
diff changeset
1902 anonymous union members at namespace scope.
kono
parents:
diff changeset
1903 * decl2.c (build_anon_union_vars): Set DECL_ANON_UNION_VAR_P.
kono
parents:
diff changeset
1904
kono
parents:
diff changeset
1905 2007-06-14 Geoff Keating <geoffk@apple.com>
kono
parents:
diff changeset
1906
kono
parents:
diff changeset
1907 * decl2.c (determine_visibility): Ensure that functions with
kono
parents:
diff changeset
1908 hidden types as parameters are hidden.
kono
parents:
diff changeset
1909
kono
parents:
diff changeset
1910 PR 31093
kono
parents:
diff changeset
1911 * decl2.c (determine_visibility): Remove duplicate code for
kono
parents:
diff changeset
1912 handling type info.
kono
parents:
diff changeset
1913
kono
parents:
diff changeset
1914 2007-06-12 Ian Lance Taylor <iant@google.com>
kono
parents:
diff changeset
1915
kono
parents:
diff changeset
1916 PR libstdc++/29286
kono
parents:
diff changeset
1917 * init.c (avoid_placement_new_aliasing): New static function.
kono
parents:
diff changeset
1918 (build_new_1): Call it.
kono
parents:
diff changeset
1919
kono
parents:
diff changeset
1920 2007-06-11 Rafael Ávila de Espíndola <espindola@google.com>
kono
parents:
diff changeset
1921
kono
parents:
diff changeset
1922 * cp-objcp-common.h (LANG_HOOKS_SIGNED_TYPE): Remove.
kono
parents:
diff changeset
1923 (LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE): Remove.
kono
parents:
diff changeset
1924
kono
parents:
diff changeset
1925 2007-06-08 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1926
kono
parents:
diff changeset
1927 PR c++/32177
kono
parents:
diff changeset
1928 * semantics.c (finish_omp_for): Call fold_build_cleanup_point_expr
kono
parents:
diff changeset
1929 on init, the non-decl cond operand and increment value.
kono
parents:
diff changeset
1930
kono
parents:
diff changeset
1931 2007-06-07 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
1932
kono
parents:
diff changeset
1933 PR c++/30759
kono
parents:
diff changeset
1934 * decl.c (check_initializer): Report an error when a brace enclosed
kono
parents:
diff changeset
1935 initializer is used for a non-aggregate type in C++98.
kono
parents:
diff changeset
1936 (redeclaration_error_message): Rewrote flag_cpp0x in terms of
kono
parents:
diff changeset
1937 cxx_dialect.
kono
parents:
diff changeset
1938 (grokdeclarator): Likewise.
kono
parents:
diff changeset
1939 (move_fn_p): Likewise.
kono
parents:
diff changeset
1940 * typeck.c (check_return_expr): Likewise.
kono
parents:
diff changeset
1941 * call.c (reference_binding): Likewise.
kono
parents:
diff changeset
1942 * error.c (cp_cpp_error): Likewise.
kono
parents:
diff changeset
1943 * pt.c (check_default_tmpl_args): Likewise.
kono
parents:
diff changeset
1944 (tsubst): Likewise.
kono
parents:
diff changeset
1945 * lex.c (init_reswords): Likewise.
kono
parents:
diff changeset
1946 * parser.c (p_parser_primary_expression): Likewise.
kono
parents:
diff changeset
1947 (TOKEN_PRECEDENCE): Likewise.
kono
parents:
diff changeset
1948 (cp_parser_init_declarator): Likewise.
kono
parents:
diff changeset
1949 (cp_parser_ptr_operator): Likewise.
kono
parents:
diff changeset
1950 (cp_parser_parameter_declaration): Likewise.
kono
parents:
diff changeset
1951 (cp_parser_enclosed_template_argument_list): Likewise.
kono
parents:
diff changeset
1952 (cp_parser_skip_to_end_of_template_parameter_list): Likewise.
kono
parents:
diff changeset
1953 (cp_parser_next_token_ends_template_argument_p): Likewise.
kono
parents:
diff changeset
1954
kono
parents:
diff changeset
1955 2007-06-04 Simon Baldwin <simonb@google.com>
kono
parents:
diff changeset
1956
kono
parents:
diff changeset
1957 * decl.c (grokdeclarator): Readability change. Moved case labels
kono
parents:
diff changeset
1958 into direct switch statement scope.
kono
parents:
diff changeset
1959
kono
parents:
diff changeset
1960 2007-06-04 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1961
kono
parents:
diff changeset
1962 * call.c (convert_like_real): Remove pointless code.
kono
parents:
diff changeset
1963
kono
parents:
diff changeset
1964 2007-05-31 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
1965
kono
parents:
diff changeset
1966 * decl.c (get_atexit_fn_ptr_type): New function.
kono
parents:
diff changeset
1967 (get_atexit_node): Use it.
kono
parents:
diff changeset
1968 (start_cleanup_fn): Likewise.
kono
parents:
diff changeset
1969 (register_dtor_fn): Use the object's destructor, instead of a
kono
parents:
diff changeset
1970 separate cleanup function, where possible.
kono
parents:
diff changeset
1971 * cp-tree.h (CPTI_ATEXIT_FN_PTR_TYPE): New enumerator.
kono
parents:
diff changeset
1972 (atexit_fn_ptr_type_node): New macro.
kono
parents:
diff changeset
1973 * decl2.c (build_cleanup): Use build_address.
kono
parents:
diff changeset
1974
kono
parents:
diff changeset
1975 2007-05-31 Daniel Berlin <dberlin@dberlin.org>
kono
parents:
diff changeset
1976
kono
parents:
diff changeset
1977 * typeck.c (build_binary_op): Include types in error.
kono
parents:
diff changeset
1978
kono
parents:
diff changeset
1979 2007-05-31 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1980
kono
parents:
diff changeset
1981 PR c++/31806
kono
parents:
diff changeset
1982 * decl.c (cp_finish_decl): Also clear was_readonly if a static var
kono
parents:
diff changeset
1983 needs runtime initialization.
kono
parents:
diff changeset
1984
kono
parents:
diff changeset
1985 2007-05-31 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
1986
kono
parents:
diff changeset
1987 PR c++/32158
kono
parents:
diff changeset
1988 * semantics.c (finish_trait_expr): Complete the types.
kono
parents:
diff changeset
1989
kono
parents:
diff changeset
1990 2007-05-30 Russell Yanofsky <russ@yanofsky.org>
kono
parents:
diff changeset
1991 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
1992 Pedro Lamarao <pedro.lamarao@mndfck.org>
kono
parents:
diff changeset
1993 Howard Hinnant <howard.hinnant@gmail.com>
kono
parents:
diff changeset
1994
kono
parents:
diff changeset
1995 PR c++/7412
kono
parents:
diff changeset
1996 PR c++/29939
kono
parents:
diff changeset
1997 * typeck.c (comptypes): Don't consider rvalue and lvalue
kono
parents:
diff changeset
1998 reference types to be equivalent.
kono
parents:
diff changeset
1999 (check_return_expr): Move from certain lvalues when returning
kono
parents:
diff changeset
2000 them.
kono
parents:
diff changeset
2001 * decl.c (grokdeclarator): Implement reference collapsing.
kono
parents:
diff changeset
2002 (copy_fn_p): Don't consider constructors taking rvalue references
kono
parents:
diff changeset
2003 to be copy constructors.
kono
parents:
diff changeset
2004 (move_fn_p): New.
kono
parents:
diff changeset
2005 * call.c (conversion): New "rvaluedness_matches_p" member.
kono
parents:
diff changeset
2006 (convert_class_to_reference): Require reference type as first
kono
parents:
diff changeset
2007 parameter instead of base type.
kono
parents:
diff changeset
2008 (reference_binding): Add logic to handle rvalue references.
kono
parents:
diff changeset
2009 (implicit_conversion): Update inaccurate comment.
kono
parents:
diff changeset
2010 (convert_like_real): Disable creation of temporaries that are
kono
parents:
diff changeset
2011 impossible to initialize for types with move constructors.
kono
parents:
diff changeset
2012 (build_over_call): Elide move constructors when possible.
kono
parents:
diff changeset
2013 (maybe_handle_implicit_object): Set "rvaluedness_matches_p".
kono
parents:
diff changeset
2014 (maybe_handle_ref_bind): Return conversion instead of type node.
kono
parents:
diff changeset
2015 (compare_ics): Add logic to use "rvaluedness_matches_p" values to
kono
parents:
diff changeset
2016 determine preferred conversion sequences.
kono
parents:
diff changeset
2017 * cp-tree.h (TYPE_REF_IS_RVALUE): New.
kono
parents:
diff changeset
2018 (LOOKUP_PREFER_RVALUE): New.
kono
parents:
diff changeset
2019 (DECL_MOVE_CONSTRUCTOR_P): New.
kono
parents:
diff changeset
2020 (struct cp_declarator): Add "reference" member for reference
kono
parents:
diff changeset
2021 types, with new "rvalue_ref" flag.
kono
parents:
diff changeset
2022 (cp_build_reference_type): Declare.
kono
parents:
diff changeset
2023 (move_fn_p): Declare.
kono
parents:
diff changeset
2024 * error.c (dump_type_prefix): Format rvalue reference types
kono
parents:
diff changeset
2025 correctly in error messages.
kono
parents:
diff changeset
2026 * except.c (build_throw): Move from certain lvalues when
kono
parents:
diff changeset
2027 throwing.
kono
parents:
diff changeset
2028 * mangle.c (write_type): Mangle rvalue references differently
kono
parents:
diff changeset
2029 than regular references.
kono
parents:
diff changeset
2030 * parser.c (make_reference_declarator): Add boolean parameter for
kono
parents:
diff changeset
2031 rvalue references.
kono
parents:
diff changeset
2032 (cp_parser_make_indirect_declarator): New.
kono
parents:
diff changeset
2033 (cp_parser_new_declarator_opt): Call
kono
parents:
diff changeset
2034 cp_parser_make_indirect_declarator.
kono
parents:
diff changeset
2035 (cp_parser_conversion_declarator_opt): Ditto.
kono
parents:
diff changeset
2036 (cp_parser_declarator): Ditto.
kono
parents:
diff changeset
2037 (cp_parser_ptr_operator): Parse "&&" tokens into rvalue reference
kono
parents:
diff changeset
2038 declarators.
kono
parents:
diff changeset
2039 * pt.c (tsubst): Implement reference collapsing.
kono
parents:
diff changeset
2040 (maybe_adjust_types_for_deduction): Implement special template
kono
parents:
diff changeset
2041 parameter deduction rule for rvalue references.
kono
parents:
diff changeset
2042 (type_unification_real): Update calls to
kono
parents:
diff changeset
2043 maybe_adjust_types_for_deduction.
kono
parents:
diff changeset
2044 (try_one_overload): Ditto.
kono
parents:
diff changeset
2045 (unify_pack_expansion): Ditto.
kono
parents:
diff changeset
2046 * tree.c (lvalue_p_1): Handle rvalue reference types.
kono
parents:
diff changeset
2047 (cp_build_reference_type): New.
kono
parents:
diff changeset
2048
kono
parents:
diff changeset
2049 2007-05-30 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2050
kono
parents:
diff changeset
2051 PR c++/31809
kono
parents:
diff changeset
2052 * decl.c (cp_finish_decl): Clear TREE_READONLY flag on TREE_STATIC
kono
parents:
diff changeset
2053 variables that need runtime initialization.
kono
parents:
diff changeset
2054
kono
parents:
diff changeset
2055 2007-05-28 Andrew Pinski <Andrew_pinski@playstation.sony.com>
kono
parents:
diff changeset
2056
kono
parents:
diff changeset
2057 PR c++/31339
kono
parents:
diff changeset
2058 * typeck.c (build_unary_op <case PREINCREMENT_EXPR,
kono
parents:
diff changeset
2059 case POSTINCREMENT_EXPR, case PREDECREMENT_EXPR,
kono
parents:
diff changeset
2060 case POSTDECREMENT_EXPR>): Return the error_mark_node
kono
parents:
diff changeset
2061 if either the real or imaginary parts would an
kono
parents:
diff changeset
2062 error_mark_node.
kono
parents:
diff changeset
2063
kono
parents:
diff changeset
2064 2007-05-25 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
2065 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2066
kono
parents:
diff changeset
2067 PR c++/31745
kono
parents:
diff changeset
2068 * parser.c (cp_parser_skip_to_closing_brace): Return true if the next
kono
parents:
diff changeset
2069 token is a closing brace, false if there are no tokens left.
kono
parents:
diff changeset
2070 (cp_parser_namespace_alias_definition): Only consume the next token if
kono
parents:
diff changeset
2071 it is a closing brace.
kono
parents:
diff changeset
2072
kono
parents:
diff changeset
2073 * parser.c (cp_parser_class_specifier): Likewise.
kono
parents:
diff changeset
2074
kono
parents:
diff changeset
2075 2007-05-25 H.J. Lu <hongjiu.lu@intel.com>
kono
parents:
diff changeset
2076
kono
parents:
diff changeset
2077 * semantics.c (finish_member_declaration): Fix a typo in the
kono
parents:
diff changeset
2078 last checkin.
kono
parents:
diff changeset
2079
kono
parents:
diff changeset
2080 2007-05-25 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
2081
kono
parents:
diff changeset
2082 PR c++/31431
kono
parents:
diff changeset
2083 PR c++/31432
kono
parents:
diff changeset
2084 PR c++/31434
kono
parents:
diff changeset
2085 PR c++/31435
kono
parents:
diff changeset
2086 PR c++/31437
kono
parents:
diff changeset
2087 PR c++/31438
kono
parents:
diff changeset
2088 PR c++/31442
kono
parents:
diff changeset
2089 PR c++/31443
kono
parents:
diff changeset
2090 PR c++/31444
kono
parents:
diff changeset
2091 PR c++/31445
kono
parents:
diff changeset
2092 * error.c (dump_type): Dump TYPE_ARGUMENT_PACK nodes.
kono
parents:
diff changeset
2093 * cp-tree.h (check_for_bare_parameter_packs): Returns bool.
kono
parents:
diff changeset
2094 * pt.c (check_for_bare_parameter_packs): Return bool indicated
kono
parents:
diff changeset
2095 whether everything was okay. Fix indentation.
kono
parents:
diff changeset
2096 (push_template_decl_real): Check for bare parameter packs in
kono
parents:
diff changeset
2097 function parameters; where errors occur, mark the parameter types
kono
parents:
diff changeset
2098 with ERROR_MARK_NODEs to avert ICEs.
kono
parents:
diff changeset
2099 (coerce_template_parameter_pack): New.
kono
parents:
diff changeset
2100 (coerce_template_parms): Moved parameter pack coercion into
kono
parents:
diff changeset
2101 coerce_template_parameter_pack, and permit it anywhere in the
kono
parents:
diff changeset
2102 template parameter list (not just at the end). Parameter and
kono
parents:
diff changeset
2103 argument indices can vary (somewhat) separately now, so add
kono
parents:
diff changeset
2104 PARM_IDX and ARG_IDX.
kono
parents:
diff changeset
2105 (fn_type_unification): Don't set an argument pack as incomplete if
kono
parents:
diff changeset
2106 no argument pack was deduced.
kono
parents:
diff changeset
2107 (type_unification_real): If a type parameter is a parameter pack
kono
parents:
diff changeset
2108 and has not otherwise been deduced, it will be deduced to an empty
kono
parents:
diff changeset
2109 parameter pack.
kono
parents:
diff changeset
2110 (more_specialized_fn): Use the actual lengths of the argument
kono
parents:
diff changeset
2111 lists when comparing against expansions.
kono
parents:
diff changeset
2112 * semantics.c (finish_member_declaration): If a field's type has
kono
parents:
diff changeset
2113 bare parameter packs, error and set its type to ERROR_MARK_NODE.
kono
parents:
diff changeset
2114
kono
parents:
diff changeset
2115 2007-05-24 Danny Smith <dannysmith@users.sourceforge.net>
kono
parents:
diff changeset
2116
kono
parents:
diff changeset
2117 PR target/27067
kono
parents:
diff changeset
2118 * mangle.c (mangle_decl): Call targetm.mangle_decl_assembler_name.
kono
parents:
diff changeset
2119
kono
parents:
diff changeset
2120 2007-05-22 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
2121
kono
parents:
diff changeset
2122 * name-lookup.c (ambiguous_decl): Adds check for hidden types.
kono
parents:
diff changeset
2123 (unqualified_namespace_lookup): Adds check for hidden types.
kono
parents:
diff changeset
2124
kono
parents:
diff changeset
2125 2007-05-22 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
2126
kono
parents:
diff changeset
2127 * decl.c (duplicate_decls): Verify namespace names are unique.
kono
parents:
diff changeset
2128
kono
parents:
diff changeset
2129 2007-05-21 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2130
kono
parents:
diff changeset
2131 * decl.c (cxx_maybe_build_cleanup): Handle
kono
parents:
diff changeset
2132 __attribute__((cleanup)).
kono
parents:
diff changeset
2133
kono
parents:
diff changeset
2134 2007-05-19 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2135
kono
parents:
diff changeset
2136 * cvt.c (cp_convert_and_check): Don't check warnings if the
kono
parents:
diff changeset
2137 conversion failed.
kono
parents:
diff changeset
2138
kono
parents:
diff changeset
2139 2007-05-18 Geoffrey Keating <geoffk@apple.com>
kono
parents:
diff changeset
2140
kono
parents:
diff changeset
2141 * mangle.c (write_real_cst): Use 'unsigned long' for %lx.
kono
parents:
diff changeset
2142
kono
parents:
diff changeset
2143 2007-05-14 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
2144
kono
parents:
diff changeset
2145 PR c++/29928
kono
parents:
diff changeset
2146 * rtti.c (get_tinfo_decl_dynamic, get_typeid): Try to complete the
kono
parents:
diff changeset
2147 type only if is a class type (5.2.8/4).
kono
parents:
diff changeset
2148
kono
parents:
diff changeset
2149 2007-05-14 Rafael Ávila de Espíndola <espindola@google.com>
kono
parents:
diff changeset
2150
kono
parents:
diff changeset
2151 * cp-objcp-common.h (LANG_HOOKS_UNSIGNED_TYPE): Remove.
kono
parents:
diff changeset
2152 * decl.c (grokdeclarator): Use unsigned_type_for instead of
kono
parents:
diff changeset
2153 c_common_unsigned_type.
kono
parents:
diff changeset
2154
kono
parents:
diff changeset
2155 2007-05-11 Silvius Rus <rus@google.com>
kono
parents:
diff changeset
2156
kono
parents:
diff changeset
2157 * typeck.c (build_indirect_ref): Add call to
kono
parents:
diff changeset
2158 strict_aliasing_warning.
kono
parents:
diff changeset
2159 (build_reinterpret_cast_1): Condition call to
kono
parents:
diff changeset
2160 strict_aliasing_warning.
kono
parents:
diff changeset
2161
kono
parents:
diff changeset
2162 2007-05-11 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
2163
kono
parents:
diff changeset
2164 * semantics.c (expand_or_defer_fn): Do not call c_record_cdtor_fn.
kono
parents:
diff changeset
2165 * decl2.c (start_objects): ctors and dtors are no longer public.
kono
parents:
diff changeset
2166 (cp_write_global_declarations): Do not call c_build_cdtor_fns.
kono
parents:
diff changeset
2167
kono
parents:
diff changeset
2168 2007-05-07 Andrew Pinski <andrew_pinski@playstation.sony.com>
kono
parents:
diff changeset
2169
kono
parents:
diff changeset
2170 * typeck.c (build_unary_op): Remove code that used to
kono
parents:
diff changeset
2171 handle non lvalue increments/decrements.
kono
parents:
diff changeset
2172
kono
parents:
diff changeset
2173 2007-05-07 Mike Stump <mrs@apple.com>
kono
parents:
diff changeset
2174
kono
parents:
diff changeset
2175 * parser.c (check_empty_body): Add.
kono
parents:
diff changeset
2176 (cp_parser_iteration_statement): Add call to check_empty_body.
kono
parents:
diff changeset
2177
kono
parents:
diff changeset
2178 2007-05-05 Geoffrey Keating <geoffk@apple.com>
kono
parents:
diff changeset
2179
kono
parents:
diff changeset
2180 PR 31775
kono
parents:
diff changeset
2181 * mangle.c (write_mangled_name): Mangle static variable names.
kono
parents:
diff changeset
2182 (write_unqualified_name): Use local-source-name for
kono
parents:
diff changeset
2183 namespace-scope static variables.
kono
parents:
diff changeset
2184
kono
parents:
diff changeset
2185 2007-05-04 Dirk Mueller <dmueller@suse.de>
kono
parents:
diff changeset
2186
kono
parents:
diff changeset
2187 * cp-tree.h (DECL_MAIN_P): only if -ffreestanding is
kono
parents:
diff changeset
2188 not in effect.
kono
parents:
diff changeset
2189
kono
parents:
diff changeset
2190 2007-05-02 Seongbae Park <seongbae.park@gmail.com>
kono
parents:
diff changeset
2191
kono
parents:
diff changeset
2192 PR c++/31663
kono
parents:
diff changeset
2193 * decl2.c (constrain_class_visibility):
kono
parents:
diff changeset
2194 Use strip_pointer_or_array_types instead of strip_array_types.
kono
parents:
diff changeset
2195
kono
parents:
diff changeset
2196 2007-04-28 Andrew Pinski <andrew_pinski@playstation.sony.com>
kono
parents:
diff changeset
2197
kono
parents:
diff changeset
2198 PR C++/30221
kono
parents:
diff changeset
2199 * decl.c (reshape_init_r): Don't reshape the first element if it
kono
parents:
diff changeset
2200 is a pointer to member function.
kono
parents:
diff changeset
2201
kono
parents:
diff changeset
2202 2007-04-27 Simon Baldwin <simonb@google.com>
kono
parents:
diff changeset
2203
kono
parents:
diff changeset
2204 * decl.c (grokparms): Changed message format from %qD to %qE.
kono
parents:
diff changeset
2205
kono
parents:
diff changeset
2206 2007-04-27 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
2207
kono
parents:
diff changeset
2208 * error.c (maybe_warn_variadic_templates): Variadic templates are
kono
parents:
diff changeset
2209 now in C++0x, so only warn about them in C++98 mode.
kono
parents:
diff changeset
2210
kono
parents:
diff changeset
2211 2007-04-26 Andrew Pinski <andrew_pinski@playstation.sony.com>
kono
parents:
diff changeset
2212
kono
parents:
diff changeset
2213 PR C++/30016
kono
parents:
diff changeset
2214 * typeck.c (build_reinterpret_cast_1): Only allow conversion to
kono
parents:
diff changeset
2215 integeral types from vectors types.
kono
parents:
diff changeset
2216
kono
parents:
diff changeset
2217 2007-04-26 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2218
kono
parents:
diff changeset
2219 PR c++/31598
kono
parents:
diff changeset
2220 * semantics.c (finish_omp_clauses): Don't create CP_OMP_CLAUSE_INFO
kono
parents:
diff changeset
2221 for type dependent OMP_CLAUSE_DECLs.
kono
parents:
diff changeset
2222
kono
parents:
diff changeset
2223 2007-04-24 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2224
kono
parents:
diff changeset
2225 PR c++/31338
kono
parents:
diff changeset
2226 * cp-tree.h (ARITHMETIC_TYPE): Include COMPLEX_TYPE.
kono
parents:
diff changeset
2227 * typeck.c (type_after_usual_arithmetic_conversions): Adjust, as
kono
parents:
diff changeset
2228 COMPLEX_TYPE is now an ARITHMETIC_TYPE.
kono
parents:
diff changeset
2229 * init.c (build_zero_init): Adjust, as
kono
parents:
diff changeset
2230 COMPLEX_TYPE is now a SCALAR_TYPE.
kono
parents:
diff changeset
2231 * typeck2.c (digest_init): Allow brace-enclosed initializers for
kono
parents:
diff changeset
2232 COMPLEX_TYPE, even though that is now a SCALAR_TYPE.
kono
parents:
diff changeset
2233
kono
parents:
diff changeset
2234 2007-04-25 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
2235
kono
parents:
diff changeset
2236 * semantics.c (classtype_has_nothrow_copy_or_assign_p): Adjust
kono
parents:
diff changeset
2237 per N2255; rename as classtype_has_nothrow_assign_or_copy_p.
kono
parents:
diff changeset
2238 (trait_expr_value): Adjust.
kono
parents:
diff changeset
2239
kono
parents:
diff changeset
2240 2007-04-23 Simon Baldwin <simonb@google.com>
kono
parents:
diff changeset
2241
kono
parents:
diff changeset
2242 * decl.c (grokparms): Added new error for duplicate function
kono
parents:
diff changeset
2243 parameters names in function prototypes, to match gcc behavior.
kono
parents:
diff changeset
2244
kono
parents:
diff changeset
2245 2007-04-23 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
2246
kono
parents:
diff changeset
2247 * decl2.c (finish_objects): Do not call target constructor/destructor
kono
parents:
diff changeset
2248 bits dirrectly.
kono
parents:
diff changeset
2249
kono
parents:
diff changeset
2250 2007-04-21 Andrew Pinski <andrew_pinski@playstation.sony.com>
kono
parents:
diff changeset
2251
kono
parents:
diff changeset
2252 * cp-tree.h (lang_tree_node): Use GENERIC_NEXT
kono
parents:
diff changeset
2253 instead of checking GIMPLE_STMT_P in chain_next.
kono
parents:
diff changeset
2254
kono
parents:
diff changeset
2255 2007-04-17 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2256
kono
parents:
diff changeset
2257 PR c++/31513
kono
parents:
diff changeset
2258 * call.c (convert_for_arg_passing): Convert bitfields to their
kono
parents:
diff changeset
2259 declared types.
kono
parents:
diff changeset
2260
kono
parents:
diff changeset
2261 2007-04-17 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
2262
kono
parents:
diff changeset
2263 PR c++/31517
kono
parents:
diff changeset
2264 * pt.c (value_dependent_expression_p): Handle MODOP_EXPRs.
kono
parents:
diff changeset
2265
kono
parents:
diff changeset
2266 2007-04-16 Seongbae Park <seongbae.park@gmail.com>
kono
parents:
diff changeset
2267
kono
parents:
diff changeset
2268 PR c++/29365
kono
parents:
diff changeset
2269 * decl2.c (constrain_class_visibility):
kono
parents:
diff changeset
2270 Do not warn about the use of anonymous namespace in the main input file.
kono
parents:
diff changeset
2271
kono
parents:
diff changeset
2272 2007-04-15 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2273
kono
parents:
diff changeset
2274 * cp-tree.h (current_template_parms): Fix typo in comment.
kono
parents:
diff changeset
2275
kono
parents:
diff changeset
2276 2007-04-15 Kazu Hirata <kazu@codesourcery.com>
kono
parents:
diff changeset
2277
kono
parents:
diff changeset
2278 * cp-tree.h, error.c: Fix comment typos.
kono
parents:
diff changeset
2279
kono
parents:
diff changeset
2280 2007-04-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2281
kono
parents:
diff changeset
2282 PR c++/31074
kono
parents:
diff changeset
2283 * call.c (reference_binding): Add c_cast_p parm. If true,
kono
parents:
diff changeset
2284 add quals to TO as needed to make it reference-compatible.
kono
parents:
diff changeset
2285
kono
parents:
diff changeset
2286 2007-04-11 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
2287
kono
parents:
diff changeset
2288 * class.c (convert_to_base_statically): Fold produced tree; verify
kono
parents:
diff changeset
2289 that we are not processing template_decl.
kono
parents:
diff changeset
2290
kono
parents:
diff changeset
2291 2007-04-09 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2292
kono
parents:
diff changeset
2293 PR c++/31449
kono
parents:
diff changeset
2294 * class.c (build_base_path): Ensure that the converted pointer has
kono
parents:
diff changeset
2295 the same cv-qualification as the input.
kono
parents:
diff changeset
2296
kono
parents:
diff changeset
2297 2007-04-09 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
2298
kono
parents:
diff changeset
2299 * tree.c (cp_tree_equal): Deal with TRAIT_EXPR.
kono
parents:
diff changeset
2300
kono
parents:
diff changeset
2301 2007-04-08 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
2302
kono
parents:
diff changeset
2303 * cp-objcp-common.h (LANG_HOOKS_TREE_INLINING_ADD_PENDING_FN_DECLS):
kono
parents:
diff changeset
2304 Do not set it.
kono
parents:
diff changeset
2305 (LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P): Do not set it.
kono
parents:
diff changeset
2306 * tree.c (cp_add_pending_fn_decls): Remove.
kono
parents:
diff changeset
2307 * cp-tree.h (cp_add_pending_fn_decls): Remove prototype.
kono
parents:
diff changeset
2308
kono
parents:
diff changeset
2309 2007-04-07 Daniel Berlin <dberlin@dberlin.org>
kono
parents:
diff changeset
2310
kono
parents:
diff changeset
2311 Revert change removing staticp.
kono
parents:
diff changeset
2312
kono
parents:
diff changeset
2313 2007-04-06 Daniel Berlin <dberlin@dberlin.org>
kono
parents:
diff changeset
2314
kono
parents:
diff changeset
2315 * cp-objcp-common.c (cxx_staticp): Remove.
kono
parents:
diff changeset
2316 * cp-objcp-common.h (LANG_HOOKS_STATICP): Remove.
kono
parents:
diff changeset
2317 * cp-tree.h (cxx_staticp):
kono
parents:
diff changeset
2318
kono
parents:
diff changeset
2319 2007-04-04 Danny Smith <dannysmith.users.sourceforge.net>
kono
parents:
diff changeset
2320
kono
parents:
diff changeset
2321 * class.c (check_for_override): Don't remove dllmport attribute
kono
parents:
diff changeset
2322 of virtual methods.
kono
parents:
diff changeset
2323
kono
parents:
diff changeset
2324 2007-04-03 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2325
kono
parents:
diff changeset
2326 PR c++/30847
kono
parents:
diff changeset
2327 * typeck.c (build_modify_expr): For COND_EXPR on LHS, if RHS has void
kono
parents:
diff changeset
2328 type issue error and return early.
kono
parents:
diff changeset
2329
kono
parents:
diff changeset
2330 2007-03-30 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2331
kono
parents:
diff changeset
2332 PR c++/31187
kono
parents:
diff changeset
2333 * typeck.c (cp_type_readonly): New fn.
kono
parents:
diff changeset
2334 * cp-tree.h: Declare it.
kono
parents:
diff changeset
2335 * decl.c (start_decl): Set implicit DECL_THIS_STATIC here.
kono
parents:
diff changeset
2336 (cp_finish_decl): Not here.
kono
parents:
diff changeset
2337
kono
parents:
diff changeset
2338 2007-03-31 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
2339
kono
parents:
diff changeset
2340 * optimize.c (maybe_clone_body): Replace splay-tree usage by
kono
parents:
diff changeset
2341 pointer-map.
kono
parents:
diff changeset
2342
kono
parents:
diff changeset
2343 2007-03-31 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
2344
kono
parents:
diff changeset
2345 PR c++/31138
kono
parents:
diff changeset
2346 PR c++/31140
kono
parents:
diff changeset
2347 PR c++/31141
kono
parents:
diff changeset
2348 * parser.c (declarator_can_be_parameter_pack): New.
kono
parents:
diff changeset
2349 (cp_parser_template_parameter): Only parse the `...' if the
kono
parents:
diff changeset
2350 declarator can be a parameter pack.
kono
parents:
diff changeset
2351 (cp_parser_parameter_declaration): Ditto. Also, handle when TYPE
kono
parents:
diff changeset
2352 is NULL.
kono
parents:
diff changeset
2353 * pt.c (find_parameter_packs_r): Look into the bounds on integer
kono
parents:
diff changeset
2354 types (they could be used as array bounds).
kono
parents:
diff changeset
2355 (check_for_bare_parameter_packs): Deal with TEMPLATE_PARM_INDEX.
kono
parents:
diff changeset
2356 (tsubst_pack_expansion): Handle failure to expand parameter
kono
parents:
diff changeset
2357 packs.
kono
parents:
diff changeset
2358
kono
parents:
diff changeset
2359 2007-03-30 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
2360
kono
parents:
diff changeset
2361 PR c++/26099
kono
parents:
diff changeset
2362 * cp-tree.h (enum cp_trait_kind, struct tree_trait_expr,
kono
parents:
diff changeset
2363 TRAIT_EXPR_TYPE1, TRAIT_EXPR_TYPE2, TRAIT_EXPR_KIND): Add.
kono
parents:
diff changeset
2364 (enum cp_tree_node_structure_enum, union lang_tree_node): Update.
kono
parents:
diff changeset
2365 (CLASS_TYPE_NON_UNION_P): Add.
kono
parents:
diff changeset
2366 (struct lang_type_class): Add has_complex_dflt.
kono
parents:
diff changeset
2367 (TYPE_HAS_COMPLEX_DFLT, TYPE_HAS_TRIVIAL_DFLT): Add.
kono
parents:
diff changeset
2368 (locate_copy, locate_ctor, locate_dtor, finish_trait_expr): Declare.
kono
parents:
diff changeset
2369 * cp-tree.def: Add TRAIT_EXPR.
kono
parents:
diff changeset
2370 * cp-objcp-common.c (cp_tree_size): Add TRAIT_EXPR case.
kono
parents:
diff changeset
2371 * lex.c (struct resword): Add __has_nothrow_assign,
kono
parents:
diff changeset
2372 __has_nothrow_constructor, __has_nothrow_copy, __has_trivial_assign,
kono
parents:
diff changeset
2373 __has_trivial_constructor, __has_trivial_copy,
kono
parents:
diff changeset
2374 __has_trivial_destructor, __has_virtual_destructor, __is_abstract,
kono
parents:
diff changeset
2375 __is_base_of, __is_class, __is_convertible_to, __is_empty, __is_enum,
kono
parents:
diff changeset
2376 __is_pod, __is_polymorphic, __is_union.
kono
parents:
diff changeset
2377 * parser.c (cp_parser_primary_expression): Deal with the new RIDs.
kono
parents:
diff changeset
2378 (cp_parser_trait_expr): New.
kono
parents:
diff changeset
2379 * semantics.c (finish_trait_expr, trait_expr_value
kono
parents:
diff changeset
2380 classtype_has_nothrow_copy_or_assign_p): New.
kono
parents:
diff changeset
2381 * method.c (locate_copy, locate_ctor, locate_dtor): Do not define
kono
parents:
diff changeset
2382 as static.
kono
parents:
diff changeset
2383 * decl.c (cp_tree_node_structure): Add TRAIT_EXPR.
kono
parents:
diff changeset
2384 * class.c (check_bases, check_field_decl, check_bases_and_members):
kono
parents:
diff changeset
2385 Deal with TYPE_HAS_COMPLEX_DFLT (t) too.
kono
parents:
diff changeset
2386 * pt.c (uses_template_parms, tsubst_copy_and_build,
kono
parents:
diff changeset
2387 value_dependent_expression_p, type_dependent_expression_p): Deal with
kono
parents:
diff changeset
2388 TRAIT_EXPR.
kono
parents:
diff changeset
2389 * tree.c (cp_walk_subtrees): Deal with TRAIT_EXPR.
kono
parents:
diff changeset
2390
kono
parents:
diff changeset
2391 2007-03-29 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
2392
kono
parents:
diff changeset
2393 * tree.c (cp_walk_subtrees): Do not set input_location.
kono
parents:
diff changeset
2394
kono
parents:
diff changeset
2395 2007-03-28 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
2396
kono
parents:
diff changeset
2397 PR c++/29077
kono
parents:
diff changeset
2398 * decl.c (grokfndecl): Properly setup decl if it is a constructor or a
kono
parents:
diff changeset
2399 destructor.
kono
parents:
diff changeset
2400
kono
parents:
diff changeset
2401 2007-03-28 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
2402
kono
parents:
diff changeset
2403 * parser.c (struct cp_parser): Update comment for
kono
parents:
diff changeset
2404 greater_than_is_operator_p.
kono
parents:
diff changeset
2405 (cp_parser_primary_expression): In C++0x mode, a cast operator can
kono
parents:
diff changeset
2406 be terminated with a `>>' token when !GREATER_THAN_IS_OPERATOR_P.
kono
parents:
diff changeset
2407 (TOKEN_PRECEDENCE): In C++0x mode, `>>' is treated like `>' when
kono
parents:
diff changeset
2408 !GREATER_THAN_IS_OPERATOR_P.
kono
parents:
diff changeset
2409 (cp_parser_binary_expression): When -Wc++0x-compat, warn about
kono
parents:
diff changeset
2410 `>>' operators that will become two `>' tokens in C++0x.
kono
parents:
diff changeset
2411 (cp_parser_parameter_declaration): Treat `>>' like `>' in C++0x
kono
parents:
diff changeset
2412 mode, allowing it to terminate default arguments.
kono
parents:
diff changeset
2413 (cp_parser_enclosed_template_argument_list): In C++0x mode, treat
kono
parents:
diff changeset
2414 `>>' like two consecutive `>' tokens.
kono
parents:
diff changeset
2415 (cp_parser_skip_to_end_of_template_parameter_list): Ditto.
kono
parents:
diff changeset
2416 (cp_parser_next_token_ends_template_argument_p): In C++0x, `>>'
kono
parents:
diff changeset
2417 ends a template argument.
kono
parents:
diff changeset
2418
kono
parents:
diff changeset
2419 2007-03-28 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
2420
kono
parents:
diff changeset
2421 * decl.c (redeclaration_error_message): Complain when redeclaring
kono
parents:
diff changeset
2422 a friend function with default template arguments (C++0x mode only).
kono
parents:
diff changeset
2423 * cp-tree.h (check_default_tmpl_args): Declare.
kono
parents:
diff changeset
2424 * pt.c (check_default_tmpl_args): In C++0x mode, permit default
kono
parents:
diff changeset
2425 template arguments in function templates. Add support for checking
kono
parents:
diff changeset
2426 the default template arguments of friend templates.
kono
parents:
diff changeset
2427 (push_template_decl_real): Fix call to check_default_tmpl_args.
kono
parents:
diff changeset
2428 (type_unification_real): If a template parameter has not been
kono
parents:
diff changeset
2429 deduced but provides a default template argument, substitute into
kono
parents:
diff changeset
2430 that default template argument.
kono
parents:
diff changeset
2431 * parser.c (cp_parser_init_declarator): When declaring (but not
kono
parents:
diff changeset
2432 defining!) a function template in C++0x mode, check for default
kono
parents:
diff changeset
2433 template arguments.
kono
parents:
diff changeset
2434
kono
parents:
diff changeset
2435 2007-03-28 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
2436
kono
parents:
diff changeset
2437 PR c++/29993
kono
parents:
diff changeset
2438 * decl.c (grokdeclarator): Deal with cv-qualified function type
kono
parents:
diff changeset
2439 typedefs in the same way for member and non-member functions.
kono
parents:
diff changeset
2440
kono
parents:
diff changeset
2441 2007-03-26 Dirk Mueller <dmueller@suse.de>
kono
parents:
diff changeset
2442
kono
parents:
diff changeset
2443 * parser.c (cp_parser_member_declaration): Pedwarn
kono
parents:
diff changeset
2444 about stray semicolons after member declarations.
kono
parents:
diff changeset
2445
kono
parents:
diff changeset
2446 2007-03-26 Paolo Carlini <pcarlini@suse.de>
kono
parents:
diff changeset
2447
kono
parents:
diff changeset
2448 PR c++/30500
kono
parents:
diff changeset
2449 * pt.c (instantiate_decl): Set in_system_header.
kono
parents:
diff changeset
2450
kono
parents:
diff changeset
2451 2007-03-22 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2452
kono
parents:
diff changeset
2453 * cp-tree.h (current_tempalte_parms): Improve documentation.
kono
parents:
diff changeset
2454 * pt.c (current_template_args): Likewise.
kono
parents:
diff changeset
2455
kono
parents:
diff changeset
2456 PR c++/30863
kono
parents:
diff changeset
2457 * parser.c (cp_parser_parse_and_diagnose_invalid_type_name): Do
kono
parents:
diff changeset
2458 not consume tokens when failing.
kono
parents:
diff changeset
2459
kono
parents:
diff changeset
2460 2007-03-22 Jim Wilson <wilson@specifix.com>
kono
parents:
diff changeset
2461 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2462
kono
parents:
diff changeset
2463 PR c++/31273
kono
parents:
diff changeset
2464 * call.c (standard_conversion): Use type_decays_to. Keep FCODE
kono
parents:
diff changeset
2465 consistent with FROM.
kono
parents:
diff changeset
2466
kono
parents:
diff changeset
2467 2007-03-22 Gabriel Dos Reis <gdr@integrable-solutions.net>
kono
parents:
diff changeset
2468
kono
parents:
diff changeset
2469 * error.c (dump_expr): Handle dependent names that designate types.
kono
parents:
diff changeset
2470 * cxx-pretty-print.c (pp_cxx_unqualified_id): Handle TYPENAME_TYPE.
kono
parents:
diff changeset
2471
kono
parents:
diff changeset
2472 2007-03-17 Kazu Hirata <kazu@codesourcery.com>
kono
parents:
diff changeset
2473
kono
parents:
diff changeset
2474 * cp-tree.def, parser.c, pt.c: Fix comment typos.
kono
parents:
diff changeset
2475
kono
parents:
diff changeset
2476 2007-03-16 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2477
kono
parents:
diff changeset
2478 * cvt.c (cp_convert_and_check) : Define.
kono
parents:
diff changeset
2479 * cp-tree.h (cp_convert_and_check): Declare.
kono
parents:
diff changeset
2480 * call.c (convert_conversion_warnings): Rename to
kono
parents:
diff changeset
2481 conversion_null_warnings. The warning for floating-point to
kono
parents:
diff changeset
2482 integer is handled by convert_and_check in convert_like_real.
kono
parents:
diff changeset
2483 (convert_like_real): convert_conversion_warnings was renamed as
kono
parents:
diff changeset
2484 conversion_null_warnings.
kono
parents:
diff changeset
2485 * typeck.c (build_binary_op): Use cp_convert_and_check to warn for
kono
parents:
diff changeset
2486 overflow and changes of value during conversion.
kono
parents:
diff changeset
2487
kono
parents:
diff changeset
2488 2007-03-15 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2489
kono
parents:
diff changeset
2490 PR c++/30891
kono
parents:
diff changeset
2491 * parser.c (cp_parser_statement): If 'namespace' is found, this
kono
parents:
diff changeset
2492 only can be a namespace alias definition, so parse it now.
kono
parents:
diff changeset
2493 (cp_parser_namespace_alias_definition): if we find an open brace
kono
parents:
diff changeset
2494 instead of '=', then this is actually a misplaced namespace
kono
parents:
diff changeset
2495 definition.
kono
parents:
diff changeset
2496
kono
parents:
diff changeset
2497 2007-03-15 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2498
kono
parents:
diff changeset
2499 PR c++/24924
kono
parents:
diff changeset
2500 * decl.c (cxx_init_decl_processing): Move command-line options
kono
parents:
diff changeset
2501 processing to c-opts.c.
kono
parents:
diff changeset
2502
kono
parents:
diff changeset
2503 2007-03-15 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
2504
kono
parents:
diff changeset
2505 * ptree.c (cxx_print_type): Use formatting markup for integers
kono
parents:
diff changeset
2506 when printing template parameter index/level/orig level.
kono
parents:
diff changeset
2507 (cxx_print_xnode): Ditto.
kono
parents:
diff changeset
2508 * cp-tree.h (TEMPLATE_PARM_PARAMETER_PACK): Use TREE_LANG_FLAG_0.
kono
parents:
diff changeset
2509 (struct template_parm_index_s): Remove the PARAMETER_PACK member.
kono
parents:
diff changeset
2510 Make INDEX, LEVEL, and ORIG_LEVEL integers instead of
kono
parents:
diff changeset
2511 HOST_WIDE_INTs.
kono
parents:
diff changeset
2512 (struct saved_scope): Make X_PROCESSING_TEMPLATE_DECL an int,
kono
parents:
diff changeset
2513 rather than a HOST_WIDE_INT.
kono
parents:
diff changeset
2514 Turn X_PROCESSING_EXPLICIT_INSTANTIATION, SKIP_EVALUATION, and
kono
parents:
diff changeset
2515 NEED_POP_FUNCTION_CONTEXT into bool bitfields; reorder fields for
kono
parents:
diff changeset
2516 better bit-packing.
kono
parents:
diff changeset
2517 (struct language_function): Make RETURNS_VALUE, RETURNS_NULL,
kono
parents:
diff changeset
2518 RETURNS_ABNORMALLY, IN_FUNCTION_TRY_HANDLER, and
kono
parents:
diff changeset
2519 IN_BASE_INITIALIZER bool bitfields.
kono
parents:
diff changeset
2520 (struct cp_declarator): Make KIND a 4-bit field. Make
kono
parents:
diff changeset
2521 PARAMETER_PACK_P a bool bitfield just after KIND.
kono
parents:
diff changeset
2522 * pt.c (uses_parameter_packs): Destroy the pointer set.
kono
parents:
diff changeset
2523 (make_pack_expansion): Ditto.
kono
parents:
diff changeset
2524 (check_for_bare_parameter_packs): Ditto.
kono
parents:
diff changeset
2525 * name-lookup.c (push_to_top_level): Make need_pop a bool value.
kono
parents:
diff changeset
2526
kono
parents:
diff changeset
2527 2007-03-14 Andrew Pinski <andrew_pinski@playstation.sony.com>
kono
parents:
diff changeset
2528
kono
parents:
diff changeset
2529 PR c++/31165
kono
parents:
diff changeset
2530 * call.c (convert_default_arg): Instead of copying the node,
kono
parents:
diff changeset
2531 unshare it.
kono
parents:
diff changeset
2532
kono
parents:
diff changeset
2533 2007-03-15 Dirk Mueller <dmueller@suse.de>
kono
parents:
diff changeset
2534
kono
parents:
diff changeset
2535 PR c++/30860
kono
parents:
diff changeset
2536 * call.c (convert_conversion_warnings): New..
kono
parents:
diff changeset
2537 (convert_like_real): .. factored out from here.
kono
parents:
diff changeset
2538 (convert_conversion_warnings): Add warning about
kono
parents:
diff changeset
2539 false being converted to NULL in argument passing.
kono
parents:
diff changeset
2540
kono
parents:
diff changeset
2541 2007-03-14 Dirk Mueller <dmueller@suse.de>
kono
parents:
diff changeset
2542
kono
parents:
diff changeset
2543 * semantics.c (c_finish_if_stmt): Call empty_if_body_warning.
kono
parents:
diff changeset
2544 (finish_do_body): Warn about empty body in do/while statement.
kono
parents:
diff changeset
2545
kono
parents:
diff changeset
2546 2007-03-14 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2547
kono
parents:
diff changeset
2548 * class.c (warn_hidden): Add OPT_Woverloaded_virtual to warning.
kono
parents:
diff changeset
2549
kono
parents:
diff changeset
2550 2007-03-14 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2551
kono
parents:
diff changeset
2552 PR c/21438
kono
parents:
diff changeset
2553 * typeck.c (build_binary_op): Call warn_for_div_zero instead of
kono
parents:
diff changeset
2554 warning.
kono
parents:
diff changeset
2555
kono
parents:
diff changeset
2556 2007-03-13 Alexandre Oliva <aoliva@redhat.com>
kono
parents:
diff changeset
2557
kono
parents:
diff changeset
2558 * repo.c (init_repo): Initialize random_seed saved options.
kono
parents:
diff changeset
2559 (finish_repo): Adjust.
kono
parents:
diff changeset
2560
kono
parents:
diff changeset
2561 2007-03-13 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2562
kono
parents:
diff changeset
2563 PR bootstrap/30899
kono
parents:
diff changeset
2564 * Make-lang.in (doc/g++.1): Use $< to specify the location from
kono
parents:
diff changeset
2565 which to copy.
kono
parents:
diff changeset
2566
kono
parents:
diff changeset
2567 2007-03-12 Seongbae Park <seongbae.park@gmail.com>
kono
parents:
diff changeset
2568
kono
parents:
diff changeset
2569 * decl.c (compute_array_index_type): New warning flag warn_vla.
kono
parents:
diff changeset
2570
kono
parents:
diff changeset
2571 2007-03-12 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2572
kono
parents:
diff changeset
2573 PR c++/30108
kono
parents:
diff changeset
2574 * call.c (convert_default_arg): Copy non-constant arguments.
kono
parents:
diff changeset
2575
kono
parents:
diff changeset
2576 2007-03-11 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2577
kono
parents:
diff changeset
2578 PR c++/31038
kono
parents:
diff changeset
2579 * parser.c (cp_parser_postfix_expression): Disallow compound
kono
parents:
diff changeset
2580 literals in constant expressions.
kono
parents:
diff changeset
2581
kono
parents:
diff changeset
2582 PR c++/30328
kono
parents:
diff changeset
2583 * semantics.c (finish_typeof): Use unlowered_expr_type.
kono
parents:
diff changeset
2584
kono
parents:
diff changeset
2585 2007-03-10 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2586
kono
parents:
diff changeset
2587 PR c++/30274
kono
parents:
diff changeset
2588 * cp-tree.h (unlowered_expr_type): New function.
kono
parents:
diff changeset
2589 * typeck.c (is_bitfield_expr_with_lowered_type): Handle
kono
parents:
diff changeset
2590 COMPOUND_EXPR, MODIFY_EXPR, and SAVE_EXPR.
kono
parents:
diff changeset
2591 (unlowered_expr_type): New function.
kono
parents:
diff changeset
2592 (build_unary_op): Disallow predecrements of bool bitfields.
kono
parents:
diff changeset
2593 * call.c (build_conditional_expr): Use unlowered_expr_type.
kono
parents:
diff changeset
2594 * pt.c (type_unification_real): Likewise.
kono
parents:
diff changeset
2595
kono
parents:
diff changeset
2596 2007-03-09 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
2597
kono
parents:
diff changeset
2598 PR c++/20599
kono
parents:
diff changeset
2599 * typeck.c (check_return_expr): Check for bare parameter packs.
kono
parents:
diff changeset
2600 (comptypes): Compare template parameter packs and
kono
parents:
diff changeset
2601 type pack expansions.
kono
parents:
diff changeset
2602 * decl.c (grokdeclarator): Deal with the declaration of function
kono
parents:
diff changeset
2603 parameter packs.
kono
parents:
diff changeset
2604 (grokparms): Verify that the (optional) function parameter pack is
kono
parents:
diff changeset
2605 at the end of the parameter list.
kono
parents:
diff changeset
2606 (xref_basetypes): Handle pack expansions in the base class.
kono
parents:
diff changeset
2607 (cp_tree_node_structure): Handle ARGUMENT_PACK_SELECT.
kono
parents:
diff changeset
2608 * cp-tree.def (TYPE_ARGUMENT_PACK): New.
kono
parents:
diff changeset
2609 (NONTYPE_ARGUMENT_PACK): New.
kono
parents:
diff changeset
2610 (TYPE_PACK_EXPANSION): New.
kono
parents:
diff changeset
2611 (EXPR_PACK_EXPANSION): New.
kono
parents:
diff changeset
2612 (ARGUMENT_PACK_SELECT): New.
kono
parents:
diff changeset
2613 * cp-objcp-common.c (cp_tree_size): Compute size of
kono
parents:
diff changeset
2614 (NON)TYPE_ARGUMENT_PACK, (TYPE|EXPR)_PACK_EXPANSION, and
kono
parents:
diff changeset
2615 ARGUMENT_PACK_SELECT.
kono
parents:
diff changeset
2616 * error.c (dump_template_argument): Print template argument packs.
kono
parents:
diff changeset
2617 (dump_template_argument_list): Ditto.
kono
parents:
diff changeset
2618 (dump_template_parameter): Dump `...' for template type parameter
kono
parents:
diff changeset
2619 packs.
kono
parents:
diff changeset
2620 (dump_type): Dump TYPE_PACK_EXPANSION nodes.
kono
parents:
diff changeset
2621 (dump_parameters): Print function parameter packs.
kono
parents:
diff changeset
2622 (dump_template_parms): Print template argument packs.
kono
parents:
diff changeset
2623 (dump_expr): Dump EXPR_PACK_EXPANSION nodes.
kono
parents:
diff changeset
2624 (maybe_warn_variadic_templates): New.
kono
parents:
diff changeset
2625 * operators.def: Add ellipsis operator for EXPR_PACK_EXPANSION.
kono
parents:
diff changeset
2626 * tree.c (cp_walk_subtrees): Walk BASELINK, TYPE_ARGUMENT_PACK,
kono
parents:
diff changeset
2627 NONTYPE_ARGUMENT_PACK, TYPE_PACK_EXPANSION, EXPR_PACK_EXPANSION,
kono
parents:
diff changeset
2628 CAST_EXPR.
kono
parents:
diff changeset
2629 * mangle.c (write_type): Mangle TYPE_PACK_EXPANSION.
kono
parents:
diff changeset
2630 (write_template_arg): Write argument packs as separate arguments.
kono
parents:
diff changeset
2631 * cp-tree.h (struct template_parm_index_s): Add flag that
kono
parents:
diff changeset
2632 indicates that the template parameter is actually a parameter
kono
parents:
diff changeset
2633 pack.
kono
parents:
diff changeset
2634 (struct tree_argument_pack_select): New.
kono
parents:
diff changeset
2635 (enum cp_tree_node_structure_enum): Add TS_CP_ARGUMENT_PACK_SELECT.
kono
parents:
diff changeset
2636 (union lang_tree_node): Add argument_pack_select.
kono
parents:
diff changeset
2637 (FUNCTION_PARAMETER_PACK_P): New.
kono
parents:
diff changeset
2638 (PACK_EXPANSION_P): New.
kono
parents:
diff changeset
2639 (PACK_EXPANSION_PATTERN): New.
kono
parents:
diff changeset
2640 (SET_PACK_EXPANSION_PATTERN): New.
kono
parents:
diff changeset
2641 (PACK_EXPANSION_PARAMETER_PACKS): New.
kono
parents:
diff changeset
2642 (ARGUMENT_PACK_P): New.
kono
parents:
diff changeset
2643 (ARGUMENT_PACK_ARGS): New.
kono
parents:
diff changeset
2644 (SET_ARGUMENT_PACK_ARGS): New.
kono
parents:
diff changeset
2645 (ARGUMENT_PACK_INCOMPLETE_P): New.
kono
parents:
diff changeset
2646 (ARGUMENT_PACK_EXPLICIT_ARGS): New.
kono
parents:
diff changeset
2647 (TEMPLATE_PARM_PARAMETER_PACK): New.
kono
parents:
diff changeset
2648 (TEMPLATE_TYPE_PARAMETER_PACK): New.
kono
parents:
diff changeset
2649 (ARGUMENT_PACK_SELECT_FROM_PACK): New.
kono
parents:
diff changeset
2650 (ARGUMENT_PACK_SELECT_INDEX): New.
kono
parents:
diff changeset
2651 (ARGUMENT_PACK_SELECT_ARG): New.
kono
parents:
diff changeset
2652 (struct cp_declarator): Add parameter_pack_p flag.
kono
parents:
diff changeset
2653 (maybe_warn_variadic_templates): Declare.
kono
parents:
diff changeset
2654 (process_template_parm): Add bool parameter IS_PARAMETER_PACK, to
kono
parents:
diff changeset
2655 indicate a template parameter pack.
kono
parents:
diff changeset
2656 (uses_parameter_packs): Declare.
kono
parents:
diff changeset
2657 (template_parameter_pack_p): Declare.
kono
parents:
diff changeset
2658 (template_parms_variadic_p): Declare.
kono
parents:
diff changeset
2659 (make_pack_expansion): Declare.
kono
parents:
diff changeset
2660 (check_for_bare_parameter_packs): Declare.
kono
parents:
diff changeset
2661 * cxx-pretty-print.c (pp_cxx_unary_expression): Print
kono
parents:
diff changeset
2662 sizeof... expressions.
kono
parents:
diff changeset
2663 (pp_cxx_expression): Print pack expansions and non-type argument
kono
parents:
diff changeset
2664 packs.
kono
parents:
diff changeset
2665 (pp_cxx_exception_specification): Print pack expansions.
kono
parents:
diff changeset
2666 (pp_cxx_direct_declarator): Print ellipsis for parameter packs.
kono
parents:
diff changeset
2667 (pp_cxx_ctor_initializer): Print pack expansions.
kono
parents:
diff changeset
2668 (pp_cxx_type_id): Print pack expansions.
kono
parents:
diff changeset
2669 (pp_cxx_template_argument_list): Print argument packs.
kono
parents:
diff changeset
2670 (pp_cxx_template_parameter): Print ellipsis for template parameter
kono
parents:
diff changeset
2671 packs.
kono
parents:
diff changeset
2672 * pt.c (comp_template_parms): Compare template parameter packs.
kono
parents:
diff changeset
2673 (template_parameter_pack_p): New.
kono
parents:
diff changeset
2674 (template_parms_variadic_p): New.
kono
parents:
diff changeset
2675 (template_args_variadic_p): New.
kono
parents:
diff changeset
2676 (make_ith_pack_parameter_name): New.
kono
parents:
diff changeset
2677 (struct find_parameter_pack_data): New.
kono
parents:
diff changeset
2678 (find_parameter_packs_r): New.
kono
parents:
diff changeset
2679 (uses_parameter_packs): New.
kono
parents:
diff changeset
2680 (make_pack_expansion): New.
kono
parents:
diff changeset
2681 (check_for_bare_parameter_packs): New.
kono
parents:
diff changeset
2682 (expand_template_argument_pack): New.
kono
parents:
diff changeset
2683 (reduce_template_parm_level): Propagate parameter pack flag.
kono
parents:
diff changeset
2684 (process_template_parm): Add is_parameter_pack parameter to state
kono
parents:
diff changeset
2685 when the parameter is actually a parameter pack. Create template
kono
parents:
diff changeset
2686 parameter packs when is_parameter_pack is true.
kono
parents:
diff changeset
2687 (current_template_args): The argument for a template parameter
kono
parents:
diff changeset
2688 pack is an argument pack containing a single pack expansion.
kono
parents:
diff changeset
2689 (process_partial_specialization): When checking that non-type
kono
parents:
diff changeset
2690 argument expressions do not involve template parameters, loop over
kono
parents:
diff changeset
2691 the arguments in argument packs separately.
kono
parents:
diff changeset
2692 (push_template_decl_real): Check that the type of the declaration
kono
parents:
diff changeset
2693 does not have any bare parameter packs. Check that primary
kono
parents:
diff changeset
2694 templates have no more than one parameter pack, and that it comes
kono
parents:
diff changeset
2695 at the end of the template parameter list.
kono
parents:
diff changeset
2696 (convert_template_argument): Handle coercions for pack expansion
kono
parents:
diff changeset
2697 expressions by coercing the pattern then rebuilding the expansion.
kono
parents:
diff changeset
2698 (coerce_template_parms): When coercing the arguments for a
kono
parents:
diff changeset
2699 variadic template, pack "extra" arguments into an argument pack.
kono
parents:
diff changeset
2700 (coerce_template_template_parms): Cannot coerce between parameter
kono
parents:
diff changeset
2701 packs and non-pack parameters.
kono
parents:
diff changeset
2702 (template_args_equal): Compare PACK_EXPANSION_P expressions.
kono
parents:
diff changeset
2703 (comp_template_args): Expand all template arguments packs before
kono
parents:
diff changeset
2704 comparing template argument lists.
kono
parents:
diff changeset
2705 (mangle_class_name_for_template): Make argument packs as separate
kono
parents:
diff changeset
2706 template arguments.
kono
parents:
diff changeset
2707 (for_each_template_parm_r): No need to handle BASELINK.
kono
parents:
diff changeset
2708 (instantiate_class_template): Handle pack expansions in the base
kono
parents:
diff changeset
2709 class list.
kono
parents:
diff changeset
2710 (tsubst_pack_expansion): New.
kono
parents:
diff changeset
2711 (tsubst_template_args): Handle substitutions of argument packs and
kono
parents:
diff changeset
2712 pack expansion into template argument lists.
kono
parents:
diff changeset
2713 (tsubst_decl): Expand function parameter packs into separate
kono
parents:
diff changeset
2714 function parameters.
kono
parents:
diff changeset
2715 (tsubst_arg_types): Expand a type pack expansion into separate
kono
parents:
diff changeset
2716 argument types.
kono
parents:
diff changeset
2717 (tsubst_exception_specification): Handle pack expansions in
kono
parents:
diff changeset
2718 exception specifiers.
kono
parents:
diff changeset
2719 (tsubst): See through ARGUMENT_PACK_SELECT arguments when
kono
parents:
diff changeset
2720 replacing a template parameter with its argument. If we encounter
kono
parents:
diff changeset
2721 a substitution for an argument pack, just return the parameter
kono
parents:
diff changeset
2722 itself.
kono
parents:
diff changeset
2723 (tsubst_copy): sizeof(X...) returns the number of elements in
kono
parents:
diff changeset
2724 parameter pack X. See through ARGUMENT_PACK_SELECT when the
kono
parents:
diff changeset
2725 PARM_DECL is a parameter pack.
kono
parents:
diff changeset
2726 (tsubst_expr): Expression pack expansions and argument packs
kono
parents:
diff changeset
2727 cannot show up here; they will all be handled through function
kono
parents:
diff changeset
2728 calls, sizeof, and template argument lists.
kono
parents:
diff changeset
2729 (tsubst_copy_and_build): sizeof(X...) returns the number of
kono
parents:
diff changeset
2730 elements in parameter pack X. Handle pack expansions in TREE_LIST
kono
parents:
diff changeset
2731 and CONSTRUCTOR nodes.
kono
parents:
diff changeset
2732 (fn_type_unification): Handle "incomplete" explicit template
kono
parents:
diff changeset
2733 argument lists that specify some of the arguments for a template
kono
parents:
diff changeset
2734 parameter pack.
kono
parents:
diff changeset
2735 (type_unification_real): Unify arguments against pack expansions.
kono
parents:
diff changeset
2736 (template_parm_level_and_index): New, helper function.
kono
parents:
diff changeset
2737 (unify_pack_expansion): New.
kono
parents:
diff changeset
2738 (unify): Unify argument packs on an argument-by-argument basis,
kono
parents:
diff changeset
2739 handling variadic argument packs as well.
kono
parents:
diff changeset
2740 (more_specialized_fn): Handle unification of function parameter
kono
parents:
diff changeset
2741 packs. All things being equal, prefer non-variadic function
kono
parents:
diff changeset
2742 templates to variadic function templates.
kono
parents:
diff changeset
2743 (more_specialized_class): Prefer the variadic class template
kono
parents:
diff changeset
2744 partial specialization that binds fewer arguments to a parameter
kono
parents:
diff changeset
2745 pack.
kono
parents:
diff changeset
2746 (regenerate_decl_from_template): Expand function parameter packs
kono
parents:
diff changeset
2747 into separate parameters.
kono
parents:
diff changeset
2748 (instantiate_decl): Ditto.
kono
parents:
diff changeset
2749 (tsubst_initializer_list): Handle pack expansions for base-class
kono
parents:
diff changeset
2750 initializers.
kono
parents:
diff changeset
2751 (dependent_type_p_r): Determine dependent types in argument packs
kono
parents:
diff changeset
2752 and pack expansions.
kono
parents:
diff changeset
2753 (value_dependent_expression_p): Determine value-dependence of
kono
parents:
diff changeset
2754 non-type argument packs.
kono
parents:
diff changeset
2755 (dependent_template_arg_p): Handle argument packs.
kono
parents:
diff changeset
2756 * semantics.c (finish_cond): Check for bare parameter packs.
kono
parents:
diff changeset
2757 (finish_expr_stmt): Ditto.
kono
parents:
diff changeset
2758 (finish_for_expr): Ditto.
kono
parents:
diff changeset
2759 (finish_switch_cond): Ditto.
kono
parents:
diff changeset
2760 (finish_mem_initializers): Ditto.
kono
parents:
diff changeset
2761 * name-lookup.c (arg_assoc_type): Handle pack expansions and
kono
parents:
diff changeset
2762 argument packs.
kono
parents:
diff changeset
2763 * decl2.c (cp_build_parm_decl): Mark function parameter packs.
kono
parents:
diff changeset
2764 * parser.c (make_declarator): Declarator is not an expansion.
kono
parents:
diff changeset
2765 (make_pointer_declarator): Transfer parameter pack flag to outer
kono
parents:
diff changeset
2766 declarator.
kono
parents:
diff changeset
2767 (make_reference_declarator): Ditto.
kono
parents:
diff changeset
2768 (make_ptrmem_declarator): Ditto.
kono
parents:
diff changeset
2769 (make_call_declarator): Ditto.
kono
parents:
diff changeset
2770 (make_array_declarator): Ditto.
kono
parents:
diff changeset
2771 (cp_parser_postfix_expression): Allow pack expansion expressions
kono
parents:
diff changeset
2772 in the argument list for a call expression.
kono
parents:
diff changeset
2773 (cp_parser_parenthesized_expression_list): Add new parameter
kono
parents:
diff changeset
2774 ALLOW_EXPANSION_P. When true, parse the ellipsis to mean "expand
kono
parents:
diff changeset
2775 into separate arguments."
kono
parents:
diff changeset
2776 (cp_parser_new_placement): Allow pack expansion expressions.
kono
parents:
diff changeset
2777 (cp_parser_new_initializer): Ditto.
kono
parents:
diff changeset
2778 (cp_parser_mem_initializer_list): Allow ellipsis to create a
kono
parents:
diff changeset
2779 base-class initializer expansion.
kono
parents:
diff changeset
2780 (cp_parser_mem_initializer): Ditto.
kono
parents:
diff changeset
2781 (cp_parser_template_parameter_list): Keep track of whether the
kono
parents:
diff changeset
2782 template parameter is a template parameter pack.
kono
parents:
diff changeset
2783 (cp_parser_template_parameter): Parse the ellipsis to indicate a
kono
parents:
diff changeset
2784 template parameter pack.
kono
parents:
diff changeset
2785 (cp_parser_type_parameter): Ditto.
kono
parents:
diff changeset
2786 (cp_parser_template_argument_list): Parse the ellipsis to indicate
kono
parents:
diff changeset
2787 a pack expansion.
kono
parents:
diff changeset
2788 (cp_parser_direct_declarator): Parse the ellipsis to indicate that
kono
parents:
diff changeset
2789 this declarator is a parameter pack.
kono
parents:
diff changeset
2790 (cp_parser_parameter_declaration): The ellipsis does not end the
kono
parents:
diff changeset
2791 parameter declaration, because it might be a parameter pack. Parse
kono
parents:
diff changeset
2792 the ellipsis to indicate a parameter pack.
kono
parents:
diff changeset
2793 (cp_parser_initializer): Allow pack expansions.
kono
parents:
diff changeset
2794 (cp_parser_initializer_list): Allow ellipsis to create an
kono
parents:
diff changeset
2795 initializer expansion.
kono
parents:
diff changeset
2796 (cp_parser_base_clause): Allow ellipsis to create a base specifier
kono
parents:
diff changeset
2797 expansion.
kono
parents:
diff changeset
2798 (cp_parser_type_id_list): Allow ellipsis to create an exception
kono
parents:
diff changeset
2799 specifier expansion.
kono
parents:
diff changeset
2800 (cp_parser_attribute_list): Don't allow pack expansions.
kono
parents:
diff changeset
2801 (cp_parser_functional_cast): Allow pack expansions.
kono
parents:
diff changeset
2802 (cp_parser_sizeof_operand): Allow ellipsis following "sizeof" to
kono
parents:
diff changeset
2803 compute the length of a parameter pack.
kono
parents:
diff changeset
2804 (cp_parser_next_token_ends_template_argument_p): An ellipsis can
kono
parents:
diff changeset
2805 end a template argument.
kono
parents:
diff changeset
2806 * tree.c (cp_walk_subtrees): Walk BASELINK, TYPE_ARGUMENT_PACK,
kono
parents:
diff changeset
2807 NONTYPE_ARGUMENT_PACK, TYPE_PACK_EXPANSION, EXPR_PACK_EXPANSION,
kono
parents:
diff changeset
2808 CAST_EXPR.
kono
parents:
diff changeset
2809
kono
parents:
diff changeset
2810 2007-03-09 Dirk Mueller <dmueller@suse.de>
kono
parents:
diff changeset
2811
kono
parents:
diff changeset
2812 * call.c (build_new_op): Call warn_logical_operator.
kono
parents:
diff changeset
2813
kono
parents:
diff changeset
2814 2007-03-08 Volker Reichelt <v.reichelt@netcologne.de>
kono
parents:
diff changeset
2815
kono
parents:
diff changeset
2816 PR c++/30852
kono
parents:
diff changeset
2817 * semantics.c (finish_offsetof): Handle COMPOUND_EXPR.
kono
parents:
diff changeset
2818
kono
parents:
diff changeset
2819 PR c++/30534
kono
parents:
diff changeset
2820 * pt.c (any_template_arguments_need_structural_equality_p):
kono
parents:
diff changeset
2821 Robustify.
kono
parents:
diff changeset
2822
kono
parents:
diff changeset
2823 2007-03-08 Alexandre Oliva <aoliva@redhat.com>
kono
parents:
diff changeset
2824
kono
parents:
diff changeset
2825 * decl.c (grokdeclarator): Disable warnings for anonymous
kono
parents:
diff changeset
2826 bitfields.
kono
parents:
diff changeset
2827
kono
parents:
diff changeset
2828 2007-03-05 Volker Reichelt <v.reichelt@netcologne.de>
kono
parents:
diff changeset
2829
kono
parents:
diff changeset
2830 * typeck2.c (readonly_error): Always emit a hard error.
kono
parents:
diff changeset
2831 Remove last argument.
kono
parents:
diff changeset
2832 * cp-tree.h (readonly_error): Adjust prototype.
kono
parents:
diff changeset
2833 * semantics.c (finish_asm_stmt): Adjust call to readonly_error.
kono
parents:
diff changeset
2834 * typeck.c (build_unary_op): Likewise.
kono
parents:
diff changeset
2835 (build_modify_expr): Likewise.
kono
parents:
diff changeset
2836
kono
parents:
diff changeset
2837 2007-03-04 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
2838
kono
parents:
diff changeset
2839 PR c++/30895
kono
parents:
diff changeset
2840 * tree.c (cp_tree_equal): Properly handle COMPLEX_CST trees.
kono
parents:
diff changeset
2841
kono
parents:
diff changeset
2842 2007-03-03 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2843
kono
parents:
diff changeset
2844 PR c++/15787
kono
parents:
diff changeset
2845 * parser.c (struct cp_parser): New IN_IF_STMT.
kono
parents:
diff changeset
2846 (cp_parser_statement_seq_opt): Handle an unexpected 'else',
kono
parents:
diff changeset
2847 returning if parsing the body of an 'if' statement or issuing an
kono
parents:
diff changeset
2848 error and continuing.
kono
parents:
diff changeset
2849 (cp_parser_selection_statement): Set IN_IF_STMT bit when parsing
kono
parents:
diff changeset
2850 body of 'if'.
kono
parents:
diff changeset
2851 (cp_parser_jump_statement): Mask new IN_IF_STMT bit.
kono
parents:
diff changeset
2852
kono
parents:
diff changeset
2853 2007-03-02 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
2854
kono
parents:
diff changeset
2855 PR c++/28253
kono
parents:
diff changeset
2856 * class.c (update_vtable_entry_for_fn): Properly handle invalid overriders
kono
parents:
diff changeset
2857 for thunks.
kono
parents:
diff changeset
2858
kono
parents:
diff changeset
2859 2007-03-02 Geoffrey Keating <geoffk@apple.com>
kono
parents:
diff changeset
2860
kono
parents:
diff changeset
2861 * g++spec.c (lang_specific_driver): Add -lstdc++ when compiling
kono
parents:
diff changeset
2862 Objective-C++. Don't exit early if -shared-libgcc needs to be
kono
parents:
diff changeset
2863 added.
kono
parents:
diff changeset
2864
kono
parents:
diff changeset
2865 2007-03-02 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2866
kono
parents:
diff changeset
2867 * typeck.c (common_base_type): Delete unused function.
kono
parents:
diff changeset
2868
kono
parents:
diff changeset
2869 2007-03-01 Brooks Moses <brooks.moses@codesourcery.com>
kono
parents:
diff changeset
2870
kono
parents:
diff changeset
2871 * Make-lang.in: Add dummy lang.install-pdf target.
kono
parents:
diff changeset
2872
kono
parents:
diff changeset
2873 2007-03-01 Simon Baldwin <simonb@google.com>
kono
parents:
diff changeset
2874
kono
parents:
diff changeset
2875 PR c++/23689
kono
parents:
diff changeset
2876 * decl.c (check_tag_decl): Added new warning for typedef ignored
kono
parents:
diff changeset
2877 when it precedes an otherwise valid non-typedef declaration.
kono
parents:
diff changeset
2878
kono
parents:
diff changeset
2879 2007-02-28 Sandra Loosemore <sandra@codesourcery.com>
kono
parents:
diff changeset
2880
kono
parents:
diff changeset
2881 * typeck.c (build_function_call): Store converted arguments
kono
parents:
diff changeset
2882 in a stack-allocated array instead of building a list.
kono
parents:
diff changeset
2883 (convert_arguments): Store arguments in the array passed in as an
kono
parents:
diff changeset
2884 argument, and return the actual number of arguments.
kono
parents:
diff changeset
2885 * call.c (build_call): Delete, and replace with...
kono
parents:
diff changeset
2886 (build_call_n, build_call_a): New.
kono
parents:
diff changeset
2887 (build_op_delete_call): Rewrite to avoid constructing argument lists.
kono
parents:
diff changeset
2888 (build_over_call): Store converted arguments in a stack-allocated
kono
parents:
diff changeset
2889 array instead of building a list.
kono
parents:
diff changeset
2890 (build_cxx_call): Pass arguments in an array instead of as a list.
kono
parents:
diff changeset
2891 (build_java_interface_fn_ref): Rewrite to avoid constructing
kono
parents:
diff changeset
2892 argument lists.
kono
parents:
diff changeset
2893 * tree.h: Update declarations to reflect above changes.
kono
parents:
diff changeset
2894 * method.c (use_thunk): Use a stack-allocated array to hold
kono
parents:
diff changeset
2895 the arguments instead of a list.
kono
parents:
diff changeset
2896 * rtti.c (throw_bad_cast): Update call to cxx_call.
kono
parents:
diff changeset
2897 (throw_bad_typeid): Likewise.
kono
parents:
diff changeset
2898 (build_dynamic_cast_1): Likewise.
kono
parents:
diff changeset
2899 * init.c (build_builtin_delete_call): Use build_call_n.
kono
parents:
diff changeset
2900 * decl.c (expand_static_init): Likewise.
kono
parents:
diff changeset
2901 * except.c (cp_protect_cleanup_actions): Likewise.
kono
parents:
diff changeset
2902 * cp-gimplify.c (genericize_eh_spec_block): Likewise.
kono
parents:
diff changeset
2903 (gimplify_must_not_throw_expr): Likewise.
kono
parents:
diff changeset
2904 (cxx_omp_apply_fn): Use build_call_a.
kono
parents:
diff changeset
2905
kono
parents:
diff changeset
2906 2007-02-26 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2907
kono
parents:
diff changeset
2908 * semantics.c (expand_or_defer_fn): Call c_record_cdtor_fn.
kono
parents:
diff changeset
2909 * decl2.c (cp_write_gloabl_declarations): Call c_build_cdtor_fns.
kono
parents:
diff changeset
2910
kono
parents:
diff changeset
2911 2007-02-25 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2912
kono
parents:
diff changeset
2913 * cp-tree.h (static_ctors): Remove.
kono
parents:
diff changeset
2914 * cp-tree.h (static_dtors): Likewise.
kono
parents:
diff changeset
2915 * cp-objcp-common.c (decl_shadowed_for_var_lookup): Adjust for
kono
parents:
diff changeset
2916 refactoring of tree_map hierarchy.
kono
parents:
diff changeset
2917 (decl_shadowed_for_var_insert): Likewise.
kono
parents:
diff changeset
2918 * semantics.c (expand_body): Use c_expand_body.
kono
parents:
diff changeset
2919 (expand_or_defer_fn): Don't update static_ctors or static_dtors.
kono
parents:
diff changeset
2920 * decl2.c (static_ctors): Remove.
kono
parents:
diff changeset
2921 (static_dtors): Likewise.
kono
parents:
diff changeset
2922 (generate_ctor_or_dtor_function): Pass NULL_TREE to
kono
parents:
diff changeset
2923 objc_generate_static_init_call. Do not call static_[cd]tors.
kono
parents:
diff changeset
2924 (generate_ctor_and_dtor_functions_for_priority): Do not check for
kono
parents:
diff changeset
2925 static_[cd]tors.
kono
parents:
diff changeset
2926 (cp_write_global_declarations): Likewise.
kono
parents:
diff changeset
2927
kono
parents:
diff changeset
2928 2007-02-23 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
2929
kono
parents:
diff changeset
2930 * class.c (note_name_declared_in_class): Make declaration
kono
parents:
diff changeset
2931 changes meaning a pedwarn.
kono
parents:
diff changeset
2932
kono
parents:
diff changeset
2933 2007-02-22 Michael Matz <matz@suse.de>
kono
parents:
diff changeset
2934
kono
parents:
diff changeset
2935 PR c++/29433
kono
parents:
diff changeset
2936 * cp-tree.h (TFF_UNQUALIFIED_NAME): New formatting flag.
kono
parents:
diff changeset
2937 * error.c (dump_aggr_type, dump_simple_decl, dump_decl,
kono
parents:
diff changeset
2938 dump_function_decl): Guard emitting outer scopes by new flag.
kono
parents:
diff changeset
2939 * cp-lang.c (cxx_dwarf_name): New function.
kono
parents:
diff changeset
2940 (LANG_HOOKS_DWARF_NAME): Define to cxx_dwarf_name.
kono
parents:
diff changeset
2941 * pt.c (classtype_mangled_name, mangle_class_name_for_template):
kono
parents:
diff changeset
2942 Remove functions.
kono
parents:
diff changeset
2943 (push_template_decl_real, lookup_template_class): Remove calls
kono
parents:
diff changeset
2944 to above functions.
kono
parents:
diff changeset
2945
kono
parents:
diff changeset
2946 2007-02-19 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
2947
kono
parents:
diff changeset
2948 * call.c (build_new_method_call): Ensure that explicit calls of
kono
parents:
diff changeset
2949 destructors have type "void".
kono
parents:
diff changeset
2950
kono
parents:
diff changeset
2951 2007-02-19 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2952
kono
parents:
diff changeset
2953 * typeck.c (build_binary_op): Replace -Wstring-literal-comparison
kono
parents:
diff changeset
2954 and -Walways-true with -Waddress.
kono
parents:
diff changeset
2955 * cvt.c (convert_to_void): Replace unconditional warning with
kono
parents:
diff changeset
2956 -Waddress.
kono
parents:
diff changeset
2957
kono
parents:
diff changeset
2958 2007-02-18 Kazu Hirata <kazu@codesourcery.com>
kono
parents:
diff changeset
2959
kono
parents:
diff changeset
2960 * decl.c, tree.c: Fix comment typos.
kono
parents:
diff changeset
2961
kono
parents:
diff changeset
2962 2007-02-15 Andrew Pinski <andrew_pinski@playstation.sony.com>
kono
parents:
diff changeset
2963
kono
parents:
diff changeset
2964 PR C++/30158
kono
parents:
diff changeset
2965 * semantics.c (finish_stmt_expr_expr): Set TREE_TYPE of the
kono
parents:
diff changeset
2966 statement expression if we had an error mark node.
kono
parents:
diff changeset
2967
kono
parents:
diff changeset
2968 2007-02-15 Sandra Loosemore <sandra@codesourcery.com>
kono
parents:
diff changeset
2969 Brooks Moses <brooks.moses@codesourcery.com>
kono
parents:
diff changeset
2970 Lee Millward <lee.millward@codesourcery.com>
kono
parents:
diff changeset
2971
kono
parents:
diff changeset
2972 * cp-tree.def (AGGR_INIT_EXPR): Adjust documentation.
kono
parents:
diff changeset
2973 Change class to tcc_vl_exp.
kono
parents:
diff changeset
2974
kono
parents:
diff changeset
2975 * call.c (build_call): Use build_call_list instead
kono
parents:
diff changeset
2976 of build3.
kono
parents:
diff changeset
2977 (build_over_call): Likewise.
kono
parents:
diff changeset
2978 (build_new_method_call): Use build_min_non_dep_call_list
kono
parents:
diff changeset
2979 instead of build_min_non_dep.
kono
parents:
diff changeset
2980
kono
parents:
diff changeset
2981 * error.c (dump_call_expr_args): New function.
kono
parents:
diff changeset
2982 (dump_aggr_init_expr_args): New function.
kono
parents:
diff changeset
2983 (dump_expr) <AGGR_INIT_EXPR, CALL_EXPR, INDIRECT_REF>: Use them.
kono
parents:
diff changeset
2984 Update to use new CALL_EXPR and AGGR_INIT_EXPR accessor macros.
kono
parents:
diff changeset
2985
kono
parents:
diff changeset
2986 * cvt.c (convert_to_void): Use build_call_array instead
kono
parents:
diff changeset
2987 of build3; use new AGGR_INIT_EXPR accessor macros.
kono
parents:
diff changeset
2988
kono
parents:
diff changeset
2989 * mangle.c (write_expression): Use TREE_OPERAND_LENGTH
kono
parents:
diff changeset
2990 instead of TREE_CODE_LENGTH.
kono
parents:
diff changeset
2991
kono
parents:
diff changeset
2992 * dump.c (cp_dump_tree) <AGGR_INIT_EXPR>: Update to use new
kono
parents:
diff changeset
2993 AGGR_INIT_EXPR accessor macros.
kono
parents:
diff changeset
2994
kono
parents:
diff changeset
2995 * cp-gimplify.c (cp_gimplify_init_expr): Use
kono
parents:
diff changeset
2996 AGGR_INIT_EXPR_SLOT to set the slot operand.
kono
parents:
diff changeset
2997
kono
parents:
diff changeset
2998 * cp-tree.h (AGGR_INIT_EXPR_FN): New macro.
kono
parents:
diff changeset
2999 (AGGR_INIT_EXPR_SLOT): New macro.
kono
parents:
diff changeset
3000 (AGGR_INIT_EXPR_ARG): New macro.
kono
parents:
diff changeset
3001 (aggr_init_expr_nargs): New macro.
kono
parents:
diff changeset
3002 (AGGR_INIT_EXPR_ARGP): New macro.
kono
parents:
diff changeset
3003 (aggr_init_expr_arg_iterator): New.
kono
parents:
diff changeset
3004 (init_aggr_init_expr_arg_iterator): New.
kono
parents:
diff changeset
3005 (next_aggr_init_expr_arg): New.
kono
parents:
diff changeset
3006 (first_aggr_init_expr_arg): New.
kono
parents:
diff changeset
3007 (more_aggr_init_expr_args_p): New.
kono
parents:
diff changeset
3008 (FOR_EACH_AGGR_INIT_EXPR_ARG): New.
kono
parents:
diff changeset
3009 (stabilize_aggr_init): New declaration.
kono
parents:
diff changeset
3010 (build_min_non_dep_call_list): Likewise.
kono
parents:
diff changeset
3011
kono
parents:
diff changeset
3012 * tree.c (process_aggr_init_operands): New function.
kono
parents:
diff changeset
3013 (build_aggr_init_array) New function.
kono
parents:
diff changeset
3014 (build_cplus_new): Update to use new CALL_EXPR and
kono
parents:
diff changeset
3015 AGGR_INIT_EXPR accessor macros. Replace use of build3 with
kono
parents:
diff changeset
3016 build_aggr_init_array.
kono
parents:
diff changeset
3017 (build_min_non_dep_call_list) New function.
kono
parents:
diff changeset
3018 (build_min_nt): Assert input code parameter is not a variable
kono
parents:
diff changeset
3019 length expression class.
kono
parents:
diff changeset
3020 (build_min, build_min_non_dep): Likewise.
kono
parents:
diff changeset
3021 (cp_tree_equal) <CALL_EXPR>: Iterate through the arguments
kono
parents:
diff changeset
3022 to check for equality instead of recursing. Handle tcc_vl_exp
kono
parents:
diff changeset
3023 tree code classes.
kono
parents:
diff changeset
3024 (stabilize_call): Update to only handle CALL_EXPRs, not
kono
parents:
diff changeset
3025 AGGR_INIT_EXPRs; use new CALL_EXPR accessor macros.
kono
parents:
diff changeset
3026 (stabilize_aggr_init): New function.
kono
parents:
diff changeset
3027 (stabilize_init): Use it.
kono
parents:
diff changeset
3028
kono
parents:
diff changeset
3029 * cxx-pretty-print.c (pp_cxx_postfix_expression)
kono
parents:
diff changeset
3030 <AGGR_INIT_EXPR, CALL_EXPR>: Update to use new CALL_EXPR and
kono
parents:
diff changeset
3031 AGGR_INIT_EXPR accessor macros and argument iterators.
kono
parents:
diff changeset
3032
kono
parents:
diff changeset
3033 * pt.c (tsubst_copy) <CALL_EXPR>: Replace build_nt with
kono
parents:
diff changeset
3034 build_vl_exp. Iterate through the operands, recursively
kono
parents:
diff changeset
3035 processing each one.
kono
parents:
diff changeset
3036 (tsubst_copy_and_build) <CALL_EXPR>: Update to use new
kono
parents:
diff changeset
3037 CALL_EXPR accessor macros.
kono
parents:
diff changeset
3038 (value_dependent_expression_p) <default>: Handle tcc_vl_exp
kono
parents:
diff changeset
3039 tree code classes. Use TREE_OPERAND_LENGTH instead of
kono
parents:
diff changeset
3040 TREE_CODE_LENGTH.
kono
parents:
diff changeset
3041
kono
parents:
diff changeset
3042 * semantics.c (finish_call_expr): Use build_nt_call_list
kono
parents:
diff changeset
3043 instead of build_nt.
kono
parents:
diff changeset
3044 (simplify_aggr_init_expr): Update to use new AGGR_INIT_EXPR
kono
parents:
diff changeset
3045 accessor macros. Use build_call_array to construct the
kono
parents:
diff changeset
3046 CALL_EXPR node instead of build3
kono
parents:
diff changeset
3047
kono
parents:
diff changeset
3048 * decl2.c (build_offset_ref_call_from_tree): Use
kono
parents:
diff changeset
3049 build_nt_call_list and build_min_non_dep_call_list instead
kono
parents:
diff changeset
3050 of build_min_nt and build_min_non_dep.
kono
parents:
diff changeset
3051
kono
parents:
diff changeset
3052 * parser.c (cp_parser_postfix_expression) <CPP_OPEN_PAREN>:
kono
parents:
diff changeset
3053 Use build_nt_call_list instead of build_min_nt.
kono
parents:
diff changeset
3054
kono
parents:
diff changeset
3055 2007-02-15 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
3056
kono
parents:
diff changeset
3057 PR c++/28943
kono
parents:
diff changeset
3058 * call.c (build_conditional_expr): Improve error message.
kono
parents:
diff changeset
3059
kono
parents:
diff changeset
3060 2007-02-13 Dirk Mueller <dmueller@suse.de>
kono
parents:
diff changeset
3061
kono
parents:
diff changeset
3062 * friend.c (do_friend): Annotate warning about friend
kono
parents:
diff changeset
3063 declarations in templates with OPT_Wnon_template_friend.
kono
parents:
diff changeset
3064 Convert informal message from warning() to inform().
kono
parents:
diff changeset
3065
kono
parents:
diff changeset
3066 2007-02-12 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
3067 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
3068
kono
parents:
diff changeset
3069 PR c++/14622
kono
parents:
diff changeset
3070 * pt.c (do_decl_instantiation): Detect type mismatches in explicit
kono
parents:
diff changeset
3071 instantiations for variables.
kono
parents:
diff changeset
3072
kono
parents:
diff changeset
3073 2007-02-12 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
3074
kono
parents:
diff changeset
3075 PR middle-end/7651
kono
parents:
diff changeset
3076 * cp-gimplify.c (gimplify_expr_stmt): Don't check extra_warnings.
kono
parents:
diff changeset
3077 Check warn_unused_value just once.
kono
parents:
diff changeset
3078
kono
parents:
diff changeset
3079 2007-02-11 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
3080
kono
parents:
diff changeset
3081 PR c++/26988
kono
parents:
diff changeset
3082 * pt.c (determine_specialization): Use skip_artificial_parms_for.
kono
parents:
diff changeset
3083 (fn_type_unificiation): Likewise.
kono
parents:
diff changeset
3084 (get_bindings): Likewise.
kono
parents:
diff changeset
3085
kono
parents:
diff changeset
3086 o2007-02-06 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
3087
kono
parents:
diff changeset
3088 PR target/29487
kono
parents:
diff changeset
3089 * decl.c (finish_function): Use DECL_REPLACEABLE.
kono
parents:
diff changeset
3090 * tree.c (cp_cannot_inline_tree_fn): Likewise.
kono
parents:
diff changeset
3091
kono
parents:
diff changeset
3092 2007-02-10 Gabriel Dos Reis <gdr@integrable-solutions.net>
kono
parents:
diff changeset
3093
kono
parents:
diff changeset
3094 * parser.c (cp_parser_primary_expression): Reformat overly long lines.
kono
parents:
diff changeset
3095
kono
parents:
diff changeset
3096 2007-02-10 Richard Henderson <rth@redhat.com>, Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3097
kono
parents:
diff changeset
3098 * decl.c (grokvardecl): Don't error if !have_tls.
kono
parents:
diff changeset
3099 (grokdeclarator): Likewise.
kono
parents:
diff changeset
3100 * parser.c (cp_parser_omp_threadprivate): Likewise.
kono
parents:
diff changeset
3101
kono
parents:
diff changeset
3102 2007-02-07 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3103
kono
parents:
diff changeset
3104 PR c++/30703
kono
parents:
diff changeset
3105 * cp-gimplify.c (cp_genericize_r): Don't dereference invisiref
kono
parents:
diff changeset
3106 parameters and result decls in omp clauses.
kono
parents:
diff changeset
3107 (cxx_omp_privatize_by_reference): Pass also invisiref PARM_DECLs
kono
parents:
diff changeset
3108 by reference.
kono
parents:
diff changeset
3109
kono
parents:
diff changeset
3110 2007-02-05 Dirk Mueller <dmueller@suse.de>
kono
parents:
diff changeset
3111
kono
parents:
diff changeset
3112 PR bootstrap/30510
kono
parents:
diff changeset
3113 * parser.c (cp_parser_class_specifier): Always initialize bases.
kono
parents:
diff changeset
3114
kono
parents:
diff changeset
3115 2007-02-05 Paolo Bonzini <bonzini@gnu.org>
kono
parents:
diff changeset
3116
kono
parents:
diff changeset
3117 * cp-tree.h (OMP_ATOMIC_CODE): Delete.
kono
parents:
diff changeset
3118 (OMP_ATOMIC_DEPENDENT_P): Rewrite.
kono
parents:
diff changeset
3119 * pt.c (tsubst_expr): Adjust for new format of dependent OMP_ATOMIC
kono
parents:
diff changeset
3120 expressions.
kono
parents:
diff changeset
3121 * semantics.c (finish_omp_atomic): Store a whole expression node
kono
parents:
diff changeset
3122 in operand 1, and integer_zero_node in operand 0, for dependent
kono
parents:
diff changeset
3123 OMP_ATOMIC. Rewrite to make flow easier to understand.
kono
parents:
diff changeset
3124
kono
parents:
diff changeset
3125 2007-02-03 Gabriel Dos Reis <gdr@integrable-solutions.net>
kono
parents:
diff changeset
3126
kono
parents:
diff changeset
3127 * decl.c (grokdeclarator): Use OPT_Wreturn_type instead of 0.
kono
parents:
diff changeset
3128
kono
parents:
diff changeset
3129 2007-02-04 Kazu Hirata <kazu@codesourcery.com>
kono
parents:
diff changeset
3130
kono
parents:
diff changeset
3131 * class.c, cp-tree.h, decl.c, decl2.c, g++spec.c, init.c,
kono
parents:
diff changeset
3132 parser.c, pt.c, tree.c, typeck.c: Follow spelling conventions.
kono
parents:
diff changeset
3133
kono
parents:
diff changeset
3134 2007-02-03 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
3135
kono
parents:
diff changeset
3136 * parser.c (cp_lexer_get_preprocessor_token): Attach the C++0x
kono
parents:
diff changeset
3137 keyword warning to -Wc++0x-compat.
kono
parents:
diff changeset
3138
kono
parents:
diff changeset
3139 2007-02-03 Gabriel Dos Reis <gdr@integrable-solutions.net>
kono
parents:
diff changeset
3140
kono
parents:
diff changeset
3141 * decl.c (grokdeclarator): Update documentation.
kono
parents:
diff changeset
3142
kono
parents:
diff changeset
3143 2007-02-02 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3144
kono
parents:
diff changeset
3145 PR c++/30536
kono
parents:
diff changeset
3146 * decl.c (grokdeclarator): If __thread is used together with
kono
parents:
diff changeset
3147 a storage class other than extern and static, clear thread_p
kono
parents:
diff changeset
3148 after issuing diagnostics and fall through to checking the
kono
parents:
diff changeset
3149 storage class.
kono
parents:
diff changeset
3150
kono
parents:
diff changeset
3151 2007-01-30 Roger Sayle <roger@eyesopen.com>
kono
parents:
diff changeset
3152
kono
parents:
diff changeset
3153 * error.c (dump_type_suffix): Avoid use of cp_build_binary_op when
kono
parents:
diff changeset
3154 calculating the size of an array (to avoid recursive errors).
kono
parents:
diff changeset
3155
kono
parents:
diff changeset
3156 2007-01-30 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
3157
kono
parents:
diff changeset
3158 PR c++/24745
kono
parents:
diff changeset
3159 * typeck.c (build_binary_op): Fix logic for warning. Move warning
kono
parents:
diff changeset
3160 to -Wpointer-arith.
kono
parents:
diff changeset
3161 * call.c (convert_like_real): Don't warn when converting to
kono
parents:
diff changeset
3162 boolean type.
kono
parents:
diff changeset
3163
kono
parents:
diff changeset
3164 2007-01-29 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
3165
kono
parents:
diff changeset
3166 * decl.c (pop_label): Replace warning with call to
kono
parents:
diff changeset
3167 warn_for_unused_label.
kono
parents:
diff changeset
3168
kono
parents:
diff changeset
3169 2007-01-28 Andrew Pinski <pinskia@gmail.com>
kono
parents:
diff changeset
3170
kono
parents:
diff changeset
3171 PR C++/28988
kono
parents:
diff changeset
3172 * semantics.c (finish_pseudo_destructor_expr): Check the
kono
parents:
diff changeset
3173 destrutor name by calling check_dtor_name.
kono
parents:
diff changeset
3174
kono
parents:
diff changeset
3175 2007-01-24 Douglas Gregor <dgregor@osl.iu.edu>
kono
parents:
diff changeset
3176
kono
parents:
diff changeset
3177 * lex.c (D_CPP0X): Rename.
kono
parents:
diff changeset
3178 (D_CXX0X): To this.
kono
parents:
diff changeset
3179 (reswords): D_CPP0X -> D_CXX0X.
kono
parents:
diff changeset
3180 (init_reswords): Ditto.
kono
parents:
diff changeset
3181 * parser.c (cp_lexer_get_preprocessor_token): Warn about the use
kono
parents:
diff changeset
3182 of C++0x keywords as identifiers.
kono
parents:
diff changeset
3183
kono
parents:
diff changeset
3184 2007-01-23 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
3185
kono
parents:
diff changeset
3186 PR c++/27492
kono
parents:
diff changeset
3187 * decl.c (duplicate_decls): Don't reset DECL_INVALID_OVERRIDER_P for
kono
parents:
diff changeset
3188 function decls.
kono
parents:
diff changeset
3189
kono
parents:
diff changeset
3190 2007-01-23 Ian Lance Taylor <iant@google.com>
kono
parents:
diff changeset
3191
kono
parents:
diff changeset
3192 * typeck.c (convert_for_assignment): Only warn about a = b = c
kono
parents:
diff changeset
3193 when converting to bool.
kono
parents:
diff changeset
3194
kono
parents:
diff changeset
3195 2007-01-23 Roger Sayle <roger@eyesopen.com>
kono
parents:
diff changeset
3196
kono
parents:
diff changeset
3197 * call.c (null_ptr_cst_p): Replace use of TREE_CONSTANT_OVERFLOW with
kono
parents:
diff changeset
3198 TREE_OVERFLOW.
kono
parents:
diff changeset
3199 * typeck.c (ignore_overflows): Remove the remaining uses of
kono
parents:
diff changeset
3200 TREE_CONSTANT_OVERFLOW.
kono
parents:
diff changeset
3201
kono
parents:
diff changeset
3202 2007-01-20 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
3203
kono
parents:
diff changeset
3204 * decl2.c (start_objects, start_static_storage_duration_function):
kono
parents:
diff changeset
3205 Do not make the functions uninlinable.
kono
parents:
diff changeset
3206
kono
parents:
diff changeset
3207 2007-01-17 Ian Lance Taylor <iant@google.com>
kono
parents:
diff changeset
3208
kono
parents:
diff changeset
3209 * class.c (add_method): Call VEC_reserve_exact rather than passing
kono
parents:
diff changeset
3210 a negative size to VEC_reserve.
kono
parents:
diff changeset
3211
kono
parents:
diff changeset
3212 2007-01-11 Simon Martin <simartin@users.sourceforge.net>
kono
parents:
diff changeset
3213
kono
parents:
diff changeset
3214 PR c++/29573
kono
parents:
diff changeset
3215 * tree.c (cp_tree_equal): Properly handle MODOP_EXPR trees.
kono
parents:
diff changeset
3216
kono
parents:
diff changeset
3217 2007-01-10 Mark Mitchell <mark@codesourcery.com>
kono
parents:
diff changeset
3218
kono
parents:
diff changeset
3219 PR c++/28999
kono
parents:
diff changeset
3220 * decl.c (make_typename_type): If the qualified name is not a
kono
parents:
diff changeset
3221 type, issue an error.
kono
parents:
diff changeset
3222 * parser.c (cp_parser_elaborated_type_specifier): Fix comment
kono
parents:
diff changeset
3223 formatting.
kono
parents:
diff changeset
3224
kono
parents:
diff changeset
3225 2007-01-08 Geoffrey Keating <geoffk@apple.com>
kono
parents:
diff changeset
3226
kono
parents:
diff changeset
3227 * rtti.c: Include target.h.
kono
parents:
diff changeset
3228 (emit_support_tinfos): If ! targetm.cxx.library_rtti_comdat (),
kono
parents:
diff changeset
3229 don't emit typeinfo for fundamental types as weak.
kono
parents:
diff changeset
3230 * Make-lang.in (cp/rtti.o): Update and correct dependencies.
kono
parents:
diff changeset
3231
kono
parents:
diff changeset
3232 2007-01-08 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
3233
kono
parents:
diff changeset
3234 * cvt.c (cp_convert_to_pointer): Use build_int_cst_type.
kono
parents:
diff changeset
3235
kono
parents:
diff changeset
3236 2007-01-08 Mark Shinwell <shinwell@codesourcery.com>
kono
parents:
diff changeset
3237
kono
parents:
diff changeset
3238 * call.c (standard_conversion): Pass flag to
kono
parents:
diff changeset
3239 vector_types_convertible_p to disallow emission of note.
kono
parents:
diff changeset
3240 * typeck.c (convert_for_assignment): Pass flag to
kono
parents:
diff changeset
3241 vector_types_convertible_p to allow emission of note.
kono
parents:
diff changeset
3242 (ptr_reasonably_similar): Pass flag to vector_types_convertible_p
kono
parents:
diff changeset
3243 to disallow emission of note.
kono
parents:
diff changeset
3244
kono
parents:
diff changeset
3245 2007-01-07 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
3246
kono
parents:
diff changeset
3247 PR c++/28986
kono
parents:
diff changeset
3248 * typeck.c (build_binary_op): Call overflow_warning if
kono
parents:
diff changeset
3249 TREE_OVERFLOW_P is true for the result and not for any of the
kono
parents:
diff changeset
3250 operands.
kono
parents:
diff changeset
3251
kono
parents:
diff changeset
3252 2007-01-06 Lee Millward <lee.millward@codesourcery.com>
kono
parents:
diff changeset
3253
kono
parents:
diff changeset
3254 PR c++/19439
kono
parents:
diff changeset
3255 * class.c (add_method): Don't wait until template
kono
parents:
diff changeset
3256 instantiation time to complain about duplicate methods.
kono
parents:
diff changeset
3257
kono
parents:
diff changeset
3258 2007-01-05 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
kono
parents:
diff changeset
3259
kono
parents:
diff changeset
3260 PR c/19978
kono
parents:
diff changeset
3261 * semantics.c (finish_unary_op_expr): Warn only if result
kono
parents:
diff changeset
3262 overflowed and operands did not.
kono
parents:
diff changeset
3263
kono
parents:
diff changeset
3264 2007-01-05 Ian Lance Taylor <iant@google.com>
kono
parents:
diff changeset
3265
kono
parents:
diff changeset
3266 * typeck.c (build_binary_op): Warn about comparing a non-weak
kono
parents:
diff changeset
3267 address to NULL.
kono
parents:
diff changeset
3268
kono
parents:
diff changeset
3269 2007-01-05 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
3270
kono
parents:
diff changeset
3271 * pt.c (tsubst): Propagate the need for structural equality checks
kono
parents:
diff changeset
3272 when reducing the level of template parameters.
kono
parents:
diff changeset
3273
kono
parents:
diff changeset
3274 2007-01-03 Kazu Hirata <kazu@codesourcery.com>
kono
parents:
diff changeset
3275
kono
parents:
diff changeset
3276 * pt.c: Fix a comment typo.
kono
parents:
diff changeset
3277
kono
parents:
diff changeset
3278 2007-01-02 Ian Lance Taylor <iant@google.com>
kono
parents:
diff changeset
3279
kono
parents:
diff changeset
3280 * semantics.c (maybe_convert_cond): Optionally warn when using an
kono
parents:
diff changeset
3281 assignment as a condition.
kono
parents:
diff changeset
3282 * typeck.c (convert_for_assignment): Optionally warn about
kono
parents:
diff changeset
3283 assigning the result of an assignment to a bool.
kono
parents:
diff changeset
3284
kono
parents:
diff changeset
3285 2007-01-02 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
3286
kono
parents:
diff changeset
3287 * pt.c (canonical_template_parms): Correct typo in comment.
kono
parents:
diff changeset
3288
kono
parents:
diff changeset
3289 2007-01-02 Douglas Gregor <doug.gregor@gmail.com>
kono
parents:
diff changeset
3290
kono
parents:
diff changeset
3291 * typeck.c (structural_comptypes): Renamed from "comptypes".
kono
parents:
diff changeset
3292 (comptypes): Use canonical type information to perform fast type
kono
parents:
diff changeset
3293 comparison. When VERIFY_CANONICAL_TYPES, verify that the
kono
parents:
diff changeset
3294 canonical type comparison returns the same results as we would see
kono
parents:
diff changeset
3295 from the current, structural check. Support COMPARE_STRUCTURAL
kono
parents:
diff changeset
3296 when we need structural checks.
kono
parents:
diff changeset
3297 * decl.c (typename_compare): Fix comment.
kono
parents:
diff changeset
3298 (build_typename_type): TYPENAME_TYPE nodes require structural
kono
parents:
diff changeset
3299 equality checks, because they resolve different based on the
kono
parents:
diff changeset
3300 current class type.
kono
parents:
diff changeset
3301 (make_unbound_class_template): UNBOUND_CLASS_TEMPLATE nodes
kono
parents:
diff changeset
3302 require structural equality checks (for now).
kono
parents:
diff changeset
3303 (build_ptrmemfunc_type): Build the canonical pointer to member
kono
parents:
diff changeset
3304 function type.
kono
parents:
diff changeset
3305 (compute_array_index_type): Whenever we build a new index type
kono
parents:
diff changeset
3306 to represent the size of an array in a template, we need to mark
kono
parents:
diff changeset
3307 this index type as requiring structural equality. This goes for
kono
parents:
diff changeset
3308 arrays with value-dependent sizes with the current ABI, or all
kono
parents:
diff changeset
3309 arrays with ABI-1.
kono
parents:
diff changeset
3310 * tree.c (cplus_array_hash): New.
kono
parents:
diff changeset
3311 (struct cplus_array_info): New.
kono
parents:
diff changeset
3312 (cplus_array_compare): New.
kono
parents:
diff changeset
3313 (cplus_array_htab): New.
kono
parents:
diff changeset
3314 (build_cplus_array_type_1): Use a hash table to cache the array
kono
parents:
diff changeset
3315 types we build. Build the canonical array type for each array
kono
parents:
diff changeset
3316 type.
kono
parents:
diff changeset
3317 (cp_build_qualified_type_real): When building a cv-qualified array
kono
parents:
diff changeset
3318 type, use the hash table of array types and build canonical array
kono
parents:
diff changeset
3319 types as necessary.
kono
parents:
diff changeset
3320 (bind_template_template_parm): BOUND_TEMPLATE_TEMPLATE_PARM nodes
kono
parents:
diff changeset
3321 use structural equality (for now).
kono
parents:
diff changeset
3322 * cp-tree.h (COMPARE_STRUCTURAL): New.
kono
parents:
diff changeset
3323 * pt.c (canonical_template_parms): New.
kono
parents:
diff changeset
3324 (canonical_type_parameter): New.
kono
parents:
diff changeset
3325 (process_template_parm): Find the canonical type parameter.
kono
parents:
diff changeset
3326 (lookup_template_class): When we have named the primary template
kono
parents:
diff changeset
3327 type, set the canonical type for our template class to the primary
kono
parents:
diff changeset
3328 template type. If any of the template arguments need structural
kono
parents:
diff changeset
3329 equality checks, the template class needs structural equality
kono
parents:
diff changeset
3330 checks.
kono
parents:
diff changeset
3331 (tsubst): When reducing the level of a template template
kono
parents:
diff changeset
3332 parameter, we require structural equality tests for the resulting
kono
parents:
diff changeset
3333 parameter because its template parameters have not had their types
kono
parents:
diff changeset
3334 canonicalized. When reducing a template type parameter, find the
kono
parents:
diff changeset
3335 canonical reduced type parameter.
kono
parents:
diff changeset
3336 (any_template_arguments_need_structural_equality_p): New.
kono
parents:
diff changeset
3337
kono
parents:
diff changeset
3338
kono
parents:
diff changeset
3339 Copyright (C) 2007 Free Software Foundation, Inc.
kono
parents:
diff changeset
3340
kono
parents:
diff changeset
3341 Copying and distribution of this file, with or without modification,
kono
parents:
diff changeset
3342 are permitted in any medium without royalty provided the copyright
kono
parents:
diff changeset
3343 notice and this notice are preserved.