annotate gcc/cp/ChangeLog-2012 @ 158:494b0b89df80 default tip

...
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Mon, 25 May 2020 18:13:55 +0900
parents 04ced10e8804
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
111
kono
parents:
diff changeset
1 2012-12-28 Kai Tietz <ktietz@redhat.com>
kono
parents:
diff changeset
2
kono
parents:
diff changeset
3 * rtti.c (LONGPTR_T): New helper-macro.
kono
parents:
diff changeset
4 (get_pseudo_ti_init): Initialize offset_type by LONGPTR_T
kono
parents:
diff changeset
5 type instead of 'long' type.
kono
parents:
diff changeset
6 (create_tinfo_types): Use for offset/flags field LONGPTR_T
kono
parents:
diff changeset
7 type instead of 'long' type.
kono
parents:
diff changeset
8
kono
parents:
diff changeset
9 2012-12-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
10
kono
parents:
diff changeset
11 PR c++/55724
kono
parents:
diff changeset
12 * pt.c (type_unification_real): Re-combine post-deduction loops.
kono
parents:
diff changeset
13
kono
parents:
diff changeset
14 2012-12-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
15
kono
parents:
diff changeset
16 PR c++/55685
kono
parents:
diff changeset
17 * pt.c (tsubst_copy_and_build): Don't use SIZEOF_EXPR_TYPE_P in
kono
parents:
diff changeset
18 templates.
kono
parents:
diff changeset
19
kono
parents:
diff changeset
20 PR c++/42315
kono
parents:
diff changeset
21 * decl.c (maybe_deduce_size_from_array_init): Don't change the
kono
parents:
diff changeset
22 variable type.
kono
parents:
diff changeset
23
kono
parents:
diff changeset
24 2012-12-13 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
25
kono
parents:
diff changeset
26 PR c++/55652
kono
parents:
diff changeset
27 * typeck2.c (merge_exception_specifiers): Don't call operand_equal_p
kono
parents:
diff changeset
28 if noex is NULL.
kono
parents:
diff changeset
29
kono
parents:
diff changeset
30 2012-12-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
31
kono
parents:
diff changeset
32 PR c++/54883
kono
parents:
diff changeset
33 * decl2.c (min_vis_r): Handle anon visibility for enums.
kono
parents:
diff changeset
34
kono
parents:
diff changeset
35 2012-12-11 Marc Glisse <marc.glisse@inria.fr>
kono
parents:
diff changeset
36
kono
parents:
diff changeset
37 PR c++/53094
kono
parents:
diff changeset
38 * tree.c (cp_tree_equal): Handle VECTOR_CST.
kono
parents:
diff changeset
39 * semantics.c (cxx_eval_bare_aggregate): Protect a dereference.
kono
parents:
diff changeset
40 Handle VECTOR_CST.
kono
parents:
diff changeset
41
kono
parents:
diff changeset
42 2012-12-11 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
43
kono
parents:
diff changeset
44 PR c++/55643
kono
parents:
diff changeset
45 * expr.c (mark_exp_read): Handle FLOAT_EXPR similarly to NOP_EXPR.
kono
parents:
diff changeset
46
kono
parents:
diff changeset
47 2012-12-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
48
kono
parents:
diff changeset
49 PR c++/54416
kono
parents:
diff changeset
50 * pt.c (maybe_process_partial_specialization): Don't accept
kono
parents:
diff changeset
51 definition of a specialization without the appropriate header.
kono
parents:
diff changeset
52
kono
parents:
diff changeset
53 * pt.c (maybe_process_partial_specialization): Handle aliases first.
kono
parents:
diff changeset
54
kono
parents:
diff changeset
55 2012-12-11 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
56
kono
parents:
diff changeset
57 PR c++/55619
kono
parents:
diff changeset
58 * semantics.c (finish_asm_stmt): Don't call decay_conversion
kono
parents:
diff changeset
59 on input operands that can be only in memory.
kono
parents:
diff changeset
60
kono
parents:
diff changeset
61 2012-12-10 Eric Botcazou <ebotcazou@adacore.com>
kono
parents:
diff changeset
62
kono
parents:
diff changeset
63 * Make-lang.in (cp/typeck.o): Add dependency on $(PARAMS_H).
kono
parents:
diff changeset
64 (cp/name-lookup.o): Likewise.
kono
parents:
diff changeset
65
kono
parents:
diff changeset
66 2012-12-10 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
67
kono
parents:
diff changeset
68 * decl2.c (cp_write_global_declarations): Return after writing a PCH.
kono
parents:
diff changeset
69
kono
parents:
diff changeset
70 2012-12-07 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
71
kono
parents:
diff changeset
72 PR c++/55127
kono
parents:
diff changeset
73 * search.c (accessible_in_template_p): New.
kono
parents:
diff changeset
74 * cp-tree.h: Declare it.
kono
parents:
diff changeset
75 * pt.c (instantiation_dependent_scope_ref_p): New.
kono
parents:
diff changeset
76 (value_dependent_expression_p): Use it.
kono
parents:
diff changeset
77 (instantiation_dependent_r): Likewise.
kono
parents:
diff changeset
78 * semantics.c (finish_decltype_type): Handle SCOPE_REF.
kono
parents:
diff changeset
79
kono
parents:
diff changeset
80 PR c++/55419
kono
parents:
diff changeset
81 * tree.c (build_target_expr): Don't set TREE_CONSTANT.
kono
parents:
diff changeset
82
kono
parents:
diff changeset
83 2012-12-07 Aldy Hernandez <aldyh@redhat.com>
kono
parents:
diff changeset
84
kono
parents:
diff changeset
85 PR c++/55513
kono
parents:
diff changeset
86 * semantics.c (cxx_eval_builtin_function_call): Set non_constant_p
kono
parents:
diff changeset
87 after folding.
kono
parents:
diff changeset
88
kono
parents:
diff changeset
89 2012-12-07 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
90
kono
parents:
diff changeset
91 * tree.c (build_aggr_init_expr): Remove tsubst_flags_t parameter.
kono
parents:
diff changeset
92 (build_cplus_new): Adjust.
kono
parents:
diff changeset
93 * cp-tree.h: Adjust declaration.
kono
parents:
diff changeset
94 * init.c (build_value_init): Adjust.
kono
parents:
diff changeset
95
kono
parents:
diff changeset
96 2012-12-07 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
97
kono
parents:
diff changeset
98 PR c++/54401
kono
parents:
diff changeset
99 * parser.c (cp_parser_alias_declaration): Commit to tentative
kono
parents:
diff changeset
100 parse when see the '=' token. Get out if the type-id is invalid.
kono
parents:
diff changeset
101 Update function comment.
kono
parents:
diff changeset
102 (cp_parser_member_declaration): Don't try to parse a using
kono
parents:
diff changeset
103 declaration if we know that we expected an alias declaration; that
kono
parents:
diff changeset
104 is, if we see the '=' token after the identifier.
kono
parents:
diff changeset
105
kono
parents:
diff changeset
106 2012-12-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
107
kono
parents:
diff changeset
108 PR c++/54325
kono
parents:
diff changeset
109 * tree.c (build_aggr_init_expr): Don't check for abstract class.
kono
parents:
diff changeset
110 (build_cplus_new): Check here instead.
kono
parents:
diff changeset
111
kono
parents:
diff changeset
112 PR c++/55058
kono
parents:
diff changeset
113 * pt.c (tsubst): Keep the quals when looking through a typedef.
kono
parents:
diff changeset
114
kono
parents:
diff changeset
115 PR c++/55249
kono
parents:
diff changeset
116 * tree.c (build_vec_init_elt): Use the type of the initializer.
kono
parents:
diff changeset
117
kono
parents:
diff changeset
118 PR c++/54744
kono
parents:
diff changeset
119 * pt.c (resolve_typename_type): Check TYPENAME_IS_RESOLVING_P on scope.
kono
parents:
diff changeset
120 * init.c (expand_member_init): Check for being in a template first.
kono
parents:
diff changeset
121 * parser.c (cp_parser_mem_initializer_list): Only check class types
kono
parents:
diff changeset
122 for equivalence to the current class.
kono
parents:
diff changeset
123
kono
parents:
diff changeset
124 PR c++/54913
kono
parents:
diff changeset
125 * semantics.c (finish_qualified_id_expr): convert_from_reference
kono
parents:
diff changeset
126 after building a SCOPE_REF.
kono
parents:
diff changeset
127
kono
parents:
diff changeset
128 2012-12-06 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
129
kono
parents:
diff changeset
130 PR c++/54207
kono
parents:
diff changeset
131 * except.c (build_noexcept_spec): Avoid direct comparison
kono
parents:
diff changeset
132 with boolean_true_node or boolean_false_node, instead use
kono
parents:
diff changeset
133 operand_equal_p and/or INTEGER_CST check.
kono
parents:
diff changeset
134 * pt.c (tsubst_exception_specification): Likewise.
kono
parents:
diff changeset
135 * typeck2.c (merge_exception_specifiers): Likewise.
kono
parents:
diff changeset
136
kono
parents:
diff changeset
137 2012-12-06 Marc Glisse <marc.glisse@inria.fr>
kono
parents:
diff changeset
138
kono
parents:
diff changeset
139 PR c++/55573
kono
parents:
diff changeset
140 * semantics.c (adjust_temp_type): Handle VECTOR_CST.
kono
parents:
diff changeset
141
kono
parents:
diff changeset
142 2012-12-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
143
kono
parents:
diff changeset
144 PR c++/54947
kono
parents:
diff changeset
145 * parser.c (cp_parser_initializer_list): Don't require an
kono
parents:
diff changeset
146 expression in [] to be constant until we know it's a C99
kono
parents:
diff changeset
147 designator.
kono
parents:
diff changeset
148
kono
parents:
diff changeset
149 PR c++/55015
kono
parents:
diff changeset
150 PR c++/53821
kono
parents:
diff changeset
151 * semantics.c (maybe_add_lambda_conv_op): Revert earlier change.
kono
parents:
diff changeset
152 * decl.c (start_preparsed_function): Make local class methods comdat
kono
parents:
diff changeset
153 in templates, too.
kono
parents:
diff changeset
154
kono
parents:
diff changeset
155 PR c++/54653
kono
parents:
diff changeset
156 * parser.c (cp_parser_class_head): A partial specialization scope
kono
parents:
diff changeset
157 counts as a template.
kono
parents:
diff changeset
158 * pt.c (tsubst_template_parms): Handle template template parm parms.
kono
parents:
diff changeset
159 (tsubst_decl) [TEMPLATE_DECL]: Handle getting a template template
kono
parents:
diff changeset
160 argument back.
kono
parents:
diff changeset
161
kono
parents:
diff changeset
162 PR c++/55564
kono
parents:
diff changeset
163 * pt.c (unify) [ARRAY_TYPE]: Unify the element type before the bounds.
kono
parents:
diff changeset
164
kono
parents:
diff changeset
165 2012-12-03 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
166
kono
parents:
diff changeset
167 PR c++/54170
kono
parents:
diff changeset
168 * cvt.c (cp_convert_to_pointer): Don't discard side-effects from
kono
parents:
diff changeset
169 expressions of nullptr_t.
kono
parents:
diff changeset
170 * typeck.c (build_ptrmemfunc): Likewise.
kono
parents:
diff changeset
171
kono
parents:
diff changeset
172 2012-12-01 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
173
kono
parents:
diff changeset
174 PR c++/55542
kono
parents:
diff changeset
175 * pt.c (make_ith_pack_parameter_name): Return NULL if
kono
parents:
diff changeset
176 name is NULL.
kono
parents:
diff changeset
177 (tsubst_decl): Call make_ith_pack_parameter_name even if
kono
parents:
diff changeset
178 DECL_NAME is NULL.
kono
parents:
diff changeset
179
kono
parents:
diff changeset
180 2012-11-29 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
181
kono
parents:
diff changeset
182 PR c++/53137
kono
parents:
diff changeset
183 * pt.c (tsubst_expr) [DECL_EXPR]: Set LAMBDA_EXPR_THIS_CAPTURE here.
kono
parents:
diff changeset
184 (tsubst_copy_and_build) [LAMBDA_EXPR]: And clear it here.
kono
parents:
diff changeset
185 (instantiate_class_template_1): Not here.
kono
parents:
diff changeset
186
kono
parents:
diff changeset
187 2012-11-29 Marc Glisse <marc.glisse@inria.fr>
kono
parents:
diff changeset
188
kono
parents:
diff changeset
189 PR c++/53094
kono
parents:
diff changeset
190 * cvt.c (ocp_convert): Call convert_to_vector.
kono
parents:
diff changeset
191
kono
parents:
diff changeset
192 2012-11-29 Kai Tietz <ktietz@redhat.com>
kono
parents:
diff changeset
193
kono
parents:
diff changeset
194 PR target/53912
kono
parents:
diff changeset
195 * class.c (dump_class_hierarchy_r): Cast from pointer via uintptr_t.
kono
parents:
diff changeset
196 (dump_vtable): Likewise.
kono
parents:
diff changeset
197
kono
parents:
diff changeset
198 2012-11-29 Ed Smith-Rowland <3dw4rd@verizon.net>
kono
parents:
diff changeset
199
kono
parents:
diff changeset
200 PR c++/52654
kono
parents:
diff changeset
201 * parser.c (cp_parser_string_literal): Add overflow_type arg.
kono
parents:
diff changeset
202 (cp_parser_userdef_numeric_literal): Warn on numeric overflow.
kono
parents:
diff changeset
203
kono
parents:
diff changeset
204 2012-11-28 Andrew Pinski <apinski@cavium.com>
kono
parents:
diff changeset
205
kono
parents:
diff changeset
206 PR bootstrap/54279
kono
parents:
diff changeset
207 * Make-lang.in (g++$(exeext)): Rename to
kono
parents:
diff changeset
208 (xg++$(exeext)): This.
kono
parents:
diff changeset
209 (g++-cross$(exeext)): Use xg++$(exeext) instead of g++$(exeext).
kono
parents:
diff changeset
210 (c++.start.encap): Likewise.
kono
parents:
diff changeset
211 (c++.install-common): Likewise.
kono
parents:
diff changeset
212
kono
parents:
diff changeset
213 2012-11-24 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
214
kono
parents:
diff changeset
215 PR c++/55446
kono
parents:
diff changeset
216 * init.c (build_vec_init): Do not early return error_mark_mode
kono
parents:
diff changeset
217 when integer_all_onesp (maxindex).
kono
parents:
diff changeset
218
kono
parents:
diff changeset
219 2012-11-23 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
220
kono
parents:
diff changeset
221 PR c++/54046
kono
parents:
diff changeset
222 * cp-objcp-common.h (LANG_HOOKS_BLOCK_MAY_FALLTHRU): Redefine.
kono
parents:
diff changeset
223 * cp-objcp-common.c (cxx_block_may_fallthru): New function.
kono
parents:
diff changeset
224 * cp-tree.h (cxx_block_may_fallthru): New prototype.
kono
parents:
diff changeset
225
kono
parents:
diff changeset
226 2012-11-23 Markus Trippelsdorf <markus@trippelsdorf.de>
kono
parents:
diff changeset
227
kono
parents:
diff changeset
228 PR c++/55418
kono
parents:
diff changeset
229 * method.c (implicitly_declare_fn): Properly initialize trivial_p.
kono
parents:
diff changeset
230
kono
parents:
diff changeset
231 2012-11-22 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
232
kono
parents:
diff changeset
233 PR c++/55137
kono
parents:
diff changeset
234 * semantics.c (verify_constant): Track overflow separately.
kono
parents:
diff changeset
235 (reduced_constant_expression_p): Don't check it here.
kono
parents:
diff changeset
236 (cxx_eval_constant_expression): Check it on CSTs.
kono
parents:
diff changeset
237 (cxx_eval_outermost_constant_expr): Treat overflows as non-constant
kono
parents:
diff changeset
238 at this point, but still return the folded version.
kono
parents:
diff changeset
239 (potential_constant_expression_1): Don't check overflow.
kono
parents:
diff changeset
240
kono
parents:
diff changeset
241 * call.c (extend_ref_init_temps_1): Recompute TREE_CONSTANT for
kono
parents:
diff changeset
242 the ADDR_EXPR.
kono
parents:
diff changeset
243
kono
parents:
diff changeset
244 2012-11-20 Diego Novillo <dnovillo@google.com>
kono
parents:
diff changeset
245 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
246
kono
parents:
diff changeset
247 * name-lookup.c: Replace all vec<T, A>() initializers
kono
parents:
diff changeset
248 with vNULL.
kono
parents:
diff changeset
249 * semantics.c: Likewise.
kono
parents:
diff changeset
250
kono
parents:
diff changeset
251 2012-11-19 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
252
kono
parents:
diff changeset
253 PR c++/55368
kono
parents:
diff changeset
254 * parser.c (cp_parser_member_declaration): Emit an error in case
kono
parents:
diff changeset
255 of stray comma at end of member declaration.
kono
parents:
diff changeset
256
kono
parents:
diff changeset
257 2012-11-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
258
kono
parents:
diff changeset
259 * class.c (one_inheriting_sig): Don't inherit base copy ctors.
kono
parents:
diff changeset
260
kono
parents:
diff changeset
261 PR c++/55262
kono
parents:
diff changeset
262 * method.c (implicitly_declare_fn): Set DECL_PARM_INDEX on
kono
parents:
diff changeset
263 the parms of an inheriting ctor.
kono
parents:
diff changeset
264
kono
parents:
diff changeset
265 PR c++/55261
kono
parents:
diff changeset
266 * class.c (add_implicitly_declared_members): Use
kono
parents:
diff changeset
267 lookup_fnfields_slot to get the base constructors.
kono
parents:
diff changeset
268
kono
parents:
diff changeset
269 2012-11-19 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
270
kono
parents:
diff changeset
271 PR middle-end/54630
kono
parents:
diff changeset
272 * class.c (fixed_type_or_null_ref_ht): New variable.
kono
parents:
diff changeset
273 (fixed_type_or_null): Use it instead of local static ht.
kono
parents:
diff changeset
274
kono
parents:
diff changeset
275 2012-11-17 Diego Novillo <dnovillo@google.com>
kono
parents:
diff changeset
276
kono
parents:
diff changeset
277 Adjust for new vec API (http://gcc.gnu.org/wiki/cxx-conversion/cxx-vec)
kono
parents:
diff changeset
278
kono
parents:
diff changeset
279 * Make-lang.in: Remove dependencies on vecir.h and vecprim.h everywhere.
kono
parents:
diff changeset
280 * call.c: Use new vec API in vec.h.
kono
parents:
diff changeset
281 * class.c: Likewise.
kono
parents:
diff changeset
282 * cp-gimplify.c: Likewise.
kono
parents:
diff changeset
283 * cp-tree.h: Likewise.
kono
parents:
diff changeset
284 * cvt.c: Likewise.
kono
parents:
diff changeset
285 * decl.c: Likewise.
kono
parents:
diff changeset
286 * decl2.c: Likewise.
kono
parents:
diff changeset
287 * error.c: Likewise.
kono
parents:
diff changeset
288 * except.c: Likewise.
kono
parents:
diff changeset
289 * init.c: Likewise.
kono
parents:
diff changeset
290 * mangle.c: Likewise.
kono
parents:
diff changeset
291 * method.c: Likewise.
kono
parents:
diff changeset
292 * name-lookup.c: Likewise.
kono
parents:
diff changeset
293 * name-lookup.h: Likewise.
kono
parents:
diff changeset
294 * parser.c: Likewise.
kono
parents:
diff changeset
295 * parser.h: Likewise.
kono
parents:
diff changeset
296 * pt.c: Likewise.
kono
parents:
diff changeset
297 * repo.c: Likewise.
kono
parents:
diff changeset
298 * rtti.c: Likewise.
kono
parents:
diff changeset
299 * search.c: Likewise.
kono
parents:
diff changeset
300 * semantics.c: Likewise.
kono
parents:
diff changeset
301 * tree.c: Likewise.
kono
parents:
diff changeset
302 * typeck.c: Likewise.
kono
parents:
diff changeset
303 * typeck2.c: Likewise.
kono
parents:
diff changeset
304
kono
parents:
diff changeset
305 2012-11-17 Gabriel Dos Reis <gdr@integrable-solutions.net>
kono
parents:
diff changeset
306
kono
parents:
diff changeset
307 * semantics.c (finish_id_expression): Tidy diagnostic message.
kono
parents:
diff changeset
308
kono
parents:
diff changeset
309 2012-11-16 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
310
kono
parents:
diff changeset
311 PR c++/54875
kono
parents:
diff changeset
312 * pt.c (lookup_template_class_1): Look at the type of the
kono
parents:
diff changeset
313 potential member enum of class template to determine if we are
kono
parents:
diff changeset
314 actually substituting into a member enum of class template.
kono
parents:
diff changeset
315
kono
parents:
diff changeset
316 2012-11-16 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
317
kono
parents:
diff changeset
318 PR c++/55337
kono
parents:
diff changeset
319 * tree.c (cp_tree_equal) <case ALIGNOF_EXPR>: Use SIZEOF_EXPR_TYPE_P
kono
parents:
diff changeset
320 only on SIZEOF_EXPR.
kono
parents:
diff changeset
321
kono
parents:
diff changeset
322 2012-11-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
323
kono
parents:
diff changeset
324 PR c++/54903
kono
parents:
diff changeset
325 * decl2.c (mark_used): Don't complain about auto in templates.
kono
parents:
diff changeset
326
kono
parents:
diff changeset
327 PR c++/37276
kono
parents:
diff changeset
328 * decl.c (decls_match): Remove #ifdef around earlier fix.
kono
parents:
diff changeset
329
kono
parents:
diff changeset
330 2012-11-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
331
kono
parents:
diff changeset
332 * class.c (finish_struct_1): Check virtual functions
kono
parents:
diff changeset
333 for missing ABI tags.
kono
parents:
diff changeset
334
kono
parents:
diff changeset
335 PR c++/55275
kono
parents:
diff changeset
336 * pt.c (maybe_process_partial_specialization): Update
kono
parents:
diff changeset
337 DECL_SOURCE_LOCATION for new specializations.
kono
parents:
diff changeset
338
kono
parents:
diff changeset
339 2012-11-14 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
340
kono
parents:
diff changeset
341 PR c++/55323
kono
parents:
diff changeset
342 * init.c (emit_mem_initializers): Skip arguments == error_mark_node.
kono
parents:
diff changeset
343
kono
parents:
diff changeset
344 2012-11-14 Fabien ChĂȘne <fabien@gcc.gnu.org>
kono
parents:
diff changeset
345
kono
parents:
diff changeset
346 PR c++/11750
kono
parents:
diff changeset
347 * call.c (build_new_method_call_1): Check that the instance type
kono
parents:
diff changeset
348 and the function context are the same before setting the flag
kono
parents:
diff changeset
349 LOOKUP_NONVIRTUAL.
kono
parents:
diff changeset
350
kono
parents:
diff changeset
351 2012-11-13 Sriraman Tallam <tmsriram@google.com>
kono
parents:
diff changeset
352
kono
parents:
diff changeset
353 * class.c (mark_versions_used): Remove.
kono
parents:
diff changeset
354 (resolve_address_of_overloaded_function): Call target hook
kono
parents:
diff changeset
355 for versioned functions. Refactor to call
kono
parents:
diff changeset
356 get_function_versions_dispatcher.
kono
parents:
diff changeset
357 * decl.c (duplicate_decls): Add comments.
kono
parents:
diff changeset
358 * cp/call.c (get_function_version_dispatcher): Expose function.
kono
parents:
diff changeset
359 (mark_versions_used): Expose function.
kono
parents:
diff changeset
360 * cp/cp-tree.h (mark_versions_used): New declaration.
kono
parents:
diff changeset
361 (get_function_version_dispatcher): Ditto.
kono
parents:
diff changeset
362
kono
parents:
diff changeset
363 2012-11-13 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
364
kono
parents:
diff changeset
365 PR c++/54466
kono
parents:
diff changeset
366 * pt.c (lookup_template_class_1): TYPE_STUB_DECL should be
kono
parents:
diff changeset
367 accessed on the main variant of the type.
kono
parents:
diff changeset
368
kono
parents:
diff changeset
369 2012-11-12 Ed Smith-Rowland <3dw4rd@verizon.net>
kono
parents:
diff changeset
370
kono
parents:
diff changeset
371 * parser.c (cp_parser_objc_class_ivars):
kono
parents:
diff changeset
372 Index declspecs.locations by ds_typedef rather than ds_thread.
kono
parents:
diff changeset
373
kono
parents:
diff changeset
374 2012-11-09 Ed Smith-Rowland <3dw4rd@verizon.net>
kono
parents:
diff changeset
375
kono
parents:
diff changeset
376 PR c++/54413
kono
parents:
diff changeset
377 * decl.c (grokfndecl): Adjust calls to interpret_x_suffix.
kono
parents:
diff changeset
378
kono
parents:
diff changeset
379 2012-11-09 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
380
kono
parents:
diff changeset
381 PR c++/54859
kono
parents:
diff changeset
382 * pt.c (check_instantiated_arg): Don't complain about dependent args.
kono
parents:
diff changeset
383
kono
parents:
diff changeset
384 * tree.c (cxx_attribute_table): Add abi_tag attribute.
kono
parents:
diff changeset
385 (check_abi_tag_redeclaration, handle_abi_tag_attribute): New.
kono
parents:
diff changeset
386 * class.c (find_abi_tags_r, check_abi_tags): New.
kono
parents:
diff changeset
387 (check_bases, check_field_decl): Call check_abi_tags.
kono
parents:
diff changeset
388 * decl.c (redeclaration_error_message): Call
kono
parents:
diff changeset
389 check_abi_tag_redeclaration.
kono
parents:
diff changeset
390 * mangle.c (tree_string_cmp, write_abi_tags): New.
kono
parents:
diff changeset
391 (write_unqualified_name): Call write_abi_tags.
kono
parents:
diff changeset
392
kono
parents:
diff changeset
393 2012-11-07 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
394
kono
parents:
diff changeset
395 PR c++/55226
kono
parents:
diff changeset
396 Revert:
kono
parents:
diff changeset
397 2012-10-23 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
398
kono
parents:
diff changeset
399 PR c++/54922
kono
parents:
diff changeset
400 * semantics.c (cx_check_missing_mem_inits): Handle anonymous union
kono
parents:
diff changeset
401 members.
kono
parents:
diff changeset
402
kono
parents:
diff changeset
403 2012-11-07 Florian Weimer <fweimer@redhat.com>
kono
parents:
diff changeset
404
kono
parents:
diff changeset
405 * init.c (build_new_1): Do not check for arithmetic overflow if
kono
parents:
diff changeset
406 inner array size is 1.
kono
parents:
diff changeset
407
kono
parents:
diff changeset
408 2012-11-05 Sriraman Tallam <tmsriram@google.com>
kono
parents:
diff changeset
409
kono
parents:
diff changeset
410 * class.c (add_method): Change assembler names of function versions.
kono
parents:
diff changeset
411 (mark_versions_used): New static function.
kono
parents:
diff changeset
412 (resolve_address_of_overloaded_function): Create dispatcher decl and
kono
parents:
diff changeset
413 return address of dispatcher instead.
kono
parents:
diff changeset
414 * decl.c (decls_match): Make decls unmatched for versioned
kono
parents:
diff changeset
415 functions.
kono
parents:
diff changeset
416 (duplicate_decls): Remove ambiguity for versioned functions.
kono
parents:
diff changeset
417 Delete versioned function data for merged decls.
kono
parents:
diff changeset
418 * decl2.c (check_classfn): Check attributes of versioned functions
kono
parents:
diff changeset
419 for match.
kono
parents:
diff changeset
420 * call.c (get_function_version_dispatcher): New function.
kono
parents:
diff changeset
421 (mark_versions_used): New static function.
kono
parents:
diff changeset
422 (build_over_call): Make calls to multiversioned functions
kono
parents:
diff changeset
423 to call the dispatcher.
kono
parents:
diff changeset
424 (joust): For calls to multi-versioned functions, make the most
kono
parents:
diff changeset
425 specialized function version win.
kono
parents:
diff changeset
426
kono
parents:
diff changeset
427 2012-10-31 Lawrence Crowl <crowl@google.com>
kono
parents:
diff changeset
428
kono
parents:
diff changeset
429 * decl2.c (var_finalized_p): Rename varpool_node to
kono
parents:
diff changeset
430 varpool_node_for_decl.
kono
parents:
diff changeset
431 (maybe_emit_vtables): Likewise.
kono
parents:
diff changeset
432
kono
parents:
diff changeset
433 2012-10-31 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
434
kono
parents:
diff changeset
435 PR c++/54583
kono
parents:
diff changeset
436 * tree.c (build_cplus_array_type): Set TREE_NO_WARNING on the
kono
parents:
diff changeset
437 TYPE_SIZE of VLAs.
kono
parents:
diff changeset
438
kono
parents:
diff changeset
439 2012-10-31 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
440
kono
parents:
diff changeset
441 PR c++/54955
kono
parents:
diff changeset
442 * parser.c (cp_nth_tokens_can_be_std_attribute_p): Recognize the
kono
parents:
diff changeset
443 'Alignas' keyword as the beginning of a c++11 attribute specifier.
kono
parents:
diff changeset
444 Update the comment of the function.
kono
parents:
diff changeset
445 (cp_next_tokens_can_be_gnu_attribute_p): Update the comment of the
kono
parents:
diff changeset
446 function.
kono
parents:
diff changeset
447
kono
parents:
diff changeset
448 2012-10-29 Jonathan Wakely <jwakely.gcc@gmail.com>
kono
parents:
diff changeset
449
kono
parents:
diff changeset
450 PR c++/54930
kono
parents:
diff changeset
451 * typeck.c (maybe_warn_about_returning_address_of_local): Use
kono
parents:
diff changeset
452 OPT_Wreturn_local_addr.
kono
parents:
diff changeset
453
kono
parents:
diff changeset
454 2012-10-26 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
455
kono
parents:
diff changeset
456 PR c++/55081
kono
parents:
diff changeset
457 * typeck2.c (store_init_value): Call fold_non_dependent_expr
kono
parents:
diff changeset
458 and maybe_constant_init even for C++98.
kono
parents:
diff changeset
459
kono
parents:
diff changeset
460 2012-10-26 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
461
kono
parents:
diff changeset
462 PR c++/54984
kono
parents:
diff changeset
463 * init.c (build_new): Don't turn a null *init into a pointer to
kono
parents:
diff changeset
464 empty vector orig_init.
kono
parents:
diff changeset
465
kono
parents:
diff changeset
466 2012-10-25 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
467
kono
parents:
diff changeset
468 PR c++/53761
kono
parents:
diff changeset
469 * class.c (finish_struct_1): Reject aggregates decorated with
kono
parents:
diff changeset
470 __transparent_union__ which cannot be made transparent because
kono
parents:
diff changeset
471 the type of the first field has a different ABI from the class
kono
parents:
diff changeset
472 overall.
kono
parents:
diff changeset
473
kono
parents:
diff changeset
474 2012-10-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
475
kono
parents:
diff changeset
476 Core 1402
kono
parents:
diff changeset
477 * call.c (joust): An implicitly deleted move function is
kono
parents:
diff changeset
478 worse than any non-deleted function.
kono
parents:
diff changeset
479 * method.c (process_subob_fn): No special rules for move.
kono
parents:
diff changeset
480 (synthesized_method_walk, implicitly_declare_fn): Likewise.
kono
parents:
diff changeset
481 Warn about virtual base with non-trivial move assignment.
kono
parents:
diff changeset
482 * cp-tree.h (struct lang_decl_fn): Remove suppress_implicit_decl.
kono
parents:
diff changeset
483 (FNDECL_SUPPRESS_IMPLICIT_DECL): Remove.
kono
parents:
diff changeset
484
kono
parents:
diff changeset
485 * semantics.c (finish_omp_threadprivate): Call complete_type.
kono
parents:
diff changeset
486
kono
parents:
diff changeset
487 * class.c (one_inherited_ctor): Warn about variadic inherited ctor.
kono
parents:
diff changeset
488
kono
parents:
diff changeset
489 2012-10-25 Marc Glisse <marc.glisse@inria.fr>
kono
parents:
diff changeset
490
kono
parents:
diff changeset
491 PR c++/54427
kono
parents:
diff changeset
492 * typeck.c (build_x_conditional_expr): Handle VEC_COND_EXPR.
kono
parents:
diff changeset
493 * call.c (build_conditional_expr_1): Likewise.
kono
parents:
diff changeset
494
kono
parents:
diff changeset
495 2012-10-25 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
496
kono
parents:
diff changeset
497 PR c++/34892
kono
parents:
diff changeset
498 * parser.c (cp_parser_template_parameter): When
kono
parents:
diff changeset
499 cp_parser_parameter_declaration parsed a default argument don't
kono
parents:
diff changeset
500 see if *is_parameter_pack needs setting.
kono
parents:
diff changeset
501
kono
parents:
diff changeset
502 2012-10-23 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
503
kono
parents:
diff changeset
504 PR c++/54922
kono
parents:
diff changeset
505 * semantics.c (cx_check_missing_mem_inits): Handle anonymous union
kono
parents:
diff changeset
506 members.
kono
parents:
diff changeset
507
kono
parents:
diff changeset
508 2012-10-23 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
509
kono
parents:
diff changeset
510 PR c++/54844
kono
parents:
diff changeset
511 * pt.c (tsubst_copy, tsubst_copy_and_build) <case SIZEOF_EXPR>: Use
kono
parents:
diff changeset
512 tsubst instead of tsubst_copy* on types.
kono
parents:
diff changeset
513
kono
parents:
diff changeset
514 PR c++/54988
kono
parents:
diff changeset
515 * decl2.c (cplus_decl_attributes): Don't return early
kono
parents:
diff changeset
516 if attributes is NULL.
kono
parents:
diff changeset
517
kono
parents:
diff changeset
518 2012-10-18 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
519
kono
parents:
diff changeset
520 PR c++/54501
kono
parents:
diff changeset
521 * decl.c (reshape_init_array_1): Avoid infinite loops.
kono
parents:
diff changeset
522
kono
parents:
diff changeset
523 2012-10-15 Alexandre Oliva <aoliva@redhat.com>
kono
parents:
diff changeset
524 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
525
kono
parents:
diff changeset
526 PR c++/17805
kono
parents:
diff changeset
527 * call.c (build_new_op_1): Filter out operator functions that don't
kono
parents:
diff changeset
528 satisfy enum-conversion match requirements.
kono
parents:
diff changeset
529
kono
parents:
diff changeset
530 2012-10-15 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
531
kono
parents:
diff changeset
532 PR c++/50080 (again)
kono
parents:
diff changeset
533 * parser.c (cp_parser_optional_template_keyword): When -pedantic
kono
parents:
diff changeset
534 and C++98 mode restore pre-Core/468 behavior.
kono
parents:
diff changeset
535
kono
parents:
diff changeset
536 2012-10-15 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
537
kono
parents:
diff changeset
538 PR c++/50080
kono
parents:
diff changeset
539 * parser.c (cp_parser_optional_template_keyword): Implement
kono
parents:
diff changeset
540 Core/468, allow outside template.
kono
parents:
diff changeset
541
kono
parents:
diff changeset
542 2012-10-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
543 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
544
kono
parents:
diff changeset
545 Implement C++11 inheriting constructors.
kono
parents:
diff changeset
546 * cp-tree.h (cpp0x_warn_str): Add CPP0X_INHERITING_CTORS.
kono
parents:
diff changeset
547 (DECL_INHERITED_CTOR_BASE, SET_DECL_INHERITED_CTOR_BASE): New.
kono
parents:
diff changeset
548 (special_function_kind): Add sfk_inheriting_constructor.
kono
parents:
diff changeset
549 * class.c (add_method): An inheriting ctor is hidden by a
kono
parents:
diff changeset
550 user-declared one.
kono
parents:
diff changeset
551 (one_inheriting_sig, one_inherited_ctor): New.
kono
parents:
diff changeset
552 (add_implicitly_declared_members): Handle inheriting ctors.
kono
parents:
diff changeset
553 * error.c (maybe_warn_cpp0x): Handle CPP0X_INHERITING_CTORS.
kono
parents:
diff changeset
554 * init.c (emit_mem_initializers): Don't set LOOKUP_DEFAULTED
kono
parents:
diff changeset
555 for an inheriting constructor.
kono
parents:
diff changeset
556 * method.c (type_has_trivial_fn): Handle sfk_inheriting_constructor.
kono
parents:
diff changeset
557 (type_set_nontrivial_flag): Likewise.
kono
parents:
diff changeset
558 (add_one_base_init): Split out from...
kono
parents:
diff changeset
559 (do_build_copy_constructor): ...here. Handle inheriting constructors.
kono
parents:
diff changeset
560 (locate_fn_flags): Handle a list of arg types.
kono
parents:
diff changeset
561 (synthesized_method_walk): Handle inheriting constructors.
kono
parents:
diff changeset
562 (maybe_explain_implicit_delete): Likewise.
kono
parents:
diff changeset
563 (deduce_inheriting_ctor): New.
kono
parents:
diff changeset
564 (implicitly_declare_fn): Handle inheriting constructors.
kono
parents:
diff changeset
565 * name-lookup.c (push_class_level_binding_1): An inheriting constructor
kono
parents:
diff changeset
566 does not declare the base's name.
kono
parents:
diff changeset
567 (do_class_using_decl): Allow inheriting constructors.
kono
parents:
diff changeset
568 * pt.c (template_parms_to_args): Split from current_template_args.
kono
parents:
diff changeset
569 (add_inherited_template_parms): New.
kono
parents:
diff changeset
570 (tsubst_decl): Handle inheriting constructors.
kono
parents:
diff changeset
571 * tree.c (special_function_p): Handle inheriting constructors.
kono
parents:
diff changeset
572
kono
parents:
diff changeset
573 2012-10-12 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
574
kono
parents:
diff changeset
575 PR c/54381
kono
parents:
diff changeset
576 * semantics.c (finish_call_expr): Pass array of 3 sizeof_arg
kono
parents:
diff changeset
577 trees and locs (corresponding to first 3 arguments) to
kono
parents:
diff changeset
578 sizeof_pointer_memaccess_warning.
kono
parents:
diff changeset
579
kono
parents:
diff changeset
580 2012-10-12 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
581
kono
parents:
diff changeset
582 PR c++/24449
kono
parents:
diff changeset
583 * decl.c (grokfndecl): When checking for ::main declarations
kono
parents:
diff changeset
584 use PROCESSING_REAL_TEMPLATE_DECL_P().
kono
parents:
diff changeset
585
kono
parents:
diff changeset
586 2012-10-12 Marc Glisse <marc.glisse@inria.fr>
kono
parents:
diff changeset
587
kono
parents:
diff changeset
588 PR c++/53055
kono
parents:
diff changeset
589 * call.c (build_new_op_1): Pass RO_ARROW_STAR to cp_build_indirect_ref.
kono
parents:
diff changeset
590 * typeck.c (cp_build_indirect_ref): Handle RO_ARROW_STAR.
kono
parents:
diff changeset
591
kono
parents:
diff changeset
592 2012-10-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
593
kono
parents:
diff changeset
594 * cp-tree.h (DECL_THUNKS): NULL_TREE for non-virtual functions.
kono
parents:
diff changeset
595 (SET_DECL_THUNKS): New.
kono
parents:
diff changeset
596 * decl.c (duplicate_decls): Adjust.
kono
parents:
diff changeset
597 * method.c (make_thunk): Adjust.
kono
parents:
diff changeset
598
kono
parents:
diff changeset
599 * decl.c (grokdeclarator): Set DECL_GNU_TLS_P for static data
kono
parents:
diff changeset
600 members, too.
kono
parents:
diff changeset
601
kono
parents:
diff changeset
602 2012-10-09 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
603
kono
parents:
diff changeset
604 PR c++/53540 - using fails to be equivalent to typedef
kono
parents:
diff changeset
605 * cp-tree.h (TYPE_TEMPLATE_INFO): For an alias that is not an
kono
parents:
diff changeset
606 instance of alias template, don't look for its TEMPLATE_INFO in
kono
parents:
diff changeset
607 its declaration.
kono
parents:
diff changeset
608 (alias_template_specialization_p): Take const_tree.
kono
parents:
diff changeset
609 * pt.c (alias_template_specialization_p): Take a const_tree.
kono
parents:
diff changeset
610 Don't call primary_template_instantiation_p.
kono
parents:
diff changeset
611 (primary_template_instantiation_p): Call
kono
parents:
diff changeset
612 alias_template_specialization_p.
kono
parents:
diff changeset
613
kono
parents:
diff changeset
614 2012-10-10 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
615
kono
parents:
diff changeset
616 * parser (cp_parser_statement): Parse c++11 attributes
kono
parents:
diff changeset
617 tentatively.
kono
parents:
diff changeset
618 (cp_parser_std_attribute_spec_seq): Do not warn too early about
kono
parents:
diff changeset
619 using c++11 attributes in non c++11 mode.
kono
parents:
diff changeset
620
kono
parents:
diff changeset
621 2012-10-10 Dehao Chen <dehao@google.com>
kono
parents:
diff changeset
622
kono
parents:
diff changeset
623 * cp-gimplify.c (cp_genericize_r): Set location for TRY expr.
kono
parents:
diff changeset
624
kono
parents:
diff changeset
625 2012-10-09 Lawrence Crowl <crowl@google.com>
kono
parents:
diff changeset
626
kono
parents:
diff changeset
627 * Make-lang.in (class.o): Add dependence on hash-table.h.
kono
parents:
diff changeset
628 (tree.o): Likewise.
kono
parents:
diff changeset
629 (semantics.o): Likewise.
kono
parents:
diff changeset
630 * class.c (fixed_type_or_null): Change to new type-safe hash table.
kono
parents:
diff changeset
631 * tree.c (verify_stmt_tree): Likewise.
kono
parents:
diff changeset
632 (verify_stmt_tree_r): Likewise.
kono
parents:
diff changeset
633 * semantics.c (struct nrv_data): Likewise.
kono
parents:
diff changeset
634
kono
parents:
diff changeset
635 2012-10-09 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
636
kono
parents:
diff changeset
637 PR c++/54194
kono
parents:
diff changeset
638 * typeck.c (build_x_binary_op): Update warn_about_parentheses call.
kono
parents:
diff changeset
639 * parser.c (cp_parser_binary_expression): Use SET_EXPR_LOCATION
kono
parents:
diff changeset
640 on current.lhs.
kono
parents:
diff changeset
641
kono
parents:
diff changeset
642 2012-10-09 Marc Glisse <marc.glisse@inria.fr>
kono
parents:
diff changeset
643
kono
parents:
diff changeset
644 PR c++/54427
kono
parents:
diff changeset
645 * typeck.c (cp_build_binary_op): Handle mixed scalar-vector
kono
parents:
diff changeset
646 operations.
kono
parents:
diff changeset
647 [LSHIFT_EXPR, RSHIFT_EXPR]: Likewise.
kono
parents:
diff changeset
648
kono
parents:
diff changeset
649 2012-10-08 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
650
kono
parents:
diff changeset
651 PR c++/54858
kono
parents:
diff changeset
652 * tree.c (cp_tree_equal): Handle FIELD_DECL.
kono
parents:
diff changeset
653
kono
parents:
diff changeset
654 2012-10-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
655
kono
parents:
diff changeset
656 Allow dynamic initialization of thread_locals.
kono
parents:
diff changeset
657 * decl.c: Define tls_aggregates.
kono
parents:
diff changeset
658 (expand_static_init): Remove sorry. Add to tls_aggregates.
kono
parents:
diff changeset
659 * cp-tree.h: Declare tls_aggregates.
kono
parents:
diff changeset
660 * call.c (set_up_extended_ref_temp): Add to tls_aggregates.
kono
parents:
diff changeset
661 * decl2.c (var_needs_tls_wrapper): New.
kono
parents:
diff changeset
662 (var_defined_without_dynamic_init): New.
kono
parents:
diff changeset
663 (get_tls_init_fn, get_tls_wrapper_fn): New.
kono
parents:
diff changeset
664 (generate_tls_wrapper, handle_tls_init): New.
kono
parents:
diff changeset
665 (cp_write_global_declarations): Call handle_tls_init and
kono
parents:
diff changeset
666 enerate_tls_wrapper.
kono
parents:
diff changeset
667 * mangle.c (write_guarded_var_name): Split out from..
kono
parents:
diff changeset
668 (mangle_guard_variable): ...here.
kono
parents:
diff changeset
669 (mangle_tls_init_fn, mangle_tls_wrapper_fn): Use it.
kono
parents:
diff changeset
670 (decl_tls_wrapper_p): New.
kono
parents:
diff changeset
671 * semantics.c (finish_id_expression): Replace use of thread_local
kono
parents:
diff changeset
672 variable with a call to its wrapper.
kono
parents:
diff changeset
673
kono
parents:
diff changeset
674 * decl.c (get_thread_atexit_node): New.
kono
parents:
diff changeset
675 (register_dtor_fn): Use it for TLS.
kono
parents:
diff changeset
676
kono
parents:
diff changeset
677 Partial implementation of C++11 thread_local.
kono
parents:
diff changeset
678 * decl.c (cp_finish_decl): Remove errors about non-trivial
kono
parents:
diff changeset
679 initialization and destruction of TLS variables.
kono
parents:
diff changeset
680 (register_dtor_fn): Add sorry about TLS variables.
kono
parents:
diff changeset
681 (expand_static_init): Add sorry about non-local TLS variables,
kono
parents:
diff changeset
682 or error with __thread.
kono
parents:
diff changeset
683 Don't emit thread-safety guards for local TLS variables.
kono
parents:
diff changeset
684 (grokdeclarator): thread_local in a function implies static.
kono
parents:
diff changeset
685 * decl.h: Adjust prototype.
kono
parents:
diff changeset
686 * decl2.c (get_guard): Copy DECL_TLS_MODEL.
kono
parents:
diff changeset
687 * parser.c (cp_parser_set_storage_class, cp_parser_set_decl_spec_type)
kono
parents:
diff changeset
688 (set_and_check_decl_spec_loc): Take the token rather than the location.
kono
parents:
diff changeset
689 Distinguish between __thread and thread_local.
kono
parents:
diff changeset
690 (cp_parser_set_storage_class): Don't complain about thread_local before
kono
parents:
diff changeset
691 extern/static.
kono
parents:
diff changeset
692 (token_is__thread): New.
kono
parents:
diff changeset
693 * call.c (make_temporary_var_for_ref_to_temp): Handle TLS.
kono
parents:
diff changeset
694 * cp-tree.h (DECL_GNU_TLS_P): New.
kono
parents:
diff changeset
695 (cp_decl_specifier_seq): Add gnu_thread_keyword_p.
kono
parents:
diff changeset
696
kono
parents:
diff changeset
697 2012-10-08 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
698
kono
parents:
diff changeset
699 PR c++/53528 C++11 attribute support
kono
parents:
diff changeset
700 * cp-tree.h (enum cpp0x_warn_str::CPP0X_ATTRIBUTES): New member.
kono
parents:
diff changeset
701 (enum cp_decl_spec::ds_std_attribute): New enumerator.
kono
parents:
diff changeset
702 (struct cp_decl_specifier_seq::std_attributes): New field.
kono
parents:
diff changeset
703 (cxx_alignas_expr, warn_misplaced_attr_for_class_type): Declare
kono
parents:
diff changeset
704 new functions.
kono
parents:
diff changeset
705 (check_tag_decl): Take an extra parameter for explicit
kono
parents:
diff changeset
706 instantiations.
kono
parents:
diff changeset
707 * decl.c (warn_misplaced_attr_for_class_type): Extract from ...
kono
parents:
diff changeset
708 (check_tag_decl): ... here. Add check for c++11 attributes being
kono
parents:
diff changeset
709 applied to an explicit instantiation. Take an extra parameter for
kono
parents:
diff changeset
710 explicit instantiations.
kono
parents:
diff changeset
711 (grokdeclarator): Make sure a c++11 attribute after an array
kono
parents:
diff changeset
712 declarator appertains to the array, an attribute after a function
kono
parents:
diff changeset
713 declarator appertains to the function type, an attribute after a
kono
parents:
diff changeset
714 declarator-id appertains to the entity being declared, and an
kono
parents:
diff changeset
715 attribute after a pointer declarator appertain to the pointer.
kono
parents:
diff changeset
716 * decl2.c (is_late_template_attribute): Use get_attribute_name.
kono
parents:
diff changeset
717 * error.c (maybe_warn_cpp0x): Support
kono
parents:
diff changeset
718 CPP0X_GENERALIZED_ATTRIBUTES.
kono
parents:
diff changeset
719 * parser.c (cp_next_tokens_can_be_attribute_p)
kono
parents:
diff changeset
720 (cp_next_tokens_can_be_gnu_attribute_p)
kono
parents:
diff changeset
721 (cp_next_tokens_can_be_std_attribute_p)
kono
parents:
diff changeset
722 (cp_nth_tokens_can_be_attribute_p)
kono
parents:
diff changeset
723 (cp_nth_tokens_can_be_gnu_attribute_p)
kono
parents:
diff changeset
724 (cp_nth_tokens_can_be_std_attribute_p)
kono
parents:
diff changeset
725 (cp_parser_gnu_attribute_list, cp_parser_std_attribute)
kono
parents:
diff changeset
726 (cp_parser_std_attribute_spec, cp_parser_std_attribute_spec_seq)
kono
parents:
diff changeset
727 (cp_parser_attributes_opt, cp_parser_std_attribute_list): New
kono
parents:
diff changeset
728 static functions.
kono
parents:
diff changeset
729 (cp_parser_gnu_attributes_opt): Replace cp_parser_attributes_opt.
kono
parents:
diff changeset
730 (cp_parser_gnu_attribute_list): Replace cp_parser_attribute_list.
kono
parents:
diff changeset
731 (cp_parser_postfix_expression): Disallow "[[" tokens here.
kono
parents:
diff changeset
732 (cp_parser_label_for_labeled_statement): Use take an extra
kono
parents:
diff changeset
733 parameter for attributes.
kono
parents:
diff changeset
734 (cp_parser_block_declaration): Use
kono
parents:
diff changeset
735 cp_nth_tokens_can_be_std_attribute_p here.
kono
parents:
diff changeset
736 (cp_parser_decl_specifier_seq): Likewise. Store C++11 attributes
kono
parents:
diff changeset
737 that appears in in decl specifiers in cp_decl_specifier_seq::std_attributes.
kono
parents:
diff changeset
738 declaration. Emit proper warning about misplaced c++11 attributes
kono
parents:
diff changeset
739 for class type.
kono
parents:
diff changeset
740 (cp_parser_explicit_instantiation): Adjust call to check_tag_decl.
kono
parents:
diff changeset
741 (cp_parser_init_declarator): Parsing attributes here is no more a
kono
parents:
diff changeset
742 GNU extension in c++-11.
kono
parents:
diff changeset
743 (cp_parser_type_specifier_seq): Use
kono
parents:
diff changeset
744 cp_next_tokens_can_be_attribute_p.
kono
parents:
diff changeset
745 (cp_parser_direct_declarator): Likewise. Hang c++11 attributes
kono
parents:
diff changeset
746 following the declarator to its syntactic construct. It'll later
kono
parents:
diff changeset
747 be applied to the proper appertaining entity by grokdeclarator.
kono
parents:
diff changeset
748 (cp_parser_ptr_operator): Likewise.
kono
parents:
diff changeset
749 (make_declarator): Initialize cp_declarator::std_attribute.
kono
parents:
diff changeset
750 (make_pointer_declarator, make_reference_declarator)
kono
parents:
diff changeset
751 (make_ptrmem_declarator, cp_parser_make_indirect_declarator): Take
kono
parents:
diff changeset
752 attributes that appertain to the pointer/reference in argument.
kono
parents:
diff changeset
753 (cp_parser_ptr_operator): Take an out parameter for c++11
kono
parents:
diff changeset
754 attributes. Update comments.
kono
parents:
diff changeset
755 (cp_parser_new_declarator_opt)
kono
parents:
diff changeset
756 (cp_parser_conversion_declarator_opt): Adjust.
kono
parents:
diff changeset
757 (cp_parser_declarator): Likewise. Handle C++11 attributes.
kono
parents:
diff changeset
758 Rename attributes to gnu_attribute for better legibility.
kono
parents:
diff changeset
759 (cp_parser_simple_declaration): Update comment.
kono
parents:
diff changeset
760 (cp_parser_class_specifier_1): Parse GNU attributes specifically
kono
parents:
diff changeset
761 (cp_parser_enum_specifier): Accept only gnu attributes after the
kono
parents:
diff changeset
762 specifier.
kono
parents:
diff changeset
763 (cp_parser_member_declaration): Don't clear attributes -- intended
kono
parents:
diff changeset
764 for the entity being declared -- too early because check_tag_decl
kono
parents:
diff changeset
765 needs them.
kono
parents:
diff changeset
766 (cp_parser_statement): Update comment. Parse optional c++11
kono
parents:
diff changeset
767 attributes at the beginning of the relevant kind of statements and
kono
parents:
diff changeset
768 ignore them, for now, unless when calling
kono
parents:
diff changeset
769 cp_parser_label_for_labeled_statement.
kono
parents:
diff changeset
770 (cp_parser_label_for_labeled_statement): Take c++11 attributes
kono
parents:
diff changeset
771 in parameter.
kono
parents:
diff changeset
772 * semantics.c (potential_constant_expression_1): Likewise.
kono
parents:
diff changeset
773 * typeck.c (fundamental_alignment_p, cxx_alignas_expr): New public
kono
parents:
diff changeset
774 functions.
kono
parents:
diff changeset
775
kono
parents:
diff changeset
776 2012-10-07 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
777
kono
parents:
diff changeset
778 * pt.c (fold_non_dependent_expr_sfinae): Remove static specifier.
kono
parents:
diff changeset
779 (tsubst_copy_and_build): Use get_target_expr_sfinae.
kono
parents:
diff changeset
780 * call.c (build_conditional_expr_1, convert_like_real): Likewise.
kono
parents:
diff changeset
781 * cvt.c (build_up_reference): Likewise.
kono
parents:
diff changeset
782 (ocp_convert): Use abstract_virtuals_error_sfinae.
kono
parents:
diff changeset
783 (build_up_reference): Propagate complain to cp_build_addr_expr.
kono
parents:
diff changeset
784 * decl.c (compute_array_index_type): Use fold_non_dependent_expr_sfinae.
kono
parents:
diff changeset
785 * cp-tree.h: Update declarations.
kono
parents:
diff changeset
786
kono
parents:
diff changeset
787 * cvt.c (build_expr_type_conversion): Tidy.
kono
parents:
diff changeset
788
kono
parents:
diff changeset
789 * tree.c (stabilize_aggr_init): Change to static.
kono
parents:
diff changeset
790
kono
parents:
diff changeset
791 2012-10-07 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
792
kono
parents:
diff changeset
793 PR c++/51422
kono
parents:
diff changeset
794 * semantics.c (is_normal_capture_proxy): Return true for
kono
parents:
diff changeset
795 error_mark_node as DECL_VALUE_EXPR.
kono
parents:
diff changeset
796
kono
parents:
diff changeset
797 2012-10-05 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
798
kono
parents:
diff changeset
799 * cp-tree.h (SIZEOF_EXPR_TYPE_P): Define.
kono
parents:
diff changeset
800 * tree.c (cp_tree_equal): Handle SIZEOF_EXPR with
kono
parents:
diff changeset
801 SIZEOF_EXPR_TYPE_P.
kono
parents:
diff changeset
802 * mangle.c (write_expression): Likewise.
kono
parents:
diff changeset
803 * cxx-pretty-print.c (pp_cxx_unary_expression): Likewise.
kono
parents:
diff changeset
804 * error.c (dump_expr): Likewise.
kono
parents:
diff changeset
805 * parser.c (cp_parser_unary_expression): For sizeof call
kono
parents:
diff changeset
806 cxx_sizeof_or_alignof_{type,expr} just for diagnostics and
kono
parents:
diff changeset
807 return SIZEOF_EXPR with the operand.
kono
parents:
diff changeset
808 * pt.c (tsubst_copy, tsubst_copy_and_build): For SIZEOF_EXPR,
kono
parents:
diff changeset
809 call cxx_sizeof_or_alignof_{type,expr} for diagnostics, but
kono
parents:
diff changeset
810 return SIZEOF_EXPR with tsubsted operand.
kono
parents:
diff changeset
811 (value_dependent_expression_p): Handle SIZEOF_EXPR with
kono
parents:
diff changeset
812 SIZEOF_EXPR_TYPE_P.
kono
parents:
diff changeset
813 (instantiation_dependent_r): Likewise.
kono
parents:
diff changeset
814 * call.c (null_ptr_cst_p): Call maybe_constant_value for C++98.
kono
parents:
diff changeset
815 * semantics.c (finish_call_expr): Call
kono
parents:
diff changeset
816 sizeof_pointer_memaccess_warning if needed.
kono
parents:
diff changeset
817 (cxx_eval_constant_expression): Handle SIZEOF_EXPR.
kono
parents:
diff changeset
818 (potential_constant_expression_1): Remove early exit for
kono
parents:
diff changeset
819 C++98. Handle PROPERTY_REF.
kono
parents:
diff changeset
820 * decl.c (duplicate_decls): When redeclaring a builtin function,
kono
parents:
diff changeset
821 keep the merged decl builtin also if newdecl is a gnu_inline
kono
parents:
diff changeset
822 inline definition.
kono
parents:
diff changeset
823 (fold_sizeof_expr_r): New function.
kono
parents:
diff changeset
824 (compute_array_index_type): Fold SIZEOF_EXPRs in itype.
kono
parents:
diff changeset
825 * cp-gimplify.c (cp_genericize_r): Fold SIZEOF_EXPR.
kono
parents:
diff changeset
826 * typeck.c (cp_build_binary_op): For warn_for_sign_compare
kono
parents:
diff changeset
827 try harder using maybe_constant_value to get INTEGER_CSTs.
kono
parents:
diff changeset
828
kono
parents:
diff changeset
829 * decl.c (stabilize_vla_size): Call pointer_set_destroy
kono
parents:
diff changeset
830 at the end.
kono
parents:
diff changeset
831
kono
parents:
diff changeset
832 2012-10-04 Arnaud Charlet <charlet@adacore.com>
kono
parents:
diff changeset
833
kono
parents:
diff changeset
834 * decl2.c (cp_write_global_declarations): Fix handling of
kono
parents:
diff changeset
835 -fdump-ada-spec*.
kono
parents:
diff changeset
836
kono
parents:
diff changeset
837 2012-10-03 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
838
kono
parents:
diff changeset
839 PR c++/54777
kono
parents:
diff changeset
840 * semantics.c (cxx_eval_constant_expression) <case COMPOUND_EXPR>: If
kono
parents:
diff changeset
841 not ignoring the second operand, pass the original second operand
kono
parents:
diff changeset
842 and not one with stripped nops to cxx_eval_constant_expression.
kono
parents:
diff changeset
843
kono
parents:
diff changeset
844 2012-10-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
845
kono
parents:
diff changeset
846 * decl.c (check_initializer): Set DECL_NONTRIVIALLY_INITIALIZED_P
kono
parents:
diff changeset
847 for a constructor call.
kono
parents:
diff changeset
848 (decl_jump_unsafe): So don't bother checking
kono
parents:
diff changeset
849 type_has_nontrivial_default_init.
kono
parents:
diff changeset
850 * call.c (set_up_extended_ref_temp): Set
kono
parents:
diff changeset
851 DECL_NONTRIVIALLY_INITIALIZED_P.
kono
parents:
diff changeset
852
kono
parents:
diff changeset
853 * cp-tree.h (TYPE_FUNCTION_OR_TEMPLATE_DECL_CHECK): New.
kono
parents:
diff changeset
854 (DECL_FRIEND_P, DECL_ANTICIPATED): Use it.
kono
parents:
diff changeset
855 (TYPE_FUNCTION_OR_TEMPLATE_DECL_P): New.
kono
parents:
diff changeset
856 * name-lookup.c (hidden_name_p): Use it.
kono
parents:
diff changeset
857
kono
parents:
diff changeset
858 * cp-tree.h (DECL_PRETTY_FUNCTION_P): Just look at the name.
kono
parents:
diff changeset
859 * decl.c (cp_make_fname_decl): Adjust.
kono
parents:
diff changeset
860
kono
parents:
diff changeset
861 2012-09-30 Sharad Singhai <singhai@google.com>
kono
parents:
diff changeset
862
kono
parents:
diff changeset
863 * decl2.c (cp_write_global_declarations): Use a different method
kono
parents:
diff changeset
864 to determine if the dump has ben initialized.
kono
parents:
diff changeset
865
kono
parents:
diff changeset
866 2012-09-29 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
867
kono
parents:
diff changeset
868 PR c++/54738
kono
parents:
diff changeset
869 * decl2.c (build_offset_ref_call_from_tree): Add tsubst_flags_t
kono
parents:
diff changeset
870 parameter.
kono
parents:
diff changeset
871 * pt.c (tsubst_copy_and_build): Adjust.
kono
parents:
diff changeset
872 * parser.c (cp_parser_postfix_expression): Likewise.
kono
parents:
diff changeset
873 * cp-tree.h: Adjust declaration.
kono
parents:
diff changeset
874
kono
parents:
diff changeset
875 2012-09-28 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
876
kono
parents:
diff changeset
877 PR c++/54372 - unused attribute inactive on dependant entities
kono
parents:
diff changeset
878 * decl2.c (is_late_template_attribute): "unused" attribute is to
kono
parents:
diff changeset
879 be applied at compile time.
kono
parents:
diff changeset
880
kono
parents:
diff changeset
881 2012-09-25 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
882
kono
parents:
diff changeset
883 PR c++/29028 - Missed unused warning on using declaration
kono
parents:
diff changeset
884 * decl.c (poplevel<warn_unused*>): Do not forget that some local
kono
parents:
diff changeset
885 bindings are represented by a TREE_LIST.
kono
parents:
diff changeset
886
kono
parents:
diff changeset
887 2012-09-25 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
888
kono
parents:
diff changeset
889 PR c++/53551 - -Wunused-local-typedefs misses uses
kono
parents:
diff changeset
890 * decl.c (make_typename_type): Record the use of typedefs.
kono
parents:
diff changeset
891
kono
parents:
diff changeset
892 2012-09-27 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
893
kono
parents:
diff changeset
894 * init.c (build_new_1): Don't test TREE_CONSTANT
kono
parents:
diff changeset
895 of INTEGER_CST.
kono
parents:
diff changeset
896
kono
parents:
diff changeset
897 2012-09-25 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
898
kono
parents:
diff changeset
899 PR c++/54526
kono
parents:
diff changeset
900 * parser.c (cp_parser_template_id): In C++11 mode simply accept
kono
parents:
diff changeset
901 X<::A>.
kono
parents:
diff changeset
902
kono
parents:
diff changeset
903 2012-09-25 Zhenqiang Chen <zhenqiang.chen@linaro.org>
kono
parents:
diff changeset
904
kono
parents:
diff changeset
905 PR c++/50970
kono
parents:
diff changeset
906 * typeck.c (cp_build_binary_op): Check side effects before generating
kono
parents:
diff changeset
907 pfn and delta related expressions.
kono
parents:
diff changeset
908
kono
parents:
diff changeset
909 2012-09-24 Lawrence Crowl <crowl@google.com>
kono
parents:
diff changeset
910
kono
parents:
diff changeset
911 * init.c (build_new_1): Change to new double_int API.
kono
parents:
diff changeset
912 * decl.c (build_enumerator): Likewise.
kono
parents:
diff changeset
913 * typeck2.c (process_init_constructor_array): Likewise.
kono
parents:
diff changeset
914 * mangle.c (write_array_type): Likewise.
kono
parents:
diff changeset
915
kono
parents:
diff changeset
916 2012-09-24 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
917
kono
parents:
diff changeset
918 PR c++/50828
kono
parents:
diff changeset
919 * error.c (dump_function_decl): Strip TFF_TEMPLATE_NAME from flags
kono
parents:
diff changeset
920 at the outset.
kono
parents:
diff changeset
921
kono
parents:
diff changeset
922 2012-09-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
923
kono
parents:
diff changeset
924 * decl.c (get_atexit_node): Remove dead code.
kono
parents:
diff changeset
925
kono
parents:
diff changeset
926 * Make-lang.in (cp/parser.o): Depend on decl.h.
kono
parents:
diff changeset
927
kono
parents:
diff changeset
928 2012-09-20 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
929
kono
parents:
diff changeset
930 PR c++/52432
kono
parents:
diff changeset
931 * pt.c (tsubst_copy_and_build): If tf_error is not set in the complain
kono
parents:
diff changeset
932 argument don't call unqualified_name_lookup_error.
kono
parents:
diff changeset
933
kono
parents:
diff changeset
934 2012-09-19 Marc Glisse <marc.glisse@inria.fr>
kono
parents:
diff changeset
935
kono
parents:
diff changeset
936 PR c++/54581
kono
parents:
diff changeset
937 * semantics.c (finish_decltype_type): Make vectors not opaque.
kono
parents:
diff changeset
938
kono
parents:
diff changeset
939 2012-09-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
940
kono
parents:
diff changeset
941 PR c++/54575
kono
parents:
diff changeset
942 * pt.c (instantiate_alias_template): New.
kono
parents:
diff changeset
943 (tsubst): Use it.
kono
parents:
diff changeset
944 (push_access_scope): Allow TYPE_DECL.
kono
parents:
diff changeset
945
kono
parents:
diff changeset
946 2012-09-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
947
kono
parents:
diff changeset
948 PR c++/53661
kono
parents:
diff changeset
949 * typeck2.c (check_narrowing): Avoid false positives on conversion
kono
parents:
diff changeset
950 from enumeral type.
kono
parents:
diff changeset
951
kono
parents:
diff changeset
952 2012-09-14 Marc Glisse <marc.glisse@inria.fr>
kono
parents:
diff changeset
953
kono
parents:
diff changeset
954 PR c++/54427
kono
parents:
diff changeset
955 * typeck.c (cp_build_binary_op) [LSHIFT_EXPR, RSHIFT_EXPR, EQ_EXPR,
kono
parents:
diff changeset
956 NE_EXPR, LE_EXPR, GE_EXPR, LT_EXPR, GT_EXPR]: Handle VECTOR_TYPE.
kono
parents:
diff changeset
957
kono
parents:
diff changeset
958 2012-09-14 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
959
kono
parents:
diff changeset
960 * decl.c (make_typename_type): Only error out if tf_error is set
kono
parents:
diff changeset
961 in complain.
kono
parents:
diff changeset
962
kono
parents:
diff changeset
963 2012-09-13 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
964 Manuel López-Ibåñez <manu@gcc.gnu.org>
kono
parents:
diff changeset
965
kono
parents:
diff changeset
966 PR c++/53210
kono
parents:
diff changeset
967 * init.c (perform_member_init): Use OPT_Winit_self instead of
kono
parents:
diff changeset
968 OPT_Wuninitialized.
kono
parents:
diff changeset
969
kono
parents:
diff changeset
970 2012-09-13 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
971
kono
parents:
diff changeset
972 * typeck.c (build_indirect_ref, build_function_call,
kono
parents:
diff changeset
973 build_function_call_vec, build_binary_op, build_unary_op,
kono
parents:
diff changeset
974 build_compound_expr, build_c_cast, build_modify_expr): Remove
kono
parents:
diff changeset
975 uses of ATTRIBUTE_UNUSED on the parameters.
kono
parents:
diff changeset
976 * class.c (set_linkage_according_to_type, resort_type_method_vec,
kono
parents:
diff changeset
977 dfs_find_final_overrider_post, empty_base_at_nonzero_offset_p):
kono
parents:
diff changeset
978 Likewise.
kono
parents:
diff changeset
979 * decl.c (local_variable_p_walkfn): Likewise.
kono
parents:
diff changeset
980 * except.c (wrap_cleanups_r, check_noexcept_r): Likewise.
kono
parents:
diff changeset
981 * error.c (find_typenames_r): Likewise.
kono
parents:
diff changeset
982 * tree.c (verify_stmt_tree_r, bot_replace,
kono
parents:
diff changeset
983 handle_java_interface_attribute, handle_com_interface_attribute,
kono
parents:
diff changeset
984 handle_init_priority_attribute, c_register_addr_space): Likewise.
kono
parents:
diff changeset
985 * cp-gimplify.c (cxx_omp_clause_default_ctor): Likewise.
kono
parents:
diff changeset
986 * cp-lang.c (objcp_tsubst_copy_and_build): Likewise.
kono
parents:
diff changeset
987 * pt.c (unify_success, unify_invalid, instantiation_dependent_r):
kono
parents:
diff changeset
988 Likewise.
kono
parents:
diff changeset
989 * semantics.c (dfs_calculate_bases_pre): Likewise.
kono
parents:
diff changeset
990 * decl2.c (fix_temporary_vars_context_r, clear_decl_external):
kono
parents:
diff changeset
991 Likewise.
kono
parents:
diff changeset
992 * parser.c (cp_lexer_token_at, cp_parser_omp_clause_mergeable,
kono
parents:
diff changeset
993 cp_parser_omp_clause_nowait, cp_parser_omp_clause_ordered,
kono
parents:
diff changeset
994 cp_parser_omp_clause_untied): Likewise.
kono
parents:
diff changeset
995 * mangle.c (write_unnamed_type_name,
kono
parents:
diff changeset
996 discriminator_for_string_literal): Likewise.
kono
parents:
diff changeset
997 * search.c (dfs_accessible_post, dfs_debug_mark): Likewise.
kono
parents:
diff changeset
998 * lex.c (handle_pragma_vtable, handle_pragma_unit,
kono
parents:
diff changeset
999 handle_pragma_interface, handle_pragma_implementation,
kono
parents:
diff changeset
1000 handle_pragma_java_exceptions): Likewise.
kono
parents:
diff changeset
1001
kono
parents:
diff changeset
1002 2012-09-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1003
kono
parents:
diff changeset
1004 PR c++/53839
kono
parents:
diff changeset
1005 * semantics.c (cxx_eval_indirect_ref): If we aren't looking for an
kono
parents:
diff changeset
1006 address, make sure the value is constant.
kono
parents:
diff changeset
1007
kono
parents:
diff changeset
1008 PR c++/54511
kono
parents:
diff changeset
1009 * pt.c (tsubst_decl) [VAR_DECL]: Handle DECL_ANON_UNION_VAR_P.
kono
parents:
diff changeset
1010
kono
parents:
diff changeset
1011 PR c++/53836
kono
parents:
diff changeset
1012 * pt.c (value_dependent_expression_p): A TREE_LIST initializer must
kono
parents:
diff changeset
1013 be dependent.
kono
parents:
diff changeset
1014
kono
parents:
diff changeset
1015 2012-09-10 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1016
kono
parents:
diff changeset
1017 PR c++/54541
kono
parents:
diff changeset
1018 PR c++/54542
kono
parents:
diff changeset
1019 * call.c (build_cxx_call): Add tsubst_flags_t parameter, use
kono
parents:
diff changeset
1020 require_complete_type_sfinae.
kono
parents:
diff changeset
1021 (build_op_delete_call, build_over_call): Adjust.
kono
parents:
diff changeset
1022 * typeck.c (build_x_compound_expr_from_vec): Add tsubst_flags_t
kono
parents:
diff changeset
1023 parameter.
kono
parents:
diff changeset
1024 (cp_build_function_call_vec): Adjust.
kono
parents:
diff changeset
1025 * init.c (build_new_1): Likewise.
kono
parents:
diff changeset
1026 * rtti.c (throw_bad_cast, throw_bad_typeid, build_dynamic_cast_1):
kono
parents:
diff changeset
1027 Likewise.
kono
parents:
diff changeset
1028 * optimize.c (build_delete_destructor_body): Likewise.
kono
parents:
diff changeset
1029 * cp-tree.h: Adjust declarations.
kono
parents:
diff changeset
1030
kono
parents:
diff changeset
1031 * call.c (convert_arg_to_ellipsis): Use require_complete_type_sfinae.
kono
parents:
diff changeset
1032
kono
parents:
diff changeset
1033 2012-09-10 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1034
kono
parents:
diff changeset
1035 PR c++/54538
kono
parents:
diff changeset
1036 PR c++/53783
kono
parents:
diff changeset
1037 * pt.c (tsubst_copy_and_build) [LAMBDA_EXPR]: Go back to using RECUR
kono
parents:
diff changeset
1038 for LAMBDA_EXPR_EXTRA_SCOPE except for function scope.
kono
parents:
diff changeset
1039
kono
parents:
diff changeset
1040 PR c++/54506
kono
parents:
diff changeset
1041 * decl.c (move_signature_fn_p): Split out from move_fn_p.
kono
parents:
diff changeset
1042 * method.c (process_subob_fn): Use it.
kono
parents:
diff changeset
1043 * cp-tree.h: Declare it.
kono
parents:
diff changeset
1044
kono
parents:
diff changeset
1045 2012-09-07 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1046
kono
parents:
diff changeset
1047 * semantics.c (sort_constexpr_mem_initializers): Tweak.
kono
parents:
diff changeset
1048
kono
parents:
diff changeset
1049 2012-09-09 Mark Kettenis <kettenis@openbsd.org>
kono
parents:
diff changeset
1050
kono
parents:
diff changeset
1051 * decl.c (reshape_init_class): Avoid dereferencing a
kono
parents:
diff changeset
1052 past-the-end pointer.
kono
parents:
diff changeset
1053
kono
parents:
diff changeset
1054 2012-09-07 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1055
kono
parents:
diff changeset
1056 * pt.c (num_template_headers_for_class): Rework per the code
kono
parents:
diff changeset
1057 inline in cp_parser_check_declarator_template_parameters.
kono
parents:
diff changeset
1058 * parser.c (cp_parser_check_declarator_template_parameters):
kono
parents:
diff changeset
1059 Use num_template_headers_for_class.
kono
parents:
diff changeset
1060
kono
parents:
diff changeset
1061 2012-09-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1062
kono
parents:
diff changeset
1063 PR c++/54341
kono
parents:
diff changeset
1064 PR c++/54253
kono
parents:
diff changeset
1065 * semantics.c (sort_constexpr_mem_initializers): New.
kono
parents:
diff changeset
1066 (build_constexpr_constructor_member_initializers): Use it.
kono
parents:
diff changeset
1067 (cx_check_missing_mem_inits): Skip artificial fields.
kono
parents:
diff changeset
1068 * init.c (expand_aggr_init_1): Don't zero out a class
kono
parents:
diff changeset
1069 with no data.
kono
parents:
diff changeset
1070
kono
parents:
diff changeset
1071 2012-09-05 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1072
kono
parents:
diff changeset
1073 PR c++/54191
kono
parents:
diff changeset
1074 * search.c (lookup_base): Add tsubst_flags_t parameter.
kono
parents:
diff changeset
1075 (adjust_result_of_qualified_name_lookup, check_final_overrider):
kono
parents:
diff changeset
1076 Adjust.
kono
parents:
diff changeset
1077 * name-lookup.c (do_class_using_decl): Adjust.
kono
parents:
diff changeset
1078 * typeck2.c (binfo_or_else, build_scoped_ref, build_m_component_ref):
kono
parents:
diff changeset
1079 Likewise.
kono
parents:
diff changeset
1080 * cvt.c (cp_convert_to_pointer, convert_to_pointer_force,
kono
parents:
diff changeset
1081 build_up_reference): Likewise.
kono
parents:
diff changeset
1082 * rtti.c (build_dynamic_cast_1): Likewise.
kono
parents:
diff changeset
1083 * tree.c (maybe_dummy_object): Likewise.
kono
parents:
diff changeset
1084 * call.c (build_conditional_expr_1, build_over_call): Likewise.
kono
parents:
diff changeset
1085 * cp-tree.h (UNIQUELY_DERIVED_FROM_P, PUBLICLY_UNIQUELY_DERIVED_P):
kono
parents:
diff changeset
1086 Remove.
kono
parents:
diff changeset
1087 (enum base_access_flags, ba_quiet): Remove.
kono
parents:
diff changeset
1088 (uniquely_derived_from_p, publicly_uniquely_derived_p): Declare.
kono
parents:
diff changeset
1089 * except.c (can_convert_eh): Adjust.
kono
parents:
diff changeset
1090 * decl.c (grokdeclarator): Likewise.
kono
parents:
diff changeset
1091 * typeck.c (comp_except_types, build_class_member_access_expr,
kono
parents:
diff changeset
1092 finish_class_member_access_expr, get_member_function_from_ptrfunc,
kono
parents:
diff changeset
1093 build_static_cast_1, get_delta_difference_1): Likewise.
kono
parents:
diff changeset
1094 * class.c (build_base_path, convert_to_base, build_vtbl_ref_1,
kono
parents:
diff changeset
1095 warn_about_ambiguous_bases): Likewise.
kono
parents:
diff changeset
1096 (uniquely_derived_from_p, publicly_uniquely_derived_p): Define.
kono
parents:
diff changeset
1097
kono
parents:
diff changeset
1098 2012-09-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1099
kono
parents:
diff changeset
1100 PR c++/54441
kono
parents:
diff changeset
1101 * decl.c (reshape_init_class): Handle invalid initializer for
kono
parents:
diff changeset
1102 0-length array member.
kono
parents:
diff changeset
1103
kono
parents:
diff changeset
1104 * error.c (dump_type_suffix): Correct handling of 0-length arrays.
kono
parents:
diff changeset
1105
kono
parents:
diff changeset
1106 PR c++/54420
kono
parents:
diff changeset
1107 * cp-tree.h (LAMBDANAME_P): Remove.
kono
parents:
diff changeset
1108 (LAMBDA_TYPE_P): Check CLASSTYPE_LAMBDA_EXPR instead.
kono
parents:
diff changeset
1109 * cp-lang.c (cxx_dwarf_name): Likewise.
kono
parents:
diff changeset
1110 * error.c (dump_aggr_type): Likewise.
kono
parents:
diff changeset
1111 * semantics.c (begin_lambda_type): Set CLASSTYPE_LAMBDA_EXPR sooner.
kono
parents:
diff changeset
1112
kono
parents:
diff changeset
1113 PR c++/54198
kono
parents:
diff changeset
1114 * decl.c (check_default_argument): Set cp_unevaluated_operand
kono
parents:
diff changeset
1115 around call to perform_implicit_conversion_flags.
kono
parents:
diff changeset
1116
kono
parents:
diff changeset
1117 PR c++/54437
kono
parents:
diff changeset
1118 PR c++/51213
kono
parents:
diff changeset
1119 * pt.c (fn_type_unification): Call coerce_template_parms before
kono
parents:
diff changeset
1120 entering substitution context.
kono
parents:
diff changeset
1121
kono
parents:
diff changeset
1122 2012-08-31 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1123 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1124
kono
parents:
diff changeset
1125 PR c++/18747
kono
parents:
diff changeset
1126 * pt.c (check_template_variable): New.
kono
parents:
diff changeset
1127 (num_template_headers_for_class): Split out...
kono
parents:
diff changeset
1128 * decl.c (grokdeclarator): ...from here.
kono
parents:
diff changeset
1129 (start_decl): Remove redundant diagnostic.
kono
parents:
diff changeset
1130 * cp-tree.h: Declare them
kono
parents:
diff changeset
1131 * parser.c (cp_parser_single_declaration): Call check_template_variable.
kono
parents:
diff changeset
1132
kono
parents:
diff changeset
1133 2012-08-31 Ollie Wild <aaw@google.com>
kono
parents:
diff changeset
1134
kono
parents:
diff changeset
1135 PR c++/54197
kono
parents:
diff changeset
1136 * call.c (extend_ref_init_temps_1): Handle COMPOUND_EXPR trees.
kono
parents:
diff changeset
1137
kono
parents:
diff changeset
1138 2012-08-30 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1139
kono
parents:
diff changeset
1140 PR c++/50545
kono
parents:
diff changeset
1141 PR c++/51222
kono
parents:
diff changeset
1142 * pt.c (instantiation_dependent_r): New.
kono
parents:
diff changeset
1143 (instantiation_dependent_expression_p): New.
kono
parents:
diff changeset
1144 (value_dependent_expression_p): Use it. SCOPE_REF is always dependent.
kono
parents:
diff changeset
1145 * semantics.c (finish_decltype_type): Use it.
kono
parents:
diff changeset
1146 * cp-tree.h: Declare it.
kono
parents:
diff changeset
1147
kono
parents:
diff changeset
1148 * semantics.c (finish_qualified_id_expr): Handle building up a
kono
parents:
diff changeset
1149 non-dependent SCOPE_REF here.
kono
parents:
diff changeset
1150 (finish_id_expression): Not here.
kono
parents:
diff changeset
1151 * error.c (dump_decl) [SCOPE_REF]: Only pass TFF_UNQUALIFIED_NAME.
kono
parents:
diff changeset
1152
kono
parents:
diff changeset
1153 * friend.c (make_friend_class): Handle template template parameters.
kono
parents:
diff changeset
1154 * parser.c (cp_parser_template_declaration_after_export): Likewise.
kono
parents:
diff changeset
1155 * pt.c (tsubst_friend_class): Likewise.
kono
parents:
diff changeset
1156 (instantiate_class_template_1): Likewise
kono
parents:
diff changeset
1157 * decl.c (check_elaborated_type_specifier): Likewise.
kono
parents:
diff changeset
1158 (lookup_and_check_tag): Likewise.
kono
parents:
diff changeset
1159
kono
parents:
diff changeset
1160 * pt.c (get_class_bindings): Call coerce_template_parms. Add
kono
parents:
diff changeset
1161 main_tmpl parameter.
kono
parents:
diff changeset
1162 (more_specialized_class): Add main_tmpl parameter.
kono
parents:
diff changeset
1163 (most_specialized_class): Adjust calls.
kono
parents:
diff changeset
1164
kono
parents:
diff changeset
1165 * decl.c (cp_finish_decl): Check for invalid multiple initializers
kono
parents:
diff changeset
1166 even if the initializer is dependent.
kono
parents:
diff changeset
1167
kono
parents:
diff changeset
1168 * pt.c (instantiate_template_1): Keep processing_template_decl set
kono
parents:
diff changeset
1169 if there are dependent args.
kono
parents:
diff changeset
1170
kono
parents:
diff changeset
1171 2012-08-25 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1172
kono
parents:
diff changeset
1173 PR c++/51421
kono
parents:
diff changeset
1174 * decl2.c (mark_used): Consistently return false after errors
kono
parents:
diff changeset
1175 about uses before deduction of auto.
kono
parents:
diff changeset
1176 * semantics.c (finish_id_expression): Check mark_used return
kono
parents:
diff changeset
1177 value and return error_mark_node in case of failure.
kono
parents:
diff changeset
1178
kono
parents:
diff changeset
1179 2012-08-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1180
kono
parents:
diff changeset
1181 PR c++/51213 (again)
kono
parents:
diff changeset
1182 * pt.c (deduction_tsubst_fntype): Remove.
kono
parents:
diff changeset
1183 (fn_type_unification): Check deduction depth and call
kono
parents:
diff changeset
1184 instantiate_template here. Handle default argument access checks.
kono
parents:
diff changeset
1185 (determine_specialization): Suppress access control.
kono
parents:
diff changeset
1186 (tsubst_decl): Check for excessive deduction depth.
kono
parents:
diff changeset
1187 (recheck_decl_substitution): Make sure access control is on.
kono
parents:
diff changeset
1188 (type_unification_real): Don't mess with access deferring here.
kono
parents:
diff changeset
1189 (get_bindings): Adjust for fn_type_unification return type.
kono
parents:
diff changeset
1190 * call.c (enum rejection_reason_code): Drop rr_template_instantiation.
kono
parents:
diff changeset
1191 (template_instantiation_rejection): Remove.
kono
parents:
diff changeset
1192 (struct rejection_reason): Change targs to num_targs.
kono
parents:
diff changeset
1193 (template_unification_rejection, print_z_candidate): Adjust.
kono
parents:
diff changeset
1194 (add_template_candidate_real): Adjust for fn_type_unification change.
kono
parents:
diff changeset
1195 * class.c (resolve_address_of_overloaded_function): Likewise.
kono
parents:
diff changeset
1196 * cp-tree.h: Adjust declaration.
kono
parents:
diff changeset
1197
kono
parents:
diff changeset
1198 * pt.c (tsubst_default_argument): Indicate where the default
kono
parents:
diff changeset
1199 argument is being instantiated for.
kono
parents:
diff changeset
1200 (tsubst_expr): Restore previous location.
kono
parents:
diff changeset
1201 (tsubst_copy_and_build): Set and restore location.
kono
parents:
diff changeset
1202 * call.c (build_new_method_call_1): Remember location of call.
kono
parents:
diff changeset
1203 * semantics.c (finish_call_expr): Here too.
kono
parents:
diff changeset
1204 * parser.c (cp_parser_omp_for_loop): Remember the location of the
kono
parents:
diff changeset
1205 increment expression.
kono
parents:
diff changeset
1206
kono
parents:
diff changeset
1207 * pt.c (resolve_overloaded_unification): Use coerce_template_parms
kono
parents:
diff changeset
1208 instead of get_bindings.
kono
parents:
diff changeset
1209 (resolve_nondeduced_context): Likewise.
kono
parents:
diff changeset
1210
kono
parents:
diff changeset
1211 * pt.c (register_specialization): Correct argument to
kono
parents:
diff changeset
1212 check_specialization_namespace.
kono
parents:
diff changeset
1213 (determine_specialization): Don't consider members of
kono
parents:
diff changeset
1214 unspecialized types.
kono
parents:
diff changeset
1215
kono
parents:
diff changeset
1216 2012-08-23 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1217
kono
parents:
diff changeset
1218 * decl.c (compute_array_index_type): Use type_dependent_expression_p.
kono
parents:
diff changeset
1219
kono
parents:
diff changeset
1220 2012-08-23 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1221
kono
parents:
diff changeset
1222 PR c++/20420
kono
parents:
diff changeset
1223 * name-lookup.c (supplement_binding_1): Handle specially enums
kono
parents:
diff changeset
1224 only in class templates.
kono
parents:
diff changeset
1225 (validate_nonmember_using_decl): Enforce 7.3.3/10 about duplicate
kono
parents:
diff changeset
1226 using declarations at function scope.
kono
parents:
diff changeset
1227
kono
parents:
diff changeset
1228 2012-08-21 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1229
kono
parents:
diff changeset
1230 * cp-tree.h (TREE_INDIRECT_USING): Use TREE_LANG_FLAG_0 accessor.
kono
parents:
diff changeset
1231 (ATTR_IS_DEPENDENT): Likewise.
kono
parents:
diff changeset
1232 (ARGUMENT_PACK_INCOMPLETE_P): Use TREE_ADDRESSABLE instead of
kono
parents:
diff changeset
1233 TREE_LANG_FLAG_0 on TREE_VECs.
kono
parents:
diff changeset
1234
kono
parents:
diff changeset
1235 2012-08-20 Florian Weimer <fweimer@redhat.com>
kono
parents:
diff changeset
1236
kono
parents:
diff changeset
1237 PR c++/19351
kono
parents:
diff changeset
1238 * call.c (build_operator_new_call): Add size_check argument and
kono
parents:
diff changeset
1239 evaluate it.
kono
parents:
diff changeset
1240 * cp-tree.h (build_operator_new_call): Adjust declaration.
kono
parents:
diff changeset
1241 * init.c (build_new_1): Compute array size check and apply it.
kono
parents:
diff changeset
1242
kono
parents:
diff changeset
1243 2012-08-20 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1244
kono
parents:
diff changeset
1245 PR c++/10416
kono
parents:
diff changeset
1246 * decl.c (poplevel): Check TYPE_HAS_NONTRIVIAL_DESTRUCTOR for
kono
parents:
diff changeset
1247 Wunused_variable too.
kono
parents:
diff changeset
1248
kono
parents:
diff changeset
1249 2012-08-20 Diego Novillo <dnovillo@google.com>
kono
parents:
diff changeset
1250
kono
parents:
diff changeset
1251 * decl.c (poplevel): Start TV_NAME_LOOKUP conditionally.
kono
parents:
diff changeset
1252
kono
parents:
diff changeset
1253 2012-08-20 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1254
kono
parents:
diff changeset
1255 * name-lookup.c (store_binding_p): New predicate, split out from ...
kono
parents:
diff changeset
1256 (store_binding): ... here. Always store binding and require
kono
parents:
diff changeset
1257 target vector with enough space.
kono
parents:
diff changeset
1258 (store_bindings): Collect to store bindings and reserve space
kono
parents:
diff changeset
1259 for them, then store them.
kono
parents:
diff changeset
1260 (store_class_bindings): Likewise.
kono
parents:
diff changeset
1261
kono
parents:
diff changeset
1262 2012-08-19 Mikael Morin <mikael@gcc.gnu.org>
kono
parents:
diff changeset
1263
kono
parents:
diff changeset
1264 * Make-lang.in: Fix typo.
kono
parents:
diff changeset
1265
kono
parents:
diff changeset
1266 2012-08-17 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1267
kono
parents:
diff changeset
1268 * cp-tree.def (SIZEOF_EXPR): Move to c-common.def.
kono
parents:
diff changeset
1269
kono
parents:
diff changeset
1270 2012-08-14 Diego Novillo <dnovillo@google.com>
kono
parents:
diff changeset
1271
kono
parents:
diff changeset
1272 Merge from cxx-conversion branch. Re-write VEC in C++.
kono
parents:
diff changeset
1273
kono
parents:
diff changeset
1274 * call.c (add_function_candidate): Remove const qualifier
kono
parents:
diff changeset
1275 from call to VEC_index.
kono
parents:
diff changeset
1276
kono
parents:
diff changeset
1277 2012-08-10 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1278
kono
parents:
diff changeset
1279 * error.c (dump_expr): Handle anonymous SSA names.
kono
parents:
diff changeset
1280
kono
parents:
diff changeset
1281 2012-08-07 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
1282
kono
parents:
diff changeset
1283 * error.c (print_instantiation_context): Pretty-print a newline before
kono
parents:
diff changeset
1284 diagnostic_flush_buffer.
kono
parents:
diff changeset
1285 * cxx-pretty-print.c (pp_cxx_function_definition): Use
kono
parents:
diff changeset
1286 pp_newline_and_flush instead of separate pp_newline and pp_flush.
kono
parents:
diff changeset
1287
kono
parents:
diff changeset
1288 2012-08-06 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
1289
kono
parents:
diff changeset
1290 Avoid crashing on erroneous static_assert usage
kono
parents:
diff changeset
1291 * semantics.c (finish_static_assert): Don't crash on erroneous
kono
parents:
diff changeset
1292 message or condition.
kono
parents:
diff changeset
1293
kono
parents:
diff changeset
1294 2012-08-06 Marc Glisse <marc.glisse@inria.fr>
kono
parents:
diff changeset
1295 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1296
kono
parents:
diff changeset
1297 PR c++/54165
kono
parents:
diff changeset
1298 * typeck.c (build_static_cast_1): Move the conversion to void case
kono
parents:
diff changeset
1299 before the perform_direct_initialization_if_possible call.
kono
parents:
diff changeset
1300
kono
parents:
diff changeset
1301 2012-08-03 Marc Glisse <marc.glisse@inria.fr>
kono
parents:
diff changeset
1302
kono
parents:
diff changeset
1303 * pt.c (tsubst_copy_and_build): Handle VECTOR_TYPE like scalars.
kono
parents:
diff changeset
1304 * cp-tree.h (scalarish_type_p): Declare.
kono
parents:
diff changeset
1305 * tree.c (scalarish_type_p): Make non-static.
kono
parents:
diff changeset
1306
kono
parents:
diff changeset
1307 2012-08-02 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1308 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1309
kono
parents:
diff changeset
1310 PR c++/51213 (again)
kono
parents:
diff changeset
1311 * pt.c (type_unification_real): Call push_deferring_access_checks /
kono
parents:
diff changeset
1312 pop_deferring_access_checks around the substitution of default
kono
parents:
diff changeset
1313 template args.
kono
parents:
diff changeset
1314 (instantiate_template_1): When the specialization returned by
kono
parents:
diff changeset
1315 retrieve_specialization has FNDECL_HAS_ACCESS_ERRORS set and we
kono
parents:
diff changeset
1316 are in a SFINAE context, simply return error_mark_node.
kono
parents:
diff changeset
1317 * cp-tree.h (FNDECL_RECHECK_ACCESS_P): Rename FNDECL_HAS_ACCESS_ERRORS.
kono
parents:
diff changeset
1318
kono
parents:
diff changeset
1319 2012-07-31 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1320
kono
parents:
diff changeset
1321 * pt.c (check_default_tmpl_args): Change is_primary and is_partial
kono
parents:
diff changeset
1322 parameters to bool type, adjust.
kono
parents:
diff changeset
1323 (push_template_decl_real): Tidy.
kono
parents:
diff changeset
1324 * parser.c (cp_parser_init_declarator): Adjust.
kono
parents:
diff changeset
1325 * decl.c (redeclaration_error_message): Likewise.
kono
parents:
diff changeset
1326 * cp-tree.h (check_default_tmpl_args): Update prototype.
kono
parents:
diff changeset
1327
kono
parents:
diff changeset
1328 2012-07-31 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1329
kono
parents:
diff changeset
1330 PR c++/53624
kono
parents:
diff changeset
1331 * pt.c (check_default_tmpl_args): Don't check local types.
kono
parents:
diff changeset
1332
kono
parents:
diff changeset
1333 2012-07-25 Sandra Loosemore <sandra@codesourcery.com>
kono
parents:
diff changeset
1334 Paul Brook <paul@codesourcery.com>
kono
parents:
diff changeset
1335
kono
parents:
diff changeset
1336 PR target/53633
kono
parents:
diff changeset
1337 * decl.c (finish_function): Check targetm.warn_func_return.
kono
parents:
diff changeset
1338
kono
parents:
diff changeset
1339 2012-07-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1340
kono
parents:
diff changeset
1341 PR c++/54086
kono
parents:
diff changeset
1342 * decl.c (grokdeclarator): Allow const and constexpr together.
kono
parents:
diff changeset
1343
kono
parents:
diff changeset
1344 PR c++/54020
kono
parents:
diff changeset
1345 * semantics.c (potential_constant_expression_1) [COND_EXPR]: Call
kono
parents:
diff changeset
1346 maybe_constant_value.
kono
parents:
diff changeset
1347
kono
parents:
diff changeset
1348 * cp-tree.h (tsubst_flags): Remove tf_no_access_control.
kono
parents:
diff changeset
1349 * call.c (standard_conversion): Don't set it.
kono
parents:
diff changeset
1350 * class.c (resolve_address_of_overloaded_function): Don't check it.
kono
parents:
diff changeset
1351 * decl.c (check_default_argument): Call
kono
parents:
diff changeset
1352 perform_implicit_conversion_flags.
kono
parents:
diff changeset
1353
kono
parents:
diff changeset
1354 * pt.c (print_candidates_1): Use inform instead of error.
kono
parents:
diff changeset
1355
kono
parents:
diff changeset
1356 2012-07-24 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1357
kono
parents:
diff changeset
1358 * pt.c (convert_template_argument, tsubst): Simplify fourth argument
kono
parents:
diff changeset
1359 to make_typename_type (complain & tf_error -> complain).
kono
parents:
diff changeset
1360
kono
parents:
diff changeset
1361 2012-07-24 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
1362
kono
parents:
diff changeset
1363 * class.c (n_vtables, n_vtable_entries, n_vtable_searches,
kono
parents:
diff changeset
1364 n_vtable_elems, n_convert_harshness, n_compute_conversion_costs,
kono
parents:
diff changeset
1365 n_inner_fields_searched): Always define.
kono
parents:
diff changeset
1366 (build_primary_vtable): Convert #ifdef GATHER_STATISTICS to if-code.
kono
parents:
diff changeset
1367 (print_class_statistics): Convert #ifdef GATHER_STATISTICS to if-code.
kono
parents:
diff changeset
1368 * tree.c (depth_reached): Always define global.
kono
parents:
diff changeset
1369 (cxx_print_statistics): Convert #ifdef GATHER_STATISTICS to if-code.
kono
parents:
diff changeset
1370 * pt.c (depth_reached): Always define.
kono
parents:
diff changeset
1371 (push_tinst_level): Convert #ifdef GATHER_STATISTICS to if-code.
kono
parents:
diff changeset
1372 * search.c (n_fields_searched, n_calls_lookup_field,
kono
parents:
diff changeset
1373 n_calls_lookup_field_1, n_calls_lookup_fnfields,
kono
parents:
diff changeset
1374 n_calls_lookup_fnfields_1, n_calls_get_base_type,
kono
parents:
diff changeset
1375 n_outer_fields_searched, n_contexts_saved): Always define.
kono
parents:
diff changeset
1376 (lookup_field_1): Convert #ifdef GATHER_STATISTICS to if-code.
kono
parents:
diff changeset
1377 (lookup_member): Likewise.
kono
parents:
diff changeset
1378 (lookup_fnfields_idx_nolazy): Likewise.
kono
parents:
diff changeset
1379 (print_search_statistics): Likewise.
kono
parents:
diff changeset
1380 (reinit_search_statistics): Unconditionally re-set counters.
kono
parents:
diff changeset
1381 * lex.c (retrofit_lang_decl): Convert #ifdef GATHER_STATISTICS
kono
parents:
diff changeset
1382 to if-code.
kono
parents:
diff changeset
1383 (cxx_dup_lang_specific_decl): Likewise.
kono
parents:
diff changeset
1384 (copy_lang_type): Likewise.
kono
parents:
diff changeset
1385 (cxx_make_type): Likewise.
kono
parents:
diff changeset
1386
kono
parents:
diff changeset
1387 2012-07-20 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1388
kono
parents:
diff changeset
1389 PR c++/54038
kono
parents:
diff changeset
1390 * tree.c (build_cplus_array_type): Use build_cplus_array_type to build
kono
parents:
diff changeset
1391 canonical array type rather than mess with its TYPE_*_VARIANT.
kono
parents:
diff changeset
1392
kono
parents:
diff changeset
1393 2012-07-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1394
kono
parents:
diff changeset
1395 PR c++/54026
kono
parents:
diff changeset
1396 * typeck.c (cp_apply_type_quals_to_decl): Check COMPLETE_TYPE_P.
kono
parents:
diff changeset
1397
kono
parents:
diff changeset
1398 PR c++/54021
kono
parents:
diff changeset
1399 * call.c (build_cxx_call): Set optimize when folding
kono
parents:
diff changeset
1400 __builtin_constant_p in a constexpr function.
kono
parents:
diff changeset
1401
kono
parents:
diff changeset
1402 2012-07-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1403
kono
parents:
diff changeset
1404 * pt.c (instantiate_decl): Don't recheck substitutions.
kono
parents:
diff changeset
1405
kono
parents:
diff changeset
1406 2012-07-18 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1407 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1408
kono
parents:
diff changeset
1409 DR 1170
kono
parents:
diff changeset
1410 PR c++/51213
kono
parents:
diff changeset
1411 * semantics.c (perform_access_checks): Add complain parm, return bool.
kono
parents:
diff changeset
1412 (perform_deferred_access_checks): Likewise.
kono
parents:
diff changeset
1413 (perform_or_defer_access_check): Likewise.
kono
parents:
diff changeset
1414 (speculative_access_check): Remove.
kono
parents:
diff changeset
1415 * call.c (enforce_access): Add complain parm, return bool.
kono
parents:
diff changeset
1416 * decl.c, friend.c, class.c, init.c, parser.c: Adjust callers.
kono
parents:
diff changeset
1417 * search.c: Adjust callers.
kono
parents:
diff changeset
1418 * cp-tree.h (TINFO_RECHECK_ACCESS_P): New macro.
kono
parents:
diff changeset
1419 (FNDECL_RECHECK_ACCESS_P): New macro.
kono
parents:
diff changeset
1420 * method.c (synthesized_method_walk): Stop deferring access checks.
kono
parents:
diff changeset
1421 * pt.c (recheck_decl_substitution): New.
kono
parents:
diff changeset
1422 (instantiate_template_1): Set and check FNDECL_RECHECK_ACCESS_P.
kono
parents:
diff changeset
1423
kono
parents:
diff changeset
1424 2012-07-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1425
kono
parents:
diff changeset
1426 * method.c (process_subob_fn): Make sure no_implicit_p is non-null
kono
parents:
diff changeset
1427 before trying to store through it.
kono
parents:
diff changeset
1428
kono
parents:
diff changeset
1429 2012-07-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1430
kono
parents:
diff changeset
1431 PR c++/53995
kono
parents:
diff changeset
1432 * decl.c (finish_enum_value_list): Only call
kono
parents:
diff changeset
1433 insert_late_enum_def_into_classtype_sorted_fields in class scope.
kono
parents:
diff changeset
1434
kono
parents:
diff changeset
1435 PR c++/53989
kono
parents:
diff changeset
1436 * tree.c (build_cplus_array_type): Also add TYPE_CANONICAL
kono
parents:
diff changeset
1437 to the list of variants.
kono
parents:
diff changeset
1438
kono
parents:
diff changeset
1439 * decl.c (xref_basetypes): Complain about incomplete template base.
kono
parents:
diff changeset
1440 * class.c (finish_struct): Adjust variants in templates, too.
kono
parents:
diff changeset
1441
kono
parents:
diff changeset
1442 PR c++/53549
kono
parents:
diff changeset
1443 * parser.c (cp_parser_class_head): Call xref_basetypes here.
kono
parents:
diff changeset
1444 (cp_parser_class_specifier_1): Not here.
kono
parents:
diff changeset
1445 * pt.c (tsubst_decl) [USING_DECL]: Check uses_template_parms
kono
parents:
diff changeset
1446 as well as DECL_DEPENDENT_P.
kono
parents:
diff changeset
1447
kono
parents:
diff changeset
1448 2012-07-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1449
kono
parents:
diff changeset
1450 * cp-tree.h (struct deferred_access_check): Add location.
kono
parents:
diff changeset
1451 * semantics.c (perform_access_checks): Use it.
kono
parents:
diff changeset
1452 (perform_or_defer_access_check): Store it.
kono
parents:
diff changeset
1453
kono
parents:
diff changeset
1454 2012-07-16 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
1455
kono
parents:
diff changeset
1456 * dump.c (dump_stmt): Moved here from c-dump.c.
kono
parents:
diff changeset
1457 * optimize.c: Include dumpfile.h instead of tree-dump.h.
kono
parents:
diff changeset
1458 * class.c: Likewise.
kono
parents:
diff changeset
1459 * decl2.c: Likewise.
kono
parents:
diff changeset
1460 * Make-lang.in: Fix dependencies.
kono
parents:
diff changeset
1461
kono
parents:
diff changeset
1462 2012-07-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1463
kono
parents:
diff changeset
1464 PR c++/53953
kono
parents:
diff changeset
1465 * method.c (synthesized_method_walk): Initialize no_implicit_p sooner.
kono
parents:
diff changeset
1466
kono
parents:
diff changeset
1467 2012-07-12 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1468
kono
parents:
diff changeset
1469 * pt.c (instantiate_decl): Check typedefs access here.
kono
parents:
diff changeset
1470 (instantiate_template_1): Not here.
kono
parents:
diff changeset
1471
kono
parents:
diff changeset
1472 * pt.c (deduction_tsubst_fntype): Just suppress access checking.
kono
parents:
diff changeset
1473 (instantiate_template_1): Set DECL_TI_TEMPLATE before access checking.
kono
parents:
diff changeset
1474 (push_deduction_access_scope, pop_deduction_access_scope): Remove.
kono
parents:
diff changeset
1475
kono
parents:
diff changeset
1476 2012-07-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1477
kono
parents:
diff changeset
1478 DR 1402
kono
parents:
diff changeset
1479 * method.c (synthesized_method_walk): Replace uses of msg with diag.
kono
parents:
diff changeset
1480 Correct handling of virtual bases with move operations.
kono
parents:
diff changeset
1481 (process_subob_fn, walk_field_subobs): Replace uses of msg with diag.
kono
parents:
diff changeset
1482
kono
parents:
diff changeset
1483 2012-07-11 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
1484
kono
parents:
diff changeset
1485 * method.c: Do not include tree-pass.h.
kono
parents:
diff changeset
1486
kono
parents:
diff changeset
1487 2012-07-10 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1488
kono
parents:
diff changeset
1489 DR 1402
kono
parents:
diff changeset
1490 PR c++/53733
kono
parents:
diff changeset
1491 * cp-tree.h (FNDECL_SUPPRESS_IMPLICIT_DECL): New.
kono
parents:
diff changeset
1492 (struct lang_decl_fn): Add suppress_implicit_decl field.
kono
parents:
diff changeset
1493 * method.c (implicitly_declare_fn): Check it.
kono
parents:
diff changeset
1494 (process_subob_fn): Add no_implicit_p parm.
kono
parents:
diff changeset
1495 (walk_field_subobs, synthesized_method_walk): Likewise.
kono
parents:
diff changeset
1496 (maybe_explain_implicit_delete): Adjust.
kono
parents:
diff changeset
1497 (explain_implicit_non_constexpr): Adjust.
kono
parents:
diff changeset
1498
kono
parents:
diff changeset
1499 * method.c (synthesized_method_walk): Avoid changing
kono
parents:
diff changeset
1500 EH spec based on cleanups in other places, too.
kono
parents:
diff changeset
1501
kono
parents:
diff changeset
1502 2012-07-09 Sterling Augustine <saugustine@google.com>
kono
parents:
diff changeset
1503
kono
parents:
diff changeset
1504 * error.c (lang_decl_name): Use TFF_UNQUALIFIED_NAME flag.
kono
parents:
diff changeset
1505
kono
parents:
diff changeset
1506 2012-07-08 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
1507
kono
parents:
diff changeset
1508 * decl.c (cp_finish_decl): Add FIXME at add_local_decl call site.
kono
parents:
diff changeset
1509
kono
parents:
diff changeset
1510 2012-07-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1511
kono
parents:
diff changeset
1512 PR c++/53862
kono
parents:
diff changeset
1513 * pt.c (tsubst_arg_types): Add "end" parameter.
kono
parents:
diff changeset
1514 (check_undeduced_parms): Use it.
kono
parents:
diff changeset
1515
kono
parents:
diff changeset
1516 * cp-tree.h (DECL_DECLARES_TYPE_P): Check DECL_TYPE_TEMPLATE_P.
kono
parents:
diff changeset
1517
kono
parents:
diff changeset
1518 PR c++/53858
kono
parents:
diff changeset
1519 * name-lookup.c (ambiguous_decl): Use DECL_TYPE_TEMPLATE_P.
kono
parents:
diff changeset
1520
kono
parents:
diff changeset
1521 2012-07-05 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1522
kono
parents:
diff changeset
1523 PR c++/53039
kono
parents:
diff changeset
1524 * pt.c (arg_from_parm_pack_p): Go back to using same_type_p or
kono
parents:
diff changeset
1525 cp_tree_equal.
kono
parents:
diff changeset
1526
kono
parents:
diff changeset
1527 * cp-tree.h (TEMPLATE_PARM_NUM_SIBLINGS): Remove.
kono
parents:
diff changeset
1528 (struct template_parm_index_s): Remove num_siblings.
kono
parents:
diff changeset
1529 * pt.c (fixup_template_parms, fixup_template_parm_index): Remove.
kono
parents:
diff changeset
1530 (fixup_template_type_parm_type): Remove.
kono
parents:
diff changeset
1531 (build_template_parm_index): Remove num_siblings parm.
kono
parents:
diff changeset
1532 (process_template_parm): Likewise.
kono
parents:
diff changeset
1533 * parser.c (cp_parser_template_parameter_list): Adjust.
kono
parents:
diff changeset
1534 * tree.c (cp_tree_equal): Don't compare num_siblings.
kono
parents:
diff changeset
1535 * typeck.c (comp_template_parms_position): Likewise.
kono
parents:
diff changeset
1536
kono
parents:
diff changeset
1537 PR c++/50852
kono
parents:
diff changeset
1538 PR c++/53039
kono
parents:
diff changeset
1539 * tree.c (strip_typedefs_expr): New.
kono
parents:
diff changeset
1540 * cp-tree.h: Declare it.
kono
parents:
diff changeset
1541 * pt.c (convert_template_argument, unify): Use it.
kono
parents:
diff changeset
1542 * parser.c (cp_parser_template_declaration_after_export): Don't call
kono
parents:
diff changeset
1543 fixup_template_parms.
kono
parents:
diff changeset
1544
kono
parents:
diff changeset
1545 2012-07-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1546
kono
parents:
diff changeset
1547 PR c++/53848
kono
parents:
diff changeset
1548 PR c++/53524
kono
parents:
diff changeset
1549 * decl.c (build_enumerator): Don't use build_lang_decl_loc.
kono
parents:
diff changeset
1550
kono
parents:
diff changeset
1551 2012-07-03 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1552
kono
parents:
diff changeset
1553 PR c++/53812
kono
parents:
diff changeset
1554 * semantics.c (finish_goto_stmt): Surround computed goto argument
kono
parents:
diff changeset
1555 with CLEANUP_POINT_EXPR if needed.
kono
parents:
diff changeset
1556
kono
parents:
diff changeset
1557 2012-07-02 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1558
kono
parents:
diff changeset
1559 PR c++/53619
kono
parents:
diff changeset
1560 * pt.c (in_template_function): New.
kono
parents:
diff changeset
1561 * cp-tree.h: Declare it.
kono
parents:
diff changeset
1562 * class.c (build_base_path, resolves_to_fixed_type_p): Use it.
kono
parents:
diff changeset
1563
kono
parents:
diff changeset
1564 PR c++/53783
kono
parents:
diff changeset
1565 * pt.c (tsubst_copy_and_build) [LAMBDA_EXPR]: Use tsubst
kono
parents:
diff changeset
1566 for LAMBDA_EXPR_EXTRA_SCOPE.
kono
parents:
diff changeset
1567
kono
parents:
diff changeset
1568 PR c++/53788
kono
parents:
diff changeset
1569 * pt.c (build_non_dependent_expr): Don't wrap a dummy object.
kono
parents:
diff changeset
1570
kono
parents:
diff changeset
1571 PR c++/53816
kono
parents:
diff changeset
1572 * class.c (resolves_to_fixed_type_p): Check uses_template_parms
kono
parents:
diff changeset
1573 (current_function_decl) instead of processing_template_decl.
kono
parents:
diff changeset
1574
kono
parents:
diff changeset
1575 PR c++/53821
kono
parents:
diff changeset
1576 * semantics.c (maybe_add_lambda_conv_op): Don't set
kono
parents:
diff changeset
1577 DECL_INTERFACE_KNOWN.
kono
parents:
diff changeset
1578
kono
parents:
diff changeset
1579 PR c++/53524
kono
parents:
diff changeset
1580 * call.c (build_conditional_expr_1): Don't warn about comparison of
kono
parents:
diff changeset
1581 two enumerators before their enumeration is complete.
kono
parents:
diff changeset
1582 (build_new_op_1): Call decay_conversion before warn_logical_operator.
kono
parents:
diff changeset
1583 * decl.c (build_enumerator): Set DECL_CONTEXT of an enumerator to
kono
parents:
diff changeset
1584 its enumeration.
kono
parents:
diff changeset
1585 * decl2.c (mark_used): Call used_types_insert for enums.
kono
parents:
diff changeset
1586 * semantics.c (finish_id_expression): Don't decay CONST_DECL.
kono
parents:
diff changeset
1587 (finish_member_declaration): Don't change DECL_CONTEXT of enumerators.
kono
parents:
diff changeset
1588 * class.c (check_field_decls): Don't change DECL_CONTEXT of enums.
kono
parents:
diff changeset
1589 * typeck.c (convert_for_assignment): Don't decay CONST_DECL.
kono
parents:
diff changeset
1590 (build_class_member_access_expr): Look through unscoped enums.
kono
parents:
diff changeset
1591 * search.c (context_for_name_lookup): Look through unscoped enums.
kono
parents:
diff changeset
1592 * pt.c (tsubst_copy_and_build): Don't decay CONST_DECL.
kono
parents:
diff changeset
1593 (tsubst_copy): Use DECL_CONTEXT to find the enumeration.
kono
parents:
diff changeset
1594 * tree.c (decl_linkage): Likewise.
kono
parents:
diff changeset
1595 * cvt.c (ocp_convert): Check decayed expr for enum range warning.
kono
parents:
diff changeset
1596
kono
parents:
diff changeset
1597 2012-06-29 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
1598
kono
parents:
diff changeset
1599 * Make-lang.in: Remove tree-mudflap.o from CXX_AND_OBJCXX_OBJS.
kono
parents:
diff changeset
1600
kono
parents:
diff changeset
1601 2012-06-27 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1602
kono
parents:
diff changeset
1603 * parser.c (cp_parser_check_for_invalid_template_id): tag_type parm.
kono
parents:
diff changeset
1604 (cp_parser_simple_type_specifier, cp_parser_class_head): Adjust.
kono
parents:
diff changeset
1605 (cp_parser_elaborated_type_specifier): Adjust.
kono
parents:
diff changeset
1606 * decl.c (duplicate_decls): Return error_mark_node on template
kono
parents:
diff changeset
1607 mismatch.
kono
parents:
diff changeset
1608
kono
parents:
diff changeset
1609 PR c++/53563
kono
parents:
diff changeset
1610 * parser.c (cp_parser_template_id): Add tag_type parm.
kono
parents:
diff changeset
1611 (cp_parser_template_name): Likewise.
kono
parents:
diff changeset
1612 (cp_parser_id_expression, cp_parser_unqualified_id): Adjust.
kono
parents:
diff changeset
1613 (cp_parser_pseudo_destructor_name, cp_parser_type_name): Adjust.
kono
parents:
diff changeset
1614 (cp_parser_simple_type_specifier, cp_parser_class_name): Adjust.
kono
parents:
diff changeset
1615 (cp_parser_elaborated_type_specifier, cp_parser_class_head): Adjust.
kono
parents:
diff changeset
1616
kono
parents:
diff changeset
1617 2012-06-27 Ramana Radhakrishnan <ramana.radhakrishnan@linaro.org>
kono
parents:
diff changeset
1618
kono
parents:
diff changeset
1619 PR C++/51033
kono
parents:
diff changeset
1620 * semantics.c (constexpr_call): Fix typo in comment.
kono
parents:
diff changeset
1621 (cxx_eval_vec_perm_expr): New.
kono
parents:
diff changeset
1622 (cxx_eval_constant_expression): Fold VEC_PERM_EXPRs.
kono
parents:
diff changeset
1623
kono
parents:
diff changeset
1624 2012-06-26 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1625
kono
parents:
diff changeset
1626 PR c++/53752
kono
parents:
diff changeset
1627 * mangle.c (write_array_type): Truncate the number-of-elements
kono
parents:
diff changeset
1628 result.
kono
parents:
diff changeset
1629
kono
parents:
diff changeset
1630 2012-06-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1631
kono
parents:
diff changeset
1632 PR c++/53498
kono
parents:
diff changeset
1633 PR c++/53305
kono
parents:
diff changeset
1634 * pt.c (tsubst_decl) [PARM_DECL]: Don't recurse into DECL_CHAIN
kono
parents:
diff changeset
1635 if cp_unevaluated_operand is set.
kono
parents:
diff changeset
1636 (tsubst_copy) [PARM_DECL]: Don't copy before tsubsting.
kono
parents:
diff changeset
1637
kono
parents:
diff changeset
1638 PR c++/52988
kono
parents:
diff changeset
1639 * typeck.c (decay_conversion): Don't discard side-effects from
kono
parents:
diff changeset
1640 expressions of nullptr_t.
kono
parents:
diff changeset
1641
kono
parents:
diff changeset
1642 2012-06-25 Florian Weimer <fweimer@redhat.com>
kono
parents:
diff changeset
1643
kono
parents:
diff changeset
1644 * init.c (build_new_1): Warn about (T[N]) for variable N, and
kono
parents:
diff changeset
1645 reject T[M][N].
kono
parents:
diff changeset
1646
kono
parents:
diff changeset
1647 * parser.c (cp_parser_direct_new_declarator): Accept non-constant
kono
parents:
diff changeset
1648 expressions. Handled now in build_new_1.
kono
parents:
diff changeset
1649
kono
parents:
diff changeset
1650 2012-06-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1651
kono
parents:
diff changeset
1652 PR c++/53202
kono
parents:
diff changeset
1653 * semantics.c (build_data_member_initialization): Always keep
kono
parents:
diff changeset
1654 initializer for empty base.
kono
parents:
diff changeset
1655 (cxx_eval_bare_aggregate): Discard it here.
kono
parents:
diff changeset
1656
kono
parents:
diff changeset
1657 PR c++/53565
kono
parents:
diff changeset
1658 * pt.c (tsubst_omp_for_iterator): Simplify DECL_EXPR handling.
kono
parents:
diff changeset
1659 (tsubst_expr) [OMP_FOR]: Here, too.
kono
parents:
diff changeset
1660
kono
parents:
diff changeset
1661 2012-06-25 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1662
kono
parents:
diff changeset
1663 PR c++/53594
kono
parents:
diff changeset
1664 * class.c (check_bases_and_members): Avoid -Wuninitialized
kono
parents:
diff changeset
1665 diagnostics for non-static const members or references if they
kono
parents:
diff changeset
1666 use NSDMI.
kono
parents:
diff changeset
1667
kono
parents:
diff changeset
1668 2012-06-16 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
1669
kono
parents:
diff changeset
1670 * parser.c (cp_parser_direct_declarator): Move virt-specifier
kono
parents:
diff changeset
1671 parsing after late-specified return type parsing.
kono
parents:
diff changeset
1672
kono
parents:
diff changeset
1673 2012-06-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1674
kono
parents:
diff changeset
1675 PR c++/53651
kono
parents:
diff changeset
1676 * name-lookup.c (constructor_name_p): Don't try to look at the
kono
parents:
diff changeset
1677 name of a DECLTYPE_TYPE.
kono
parents:
diff changeset
1678
kono
parents:
diff changeset
1679 2012-06-18 Lawrence Crowl <crowl@google.com>
kono
parents:
diff changeset
1680
kono
parents:
diff changeset
1681 * decl2.c (cp_write_global_declarations): Rename use of TV_PHASE_CGRAPH
kono
parents:
diff changeset
1682 to TV_PHASE_OPT_GEN.
kono
parents:
diff changeset
1683
kono
parents:
diff changeset
1684 2012-06-18 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
1685
kono
parents:
diff changeset
1686 * decl.c (finish_function): Remove code conditional on VMS_TARGET.
kono
parents:
diff changeset
1687
kono
parents:
diff changeset
1688 2012-06-15 Marc Glisse <marc.glisse@inria.fr>
kono
parents:
diff changeset
1689
kono
parents:
diff changeset
1690 PR c++/51033
kono
parents:
diff changeset
1691 * semantics.c (literal_type_p): Handle VECTOR_TYPE.
kono
parents:
diff changeset
1692 (potential_constant_expression_1): Handle VEC_PERM_EXPR.
kono
parents:
diff changeset
1693 * parser.c (cp_parser_postfix_expression): Handle RID_BUILTIN_SHUFFLE.
kono
parents:
diff changeset
1694
kono
parents:
diff changeset
1695 2012-06-09 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1696
kono
parents:
diff changeset
1697 * pt.c (tsubst_expr) [TAG_DEFN]: Instantiate local class.
kono
parents:
diff changeset
1698 * class.c (finish_struct): Don't add a TAG_DEFN for a lambda.
kono
parents:
diff changeset
1699 * decl2.c (finish_static_data_member_decl): Avoid redundant error.
kono
parents:
diff changeset
1700
kono
parents:
diff changeset
1701 PR c++/53599
kono
parents:
diff changeset
1702 * name-lookup.c (pushtag_1): Add a DECL_EXPR for a local class.
kono
parents:
diff changeset
1703 * semantics.c (finish_cond): Build a COMPOUND_EXPR.
kono
parents:
diff changeset
1704 * pt.c (tsubst_expr) [COMPOUND_EXPR]: Handle.
kono
parents:
diff changeset
1705 [DECL_EXPR]: Don't call cp_finish_decl for an implicit typedef.
kono
parents:
diff changeset
1706 Don't return the decl.
kono
parents:
diff changeset
1707
kono
parents:
diff changeset
1708 2012-06-11 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
1709
kono
parents:
diff changeset
1710 PR c++/53605
kono
parents:
diff changeset
1711 * mangle.c (write_array_type): Use double-ints for array domain
kono
parents:
diff changeset
1712 arithmetic.
kono
parents:
diff changeset
1713
kono
parents:
diff changeset
1714 2012-06-07 Fabien ChĂȘne <fabien@gcc.gnu.org>
kono
parents:
diff changeset
1715
kono
parents:
diff changeset
1716 PR c++/51214
kono
parents:
diff changeset
1717 * cp-tree.h (insert_late_enum_def_into_classtype_sorted_fields):
kono
parents:
diff changeset
1718 Declare.
kono
parents:
diff changeset
1719 * class.c (insert_into_classtype_sorted_fields): New.
kono
parents:
diff changeset
1720 (add_enum_fields_to_record_type): New.
kono
parents:
diff changeset
1721 (count_fields): Adjust the comment.
kono
parents:
diff changeset
1722 (add_fields_to_record_type): Likewise.
kono
parents:
diff changeset
1723 (finish_struct_1): Move the code that inserts the fields for the
kono
parents:
diff changeset
1724 sorted case, into insert_into_classtype_sorted_fields, and call
kono
parents:
diff changeset
1725 it.
kono
parents:
diff changeset
1726 (insert_late_enum_def_into_classtype_sorted_fields): Define.
kono
parents:
diff changeset
1727 * decl.c (finish_enum_value_list): Call
kono
parents:
diff changeset
1728 insert_late_enum_def_into_classtype_sorted_fields if a late enum
kono
parents:
diff changeset
1729 definition is encountered.
kono
parents:
diff changeset
1730
kono
parents:
diff changeset
1731 2012-06-06 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1732
kono
parents:
diff changeset
1733 PR c++/53567
kono
parents:
diff changeset
1734 * typeck.c (cp_perform_integral_promotions): New, like
kono
parents:
diff changeset
1735 perform_integral_promotions but also takes a tsubst_flags_t parameter.
kono
parents:
diff changeset
1736 (pointer_diff): Add tsubst_flags_t parameter.
kono
parents:
diff changeset
1737 (decay_conversion, cp_default_conversion, cp_build_array_ref,
kono
parents:
diff changeset
1738 cp_build_binary_op, cp_build_unary_op, build_static_cast_1,
kono
parents:
diff changeset
1739 build_reinterpret_cast_1, cp_build_modify_expr,
kono
parents:
diff changeset
1740 convert_for_assignment): Adjust.
kono
parents:
diff changeset
1741 * optimize.c (build_delete_destructor_body): Adjust.
kono
parents:
diff changeset
1742 * init.c (expand_virtual_init, expand_default_init, build_new_1,
kono
parents:
diff changeset
1743 build_new, build_vec_delete_1, build_vec_init, build_delete): Adjust.
kono
parents:
diff changeset
1744 (construct_virtual_base): Adjust LOOKUP_COMPLAIN -> 0.
kono
parents:
diff changeset
1745 * class.c (build_base_path): Adjust.
kono
parents:
diff changeset
1746 * decl.c (compute_array_index_type, finish_destructor_body): Likewise.
kono
parents:
diff changeset
1747 * method.c (synthesized_method_walk): Adjust flag and complain.
kono
parents:
diff changeset
1748 * rtti.c (ifnonnull): Add tsubst_flags_t parameter.
kono
parents:
diff changeset
1749 (build_typeid, build_dynamic_cast_1): Adjust.
kono
parents:
diff changeset
1750 * except.c (initialize_handler_parm): Likewise.
kono
parents:
diff changeset
1751 * typeck2.c (process_init_constructor_record): Likewise.
kono
parents:
diff changeset
1752 * pt.c (tsubst_friend_class): Don't change flags.
kono
parents:
diff changeset
1753 * semantics.c (finish_goto_stmt, handle_omp_for_class_iterator,
kono
parents:
diff changeset
1754 finish_static_assert): Likewise.
kono
parents:
diff changeset
1755 * parser.c (cp_parser_lookup_name): Just pass 0 as flags to
kono
parents:
diff changeset
1756 lookup_name_real.
kono
parents:
diff changeset
1757 * call.c (build_op_delete_call): Add tsubst_flags_t parameter.
kono
parents:
diff changeset
1758 (convert_like_real, convert_arg_to_ellipsis, convert_for_arg_passing):
kono
parents:
diff changeset
1759 Adjust.
kono
parents:
diff changeset
1760 (standard_conversion): Adjust LOOKUP_COMPLAIN -> 0.
kono
parents:
diff changeset
1761 (implicit_conversion): Mask out tf_error with a FIXME.
kono
parents:
diff changeset
1762 (build_user_type_conversion_1, build_new_op_1, build_over_call): Use
kono
parents:
diff changeset
1763 complain & tf_error instead of flags & LOOKUP_COMPLAIN.
kono
parents:
diff changeset
1764 * cvt.c (cp_convert_to_pointer, convert_to_pointer_force,
kono
parents:
diff changeset
1765 build_up_reference, convert_to_reference, cp_convert,
kono
parents:
diff changeset
1766 cp_convert_and_check, ocp_convert, convert_force): Add tsubst_flags_t
kono
parents:
diff changeset
1767 parameter.
kono
parents:
diff changeset
1768 (convert_to_reference, ocp_convert): Use complain & tf_error instead
kono
parents:
diff changeset
1769 of flags & LOOKUP_COMPLAIN.
kono
parents:
diff changeset
1770 (convert_force): Adjust LOOKUP_COMPLAIN -> 0.
kono
parents:
diff changeset
1771 * name-lookup.c (identifier_type_value_1, lookup_qualified_name,
kono
parents:
diff changeset
1772 lookup_name_real, lookup_function_nonclass, lookup_name,
kono
parents:
diff changeset
1773 lookup_name_prefer_type): Adjust LOOKUP_COMPLAIN -> 0.
kono
parents:
diff changeset
1774 * cp-tree.h: Adjust prototypes; remove LOOKUP_COMPLAIN.
kono
parents:
diff changeset
1775
kono
parents:
diff changeset
1776 2012-06-06 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
1777
kono
parents:
diff changeset
1778 * decl.c: Do not include output.h.
kono
parents:
diff changeset
1779 (start_decl): Remove code for flag_conserve_space.
kono
parents:
diff changeset
1780
kono
parents:
diff changeset
1781 2012-06-06 Fabien ChĂȘne <fabien@gcc.gnu.org>
kono
parents:
diff changeset
1782
kono
parents:
diff changeset
1783 PR c++/52841
kono
parents:
diff changeset
1784 * parser.c (cp_parser_alias_declaration): Return earlier
kono
parents:
diff changeset
1785 if an error occured.
kono
parents:
diff changeset
1786
kono
parents:
diff changeset
1787 2012-06-04 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1788
kono
parents:
diff changeset
1789 PR c++/53524
kono
parents:
diff changeset
1790 * call.c (build_conditional_expr_1): Use OPT_Wenum_compare
kono
parents:
diff changeset
1791 to control enumeral mismatch in conditional expression too.
kono
parents:
diff changeset
1792
kono
parents:
diff changeset
1793 2012-06-04 Sterling Augustine <saugustine@google.com>
kono
parents:
diff changeset
1794
kono
parents:
diff changeset
1795 * cp-tree.h: Declare decl_as_dwarf_string, lang_decl_dwarf_name.
kono
parents:
diff changeset
1796 * cp-lang.c (cxx_dwarf_name): Call them.
kono
parents:
diff changeset
1797
kono
parents:
diff changeset
1798 2012-06-04 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
1799
kono
parents:
diff changeset
1800 * semantics.c: Do not include output.h.
kono
parents:
diff changeset
1801 * decl2.c: Likewise.
kono
parents:
diff changeset
1802 * friend.c: Likewise.
kono
parents:
diff changeset
1803 * typeck.c: Likewise.
kono
parents:
diff changeset
1804 * typeck2.c: Likewise.
kono
parents:
diff changeset
1805 * Make-lang.in: Fix dependencies.
kono
parents:
diff changeset
1806
kono
parents:
diff changeset
1807 2012-06-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1808
kono
parents:
diff changeset
1809 PR c++/52973
kono
parents:
diff changeset
1810 * parser.c (cp_parser_class_head): Apply attributes here.
kono
parents:
diff changeset
1811 * semantics.c (begin_class_definition): Not here.
kono
parents:
diff changeset
1812 * cp-tree.h: Adjust.
kono
parents:
diff changeset
1813
kono
parents:
diff changeset
1814 PR c++/52725
kono
parents:
diff changeset
1815 * parser.c (cp_parser_binary_expression): Bail early if we're parsing
kono
parents:
diff changeset
1816 tentatively and the LHS has a parse error.
kono
parents:
diff changeset
1817
kono
parents:
diff changeset
1818 PR c++/53137
kono
parents:
diff changeset
1819 * pt.c (instantiate_class_template_1): Set LAMBDA_EXPR_THIS_CAPTURE.
kono
parents:
diff changeset
1820 (instantiate_decl): Don't push_to_top_level for local class methods.
kono
parents:
diff changeset
1821 (instantiate_class_template_1): Or for local classes.
kono
parents:
diff changeset
1822
kono
parents:
diff changeset
1823 PR c++/53484
kono
parents:
diff changeset
1824 * pt.c (do_auto_deduction): Don't try to deduce from a
kono
parents:
diff changeset
1825 type-dependent initializer.
kono
parents:
diff changeset
1826
kono
parents:
diff changeset
1827 2012-06-01 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1828
kono
parents:
diff changeset
1829 PR c++/26155
kono
parents:
diff changeset
1830 * name-lookup.c (push_namespace): When error recovery is
kono
parents:
diff changeset
1831 impossible just error out in duplicate_decls.
kono
parents:
diff changeset
1832
kono
parents:
diff changeset
1833 2012-05-31 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
1834
kono
parents:
diff changeset
1835 * call.c: Do not include output.h.
kono
parents:
diff changeset
1836 * class.c: Likewise.
kono
parents:
diff changeset
1837 * except.c: Likewise.
kono
parents:
diff changeset
1838 * friend.c: Likewise.
kono
parents:
diff changeset
1839 * init.c: Likewise.
kono
parents:
diff changeset
1840 * lex.c: Likewise.
kono
parents:
diff changeset
1841 * method.c: Likewise.
kono
parents:
diff changeset
1842 * parser.c: Likewise.
kono
parents:
diff changeset
1843 * pt.c: Likewise.
kono
parents:
diff changeset
1844 * rtti.c: Likewise.
kono
parents:
diff changeset
1845 * search.c: Likewise.
kono
parents:
diff changeset
1846
kono
parents:
diff changeset
1847 2012-05-30 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1848
kono
parents:
diff changeset
1849 PR c++/53356
kono
parents:
diff changeset
1850 * tree.c (stabilize_init): Handle stabilizing a TARGET_EXPR
kono
parents:
diff changeset
1851 representing a bitwise copy of a glvalue.
kono
parents:
diff changeset
1852
kono
parents:
diff changeset
1853 * tree.c (stabilize_expr): Tweak logic.
kono
parents:
diff changeset
1854
kono
parents:
diff changeset
1855 PR c++/53356
kono
parents:
diff changeset
1856 * tree.c (stabilize_init): Side effects make the init unstable.
kono
parents:
diff changeset
1857
kono
parents:
diff changeset
1858 2012-05-28 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1859
kono
parents:
diff changeset
1860 PR c++/53503
kono
parents:
diff changeset
1861 * semantics.c (potential_constant_expression_1): Handle LTGT_EXPR.
kono
parents:
diff changeset
1862
kono
parents:
diff changeset
1863 2012-05-26 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1864
kono
parents:
diff changeset
1865 PR c++/53491
kono
parents:
diff changeset
1866 * tree.c (stabilize_expr): Handle exp of void type.
kono
parents:
diff changeset
1867
kono
parents:
diff changeset
1868 2012-05-26 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1869
kono
parents:
diff changeset
1870 PR c++/53220
kono
parents:
diff changeset
1871 * call.c (convert_like_real) [ck_list]: Take array address directly.
kono
parents:
diff changeset
1872 * typeck.c (decay_conversion): Reject decay of an array compound
kono
parents:
diff changeset
1873 literal.
kono
parents:
diff changeset
1874
kono
parents:
diff changeset
1875 2012-05-25 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1876
kono
parents:
diff changeset
1877 PR c++/32054
kono
parents:
diff changeset
1878 * parser.c (cp_parser_member_declaration): A storage class is not
kono
parents:
diff changeset
1879 allowed in a declaration of an anonymous aggregate in a class scope.
kono
parents:
diff changeset
1880
kono
parents:
diff changeset
1881 2012-05-24 Uros Bizjak <ubizjak@gmail.com>
kono
parents:
diff changeset
1882
kono
parents:
diff changeset
1883 PR obj-c++/53441
kono
parents:
diff changeset
1884 * decl.c (grokdeclarator): Check that current_class_type is non-NULL
kono
parents:
diff changeset
1885 before calling constructor_name_p.
kono
parents:
diff changeset
1886
kono
parents:
diff changeset
1887 2012-05-24 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1888
kono
parents:
diff changeset
1889 PR c++/32080
kono
parents:
diff changeset
1890 * parser.c (cp_parser_ctor_initializer_opt_and_function_body,
kono
parents:
diff changeset
1891 cp_parser_function_body): Add a bool parameter, true when parsing
kono
parents:
diff changeset
1892 a function-try-block.
kono
parents:
diff changeset
1893 (cp_parser_function_try_block): Pass true to the above.
kono
parents:
diff changeset
1894 (cp_parser_function_definition_after_declarator,
kono
parents:
diff changeset
1895 cp_parser_function_transaction): Adjust.
kono
parents:
diff changeset
1896
kono
parents:
diff changeset
1897 2012-05-23 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1898
kono
parents:
diff changeset
1899 PR c++/29185
kono
parents:
diff changeset
1900 * decl2.c (delete_sanity): Extend 'deleting array' warning to
kono
parents:
diff changeset
1901 any array type.
kono
parents:
diff changeset
1902
kono
parents:
diff changeset
1903 2012-05-21 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1904
kono
parents:
diff changeset
1905 PR c++/51184
kono
parents:
diff changeset
1906 * decl.c (grokdeclarator): Diagnose functions returning abstract
kono
parents:
diff changeset
1907 class types as TYPENAME.
kono
parents:
diff changeset
1908 * cp-tree.h (ABSTRACT_CLASS_TYPE_P): Add.
kono
parents:
diff changeset
1909 * except.c (is_admissible_throw_operand_or_catch_parameter): Use it.
kono
parents:
diff changeset
1910 * pt.c (tsubst): Likewise.
kono
parents:
diff changeset
1911 * semantics.c (trait_expr_value): Likewise.
kono
parents:
diff changeset
1912
kono
parents:
diff changeset
1913 2012-05-21 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1914
kono
parents:
diff changeset
1915 PR c++/40821
kono
parents:
diff changeset
1916 * parser.c (cp_parser_attributes_opt): Enforce error checking of
kono
parents:
diff changeset
1917 unbalanced parentheses in the presence of tentative parsing.
kono
parents:
diff changeset
1918
kono
parents:
diff changeset
1919 2012-05-17 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1920
kono
parents:
diff changeset
1921 PR c++/39681
kono
parents:
diff changeset
1922 * parser.c (cp_parser_new_type_id): Early return error_mark_node
kono
parents:
diff changeset
1923 if the cp_parser_type_specifier_seq call has type_specifier_seq.type
kono
parents:
diff changeset
1924 error_mark_node; tidy.
kono
parents:
diff changeset
1925 (cp_parser_new_expression): Always initialize nelts to NULL_TREE to
kono
parents:
diff changeset
1926 avoid uninitialized warnings.
kono
parents:
diff changeset
1927 (cp_parser_init_declarator, cp_parser_late_parse_one_default_arg):
kono
parents:
diff changeset
1928 Call cp_parser_skip_to_end_of_statement if cp_parser_initializer
kono
parents:
diff changeset
1929 returns error_mark_node.
kono
parents:
diff changeset
1930
kono
parents:
diff changeset
1931 2012-05-17 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1932
kono
parents:
diff changeset
1933 PR c++/53371
kono
parents:
diff changeset
1934 * except.c (is_admissible_throw_operand): Rename to
kono
parents:
diff changeset
1935 is_admissible_throw_operand_or_catch_parameter and handle
kono
parents:
diff changeset
1936 catch parameter too.
kono
parents:
diff changeset
1937 (expand_start_catch_block): Use it.
kono
parents:
diff changeset
1938 (build_throw): Adjust.
kono
parents:
diff changeset
1939
kono
parents:
diff changeset
1940 2012-05-17 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1941
kono
parents:
diff changeset
1942 PR c++/44516
kono
parents:
diff changeset
1943 * typeck.c (build_x_array_ref, build_x_conditional_expr,
kono
parents:
diff changeset
1944 build_x_compound_expr, build_x_modify_expr): Add location_t parameter.
kono
parents:
diff changeset
1945 (finish_class_member_access_expr, build_x_indirect_ref,
kono
parents:
diff changeset
1946 build_x_binary_op, build_x_compound_expr_from_list,
kono
parents:
diff changeset
1947 build_x_compound_expr_from_vec): Adjust callers.
kono
parents:
diff changeset
1948 * tree.c (build_min_nt_loc): New.
kono
parents:
diff changeset
1949 (build_min_nt): Remove.
kono
parents:
diff changeset
1950 * typeck2.c (build_x_arrow): Adjust callers.
kono
parents:
diff changeset
1951 * pt.c (tsubst_qualified_id, tsubst_omp_for_iterator,
kono
parents:
diff changeset
1952 tsubst_copy_and_build): Likewise.
kono
parents:
diff changeset
1953 * semantics.c (finish_mem_initializers, handle_omp_for_class_iterator,
kono
parents:
diff changeset
1954 finish_omp_atomic): Likewise.
kono
parents:
diff changeset
1955 * decl2.c (grok_array_decl, build_anon_union_vars): Adjust.
kono
parents:
diff changeset
1956 * parser.c (cp_parser_question_colon_clause,
kono
parents:
diff changeset
1957 cp_parser_assignment_expression, cp_parser_expression,
kono
parents:
diff changeset
1958 cp_parser_template_id, cp_parser_omp_for_loop): Likewise.
kono
parents:
diff changeset
1959 * cp-tree.h: Update.
kono
parents:
diff changeset
1960
kono
parents:
diff changeset
1961 2012-05-16 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
1962
kono
parents:
diff changeset
1963 PR preprocessor/7263
kono
parents:
diff changeset
1964 * cp-tree.h (enum cp_decl_spec): Add new enumerators to cover all
kono
parents:
diff changeset
1965 the possible declarator specifiers so far.
kono
parents:
diff changeset
1966 (struct cp_decl_specifier_seq::locations): Declare new member.
kono
parents:
diff changeset
1967 (cp_decl_specifier_seq::{specs, type_location}): Remove.
kono
parents:
diff changeset
1968 (decl_spec_seq_has_spec_p): Declare new function.
kono
parents:
diff changeset
1969 * parser.c (cp_parser_check_decl_spec): Remove.
kono
parents:
diff changeset
1970 (set_and_check_decl_spec_loc): Define new static function.
kono
parents:
diff changeset
1971 (decl_spec_seq_has_spec_p): Define new public function.
kono
parents:
diff changeset
1972 (cp_parser_decl_specifier_seq, cp_parser_function_specifier_opt)
kono
parents:
diff changeset
1973 (cp_parser_type_specifier, cp_parser_simple_type_specifier)
kono
parents:
diff changeset
1974 (cp_parser_set_storage_class, cp_parser_set_decl_spec_type)
kono
parents:
diff changeset
1975 (cp_parser_alias_declaration): Set the locations for each
kono
parents:
diff changeset
1976 declspec, using set_and_check_decl_spec_loc.
kono
parents:
diff changeset
1977 (cp_parser_explicit_instantiation, cp_parser_init_declarator)
kono
parents:
diff changeset
1978 (cp_parser_member_declaration, cp_parser_init_declarator): Use the
kono
parents:
diff changeset
1979 new declspec location for specifiers. Use the new
kono
parents:
diff changeset
1980 decl_spec_seq_has_spec_p.
kono
parents:
diff changeset
1981 (cp_parser_type_specifier_seq): Use the new
kono
parents:
diff changeset
1982 set_and_check_decl_spec_loc. Stop using
kono
parents:
diff changeset
1983 cp_parser_check_decl_spec. Use the new decl_spec_seq_has_spec_p.
kono
parents:
diff changeset
1984 (, cp_parser_init_declarator): Use the new
kono
parents:
diff changeset
1985 set_and_check_decl_spec_loc.
kono
parents:
diff changeset
1986 (cp_parser_single_declaration, cp_parser_friend_p)
kono
parents:
diff changeset
1987 (cp_parser_objc_class_ivars, cp_parser_objc_struct_declaration):
kono
parents:
diff changeset
1988 Use the new decl_spec_seq_has_spec_p.
kono
parents:
diff changeset
1989 * decl.c (check_tag_decl): Use new decl_spec_seq_has_spec_p. Use
kono
parents:
diff changeset
1990 the more precise ds_redefined_builtin_type_spec location for
kono
parents:
diff changeset
1991 diagnostics about re-declaring C++ built-in types.
kono
parents:
diff changeset
1992 (start_decl, grokvardecl, grokdeclarator): Use the new
kono
parents:
diff changeset
1993 decl_spec_seq_has_spec_p.
kono
parents:
diff changeset
1994
kono
parents:
diff changeset
1995 2012-05-15 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1996
kono
parents:
diff changeset
1997 PR c++/11856
kono
parents:
diff changeset
1998 * pt.c (tsubst_copy_and_build): Increase / decrease
kono
parents:
diff changeset
1999 c_inhibit_evaluation_warnings around build_x_binary_op call.
kono
parents:
diff changeset
2000
kono
parents:
diff changeset
2001 2012-05-12 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2002
kono
parents:
diff changeset
2003 * cp-tree.h (TYPE_PTRMEM_P): Rename to TYPE_PTRDATAMEM_P.
kono
parents:
diff changeset
2004 (TYPE_PTR_TO_MEMBER_P): Rename to TYPE_PTRMEM_P.
kono
parents:
diff changeset
2005 (TYPE_PTR_OR_PTRMEM_P): Add.
kono
parents:
diff changeset
2006 * typeck.c (composite_pointer_type_r, composite_pointer_type,
kono
parents:
diff changeset
2007 common_pointer_type, cp_build_indirect_ref, cp_build_binary_op,
kono
parents:
diff changeset
2008 cp_truthvalue_conversion, convert_ptrmem, build_static_cast_1,
kono
parents:
diff changeset
2009 build_reinterpret_cast_1, build_const_cast_1, comp_ptr_ttypes_real,
kono
parents:
diff changeset
2010 casts_away_constness_r, casts_away_constness): Adjust.
kono
parents:
diff changeset
2011 * init.c (build_zero_init_1): Adjust.
kono
parents:
diff changeset
2012 * class.c (check_field_decls): Likewise.
kono
parents:
diff changeset
2013 * decl.c (check_default_argument): Likewise.
kono
parents:
diff changeset
2014 * rtti.c (target_incomplete_p): Likewise.
kono
parents:
diff changeset
2015 * tree.c (zero_init_p): Likewise.
kono
parents:
diff changeset
2016 * cxx-pretty-print.c (pp_cxx_ptr_operator,
kono
parents:
diff changeset
2017 pp_cxx_abstract_declarator): Likewise.
kono
parents:
diff changeset
2018 * typeck2.c (build_m_component_ref): Likewise.
kono
parents:
diff changeset
2019 * pt.c (convert_nontype_argument, invalid_nontype_parm_type_p,
kono
parents:
diff changeset
2020 dependent_type_p_r): Likewise.
kono
parents:
diff changeset
2021 * call.c (null_member_pointer_value_p, standard_conversion,
kono
parents:
diff changeset
2022 add_builtin_candidate, build_conditional_expr_1, compare_ics):
kono
parents:
diff changeset
2023 Likewise.
kono
parents:
diff changeset
2024 * cp-objcp-common.c (cp_var_mod_type_p): Likewise.
kono
parents:
diff changeset
2025 * cvt.c (cp_convert_to_pointer, ocp_convert,
kono
parents:
diff changeset
2026 perform_qualification_conversions): Likewise.
kono
parents:
diff changeset
2027 * mangle.c (write_type): Likewise.
kono
parents:
diff changeset
2028 * name-lookup.c (arg_assoc_type): Likewise.
kono
parents:
diff changeset
2029
kono
parents:
diff changeset
2030 2012-05-12 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2031
kono
parents:
diff changeset
2032 * parser.c (struct cp_parser_expression_stack_entry): Add location_t
kono
parents:
diff changeset
2033 field.
kono
parents:
diff changeset
2034 (cp_parser_binary_expression): Rework to always update at the same
kono
parents:
diff changeset
2035 time tree_type and loc.
kono
parents:
diff changeset
2036 * call.c (print_z_candidate): Add location_t parameter.
kono
parents:
diff changeset
2037 (print_z_candidates, convert_like_real, joust): Adjust.
kono
parents:
diff changeset
2038
kono
parents:
diff changeset
2039 2012-05-11 Alexandre Oliva <aoliva@redhat.com>
kono
parents:
diff changeset
2040
kono
parents:
diff changeset
2041 PR c++/53209
kono
parents:
diff changeset
2042 * pt.c (tsubst_decl): Bail out if argvec is error_mark_node.
kono
parents:
diff changeset
2043
kono
parents:
diff changeset
2044 2012-05-11 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2045
kono
parents:
diff changeset
2046 PR c++/53305
kono
parents:
diff changeset
2047 * pt.c (tsubst_copy: case PARM_DECL): Return error_mark_node if
kono
parents:
diff changeset
2048 tsubst_decl returns NULL_TREE.
kono
parents:
diff changeset
2049 * cxx-pretty-print.c (pp_cxx_simple_type_specifier): Handle
kono
parents:
diff changeset
2050 BOUND_TEMPLATE_TEMPLATE_PARM.
kono
parents:
diff changeset
2051
kono
parents:
diff changeset
2052 2012-05-10 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2053
kono
parents:
diff changeset
2054 PR c++/53158
kono
parents:
diff changeset
2055 * cvt.c (ocp_convert): Error out early for void -> bool conversions.
kono
parents:
diff changeset
2056 * typeck.c (decay_conversion): Use error_at.
kono
parents:
diff changeset
2057 * call.c (build_integral_nontype_arg_conv, convert_like_real,
kono
parents:
diff changeset
2058 convert_arg_to_ellipsis, perform_implicit_conversion_flags,
kono
parents:
diff changeset
2059 initialize_reference): Likewise.
kono
parents:
diff changeset
2060 * cvt.c (warn_ref_binding): Add location_t parameter.
kono
parents:
diff changeset
2061 (cp_convert_to_pointer, convert_to_reference, ocp_convert,
kono
parents:
diff changeset
2062 convert_to_void, ): Use error_at and warning_at.
kono
parents:
diff changeset
2063
kono
parents:
diff changeset
2064 2012-05-10 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2065
kono
parents:
diff changeset
2066 PR c++/53301
kono
parents:
diff changeset
2067 * decl.c (check_default_argument): Fix typo (POINTER_TYPE_P
kono
parents:
diff changeset
2068 instead of TYPE_PTR_P) in zero-as-null-pointer-constant warning.
kono
parents:
diff changeset
2069
kono
parents:
diff changeset
2070 2012-05-06 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2071
kono
parents:
diff changeset
2072 PR c++/53152
kono
parents:
diff changeset
2073 * call.c (op_error, build_new_op_1, build_new_op): Add location_t
kono
parents:
diff changeset
2074 parameter.
kono
parents:
diff changeset
2075 (build_conditional_expr_1): Adjust.
kono
parents:
diff changeset
2076 * typeck.c (build_x_indirect_ref, build_x_binary_op,
kono
parents:
diff changeset
2077 build_x_unary_op): Add location_t parameter.
kono
parents:
diff changeset
2078 (rationalize_conditional_expr, build_x_array_ref,
kono
parents:
diff changeset
2079 build_x_compound_expr, cp_build_modify_expr, build_x_modify_expr):
kono
parents:
diff changeset
2080 Adjust.
kono
parents:
diff changeset
2081 * typeck2.c (build_x_arrow): Add location_t parameter.
kono
parents:
diff changeset
2082 * semantics.c (finish_unary_op_expr): Likewise.
kono
parents:
diff changeset
2083 (finish_increment_expr, handle_omp_for_class_iterator): Adjust.
kono
parents:
diff changeset
2084 * decl2.c (grok_array_decl): Add location_t parameter.
kono
parents:
diff changeset
2085 * parser.c (cp_parser_postfix_open_square_expression,
kono
parents:
diff changeset
2086 cp_parser_postfix_dot_deref_expression, cp_parser_unary_expression,
kono
parents:
diff changeset
2087 cp_parser_binary_expression, cp_parser_builtin_offsetof,
kono
parents:
diff changeset
2088 do_range_for_auto_deduction, cp_convert_range_for,
kono
parents:
diff changeset
2089 cp_parser_template_argument, cp_parser_omp_for_cond): Pass the
kono
parents:
diff changeset
2090 location, adjust.
kono
parents:
diff changeset
2091 * pt.c (tsubst_copy_and_build): Adjust.
kono
parents:
diff changeset
2092 * tree.c (maybe_dummy_object): Likewise.
kono
parents:
diff changeset
2093 * cp-tree.h: Update declarations.
kono
parents:
diff changeset
2094
kono
parents:
diff changeset
2095 2012-05-04 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2096
kono
parents:
diff changeset
2097 * semantics.c (cxx_eval_constant_expression, case CONVERT_EXPR): Tidy.
kono
parents:
diff changeset
2098
kono
parents:
diff changeset
2099 2012-05-04 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2100
kono
parents:
diff changeset
2101 PR c++/53166
kono
parents:
diff changeset
2102 * pt.c (instantiate_class_template_1): Increase / decrease
kono
parents:
diff changeset
2103 c_inhibit_evaluation_warnings around the tsubst_expr call
kono
parents:
diff changeset
2104 for STATIC_ASSERT_CONDITION.
kono
parents:
diff changeset
2105 (tsubst_expr, case STATIC_ASSERT): Likewise.
kono
parents:
diff changeset
2106 * typeck.c (cp_build_binary_op, case EQ_EXPR/NE_EXPR): Check
kono
parents:
diff changeset
2107 c_inhibit_evaluation_warnings in the OPT_Waddress warnings.
kono
parents:
diff changeset
2108
kono
parents:
diff changeset
2109 2012-05-03 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2110
kono
parents:
diff changeset
2111 PR c++/53186
kono
parents:
diff changeset
2112 * call.c (build_over_call): Handle final member functions
kono
parents:
diff changeset
2113 and class types.
kono
parents:
diff changeset
2114 (build_new_method_call_1): Do not handle here.
kono
parents:
diff changeset
2115
kono
parents:
diff changeset
2116 2012-05-02 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
2117
kono
parents:
diff changeset
2118 * decl.c (grokdeclarator): Properly check for sizes that
kono
parents:
diff changeset
2119 cover more than half of the address-space.
kono
parents:
diff changeset
2120
kono
parents:
diff changeset
2121 2012-04-30 Marc Glisse <marc.glisse@inria.fr>
kono
parents:
diff changeset
2122
kono
parents:
diff changeset
2123 PR c++/51033
kono
parents:
diff changeset
2124 * typeck.c (cp_build_array_ref): Handle VECTOR_TYPE.
kono
parents:
diff changeset
2125 * decl2.c (grok_array_decl): Likewise.
kono
parents:
diff changeset
2126
kono
parents:
diff changeset
2127 PR c++/51314
kono
parents:
diff changeset
2128 * parser.c (cp_parser_sizeof_operand): Require parentheses for
kono
parents:
diff changeset
2129 sizeof...
kono
parents:
diff changeset
2130
kono
parents:
diff changeset
2131 2012-04-30 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
2132
kono
parents:
diff changeset
2133 Fix location for static class members
kono
parents:
diff changeset
2134 * decl.c (grokdeclarator): Use the location carried by the
kono
parents:
diff changeset
2135 declarator for the DECL of the static class member.
kono
parents:
diff changeset
2136
kono
parents:
diff changeset
2137 Fix va_arg type location
kono
parents:
diff changeset
2138 * cp-tree.h (build_x_va_arg): Take an additional location
kono
parents:
diff changeset
2139 parameter.
kono
parents:
diff changeset
2140 * call.c (build_x_va_arg): Take a loc parameter for the location
kono
parents:
diff changeset
2141 of the type of the va_arg expression.
kono
parents:
diff changeset
2142 * parser.c (cp_parser_primary_expression): Pass the type of the
kono
parents:
diff changeset
2143 type in the va_arg expression to build_x_va_arg.
kono
parents:
diff changeset
2144 * pt.c (tsubst_copy): Adjust calls to build_x_va_arg.
kono
parents:
diff changeset
2145
kono
parents:
diff changeset
2146 Make conversion warnings work on NULL with -ftrack-macro-expansion
kono
parents:
diff changeset
2147 * call.c (conversion_null_warnings): Use the new
kono
parents:
diff changeset
2148 expansion_point_location_if_in_system_header.
kono
parents:
diff changeset
2149 * cvt.c (build_expr_type_conversion): Likewise.
kono
parents:
diff changeset
2150 * typeck.c (cp_build_binary_op): Likewise.
kono
parents:
diff changeset
2151
kono
parents:
diff changeset
2152 2012-04-30 Manuel López-Ibåñez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2153
kono
parents:
diff changeset
2154 * typeck.c (convert_for_assignment): Replace
kono
parents:
diff changeset
2155 Wmissing-format-attribute with Wsuggest-attribute=format.
kono
parents:
diff changeset
2156 * call.c (convert_for_arg_passing): Likewise.
kono
parents:
diff changeset
2157
kono
parents:
diff changeset
2158 2012-04-26 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2159
kono
parents:
diff changeset
2160 PR c++/53096
kono
parents:
diff changeset
2161 * class.c (check_bases_and_members): Implement core/1333, do not
kono
parents:
diff changeset
2162 disallow defaulted in the class body non-const ref special members.
kono
parents:
diff changeset
2163
kono
parents:
diff changeset
2164 2012-04-24 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2165
kono
parents:
diff changeset
2166 PR c++/52363
kono
parents:
diff changeset
2167 * call.c (tourney, perform_overload_resolution,
kono
parents:
diff changeset
2168 build_operator_new_call, build_user_type_conversion_1,
kono
parents:
diff changeset
2169 build_user_type_conversion, perform_overload_resolution,
kono
parents:
diff changeset
2170 add_template_candidate, add_template_candidate_real,
kono
parents:
diff changeset
2171 add_template_conv_candidate, add_builtin_candidates,
kono
parents:
diff changeset
2172 add_builtin_candidate, build_builtin_candidate,
kono
parents:
diff changeset
2173 add_conv_candidate, add_function_candidate, implicit_conversion,
kono
parents:
diff changeset
2174 reference_binding, build_list_conv, conditional_conversion,
kono
parents:
diff changeset
2175 add_candidates, can_convert_array, build_aggr_conv,
kono
parents:
diff changeset
2176 build_array_conv, build_complex_conv, conditional_conversion):
kono
parents:
diff changeset
2177 Add tsubst_flags_t parameter.
kono
parents:
diff changeset
2178 (joust): Likewise, use it to handle SFINAE as if pedantic.
kono
parents:
diff changeset
2179 (add_list_candidates, build_integral_nontype_arg_conv,
kono
parents:
diff changeset
2180 perform_overload_resolution, build_new_function_call,
kono
parents:
diff changeset
2181 build_operator_new_call, build_op_call_1,
kono
parents:
diff changeset
2182 build_conditional_expr_1, build_new_op_1, convert_like_real,
kono
parents:
diff changeset
2183 convert_arg_to_ellipsis, convert_default_arg,
kono
parents:
diff changeset
2184 convert_for_arg_passing, build_over_call,
kono
parents:
diff changeset
2185 build_new_method_call_1, can_convert_arg, can_convert_arg_bad,
kono
parents:
diff changeset
2186 perform_implicit_conversion_flags,
kono
parents:
diff changeset
2187 perform_direct_initialization_if_possible,
kono
parents:
diff changeset
2188 initialize_reference): Adjust.
kono
parents:
diff changeset
2189 * typeck.c (casts_away_constness, casts_away_constness_r):
kono
parents:
diff changeset
2190 Add tsubst_flags_t parameter.
kono
parents:
diff changeset
2191 (convert_arguments, check_for_casting_away_constness,
kono
parents:
diff changeset
2192 build_static_cast_1, build_ptrmemfunc, convert_for_assignment):
kono
parents:
diff changeset
2193 Adjust.
kono
parents:
diff changeset
2194 * decl.c (reshape_init_r, check_default_argument): Likewise.
kono
parents:
diff changeset
2195 * cp-gimplify.c (cxx_omp_clause_apply_fn): Likewise.
kono
parents:
diff changeset
2196 * pt.c (convert_nontype_argument, check_non_deducible_conversion):
kono
parents:
diff changeset
2197 Likewise.
kono
parents:
diff changeset
2198 * init.c (build_new_1): Likewise.
kono
parents:
diff changeset
2199 * cvt.c (convert_to_reference, ocp_convert, build_type_conversion,
kono
parents:
diff changeset
2200 build_expr_type_conversion, ): Likewise.
kono
parents:
diff changeset
2201 * search.c (check_final_overrider): Likewise.
kono
parents:
diff changeset
2202 * cp-tree.h (build_user_type_conversion,
kono
parents:
diff changeset
2203 build_operator_new_call, can_convert, can_convert_arg,
kono
parents:
diff changeset
2204 can_convert_arg_bad, convert_default_arg,
kono
parents:
diff changeset
2205 convert_arg_to_ellipsis, convert_for_arg_passing):
kono
parents:
diff changeset
2206 Adjust declaration.
kono
parents:
diff changeset
2207
kono
parents:
diff changeset
2208 2012-04-22 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
2209
kono
parents:
diff changeset
2210 * decl2.c (maybe_make_one_only): Mark keyed COMDATs as USED so they
kono
parents:
diff changeset
2211 gets finalized.
kono
parents:
diff changeset
2212
kono
parents:
diff changeset
2213 2012-04-22 Manuel López-Ibåñez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2214
kono
parents:
diff changeset
2215 PR c/44774
kono
parents:
diff changeset
2216 * typeck.c (composite_pointer_type): Likewise.
kono
parents:
diff changeset
2217 (cxx_sizeof_or_alignof_type): Likewise.
kono
parents:
diff changeset
2218 (cp_build_array_ref): Likewise.
kono
parents:
diff changeset
2219 (cp_build_function_call_vec): Likewise.
kono
parents:
diff changeset
2220 (cp_build_addr_expr_1): Likewise.
kono
parents:
diff changeset
2221 (convert_member_func_to_ptr): Likewise.
kono
parents:
diff changeset
2222 * decl.c (check_tag_decl): Likewise.
kono
parents:
diff changeset
2223 (check_static_variable_definition): Likewise.
kono
parents:
diff changeset
2224 (compute_array_index_type): Likewise.
kono
parents:
diff changeset
2225 (create_array_type_for_decl): Likewise.
kono
parents:
diff changeset
2226 (grokdeclarator): Likewise.
kono
parents:
diff changeset
2227 (grok_op_properties): Likewise.
kono
parents:
diff changeset
2228 * error.c (maybe_warn_cpp0x): Likewise.
kono
parents:
diff changeset
2229 * pt.c (maybe_process_partial_specialization): Likewise.
kono
parents:
diff changeset
2230 (convert_template_argument): Likewise.
kono
parents:
diff changeset
2231 (do_decl_instantiation): Likewise.
kono
parents:
diff changeset
2232 (do_type_instantiation): Likewise.
kono
parents:
diff changeset
2233 * parser.c (cp_parser_primary_expression): Likewise.
kono
parents:
diff changeset
2234 (cp_parser_postfix_expression): Likewise.
kono
parents:
diff changeset
2235 (cp_parser_unary_expression): Likewise.
kono
parents:
diff changeset
2236 (cp_parser_question_colon_clause): Likewise.
kono
parents:
diff changeset
2237 (cp_parser_lambda_introducer): Likewise.
kono
parents:
diff changeset
2238 (cp_parser_lambda_declarator_opt): Likewise.
kono
parents:
diff changeset
2239 (cp_parser_compound_statement): Likewise.
kono
parents:
diff changeset
2240 (cp_parser_jump_statement): Likewise.
kono
parents:
diff changeset
2241 (cp_parser_declaration_seq_opt): Likewise.
kono
parents:
diff changeset
2242 (cp_parser_enum_specifier): Likewise.
kono
parents:
diff changeset
2243 (cp_parser_enumerator_list): Likewise.
kono
parents:
diff changeset
2244 (cp_parser_initializer_list): Likewise.
kono
parents:
diff changeset
2245 (cp_parser_member_declaration): Likewise.
kono
parents:
diff changeset
2246 * call.c (build_conditional_expr_1): Likewise.
kono
parents:
diff changeset
2247 * friend.c (make_friend_class): Likewise.
kono
parents:
diff changeset
2248 * name-lookup.c (pushdecl_maybe_friend_1): Likewise.
kono
parents:
diff changeset
2249
kono
parents:
diff changeset
2250 2012-04-21 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
2251
kono
parents:
diff changeset
2252 * method.c (make_alias_for): Do not set TREE_SYMBOL_REFERENCED.
kono
parents:
diff changeset
2253 * decl2.c (mark_needed): Likewise.
kono
parents:
diff changeset
2254 (decl_needed_p): Do not test TREE_SYMBOL_REFERENCED.
kono
parents:
diff changeset
2255
kono
parents:
diff changeset
2256 * decl2.c (cxx_callgraph_analyze_expr): Remove.
kono
parents:
diff changeset
2257 * cp-objcp-common.h (LANG_HOOKS_CALLGRAPH_ANALYZE_EXPR): Remove.
kono
parents:
diff changeset
2258 * cp-tree.h (cxx_callgraph_analyze_expr): Remove.
kono
parents:
diff changeset
2259
kono
parents:
diff changeset
2260 2012-04-21 Manuel López-Ibåñez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2261
kono
parents:
diff changeset
2262 PR 35441
kono
parents:
diff changeset
2263 * typeck.c (cp_build_function_call_vec): Do not pretty-print
kono
parents:
diff changeset
2264 expressions when caret is enabled.
kono
parents:
diff changeset
2265
kono
parents:
diff changeset
2266 2012-04-20 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
2267
kono
parents:
diff changeset
2268 PR target/53042
kono
parents:
diff changeset
2269 * decl2.c (maybe_emit_vtables): Do not initialize same_comdat_group
kono
parents:
diff changeset
2270 list when target has no support for it.
kono
parents:
diff changeset
2271
kono
parents:
diff changeset
2272 2012-04-20 Michael Matz <matz@suse.de>
kono
parents:
diff changeset
2273
kono
parents:
diff changeset
2274 * error.c (pedwarn_cxx98): Move va_end call after user
kono
parents:
diff changeset
2275 of the va_list.
kono
parents:
diff changeset
2276
kono
parents:
diff changeset
2277 2012-04-18 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2278
kono
parents:
diff changeset
2279 PR c++/52422
kono
parents:
diff changeset
2280 * cp-tree.h (build_addr_func, decay_conversion,
kono
parents:
diff changeset
2281 get_member_function_from_ptrfunc,
kono
parents:
diff changeset
2282 build_m_component_ref, convert_member_func_to_ptr):
kono
parents:
diff changeset
2283 Add tsubst_flags_t parameter.
kono
parents:
diff changeset
2284 * typeck.c (cp_default_conversion): Add.
kono
parents:
diff changeset
2285 (decay_conversion, default_conversion,
kono
parents:
diff changeset
2286 get_member_function_from_ptrfunc, convert_member_func_to_ptr):
kono
parents:
diff changeset
2287 Add tsubst_flags_t parameter and use it throughout.
kono
parents:
diff changeset
2288 (cp_build_indirect_ref, cp_build_array_ref,
kono
parents:
diff changeset
2289 cp_build_function_call_vec, convert_arguments, build_x_binary_op,
kono
parents:
diff changeset
2290 cp_build_binary_op, cp_build_unary_op, build_reinterpret_cast_1,
kono
parents:
diff changeset
2291 build_const_cast_1, expand_ptrmemfunc_cst,
kono
parents:
diff changeset
2292 convert_for_initialization): Adjust.
kono
parents:
diff changeset
2293 * init.c (build_vec_init): Adjust.
kono
parents:
diff changeset
2294 * decl.c (grok_reference_init, get_atexit_node): Likewise.
kono
parents:
diff changeset
2295 * rtti.c (build_dynamic_cast_1, tinfo_base_init): Likewise.
kono
parents:
diff changeset
2296 * except.c (build_throw): Likewise.
kono
parents:
diff changeset
2297 * typeck2.c (build_x_arrow): Likewise.
kono
parents:
diff changeset
2298 (build_m_component_ref): Add tsubst_flags_t parameter and
kono
parents:
diff changeset
2299 use it throughout.
kono
parents:
diff changeset
2300 * pt.c (convert_nontype_argument): Adjust.
kono
parents:
diff changeset
2301 * semantics.c (finish_asm_stmt, maybe_add_lambda_conv_op): Likewise.
kono
parents:
diff changeset
2302 * decl2.c (build_offset_ref_call_from_tree): Likewise.
kono
parents:
diff changeset
2303 * call.c (build_addr_func): Add tsubst_flags_t parameter and
kono
parents:
diff changeset
2304 use it throughout.
kono
parents:
diff changeset
2305 (build_call_a, build_conditional_expr_1, build_new_op_1,
kono
parents:
diff changeset
2306 convert_like_real, convert_arg_to_ellipsis, build_over_call,
kono
parents:
diff changeset
2307 build_special_member_call): Adjust.
kono
parents:
diff changeset
2308 * cvt.c (cp_convert_to_pointer, force_rvalue,
kono
parents:
diff changeset
2309 build_expr_type_conversion): Likewise.
kono
parents:
diff changeset
2310
kono
parents:
diff changeset
2311 2012-04-17 Tom de Vries <tom@codesourcery.com>
kono
parents:
diff changeset
2312
kono
parents:
diff changeset
2313 * cp-gimplify.c (begin_bc_block): Add location parameter and use as
kono
parents:
diff changeset
2314 location argument to create_artificial_label.
kono
parents:
diff changeset
2315 (finish_bc_block): Change return type to void. Remove body_seq
kono
parents:
diff changeset
2316 parameter, and add block parameter. Append label to STMT_LIST and
kono
parents:
diff changeset
2317 return in block.
kono
parents:
diff changeset
2318 (gimplify_cp_loop, gimplify_for_stmt, gimplify_while_stmt)
kono
parents:
diff changeset
2319 (gimplify_do_stmt, gimplify_switch_stmt): Remove function.
kono
parents:
diff changeset
2320 (genericize_cp_loop, genericize_for_stmt, genericize_while_stmt)
kono
parents:
diff changeset
2321 (genericize_do_stmt, genericize_switch_stmt, genericize_continue_stmt)
kono
parents:
diff changeset
2322 (genericize_break_stmt, genericize_omp_for_stmt): New function.
kono
parents:
diff changeset
2323 (cp_gimplify_omp_for): Remove bc_continue processing.
kono
parents:
diff changeset
2324 (cp_gimplify_expr): Genericize VEC_INIT_EXPR.
kono
parents:
diff changeset
2325 (cp_gimplify_expr): Mark FOR_STMT, WHILE_STMT, DO_STMT, SWITCH_STMT,
kono
parents:
diff changeset
2326 CONTINUE_STMT, and BREAK_STMT as unreachable.
kono
parents:
diff changeset
2327 (cp_genericize_r): Genericize FOR_STMT, WHILE_STMT, DO_STMT,
kono
parents:
diff changeset
2328 SWITCH_STMT, CONTINUE_STMT, BREAK_STMT and OMP_FOR.
kono
parents:
diff changeset
2329 (cp_genericize_tree): New function, factored out of ...
kono
parents:
diff changeset
2330 (cp_genericize): ... this function.
kono
parents:
diff changeset
2331
kono
parents:
diff changeset
2332 2012-04-17 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2333
kono
parents:
diff changeset
2334 PR c++/52599
kono
parents:
diff changeset
2335 * semantics.c (build_constexpr_constructor_member_initializers):
kono
parents:
diff changeset
2336 Check for function-try-block as function-body.
kono
parents:
diff changeset
2337
kono
parents:
diff changeset
2338 2012-04-17 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2339
kono
parents:
diff changeset
2340 PR c++/53003
kono
parents:
diff changeset
2341 * parser.c (cp_parser_member_declaration): Check that
kono
parents:
diff changeset
2342 initializer_token_start is non null before dereferencing it.
kono
parents:
diff changeset
2343
kono
parents:
diff changeset
2344 2012-04-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2345
kono
parents:
diff changeset
2346 PR c++/38543
kono
parents:
diff changeset
2347 * pt.c (determine_specialization): Instead of comparing the number
kono
parents:
diff changeset
2348 of parms, check that tsubst gives the right answer.
kono
parents:
diff changeset
2349
kono
parents:
diff changeset
2350 PR c++/52008
kono
parents:
diff changeset
2351 * pt.c (process_partial_specialization): Complain about a partial
kono
parents:
diff changeset
2352 specialization with fewer args than primary template parms.
kono
parents:
diff changeset
2353
kono
parents:
diff changeset
2354 PR c++/50830
kono
parents:
diff changeset
2355 * pt.c (convert_template_argument): Handle template template
kono
parents:
diff changeset
2356 argument packs.
kono
parents:
diff changeset
2357
kono
parents:
diff changeset
2358 PR c++/50303
kono
parents:
diff changeset
2359 * pt.c (tsubst_pack_expansion): Use tsubst_expr for template
kono
parents:
diff changeset
2360 template parameters.
kono
parents:
diff changeset
2361
kono
parents:
diff changeset
2362 2012-04-16 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2363
kono
parents:
diff changeset
2364 PR c++/49152
kono
parents:
diff changeset
2365 * call.c (op_error): Print types; when flag_diagnostics_show_caret
kono
parents:
diff changeset
2366 is false print expressions too.
kono
parents:
diff changeset
2367 (op_error_string): Add.
kono
parents:
diff changeset
2368
kono
parents:
diff changeset
2369 2012-04-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2370
kono
parents:
diff changeset
2371 PR c++/51148
kono
parents:
diff changeset
2372 * friend.c (make_friend_class): Call check_for_bare_parameter_packs.
kono
parents:
diff changeset
2373
kono
parents:
diff changeset
2374 2012-04-16 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
2375
kono
parents:
diff changeset
2376 * decl2.c (collect_candidates_for_java_method_alias): Use FOR_EACH
kono
parents:
diff changeset
2377 walkers to walk cgraph and varpool.
kono
parents:
diff changeset
2378
kono
parents:
diff changeset
2379 2012-04-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2380
kono
parents:
diff changeset
2381 PR c++/47220
kono
parents:
diff changeset
2382 * pt.c (coerce_template_parameter_pack): Check for error_mark_node.
kono
parents:
diff changeset
2383
kono
parents:
diff changeset
2384 PR c++/52292
kono
parents:
diff changeset
2385 PR c++/52380
kono
parents:
diff changeset
2386 * pt.c (coerce_template_parms): Even if we aren't converting we
kono
parents:
diff changeset
2387 want to expand argument packs.
kono
parents:
diff changeset
2388
kono
parents:
diff changeset
2389 PR c++/52706
kono
parents:
diff changeset
2390 * mangle.c (write_type): nullptr_t is a builtin type.
kono
parents:
diff changeset
2391
kono
parents:
diff changeset
2392 2012-04-14 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
2393
kono
parents:
diff changeset
2394 * tree.c: Update field referenced for new cgraph/varpool layout.
kono
parents:
diff changeset
2395 * decl2.c: Likewise.
kono
parents:
diff changeset
2396
kono
parents:
diff changeset
2397 2012-04-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2398
kono
parents:
diff changeset
2399 PR c++/52824
kono
parents:
diff changeset
2400 * pt.c (any_pack_expanson_args_p): New.
kono
parents:
diff changeset
2401 (coerce_template_parms): Use it.
kono
parents:
diff changeset
2402
kono
parents:
diff changeset
2403 PR c++/52905
kono
parents:
diff changeset
2404 * call.c (joust): Handle comparing list and non-list ctors.
kono
parents:
diff changeset
2405
kono
parents:
diff changeset
2406 PR c++/52915
kono
parents:
diff changeset
2407 * decl2.c (finish_anon_union): Use cp_finish_decl.
kono
parents:
diff changeset
2408 * error.c (dump_function_name): Avoid showing anonymous "name".
kono
parents:
diff changeset
2409
kono
parents:
diff changeset
2410 2012-04-11 Fabien ChĂȘne <fabien@gcc.gnu.org>
kono
parents:
diff changeset
2411
kono
parents:
diff changeset
2412 PR c++/52465
kono
parents:
diff changeset
2413 * parser.c (cp_parser_class_name): Call strip_using_decl and
kono
parents:
diff changeset
2414 return the target decl.
kono
parents:
diff changeset
2415 * name-lookup.c (strip_using_decl): Returns NULL_TREE if the decl
kono
parents:
diff changeset
2416 to be stripped is NULL_TREE.
kono
parents:
diff changeset
2417 (qualify_lookup): Call strip_using_decl and perform some checks on
kono
parents:
diff changeset
2418 the target decl.
kono
parents:
diff changeset
2419
kono
parents:
diff changeset
2420 2012-04-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2421
kono
parents:
diff changeset
2422 PR debug/45088
kono
parents:
diff changeset
2423 * decl.c (grokdeclarator): Strip the injected-class-name typedef
kono
parents:
diff changeset
2424 if we are building a declaration or compound type.
kono
parents:
diff changeset
2425
kono
parents:
diff changeset
2426 PR c++/52906
kono
parents:
diff changeset
2427 * decl.c (check_tag_decl): Don't complain about attributes if we
kono
parents:
diff changeset
2428 don't even have a type.
kono
parents:
diff changeset
2429
kono
parents:
diff changeset
2430 2012-04-10 Manuel López-Ibåñez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2431
kono
parents:
diff changeset
2432 * cvt.c (convert_to_void): Update comment.
kono
parents:
diff changeset
2433
kono
parents:
diff changeset
2434 2012-04-05 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2435
kono
parents:
diff changeset
2436 PR c++/52596
kono
parents:
diff changeset
2437 * semantics.c (finish_non_static_data_member): In templates, pass
kono
parents:
diff changeset
2438 the decl to build_qualified_name.
kono
parents:
diff changeset
2439 * tree.c (lvalue_kind) [SCOPE_REF]: Handle FIELD_DECL.
kono
parents:
diff changeset
2440
kono
parents:
diff changeset
2441 2012-04-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2442
kono
parents:
diff changeset
2443 PR c++/52845
kono
parents:
diff changeset
2444 * decl.c (finish_function): Update fntype after deducing return type.
kono
parents:
diff changeset
2445
kono
parents:
diff changeset
2446 2012-04-03 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2447
kono
parents:
diff changeset
2448 PR c++/52796
kono
parents:
diff changeset
2449 * pt.c (tsubst_initializer_list): A pack expansion with no elements
kono
parents:
diff changeset
2450 means value-initialization.
kono
parents:
diff changeset
2451
kono
parents:
diff changeset
2452 2012-04-01 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2453
kono
parents:
diff changeset
2454 PR c++/50043
kono
parents:
diff changeset
2455 * class.c (deduce_noexcept_on_destructor,
kono
parents:
diff changeset
2456 deduce_noexcept_on_destructors): New.
kono
parents:
diff changeset
2457 (check_bases_and_members): Call the latter.
kono
parents:
diff changeset
2458 * decl.c (grokfndecl): Call the former.
kono
parents:
diff changeset
2459 * method.c (implicitly_declare_fn): Not static.
kono
parents:
diff changeset
2460 * cp-tree.h (deduce_noexcept_on_destructor, implicitly_declare_fn):
kono
parents:
diff changeset
2461 Declare
kono
parents:
diff changeset
2462
kono
parents:
diff changeset
2463 2012-03-29 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2464
kono
parents:
diff changeset
2465 PR c++/52718
kono
parents:
diff changeset
2466 * decl.c (check_default_argument): With -Wzero-as-null-pointer-constant
kono
parents:
diff changeset
2467 warn for a zero as null pointer constant default argument.
kono
parents:
diff changeset
2468
kono
parents:
diff changeset
2469 2012-03-29 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2470
kono
parents:
diff changeset
2471 PR c++/52685
kono
parents:
diff changeset
2472 * tree.c (copy_binfo): Handle BINFO_DEPENDENT_BASE_P.
kono
parents:
diff changeset
2473
kono
parents:
diff changeset
2474 2012-03-29 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2475
kono
parents:
diff changeset
2476 PR c++/52759
kono
parents:
diff changeset
2477 * decl.c (start_decl): Don't call maybe_apply_pragma_weak
kono
parents:
diff changeset
2478 if processing_template_decl.
kono
parents:
diff changeset
2479
kono
parents:
diff changeset
2480 2012-03-29 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2481
kono
parents:
diff changeset
2482 PR c++/52743
kono
parents:
diff changeset
2483 * call.c (compare_ics): Handle ck_aggr like ck_list.
kono
parents:
diff changeset
2484
kono
parents:
diff changeset
2485 2012-03-28 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2486
kono
parents:
diff changeset
2487 PR c++/52746
kono
parents:
diff changeset
2488 * typeck.c (lookup_destructor): Clear BASELINK_QUALIFIED_P if
kono
parents:
diff changeset
2489 we didn't get an explicit scope.
kono
parents:
diff changeset
2490 * pt.c (tsubst_baselink): Likewise.
kono
parents:
diff changeset
2491
kono
parents:
diff changeset
2492 2012-03-28 Richard Guenther <rguenther@suse.de>
kono
parents:
diff changeset
2493
kono
parents:
diff changeset
2494 * typeck2.c (process_init_constructor_array): Use the proper
kono
parents:
diff changeset
2495 type for computing the array length.
kono
parents:
diff changeset
2496
kono
parents:
diff changeset
2497 2012-03-27 Meador Inge <meadori@codesourcery.com>
kono
parents:
diff changeset
2498
kono
parents:
diff changeset
2499 PR c++/52672
kono
parents:
diff changeset
2500 * semantics.c (cxx_fold_indirect_ref): Don't attempt to fold
kono
parents:
diff changeset
2501 stripped child trees that are not pointer types.
kono
parents:
diff changeset
2502
kono
parents:
diff changeset
2503 2012-03-21 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2504
kono
parents:
diff changeset
2505 Implement return type deduction for normal functions with -std=c++1y.
kono
parents:
diff changeset
2506 * cp-tree.h (FNDECL_USED_AUTO): New macro.
kono
parents:
diff changeset
2507 (LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P): Remove.
kono
parents:
diff changeset
2508 (dependent_lambda_return_type_node): Remove.
kono
parents:
diff changeset
2509 (CPTI_DEPENDENT_LAMBDA_RETURN_TYPE): Remove.
kono
parents:
diff changeset
2510 (struct language_function): Add x_auto_return_pattern field.
kono
parents:
diff changeset
2511 (current_function_auto_return_pattern): New.
kono
parents:
diff changeset
2512 (enum tsubst_flags): Add tf_partial.
kono
parents:
diff changeset
2513 * decl.c (decls_match): Handle auto return comparison.
kono
parents:
diff changeset
2514 (duplicate_decls): Adjust error message for auto return.
kono
parents:
diff changeset
2515 (cxx_init_decl_processing): Remove dependent_lambda_return_type_node.
kono
parents:
diff changeset
2516 (cp_finish_decl): Don't do auto deduction for functions.
kono
parents:
diff changeset
2517 (grokdeclarator): Allow auto return without trailing return type in
kono
parents:
diff changeset
2518 C++1y mode.
kono
parents:
diff changeset
2519 (check_function_type): Defer checking of deduced return type.
kono
parents:
diff changeset
2520 (start_preparsed_function): Set current_function_auto_return_pattern.
kono
parents:
diff changeset
2521 (finish_function): Set deduced return type to void if not previously
kono
parents:
diff changeset
2522 deduced.
kono
parents:
diff changeset
2523 * decl2.c (change_return_type): Handle error_mark_node.
kono
parents:
diff changeset
2524 (mark_used): Always instantiate functions with deduced return type.
kono
parents:
diff changeset
2525 Complain about use if deduction isn't done.
kono
parents:
diff changeset
2526 * parser.c (cp_parser_lambda_declarator_opt): Use 'auto' for
kono
parents:
diff changeset
2527 initial return type.
kono
parents:
diff changeset
2528 (cp_parser_lambda_body): Don't deduce return type in a template.
kono
parents:
diff changeset
2529 (cp_parser_conversion_type_id): Allow auto in C++1y.
kono
parents:
diff changeset
2530 * pt.c (instantiate_class_template_1): Don't mess with
kono
parents:
diff changeset
2531 LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P.
kono
parents:
diff changeset
2532 (tsubst_copy_and_build): Likewise.
kono
parents:
diff changeset
2533 (fn_type_unification, tsubst): Don't reduce the template parm level
kono
parents:
diff changeset
2534 of 'auto' during deduction.
kono
parents:
diff changeset
2535 (unify): Compare 'auto' specially.
kono
parents:
diff changeset
2536 (get_bindings): Change test.
kono
parents:
diff changeset
2537 (always_instantiate_p): Always instantiate functions with deduced
kono
parents:
diff changeset
2538 return type.
kono
parents:
diff changeset
2539 (do_auto_deduction): Handle error_mark_node and lambda context.
kono
parents:
diff changeset
2540 Don't check for use in initializer.
kono
parents:
diff changeset
2541 (contains_auto_r): Remove.
kono
parents:
diff changeset
2542 * search.c (lookup_conversions_r): Handle auto conversion function.
kono
parents:
diff changeset
2543 * semantics.c (lambda_return_type): Handle null return. Don't mess
kono
parents:
diff changeset
2544 with dependent_lambda_return_type_node.
kono
parents:
diff changeset
2545 (apply_deduced_return_type): Rename from apply_lambda_return_type.
kono
parents:
diff changeset
2546 * typeck.c (merge_types): Handle auto.
kono
parents:
diff changeset
2547 (check_return_expr): Do auto deduction.
kono
parents:
diff changeset
2548 * typeck2.c (add_exception_specifier): Fix complain check.
kono
parents:
diff changeset
2549
kono
parents:
diff changeset
2550 2012-03-22 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2551
kono
parents:
diff changeset
2552 PR c++/52487
kono
parents:
diff changeset
2553 * class.c (check_field_decls): Call literal_type_p only
kono
parents:
diff changeset
2554 on complete types.
kono
parents:
diff changeset
2555
kono
parents:
diff changeset
2556 2012-03-22 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2557
kono
parents:
diff changeset
2558 PR c++/52671
kono
parents:
diff changeset
2559 * decl.c (check_tag_decl): Only use CLASSTYPE_TEMPLATE_INSTANTIATION
kono
parents:
diff changeset
2560 on CLASS_TYPE_P types.
kono
parents:
diff changeset
2561
kono
parents:
diff changeset
2562 2012-03-20 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2563
kono
parents:
diff changeset
2564 * lex.c (init_reswords): Use >= for cxx_dialect test.
kono
parents:
diff changeset
2565 * parser.c (cp_parser_exception_specification_opt): Likewise.
kono
parents:
diff changeset
2566
kono
parents:
diff changeset
2567 * mangle.c (write_type): Handle 'auto'.
kono
parents:
diff changeset
2568 * init.c (build_new): Don't do auto deduction where it might
kono
parents:
diff changeset
2569 affect template mangling.
kono
parents:
diff changeset
2570
kono
parents:
diff changeset
2571 PR c++/52510
kono
parents:
diff changeset
2572 * decl.c (reshape_init_class): Handle repeated reshaping.
kono
parents:
diff changeset
2573 * search.c (lookup_field_1): Add sanity check.
kono
parents:
diff changeset
2574
kono
parents:
diff changeset
2575 2012-03-19 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2576
kono
parents:
diff changeset
2577 PR c++/14710
kono
parents:
diff changeset
2578 * cp-tree.h (xvalue_p, maybe_warn_about_useless_cast): Declare.
kono
parents:
diff changeset
2579 * tree.c (xvalue_p): Define.
kono
parents:
diff changeset
2580 * typeck.c (maybe_warn_about_useless_cast): Define.
kono
parents:
diff changeset
2581 (build_reinterpret_cast, build_const_cast,
kono
parents:
diff changeset
2582 build_static_cast, cp_build_c_cast): Use maybe_warn_about_useless_cast.
kono
parents:
diff changeset
2583 * rtti.c (build_dynamic_cast): Likewise.
kono
parents:
diff changeset
2584 * pt.c (tsubst_copy_and_build, case CAST_EXPR): Increment/decrement
kono
parents:
diff changeset
2585 c_inhibit_evaluation_warnings before/after the build_* calls.
kono
parents:
diff changeset
2586
kono
parents:
diff changeset
2587 2012-03-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2588
kono
parents:
diff changeset
2589 PR c++/52582
kono
parents:
diff changeset
2590 * method.c (implicitly_declare_fn): Set DECL_EXTERNAL.
kono
parents:
diff changeset
2591
kono
parents:
diff changeset
2592 2012-03-15 Manuel López-Ibåñez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2593
kono
parents:
diff changeset
2594 PR c++/44783
kono
parents:
diff changeset
2595 * error.c (print_instantiation_partial_context): Use
kono
parents:
diff changeset
2596 template_backtrace_limit.
kono
parents:
diff changeset
2597
kono
parents:
diff changeset
2598 2012-03-14 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>
kono
parents:
diff changeset
2599
kono
parents:
diff changeset
2600 * Make-lang.in (doc/g++.1): Remove IRIX 6.5 reference.
kono
parents:
diff changeset
2601
kono
parents:
diff changeset
2602 2012-03-14 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2603
kono
parents:
diff changeset
2604 PR c++/52521
kono
parents:
diff changeset
2605 * parser.c (lookup_literal_operator): Return fn only if
kono
parents:
diff changeset
2606 processed all arguments from args vector and argtypes is
kono
parents:
diff changeset
2607 void_list_node.
kono
parents:
diff changeset
2608
kono
parents:
diff changeset
2609 2012-01-30 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
2610
kono
parents:
diff changeset
2611 PR c++/51641
kono
parents:
diff changeset
2612 * cp-tree.h (template_type_parameter_p): Declare new function.
kono
parents:
diff changeset
2613 (parameter_of_template_p): Remove.
kono
parents:
diff changeset
2614 * pt.c (template_type_parameter_p): Define new function.
kono
parents:
diff changeset
2615 (parameter_of_template_p): Remove.
kono
parents:
diff changeset
2616 * name-lookup.c (binding_to_template_parms_of_scope_p): Don't rely
kono
parents:
diff changeset
2617 on parameter_of_template_p anymore. Compare the level of the
kono
parents:
diff changeset
2618 template parameter to the depth of the template.
kono
parents:
diff changeset
2619
kono
parents:
diff changeset
2620 2011-12-15 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
2621
kono
parents:
diff changeset
2622 * call.c (standard_conversion, build_integral_nontype_arg_conv)
kono
parents:
diff changeset
2623 (build_new_op_1, convert_like_real, is_subseq)
kono
parents:
diff changeset
2624 (maybe_handle_implicit_object, maybe_handle_ref_bind, compare_ics)
kono
parents:
diff changeset
2625 (joust): Use next_conversion instead of accessing fields of struct
kono
parents:
diff changeset
2626 conversion directly.
kono
parents:
diff changeset
2627
kono
parents:
diff changeset
2628 2012-03-12 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2629
kono
parents:
diff changeset
2630 PR c++/52299
kono
parents:
diff changeset
2631 * pt.c (tsubst_copy_and_build, case COND_EXPR): Avoid bogus
kono
parents:
diff changeset
2632 division by zero warnings.
kono
parents:
diff changeset
2633
kono
parents:
diff changeset
2634 2012-03-08 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2635
kono
parents:
diff changeset
2636 * typeck.c (build_array_ref, cp_build_addr_expr_1, convert_ptrmem,
kono
parents:
diff changeset
2637 build_ptrmemfunc): Consistently forward the tsubst_flags_t
kono
parents:
diff changeset
2638 parameter.
kono
parents:
diff changeset
2639 * call.c (resolve_args): Likewise.
kono
parents:
diff changeset
2640
kono
parents:
diff changeset
2641 2012-03-07 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2642
kono
parents:
diff changeset
2643 PR c++/52521
kono
parents:
diff changeset
2644 * mangle.c (write_literal_operator_name): The length comes after the
kono
parents:
diff changeset
2645 operator prefix.
kono
parents:
diff changeset
2646
kono
parents:
diff changeset
2647 2012-03-05 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2648
kono
parents:
diff changeset
2649 * pt.c (local_specializations): Change from htab_t into
kono
parents:
diff changeset
2650 struct pointer_map_t *.
kono
parents:
diff changeset
2651 (retrieve_local_specializations, register_local_specialization,
kono
parents:
diff changeset
2652 tsubst_pack_expansion, instantiate_decl): Adjust users.
kono
parents:
diff changeset
2653 (eq_local_specializations, hash_local_specialization): Remove.
kono
parents:
diff changeset
2654
kono
parents:
diff changeset
2655 2012-03-05 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2656
kono
parents:
diff changeset
2657 PR c++/51930
kono
parents:
diff changeset
2658 * decl2.c (determine_visibility): Correct calculation of class
kono
parents:
diff changeset
2659 args depth.
kono
parents:
diff changeset
2660 * decl.c (check_tag_decl): Adjust warning.
kono
parents:
diff changeset
2661
kono
parents:
diff changeset
2662 * method.c (synthesized_method_walk): Cleanups don't affect the EH
kono
parents:
diff changeset
2663 spec either.
kono
parents:
diff changeset
2664
kono
parents:
diff changeset
2665 2012-03-03 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2666
kono
parents:
diff changeset
2667 * init.c (perform_member_init): Cope with uninstantiated NSDMI.
kono
parents:
diff changeset
2668
kono
parents:
diff changeset
2669 Core 1270
kono
parents:
diff changeset
2670 * call.c (build_aggr_conv): Call reshape_init.
kono
parents:
diff changeset
2671 (convert_like_real): Likewise.
kono
parents:
diff changeset
2672 * typeck2.c (process_init_constructor): Clear TREE_CONSTANT if
kono
parents:
diff changeset
2673 not all constant.
kono
parents:
diff changeset
2674
kono
parents:
diff changeset
2675 * mangle.c (write_nested_name): Use decl_mangling_context.
kono
parents:
diff changeset
2676 (write_prefix, write_template_prefix): Likewise.
kono
parents:
diff changeset
2677
kono
parents:
diff changeset
2678 PR c++/36797
kono
parents:
diff changeset
2679 * mangle.c (write_expression): Improve diagnostic for TRAIT_EXPR.
kono
parents:
diff changeset
2680
kono
parents:
diff changeset
2681 * class.c (add_method): Always build an OVERLOAD for using-decls.
kono
parents:
diff changeset
2682 * search.c (lookup_member): Handle getting an OVERLOAD for a
kono
parents:
diff changeset
2683 single function.
kono
parents:
diff changeset
2684
kono
parents:
diff changeset
2685 2012-03-02 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2686
kono
parents:
diff changeset
2687 PR c++/51989
kono
parents:
diff changeset
2688 * typeck2.c (build_x_arrow): Take a tsubst_flags_t argument and
kono
parents:
diff changeset
2689 propagate it.
kono
parents:
diff changeset
2690 * cp-tree.h (build_x_arrow): Adjust prototype.
kono
parents:
diff changeset
2691 * pt.c (tsubst_copy_and_build): Adjust call.
kono
parents:
diff changeset
2692 * parser.c (cp_parser_postfix_dot_deref_expression): Likewise.
kono
parents:
diff changeset
2693
kono
parents:
diff changeset
2694 2012-03-02 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2695
kono
parents:
diff changeset
2696 * name-lookup.c (binding_to_template_parms_of_scope_p): Clean up.
kono
parents:
diff changeset
2697
kono
parents:
diff changeset
2698 2012-02-29 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2699
kono
parents:
diff changeset
2700 PR c++/51930
kono
parents:
diff changeset
2701 * decl.c (check_tag_decl): Move warning for misplaced attributes here.
kono
parents:
diff changeset
2702 (shadow_tag): From here.
kono
parents:
diff changeset
2703 * parser.c (cp_parser_explicit_instantiation): Don't warn here.
kono
parents:
diff changeset
2704
kono
parents:
diff changeset
2705 2012-02-21 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2706
kono
parents:
diff changeset
2707 PR c++/52312
kono
parents:
diff changeset
2708 * typeck.c (check_literal_operator_args): Initialize *long_double_p
kono
parents:
diff changeset
2709 and *long_long_unsigned_p even if processing_template_decl.
kono
parents:
diff changeset
2710
kono
parents:
diff changeset
2711 2012-02-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2712
kono
parents:
diff changeset
2713 PR c++/52248
kono
parents:
diff changeset
2714 * decl.c (define_label): Use timevar_cond_start/stop.
kono
parents:
diff changeset
2715
kono
parents:
diff changeset
2716 2012-02-16 Fabien ChĂȘne <fabien@gcc.gnu.org>
kono
parents:
diff changeset
2717
kono
parents:
diff changeset
2718 PR c++/52126
kono
parents:
diff changeset
2719 * decl.c (xref_basetypes): Call dependent_scope_p instead of
kono
parents:
diff changeset
2720 dependent_type_p.
kono
parents:
diff changeset
2721
kono
parents:
diff changeset
2722 2012-02-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2723
kono
parents:
diff changeset
2724 PR c++/51415
kono
parents:
diff changeset
2725 * error.c (dump_expr): Handle lambda closures specifically.
kono
parents:
diff changeset
2726
kono
parents:
diff changeset
2727 2012-02-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2728
kono
parents:
diff changeset
2729 * parser.c (cp_parser_explicit_instantiation): Give a warning
kono
parents:
diff changeset
2730 for ignored attributes on explicit class instantiation.
kono
parents:
diff changeset
2731
kono
parents:
diff changeset
2732 2012-02-14 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2733
kono
parents:
diff changeset
2734 PR c++/52247
kono
parents:
diff changeset
2735 * pt.c (tsubst_copy_asm_operands): For LABEL_DECL values call
kono
parents:
diff changeset
2736 lookup_label on label's name and set TREE_USED.
kono
parents:
diff changeset
2737
kono
parents:
diff changeset
2738 2012-02-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2739
kono
parents:
diff changeset
2740 PR c++/39055
kono
parents:
diff changeset
2741 * decl.c (local_variable_p_walkfn): Don't check DECL_ARTIFICIAL.
kono
parents:
diff changeset
2742
kono
parents:
diff changeset
2743 2012-02-14 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2744
kono
parents:
diff changeset
2745 PR c/52181
kono
parents:
diff changeset
2746 * decl.c (duplicate_decls): If olddecl has bigger DECL_ALIGN than
kono
parents:
diff changeset
2747 newdecl, copy DECL_ALIGN to newdecl and or DECL_USER_ALIGN bits.
kono
parents:
diff changeset
2748
kono
parents:
diff changeset
2749 2012-02-07 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2750
kono
parents:
diff changeset
2751 PR c++/51675
kono
parents:
diff changeset
2752 * semantics.c (cx_check_missing_mem_inits): Handle unions.
kono
parents:
diff changeset
2753 Fix constexpr default constructor logic.
kono
parents:
diff changeset
2754
kono
parents:
diff changeset
2755 PR c++/52035
kono
parents:
diff changeset
2756 * pt.c (tsubst): Strip uninstantiated typedef.
kono
parents:
diff changeset
2757
kono
parents:
diff changeset
2758 2012-02-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2759
kono
parents:
diff changeset
2760 PR c++/52088
kono
parents:
diff changeset
2761 * cvt.c (build_expr_type_conversion): Check for template conversion.
kono
parents:
diff changeset
2762
kono
parents:
diff changeset
2763 2012-01-31 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2764
kono
parents:
diff changeset
2765 PR c++/52043
kono
parents:
diff changeset
2766 * cp-tree.h (PACK_EXPANSION_LOCAL_P): New.
kono
parents:
diff changeset
2767 * pt.c (make_pack_expansion, tsubst_initializer_list): Set it.
kono
parents:
diff changeset
2768 (tsubst_pack_expansion): Check it.
kono
parents:
diff changeset
2769
kono
parents:
diff changeset
2770 2012-01-29 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2771
kono
parents:
diff changeset
2772 PR c++/51327
kono
parents:
diff changeset
2773 * class.c (explain_non_literal_class): Correctly handle implicitly
kono
parents:
diff changeset
2774 deleted constructors.
kono
parents:
diff changeset
2775
kono
parents:
diff changeset
2776 2012-01-27 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2777
kono
parents:
diff changeset
2778 PR c++/51852
kono
parents:
diff changeset
2779 * pt.c (tsubst_pack_expansion): Delete and restore
kono
parents:
diff changeset
2780 local_specialization whenever need_local_specialization, not just
kono
parents:
diff changeset
2781 when saved_local_specializations is non-NULL.
kono
parents:
diff changeset
2782
kono
parents:
diff changeset
2783 2012-01-26 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2784
kono
parents:
diff changeset
2785 PR c++/51370
kono
parents:
diff changeset
2786 * error.c (dump_decl, [TEMPLATE_ID_EXPR]): Handle error_mark_node
kono
parents:
diff changeset
2787 as TREE_OPERAND (t, 1).
kono
parents:
diff changeset
2788
kono
parents:
diff changeset
2789 2012-01-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2790
kono
parents:
diff changeset
2791 PR c++/51917
kono
parents:
diff changeset
2792 * decl.c (xref_basetypes): Check VEC_length instead of VEC_space.
kono
parents:
diff changeset
2793
kono
parents:
diff changeset
2794 PR c++/51973
kono
parents:
diff changeset
2795 * tree.c (called_fns_equal): Check template args.
kono
parents:
diff changeset
2796 (cp_tree_equal): Call it.
kono
parents:
diff changeset
2797
kono
parents:
diff changeset
2798 2012-01-24 Aldy Hernandez <aldyh@redhat.com>
kono
parents:
diff changeset
2799 Patrick Marlier <patrick.marlier@gmail.com>
kono
parents:
diff changeset
2800
kono
parents:
diff changeset
2801 PR c++/51928
kono
parents:
diff changeset
2802 * class.c (set_method_tm_attributes): Use TARGET_THUNK instead of
kono
parents:
diff changeset
2803 thunk for set_one_vmethod_tm_attributes.
kono
parents:
diff changeset
2804
kono
parents:
diff changeset
2805 2012-01-24 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2806
kono
parents:
diff changeset
2807 PR c++/51223
kono
parents:
diff changeset
2808 * call.c (build_over_call): Check for error_mark_node as
kono
parents:
diff changeset
2809 TREE_VALUE when default arguments are processed.
kono
parents:
diff changeset
2810
kono
parents:
diff changeset
2811 2012-01-23 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2812
kono
parents:
diff changeset
2813 PR c++/51930
kono
parents:
diff changeset
2814 * decl2.c (determine_visibility): Check for visibility attribute
kono
parents:
diff changeset
2815 on template specialization.
kono
parents:
diff changeset
2816
kono
parents:
diff changeset
2817 2012-01-23 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2818
kono
parents:
diff changeset
2819 PR c++/51398
kono
parents:
diff changeset
2820 * pt.c (parameter_of_template_p): Skip error_mark_node parameters.
kono
parents:
diff changeset
2821
kono
parents:
diff changeset
2822 2012-01-23 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2823
kono
parents:
diff changeset
2824 PR c++/51925
kono
parents:
diff changeset
2825 * class.c (add_method): Set OVL_USED for using-decls.
kono
parents:
diff changeset
2826 * tree.c (ovl_scope): New.
kono
parents:
diff changeset
2827 * cp-tree.h: Declare it.
kono
parents:
diff changeset
2828 * parser.c (cp_parser_template_name): Use it.
kono
parents:
diff changeset
2829 * semantics.c (baselink_for_fns): Likewise.
kono
parents:
diff changeset
2830 * name-lookup.c (set_inherited_value_binding_p): Likewise.
kono
parents:
diff changeset
2831
kono
parents:
diff changeset
2832 2012-01-20 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2833
kono
parents:
diff changeset
2834 PR c++/51402
kono
parents:
diff changeset
2835 * pt.c (lookup_template_class_1): Check context returned by
kono
parents:
diff changeset
2836 tsubst for error_mark_node.
kono
parents:
diff changeset
2837
kono
parents:
diff changeset
2838 2012-01-19 Kai Tietz <ktietz@redhat.com>
kono
parents:
diff changeset
2839
kono
parents:
diff changeset
2840 PR c++/51344
kono
parents:
diff changeset
2841 * decl2.c (save_template_attributes): Use merge_attributes
kono
parents:
diff changeset
2842 instead of chaining up via TREE_CHAIN.
kono
parents:
diff changeset
2843
kono
parents:
diff changeset
2844 2012-01-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2845
kono
parents:
diff changeset
2846 PR c++/51889
kono
parents:
diff changeset
2847 * class.c (finish_struct): Call add_method here for function usings.
kono
parents:
diff changeset
2848 * semantics.c (finish_member_declaration): Not here.
kono
parents:
diff changeset
2849
kono
parents:
diff changeset
2850 2012-01-18 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2851
kono
parents:
diff changeset
2852 PR c++/51225
kono
parents:
diff changeset
2853 * typeck2.c (store_init_value): Within a template guard
kono
parents:
diff changeset
2854 cxx_constant_value with require_potential_constant_expression.
kono
parents:
diff changeset
2855 * pt.c (convert_nontype_argument): Likewise.
kono
parents:
diff changeset
2856
kono
parents:
diff changeset
2857 2012-01-16 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2858
kono
parents:
diff changeset
2859 PR c++/51854
kono
parents:
diff changeset
2860 * mangle.c (write_template_arg_literal): Handle complex.
kono
parents:
diff changeset
2861
kono
parents:
diff changeset
2862 2012-01-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2863
kono
parents:
diff changeset
2864 PR c++/51827
kono
parents:
diff changeset
2865 * mangle.c (mangle_decl): Don't mangle uninstantiated templates.
kono
parents:
diff changeset
2866
kono
parents:
diff changeset
2867 PR c++/51868
kono
parents:
diff changeset
2868 * typeck.c (build_static_cast_1): Handle bit-fields properly.
kono
parents:
diff changeset
2869
kono
parents:
diff changeset
2870 2012-01-13 Ian Lance Taylor <iant@google.com>
kono
parents:
diff changeset
2871
kono
parents:
diff changeset
2872 PR c++/50012
kono
parents:
diff changeset
2873 * typeck.c (enum_cast_to_int): New static function.
kono
parents:
diff changeset
2874 (cp_build_binary_op): When handling warn_sign_compare, don't test
kono
parents:
diff changeset
2875 for TREE_NO_WARNING. Do call enum_cast_to_int.
kono
parents:
diff changeset
2876 * call.c (avoid_sign_compare_warnings): Remove static function.
kono
parents:
diff changeset
2877 (build_new_op_1): Don't call avoid_sign_compare_warnings.
kono
parents:
diff changeset
2878
kono
parents:
diff changeset
2879 2012-01-13 Steven Bosscher <steven@gcc.gnu.org>
kono
parents:
diff changeset
2880
kono
parents:
diff changeset
2881 * decl2.c: Do not include tree-mudflap.h
kono
parents:
diff changeset
2882 * semantics.c: Likewise.
kono
parents:
diff changeset
2883
kono
parents:
diff changeset
2884 2012-01-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2885
kono
parents:
diff changeset
2886 PR c++/20681
kono
parents:
diff changeset
2887 * semantics.c (finish_break_stmt): Avoid adding an unreachable
kono
parents:
diff changeset
2888 BREAK_STMT.
kono
parents:
diff changeset
2889
kono
parents:
diff changeset
2890 PR c++/51813
kono
parents:
diff changeset
2891 * decl2.c (constrain_visibility): Clear DECL_VISIBILITY_SPECIFIED
kono
parents:
diff changeset
2892 when reducing the visibility.
kono
parents:
diff changeset
2893
kono
parents:
diff changeset
2894 PR c++/51620
kono
parents:
diff changeset
2895 * class.c (build_vtbl_initializer): Use __cxa_deleted_virtual.
kono
parents:
diff changeset
2896
kono
parents:
diff changeset
2897 2012-01-12 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2898
kono
parents:
diff changeset
2899 PR c++/51714
kono
parents:
diff changeset
2900 * pt.c (value_dependent_expression_p): Treat STMT_EXPR as
kono
parents:
diff changeset
2901 value-dependent.
kono
parents:
diff changeset
2902
kono
parents:
diff changeset
2903 2012-01-13 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
2904
kono
parents:
diff changeset
2905 PR c++/51633
kono
parents:
diff changeset
2906 * semantics.c (cp_parser_ctor_initializer_opt_and_function_body):
kono
parents:
diff changeset
2907 Set the pointer to the last block of the constructor to the
kono
parents:
diff changeset
2908 current statement.
kono
parents:
diff changeset
2909 (build_constexpr_constructor_member_initializers): Get
kono
parents:
diff changeset
2910 build_data_member_initialization a chance to deal with more
kono
parents:
diff changeset
2911 statements before we choke.
kono
parents:
diff changeset
2912
kono
parents:
diff changeset
2913 2012-01-12 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2914
kono
parents:
diff changeset
2915 PR c++/48051
kono
parents:
diff changeset
2916 * mangle.c (write_expression): Mangle BASELINK scope if
kono
parents:
diff changeset
2917 BASELINK_QUALIFIED_P.
kono
parents:
diff changeset
2918 * search.c (adjust_result_of_qualified_name_lookup): Set
kono
parents:
diff changeset
2919 BASELINK_QUALIFIED_P.
kono
parents:
diff changeset
2920 * tree.c (cp_tree_equal) [BASELINK]: Compare BASELINK_QUALIFIED_P.
kono
parents:
diff changeset
2921 * parser.c (cp_parser_postfix_dot_deref_expression): Don't call
kono
parents:
diff changeset
2922 adjust_result_of_qualified_name_lookup for non-qualified names.
kono
parents:
diff changeset
2923
kono
parents:
diff changeset
2924 PR c++/51403
kono
parents:
diff changeset
2925 * pt.c (unify): Handle error_mark_node.
kono
parents:
diff changeset
2926
kono
parents:
diff changeset
2927 2012-01-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2928
kono
parents:
diff changeset
2929 PR c++/51565
kono
parents:
diff changeset
2930 * call.c (standard_conversion): For ptrmemfuncs, compare the
kono
parents:
diff changeset
2931 static_fn_types.
kono
parents:
diff changeset
2932
kono
parents:
diff changeset
2933 PR c++/51818
kono
parents:
diff changeset
2934 * mangle.c (find_substitution): A type is only a substitution
kono
parents:
diff changeset
2935 match if we're looking for a type.
kono
parents:
diff changeset
2936 (write_nested_name): Use decl_mangling_context.
kono
parents:
diff changeset
2937
kono
parents:
diff changeset
2938 * decl.c (decls_match): Assert that the arguments are decls.
kono
parents:
diff changeset
2939
kono
parents:
diff changeset
2940 PR c++/51613
kono
parents:
diff changeset
2941 * pt.c (resolve_overloaded_unification): Compare types with
kono
parents:
diff changeset
2942 same_type_p, not decls_match.
kono
parents:
diff changeset
2943
kono
parents:
diff changeset
2944 2012-01-10 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2945
kono
parents:
diff changeset
2946 PR c++/51614
kono
parents:
diff changeset
2947 * class.c (build_base_path): Diagnose ambiguous base.
kono
parents:
diff changeset
2948
kono
parents:
diff changeset
2949 PR c++/51433
kono
parents:
diff changeset
2950 * semantics.c (cxx_eval_call_expression): Always retry previously
kono
parents:
diff changeset
2951 non-constant expressions.
kono
parents:
diff changeset
2952
kono
parents:
diff changeset
2953 2012-01-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2954
kono
parents:
diff changeset
2955 DR 686
kono
parents:
diff changeset
2956 PR c++/47450
kono
parents:
diff changeset
2957 * parser.c (cp_parser_new_expression): Set
kono
parents:
diff changeset
2958 type_definition_forbidden_message.
kono
parents:
diff changeset
2959
kono
parents:
diff changeset
2960 PR c++/6057
kono
parents:
diff changeset
2961 PR c++/48051
kono
parents:
diff changeset
2962 PR c++/50855
kono
parents:
diff changeset
2963 PR c++/51322
kono
parents:
diff changeset
2964 * mangle.c (write_expression): Support NEW_EXPR, DELETE_EXPR,
kono
parents:
diff changeset
2965 THROW_EXPR, CONSTRUCTOR, OVERLOAD. Fix PREINCREMENT_EXPR and
kono
parents:
diff changeset
2966 PREDECREMENT_EXPR.
kono
parents:
diff changeset
2967 (write_template_arg): Fix mangling of class-scope functions and
kono
parents:
diff changeset
2968 argument packs.
kono
parents:
diff changeset
2969 (mangle_decl): Update suggested -fabi-version argument.
kono
parents:
diff changeset
2970 * operators.def: Add DOTSTAR_EXPR, REINTERPRET_CAST_EXPR,
kono
parents:
diff changeset
2971 DYNAMIC_CAST_EXPR; correct CONST_CAST_EXPR, STATIC_CAST_EXPR.
kono
parents:
diff changeset
2972 * tree.c (dependent_name): No longer static.
kono
parents:
diff changeset
2973 * cp-tree.h: Declare it.
kono
parents:
diff changeset
2974 * pt.c (unify): Defer handling of unconverted functions.
kono
parents:
diff changeset
2975
kono
parents:
diff changeset
2976 * mangle.c (mangle_decl): Don't generate mangling aliases
kono
parents:
diff changeset
2977 for maybe-in-charge [cd]tors.
kono
parents:
diff changeset
2978
kono
parents:
diff changeset
2979 * error.c (dump_expr): Print type of CONSTRUCTOR.
kono
parents:
diff changeset
2980
kono
parents:
diff changeset
2981 2012-01-05 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
2982
kono
parents:
diff changeset
2983 PR c++/51541
kono
parents:
diff changeset
2984 * parser.c (cp_parser_alias_declaration): Get out early upon
kono
parents:
diff changeset
2985 errors in the identifier or the attributes.
kono
parents:
diff changeset
2986
kono
parents:
diff changeset
2987 2012-01-04 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2988
kono
parents:
diff changeset
2989 PR c++/51064
kono
parents:
diff changeset
2990 * pt.c (tsubst_copy_and_build): Maybe set TREE_NO_WARNING on
kono
parents:
diff changeset
2991 the tree returned by build_x_binary_op.
kono
parents:
diff changeset
2992
kono
parents:
diff changeset
2993 2012-01-03 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2994
kono
parents:
diff changeset
2995 PR c++/51738
kono
parents:
diff changeset
2996 * parser.c (cp_parser_postfix_open_square_expression): Handle
kono
parents:
diff changeset
2997 postfix-expression [ braced-init-list ].
kono
parents:
diff changeset
2998
kono
parents:
diff changeset
2999 2012-01-03 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3000
kono
parents:
diff changeset
3001 PR c++/29273
kono
parents:
diff changeset
3002 * rtti.c (build_dynamic_cast_1): In case of T a pointer type,
kono
parents:
diff changeset
3003 call decay_conversion on v.
kono
parents:
diff changeset
3004
kono
parents:
diff changeset
3005 2012-01-03 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3006
kono
parents:
diff changeset
3007 PR c++/15867
kono
parents:
diff changeset
3008 * decl.c (duplicate_decls): With -Wredundant-decls don't warn for
kono
parents:
diff changeset
3009 declaration followed by specialization.
kono
parents:
diff changeset
3010
kono
parents:
diff changeset
3011 2012-01-03 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3012
kono
parents:
diff changeset
3013 PR c++/51669
kono
parents:
diff changeset
3014 * semantics.c (finish_omp_clauses): Call fold_build_cleanup_point_expr
kono
parents:
diff changeset
3015 on OMP_CLAUSE_{IF,FINAL,NUM_THREADS,SCHEDULE_CHUNK}_EXPR.
kono
parents:
diff changeset
3016
kono
parents:
diff changeset
3017 2012-01-02 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3018
kono
parents:
diff changeset
3019 DR 1359
kono
parents:
diff changeset
3020 PR c++/51675
kono
parents:
diff changeset
3021 * method.c (walk_field_subobs): Don't check for uninitialized
kono
parents:
diff changeset
3022 fields in a union.
kono
parents:
diff changeset
3023 (synthesized_method_walk): Check here.
kono
parents:
diff changeset
3024
kono
parents:
diff changeset
3025 DR 325
kono
parents:
diff changeset
3026 PR c++/51666
kono
parents:
diff changeset
3027 * parser.c (cp_parser_cache_defarg): Split out...
kono
parents:
diff changeset
3028 (cp_parser_parameter_declaration): ...from here.
kono
parents:
diff changeset
3029 (cp_parser_save_nsdmi): Use it.
kono
parents:
diff changeset
3030 (cp_parser_cache_group): Remove CPP_COMMA support.
kono
parents:
diff changeset
3031
kono
parents:
diff changeset
3032 2012-01-02 Dodji Seketeli <dodji@redhat.com>
kono
parents:
diff changeset
3033
kono
parents:
diff changeset
3034 PR c++/51462
kono
parents:
diff changeset
3035 * semantics.c (cx_check_missing_mem_inits): Don't assert in case
kono
parents:
diff changeset
3036 of error.
kono
parents:
diff changeset
3037
kono
parents:
diff changeset
3038 2012-01-02 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3039
kono
parents:
diff changeset
3040 PR c++/20140
kono
parents:
diff changeset
3041 * typeck2.c (digest_init_r): Use copy_init when initializing
kono
parents:
diff changeset
3042 an array of chars.
kono
parents:
diff changeset
3043
kono
parents:
diff changeset
3044 2012-01-01 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3045
kono
parents:
diff changeset
3046 PR c++/16603
kono
parents:
diff changeset
3047 * decl.c (build_enumerator): Don't call perform_integral_promotions
kono
parents:
diff changeset
3048 on the value.
kono
parents:
diff changeset
3049
kono
parents:
diff changeset
3050 2012-01-01 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3051
kono
parents:
diff changeset
3052 PR c++/51379
kono
parents:
diff changeset
3053 * typeck.c (build_reinterpret_cast_1): Implement resolution of
kono
parents:
diff changeset
3054 DR 799.
kono
parents:
diff changeset
3055
kono
parents:
diff changeset
3056 2012-01-01 Fabien ChĂȘne <fabien@gcc.gnu.org>
kono
parents:
diff changeset
3057
kono
parents:
diff changeset
3058 * parser.c (cp_parser_using_declaration): Add a warning about
kono
parents:
diff changeset
3059 deprecated access declarations when no errors were encountered
kono
parents:
diff changeset
3060 while parsing the access declaration. Save the first token in
kono
parents:
diff changeset
3061 order to emit the warning at the right place.
kono
parents:
diff changeset
3062
kono
parents:
diff changeset
3063 Copyright (C) 2012 Free Software Foundation, Inc.
kono
parents:
diff changeset
3064
kono
parents:
diff changeset
3065 Copying and distribution of this file, with or without modification,
kono
parents:
diff changeset
3066 are permitted in any medium without royalty provided the copyright
kono
parents:
diff changeset
3067 notice and this notice are preserved.