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

fix conv1.c
author mir3636
date Thu, 08 Mar 2018 14:53:42 +0900
parents 04ced10e8804
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
111
kono
parents:
diff changeset
1 2016-12-24 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2
kono
parents:
diff changeset
3 PR middle-end/78901
kono
parents:
diff changeset
4 * except.c (nothrow_libfn_p): Expect libc_name_p to return
kono
parents:
diff changeset
5 const struct libc_name_struct *, if it returns NULL, return 0,
kono
parents:
diff changeset
6 otherwise check c_ver and use flag_isoc99 or flag_isoc11.
kono
parents:
diff changeset
7 * cfns.gperf: Add %struct-type and libc_name_struct definition.
kono
parents:
diff changeset
8 For all C89 C library functions add , 89 after the name, add
kono
parents:
diff changeset
9 C99 C library functions with , 99 and C11 C library functions
kono
parents:
diff changeset
10 with , 11 suffix.
kono
parents:
diff changeset
11 * cfns.h: Regenerated.
kono
parents:
diff changeset
12
kono
parents:
diff changeset
13 2016-12-22 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
14
kono
parents:
diff changeset
15 PR c++/78906
kono
parents:
diff changeset
16 * pt.c (finish_template_variable): Use most_general_template.
kono
parents:
diff changeset
17
kono
parents:
diff changeset
18 PR c++/78898
kono
parents:
diff changeset
19 PR c++/42329
kono
parents:
diff changeset
20 * pt.c (unify): Don't look for a class template from a non-class.
kono
parents:
diff changeset
21
kono
parents:
diff changeset
22 2016-12-21 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
23
kono
parents:
diff changeset
24 PR c++/72707
kono
parents:
diff changeset
25 * name-lookup.c (pushdecl_maybe_friend_1): Do check shadowing of
kono
parents:
diff changeset
26 artificial x if it is an anonymous union variable.
kono
parents:
diff changeset
27
kono
parents:
diff changeset
28 PR bootstrap/78817
kono
parents:
diff changeset
29 * typeck.c (cp_build_function_call_vec): If check_function_arguments
kono
parents:
diff changeset
30 returns true, set TREE_NO_WARNING on CALL_EXPR.
kono
parents:
diff changeset
31 * call.c (build_over_call): Likewise.
kono
parents:
diff changeset
32
kono
parents:
diff changeset
33 PR c++/77830
kono
parents:
diff changeset
34 * constexpr.c (cxx_eval_array_reference): Perform out of bounds
kono
parents:
diff changeset
35 verification even if lval is true, just allow one past the last
kono
parents:
diff changeset
36 element in that case.
kono
parents:
diff changeset
37 (cxx_eval_store_expression): Detect stores to out of bound
kono
parents:
diff changeset
38 ARRAY_REF.
kono
parents:
diff changeset
39
kono
parents:
diff changeset
40 2016-12-21 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
41
kono
parents:
diff changeset
42 Implement P0522R0, matching of template template arguments.
kono
parents:
diff changeset
43 * pt.c (coerce_template_template_parms): Allow a template argument
kono
parents:
diff changeset
44 that's less specialized than the parameter.
kono
parents:
diff changeset
45 (unify_bound_ttp_args): Adjust parm's args to apply to arg's
kono
parents:
diff changeset
46 template.
kono
parents:
diff changeset
47 (coerce_template_args_for_ttp): Split out from
kono
parents:
diff changeset
48 lookup_template_class_1.
kono
parents:
diff changeset
49 (coerce_ttp_args_for_tta, store_defaulted_ttp)
kono
parents:
diff changeset
50 (lookup_defaulted_ttp, add_defaults_to_ttp): New.
kono
parents:
diff changeset
51 (process_partial_specialization): Set DECL_CONTEXT of
kono
parents:
diff changeset
52 template template-parameters.
kono
parents:
diff changeset
53 (coerce_template_parms): Only inform when complain.
kono
parents:
diff changeset
54 (expand_template_argument_pack): Handle error_mark_node.
kono
parents:
diff changeset
55 (convert_template_argument, template_args_equal, unify): Handle
kono
parents:
diff changeset
56 any_targ_node.
kono
parents:
diff changeset
57 * cp-tree.h (enum cp_tree_index): Add CPTI_ANY_TARG.
kono
parents:
diff changeset
58 (any_targ_node): New.
kono
parents:
diff changeset
59 * decl.c (cxx_init_decl_processing): Set it.
kono
parents:
diff changeset
60 * name-lookup.c (consider_binding_level): Ignore names with embedded
kono
parents:
diff changeset
61 spaces.
kono
parents:
diff changeset
62
kono
parents:
diff changeset
63 PR c++/42329
kono
parents:
diff changeset
64 * pt.c (unify_bound_ttp_args): Split out from unify.
kono
parents:
diff changeset
65 (try_class_unification): Handle BOUND_TEMPLATE_TEMPLATE_PARM.
kono
parents:
diff changeset
66 (unify): Check for type/non-type mismatch early.
kono
parents:
diff changeset
67 [BOUND_TEMPLATE_TEMPLATE_PARM]: Try get_template_base.
kono
parents:
diff changeset
68
kono
parents:
diff changeset
69 * pt.c (coerce_template_parms): Consider variadic_args_p before
kono
parents:
diff changeset
70 complaining about too many template arguments.
kono
parents:
diff changeset
71
kono
parents:
diff changeset
72 * pt.c (process_partial_specialization): Use
kono
parents:
diff changeset
73 get_partial_spec_bindings to check that the partial specialization
kono
parents:
diff changeset
74 is more specialized than the primary template.
kono
parents:
diff changeset
75
kono
parents:
diff changeset
76 * pt.c (convert_template_argument): Pass args to do_auto_deduction.
kono
parents:
diff changeset
77 (mark_template_parm): Handle deducibility from type of non-type
kono
parents:
diff changeset
78 argument here.
kono
parents:
diff changeset
79 (for_each_template_parm_r): Not here.
kono
parents:
diff changeset
80
kono
parents:
diff changeset
81 * ptree.c (cxx_print_type): Print args of
kono
parents:
diff changeset
82 BOUND_TEMPLATE_TEMPLATE_PARM.
kono
parents:
diff changeset
83 (cxx_print_decl): Print DECL_TEMPLATE_PARMS.
kono
parents:
diff changeset
84
kono
parents:
diff changeset
85 PR c++/78767 - ICE with inherited constructor default argument
kono
parents:
diff changeset
86 * method.c (strip_inheriting_ctors): Strip template as appropriate.
kono
parents:
diff changeset
87
kono
parents:
diff changeset
88 PR c++/78749 - friend in anonymous namespace
kono
parents:
diff changeset
89 * decl.c (wrapup_globals_for_namespace): Don't complain about friend
kono
parents:
diff changeset
90 pseudo-template instantiations.
kono
parents:
diff changeset
91
kono
parents:
diff changeset
92 2016-12-16 Richard Biener <rguenther@suse.de>
kono
parents:
diff changeset
93
kono
parents:
diff changeset
94 PR c++/71694
kono
parents:
diff changeset
95 * cp-objcp-common.h (cp_unit_size_without_reusable_padding): Declare.
kono
parents:
diff changeset
96 (LANG_HOOKS_UNIT_SIZE_WITHOUT_REUSABLE_PADDING): Define.
kono
parents:
diff changeset
97 * cp-objcp-common.c (cp_unit_size_without_reusable_padding): New.
kono
parents:
diff changeset
98
kono
parents:
diff changeset
99 2016-12-15 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
100
kono
parents:
diff changeset
101 P0490R0 GB 20: decomposition declaration should commit to tuple
kono
parents:
diff changeset
102 interpretation early
kono
parents:
diff changeset
103 * decl.c (get_tuple_size): Make static. If inst is error_mark_node
kono
parents:
diff changeset
104 or non-complete type, return NULL_TREE, otherwise if
kono
parents:
diff changeset
105 lookup_qualified_name fails or doesn't fold into INTEGER_CST, return
kono
parents:
diff changeset
106 error_mark_node.
kono
parents:
diff changeset
107 (get_tuple_element_type, get_tuple_decomp_init): Make static.
kono
parents:
diff changeset
108 (cp_finish_decomp): Pass LOC to get_tuple_size. If it returns
kono
parents:
diff changeset
109 error_mark_node, complain and fail.
kono
parents:
diff changeset
110
kono
parents:
diff changeset
111 2016-12-15 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
112
kono
parents:
diff changeset
113 PR c++/77585
kono
parents:
diff changeset
114 * pt.c (instantiate_decl): Push to class scope lambda resides
kono
parents:
diff changeset
115 within when instantiating a generic lambda function.
kono
parents:
diff changeset
116
kono
parents:
diff changeset
117 2016-12-14 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
118
kono
parents:
diff changeset
119 PR c++/78774
kono
parents:
diff changeset
120 * pt.c (convert_template_argument): Avoid assuming operand type
kono
parents:
diff changeset
121 is non-null since that of SCOPE_REF is not.
kono
parents:
diff changeset
122
kono
parents:
diff changeset
123 2016-12-14 Martin Jambor <mjambor@suse.cz>
kono
parents:
diff changeset
124
kono
parents:
diff changeset
125 * parser.c: Include omp-general.h and omp-offload.h instead of
kono
parents:
diff changeset
126 omp-low.h.
kono
parents:
diff changeset
127 (cp_parser_omp_simd): Adjusted calls to find_omp_clause to use its new
kono
parents:
diff changeset
128 name.
kono
parents:
diff changeset
129 (cp_parser_omp_target_update): Likewise.
kono
parents:
diff changeset
130 (cp_parser_oacc_declare): Likewise.
kono
parents:
diff changeset
131 (cp_parser_oacc_enter_exit_data): Likewise.
kono
parents:
diff changeset
132 (cp_parser_oacc_update): Likewise.
kono
parents:
diff changeset
133 (cp_finalize_oacc_routine): Adjusted call to get_oacc_fn_attrib,
kono
parents:
diff changeset
134 build_oacc_routine_dims and replace_oacc_fn_attrib to use their new
kono
parents:
diff changeset
135 names.
kono
parents:
diff changeset
136 * semantics.c: Include omp-general insteda of omp-low.h.
kono
parents:
diff changeset
137 (finish_omp_for): Adjusted calls to find_omp_clause to use its new
kono
parents:
diff changeset
138 name.
kono
parents:
diff changeset
139 (finish_omp_cancel): Likewise.
kono
parents:
diff changeset
140 (finish_omp_cancellation_point): Likewise.
kono
parents:
diff changeset
141
kono
parents:
diff changeset
142 2016-12-14 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
143
kono
parents:
diff changeset
144 PR c++/72775
kono
parents:
diff changeset
145 * init.c (perform_member_init): Diagnose member initializer for
kono
parents:
diff changeset
146 flexible array member.
kono
parents:
diff changeset
147
kono
parents:
diff changeset
148 2016-12-14 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
149
kono
parents:
diff changeset
150 PR c++/78701
kono
parents:
diff changeset
151 * pt.c (type_unification_real): Check tsubst arg doesn't have
kono
parents:
diff changeset
152 remaining template parms before converting it.
kono
parents:
diff changeset
153
kono
parents:
diff changeset
154 PR c++/69481
kono
parents:
diff changeset
155 * cp-tree.h (TYPE_TEMPLATE_INFO_MAYBE_ALIAS): Always use
kono
parents:
diff changeset
156 TYPE_ALIAS_TEMPLATE_INFO for aliases.
kono
parents:
diff changeset
157
kono
parents:
diff changeset
158 2016-12-13 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
159
kono
parents:
diff changeset
160 PR c++/69481
kono
parents:
diff changeset
161 * cp-tree.h (TYPE_TEMPLATE_INFO): Remove alias type checking.
kono
parents:
diff changeset
162 (TYPE_ALIAS_TEMPLATE_INFO): New.
kono
parents:
diff changeset
163 (TYPE_TEMPLATE_INFO_MAYBE_ALIAS): New. Use those macros.
kono
parents:
diff changeset
164 * error.c (dump_alias_template_specialization): Adjust.
kono
parents:
diff changeset
165 * pt.c (maybe_process_partial_specialization,
kono
parents:
diff changeset
166 iterative_has_template_arg, find_parameter_packs_r,
kono
parents:
diff changeset
167 alias_template_specialization_p, dependent_alias_template_spec_p,
kono
parents:
diff changeset
168 get_underlying_template, lookup_template_class_1, unify): Adjust
kono
parents:
diff changeset
169 template using decl access.
kono
parents:
diff changeset
170
kono
parents:
diff changeset
171 2016-12-11 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
172
kono
parents:
diff changeset
173 PR c++/78637
kono
parents:
diff changeset
174 * parser.c (cp_parser_namespace_definition): Increment
kono
parents:
diff changeset
175 nested_definition_count only if push_namespace succeeds.
kono
parents:
diff changeset
176
kono
parents:
diff changeset
177 2016-12-08 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
178
kono
parents:
diff changeset
179 PR c++/78551
kono
parents:
diff changeset
180 * constexpr.c (extract_string_elt): New. Broken out of ...
kono
parents:
diff changeset
181 (cxx_eval_array_reference): ... here. Call it.
kono
parents:
diff changeset
182 (cxx_eval_store_expression): Convert init by STRING_CST into
kono
parents:
diff changeset
183 CONSTRUCTOR, if needed.
kono
parents:
diff changeset
184
kono
parents:
diff changeset
185 2016-12-08 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
186
kono
parents:
diff changeset
187 P0003R5 - removal of dynamic exception specification from C++17
kono
parents:
diff changeset
188 * parser.c (cp_parser_exception_specification_opt): For C++17
kono
parents:
diff changeset
189 error out on throw ( type-id-list ), for C++11 and C++14 issue
kono
parents:
diff changeset
190 -Wdeprecated warning on it. Formatting fix. Treat throw()
kono
parents:
diff changeset
191 in C++17 as noexcept(true).
kono
parents:
diff changeset
192
kono
parents:
diff changeset
193 2016-12-07 Martin Jambor <mjambor@suse.cz>
kono
parents:
diff changeset
194
kono
parents:
diff changeset
195 PR c++/78589
kono
parents:
diff changeset
196 * error.c (dump_decl): Use dump_function_name to dump
kono
parents:
diff changeset
197 !DECL_LANG_SPECIFIC function decls with no or self-referencing
kono
parents:
diff changeset
198 abstract origin.
kono
parents:
diff changeset
199
kono
parents:
diff changeset
200 2016-12-07 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
201
kono
parents:
diff changeset
202 * pt.c (tsubst <{NON,}TYPE_ARGUMENT_PACK>: Simplify control flow
kono
parents:
diff changeset
203 and avoid re-tsubsting type.
kono
parents:
diff changeset
204
kono
parents:
diff changeset
205 * cp-tree.h (enum cp_tree_index): Add CPTI_AUTO_IDENTIFIER &
kono
parents:
diff changeset
206 CPTI_DECLTYPE_AUTO_IDENTIFIER.
kono
parents:
diff changeset
207 (auto_identifier, decltype_auto_identifier): New.
kono
parents:
diff changeset
208 *decl.c (initialize_predefined_identifiers): Add 'auto' and
kono
parents:
diff changeset
209 'decltype(auto)'.
kono
parents:
diff changeset
210 (grokdeclarator): Use cached identifier.
kono
parents:
diff changeset
211 * pt.c (make_decltype_auto, make_auto, make_constrained_auto,
kono
parents:
diff changeset
212 is_auto): Likewise.
kono
parents:
diff changeset
213
kono
parents:
diff changeset
214 2016-12-02 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
215
kono
parents:
diff changeset
216 PR c++/78649
kono
parents:
diff changeset
217 * pt.c (tsubst_init): Don't call build_value_init if decl's type
kono
parents:
diff changeset
218 is error_mark_node.
kono
parents:
diff changeset
219
kono
parents:
diff changeset
220 2016-12-02 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
221 James Norris <jnorris@codesourcery.com>
kono
parents:
diff changeset
222
kono
parents:
diff changeset
223 * parser.c (cp_parser_oacc_enter_exit_data): Update diagnostics.
kono
parents:
diff changeset
224 (cp_parser_pragma): Error when PRAGMA_OACC_{ENTER_DATA,
kono
parents:
diff changeset
225 EXIT_DATA,WAIT} are not used in compound statements.
kono
parents:
diff changeset
226
kono
parents:
diff changeset
227 2016-12-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
228
kono
parents:
diff changeset
229 * call.c (add_function_candidate): Also exclude inherited ctors
kono
parents:
diff changeset
230 that take a type reference-related to the derived class.
kono
parents:
diff changeset
231
kono
parents:
diff changeset
232 * call.c (add_function_candidate): Exclude inherited copy/move
kono
parents:
diff changeset
233 ctors.
kono
parents:
diff changeset
234
kono
parents:
diff changeset
235 2016-11-29 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
236
kono
parents:
diff changeset
237 PR c++/77922
kono
parents:
diff changeset
238 * name-lookup.c (lookup_name_fuzzy): Filter out reserved words
kono
parents:
diff changeset
239 that were filtered out by init_reswords.
kono
parents:
diff changeset
240
kono
parents:
diff changeset
241 2016-11-28 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
242 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
243
kono
parents:
diff changeset
244 PR c++/72808
kono
parents:
diff changeset
245 * decl.c (finish_enum_value_list): Call fixup_type_variants on
kono
parents:
diff changeset
246 current_class_type after
kono
parents:
diff changeset
247 insert_late_enum_def_into_classtype_sorted_fields.
kono
parents:
diff changeset
248
kono
parents:
diff changeset
249 2016-11-28 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
250
kono
parents:
diff changeset
251 PR c++/77591
kono
parents:
diff changeset
252 * typeck.c (maybe_warn_about_returning_address_of_local): Optimize
kono
parents:
diff changeset
253 whats_returned through fold_for_warn.
kono
parents:
diff changeset
254
kono
parents:
diff changeset
255 2016-11-27 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
256
kono
parents:
diff changeset
257 PR c++/77907
kono
parents:
diff changeset
258 * constexpr.c (cxx_eval_constant_expression): Use cp_fold_convert.
kono
parents:
diff changeset
259
kono
parents:
diff changeset
260 2016-11-24 Martin Liska <mliska@suse.cz>
kono
parents:
diff changeset
261
kono
parents:
diff changeset
262 PR bootstrap/78493
kono
parents:
diff changeset
263 * parser.c (cp_parser_range_for): Use safe_push instead of quick_push.
kono
parents:
diff changeset
264
kono
parents:
diff changeset
265 2016-11-23 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
266
kono
parents:
diff changeset
267 PR c++/77907
kono
parents:
diff changeset
268 * cp-gimplify.c (cp_fold) <case CALL_EXPR>: When calling constructor
kono
parents:
diff changeset
269 and maybe_constant_value returns non-CALL_EXPR, create INIT_EXPR
kono
parents:
diff changeset
270 with the object on lhs and maybe_constant_value returned expr on rhs.
kono
parents:
diff changeset
271
kono
parents:
diff changeset
272 PR c++/71450
kono
parents:
diff changeset
273 * pt.c (tsubst_copy): Return error_mark_node when mark_used
kono
parents:
diff changeset
274 fails, even when complain & tf_error.
kono
parents:
diff changeset
275
kono
parents:
diff changeset
276 PR c++/77739
kono
parents:
diff changeset
277 * cp-gimplify.c (cp_gimplify_tree) <case VEC_INIT_EXPR>: Pass
kono
parents:
diff changeset
278 false as handle_invisiref_parm_p to cp_genericize_tree.
kono
parents:
diff changeset
279 (struct cp_genericize_data): Add handle_invisiref_parm_p field.
kono
parents:
diff changeset
280 (cp_genericize_r): Don't wrap is_invisiref_parm into references
kono
parents:
diff changeset
281 if !wtd->handle_invisiref_parm_p.
kono
parents:
diff changeset
282 (cp_genericize_tree): Add handle_invisiref_parm_p argument,
kono
parents:
diff changeset
283 set wtd.handle_invisiref_parm_p to it.
kono
parents:
diff changeset
284 (cp_genericize): Pass true as handle_invisiref_parm_p to
kono
parents:
diff changeset
285 cp_genericize_tree. Formatting fix.
kono
parents:
diff changeset
286
kono
parents:
diff changeset
287 2016-11-21 Bernd Edlinger <bernd.edlinger@hotmail.de>
kono
parents:
diff changeset
288
kono
parents:
diff changeset
289 PR c++/71973
kono
parents:
diff changeset
290 * decl.c (duplicate_decls): Warn when a built-in function is redefined.
kono
parents:
diff changeset
291 Don't overload builtin functions with C++ functions.
kono
parents:
diff changeset
292 Handle const_tm_ptr_type_node like file_ptr_node.
kono
parents:
diff changeset
293 Copy the TREE_NOTHROW flag unmodified to the old decl.
kono
parents:
diff changeset
294
kono
parents:
diff changeset
295 2016-11-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
296
kono
parents:
diff changeset
297 PR objc++/78418 - ICE in string tests on darwin
kono
parents:
diff changeset
298 * tree.c (lvalue_kind): Guard DECL_HAS_VALUE_EXPR_P.
kono
parents:
diff changeset
299
kono
parents:
diff changeset
300 2016-11-18 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
301
kono
parents:
diff changeset
302 PR c++/77285
kono
parents:
diff changeset
303 * mangle.c (mangle_tls_init_fn, mangle_tls_wrapper_fn): Call
kono
parents:
diff changeset
304 check_abi_tags.
kono
parents:
diff changeset
305
kono
parents:
diff changeset
306 2016-11-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
307
kono
parents:
diff changeset
308 PR c++/67631 - list-init and explicit conversions
kono
parents:
diff changeset
309 * semantics.c (finish_compound_literal): Call digest_init_flags.
kono
parents:
diff changeset
310 * typeck2.c (digest_init_flags): Add complain parm.
kono
parents:
diff changeset
311 (store_init_value): Pass it.
kono
parents:
diff changeset
312
kono
parents:
diff changeset
313 2016-11-18 Richard Sandiford <richard.sandiford@arm.com>
kono
parents:
diff changeset
314 Alan Hayward <alan.hayward@arm.com>
kono
parents:
diff changeset
315 David Sherwood <david.sherwood@arm.com>
kono
parents:
diff changeset
316
kono
parents:
diff changeset
317 * class.c (finish_struct_bits): Use SET_DECL_MODE.
kono
parents:
diff changeset
318 (build_base_field_1, layout_class_type, finish_struct_1): Likewise.
kono
parents:
diff changeset
319 * decl.c (make_label_decl): Likewise.
kono
parents:
diff changeset
320 * pt.c (tsubst_decl): Likewise.
kono
parents:
diff changeset
321
kono
parents:
diff changeset
322 2016-11-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
323
kono
parents:
diff changeset
324 PR c++/78193 - inherited ctor regressions on sparc32.
kono
parents:
diff changeset
325 * call.c (build_over_call): Don't set CALL_FROM_THUNK_P here.
kono
parents:
diff changeset
326 (build_call_a): Set it here, and don't insert EMPTY_CLASS_EXPR.
kono
parents:
diff changeset
327 (convert_like_real) [ck_rvalue]: Also pass non-addressable
kono
parents:
diff changeset
328 types along directly.
kono
parents:
diff changeset
329
kono
parents:
diff changeset
330 2016-11-17 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
331
kono
parents:
diff changeset
332 PR c++/55080
kono
parents:
diff changeset
333 * parser.c (cp_parser_non_integral_constant_expression): Issue a
kono
parents:
diff changeset
334 pedwarn instead of an error for case NIC_FLOAT.
kono
parents:
diff changeset
335
kono
parents:
diff changeset
336 2016-11-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
337
kono
parents:
diff changeset
338 PR c++/78124 - list-initialization and inherited ctor
kono
parents:
diff changeset
339 * name-lookup.c (do_class_using_decl): Set CLASSTYPE_NON_AGGREGATE.
kono
parents:
diff changeset
340
kono
parents:
diff changeset
341 PR c++/78369 - {} as default argument
kono
parents:
diff changeset
342 * call.c (build_special_member_call): Handle CONSTRUCTOR.
kono
parents:
diff changeset
343
kono
parents:
diff changeset
344 PR c++/68377
kono
parents:
diff changeset
345 * parser.c (cp_parser_fold_expression): Check TREE_NO_WARNING.
kono
parents:
diff changeset
346
kono
parents:
diff changeset
347 2016-11-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
348
kono
parents:
diff changeset
349 PR c++/78373
kono
parents:
diff changeset
350 * decl.c (cp_finish_decl): Don't set TREE_CONSTANT on a reference.
kono
parents:
diff changeset
351 * typeck2.c (store_init_value): Likewise.
kono
parents:
diff changeset
352
kono
parents:
diff changeset
353 * decl.c (store_decomp_type, lookup_decomp_type): New.
kono
parents:
diff changeset
354 (cp_finish_decomp): Call store_decomp_type.
kono
parents:
diff changeset
355 * semantics.c (finish_decltype_type): Call lookup_decomp_type.
kono
parents:
diff changeset
356 * cp-tree.h: Declare lookup_decomp_type.
kono
parents:
diff changeset
357
kono
parents:
diff changeset
358 2016-11-15 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
359
kono
parents:
diff changeset
360 * decl.c (cp_finish_decomp): For DECL_NAMESPACE_SCOPE_P decl,
kono
parents:
diff changeset
361 set DECL_ASSEMBLER_NAME.
kono
parents:
diff changeset
362 * parser.c (cp_parser_decomposition_declaration): Likewise
kono
parents:
diff changeset
363 if returning error_mark_node.
kono
parents:
diff changeset
364 * mangle.c (mangle_decomp): New function.
kono
parents:
diff changeset
365 * cp-tree.h (mangle_decomp): New declaration.
kono
parents:
diff changeset
366
kono
parents:
diff changeset
367 2016-11-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
368
kono
parents:
diff changeset
369 PR c++/78358
kono
parents:
diff changeset
370 * semantics.c (finish_decltype_type): Strip references for a tuple
kono
parents:
diff changeset
371 decomposition.
kono
parents:
diff changeset
372 * cp-tree.h (DECL_DECOMPOSITION_P): False for non-variables.
kono
parents:
diff changeset
373
kono
parents:
diff changeset
374 * decl2.c (decl_maybe_constant_var_p): References qualify.
kono
parents:
diff changeset
375 * constexpr.c (non_const_var_error): Handle references.
kono
parents:
diff changeset
376 * init.c (constant_value_1): Always check decl_constant_var_p.
kono
parents:
diff changeset
377 * cp-gimplify.c (cp_fold_maybe_rvalue): Don't fold references.
kono
parents:
diff changeset
378 * error.c (dump_decl_name): Split out from dump_decl.
kono
parents:
diff changeset
379
kono
parents:
diff changeset
380 2016-11-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
381
kono
parents:
diff changeset
382 * tree.c (bitfield_p): New.
kono
parents:
diff changeset
383 * cp-tree.h: Declare it.
kono
parents:
diff changeset
384 * typeck.c (cxx_sizeof_expr, cxx_alignof_expr)
kono
parents:
diff changeset
385 (cp_build_addr_expr_1): Use it instead of DECL_C_BIT_FIELD.
kono
parents:
diff changeset
386 * decl.c (cp_finish_decomp): Look through reference. Always
kono
parents:
diff changeset
387 SET_DECL_DECOMPOSITION_P.
kono
parents:
diff changeset
388 * semantics.c (finish_decltype_type): Adjust decomposition handling.
kono
parents:
diff changeset
389
kono
parents:
diff changeset
390 2016-11-13 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
391 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
392
kono
parents:
diff changeset
393 Implement P0217R3 - C++17 structured bindings
kono
parents:
diff changeset
394 * cp-tree.h (struct lang_decl_base): Add decomposition_p.
kono
parents:
diff changeset
395 (DECL_DECOMPOSITION_P): New
kono
parents:
diff changeset
396 (enum auto_deduction_context): Add adc_decomp_type.
kono
parents:
diff changeset
397 (enum cp_declarator_kind): Add cdk_decomp.
kono
parents:
diff changeset
398 * constexpr.c (cxx_eval_constant_expression): Look through
kono
parents:
diff changeset
399 DECL_VALUE_EXPR.
kono
parents:
diff changeset
400 (potential_constant_expression_1): Likewise.
kono
parents:
diff changeset
401 * decl.c (reshape_init): Preserve CONSTRUCTOR_IS_DIRECT_INIT.
kono
parents:
diff changeset
402 (check_initializer): Use build_aggr_init for DECL_DECOMPOSITION_P.
kono
parents:
diff changeset
403 (cp_finish_decl): Pass adc_decomp_type for decomposition.
kono
parents:
diff changeset
404 (find_decomp_class_base, get_tuple_size, get_tuple_element_type)
kono
parents:
diff changeset
405 (get_tuple_decomp_init, cp_finish_decomp): New.
kono
parents:
diff changeset
406 (grokdeclarator): Handle decomposition.
kono
parents:
diff changeset
407 * init.c (build_aggr_init): Handle decomposition array.
kono
parents:
diff changeset
408 (build_vec_init): Handle initialization from { array }.
kono
parents:
diff changeset
409 * name-lookup.c (add_function): Always wrap TEMPLATE_DECL in
kono
parents:
diff changeset
410 OVERLOAD.
kono
parents:
diff changeset
411 * parser.c (declarator_can_be_parameter_pack): Handle cdk_decomp.
kono
parents:
diff changeset
412 (function_declarator_p, strip_declarator_types)
kono
parents:
diff changeset
413 (cp_parser_check_declarator_template_parameters): Likewise.
kono
parents:
diff changeset
414 (cp_parser_range_for, cp_convert_range_for): Handle decomposition.
kono
parents:
diff changeset
415 (cp_parser_simple_declaration): Parse decomposition.
kono
parents:
diff changeset
416 (cp_parser_decomposition_declaration): New.
kono
parents:
diff changeset
417 * pt.c (tsubst_decomp_names): New.
kono
parents:
diff changeset
418 (subst_expr) [DECL_EXPR, RANGE_FOR_STMT]: Handle decomposition.
kono
parents:
diff changeset
419 (do_auto_deduction): Handle adc_decomp_type.
kono
parents:
diff changeset
420 * semantics.c (finish_decltype_type): Look through DECL_VALUE_EXPR.
kono
parents:
diff changeset
421 * typeck.c (is_bitfield_expr_with_lowered_type): Likewise.
kono
parents:
diff changeset
422 * tree.c (lvalue_kind): Likewise.
kono
parents:
diff changeset
423 (cp_build_reference_type): Handle reference collapsing.
kono
parents:
diff changeset
424
kono
parents:
diff changeset
425 2016-11-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
426
kono
parents:
diff changeset
427 * call.c (build_new_method_call_1): Include template arguments in
kono
parents:
diff changeset
428 error message.
kono
parents:
diff changeset
429 (print_error_for_call_failure): Likewise.
kono
parents:
diff changeset
430 (build_new_function_call): Pass them in.
kono
parents:
diff changeset
431 * name-lookup.c (supplement_binding_1): Don't complain about a
kono
parents:
diff changeset
432 conflict with an erroneous declaration.
kono
parents:
diff changeset
433 * error.c (dump_decl): Fix printing of alias declaration.
kono
parents:
diff changeset
434 * decl.c (make_typename_type): Call cxx_incomplete_type_error.
kono
parents:
diff changeset
435 * parser.c (cp_parser_diagnose_invalid_type_name): Likewise.
kono
parents:
diff changeset
436 * semantics.c (perform_koenig_lookup): Don't wrap an error in
kono
parents:
diff changeset
437 TEMPLATE_ID_EXPR.
kono
parents:
diff changeset
438
kono
parents:
diff changeset
439 2016-11-13 Prathamesh Kulkarni <prathamesh.kulkarni@linaro.org>
kono
parents:
diff changeset
440
kono
parents:
diff changeset
441 PR c/35503
kono
parents:
diff changeset
442 * parser.c (cp_parser_postfix_pexpression): Call warn_for_restrict.
kono
parents:
diff changeset
443
kono
parents:
diff changeset
444 2016-11-12 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
445
kono
parents:
diff changeset
446 CWG 2233
kono
parents:
diff changeset
447 * typeck.c (convert_arguments): Handle default arg followed by none.
kono
parents:
diff changeset
448
kono
parents:
diff changeset
449 * constexpr.c (potential_constant_expression_1): REALPART_EXPR and
kono
parents:
diff changeset
450 IMAGPART_EXPR can be lvalues.
kono
parents:
diff changeset
451
kono
parents:
diff changeset
452 DR 374
kono
parents:
diff changeset
453 PR c++/56480
kono
parents:
diff changeset
454 * pt.c (check_specialization_namespace): Allow any enclosing
kono
parents:
diff changeset
455 namespace.
kono
parents:
diff changeset
456 (check_unqualified_spec_or_inst): New.
kono
parents:
diff changeset
457 (check_explicit_specialization): Call it.
kono
parents:
diff changeset
458 * parser.c (cp_parser_elaborated_type_specifier)
kono
parents:
diff changeset
459 (cp_parser_class_head): Call it.
kono
parents:
diff changeset
460
kono
parents:
diff changeset
461 2016-11-10 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
462
kono
parents:
diff changeset
463 PR c++/77337
kono
parents:
diff changeset
464 * pt.c (tsubst_friend_function): Don't set DECL_INITIAL.
kono
parents:
diff changeset
465 (instantiate_decl): It's OK to defer a constexpr function.
kono
parents:
diff changeset
466 * cp-tree.h (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION): Check
kono
parents:
diff changeset
467 DECL_LANG_SPECIFIC.
kono
parents:
diff changeset
468 * decl2.c (decl_defined_p): Use it. No longer static.
kono
parents:
diff changeset
469 * decl.c (redeclaration_error_message): Use decl_defined_p.
kono
parents:
diff changeset
470 * constexpr.c (cxx_eval_call_expression): Set input_location around
kono
parents:
diff changeset
471 call to instantiate_decl.
kono
parents:
diff changeset
472
kono
parents:
diff changeset
473 2016-11-10 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
474
kono
parents:
diff changeset
475 * mangle.c (mangle_decl): Only emit -Wc++1z-compat warnings for
kono
parents:
diff changeset
476 public or external symbols.
kono
parents:
diff changeset
477
kono
parents:
diff changeset
478 2016-11-09 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
479
kono
parents:
diff changeset
480 PR c++/78283
kono
parents:
diff changeset
481 * mangle.c (start_mangling): Reset G.need_cxx1z_warning.
kono
parents:
diff changeset
482
kono
parents:
diff changeset
483 2016-11-09 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
484
kono
parents:
diff changeset
485 * parser.c (cp_parser_simple_type_specifier): Allow placeholder
kono
parents:
diff changeset
486 for template template parameter.
kono
parents:
diff changeset
487 (cp_parser_type_id_1): Improve diagnostic.
kono
parents:
diff changeset
488 * decl.c (grokdeclarator): Handle class deduction diagnostics here.
kono
parents:
diff changeset
489 * pt.c (splice_late_return_type): Not here.
kono
parents:
diff changeset
490 (tsubst) [TEMPLATE_TYPE_PARM]: Substitute into placeholder template.
kono
parents:
diff changeset
491 (do_class_deduction): Handle non-class templates.
kono
parents:
diff changeset
492
kono
parents:
diff changeset
493 Implement P0127R2, Declaring non-type parameters with auto.
kono
parents:
diff changeset
494 * cp-tree.h (enum auto_deduction_context): Add adc_unify.
kono
parents:
diff changeset
495 * decl.c (grokdeclarator): Allow 'auto' in C++17 template non-type
kono
parents:
diff changeset
496 parameter types.
kono
parents:
diff changeset
497 * pt.c (do_auto_deduction): Add outer_targs parameter.
kono
parents:
diff changeset
498 (convert_template_argument): Call do_auto_deduction. If adc_unify,
kono
parents:
diff changeset
499 don't give up on dependent init.
kono
parents:
diff changeset
500 (unify): Likewise. In C++17, walk into the type of a
kono
parents:
diff changeset
501 TEMPLATE_PARM_INDEX.
kono
parents:
diff changeset
502 (for_each_template_parm): Add any_fn parameter.
kono
parents:
diff changeset
503 (struct pair_fn_data): Likewise.
kono
parents:
diff changeset
504 (for_each_template_parm_r): Call it for any tree. In C++17, walk
kono
parents:
diff changeset
505 into the type of a TEMPLATE_PARM_INDEX.
kono
parents:
diff changeset
506 (zero_r, array_deduction_r, try_array_deduction): New.
kono
parents:
diff changeset
507 (type_unification_real): Call try_array_deduction.
kono
parents:
diff changeset
508 (get_partial_spec_bindings): Likewise.
kono
parents:
diff changeset
509
kono
parents:
diff changeset
510 2016-11-07 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
511
kono
parents:
diff changeset
512 Implement P0012R1, Make exception specifications part of the type
kono
parents:
diff changeset
513 system.
kono
parents:
diff changeset
514 * cp-tree.h (enum tsubst_flags): Add tf_fndecl_type.
kono
parents:
diff changeset
515 (flag_noexcept_type, ce_type): New.
kono
parents:
diff changeset
516 * call.c (build_conv): Add ck_fnptr.
kono
parents:
diff changeset
517 (enum conversion_kind): Change ck_tsafe to ck_fnptr.
kono
parents:
diff changeset
518 (convert_like_real): Likewise.
kono
parents:
diff changeset
519 (standard_conversion): Likewise. Allow function pointer
kono
parents:
diff changeset
520 conversions for pointers to member functions.
kono
parents:
diff changeset
521 (reference_compatible_p): Allow function pointer conversions.
kono
parents:
diff changeset
522 (direct_reference_binding): Likewise.
kono
parents:
diff changeset
523 (reference_binding): Reference-compatible is no longer a subset of
kono
parents:
diff changeset
524 reference-related.
kono
parents:
diff changeset
525 (is_subseq): Also strip ck_lvalue after next_conversion.
kono
parents:
diff changeset
526 * class.c (instantiate_type): Check fnptr_conv_p.
kono
parents:
diff changeset
527 (resolve_address_of_overloaded_function): Likewise.
kono
parents:
diff changeset
528 * cvt.c (can_convert_tx_safety): Now static.
kono
parents:
diff changeset
529 (noexcept_conv_p, fnptr_conv_p, strip_fnptr_conv): New.
kono
parents:
diff changeset
530 * decl.c (flag_noexcept_type): Define.
kono
parents:
diff changeset
531 (cxx_init_decl_processing): Set it.
kono
parents:
diff changeset
532 (bad_specifiers): Check it.
kono
parents:
diff changeset
533 (grokdeclarator) [cdk_function]: Add exception-spec to type here.
kono
parents:
diff changeset
534 * lambda.c (maybe_add_lambda_conv_op): Add exception-spec to
kono
parents:
diff changeset
535 returned pointer.
kono
parents:
diff changeset
536 * mangle.c (struct globals): Add need_cxx1z_warning.
kono
parents:
diff changeset
537 (mangle_decl): Check it.
kono
parents:
diff changeset
538 (write_exception_spec): New.
kono
parents:
diff changeset
539 (write_function_type): Call it.
kono
parents:
diff changeset
540 (canonicalize_for_substitution): Handle exception spec.
kono
parents:
diff changeset
541 (write_type): Likewise.
kono
parents:
diff changeset
542 (write_encoding): Set processing_template_decl across mangling of
kono
parents:
diff changeset
543 partially-instantiated type.
kono
parents:
diff changeset
544 * pt.c (determine_specialization): Pass tf_fndecl_type.
kono
parents:
diff changeset
545 (tsubst_decl, fn_type_unification): Likewise.
kono
parents:
diff changeset
546 (tsubst): Strip tf_fndecl_type, pass it to
kono
parents:
diff changeset
547 tsubst_exception_specification.
kono
parents:
diff changeset
548 (convert_nontype_argument_function): Handle function pointer
kono
parents:
diff changeset
549 conversion.
kono
parents:
diff changeset
550 (convert_nontype_argument): Likewise.
kono
parents:
diff changeset
551 (unify, for_each_template_parm_r): Walk into noexcept-specifier.
kono
parents:
diff changeset
552 * rtti.c (ptr_initializer): Encode noexcept.
kono
parents:
diff changeset
553 * tree.c (canonical_eh_spec): New.
kono
parents:
diff changeset
554 (build_exception_variant): Use it.
kono
parents:
diff changeset
555 * typeck.c (composite_pointer_type): Handle fnptr conversion.
kono
parents:
diff changeset
556 (comp_except_specs): Compare canonical EH specs.
kono
parents:
diff changeset
557 (structural_comptypes): Call it.
kono
parents:
diff changeset
558
kono
parents:
diff changeset
559 * call.c (standard_conversion): Reorganize pointer conversions.
kono
parents:
diff changeset
560 * pt.c (convert_nontype_argument_function): Convert to ref here.
kono
parents:
diff changeset
561 (convert_nontype_argument): Not here.
kono
parents:
diff changeset
562 (convert_template_argument): Add original type to error message.
kono
parents:
diff changeset
563 (RECUR_AND_CHECK_FAILURE): Remove trailing semicolon.
kono
parents:
diff changeset
564 (unify): Compare function-qualifiers.
kono
parents:
diff changeset
565 * typeck.c (same_type_ignoring_top_level_qualifiers_p): Use
kono
parents:
diff changeset
566 cp_build_qualified_type rather than TYPE_MAIN_VARIANT.
kono
parents:
diff changeset
567
kono
parents:
diff changeset
568 * pt.c (push_tinst_level_loc): Add template instantiations to the
kono
parents:
diff changeset
569 announce_function stream.
kono
parents:
diff changeset
570
kono
parents:
diff changeset
571 2016-11-04 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
572
kono
parents:
diff changeset
573 PR c++/67980
kono
parents:
diff changeset
574 * pt.c (tsubst_expr, case IF_STMT): Use fold_non_dependent_expr
kono
parents:
diff changeset
575 to suppress unwanted warnings.
kono
parents:
diff changeset
576
kono
parents:
diff changeset
577 2016-11-03 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
578
kono
parents:
diff changeset
579 PR c++/78198
kono
parents:
diff changeset
580 * call.c (convert_default_arg): Look through inheriting ctors.
kono
parents:
diff changeset
581
kono
parents:
diff changeset
582 2016-11-03 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
583 Alexandre Oliva <aoliva@redhat.com>
kono
parents:
diff changeset
584 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
585
kono
parents:
diff changeset
586 PR debug/28767
kono
parents:
diff changeset
587 PR debug/56974
kono
parents:
diff changeset
588 * tree.c (cp_check_qualified_type): Use check_base_type and
kono
parents:
diff changeset
589 TYPE_QUALS comparison instead of check_qualified_type.
kono
parents:
diff changeset
590 (cxx_type_hash_eq): Return false if type_memfn_rqual don't match.
kono
parents:
diff changeset
591 * cp-objcp-common.c (cp_get_debug_type): New function.
kono
parents:
diff changeset
592 (cp_decl_dwarf_attribute): Don't handle types here.
kono
parents:
diff changeset
593 (cp_type_dwarf_attribute): New function.
kono
parents:
diff changeset
594 * cp-objcp-common.h (cp_get_debug_type, cp_type_dwarf_attribute):
kono
parents:
diff changeset
595 Declare.
kono
parents:
diff changeset
596 (LANG_HOOKS_GET_DEBUG_TYPE, LANG_HOOKS_TYPE_DWARF_ATTRIBUTE):
kono
parents:
diff changeset
597 Define.
kono
parents:
diff changeset
598
kono
parents:
diff changeset
599 2016-11-03 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
600
kono
parents:
diff changeset
601 * tree.c (cp_check_qualified_type): Call check_base_type instead
kono
parents:
diff changeset
602 of check_qualified_type.
kono
parents:
diff changeset
603 (cxx_type_hash_eq): Check ref-qualifiers.
kono
parents:
diff changeset
604 * typeck.c (apply_memfn_quals): No need to mess with TYPE_CANONICAL.
kono
parents:
diff changeset
605
kono
parents:
diff changeset
606 2016-11-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
607
kono
parents:
diff changeset
608 Implement P0136R1, Rewording inheriting constructors.
kono
parents:
diff changeset
609 * call.c (enum rejection_reason_code): Add rr_inherited_ctor.
kono
parents:
diff changeset
610 (inherited_ctor_rejection): New.
kono
parents:
diff changeset
611 (add_function_candidate): Reject inherited ctors for copying.
kono
parents:
diff changeset
612 (enforce_access): Use strip_inheriting_ctors.
kono
parents:
diff changeset
613 (print_z_candidate): Likewise. Handle rr_inherited_ctor.
kono
parents:
diff changeset
614 (convert_like_real): Avoid copying inheriting ctor parameters.
kono
parents:
diff changeset
615 (build_over_call): Likewise. A base ctor inheriting from vbase
kono
parents:
diff changeset
616 has no parms. Sorry about varargs.
kono
parents:
diff changeset
617 (joust): A local constructor beats inherited with the same convs.
kono
parents:
diff changeset
618 * class.c (add_method): Handle hiding inheriting ctors.
kono
parents:
diff changeset
619 (one_inherited_ctor): Handle new semantics.
kono
parents:
diff changeset
620 (add_implicitly_declared_members): Pass using_decl down.
kono
parents:
diff changeset
621 (build_clone): A base ctor inheriting from vbase has no parms.
kono
parents:
diff changeset
622 * cp-tree.h (DECL_INHERITED_CTOR): Store this instead of the base.
kono
parents:
diff changeset
623 (SET_DECL_INHERITED_CTOR): Likewise.
kono
parents:
diff changeset
624 (DECL_INHERITED_CTOR_BASE): Adjust.
kono
parents:
diff changeset
625 * constexpr.c: Adjust.
kono
parents:
diff changeset
626 * error.c (dump_function_decl): Decorate inheriting ctors.
kono
parents:
diff changeset
627 * init.c (emit_mem_initializers): Suppress access control in
kono
parents:
diff changeset
628 inheriting ctor.
kono
parents:
diff changeset
629 * mangle.c (write_special_name_constructor): Handle new inheriting
kono
parents:
diff changeset
630 ctor mangling.
kono
parents:
diff changeset
631 * method.c (strip_inheriting_ctors, inherited_ctor_binfo)
kono
parents:
diff changeset
632 (ctor_omit_inherited_parms, binfo_inherited_from): New.
kono
parents:
diff changeset
633 (synthesized_method_walk): Use binfo_inherited_from. Suppress
kono
parents:
diff changeset
634 access control in inheriting ctor.
kono
parents:
diff changeset
635 (deduce_inheriting_ctor): Deleted if ambiguous ctor inheritance.
kono
parents:
diff changeset
636 (maybe_explain_implicit_delete): Explain ambigous ctor inheritance.
kono
parents:
diff changeset
637 (add_one_base_init, do_build_copy_constructor): Adjust.
kono
parents:
diff changeset
638 (locate_fn_flags, explain_implicit_non_constexpr): Adjust.
kono
parents:
diff changeset
639 (implicitly_declare_fn): Adjust.
kono
parents:
diff changeset
640 (get_inherited_ctor): Remove.
kono
parents:
diff changeset
641 * name-lookup.c (do_class_using_decl): Check for indirect ctor
kono
parents:
diff changeset
642 inheritance.
kono
parents:
diff changeset
643 * optimize.c (cdtor_comdat_group): Adjust for new mangling.
kono
parents:
diff changeset
644 (maybe_clone_body): Handle omitted parms in base clone.
kono
parents:
diff changeset
645 (maybe_thunk_body): Don't thunk if base clone omits parms.
kono
parents:
diff changeset
646 * pt.c (tsubst_decl): Adjust.
kono
parents:
diff changeset
647 (instantiate_template_1): Suppress access control in inheriting
kono
parents:
diff changeset
648 ctor.
kono
parents:
diff changeset
649 (fn_type_unification): Do deduction with inherited ctor.
kono
parents:
diff changeset
650 * tree.c (special_function_p): Adjust.
kono
parents:
diff changeset
651
kono
parents:
diff changeset
652 2016-11-01 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
653
kono
parents:
diff changeset
654 * cp-objcp-common.c (cp_decl_dwarf_attribute): Handle DW_AT_inline.
kono
parents:
diff changeset
655
kono
parents:
diff changeset
656 2016-11-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
657
kono
parents:
diff changeset
658 * class.c (declared_access): Split out from handle_using_decl.
kono
parents:
diff changeset
659
kono
parents:
diff changeset
660 2016-10-31 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
661
kono
parents:
diff changeset
662 PR c++/78089
kono
parents:
diff changeset
663 * parser.c (cp_parser_postfix_expression): Replace return statement in
kono
parents:
diff changeset
664 the first switch with setting postfix_expression to the return
kono
parents:
diff changeset
665 expression and break;.
kono
parents:
diff changeset
666
kono
parents:
diff changeset
667 PR c++/77886
kono
parents:
diff changeset
668 * pt.c (tsubst_expr) <case CASE_LABEL_EXPR> Copy over
kono
parents:
diff changeset
669 FALLTHROUGH_LABEL_P flag to the new LABEL_DECL.
kono
parents:
diff changeset
670 (tsubst_expr) <case LABEL_EXPR>: Likewise.
kono
parents:
diff changeset
671
kono
parents:
diff changeset
672 2016-09-11 Le-Chun Wu <lcwu@google.com>
kono
parents:
diff changeset
673 Mark Wielaard <mjw@redhat.com>
kono
parents:
diff changeset
674
kono
parents:
diff changeset
675 * name-lookup.c (pushdecl_maybe_friend): When emitting a
kono
parents:
diff changeset
676 shadowing warning, use the code corresponding to the
kono
parents:
diff changeset
677 given -Wshadow= variant.
kono
parents:
diff changeset
678
kono
parents:
diff changeset
679 2016-10-26 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
680
kono
parents:
diff changeset
681 * class.c (add_method): Allow using-declarations to coexist.
kono
parents:
diff changeset
682
kono
parents:
diff changeset
683 2016-10-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
684
kono
parents:
diff changeset
685 * constexpr.c (maybe_constant_init): Pull out TARGET_EXPR_INITIAL.
kono
parents:
diff changeset
686 (cxx_eval_outermost_constant_expr): Don't return a CONSTRUCTOR
kono
parents:
diff changeset
687 with CONSTRUCTOR_NO_IMPLICIT_ZERO.
kono
parents:
diff changeset
688 (cxx_eval_call_expression): Clear CONSTRUCTOR_NO_IMPLICIT_ZERO.
kono
parents:
diff changeset
689
kono
parents:
diff changeset
690 2016-10-25 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
691
kono
parents:
diff changeset
692 * parser.c (cp_parser_postfix_expression): Adding missing break;.
kono
parents:
diff changeset
693
kono
parents:
diff changeset
694 * cp-tree.h (finish_builtin_launder): Declare.
kono
parents:
diff changeset
695 * parser.c (cp_parser_postfix_expression): Handle RID_BUILTIN_LAUNDER.
kono
parents:
diff changeset
696 * semantics.c (finish_builtin_launder): New function.
kono
parents:
diff changeset
697 * pt.c (tsubst_copy_and_build): Handle instantiation of IFN_LAUNDER.
kono
parents:
diff changeset
698 * constexpr.c (cxx_eval_internal_function): Handle IFN_LAUNDER.
kono
parents:
diff changeset
699 (potential_constant_expression_1): Likewise.
kono
parents:
diff changeset
700
kono
parents:
diff changeset
701 2016-10-24 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
702
kono
parents:
diff changeset
703 * cp-objcp-common.c (cp_decl_dwarf_attribute): Handle DW_AT_reference
kono
parents:
diff changeset
704 and DW_AT_rvalue_reference.
kono
parents:
diff changeset
705
kono
parents:
diff changeset
706 * cxx-pretty-print.c (pp_cxx_check_constraint): Use VAR_P (x)
kono
parents:
diff changeset
707 instead of TREE_CODE (x) == VAR_DECL.
kono
parents:
diff changeset
708 * constraint.cc (get_concept_definition): Likewise.
kono
parents:
diff changeset
709 (finish_shorthand_constraint): Likewise.
kono
parents:
diff changeset
710 * init.c (warn_placement_new_too_small): Likewise.
kono
parents:
diff changeset
711 * cp-gimplify.c (cp_genericize_r): Likewise.
kono
parents:
diff changeset
712
kono
parents:
diff changeset
713 2016-10-21 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
714
kono
parents:
diff changeset
715 PR c++/77656
kono
parents:
diff changeset
716 * pt.c (convert_template_argument): Call convert_nontype_argument
kono
parents:
diff changeset
717 on value-dependent but not type-dependent arguments.
kono
parents:
diff changeset
718 (convert_nontype_argument): Handle value-dependent arguments.
kono
parents:
diff changeset
719 (canonicalize_expr_argument): New.
kono
parents:
diff changeset
720 (deducible_expression, unify): Skip CONVERT_EXPR.
kono
parents:
diff changeset
721 * error.c (dump_template_argument): Likewise.
kono
parents:
diff changeset
722 * mangle.c (write_expression): Likewise.
kono
parents:
diff changeset
723
kono
parents:
diff changeset
724 * ptree.c (cxx_print_xnode) [TEMPLATE_PARM_INDEX]: Dump the decl.
kono
parents:
diff changeset
725
kono
parents:
diff changeset
726 2016-10-21 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
727
kono
parents:
diff changeset
728 * cp-objcp-common.c (cp_decl_dwarf_attribute): Handle
kono
parents:
diff changeset
729 DW_AT_const_expr.
kono
parents:
diff changeset
730
kono
parents:
diff changeset
731 2016-10-17 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
732
kono
parents:
diff changeset
733 * cp-objcp-common.h (cp_function_decl_explicit_p,
kono
parents:
diff changeset
734 cp_function_decl_deleted_p, cp_function_decl_defaulted): Remove.
kono
parents:
diff changeset
735 (cp_decl_dwarf_attribute): Declare.
kono
parents:
diff changeset
736 (LANG_HOOKS_FUNCTION_DECL_EXPLICIT_P,
kono
parents:
diff changeset
737 LANG_HOOKS_FUNCTION_DECL_DELETED_P,
kono
parents:
diff changeset
738 LANG_HOOKS_FUNCTION_DECL_DEFAULTED): Remove.
kono
parents:
diff changeset
739 (LANG_HOOKS_DECL_DWARF_ATTRIBUTE): Redefine.
kono
parents:
diff changeset
740 * cp-objcp-common.c (cp_function_decl_explicit_p,
kono
parents:
diff changeset
741 cp_function_decl_deleted_p, cp_function_decl_defaulted): Remove.
kono
parents:
diff changeset
742 (cp_decl_dwarf_attribute): New function.
kono
parents:
diff changeset
743
kono
parents:
diff changeset
744 2016-10-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
745
kono
parents:
diff changeset
746 PR c++/77945
kono
parents:
diff changeset
747 * constexpr.c (maybe_simplify_trivial_copy): New.
kono
parents:
diff changeset
748 (cxx_eval_store_expression): Call it.
kono
parents:
diff changeset
749 * call.c (build_over_call): Use unsigned char for trivial copy.
kono
parents:
diff changeset
750
kono
parents:
diff changeset
751 2016-10-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
752
kono
parents:
diff changeset
753 Implement P0017R1, C++17 aggregates with bases.
kono
parents:
diff changeset
754 * class.c (build_base_field_1): Split out from...
kono
parents:
diff changeset
755 (build_base_field): ...here. In C++17 mode, build a field for
kono
parents:
diff changeset
756 empty bases.
kono
parents:
diff changeset
757 * decl.c (xref_basetypes): In C++17 aggregates can have bases.
kono
parents:
diff changeset
758 (next_initializable_field): Allow base fields in C++17.
kono
parents:
diff changeset
759 * typeck2.c (process_init_constructor_record): Likewise.
kono
parents:
diff changeset
760
kono
parents:
diff changeset
761 2016-10-14 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
762
kono
parents:
diff changeset
763 DR 1511 - const volatile variables and ODR
kono
parents:
diff changeset
764 * decl.c (grokvardecl): Change flags argument to type_quals,
kono
parents:
diff changeset
765 add conceptp argument. Set TREE_PUBLIC for non-static volatile vars.
kono
parents:
diff changeset
766 (grokdeclarator): Adjust grokvardecl caller.
kono
parents:
diff changeset
767
kono
parents:
diff changeset
768 2016-10-13 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
769
kono
parents:
diff changeset
770 PR c++/71912
kono
parents:
diff changeset
771 * class.c (struct flexmems_t): Add members.
kono
parents:
diff changeset
772 (find_flexarrays): Add arguments. Correct handling of anonymous
kono
parents:
diff changeset
773 structs.
kono
parents:
diff changeset
774 (diagnose_flexarrays): Adjust to issue warnings in addition to errors.
kono
parents:
diff changeset
775 (check_flexarrays): Add argument.
kono
parents:
diff changeset
776 (diagnose_invalid_flexarray): New functions.
kono
parents:
diff changeset
777
kono
parents:
diff changeset
778 2016-10-13 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
779 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
780
kono
parents:
diff changeset
781 Implement P0386R2 - C++17 inline variables
kono
parents:
diff changeset
782 * cp-tree.h (struct lang_type): Shrink language field to 1 bit
kono
parents:
diff changeset
783 from 4. Add var_declared_inline_p field. Mention 2 spare bits.
kono
parents:
diff changeset
784 (DECL_VAR_DECLARED_INLINE_P): Define.
kono
parents:
diff changeset
785 (SET_DECL_VAR_DECLARED_INLINE_P): Define.
kono
parents:
diff changeset
786 (DECL_INLINE_VAR_P): Define.
kono
parents:
diff changeset
787 (diagnose_inline_vars_for_namespace): Declare.
kono
parents:
diff changeset
788 * decl.c (diagnose_inline_vars_for_namespace): New function.
kono
parents:
diff changeset
789 (duplicate_decls): For static data members copy
kono
parents:
diff changeset
790 DECL_DECLARED_CONSTEXPR_P.
kono
parents:
diff changeset
791 (redeclaration_error_message): Handle C++17 redundant redeclaration
kono
parents:
diff changeset
792 of constexpr static data member outside of class.
kono
parents:
diff changeset
793 (maybe_commonize_var): Handle inline variables.
kono
parents:
diff changeset
794 (check_initializer): Ignore inline variables for diagnostics.
kono
parents:
diff changeset
795 Adjust diagnostic wording for C++17.
kono
parents:
diff changeset
796 (make_rtl_for_nonlocal_decl): Allow in-class definition of
kono
parents:
diff changeset
797 inline static data members.
kono
parents:
diff changeset
798 (bad_specifiers): Don't diagnose inline on variables here.
kono
parents:
diff changeset
799 (grokvardecl): Add inlinep argument, non-static const inline variables
kono
parents:
diff changeset
800 are TREE_PUBLIC.
kono
parents:
diff changeset
801 (check_static_variable_definition): Return early also for inline
kono
parents:
diff changeset
802 variables.
kono
parents:
diff changeset
803 (mark_inline_variable): New.
kono
parents:
diff changeset
804 (grokdeclarator): Handle inline variables and inline static data
kono
parents:
diff changeset
805 members.
kono
parents:
diff changeset
806 * typeck2.c (store_init_value): Don't diagnose non-constant
kono
parents:
diff changeset
807 initializers for non-constexpr inline static data members.
kono
parents:
diff changeset
808 * decl2.c (vague_linkage_p): Return true for inline variables.
kono
parents:
diff changeset
809 (c_parse_final_cleanups): In-class declaration of inline static
kono
parents:
diff changeset
810 data members is a definition. Call diagnose_inline_vars_for_namespace
kono
parents:
diff changeset
811 through walk_namespaces.
kono
parents:
diff changeset
812 * pt.c (instantiate_decl): Set pattern_defined for in-class definitions
kono
parents:
diff changeset
813 of inline static data members.
kono
parents:
diff changeset
814
kono
parents:
diff changeset
815 2016-10-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
816
kono
parents:
diff changeset
817 * decl.c (mark_inline_variable): New.
kono
parents:
diff changeset
818
kono
parents:
diff changeset
819 >>>>>>> .r241142
kono
parents:
diff changeset
820 2016-10-13 Thomas Preud'homme <thomas.preudhomme@arm.com>
kono
parents:
diff changeset
821
kono
parents:
diff changeset
822 * decl2.c: Include memmodel.h.
kono
parents:
diff changeset
823 * rtti.c: Likewise.
kono
parents:
diff changeset
824
kono
parents:
diff changeset
825 2016-10-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
826
kono
parents:
diff changeset
827 PR c++/77742
kono
parents:
diff changeset
828 * init.c (build_new_1): Don't -Waligned-new about placement new.
kono
parents:
diff changeset
829 (malloc_alignment): New. Consider MALLOC_ABI_ALIGNMENT.
kono
parents:
diff changeset
830 * decl.c (cxx_init_decl_processing): New.
kono
parents:
diff changeset
831
kono
parents:
diff changeset
832 2016-10-10 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
833
kono
parents:
diff changeset
834 PR c++/77890
kono
parents:
diff changeset
835 PR c++/77912
kono
parents:
diff changeset
836 * pt.c (do_class_deduction): Set cp_unevaluated_operand.
kono
parents:
diff changeset
837 (tsubst) [TEMPLATE_TYPE_PARM]: Copy CLASS_PLACEHOLDER_TEMPLATE.
kono
parents:
diff changeset
838
kono
parents:
diff changeset
839 2016-10-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
840
kono
parents:
diff changeset
841 * cp-gimplify.c (cp_fold): Add variable name.
kono
parents:
diff changeset
842
kono
parents:
diff changeset
843 * cp-gimplify.c (cp_fold): Distribute cp_truthvalue_conversion
kono
parents:
diff changeset
844 into COND_EXPR.
kono
parents:
diff changeset
845
kono
parents:
diff changeset
846 2016-10-07 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
847
kono
parents:
diff changeset
848 Further P0135 refinement.
kono
parents:
diff changeset
849 * call.c (build_user_type_conversion_1): Consider conversions from
kono
parents:
diff changeset
850 a single element in an initializer-list.
kono
parents:
diff changeset
851 (build_temp): Undo early_elide_copy change.
kono
parents:
diff changeset
852 (build_over_call): Check that we don't try to copy a TARGET_EXPR
kono
parents:
diff changeset
853 in C++17 mode. Set user_conv_p here.
kono
parents:
diff changeset
854 (convert_like_real): Not here.
kono
parents:
diff changeset
855 (check_self_delegation): Split out from...
kono
parents:
diff changeset
856 (build_special_member_call): ...here. Handle C++17 copy elision.
kono
parents:
diff changeset
857 * cvt.c (early_elide_copy): Remove.
kono
parents:
diff changeset
858 (ocp_convert): Undo early_elide_copy change.
kono
parents:
diff changeset
859 * except.c (build_throw): Likewise.
kono
parents:
diff changeset
860 * init.c (expand_default_init): Likewise.
kono
parents:
diff changeset
861 * typeck.c (cp_build_modify_expr): Likewise.
kono
parents:
diff changeset
862
kono
parents:
diff changeset
863 2016-10-07 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
864
kono
parents:
diff changeset
865 PR c++/64433
kono
parents:
diff changeset
866 DR1658, DR1611
kono
parents:
diff changeset
867 * init.c (emit_mem_initializers): Don't construct vbases of
kono
parents:
diff changeset
868 abstract classes.
kono
parents:
diff changeset
869 (push_base_cleanups): Don't push vbase cleanups for abstract class
kono
parents:
diff changeset
870 when in C++14 mode.
kono
parents:
diff changeset
871 * method.c (synthethesized_method_walk): Don't walk vbases of
kono
parents:
diff changeset
872 abstract classes when in C++14 mode.
kono
parents:
diff changeset
873
kono
parents:
diff changeset
874 2016-10-07 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
875
kono
parents:
diff changeset
876 Implement LWG2296 helper intrinsic
kono
parents:
diff changeset
877 * parser.c (cp_parser_postfix_expression): Handle RID_ADDRESSOF.
kono
parents:
diff changeset
878 * cp-objcp-common.c (cp_common_init_ts): Handle ADDRESSOF_EXPR.
kono
parents:
diff changeset
879 * constexpr.c (potential_constant_expression_1): Likewise.
kono
parents:
diff changeset
880 * error.c (dump_expr): Likewise.
kono
parents:
diff changeset
881 * typeck.c (cp_build_addressof): New function.
kono
parents:
diff changeset
882 * cp-tree.h (cp_build_addressof): Declare.
kono
parents:
diff changeset
883 * cxx-pretty-print.h (pp_cxx_addressof_expression): Declare.
kono
parents:
diff changeset
884 * cp-tree.def (ADDRESSOF_EXPR): New tree code.
kono
parents:
diff changeset
885 * cxx-pretty-print.c (cxx_pretty_printer::primary_expression): Handle
kono
parents:
diff changeset
886 ADDRESSOF_EXPR. Add __builtin_addressof and
kono
parents:
diff changeset
887 __has_unique_object_representations into syntax in function comment.
kono
parents:
diff changeset
888 (pp_cxx_addressof_expression): New function.
kono
parents:
diff changeset
889 * pt.c (tsubst_copy_and_build): Handle ADDRESSOF_EXPR.
kono
parents:
diff changeset
890
kono
parents:
diff changeset
891 2016-10-07 Bernd Edlinger <bernd.edlinger@hotmail.de>
kono
parents:
diff changeset
892
kono
parents:
diff changeset
893 PR c++/77700
kono
parents:
diff changeset
894 * parser.c (cp_parser_base_specifier): Fix a warning.
kono
parents:
diff changeset
895
kono
parents:
diff changeset
896 2016-10-07 Bernd Schmidt <bschmidt@redhat.com>
kono
parents:
diff changeset
897
kono
parents:
diff changeset
898 PR c++/69733
kono
parents:
diff changeset
899 * decl.c (grokdeclarator): Try to find the correct location for an
kono
parents:
diff changeset
900 ignored qualifier.
kono
parents:
diff changeset
901
kono
parents:
diff changeset
902 2016-10-07 Martin Liska <mliska@suse.cz>
kono
parents:
diff changeset
903
kono
parents:
diff changeset
904 * lambda.c (maybe_add_lambda_conv_op): Set default value.
kono
parents:
diff changeset
905
kono
parents:
diff changeset
906 2016-10-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
907
kono
parents:
diff changeset
908 * call.c (build_temp, convert_like_real): Don't re-copy
kono
parents:
diff changeset
909 TARGET_EXPR. Handle packed fields.
kono
parents:
diff changeset
910 (build_x_va_arg): Wrap it in a TARGET_EXPR.
kono
parents:
diff changeset
911 (build_over_call): Add sanity check.
kono
parents:
diff changeset
912 * cvt.c (early_elide_copy): New.
kono
parents:
diff changeset
913 (ocp_convert): Use it.
kono
parents:
diff changeset
914 * except.c (build_throw): Use it.
kono
parents:
diff changeset
915 * init.c (get_nsdmi): Put back the TARGET_EXPR.
kono
parents:
diff changeset
916 (expand_default_init): Call early_elide_copy.
kono
parents:
diff changeset
917 * typeck.c (cp_build_modify_expr): Call early_elide_copy.
kono
parents:
diff changeset
918
kono
parents:
diff changeset
919 2016-10-06 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
920
kono
parents:
diff changeset
921 Implement P0258R2 - helper for C++17
kono
parents:
diff changeset
922 std::has_unique_object_representations trait
kono
parents:
diff changeset
923 * cp-tree.h (enum cp_trait_kind): Add
kono
parents:
diff changeset
924 CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS.
kono
parents:
diff changeset
925 (struct lang_type_class): Add unique_obj_representations
kono
parents:
diff changeset
926 and unique_obj_representations_set bitfields.
kono
parents:
diff changeset
927 (CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS,
kono
parents:
diff changeset
928 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET): Define.
kono
parents:
diff changeset
929 (type_has_unique_obj_representations): Declare.
kono
parents:
diff changeset
930 * parser.c (cp_parser_primary_expression): Handle
kono
parents:
diff changeset
931 RID_HAS_UNIQUE_OBJ_REPRESENTATIONS.
kono
parents:
diff changeset
932 (cp_parser_trait_expr): Likewise. Formatting fix.
kono
parents:
diff changeset
933 * semantics.c (trait_expr_value, finish_trait_expr): Handle
kono
parents:
diff changeset
934 CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS.
kono
parents:
diff changeset
935 * tree.c (type_has_unique_obj_representations): New function.
kono
parents:
diff changeset
936 (record_has_unique_obj_representations): New function.
kono
parents:
diff changeset
937 * cxx-pretty-print.c (pp_cxx_trait_expression): Handle
kono
parents:
diff changeset
938 CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS.
kono
parents:
diff changeset
939
kono
parents:
diff changeset
940 2016-10-05 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
941
kono
parents:
diff changeset
942 Implement P0135R1, Guaranteed copy elision.
kono
parents:
diff changeset
943 * cvt.c (ocp_convert): Don't re-copy a TARGET_EXPR in C++17.
kono
parents:
diff changeset
944
kono
parents:
diff changeset
945 PR c++/54293
kono
parents:
diff changeset
946 * call.c (reference_binding): Fix binding to member of temporary.
kono
parents:
diff changeset
947
kono
parents:
diff changeset
948 * call.c (extend_ref_init_temps): Fix TARGET_EXPR handling.
kono
parents:
diff changeset
949
kono
parents:
diff changeset
950 * parser.c (cp_parser_skip_to_end_of_statement): Add missing break.
kono
parents:
diff changeset
951
kono
parents:
diff changeset
952 * semantics.c (finish_compound_literal): Handle class placeholder.
kono
parents:
diff changeset
953
kono
parents:
diff changeset
954 2016-10-05 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
955
kono
parents:
diff changeset
956 Implement P0305R1, Selection statements with initializer.
kono
parents:
diff changeset
957 * cp-array-notation.c (create_an_loop): Call finish_init_stmt
kono
parents:
diff changeset
958 instead of finish_for_init_stmt.
kono
parents:
diff changeset
959 * cp-tree.h (finish_for_init_stmt): Rename to finish_init_stmt.
kono
parents:
diff changeset
960 * decl.c (poplevel): Adjust a comment.
kono
parents:
diff changeset
961 * init.c (build_vec_init): Call finish_init_stmt instead of
kono
parents:
diff changeset
962 finish_for_init_stmt.
kono
parents:
diff changeset
963 * name-lookup.c (pushdecl_maybe_friend_1): Adjust a comment.
kono
parents:
diff changeset
964 * name-lookup.h (enum scope_kind): Likewise.
kono
parents:
diff changeset
965 * parser.c (cp_parser_statement): Update commentary.
kono
parents:
diff changeset
966 (cp_parser_init_statement_p): New function.
kono
parents:
diff changeset
967 (cp_parser_selection_statement): Parse the optional init-statement.
kono
parents:
diff changeset
968 (cp_parser_for): Call finish_init_stmt instead of finish_for_init_stmt.
kono
parents:
diff changeset
969 (cp_parser_c_for): Likewise.
kono
parents:
diff changeset
970 (cp_convert_range_for): Call finish_init_stmt instead of finish_for_init_stmt.
kono
parents:
diff changeset
971 (cp_parser_range_for_member_function): Update commentary.
kono
parents:
diff changeset
972 (cp_parser_iteration_statement):
kono
parents:
diff changeset
973 (cp_parser_for_init_statement): Rename to cp_parser_init_statement.
kono
parents:
diff changeset
974 * pt.c (tsubst_omp_for_iterator): Update commentary.
kono
parents:
diff changeset
975 (tsubst_expr): Call finish_init_stmt instead of finish_for_init_stmt.
kono
parents:
diff changeset
976 * semantics.c (finish_for_init_stmt): Rename to finish_init_stmt.
kono
parents:
diff changeset
977 Update commentary.
kono
parents:
diff changeset
978
kono
parents:
diff changeset
979 2016-10-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
980
kono
parents:
diff changeset
981 PR c++/77852
kono
parents:
diff changeset
982 * pt.c (do_class_deduction): Handle list-initialization.
kono
parents:
diff changeset
983 (do_auto_deduction): Call it sooner.
kono
parents:
diff changeset
984 (build_deduction_guide): Use tsubst_arg_types.
kono
parents:
diff changeset
985 (rewrite_template_parm): Don't copy_type.
kono
parents:
diff changeset
986
kono
parents:
diff changeset
987 PR c++/77775
kono
parents:
diff changeset
988 * constexpr.c (cxx_eval_component_reference): Use name matching
kono
parents:
diff changeset
989 for PMFs.
kono
parents:
diff changeset
990
kono
parents:
diff changeset
991 Implement P0091R2, Template argument deduction for class templates.
kono
parents:
diff changeset
992 * parser.c (cp_parser_simple_type_specifier): Parse class placeholder.
kono
parents:
diff changeset
993 Use the location of the beginning of the type-specifier.
kono
parents:
diff changeset
994 (cp_parser_init_declarator): Parse deduction guide.
kono
parents:
diff changeset
995 (cp_parser_diagnose_invalid_type_name): Mention class deduction.
kono
parents:
diff changeset
996 (cp_parser_type_id_1): Don't accept class placeholder as template arg.
kono
parents:
diff changeset
997 * cp-tree.h (CLASS_PLACEHOLDER_TEMPLATE): New.
kono
parents:
diff changeset
998 * decl.c (grokdeclarator): Check for uninitialized auto here.
kono
parents:
diff changeset
999 (start_decl_1): Not here.
kono
parents:
diff changeset
1000 (cp_finish_decl): Or here. Don't collapse a list when doing
kono
parents:
diff changeset
1001 class deduction.
kono
parents:
diff changeset
1002 (grokfndecl): Check deduction guide scope and body.
kono
parents:
diff changeset
1003 * error.c (dump_decl, dump_function_decl, dump_function_name):
kono
parents:
diff changeset
1004 Handle deduction guides.
kono
parents:
diff changeset
1005 * pt.c (make_template_placeholder, do_class_deduction): New.
kono
parents:
diff changeset
1006 (build_deduction_guide, rewrite_template_parm): New.
kono
parents:
diff changeset
1007 (dguide_name, dguide_name_p, deduction_guide_p): New.
kono
parents:
diff changeset
1008 (do_auto_deduction): Call do_class_deduction.
kono
parents:
diff changeset
1009 (splice_late_return_type, is_auto): Handle class placeholders.
kono
parents:
diff changeset
1010 (template_parms_level_to_args): Split from template_parms_to_args.
kono
parents:
diff changeset
1011 (tsubst_template_parms_level): Split from tsubst_template_parms.
kono
parents:
diff changeset
1012 * typeck2.c (build_functional_cast): Handle class placeholder.
kono
parents:
diff changeset
1013
kono
parents:
diff changeset
1014 2016-10-04 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
1015
kono
parents:
diff changeset
1016 PR c++/77804
kono
parents:
diff changeset
1017 * init.c (warn_placement_new_too_small): Avoid assuming an array type
kono
parents:
diff changeset
1018 has a constant size.
kono
parents:
diff changeset
1019
kono
parents:
diff changeset
1020 2016-10-04 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1021
kono
parents:
diff changeset
1022 PR c++/77791
kono
parents:
diff changeset
1023 * parser.c (cp_parser_lambda_declarator_opt): Only pedwarn
kono
parents:
diff changeset
1024 for C++11 on decls in the param_list. Test cxx_dialect < cxx14 before
kono
parents:
diff changeset
1025 the loop just once.
kono
parents:
diff changeset
1026
kono
parents:
diff changeset
1027 * cp-tree.h (enum cp_tree_index): Remove CPTI_JAVA_*,
kono
parents:
diff changeset
1028 CPTI_LANG_NAME_JAVA and CPTI_JCLASS.
kono
parents:
diff changeset
1029 (java_byte_type_node, java_short_type_node, java_int_type_node,
kono
parents:
diff changeset
1030 java_long_type_node, java_float_type_node, java_double_type_node,
kono
parents:
diff changeset
1031 java_char_type_node, java_boolean_type_node, lang_name_java,
kono
parents:
diff changeset
1032 jclass_node): Remove.
kono
parents:
diff changeset
1033 (enum languages): Remove lang_java.
kono
parents:
diff changeset
1034 (TYPE_FOR_JAVA): Remove.
kono
parents:
diff changeset
1035 (struct lang_type_class): Remove java_interface bit-field.
kono
parents:
diff changeset
1036 (TYPE_JAVA_INTERFACE): Remove.
kono
parents:
diff changeset
1037 (pragma_java_exceptions): Remove.
kono
parents:
diff changeset
1038 (check_java_method, build_java_class_ref): Remove prototypes.
kono
parents:
diff changeset
1039 * name-lookup.c (pushtag_1): Don't set TYPE_FOR_JAVA.
kono
parents:
diff changeset
1040 * decl2.c (acceptable_java_type, check_java_method): Remove.
kono
parents:
diff changeset
1041 (import_export_decl): Remove TYPE_FOR_JAVA handling.
kono
parents:
diff changeset
1042 (build_java_method_aliases): Remove.
kono
parents:
diff changeset
1043 (c_parse_final_cleanups): Don't call build_java_method_aliases.
kono
parents:
diff changeset
1044 (possibly_inlined_p): Don't test pragma_java_exceptions.
kono
parents:
diff changeset
1045 * init.c (build_new_1): Remove TYPE_FOR_JAVA handling.
kono
parents:
diff changeset
1046 (build_java_class_ref): Remove.
kono
parents:
diff changeset
1047 * pt.c (maybe_new_partial_specialization, lookup_template_class_1,
kono
parents:
diff changeset
1048 instantiate_class_template_1): Don't copy TYPE_FOR_JAVA.
kono
parents:
diff changeset
1049 * except.c (eh_type_info): Remove java type handling.
kono
parents:
diff changeset
1050 (decl_is_java_type, choose_personality_routine): Remove.
kono
parents:
diff changeset
1051 (initialize_handler_parm): Don't call choose_personality_routine.
kono
parents:
diff changeset
1052 (expand_start_catch_block): Don't handle java types.
kono
parents:
diff changeset
1053 (build_throw): Likewise.
kono
parents:
diff changeset
1054 * cp-lang.c (cp_eh_personality): Don't handle pragma_java_exceptions.
kono
parents:
diff changeset
1055 * typeck.c (structural_comptypes): Don't compare TYPE_FOR_JAVA.
kono
parents:
diff changeset
1056 * call.c (build_over_call): Don't handle TYPE_JAVA_INTERFACE.
kono
parents:
diff changeset
1057 (java_iface_lookup_fn): Remove.
kono
parents:
diff changeset
1058 (build_java_interface_fn_ref): Remove.
kono
parents:
diff changeset
1059 * tree.c (cxx_attribute_table): Remove java_interface.
kono
parents:
diff changeset
1060 (handle_java_interface_attribute): Remove.
kono
parents:
diff changeset
1061 * lex.c (pragma_java_exceptions): Remove.
kono
parents:
diff changeset
1062 (init_cp_pragma): Don't register GCC java_exceptions pragma.
kono
parents:
diff changeset
1063 (handle_pragma_java_exceptions): Remove.
kono
parents:
diff changeset
1064 (retrofit_lang_decl): Don't handle lang_name_java.
kono
parents:
diff changeset
1065 * method.c (implicitly_declare_fn): Don't handle TYPE_FOR_JAVA.
kono
parents:
diff changeset
1066 * error.c (language_to_string): Don't handle lang_java.
kono
parents:
diff changeset
1067 * decl.c (record_builtin_java_type): Remove.
kono
parents:
diff changeset
1068 (initialize_predefined_identifiers): Remove Java.
kono
parents:
diff changeset
1069 (cxx_init_decl_processing): Remove java_*_type_node.
kono
parents:
diff changeset
1070 (cp_finish_decl): Don't handle TYPE_FOR_JAVA.
kono
parents:
diff changeset
1071 (grokfndecl): Likewise.
kono
parents:
diff changeset
1072 (check_special_function_return_type): Likewise.
kono
parents:
diff changeset
1073 (grokdeclarator): Don't set TYPE_FOR_JAVA.
kono
parents:
diff changeset
1074 (grokparms): Don't handle TYPE_FOR_JAVA.
kono
parents:
diff changeset
1075 (xref_basetypes): Likewise.
kono
parents:
diff changeset
1076 (check_function_type): Likewise.
kono
parents:
diff changeset
1077 (finish_constructor_body): Likewise.
kono
parents:
diff changeset
1078 * mangle.c (write_builtin_type): Don't handle TYPE_FOR_JAVA
kono
parents:
diff changeset
1079 and java_*_type_node.
kono
parents:
diff changeset
1080 (write_bare_function_type): Don't handle TYPE_FOR_JAVA.
kono
parents:
diff changeset
1081 (write_java_integer_type_codes): Remove.
kono
parents:
diff changeset
1082 * class.c (add_method): Don't handle TYPE_FOR_JAVA.
kono
parents:
diff changeset
1083 (add_implicitly_declared_members, determine_key_method,
kono
parents:
diff changeset
1084 finish_struct_1): Likewise.
kono
parents:
diff changeset
1085 (push_lang_context): Don't handle lang_name_java.
kono
parents:
diff changeset
1086
kono
parents:
diff changeset
1087 2016-10-03 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1088
kono
parents:
diff changeset
1089 Core 903
kono
parents:
diff changeset
1090 * typeck.c (cp_build_binary_op): Pass original operands to
kono
parents:
diff changeset
1091 null_ptr_cst_p, not those after the default conversions.
kono
parents:
diff changeset
1092
kono
parents:
diff changeset
1093 2016-10-03 Bernd Edlinger <bernd.edlinger@hotmail.de>
kono
parents:
diff changeset
1094
kono
parents:
diff changeset
1095 * parser.c (cp_parser_condition): Fix a warning.
kono
parents:
diff changeset
1096
kono
parents:
diff changeset
1097 2016-09-29 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1098
kono
parents:
diff changeset
1099 Implement P0001R1 - C++17 removal of register storage class specifier
kono
parents:
diff changeset
1100 * decl.c (cp_finish_decl): Diagnose register storage class
kono
parents:
diff changeset
1101 on vars except when used in GNU global or local register variable
kono
parents:
diff changeset
1102 extension.
kono
parents:
diff changeset
1103 (grokdeclarator): Diagnose register storage class on parameters.
kono
parents:
diff changeset
1104 * except.c (expand_start_catch_block): Set DECL_REGISTER only
kono
parents:
diff changeset
1105 after cp_finish_decl call.
kono
parents:
diff changeset
1106
kono
parents:
diff changeset
1107 2016-09-29 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1108
kono
parents:
diff changeset
1109 * rtti.c (involves_incomplete_p): Add fall through comment.
kono
parents:
diff changeset
1110
kono
parents:
diff changeset
1111 2016-09-28 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1112
kono
parents:
diff changeset
1113 PR c++/77467
kono
parents:
diff changeset
1114 * constexpr.c (enum constexpr_switch_state): New.
kono
parents:
diff changeset
1115 (struct constexpr_ctx): Add css_state field.
kono
parents:
diff changeset
1116 (label_matches): Add CTX and STMT arguments, remove I and
kono
parents:
diff changeset
1117 DEFAULT_LABEL. For CASE_LABEL_EXPR assert ctx->css_state != NULL,
kono
parents:
diff changeset
1118 handle default labels according to css_state.
kono
parents:
diff changeset
1119 (cxx_eval_statement_list): Remove statement skipping, label_matches
kono
parents:
diff changeset
1120 and default_label handling code.
kono
parents:
diff changeset
1121 (cxx_eval_loop_expr): Exit after first iteration even if
kono
parents:
diff changeset
1122 switches (jump_target).
kono
parents:
diff changeset
1123 (cxx_eval_switch_expr): Set up css_state field in ctx, if default
kono
parents:
diff changeset
1124 label has been seen in the body, but no cases matched, evaluate
kono
parents:
diff changeset
1125 the body second time.
kono
parents:
diff changeset
1126 (cxx_eval_constant_expression): Handle stmt skipping and label_matches
kono
parents:
diff changeset
1127 here. Handle PREDICT_EXPR. For MODIFY_EXPR or INIT_EXPR, assert
kono
parents:
diff changeset
1128 statement is not skipped. For COND_EXPR during skipping, don't
kono
parents:
diff changeset
1129 evaluate condition, just the then block and if still skipping at the
kono
parents:
diff changeset
1130 end also the else block.
kono
parents:
diff changeset
1131 (cxx_eval_outermost_constant_expr): Adjust constexpr_ctx initializer.
kono
parents:
diff changeset
1132 (is_sub_constant_expr): Likewise.
kono
parents:
diff changeset
1133
kono
parents:
diff changeset
1134 2016-09-27 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1135
kono
parents:
diff changeset
1136 Implement P0018R3, C++17 lambda capture of *this by value as [=,*this]
kono
parents:
diff changeset
1137 * parser.c (cp_parser_lambda_introducer): Formatting fix. Pass
kono
parents:
diff changeset
1138 true instead of false as by_reference_p to add_capture for 'this'.
kono
parents:
diff changeset
1139 Parse '*this' simple-capture.
kono
parents:
diff changeset
1140 * lambda.c (build_capture_proxy): Handle '*this' capture by value.
kono
parents:
diff changeset
1141 (add_capture): Adjust function comment. For id == this_identifier,
kono
parents:
diff changeset
1142 treat by_reference_p as capturing '*this' by reference, i.e. 'this'
kono
parents:
diff changeset
1143 by value, and !by_reference_p as capturing '*this' by value.
kono
parents:
diff changeset
1144 (add_default_capture): For implicit 'this' capture, always pass
kono
parents:
diff changeset
1145 by_reference_p true rather than false.
kono
parents:
diff changeset
1146
kono
parents:
diff changeset
1147 PR c++/77722
kono
parents:
diff changeset
1148 * cp-gimplify.c (cp_ubsan_maybe_instrument_return): Instrument also
kono
parents:
diff changeset
1149 functions that have just a STATEMENT_LIST instead of BIND_EXPR, or
kono
parents:
diff changeset
1150 BIND_EXPR with some statement rather than STATEMENT_LIST as body.
kono
parents:
diff changeset
1151
kono
parents:
diff changeset
1152 2016-09-26 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
1153
kono
parents:
diff changeset
1154 * init.c (expand_default_init): Fix } indentation.
kono
parents:
diff changeset
1155 * method.c (process_subob_fn): Simplify control structure to
kono
parents:
diff changeset
1156 remove gotos.
kono
parents:
diff changeset
1157 (implicitly_declare_fn): Remove duplicated lambda ctor check.
kono
parents:
diff changeset
1158
kono
parents:
diff changeset
1159 2016-09-26 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1160
kono
parents:
diff changeset
1161 PR c/7652
kono
parents:
diff changeset
1162 * parser.c (cp_parser_storage_class_specifier_opt): Add
kono
parents:
diff changeset
1163 gcc_fallthrough.
kono
parents:
diff changeset
1164 (cp_parser_skip_to_end_of_template_parameter_list): Likewise.
kono
parents:
diff changeset
1165 (cp_parser_cache_defarg): Likewise.
kono
parents:
diff changeset
1166 (cp_parser_omp_for_cond): Likewise.
kono
parents:
diff changeset
1167 * semantics.c (finish_decltype_type): Likewise.
kono
parents:
diff changeset
1168 * typeck.c (structural_comptypes): Likewise.
kono
parents:
diff changeset
1169 (cp_build_binary_op): Likewise.
kono
parents:
diff changeset
1170 (cp_build_modify_expr): Likewise.
kono
parents:
diff changeset
1171
kono
parents:
diff changeset
1172 2016-09-26 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1173
kono
parents:
diff changeset
1174 PR c/7652
kono
parents:
diff changeset
1175 * constexpr.c (cxx_eval_internal_function): Handle IFN_FALLTHROUGH.
kono
parents:
diff changeset
1176 (potential_constant_expression_1): Likewise.
kono
parents:
diff changeset
1177 * constraint.cc (function_concept_check_p): Check fn for null.
kono
parents:
diff changeset
1178 * parser.c (cp_parser_expression_statement): Handle attribute
kono
parents:
diff changeset
1179 fallthrough.
kono
parents:
diff changeset
1180 (cp_parser_statement): Likewise.
kono
parents:
diff changeset
1181 (cp_parser_label_for_labeled_statement): Set FALLTHROUGH_LABEL_P on
kono
parents:
diff changeset
1182 labels.
kono
parents:
diff changeset
1183 (cp_parser_std_attribute): Handle fallthrough attribute.
kono
parents:
diff changeset
1184 (cp_parser_check_std_attribute): Add %< %> quotes.
kono
parents:
diff changeset
1185 * pt.c (tsubst_copy_and_build): Handle internal functions.
kono
parents:
diff changeset
1186 (instantiation_dependent_scope_ref_p): Return if the expression is
kono
parents:
diff changeset
1187 null.
kono
parents:
diff changeset
1188
kono
parents:
diff changeset
1189 2016-09-24 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1190
kono
parents:
diff changeset
1191 PR c/77490
kono
parents:
diff changeset
1192 * typeck.c (cp_build_unary_op): Warn about bit not on expressions that
kono
parents:
diff changeset
1193 have boolean value.
kono
parents:
diff changeset
1194
kono
parents:
diff changeset
1195 2016-09-23 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1196
kono
parents:
diff changeset
1197 Implement P0138R2, C++17 construction rules for enum class values
kono
parents:
diff changeset
1198 * cp-tree.h (is_direct_enum_init): Declare.
kono
parents:
diff changeset
1199 * decl.c (is_direct_enum_init): New function.
kono
parents:
diff changeset
1200 (reshape_init): Use it.
kono
parents:
diff changeset
1201 * typeck.c (convert_for_assignment): Likewise.
kono
parents:
diff changeset
1202
kono
parents:
diff changeset
1203 * Make-lang.in (check-c++1z): Pass RUNTESTFLAGS down to
kono
parents:
diff changeset
1204 make check-g++.
kono
parents:
diff changeset
1205
kono
parents:
diff changeset
1206 * constexpr.c (call_stack): Remove unnecessary
kono
parents:
diff changeset
1207 = vNULL initialization of file scope vec.
kono
parents:
diff changeset
1208
kono
parents:
diff changeset
1209 * name-lookup.c (store_bindings, store_class_bindings): Don't
kono
parents:
diff changeset
1210 initialize static local bindings_need_stored to vNULL.
kono
parents:
diff changeset
1211
kono
parents:
diff changeset
1212 * typeck2.c (process_init_constructor_record): Use
kono
parents:
diff changeset
1213 CONSTRUCTOR_NELTS (...) instead of
kono
parents:
diff changeset
1214 vec_safe_length (CONSTRUCTOR_ELTS (...)).
kono
parents:
diff changeset
1215 * decl.c (reshape_init_r): Likewise.
kono
parents:
diff changeset
1216 (check_initializer): Likewise.
kono
parents:
diff changeset
1217
kono
parents:
diff changeset
1218 2016-09-22 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1219
kono
parents:
diff changeset
1220 PR c++/71979
kono
parents:
diff changeset
1221 * class.c (build_base_path): Allow for lookup_base returning
kono
parents:
diff changeset
1222 NULL_TREE.
kono
parents:
diff changeset
1223
kono
parents:
diff changeset
1224 2016-09-21 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1225
kono
parents:
diff changeset
1226 Core 903
kono
parents:
diff changeset
1227 * call.c (null_ptr_cst_p): Check char_type_p.
kono
parents:
diff changeset
1228
kono
parents:
diff changeset
1229 2016-09-21 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1230
kono
parents:
diff changeset
1231 PR c++/77651
kono
parents:
diff changeset
1232 * init.c (build_new_1): Don't suggest to use -faligned-new if
kono
parents:
diff changeset
1233 aligned_new_threshold is non-zero.
kono
parents:
diff changeset
1234 (type_has_new_extended_alignment): Change aligned_new_threshhold
kono
parents:
diff changeset
1235 to aligned_new_threshold.
kono
parents:
diff changeset
1236 * call.c (second_parm_is_size_t, aligned_allocation_fn_p,
kono
parents:
diff changeset
1237 aligned_deallocation_fn_p, build_op_delete_call): Likewise.
kono
parents:
diff changeset
1238 * decl.c (cxx_init_decl_processing): Likewise.
kono
parents:
diff changeset
1239
kono
parents:
diff changeset
1240 2016-09-20 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1241
kono
parents:
diff changeset
1242 PR c++/77626
kono
parents:
diff changeset
1243 * constexpr.c (cxx_fold_indirect_ref): Don't call byte_position on
kono
parents:
diff changeset
1244 FIELD_DECLs with error_mark_node type. Remove useless break; after
kono
parents:
diff changeset
1245 return.
kono
parents:
diff changeset
1246
kono
parents:
diff changeset
1247 PR c++/77638
kono
parents:
diff changeset
1248 * parser.c (cp_parser_template_declaration_after_parameter): For 2
kono
parents:
diff changeset
1249 argument operator"" template set ok to false for
kono
parents:
diff changeset
1250 parm == error_mark_node.
kono
parents:
diff changeset
1251
kono
parents:
diff changeset
1252 PR c++/77637
kono
parents:
diff changeset
1253 * parser.c (cp_parser_std_attribute_list): Reject ... without
kono
parents:
diff changeset
1254 preceding attribute.
kono
parents:
diff changeset
1255
kono
parents:
diff changeset
1256 2016-09-19 Bernd Edlinger <bernd.edlinger@hotmail.de>
kono
parents:
diff changeset
1257
kono
parents:
diff changeset
1258 PR c++/77434
kono
parents:
diff changeset
1259 * cvt.c (cp_convert_and_check): Suppress Wint-in-bool-context here.
kono
parents:
diff changeset
1260
kono
parents:
diff changeset
1261 2016-09-16 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
1262
kono
parents:
diff changeset
1263 PR c++/77639
kono
parents:
diff changeset
1264 * parser.c (cp_parser_class_head): When
kono
parents:
diff changeset
1265 processing_template_parmlist, don't assume that the
kono
parents:
diff changeset
1266 class-head may start an explicit specialization.
kono
parents:
diff changeset
1267
kono
parents:
diff changeset
1268 2016-09-16 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1269
kono
parents:
diff changeset
1270 PR c++/77482
kono
parents:
diff changeset
1271 * error.c (dump_simple_decl): Only check DECL_DECLARED_CONCEPT_P
kono
parents:
diff changeset
1272 if DECL_LANG_SPECIFIC is non-NULL. Fix up formatting.
kono
parents:
diff changeset
1273
kono
parents:
diff changeset
1274 PR c++/77338
kono
parents:
diff changeset
1275 * constexpr.c (cxx_eval_constant_expression) <case PARM_DECL>: Only
kono
parents:
diff changeset
1276 call is_really_empty_class on complete types.
kono
parents:
diff changeset
1277
kono
parents:
diff changeset
1278 PR c++/77375
kono
parents:
diff changeset
1279 * class.c (check_bases): Set CLASSTYPE_HAS_MUTABLE if any
kono
parents:
diff changeset
1280 TYPE_HAS_MUTABLE_P for any bases.
kono
parents:
diff changeset
1281
kono
parents:
diff changeset
1282 2016-09-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1283
kono
parents:
diff changeset
1284 * class.c (check_bases, set_one_vmethod_tm_attributes): Use
kono
parents:
diff changeset
1285 least_bit_hwi.
kono
parents:
diff changeset
1286 * decl.c (cxx_init_decl_processing): Use pow2p_hwi.
kono
parents:
diff changeset
1287 * parser.c (cp_parser_cilk_simd_vectorlength): Use pow2p_hwi.
kono
parents:
diff changeset
1288
kono
parents:
diff changeset
1289 2016-09-14 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1290
kono
parents:
diff changeset
1291 PR c++/77549
kono
parents:
diff changeset
1292 * name-lookup.c (consider_binding_level): Look through TREE_LIST
kono
parents:
diff changeset
1293 and OVERLOAD.
kono
parents:
diff changeset
1294
kono
parents:
diff changeset
1295 2016-09-14 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1296
kono
parents:
diff changeset
1297 * typeck.c (cp_build_unary_op): Diagnose incrementing boolean
kono
parents:
diff changeset
1298 expressions. Tweak an error message.
kono
parents:
diff changeset
1299
kono
parents:
diff changeset
1300 2016-09-14 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1301
kono
parents:
diff changeset
1302 * cp-tree.h (cp_build_unary_op): Change nonconvert parameter type to
kono
parents:
diff changeset
1303 bool.
kono
parents:
diff changeset
1304 * decl2.c (one_static_initialization_or_destruction): Use true instead
kono
parents:
diff changeset
1305 of 1.
kono
parents:
diff changeset
1306 * init.c (build_vec_init): Use false instead of 0.
kono
parents:
diff changeset
1307 * pt.c (tsubst_copy_and_build): Likewise.
kono
parents:
diff changeset
1308 * semantics.c (simplify_loop_decl_cond): Likewise.
kono
parents:
diff changeset
1309 * typeck.c (rationalize_conditional_expr): Likewise.
kono
parents:
diff changeset
1310 (cp_build_binary_op): Use true instead of 1.
kono
parents:
diff changeset
1311 (cp_build_unary_op): Change nonconvert parameter type to bool. Use true
kono
parents:
diff changeset
1312 instead of 1.
kono
parents:
diff changeset
1313 (build_unary_op): Change nonconvert parameter type to bool.
kono
parents:
diff changeset
1314 (unary_complex_lvalue): Use false instead of 0.
kono
parents:
diff changeset
1315
kono
parents:
diff changeset
1316 2016-09-13 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1317
kono
parents:
diff changeset
1318 Implement P0028R4, C++17 using attribute namespaces without repetition
kono
parents:
diff changeset
1319 * parser.c (cp_parser_std_attribute): Add ATTR_NS argument. Diagnose
kono
parents:
diff changeset
1320 non-NULL ATTR_NS with scoped attribute token. Handle non-NULL
kono
parents:
diff changeset
1321 ATTR_NS with non-scoped attribute tokens. Allow named ops in
kono
parents:
diff changeset
1322 identifier after ::.
kono
parents:
diff changeset
1323 (cp_parser_std_attribute_list): Add ATTR_NS argument, pass it down
kono
parents:
diff changeset
1324 to cp_parser_std_attribute calls.
kono
parents:
diff changeset
1325 (cp_parser_std_attribute_spec): Parse optional C++17
kono
parents:
diff changeset
1326 attribute-using-prefix, adjust grammar in function comment.
kono
parents:
diff changeset
1327
kono
parents:
diff changeset
1328 PR c++/77553
kono
parents:
diff changeset
1329 * constexpr.c (cxx_fold_pointer_plus_expression): New function.
kono
parents:
diff changeset
1330 (cxx_eval_binary_expression): Use it for POINTER_PLUS_EXPR.
kono
parents:
diff changeset
1331 (cxx_eval_pointer_plus_expression): Remove.
kono
parents:
diff changeset
1332 (cxx_eval_constant_expression) <case POINTER_PLUS_EXPR>: Don't
kono
parents:
diff changeset
1333 call cxx_eval_pointer_plus_expression.
kono
parents:
diff changeset
1334
kono
parents:
diff changeset
1335 2016-09-13 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
1336
kono
parents:
diff changeset
1337 * parser.c (cp_parser_class_specifier_1): Update for renaming of
kono
parents:
diff changeset
1338 add_fixit_insert to add_fixit_insert_before.
kono
parents:
diff changeset
1339 (cp_parser_class_head): Likewise.
kono
parents:
diff changeset
1340
kono
parents:
diff changeset
1341 2016-09-12 Bernd Edlinger <bernd.edlinger@hotmail.de>
kono
parents:
diff changeset
1342
kono
parents:
diff changeset
1343 PR c++/77496
kono
parents:
diff changeset
1344 * call.c (build_conditional_expr_1): Call warn_for_omitted_condop.
kono
parents:
diff changeset
1345 * class.c (instantiate_type): Look through the SAVE_EXPR.
kono
parents:
diff changeset
1346
kono
parents:
diff changeset
1347 2016-09-09 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1348
kono
parents:
diff changeset
1349 Implement P0035R4, C++17 new of over-aligned types.
kono
parents:
diff changeset
1350 * cp-tree.h (enum cp_tree_index): Add CPTI_ALIGN_TYPE.
kono
parents:
diff changeset
1351 (align_type_node): New macro.
kono
parents:
diff changeset
1352 * call.c (build_operator_new_call): Handle C++17 aligned new.
kono
parents:
diff changeset
1353 (second_parm_is_size_t, build_op_delete_call): Likewise.
kono
parents:
diff changeset
1354 (non_placement_deallocation_fn_p): Likewise. Rename to
kono
parents:
diff changeset
1355 usual_deallocation_fn_p.
kono
parents:
diff changeset
1356 (aligned_allocation_fn_p, aligned_deallocation_fn_p): New.
kono
parents:
diff changeset
1357 * decl.c (cxx_init_decl_processing): Add aligned new support.
kono
parents:
diff changeset
1358 * init.c (type_has_new_extended_alignment): New.
kono
parents:
diff changeset
1359 (build_new_1): Handle aligned new.
kono
parents:
diff changeset
1360 * tree.c (vec_copy_and_insert): New.
kono
parents:
diff changeset
1361
kono
parents:
diff changeset
1362 2016-09-02 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1363
kono
parents:
diff changeset
1364 PR sanitizer/77396
kono
parents:
diff changeset
1365 * decl2.c (do_static_initialization_or_destruction): Only
kono
parents:
diff changeset
1366 call asan_dynamic_init_call if INITP is true.
kono
parents:
diff changeset
1367
kono
parents:
diff changeset
1368 2016-09-01 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
1369
kono
parents:
diff changeset
1370 * mangle.c: Increase buffer size to guarantee it fits the output
kono
parents:
diff changeset
1371 of the formatted function regardless of its arguments.
kono
parents:
diff changeset
1372
kono
parents:
diff changeset
1373 2016-09-01 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1374
kono
parents:
diff changeset
1375 PR c/7652
kono
parents:
diff changeset
1376 * error.c (dump_type): Fix falls through comment.
kono
parents:
diff changeset
1377 (dump_decl): Likewise.
kono
parents:
diff changeset
1378 (dump_expr): Likewise.
kono
parents:
diff changeset
1379
kono
parents:
diff changeset
1380 2016-08-30 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
1381
kono
parents:
diff changeset
1382 * parser.c (cp_parser_enclosed_template_argument_list): Add fix-it
kono
parents:
diff changeset
1383 hint to ">>" within nested template argument list error.
kono
parents:
diff changeset
1384
kono
parents:
diff changeset
1385 2016-08-30 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
1386
kono
parents:
diff changeset
1387 * name-lookup.c (suggest_alternatives_for): Use add_fixit_replace
kono
parents:
diff changeset
1388 rather than add_fixit_misspelled_id.
kono
parents:
diff changeset
1389 * parser.c (cp_parser_diagnose_invalid_type_name): Likewise.
kono
parents:
diff changeset
1390
kono
parents:
diff changeset
1391 2016-08-29 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1392
kono
parents:
diff changeset
1393 PR c++/77379
kono
parents:
diff changeset
1394 * mangle.c (maybe_check_abi_tags): Add version parm, handle thunks.
kono
parents:
diff changeset
1395 (mangle_thunk): Add thunk parameter.
kono
parents:
diff changeset
1396 * method.c (finish_thunk): Pass it.
kono
parents:
diff changeset
1397 * cp-tree.h: Declare it.
kono
parents:
diff changeset
1398
kono
parents:
diff changeset
1399 2016-08-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1400
kono
parents:
diff changeset
1401 Avoid calling a trivial default constructor.
kono
parents:
diff changeset
1402 * class.c (default_ctor_p): New.
kono
parents:
diff changeset
1403 (in_class_defaulted_default_constructor): Use it.
kono
parents:
diff changeset
1404 (type_has_non_user_provided_default_constructor): Use it.
kono
parents:
diff changeset
1405 * call.c (build_over_call): Handle trivial default constructor.
kono
parents:
diff changeset
1406 * cp-tree.h: Declare default_ctor_p.
kono
parents:
diff changeset
1407
kono
parents:
diff changeset
1408 PR c++/57728
kono
parents:
diff changeset
1409 * pt.c (do_type_instantiation): Don't mess with non-user-provided
kono
parents:
diff changeset
1410 member functions.
kono
parents:
diff changeset
1411
kono
parents:
diff changeset
1412 2016-08-25 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1413
kono
parents:
diff changeset
1414 * parser.c (cp_parser_binary_expression): Pass LHS to
kono
parents:
diff changeset
1415 warn_logical_not_parentheses.
kono
parents:
diff changeset
1416
kono
parents:
diff changeset
1417 2016-08-18 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1418
kono
parents:
diff changeset
1419 PR c/7652
kono
parents:
diff changeset
1420 * call.c (add_builtin_candidate): Add gcc_fallthrough.
kono
parents:
diff changeset
1421 * cxx-pretty-print.c (pp_cxx_unqualified_id): Likewise.
kono
parents:
diff changeset
1422 * parser.c (cp_parser_skip_to_end_of_statement): Likewise.
kono
parents:
diff changeset
1423 (cp_parser_cache_defarg): Likewise.
kono
parents:
diff changeset
1424
kono
parents:
diff changeset
1425 2016-08-12 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1426
kono
parents:
diff changeset
1427 PR c/7652
kono
parents:
diff changeset
1428 * call.c (add_builtin_candidate): Add FALLTHRU.
kono
parents:
diff changeset
1429 (build_integral_nontype_arg_conv): Adjust fall through comment.
kono
parents:
diff changeset
1430 (build_new_op_1): Add FALLTHRU.
kono
parents:
diff changeset
1431 (convert_like_real): Adjust fall through comment.
kono
parents:
diff changeset
1432 * class.c (fixed_type_or_null): Likewise.
kono
parents:
diff changeset
1433 * constexpr.c (cxx_eval_constant_expression): Likewise.
kono
parents:
diff changeset
1434 (potential_constant_expression_1): Likewise. Add FALLTHRU.
kono
parents:
diff changeset
1435 * cp-gimplify.c (cp_gimplify_expr): Adjust fall through comment.
kono
parents:
diff changeset
1436 (cp_fold): Add FALLTHRU.
kono
parents:
diff changeset
1437 * cvt.c (build_expr_type_conversion): Adjust fall through comment.
kono
parents:
diff changeset
1438 * cxx-pretty-print.c (pp_cxx_unqualified_id): Add FALLTHRU.
kono
parents:
diff changeset
1439 (pp_cxx_qualified_id): Likewise.
kono
parents:
diff changeset
1440 (cxx_pretty_printer::constant): Adjust fall through comment.
kono
parents:
diff changeset
1441 (cxx_pretty_printer::primary_expression): Add FALLTHRU.
kono
parents:
diff changeset
1442 (pp_cxx_pm_expression): Adjust fall through comment.
kono
parents:
diff changeset
1443 (cxx_pretty_printer::expression): Add FALLTHRU.
kono
parents:
diff changeset
1444 (cxx_pretty_printer::declaration_specifiers): Reformat code.
kono
parents:
diff changeset
1445 (pp_cxx_type_specifier_seq): Adjust fall through comment.
kono
parents:
diff changeset
1446 (pp_cxx_ptr_operator): Likewise. Add FALLTHRU.
kono
parents:
diff changeset
1447 * error.c (dump_type): Adjust fall through comment.
kono
parents:
diff changeset
1448 (dump_decl): Likewise.
kono
parents:
diff changeset
1449 * mangle.c (write_type): Likewise.
kono
parents:
diff changeset
1450 * method.c (synthesized_method_walk): Add FALLTHRU.
kono
parents:
diff changeset
1451 * name-lookup.c (arg_assoc_type): Likewise.
kono
parents:
diff changeset
1452 * parser.c (cp_lexer_print_token): Adjust fall through comment.
kono
parents:
diff changeset
1453 (cp_parser_primary_expression): Add FALLTHRU.
kono
parents:
diff changeset
1454 (cp_parser_operator): Likewise.
kono
parents:
diff changeset
1455 * pt.c (find_parameter_packs_r): Likewise.
kono
parents:
diff changeset
1456 (tsubst_aggr_type): Adjust fall through comment.
kono
parents:
diff changeset
1457 * semantics.c (finish_omp_clauses): Add FALLTHRU.
kono
parents:
diff changeset
1458 * tree.c (lvalue_kind): Likewise.
kono
parents:
diff changeset
1459
kono
parents:
diff changeset
1460 2016-08-12 Alexandre Oliva <aoliva@redhat.com>
kono
parents:
diff changeset
1461
kono
parents:
diff changeset
1462 PR debug/63240
kono
parents:
diff changeset
1463 * cp-objcp-common.c (cp_function_decl_defaulted): New.
kono
parents:
diff changeset
1464 (cp_function_decl_explicit_p): Const_tree-ify.
kono
parents:
diff changeset
1465 (cp_function_decl_deleted_p): Likewise.
kono
parents:
diff changeset
1466 * cp-objcp-common.h (cp_function_decl_defaulted): Declare.
kono
parents:
diff changeset
1467 (cp_function_decl_explicit_p): Const_tree-ify.
kono
parents:
diff changeset
1468 (cp_function_decl_deleted_p): Likewise.
kono
parents:
diff changeset
1469 (LANG_HOOKS_FUNCTION_DECL_DEFAULTED): Redefine.
kono
parents:
diff changeset
1470
kono
parents:
diff changeset
1471 2016-08-11 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1472
kono
parents:
diff changeset
1473 PR c++/72868
kono
parents:
diff changeset
1474 * constexpr.c (label_matches): Handle case range expressions.
kono
parents:
diff changeset
1475
kono
parents:
diff changeset
1476 2016-08-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1477
kono
parents:
diff changeset
1478 PR c++/73456
kono
parents:
diff changeset
1479 * logic.cc (non_atomic_constraint_p): Handle EXPR_PACK_EXPANSION.
kono
parents:
diff changeset
1480
kono
parents:
diff changeset
1481 2016-08-10 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1482
kono
parents:
diff changeset
1483 Implement C++17 constexpr if.
kono
parents:
diff changeset
1484 * cp-tree.h (IF_STMT_CONSTEXPR_P): New.
kono
parents:
diff changeset
1485 * name-lookup.c (push_to_top_level, pop_from_top_level_1): Handle it.
kono
parents:
diff changeset
1486 * parser.h (struct cp_parser): Add in_discarded_stmt field.
kono
parents:
diff changeset
1487 * parser.c (cp_parser_selection_statement): Handle 'if constexpr'.
kono
parents:
diff changeset
1488 (cp_parser_jump_statement): Avoid deducing from a discarded return.
kono
parents:
diff changeset
1489 * pt.c (tsubst_expr): Only instantiate taken branch of constexpr if.
kono
parents:
diff changeset
1490 * semantics.c (begin_if_stmt): Set the binding level this_entity.
kono
parents:
diff changeset
1491 (finish_if_stmt_cond): Require the condition of a
kono
parents:
diff changeset
1492 constexpr if to be constant.
kono
parents:
diff changeset
1493 * decl.c (level_for_constexpr_if): New.
kono
parents:
diff changeset
1494 (named_label_entry): Add in_constexpr_if field.
kono
parents:
diff changeset
1495 (poplevel_named_label_1): Set it.
kono
parents:
diff changeset
1496 (check_goto): Check it.
kono
parents:
diff changeset
1497 (check_previous_goto_1): Check level_for_constexpr_if.
kono
parents:
diff changeset
1498
kono
parents:
diff changeset
1499 2016-08-09 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1500
kono
parents:
diff changeset
1501 PR c++/68703
kono
parents:
diff changeset
1502 * decl2.c (any_dependent_type_attributes_p): New.
kono
parents:
diff changeset
1503 * pt.c (dependent_type_p_r, type_dependent_expression_p): Check it.
kono
parents:
diff changeset
1504 * semantics.c (finish_id_expression): Check it.
kono
parents:
diff changeset
1505 * typeck.c (finish_class_member_access_expr): Check it.
kono
parents:
diff changeset
1506
kono
parents:
diff changeset
1507 PR c++/71712
kono
parents:
diff changeset
1508 * class.c (check_abi_tags): Don't duplicate tags for conversion ops.
kono
parents:
diff changeset
1509
kono
parents:
diff changeset
1510 Adjust mangling of ABI tags on class template member functions.
kono
parents:
diff changeset
1511 * class.c (missing_abi_tags): New.
kono
parents:
diff changeset
1512 (check_abi_tags): Don't check template. Add just_checking mode.
kono
parents:
diff changeset
1513 * mangle.c (abi_flag_at_least, any_abi_below, equal_abi_tags): New.
kono
parents:
diff changeset
1514 (sorted_abi_tags): Split out from write_abi_tags.
kono
parents:
diff changeset
1515 (struct releasing_vec): New.
kono
parents:
diff changeset
1516 (write_unqualified_name): Only look for the primary
kono
parents:
diff changeset
1517 template for types. Implement backward compatibility.
kono
parents:
diff changeset
1518
kono
parents:
diff changeset
1519 PR c++/72849
kono
parents:
diff changeset
1520 * constexpr.c (cxx_eval_constant_expression): Check
kono
parents:
diff changeset
1521 COMPLETE_TYPE_P before calling is_really_empty_class.
kono
parents:
diff changeset
1522 * class.c (is_really_empty_class): Don't call complete_type.
kono
parents:
diff changeset
1523
kono
parents:
diff changeset
1524 PR c++/56701
kono
parents:
diff changeset
1525 * typeck.c (cp_build_addr_expr_1): Remove special *this handling.
kono
parents:
diff changeset
1526
kono
parents:
diff changeset
1527 2016-08-09 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1528
kono
parents:
diff changeset
1529 PR c++/72809
kono
parents:
diff changeset
1530 * rtti.c (get_pseudo_ti_index): Return TK_CLASS_TYPE for
kono
parents:
diff changeset
1531 builtin aggregate types without TYPE_BINFO.
kono
parents:
diff changeset
1532
kono
parents:
diff changeset
1533 2016-08-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1534
kono
parents:
diff changeset
1535 Implement C++17 constexpr lambda.
kono
parents:
diff changeset
1536 * class.c (finalize_literal_type_property): Handle lambdas.
kono
parents:
diff changeset
1537 * constexpr.c (is_valid_constexpr_fn): Likewise. No longer static.
kono
parents:
diff changeset
1538 (explain_invalid_constexpr_fn, cxx_eval_call_expression): Handle
kono
parents:
diff changeset
1539 lambdas.
kono
parents:
diff changeset
1540 (cxx_eval_constant_expression): Handle capture proxy.
kono
parents:
diff changeset
1541 (var_in_constexpr_fn): Don't check for C++14.
kono
parents:
diff changeset
1542 (var_in_maybe_constexpr_fn): New.
kono
parents:
diff changeset
1543 (potential_constant_expression_1): Use it. Check DECL_EXPR for
kono
parents:
diff changeset
1544 declarations not allowed in constexpr function. Handle
kono
parents:
diff changeset
1545 STATIC_ASSERT, RANGE_FOR_STMT.
kono
parents:
diff changeset
1546 * decl.c (make_rtl_for_nonlocal_decl): Use var_in_maybe_constexpr_fn.
kono
parents:
diff changeset
1547 (finish_function): Set DECL_DECLARED_CONSTEXPR_P on lambda members.
kono
parents:
diff changeset
1548 * lambda.c (begin_lambda_type): Set CLASSTYPE_LITERAL_P.
kono
parents:
diff changeset
1549 (maybe_add_lambda_conv_op): Clear thunk CALL_EXPR location.
kono
parents:
diff changeset
1550 (lambda_static_thunk_p): New.
kono
parents:
diff changeset
1551 * parser.c (cp_keyword_starts_decl_specifier_p): Add RID_CONSTEXPR.
kono
parents:
diff changeset
1552 (CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR): New enumerator.
kono
parents:
diff changeset
1553 (cp_parser_decl_specifier_seq): Handle it.
kono
parents:
diff changeset
1554 (cp_parser_lambda_declarator_opt): Use cp_parser_decl_specifier_seq.
kono
parents:
diff changeset
1555 * pt.c (instantiate_class_template_1): Set CLASSTYPE_LITERAL_P.
kono
parents:
diff changeset
1556 (tsubst_copy_and_build) [CALL_EXPR]: Propagate CALL_FROM_THUNK_P.
kono
parents:
diff changeset
1557 * error.c (dump_function_decl): Check TFF_NO_TEMPLATE_BINDINGS.
kono
parents:
diff changeset
1558 (dump_expr) [FUNCTION_DECL]: Pass it.
kono
parents:
diff changeset
1559
kono
parents:
diff changeset
1560 2016-08-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1561
kono
parents:
diff changeset
1562 PR c++/67131
kono
parents:
diff changeset
1563 * class.c (is_really_empty_class): Call complete_type.
kono
parents:
diff changeset
1564 * constexpr.c (cxx_eval_constant_expression): Check
kono
parents:
diff changeset
1565 is_really_empty_class.
kono
parents:
diff changeset
1566 (potential_constant_expression_1): Likewise. Check for error type.
kono
parents:
diff changeset
1567
kono
parents:
diff changeset
1568 2016-08-08 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1569
kono
parents:
diff changeset
1570 PR c++/58706
kono
parents:
diff changeset
1571 * parser.c: Include tree-iterator.h.
kono
parents:
diff changeset
1572 (cp_parser_omp_for_loop_init): Move lambda DECL_EXPRs from init
kono
parents:
diff changeset
1573 to FOR_BLOCK.
kono
parents:
diff changeset
1574 (cp_parser_omp_for_loop): Handle non-STATEMENT_LIST FOR_BLOCK
kono
parents:
diff changeset
1575 entries.
kono
parents:
diff changeset
1576
kono
parents:
diff changeset
1577 2016-08-06 Jonathan Wakely <jwakely@redhat.com>
kono
parents:
diff changeset
1578
kono
parents:
diff changeset
1579 * call.c (convert_like_real): Harmonize diagnostics for invalid
kono
parents:
diff changeset
1580 reference binding.
kono
parents:
diff changeset
1581
kono
parents:
diff changeset
1582 2016-08-05 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
1583
kono
parents:
diff changeset
1584 * constexpr.c (cxx_eval_store_expression): Remove hyphen from
kono
parents:
diff changeset
1585 the spelling of "constant-expression" in diagnostic messages
kono
parents:
diff changeset
1586 for consistency.
kono
parents:
diff changeset
1587 (cxx_eval_constant_expression): Same.
kono
parents:
diff changeset
1588 (cxx_eval_outermost_constant_expr): Same.
kono
parents:
diff changeset
1589 (potential_constant_expression_1): Same.
kono
parents:
diff changeset
1590
kono
parents:
diff changeset
1591 2016-08-05 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
1592
kono
parents:
diff changeset
1593 PR c++/68724
kono
parents:
diff changeset
1594 * pt.c (unify): TRAIT_EXPR is an expr.
kono
parents:
diff changeset
1595
kono
parents:
diff changeset
1596 2016-08-04 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1597
kono
parents:
diff changeset
1598 PR c++/72800
kono
parents:
diff changeset
1599 * lambda.c (add_capture): Check lambda_capture_field_type return
kono
parents:
diff changeset
1600 value for error_mark_node.
kono
parents:
diff changeset
1601
kono
parents:
diff changeset
1602 2016-08-04 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
1603
kono
parents:
diff changeset
1604 PR c++/72759
kono
parents:
diff changeset
1605 * pt.c (tsubst_qualified_id): Return error_mark_node if
kono
parents:
diff changeset
1606 template_args is error_mark_node.
kono
parents:
diff changeset
1607
kono
parents:
diff changeset
1608 2016-08-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1609
kono
parents:
diff changeset
1610 PR c++/72415
kono
parents:
diff changeset
1611 * pt.c (tsubst_pack_expansion): Pull a single pack expansion out
kono
parents:
diff changeset
1612 of the TREE_VEC.
kono
parents:
diff changeset
1613
kono
parents:
diff changeset
1614 * cp-tree.h (TYPE_UNNAMED_P): Rename from TYPE_ANONYMOUS_P.
kono
parents:
diff changeset
1615 (TYPE_WAS_UNNAMED): Rename from TYPE_WAS_ANONYMOUS.
kono
parents:
diff changeset
1616 * class.c, decl.c, decl2.c, error.c, lambda.c, mangle.c,
kono
parents:
diff changeset
1617 name-lookup.c, parser.c, pt.c, semantics.c, tree.c: Adjust.
kono
parents:
diff changeset
1618
kono
parents:
diff changeset
1619 PR c++/72796
kono
parents:
diff changeset
1620 * typeck.c (finish_class_member_access_expr): Avoid stripping
kono
parents:
diff changeset
1621 SCOPE_REF to dependent base.
kono
parents:
diff changeset
1622
kono
parents:
diff changeset
1623 2016-08-04 Thomas Schwinge <thomas@codesourcery.com>
kono
parents:
diff changeset
1624
kono
parents:
diff changeset
1625 * parser.c (cp_ensure_no_oacc_routine): Improve diagnostics.
kono
parents:
diff changeset
1626 (cp_parser_late_parsing_cilk_simd_fn_info): Fix diagnostics.
kono
parents:
diff changeset
1627 (cp_parser_late_parsing_oacc_routine, cp_finalize_oacc_routine):
kono
parents:
diff changeset
1628 Simplify code, and improve diagnostics.
kono
parents:
diff changeset
1629 (cp_parser_oacc_routine): Likewise. Move pragma context
kono
parents:
diff changeset
1630 checking...
kono
parents:
diff changeset
1631 (cp_parser_pragma): ... here.
kono
parents:
diff changeset
1632
kono
parents:
diff changeset
1633 * parser.h (struct cp_omp_declare_simd_data): New.
kono
parents:
diff changeset
1634 (struct cp_parser): Use it for oacc_routine member.
kono
parents:
diff changeset
1635 * parser.c (cp_ensure_no_oacc_routine, cp_parser_oacc_routine)
kono
parents:
diff changeset
1636 (cp_parser_late_parsing_oacc_routine, cp_finalize_oacc_routine):
kono
parents:
diff changeset
1637 Use it. Simplify code.
kono
parents:
diff changeset
1638 (cp_parser_new): Initialize all members pointing to special
kono
parents:
diff changeset
1639 parsing data structures.
kono
parents:
diff changeset
1640 (cp_parser_cilk_simd_fn_vector_attrs): Initialize
kono
parents:
diff changeset
1641 parser->cilk_simd_fn_info->clauses.
kono
parents:
diff changeset
1642 (cp_parser_omp_declare_simd): Initialize
kono
parents:
diff changeset
1643 parser->omp_declare_simd->clauses.
kono
parents:
diff changeset
1644 (cp_parser_late_parsing_omp_declare_simd): Simplify code.
kono
parents:
diff changeset
1645
kono
parents:
diff changeset
1646 2016-08-04 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1647
kono
parents:
diff changeset
1648 PR c++/70229
kono
parents:
diff changeset
1649 * constexpr.c (check_constexpr_ctor_body_1): Allow typedef
kono
parents:
diff changeset
1650 declarations.
kono
parents:
diff changeset
1651
kono
parents:
diff changeset
1652 2016-08-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1653
kono
parents:
diff changeset
1654 * mangle.c (mangle_decl): Warn about mangled name change even if
kono
parents:
diff changeset
1655 DECL_REALLY_EXTERN.
kono
parents:
diff changeset
1656
kono
parents:
diff changeset
1657 * mangle.c (get_abi_tags): New.
kono
parents:
diff changeset
1658 (find_substitution, write_unqualified_name, write_abi_tags)
kono
parents:
diff changeset
1659 (maybe_check_abi_tags): Use it.
kono
parents:
diff changeset
1660
kono
parents:
diff changeset
1661 * mangle.c (mangle_decl): Fix mangled name change warning.
kono
parents:
diff changeset
1662
kono
parents:
diff changeset
1663 PR c++/72766
kono
parents:
diff changeset
1664 * constexpr.c (cxx_eval_pointer_plus_expression): Check constancy
kono
parents:
diff changeset
1665 of nelts.
kono
parents:
diff changeset
1666 * cp-gimplify.c (cp_fully_fold): Only maybe_constant_value in
kono
parents:
diff changeset
1667 C++11 and up.
kono
parents:
diff changeset
1668
kono
parents:
diff changeset
1669 2016-07-30 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
1670
kono
parents:
diff changeset
1671 PR c++/60760
kono
parents:
diff changeset
1672 PR c++/71091
kono
parents:
diff changeset
1673 * constexpr.c (cxx_eval_binary_expression): Reject invalid expressions
kono
parents:
diff changeset
1674 involving null pointers.
kono
parents:
diff changeset
1675 (cxx_eval_component_reference): Reject null pointer dereferences.
kono
parents:
diff changeset
1676 (cxx_eval_indirect_ref): Reject indirecting through null pointers.
kono
parents:
diff changeset
1677 (cxx_eval_constant_expression): Reject invalid expressions involving
kono
parents:
diff changeset
1678 null pointers.
kono
parents:
diff changeset
1679
kono
parents:
diff changeset
1680 2016-07-29 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1681
kono
parents:
diff changeset
1682 PR c/71926
kono
parents:
diff changeset
1683 * semantics.c (maybe_convert_cond): Use the location of COND for the
kono
parents:
diff changeset
1684 parentheses warning.
kono
parents:
diff changeset
1685
kono
parents:
diff changeset
1686 2016-07-29 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1687
kono
parents:
diff changeset
1688 * decl.c (build_enumerator): Tweak diagnostic.
kono
parents:
diff changeset
1689
kono
parents:
diff changeset
1690 PR c++/72457
kono
parents:
diff changeset
1691 * init.c (expand_aggr_init_1): Only handle value-init of bases.
kono
parents:
diff changeset
1692 * constexpr.c (build_data_member_initialization): Handle multiple
kono
parents:
diff changeset
1693 initializers for the same field.
kono
parents:
diff changeset
1694
kono
parents:
diff changeset
1695 2016-07-28 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1696
kono
parents:
diff changeset
1697 PR c++/71665
kono
parents:
diff changeset
1698 * decl.c (build_enumerator): Check the type of the enumerator before
kono
parents:
diff changeset
1699 calling cxx_constant_value.
kono
parents:
diff changeset
1700
kono
parents:
diff changeset
1701 2016-07-27 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1702
kono
parents:
diff changeset
1703 PR c++/71747
kono
parents:
diff changeset
1704 * pt.c (get_partial_spec_bindings): Replace tparms and spec_args
kono
parents:
diff changeset
1705 parameters with spec_tmpl. Call push_tinst_level.
kono
parents:
diff changeset
1706 (most_specialized_partial_spec): Adjust.
kono
parents:
diff changeset
1707 (more_specialized_partial_spec): Adjust.
kono
parents:
diff changeset
1708
kono
parents:
diff changeset
1709 2016-07-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1710
kono
parents:
diff changeset
1711 PR c++/65970
kono
parents:
diff changeset
1712 * cp-gimplify.c (genericize_cp_loop): Revert location change.
kono
parents:
diff changeset
1713
kono
parents:
diff changeset
1714 PR c++/71837
kono
parents:
diff changeset
1715 * lambda.c (add_capture): Leave a pack expansion in a TREE_LIST.
kono
parents:
diff changeset
1716 (build_lambda_object): Call build_x_compound_expr_from_list.
kono
parents:
diff changeset
1717 * pt.c (tsubst) [DECLTYPE_TYPE]: Likewise.
kono
parents:
diff changeset
1718
kono
parents:
diff changeset
1719 PR c++/71833
kono
parents:
diff changeset
1720 PR c++/54440
kono
parents:
diff changeset
1721 * pt.c (coerce_template_parameter_pack): Fix logic for
kono
parents:
diff changeset
1722 pack index.
kono
parents:
diff changeset
1723
kono
parents:
diff changeset
1724 PR c++/65970
kono
parents:
diff changeset
1725 * constexpr.c (cxx_eval_loop_expr): Count iterations.
kono
parents:
diff changeset
1726 * cp-gimplify.c (genericize_cp_loop): Use start_locus even for
kono
parents:
diff changeset
1727 infinite loops.
kono
parents:
diff changeset
1728
kono
parents:
diff changeset
1729 PR c++/71972
kono
parents:
diff changeset
1730 * constexpr.c (cxx_eval_array_reference): Handle looking for the
kono
parents:
diff changeset
1731 value of an element we're currently modifying.
kono
parents:
diff changeset
1732
kono
parents:
diff changeset
1733 2016-07-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1734
kono
parents:
diff changeset
1735 PR c++/71515
kono
parents:
diff changeset
1736 * pt.c (resolve_typename_type): Try to avoid calling
kono
parents:
diff changeset
1737 currently_open_class.
kono
parents:
diff changeset
1738
kono
parents:
diff changeset
1739 2016-07-23 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1740
kono
parents:
diff changeset
1741 PR c++/66617
kono
parents:
diff changeset
1742 * call.c (add_list_candidates): Handle VTT parm.
kono
parents:
diff changeset
1743 (build_new_method_call_1): Likewise.
kono
parents:
diff changeset
1744
kono
parents:
diff changeset
1745 PR c++/55922
kono
parents:
diff changeset
1746 PR c++/63151
kono
parents:
diff changeset
1747 * init.c (expand_aggr_init_1): Handle list-initialization from {}.
kono
parents:
diff changeset
1748
kono
parents:
diff changeset
1749 PR c++/70709
kono
parents:
diff changeset
1750 * class.c (walk_subobject_offsets): Handle 0-length array.
kono
parents:
diff changeset
1751
kono
parents:
diff changeset
1752 PR c++/70778
kono
parents:
diff changeset
1753 * pt.c (tsubst): Also substitute into the template of a
kono
parents:
diff changeset
1754 BOUND_TEMPLATE_TEMPLATE_PARM.
kono
parents:
diff changeset
1755
kono
parents:
diff changeset
1756 PR c++/71738
kono
parents:
diff changeset
1757 * pt.c (lookup_template_class_1): Handle getting template from tsubst.
kono
parents:
diff changeset
1758
kono
parents:
diff changeset
1759 PR c++/71350
kono
parents:
diff changeset
1760 * decl.c (reshape_init_r): Check complain for missing braces warning.
kono
parents:
diff changeset
1761
kono
parents:
diff changeset
1762 2016-07-22 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1763
kono
parents:
diff changeset
1764 PR c++/71576
kono
parents:
diff changeset
1765 * call.c (convert_like_real): Use lvalue_kind.
kono
parents:
diff changeset
1766
kono
parents:
diff changeset
1767 PR c++/71748
kono
parents:
diff changeset
1768 PR c++/52746
kono
parents:
diff changeset
1769 * pt.c (tsubst_baselink): Call
kono
parents:
diff changeset
1770 adjust_result_of_qualified_name_lookup for unqualified
kono
parents:
diff changeset
1771 destructors.
kono
parents:
diff changeset
1772
kono
parents:
diff changeset
1773 2016-07-21 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1774
kono
parents:
diff changeset
1775 PR c++/69223
kono
parents:
diff changeset
1776 * semantics.c (apply_deduced_return_type): Call
kono
parents:
diff changeset
1777 complete_type_or_else before building the new RESULT_DECL.
kono
parents:
diff changeset
1778
kono
parents:
diff changeset
1779 PR c++/71274
kono
parents:
diff changeset
1780 * decl2.c (maybe_instantiate_decl): Split out from mark_used.
kono
parents:
diff changeset
1781 (decl_constant_var_p): Use it instead.
kono
parents:
diff changeset
1782
kono
parents:
diff changeset
1783 PR c++/71630
kono
parents:
diff changeset
1784 * pt.c (instantiate_decl): Fix pattern_defined for namespace scope
kono
parents:
diff changeset
1785 variable templates.
kono
parents:
diff changeset
1786
kono
parents:
diff changeset
1787 PR c++/71913
kono
parents:
diff changeset
1788 * call.c (unsafe_copy_elision_p): It's OK to elide when
kono
parents:
diff changeset
1789 initializing an unknown object.
kono
parents:
diff changeset
1790
kono
parents:
diff changeset
1791 * call.c (build_over_call): Check unsafe_copy_elision_p even for
kono
parents:
diff changeset
1792 trivial constructors.
kono
parents:
diff changeset
1793 * method.c (do_build_copy_constructor): Don't copy tail padding
kono
parents:
diff changeset
1794 even in a trivial constructor.
kono
parents:
diff changeset
1795
kono
parents:
diff changeset
1796 2016-07-21 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1797
kono
parents:
diff changeset
1798 PR c++/71728
kono
parents:
diff changeset
1799 * constexpr.c (potential_constant_expression_1) <case GOTO_EXPR>:
kono
parents:
diff changeset
1800 Replace assert with test, return false if the goto isn't break
kono
parents:
diff changeset
1801 or continue. Formatting fix.
kono
parents:
diff changeset
1802
kono
parents:
diff changeset
1803 2016-07-21 Richard Biener <rguenther@suse.de>
kono
parents:
diff changeset
1804
kono
parents:
diff changeset
1805 * vtable-class-hierarchy.c (vtv_generate_init_routine): Set
kono
parents:
diff changeset
1806 DECL_IGNORED_P.
kono
parents:
diff changeset
1807
kono
parents:
diff changeset
1808 2016-07-21 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1809
kono
parents:
diff changeset
1810 PR c++/71941
kono
parents:
diff changeset
1811 * cp-gimplify.c (cp_genericize): For nested cp_genericize calls
kono
parents:
diff changeset
1812 save/restore bc_label array.
kono
parents:
diff changeset
1813
kono
parents:
diff changeset
1814 2016-07-21 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1815
kono
parents:
diff changeset
1816 PR c++/70781
kono
parents:
diff changeset
1817 * parser.c (cp_parser_lambda_expression): Unset OK if there was an
kono
parents:
diff changeset
1818 error parsing the lambda-declarator.
kono
parents:
diff changeset
1819
kono
parents:
diff changeset
1820 PR c++/71896
kono
parents:
diff changeset
1821 * constexpr.c (cxx_eval_binary_expression): Handle comparison
kono
parents:
diff changeset
1822 between lowered and unlowered PTRMEM_CST.
kono
parents:
diff changeset
1823
kono
parents:
diff changeset
1824 PR c++/65168
kono
parents:
diff changeset
1825 * typeck.c (cp_truthvalue_conversion): Compare pointers to nullptr.
kono
parents:
diff changeset
1826 Don't set c_inhibit_evaluation_warnings.
kono
parents:
diff changeset
1827
kono
parents:
diff changeset
1828 PR c++/71121
kono
parents:
diff changeset
1829 * cp-gimplify.c (cp_fully_fold): First call maybe_constant_value.
kono
parents:
diff changeset
1830
kono
parents:
diff changeset
1831 2016-07-21 Andrew Sutton <andrew.n.sutton@gmail.com>
kono
parents:
diff changeset
1832 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1833
kono
parents:
diff changeset
1834 Improving concepts performance and diagnostics.
kono
parents:
diff changeset
1835 PR c++/67565
kono
parents:
diff changeset
1836 PR c++/67579
kono
parents:
diff changeset
1837 PR c++/71843
kono
parents:
diff changeset
1838 * cp-tree.def (CHECK_CONSTR): New.
kono
parents:
diff changeset
1839 * cp-tree.h (CHECK_CONSTR_CONCEPT): New.
kono
parents:
diff changeset
1840 (CHECK_CONSTR_ARGS): New.
kono
parents:
diff changeset
1841 * constraint.cc (make_predicate_constraint): Remove in favor of
kono
parents:
diff changeset
1842 normalize_expression.
kono
parents:
diff changeset
1843 (resolve_constraint_check): Actually return error_mark_node when
kono
parents:
diff changeset
1844 resolution fails.
kono
parents:
diff changeset
1845 (resolve_variable_concept_check): Perform coercion as if processing
kono
parents:
diff changeset
1846 a template. Also return errors on resolution failure.
kono
parents:
diff changeset
1847 (lift_*): Remove all of these functions. Don't unnecessarily inline
kono
parents:
diff changeset
1848 concepts.
kono
parents:
diff changeset
1849 (learn_*): Add facilities to memoize implications for subsumption
kono
parents:
diff changeset
1850 during normalization.
kono
parents:
diff changeset
1851 (expanding_concept): New.
kono
parents:
diff changeset
1852 (expand_concept): New. Return the inlined and normalized definition
kono
parents:
diff changeset
1853 of a concept when needed.
kono
parents:
diff changeset
1854 (transform_*, xform_*): Rename to normalize_* to better reflect the
kono
parents:
diff changeset
1855 responsibility of those functions.
kono
parents:
diff changeset
1856 (normalize_template_id_expression): Check for non-boolean operands
kono
parents:
diff changeset
1857 when possible. Generate check constraints instead of normal variable
kono
parents:
diff changeset
1858 references.
kono
parents:
diff changeset
1859 (normalize_call_expression): Report errors when resolution fails.
kono
parents:
diff changeset
1860 (check_for_logical_overloads): Rewrite this check to more accurately
kono
parents:
diff changeset
1861 report the error.
kono
parents:
diff changeset
1862 (normalize_atom): Check for overloaded calls and invalid types before
kono
parents:
diff changeset
1863 determining if the expression refers to a concept.
kono
parents:
diff changeset
1864 (build_constraints): Don't cache normalized constraints or decomposed
kono
parents:
diff changeset
1865 assumptions.
kono
parents:
diff changeset
1866 (finish_shorthand_constraint): Return a normalized expression instead
kono
parents:
diff changeset
1867 of a predicate constraint.
kono
parents:
diff changeset
1868 (finish_template_introduction): Same.
kono
parents:
diff changeset
1869 (placeholder_extract_concept_and_args): Rewrite this since we only
kono
parents:
diff changeset
1870 ever get check constraints here.
kono
parents:
diff changeset
1871 (equivalent_placeholder_constraints): Rewrite in terms of check
kono
parents:
diff changeset
1872 constraints, and handle error_mark_nodes correctly.
kono
parents:
diff changeset
1873 (tsubst_check_constraint, tsubst_expr_constr, tsubst_type_constr)
kono
parents:
diff changeset
1874 (tsubst_implicit_conversion_constr)
kono
parents:
diff changeset
1875 (tsubst_argument_deduction_constr, tsubst_exception_constr)
kono
parents:
diff changeset
1876 (tsubst_parameterized_constraint, tsubst_constraint): New.
kono
parents:
diff changeset
1877 (tsbust_conjunection): Replace with tsubst_logical_operator and
kono
parents:
diff changeset
1878 actually generate the right kind of constraint.
kono
parents:
diff changeset
1879 (tsubst_requirement_body): Reverse the order of substituted arguments
kono
parents:
diff changeset
1880 so that they appear in the order written (helps diagnostics).
kono
parents:
diff changeset
1881 (satisfy_check_constraint): New.
kono
parents:
diff changeset
1882 (satisfy_conjunction): Simplify.
kono
parents:
diff changeset
1883 (satisfy_disjunction): Same.
kono
parents:
diff changeset
1884 (satisfy_constraint_1): Handle check constraints.
kono
parents:
diff changeset
1885 (eval_constr): New (private) global state.
kono
parents:
diff changeset
1886 (evaluating_constraints_sentinel): New. Manages eval_constr.
kono
parents:
diff changeset
1887 (satisfy_constraint): Add timing variables.
kono
parents:
diff changeset
1888 (satisfy_associated_constraints): Add hooks for memoization.
kono
parents:
diff changeset
1889 (evaluate_function_concept): Build a check constraint instead of
kono
parents:
diff changeset
1890 normalizing its definition.
kono
parents:
diff changeset
1891 (evaluate_variable_concept): Same.
kono
parents:
diff changeset
1892 (evaluate_constraint_expression): Normalize, but in the current
kono
parents:
diff changeset
1893 declaration processing context.
kono
parents:
diff changeset
1894 (evaluating_constraints_p): New.
kono
parents:
diff changeset
1895 (elide_constraint_failure_p): Actually emit constraint_thresh errors.
kono
parents:
diff changeset
1896 (diagnose_*): Remove artificial indentation. Add a new parameter to
kono
parents:
diff changeset
1897 each that tracks the current (complete) constraint prior to any
kono
parents:
diff changeset
1898 substitutions.
kono
parents:
diff changeset
1899 (diagnose_expression): Removed.
kono
parents:
diff changeset
1900 (diagnose_call_expression): Same.
kono
parents:
diff changeset
1901 (diagnose_template_id): Same.
kono
parents:
diff changeset
1902 (diagnose_template_id): New.
kono
parents:
diff changeset
1903 (diagnose_logical_constraint): New.
kono
parents:
diff changeset
1904 (diagnose_expression_constraint): Show the original expression.
kono
parents:
diff changeset
1905 (diagnose_type_constraint): Show the original type.
kono
parents:
diff changeset
1906 (diagnose_implicit_conversion_constraint): Be specific about
kono
parents:
diff changeset
1907 failures, don't re-diagnose a known-to-be-failed substitutions,
kono
parents:
diff changeset
1908 and manage elisions properly.
kono
parents:
diff changeset
1909 (diagnose_argument_deduction_constraint): Same.
kono
parents:
diff changeset
1910 (diagnose_exception_constraint): Same.
kono
parents:
diff changeset
1911 (diagnose_parameterized_constraint): Same.
kono
parents:
diff changeset
1912 (constraint_p): Allow EXPR_PACK_EXPANSION.
kono
parents:
diff changeset
1913 * logic.cc (next_by_distance): Removed. No longer used.
kono
parents:
diff changeset
1914 (any_p): Renamed from any_of.
kono
parents:
diff changeset
1915 (term_entry, term_hasher): New.
kono
parents:
diff changeset
1916 (term_list): Rewrite to include a hash table for quick lookup.
kono
parents:
diff changeset
1917 Also, make less stateful.
kono
parents:
diff changeset
1918 (proof_state): Extend to allow goals to be discharged once
kono
parents:
diff changeset
1919 satisfied.
kono
parents:
diff changeset
1920 (non_atomic_constraint_p): New.
kono
parents:
diff changeset
1921 (any_non_atomic_constraints_p): New.
kono
parents:
diff changeset
1922 (...rest...): Previous implementation completely replaced with an
kono
parents:
diff changeset
1923 iterative algorithm that opportunistically prunes the search space
kono
parents:
diff changeset
1924 before committing to using more memory.
kono
parents:
diff changeset
1925 * parser.c: (cp_parser_type_parameter): Normalize constraints.
kono
parents:
diff changeset
1926 (cp_parser_explicit_template_declaration): Same.
kono
parents:
diff changeset
1927 * pt.c: (finish_template_variable): Be less redundant with this error
kono
parents:
diff changeset
1928 message.
kono
parents:
diff changeset
1929 (template_args_equal): No longer static.
kono
parents:
diff changeset
1930 (tsubst_decl): Don't try to find specializations of variables that
kono
parents:
diff changeset
1931 have already been instantiated.
kono
parents:
diff changeset
1932 (build_non_dependent_expr): Avoid infinite recursion during concept
kono
parents:
diff changeset
1933 expansion.
kono
parents:
diff changeset
1934 (make_constrained_auto): Normalize constraints.
kono
parents:
diff changeset
1935 (do_auto_deduction): When doing auto deduction from a
kono
parents:
diff changeset
1936 partial-concept-id, be sure to include the explicit args checking
kono
parents:
diff changeset
1937 the constraints.
kono
parents:
diff changeset
1938 (constraint_sat_*): New. Memoize satisfied constraints.
kono
parents:
diff changeset
1939 (concept_spec_*): New. Memoize expressions associated with a concept
kono
parents:
diff changeset
1940 specialization.
kono
parents:
diff changeset
1941 (constraint_memos, concept_memos): New.
kono
parents:
diff changeset
1942 (lookup_constraint_satisfaction, memoize_constraint_satisfaction): New.
kono
parents:
diff changeset
1943 (lookup_concept_satisfaction, memoize_concept_satisfaction): New.
kono
parents:
diff changeset
1944 (get_concept_expansion, save_concept_expansion): New.
kono
parents:
diff changeset
1945 (hash_subsumption_args): New.
kono
parents:
diff changeset
1946 (comp_subsumption_args): New.
kono
parents:
diff changeset
1947 (subsumption_*): New. Memoize parts of the subsumption relation.
kono
parents:
diff changeset
1948 (lookup_subsumption_result, save_subsumption_result): New.
kono
parents:
diff changeset
1949 (init_constraint_processing): Initialize memo tables.
kono
parents:
diff changeset
1950 (get_constraints): Shortcut if !flag_concepts.
kono
parents:
diff changeset
1951 * decl.c (grokfndecl): Normalize constraints.
kono
parents:
diff changeset
1952 * error.c (dump_simple_decl): Print "concept" when appropriate.
kono
parents:
diff changeset
1953 (dump_function_decl): Same.
kono
parents:
diff changeset
1954 (dump_template_decl): Don't write requirements when we're not
kono
parents:
diff changeset
1955 printing the header.
kono
parents:
diff changeset
1956 (dump_expr): Handle fold expressions.
kono
parents:
diff changeset
1957 * cxx-pretty-print.c (cxx_pretty_printer::expression): Handle
kono
parents:
diff changeset
1958 fold expressions.
kono
parents:
diff changeset
1959 (get_fold_operator): New.
kono
parents:
diff changeset
1960 (pp_cxx_unary_left_fold_expression): New.
kono
parents:
diff changeset
1961 (pp_cxx_unary_right_fold_expression): New.
kono
parents:
diff changeset
1962 (pp_cxx_binary_fold_expression): New.
kono
parents:
diff changeset
1963 (pp_cxx_check_constraint): New.
kono
parents:
diff changeset
1964 (pp_cxx_*_constraint): Rewrite the grammar of internal constraints
kono
parents:
diff changeset
1965 to make them easier to read when debugging.
kono
parents:
diff changeset
1966 * search.c (accessible_p): Don't shortcut when evaluating constraints.
kono
parents:
diff changeset
1967 * tree.c (cp_tree_equal): Handle CHECK_CONSTR.
kono
parents:
diff changeset
1968
kono
parents:
diff changeset
1969 2016-07-20 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
1970
kono
parents:
diff changeset
1971 PR c/70339
kono
parents:
diff changeset
1972 PR c/71858
kono
parents:
diff changeset
1973 * name-lookup.c: Include gcc-rich-location.h, spellcheck-tree.h,
kono
parents:
diff changeset
1974 and parser.h.
kono
parents:
diff changeset
1975 (suggest_alternatives_for): If no candidates are found, try
kono
parents:
diff changeset
1976 lookup_name_fuzzy and report if if finds a suggestion.
kono
parents:
diff changeset
1977 (consider_binding_level): New function.
kono
parents:
diff changeset
1978 (lookup_name_fuzzy) New function.
kono
parents:
diff changeset
1979 * parser.c: Include gcc-rich-location.h.
kono
parents:
diff changeset
1980 (cp_lexer_next_token_is_decl_specifier_keyword): Move most of
kono
parents:
diff changeset
1981 logic into...
kono
parents:
diff changeset
1982 (cp_keyword_starts_decl_specifier_p): ...this new function.
kono
parents:
diff changeset
1983 (cp_parser_diagnose_invalid_type_name): When issuing
kono
parents:
diff changeset
1984 "does not name a type" errors, attempt to make a suggestion using
kono
parents:
diff changeset
1985 lookup_name_fuzzy.
kono
parents:
diff changeset
1986 * parser.h (cp_keyword_starts_decl_specifier_p): New prototype.
kono
parents:
diff changeset
1987 * search.c (lookup_field_fuzzy_info::fuzzy_lookup_field): Reject
kono
parents:
diff changeset
1988 types that are not CLASS_TYPE_P, rather than rejecting individual
kono
parents:
diff changeset
1989 tree codes.
kono
parents:
diff changeset
1990
kono
parents:
diff changeset
1991 2016-07-20 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1992
kono
parents:
diff changeset
1993 PR c++/71909
kono
parents:
diff changeset
1994 * parser.c (cp_parser_save_member_function_body): Consume
kono
parents:
diff changeset
1995 __transaction_relaxed or __transaction_atomic with optional
kono
parents:
diff changeset
1996 attribute. Only skip catch with block if try keyword is seen.
kono
parents:
diff changeset
1997
kono
parents:
diff changeset
1998 PR c++/50060
kono
parents:
diff changeset
1999 * constexpr.c (cxx_eval_builtin_function_call): Pass false as lval
kono
parents:
diff changeset
2000 when evaluating call arguments. Use fold_builtin_call_array instead
kono
parents:
diff changeset
2001 of fold_build_call_array_loc, return t if it returns NULL. Otherwise
kono
parents:
diff changeset
2002 check the result with potential_constant_expression and call
kono
parents:
diff changeset
2003 cxx_eval_constant_expression on it.
kono
parents:
diff changeset
2004
kono
parents:
diff changeset
2005 2016-07-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2006
kono
parents:
diff changeset
2007 PR c++/67164
kono
parents:
diff changeset
2008 * pt.c (iterative_hash_template_arg, template_args_equal): Don't
kono
parents:
diff changeset
2009 handle ARGUMENT_PACK_SELECT.
kono
parents:
diff changeset
2010
kono
parents:
diff changeset
2011 2016-07-18 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2012
kono
parents:
diff changeset
2013 PR c++/70869
kono
parents:
diff changeset
2014 PR c++/71054
kono
parents:
diff changeset
2015 * cp-gimplify.c (cp_genericize_r): Revert the 2016-07-07 change.
kono
parents:
diff changeset
2016 * tree.c (cp_walk_subtrees): For DECL_EXPR on DECL_ARTIFICIAL
kono
parents:
diff changeset
2017 non-static VAR_DECL, walk the decl's DECL_INITIAL, DECL_SIZE and
kono
parents:
diff changeset
2018 DECL_SIZE_UNIT.
kono
parents:
diff changeset
2019
kono
parents:
diff changeset
2020 PR c++/71835
kono
parents:
diff changeset
2021 * call.c (build_op_call_1): Use convert_like_with_context only
kono
parents:
diff changeset
2022 if cand->fn is a decl.
kono
parents:
diff changeset
2023
kono
parents:
diff changeset
2024 PR c++/71828
kono
parents:
diff changeset
2025 * constexpr.c (cxx_eval_constant_expression) <case REALPART_EXPR>:
kono
parents:
diff changeset
2026 For lval don't use cxx_eval_unary_expression and instead recurse
kono
parents:
diff changeset
2027 and if needed rebuild the reference.
kono
parents:
diff changeset
2028
kono
parents:
diff changeset
2029 PR c++/71826
kono
parents:
diff changeset
2030 * pt.c (tsubst_baselink): Only set BASELINK_OPTYPE for BASELINK_P.
kono
parents:
diff changeset
2031
kono
parents:
diff changeset
2032 PR c++/71822
kono
parents:
diff changeset
2033 * cp-gimplify.c (cp_gimplify_expr) <case VEC_INIT_EXPR>: Recursively
kono
parents:
diff changeset
2034 fold *expr_p before genericizing it.
kono
parents:
diff changeset
2035
kono
parents:
diff changeset
2036 PR c++/71871
kono
parents:
diff changeset
2037 * typeck.c (build_x_conditional_expr): Revert the 2012-10-25 change.
kono
parents:
diff changeset
2038
kono
parents:
diff changeset
2039 2016-07-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2040
kono
parents:
diff changeset
2041 PR c++/71495
kono
parents:
diff changeset
2042 * call.c (convert_like_real): Mask complain.
kono
parents:
diff changeset
2043 * semantics.c (perform_koenig_lookup): Likewise.
kono
parents:
diff changeset
2044
kono
parents:
diff changeset
2045 PR c++/71092
kono
parents:
diff changeset
2046 * constexpr.c (cxx_eval_call_expression): Fail quietly when cgraph
kono
parents:
diff changeset
2047 threw away DECL_SAVED_TREE.
kono
parents:
diff changeset
2048
kono
parents:
diff changeset
2049 PR c++/71117
kono
parents:
diff changeset
2050 Core 2189
kono
parents:
diff changeset
2051 * call.c (add_template_conv_candidate): Disable if there are
kono
parents:
diff changeset
2052 viable candidates.
kono
parents:
diff changeset
2053
kono
parents:
diff changeset
2054 PR c++/71511
kono
parents:
diff changeset
2055 * typeck2.c (cxx_incomplete_type_diagnostic): Handle DECLTYPE_TYPE.
kono
parents:
diff changeset
2056
kono
parents:
diff changeset
2057 PR c++/71513
kono
parents:
diff changeset
2058 * pt.c (tsubst_attributes): Fix loop logic.
kono
parents:
diff changeset
2059
kono
parents:
diff changeset
2060 PR c++/71604
kono
parents:
diff changeset
2061 PR c++/54430
kono
parents:
diff changeset
2062 * parser.c (cp_parser_range_for): Modify IDENTIFIER_BINDING directly.
kono
parents:
diff changeset
2063 (cp_parser_simple_declaration): Diagnose type definition in
kono
parents:
diff changeset
2064 for-range-declaration.
kono
parents:
diff changeset
2065
kono
parents:
diff changeset
2066 PR c++/71711
kono
parents:
diff changeset
2067 * operators.def: Add *_FOLD_EXPR.
kono
parents:
diff changeset
2068 * cp-tree.h (FOLD_EXPR_P): Parenthesize.
kono
parents:
diff changeset
2069 * mangle.c (write_expression): Handle fold-expressions.
kono
parents:
diff changeset
2070 * pt.c (tsubst_unary_left_fold, tsubst_binary_left_fold)
kono
parents:
diff changeset
2071 (tsubst_unary_right_fold, tsubst_binary_right_fold): Handle
kono
parents:
diff changeset
2072 partial instantiation.
kono
parents:
diff changeset
2073
kono
parents:
diff changeset
2074 PR c++/71814
kono
parents:
diff changeset
2075 * mangle.c (write_expression): Handle sizeof... an argument pack.
kono
parents:
diff changeset
2076
kono
parents:
diff changeset
2077 PR c++/71718
kono
parents:
diff changeset
2078 * pt.c (push_tinst_level_loc): Set at_eof before fatal_error.
kono
parents:
diff changeset
2079
kono
parents:
diff changeset
2080 PR c++/70824
kono
parents:
diff changeset
2081 * init.c (constant_value_1): Don't instantiated DECL_INITIAL of
kono
parents:
diff changeset
2082 artificial variables.
kono
parents:
diff changeset
2083
kono
parents:
diff changeset
2084 2016-07-15 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
2085
kono
parents:
diff changeset
2086 * parser.c (cp_parser_oacc_declare): Don't scan for
kono
parents:
diff changeset
2087 GOMP_MAP_POINTER.
kono
parents:
diff changeset
2088 * semantics.c (handle_omp_array_sections): Mark data clauses with
kono
parents:
diff changeset
2089 GOMP_MAP_FORCE_{PRESENT,TO,FROM,TOFROM} as potentially having
kono
parents:
diff changeset
2090 zero-length subarrays.
kono
parents:
diff changeset
2091
kono
parents:
diff changeset
2092 2016-07-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2093
kono
parents:
diff changeset
2094 * decl.c (store_parm_decls): Remove check for void parm.
kono
parents:
diff changeset
2095
kono
parents:
diff changeset
2096 2016-07-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2097
kono
parents:
diff changeset
2098 * cp-tree.h: Unpoison lvalue_p.
kono
parents:
diff changeset
2099 * call.c, class.c, constexpr.c, cvt.c, init.c, lambda.c, pt.c,
kono
parents:
diff changeset
2100 tree.c, typeck.c, typeck2.c: Use lvalue_p instead of
kono
parents:
diff changeset
2101 real_lvalue_p.
kono
parents:
diff changeset
2102
kono
parents:
diff changeset
2103 * tree.c (obvalue_p): Rename from lvalue_p.
kono
parents:
diff changeset
2104 (lvalue_p): Define for c-common.
kono
parents:
diff changeset
2105 * call.c, cp-tree.h, cvt.c, init.c: Adjust.
kono
parents:
diff changeset
2106 * typeck.c: Adjust.
kono
parents:
diff changeset
2107 (cp_build_addr_expr_1): Remove obsolete code.
kono
parents:
diff changeset
2108
kono
parents:
diff changeset
2109 * tree.c (glvalue_p): Rename from lvalue_or_rvalue_with_address_p.
kono
parents:
diff changeset
2110 * call.c, cp-tree.h, typeck.c: Adjust.
kono
parents:
diff changeset
2111
kono
parents:
diff changeset
2112 * lambda.c (maybe_add_lambda_conv_op): Fix null object argument.
kono
parents:
diff changeset
2113
kono
parents:
diff changeset
2114 P0145R2: Refining Expression Order for C++.
kono
parents:
diff changeset
2115 * cp-gimplify.c (lvalue_has_side_effects): New.
kono
parents:
diff changeset
2116 (cp_gimplify_expr): Implement assignment ordering.
kono
parents:
diff changeset
2117 * call.c (op_is_ordered, build_over_call): Adjust for
kono
parents:
diff changeset
2118 -fargs-in-order renaming to -fstrong-eval-order.
kono
parents:
diff changeset
2119 * cp-gimplify.c (cp_gimplify_expr): Likewise.
kono
parents:
diff changeset
2120
kono
parents:
diff changeset
2121 2016-07-07 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2122 Kai Tietz <ktietz70@googlemail.com>
kono
parents:
diff changeset
2123
kono
parents:
diff changeset
2124 PR c++/70869
kono
parents:
diff changeset
2125 PR c++/71054
kono
parents:
diff changeset
2126 * cp-gimplify.c (cp_genericize_r): For DECL_EXPR for non-static
kono
parents:
diff changeset
2127 artificial vars, genericize their initializers.
kono
parents:
diff changeset
2128
kono
parents:
diff changeset
2129 2016-07-05 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
2130
kono
parents:
diff changeset
2131 PR c++/62314
kono
parents:
diff changeset
2132 * parser.c (cp_parser_class_specifier_1): When reporting
kono
parents:
diff changeset
2133 missing semicolons, use a fixit-hint to suggest insertion
kono
parents:
diff changeset
2134 of a semicolon immediately after the closing brace,
kono
parents:
diff changeset
2135 offsetting the reported column accordingly.
kono
parents:
diff changeset
2136
kono
parents:
diff changeset
2137 2016-07-04 Jan Beulich <jbeulich@suse.com>
kono
parents:
diff changeset
2138
kono
parents:
diff changeset
2139 * lang-specs.h ("@c++-header"): Conditionalize "-o".
kono
parents:
diff changeset
2140
kono
parents:
diff changeset
2141 2016-06-29 Thomas Schwinge <thomas@codesourcery.com>
kono
parents:
diff changeset
2142
kono
parents:
diff changeset
2143 * parser.c (cp_parser_pragma) <PRAGMA_OMP_CANCELLATION_POINT>:
kono
parents:
diff changeset
2144 Move pragma context checking into...
kono
parents:
diff changeset
2145 (cp_parser_omp_cancellation_point): ... here, and improve
kono
parents:
diff changeset
2146 diagnostic messages.
kono
parents:
diff changeset
2147 * semantics.c (finish_omp_cancel, finish_omp_cancellation_point):
kono
parents:
diff changeset
2148 Improve diagnostic messages.
kono
parents:
diff changeset
2149
kono
parents:
diff changeset
2150 2016-06-28 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2151
kono
parents:
diff changeset
2152 * Make-lang.in: Don't cat ../stage_current if it does not exist.
kono
parents:
diff changeset
2153
kono
parents:
diff changeset
2154 2016-06-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2155
kono
parents:
diff changeset
2156 P0145R2: Refining Expression Order for C++.
kono
parents:
diff changeset
2157 * typeck.c (cp_build_modify_expr): Leave COMPOUND_EXPR on LHS.
kono
parents:
diff changeset
2158
kono
parents:
diff changeset
2159 * tree.c (get_target_expr_sfinae): Handle bit-fields.
kono
parents:
diff changeset
2160 (build_target_expr): Call mark_rvalue_use.
kono
parents:
diff changeset
2161
kono
parents:
diff changeset
2162 2016-06-24 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2163
kono
parents:
diff changeset
2164 * call.c (magic_varargs_p): Return 3 for __builtin_*_overflow_p.
kono
parents:
diff changeset
2165 (build_over_call): For magic == 3, do no conversion only on 3rd
kono
parents:
diff changeset
2166 argument.
kono
parents:
diff changeset
2167
kono
parents:
diff changeset
2168 2016-06-23 Andi Kleen <ak@linux.intel.com>
kono
parents:
diff changeset
2169
kono
parents:
diff changeset
2170 * Make-lang.in: Add support for autofdo.
kono
parents:
diff changeset
2171
kono
parents:
diff changeset
2172 2016-06-21 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2173
kono
parents:
diff changeset
2174 * constraint.cc (constraints_satisfied_p): Keep as many levels of
kono
parents:
diff changeset
2175 args as our template has levels of parms.
kono
parents:
diff changeset
2176
kono
parents:
diff changeset
2177 * pt.c (template_parm_outer_level, uses_outer_template_parms): New.
kono
parents:
diff changeset
2178 (type_dependent_expression_p): Use uses_outer_template_parms.
kono
parents:
diff changeset
2179
kono
parents:
diff changeset
2180 2016-06-20 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
2181
kono
parents:
diff changeset
2182 * parser.c (cp_parser_string_literal): Convert non-standard
kono
parents:
diff changeset
2183 concatenation error to directly use a rich_location, and
kono
parents:
diff changeset
2184 use that to add the location of the first literal to the
kono
parents:
diff changeset
2185 diagnostic.
kono
parents:
diff changeset
2186
kono
parents:
diff changeset
2187 2016-06-17 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2188
kono
parents:
diff changeset
2189 * decl.c (validate_constexpr_redeclaration): Change pair of errors
kono
parents:
diff changeset
2190 to error + inform.
kono
parents:
diff changeset
2191 * error.c (dump_function_decl): Save the constexpr specifier too.
kono
parents:
diff changeset
2192
kono
parents:
diff changeset
2193 2016-06-17 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2194
kono
parents:
diff changeset
2195 * tree.c (builtin_valid_in_constant_expr_p): Test for
kono
parents:
diff changeset
2196 DECL_BUILT_IN_CLASS equal to BUILT_IN_NORMAL instead of just
kono
parents:
diff changeset
2197 DECL_BUILT_IN.
kono
parents:
diff changeset
2198 (bot_manip): Likewise.
kono
parents:
diff changeset
2199 * call.c (magic_varargs_p): Likewise.
kono
parents:
diff changeset
2200
kono
parents:
diff changeset
2201 2016-06-17 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2202
kono
parents:
diff changeset
2203 * decl.c (grokfndecl): Change pair of errors to error + inform.
kono
parents:
diff changeset
2204
kono
parents:
diff changeset
2205 2016-06-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2206
kono
parents:
diff changeset
2207 PR c++/71209
kono
parents:
diff changeset
2208 * typeck.c (finish_class_member_access_expr): Avoid "not a base"
kono
parents:
diff changeset
2209 warning when there are dependent bases.
kono
parents:
diff changeset
2210
kono
parents:
diff changeset
2211 2016-06-17 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2212
kono
parents:
diff changeset
2213 * semantics.c (handle_omp_array_sections_1): Don't ICE when
kono
parents:
diff changeset
2214 processing_template_decl when checking for bitfields and unions.
kono
parents:
diff changeset
2215 Look through REFERENCE_REF_P as base of COMPONENT_REF.
kono
parents:
diff changeset
2216 (finish_omp_clauses): Look through REFERENCE_REF_P even for
kono
parents:
diff changeset
2217 array sections with COMPONENT_REF bases.
kono
parents:
diff changeset
2218
kono
parents:
diff changeset
2219 2016-06-16 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2220
kono
parents:
diff changeset
2221 * parser.c (cp_parser_omp_var_list_no_open): Call
kono
parents:
diff changeset
2222 convert_from_reference before cp_parser_postfix_dot_deref_expression.
kono
parents:
diff changeset
2223 * semantics.c (finish_omp_clauses): Don't ICE when
kono
parents:
diff changeset
2224 processing_template_decl when checking for bitfields and unions.
kono
parents:
diff changeset
2225 Look through REFERENCE_REF_P as base of COMPONENT_REF.
kono
parents:
diff changeset
2226
kono
parents:
diff changeset
2227 2016-06-15 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2228
kono
parents:
diff changeset
2229 * decl.c (wrapup_globals_for_namespace): Use DECL_SOURCE_LOCATION and
kono
parents:
diff changeset
2230 "%qF" in warning_at instead of "%q+F" in warning.
kono
parents:
diff changeset
2231 (check_redeclaration_exception_specification): Likewise in pedwarn
kono
parents:
diff changeset
2232 (and error, inform, for consistency).
kono
parents:
diff changeset
2233 * call.c (joust): Likewise.
kono
parents:
diff changeset
2234
kono
parents:
diff changeset
2235 2016-06-15 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2236
kono
parents:
diff changeset
2237 PR c++/70202
kono
parents:
diff changeset
2238 * decl.c (xref_basetypes): Revert r117839 changes; add fix-up
kono
parents:
diff changeset
2239 code at the end of the for loop; also revert r159637 changes,
kono
parents:
diff changeset
2240 add back the gcc_assert.
kono
parents:
diff changeset
2241 * cp-tree.h (xref_basetypes): Adjust declaration.
kono
parents:
diff changeset
2242 * parser.c (cp_parser_class_head): Adjust xref_basetypes call.
kono
parents:
diff changeset
2243
kono
parents:
diff changeset
2244 2016-06-14 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
2245
kono
parents:
diff changeset
2246 * search.c: Include spellcheck-tree.h rather than spellcheck.h.
kono
parents:
diff changeset
2247
kono
parents:
diff changeset
2248 2016-06-14 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
2249
kono
parents:
diff changeset
2250 * typeck.c: Include "gcc-rich-location.h".
kono
parents:
diff changeset
2251 (finish_class_member_access_expr): Simplify fixit code by
kono
parents:
diff changeset
2252 using gcc_rich_location::add_fixit_misspelled_id.
kono
parents:
diff changeset
2253
kono
parents:
diff changeset
2254 2016-06-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2255
kono
parents:
diff changeset
2256 P0145R2: Refining Expression Order for C++.
kono
parents:
diff changeset
2257 * cp-tree.h (CALL_EXPR_OPERATOR_SYNTAX, CALL_EXPR_ORDERED_ARGS)
kono
parents:
diff changeset
2258 (CALL_EXPR_REVERSE_ARGS): New.
kono
parents:
diff changeset
2259 * call.c (build_new_op_1): Set them.
kono
parents:
diff changeset
2260 (extract_call_expr, op_is_ordered): New.
kono
parents:
diff changeset
2261 (build_over_call): Set CALL_EXPR_ORDERED_ARGS.
kono
parents:
diff changeset
2262 * cp-gimplify.c (cp_gimplify_expr) [CALL_EXPR]: Handle new flags.
kono
parents:
diff changeset
2263 * pt.c (tsubst_copy_and_build): Copy new flags.
kono
parents:
diff changeset
2264 * semantics.c (simplify_aggr_init_expr): Likewise.
kono
parents:
diff changeset
2265 * tree.c (build_aggr_init_expr): Likewise.
kono
parents:
diff changeset
2266 (build_min_non_dep_op_overload): Likewise.
kono
parents:
diff changeset
2267
kono
parents:
diff changeset
2268 2016-06-14 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2269
kono
parents:
diff changeset
2270 PR c++/71528
kono
parents:
diff changeset
2271 * decl.c (duplicate_decls): For DECL_INITIALIZED_P non-external
kono
parents:
diff changeset
2272 olddecl vars, preserve their TREE_READONLY bit.
kono
parents:
diff changeset
2273
kono
parents:
diff changeset
2274 PR c++/71516
kono
parents:
diff changeset
2275 * decl.c (complete_vars): Handle gracefully type == error_mark_node.
kono
parents:
diff changeset
2276
kono
parents:
diff changeset
2277 2016-06-14 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2278
kono
parents:
diff changeset
2279 * typeck2.c (digest_init_r): Use EXPR_LOC_OR_LOC on init.
kono
parents:
diff changeset
2280
kono
parents:
diff changeset
2281 2016-06-13 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2282
kono
parents:
diff changeset
2283 * decl.c (grokdeclarator): Fix typo in pedwarn text.
kono
parents:
diff changeset
2284
kono
parents:
diff changeset
2285 2016-06-10 Thomas Schwinge <thomas@codesourcery.com>
kono
parents:
diff changeset
2286
kono
parents:
diff changeset
2287 PR c/71381
kono
parents:
diff changeset
2288 * parser.c (cp_parser_omp_var_list_no_open) <OMP_CLAUSE__CACHE_>:
kono
parents:
diff changeset
2289 Loosen checking.
kono
parents:
diff changeset
2290
kono
parents:
diff changeset
2291 2016-06-09 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2292
kono
parents:
diff changeset
2293 PR c++/71465
kono
parents:
diff changeset
2294 Revert:
kono
parents:
diff changeset
2295 2016-06-04 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2296
kono
parents:
diff changeset
2297 PR c++/70202
kono
parents:
diff changeset
2298 * parser.c (cp_parser_class_head): When xref_basetypes fails and
kono
parents:
diff changeset
2299 emits an error do not zero the type.
kono
parents:
diff changeset
2300
kono
parents:
diff changeset
2301 2016-06-08 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2302
kono
parents:
diff changeset
2303 * decl.c (maybe_deduce_size_from_array_init): Use
kono
parents:
diff changeset
2304 DECL_SOURCE_LOCATION in error_at.
kono
parents:
diff changeset
2305 (layout_var_decl): Likewise.
kono
parents:
diff changeset
2306 (check_array_initializer): Likewise.
kono
parents:
diff changeset
2307 (check_initializer): Likewise.
kono
parents:
diff changeset
2308 (duplicate_decls, check_elaborated_type_specifier): Tidy.
kono
parents:
diff changeset
2309
kono
parents:
diff changeset
2310 2016-06-08 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
2311 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2312
kono
parents:
diff changeset
2313 PR c++/70507
kono
parents:
diff changeset
2314 PR c/68120
kono
parents:
diff changeset
2315 * constexpr.c: Include gimple-fold.h.
kono
parents:
diff changeset
2316 (cxx_eval_internal_function): New function.
kono
parents:
diff changeset
2317 (cxx_eval_call_expression): Call it.
kono
parents:
diff changeset
2318 (potential_constant_expression_1): Handle integer arithmetic
kono
parents:
diff changeset
2319 overflow built-ins.
kono
parents:
diff changeset
2320 * tree.c (builtin_valid_in_constant_expr_p): Handle
kono
parents:
diff changeset
2321 BUILT_IN_{ADD,SUB,MUL}_OVERFLOW_P.
kono
parents:
diff changeset
2322
kono
parents:
diff changeset
2323 2016-06-08 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2324
kono
parents:
diff changeset
2325 * pt.c (tsubst, case TYPENAME_TYPE): Don't delay checking the
kono
parents:
diff changeset
2326 return value of tsubst_aggr_type for error_mark_node.
kono
parents:
diff changeset
2327
kono
parents:
diff changeset
2328 2016-06-08 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2329
kono
parents:
diff changeset
2330 PR c++/71442
kono
parents:
diff changeset
2331 * pt.c (tsubst_copy): Only set TREE_USED on DECLs.
kono
parents:
diff changeset
2332
kono
parents:
diff changeset
2333 2016-06-06 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2334 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2335
kono
parents:
diff changeset
2336 PR c++/70847
kono
parents:
diff changeset
2337 PR c++/71330
kono
parents:
diff changeset
2338 PR c++/71393
kono
parents:
diff changeset
2339 * cp-gimplify.c (cp_fold_r): Set *walk_subtrees = 0 and return NULL
kono
parents:
diff changeset
2340 right after cp_fold call if cp_fold has returned the same stmt
kono
parents:
diff changeset
2341 already in some earlier cp_fold_r call.
kono
parents:
diff changeset
2342 (cp_fold_function): Add pset automatic variable, pass its address
kono
parents:
diff changeset
2343 to cp_walk_tree.
kono
parents:
diff changeset
2344
kono
parents:
diff changeset
2345 2016-06-04 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2346
kono
parents:
diff changeset
2347 PR c++/70202
kono
parents:
diff changeset
2348 * parser.c (cp_parser_class_head): When xref_basetypes fails and
kono
parents:
diff changeset
2349 emits an error do not zero the type.
kono
parents:
diff changeset
2350
kono
parents:
diff changeset
2351 2016-06-03 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2352
kono
parents:
diff changeset
2353 PR c++/27100
kono
parents:
diff changeset
2354 * decl.c (duplicate_decls): Properly copy the
kono
parents:
diff changeset
2355 DECL_PENDING_INLINE_P, DECL_PENDING_INLINE_INFO and
kono
parents:
diff changeset
2356 DECL_SAVED_FUNCTION_DATA fields from OLDDECL to NEWDECL.
kono
parents:
diff changeset
2357
kono
parents:
diff changeset
2358 2016-06-03 Chung-Lin Tang <cltang@codesourcery.com>
kono
parents:
diff changeset
2359
kono
parents:
diff changeset
2360 * semantics.c (finish_omp_clauses): Mark OpenACC reduction
kono
parents:
diff changeset
2361 arguments as addressable when async clause exists.
kono
parents:
diff changeset
2362
kono
parents:
diff changeset
2363 2016-06-02 Jan Hubicka <jh@suse.cz>
kono
parents:
diff changeset
2364
kono
parents:
diff changeset
2365 * cp-gimplify.c (genericize_continue_stmt): Force addition of
kono
parents:
diff changeset
2366 predict stmt.
kono
parents:
diff changeset
2367
kono
parents:
diff changeset
2368 2016-06-02 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2369
kono
parents:
diff changeset
2370 * decl.c (xref_tag_1): Change pairs of errors to error + inform.
kono
parents:
diff changeset
2371 (start_enum): Likewise.
kono
parents:
diff changeset
2372 * parser.c (cp_parser_class_head): Likewise.
kono
parents:
diff changeset
2373
kono
parents:
diff changeset
2374 2016-06-02 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2375
kono
parents:
diff changeset
2376 PR c++/71372
kono
parents:
diff changeset
2377 * cp-gimplify.c (cp_fold): For INDIRECT_REF, if the folded expression
kono
parents:
diff changeset
2378 is INDIRECT_REF or MEM_REF, copy over TREE_READONLY, TREE_SIDE_EFFECTS
kono
parents:
diff changeset
2379 and TREE_THIS_VOLATILE flags. For ARRAY_REF and ARRAY_RANGE_REF, copy
kono
parents:
diff changeset
2380 over TREE_READONLY, TREE_SIDE_EFFECTS and TREE_THIS_VOLATILE flags
kono
parents:
diff changeset
2381 to the newly built tree.
kono
parents:
diff changeset
2382
kono
parents:
diff changeset
2383 2016-05-31 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2384
kono
parents:
diff changeset
2385 * pt.c (instantiate_decl): Avoid recalculation.
kono
parents:
diff changeset
2386
kono
parents:
diff changeset
2387 PR c++/60095
kono
parents:
diff changeset
2388 PR c++/69515
kono
parents:
diff changeset
2389 PR c++/69009
kono
parents:
diff changeset
2390 * pt.c (instantiate_template_1): Don't put the partial
kono
parents:
diff changeset
2391 specialization in DECL_TI_TEMPLATE.
kono
parents:
diff changeset
2392 (partial_specialization_p, impartial_args): Remove.
kono
parents:
diff changeset
2393 (regenerate_decl_from_template): Add args parm.
kono
parents:
diff changeset
2394 (instantiate_decl): Look up the partial specialization again.
kono
parents:
diff changeset
2395
kono
parents:
diff changeset
2396 PR c++/71227
kono
parents:
diff changeset
2397 * pt.c (check_explicit_specialization): Give better diagnostic about
kono
parents:
diff changeset
2398 specializing a hidden friend.
kono
parents:
diff changeset
2399
kono
parents:
diff changeset
2400 2016-05-31 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2401
kono
parents:
diff changeset
2402 PR c++/71248
kono
parents:
diff changeset
2403 * decl.c (check_static_variable_definition): Use DECL_SOURCE_LOCATION
kono
parents:
diff changeset
2404 to obtain correct locations; avoid redundant diagnostics on
kono
parents:
diff changeset
2405 out-of-class definitions.
kono
parents:
diff changeset
2406
kono
parents:
diff changeset
2407 2016-05-30 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
2408
kono
parents:
diff changeset
2409 PR c++/71306
kono
parents:
diff changeset
2410 * init.c (warn_placement_new_too_small): Handle placement new arguments
kono
parents:
diff changeset
2411 that are elements of arrays more carefully. Remove a pointless loop.
kono
parents:
diff changeset
2412
kono
parents:
diff changeset
2413 2016-05-30 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2414
kono
parents:
diff changeset
2415 PR c++/71349
kono
parents:
diff changeset
2416 * parser.c (cp_parser_omp_for): Don't disallow nowait clause
kono
parents:
diff changeset
2417 when combined with target construct.
kono
parents:
diff changeset
2418 (cp_parser_omp_parallel): Pass cclauses == NULL as last argument
kono
parents:
diff changeset
2419 to cp_parser_omp_all_clauses.
kono
parents:
diff changeset
2420
kono
parents:
diff changeset
2421 2016-05-30 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2422
kono
parents:
diff changeset
2423 PR c++/71238
kono
parents:
diff changeset
2424 * lex.c (unqualified_name_lookup_error): Take a location too.
kono
parents:
diff changeset
2425 (unqualified_fn_lookup_error): Take a cp_expr.
kono
parents:
diff changeset
2426 * cp-tree.h (unqualified_name_lookup_error,
kono
parents:
diff changeset
2427 unqualified_fn_lookup_error): Adjust declarations.
kono
parents:
diff changeset
2428 * semantics.c (perform_koenig_lookup): Adjust
kono
parents:
diff changeset
2429 unqualified_fn_lookup_error call, pass the location of
kono
parents:
diff changeset
2430 the identifier too as part of a cp_expr.
kono
parents:
diff changeset
2431
kono
parents:
diff changeset
2432 2016-05-30 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2433
kono
parents:
diff changeset
2434 PR c++/71099
kono
parents:
diff changeset
2435 * parser.c (cp_parser_function_specifier_opt): Use current_class_type
kono
parents:
diff changeset
2436 to improve the diagnostic about wrong uses of 'virtual'.
kono
parents:
diff changeset
2437
kono
parents:
diff changeset
2438 2016-05-29 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2439
kono
parents:
diff changeset
2440 PR c++/71105
kono
parents:
diff changeset
2441 * lambda.c (maybe_add_lambda_conv_op): Early return also when
kono
parents:
diff changeset
2442 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE != CPLD_NONE.
kono
parents:
diff changeset
2443
kono
parents:
diff changeset
2444 2016-05-28 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
2445
kono
parents:
diff changeset
2446 Revert:
kono
parents:
diff changeset
2447 PR c++/69855
kono
parents:
diff changeset
2448 * name-lookup.c (pushdecl_maybe_friend_1): Push local function
kono
parents:
diff changeset
2449 decls into the global scope after stripping template bits
kono
parents:
diff changeset
2450 and setting DECL_ANTICIPATED.
kono
parents:
diff changeset
2451
kono
parents:
diff changeset
2452 2016-05-27 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2453
kono
parents:
diff changeset
2454 PR c++/60385
kono
parents:
diff changeset
2455 * name-lookup.c (push_namespace): Return bool, false when pushdecl
kono
parents:
diff changeset
2456 fails.
kono
parents:
diff changeset
2457 * name-lookup.h (push_namespace): Adjust declaration.
kono
parents:
diff changeset
2458 * parser.c (cp_parser_namespace_definition): Check push_namespace
kono
parents:
diff changeset
2459 return value.
kono
parents:
diff changeset
2460
kono
parents:
diff changeset
2461 2016-05-27 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
2462
kono
parents:
diff changeset
2463 PR c++/69855
kono
parents:
diff changeset
2464 * name-lookup.c (pushdecl_maybe_friend_1): Push local function
kono
parents:
diff changeset
2465 decls into the global scope after stripping template bits
kono
parents:
diff changeset
2466 and setting DECL_ANTICIPATED.
kono
parents:
diff changeset
2467
kono
parents:
diff changeset
2468 2016-05-26 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2469
kono
parents:
diff changeset
2470 * semantics.c (finish_omp_clauses) <case OMP_CLAUSE_SCHEDULE>: Warn
kono
parents:
diff changeset
2471 if OMP_CLAUSE_SCHEDULE_CHUNK_EXPR is known not to be positive.
kono
parents:
diff changeset
2472
kono
parents:
diff changeset
2473 2016-05-26 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2474
kono
parents:
diff changeset
2475 PR c++/70822
kono
parents:
diff changeset
2476 PR c++/70106
kono
parents:
diff changeset
2477 * cp-tree.h (REF_PARENTHESIZED_P): Make this flag apply to
kono
parents:
diff changeset
2478 SCOPE_REFs too.
kono
parents:
diff changeset
2479 * pt.c (tsubst_qualified_id): If REF_PARENTHESIZED_P is set
kono
parents:
diff changeset
2480 on the qualified_id then propagate it to the resulting
kono
parents:
diff changeset
2481 expression.
kono
parents:
diff changeset
2482 (do_auto_deduction): Check REF_PARENTHESIZED_P on SCOPE_REFs
kono
parents:
diff changeset
2483 too.
kono
parents:
diff changeset
2484 * semantics.c (force_paren_expr): If given a SCOPE_REF, just set
kono
parents:
diff changeset
2485 its REF_PARENTHESIZED_P flag.
kono
parents:
diff changeset
2486
kono
parents:
diff changeset
2487 2016-05-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2488
kono
parents:
diff changeset
2489 PR c++/71173
kono
parents:
diff changeset
2490 PR c++/70522
kono
parents:
diff changeset
2491 * cp-tree.h (enum tag_types): Add scope_type.
kono
parents:
diff changeset
2492 * parser.c (cp_parser_class_name): Use scope_type.
kono
parents:
diff changeset
2493 (prefer_type_arg): Handle scope_type.
kono
parents:
diff changeset
2494 (cp_parser_lookup_name): Use prefer_type_arg.
kono
parents:
diff changeset
2495 * name-lookup.c (lookup_qualified_name): Change bool is_type_p to
kono
parents:
diff changeset
2496 int prefer_type, use lookup_flags.
kono
parents:
diff changeset
2497 * name-lookup.h: Adjust.
kono
parents:
diff changeset
2498
kono
parents:
diff changeset
2499 2016-05-24 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
2500
kono
parents:
diff changeset
2501 * parser.c (cp_parser_oacc_declare): Add support for
kono
parents:
diff changeset
2502 GOMP_MAP_FIRSTPRIVATE_POINTER.
kono
parents:
diff changeset
2503 * semantics.c (handle_omp_array_sections_1): Replace bool is_omp
kono
parents:
diff changeset
2504 argument with enum c_omp_region_type ort. Don't privatize OpenACC
kono
parents:
diff changeset
2505 non-static members.
kono
parents:
diff changeset
2506 (handle_omp_array_sections): Replace bool is_omp argument with enum
kono
parents:
diff changeset
2507 c_omp_region_type ort. Update call to handle_omp_array_sections_1.
kono
parents:
diff changeset
2508 (finish_omp_clauses): Add specific errors and warning messages for
kono
parents:
diff changeset
2509 OpenACC. Use firsrtprivate pointers for OpenACC subarrays. Update
kono
parents:
diff changeset
2510 call to handle_omp_array_sections.
kono
parents:
diff changeset
2511
kono
parents:
diff changeset
2512 2016-05-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2513
kono
parents:
diff changeset
2514 PR c++/70584
kono
parents:
diff changeset
2515 * cp-gimplify.c (cp_fold_maybe_rvalue): Loop in case cp_fold
kono
parents:
diff changeset
2516 returns a decl.
kono
parents:
diff changeset
2517 (cp_fold) [INDIRECT_REF]: Don't fold to an rvalue.
kono
parents:
diff changeset
2518
kono
parents:
diff changeset
2519 2016-05-24 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
2520
kono
parents:
diff changeset
2521 PR c++/71147
kono
parents:
diff changeset
2522 * decl.c (layout_var_decl, grokdeclarator): Use complete_or_array_type_p.
kono
parents:
diff changeset
2523 * pt.c (instantiate_class_template_1): Try to complete the element
kono
parents:
diff changeset
2524 type of a flexible array member.
kono
parents:
diff changeset
2525 (can_complete_type_without_circularity): Handle arrays of unknown bound.
kono
parents:
diff changeset
2526 * typeck.c (complete_type): Also complete the type of the elements of
kono
parents:
diff changeset
2527 arrays with an unspecified bound.
kono
parents:
diff changeset
2528
kono
parents:
diff changeset
2529 2016-05-24 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2530
kono
parents:
diff changeset
2531 PR c++/69872
kono
parents:
diff changeset
2532 * typeck2.c (check_narrowing): Check pedwarn return value.
kono
parents:
diff changeset
2533
kono
parents:
diff changeset
2534 2016-05-24 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2535
kono
parents:
diff changeset
2536 PR c++/71257
kono
parents:
diff changeset
2537 * semantics.c (finish_omp_clauses) <case OMP_CLAUSE_LINEAR>:
kono
parents:
diff changeset
2538 For OMP_CLAUSE_LINEAR_REF don't require type to be
kono
parents:
diff changeset
2539 integral or pointer.
kono
parents:
diff changeset
2540
kono
parents:
diff changeset
2541 2016-05-24 Richard Biener <rguenther@suse.de>
kono
parents:
diff changeset
2542
kono
parents:
diff changeset
2543 PR middle-end/70434
kono
parents:
diff changeset
2544 PR c/69504
kono
parents:
diff changeset
2545 * expr.c (mark_exp_read): Handle VIEW_CONVERT_EXPR.
kono
parents:
diff changeset
2546 * constexpr.c (cxx_eval_array_reference): Handle indexed
kono
parents:
diff changeset
2547 vectors.
kono
parents:
diff changeset
2548 * typeck.c (cp_build_array_ref): Adjust.
kono
parents:
diff changeset
2549
kono
parents:
diff changeset
2550 2016-05-23 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2551
kono
parents:
diff changeset
2552 PR c++/70344
kono
parents:
diff changeset
2553 * constexpr.c (cxx_eval_call_expression): Check for
kono
parents:
diff changeset
2554 fun == current_function_decl again.
kono
parents:
diff changeset
2555
kono
parents:
diff changeset
2556 PR c++/70584
kono
parents:
diff changeset
2557 * cp-gimplify.c (cp_fold) [INDIRECT_REF]: Call
kono
parents:
diff changeset
2558 maybe_undo_parenthesized_ref.
kono
parents:
diff changeset
2559
kono
parents:
diff changeset
2560 PR c++/70735
kono
parents:
diff changeset
2561 * pt.c (tsubst_copy): Just return a local variable from
kono
parents:
diff changeset
2562 non-template context. Don't call rest_of_decl_compilation for
kono
parents:
diff changeset
2563 duplicated static locals.
kono
parents:
diff changeset
2564 (tsubst_decl): Set DECL_CONTEXT of local static from another
kono
parents:
diff changeset
2565 function.
kono
parents:
diff changeset
2566
kono
parents:
diff changeset
2567 2016-05-23 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2568
kono
parents:
diff changeset
2569 PR c++/70972
kono
parents:
diff changeset
2570 * method.c (forward_parm): Use cp_build_reference_type.
kono
parents:
diff changeset
2571
kono
parents:
diff changeset
2572 2016-05-23 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2573
kono
parents:
diff changeset
2574 PR c++/69095
kono
parents:
diff changeset
2575 * parser.c (cp_parser_initializer): Use check_for_bare_parameter_packs.
kono
parents:
diff changeset
2576
kono
parents:
diff changeset
2577 2016-05-23 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2578
kono
parents:
diff changeset
2579 * pt.c (check_for_bare_parameter_packs): Improve error message
kono
parents:
diff changeset
2580 location for expressions.
kono
parents:
diff changeset
2581
kono
parents:
diff changeset
2582 2016-05-20 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
2583
kono
parents:
diff changeset
2584 * constexpr.c (cxx_bind_parameters_in_call): Avoid gratuitous if
kono
parents:
diff changeset
2585 ... goto.
kono
parents:
diff changeset
2586 (cxx_eval_call_expression): Fix comment grammar.
kono
parents:
diff changeset
2587
kono
parents:
diff changeset
2588 2016-05-20 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2589
kono
parents:
diff changeset
2590 PR c++/70572
kono
parents:
diff changeset
2591 * decl.c (cp_finish_decl): Check do_auto_deduction return value
kono
parents:
diff changeset
2592 and return immediately in case of erroneous code.
kono
parents:
diff changeset
2593
kono
parents:
diff changeset
2594 2016-05-19 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2595
kono
parents:
diff changeset
2596 PR c++/71075
kono
parents:
diff changeset
2597 * pt.c (unify_template_argument_mismatch): Use %qE instead of %qD.
kono
parents:
diff changeset
2598
kono
parents:
diff changeset
2599 2016-05-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2600
kono
parents:
diff changeset
2601 PR c++/10200
kono
parents:
diff changeset
2602 * pt.c (fn_type_unification): Add outer template args if needed.
kono
parents:
diff changeset
2603 (type_unification_real): Handle getting full args.
kono
parents:
diff changeset
2604
kono
parents:
diff changeset
2605 2016-05-19 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
2606
kono
parents:
diff changeset
2607 PR c++/71184
kono
parents:
diff changeset
2608 * parser.c (cp_parser_operator): For array new/delete, check that
kono
parents:
diff changeset
2609 cp_parser_require returned a non-NULL token before dereferencing
kono
parents:
diff changeset
2610 it.
kono
parents:
diff changeset
2611
kono
parents:
diff changeset
2612 2016-05-19 Bernd Edlinger <bernd.edlinger@hotmail.de>
kono
parents:
diff changeset
2613
kono
parents:
diff changeset
2614 * decl.c (finish_enum_value_list): Use the specified mode.
kono
parents:
diff changeset
2615
kono
parents:
diff changeset
2616 2016-05-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2617
kono
parents:
diff changeset
2618 * pt.c (value_dependent_expression_p): Tweak new cases to better
kono
parents:
diff changeset
2619 match the wording in the standard.
kono
parents:
diff changeset
2620
kono
parents:
diff changeset
2621 2016-05-18 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2622
kono
parents:
diff changeset
2623 PR c++/69793
kono
parents:
diff changeset
2624 * parser.c (cp_parser_template_id): Don't call cp_lexer_peek_nth_token
kono
parents:
diff changeset
2625 when the previous cp_lexer_peek_token returns CPP_EOF.
kono
parents:
diff changeset
2626
kono
parents:
diff changeset
2627 2016-05-18 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2628
kono
parents:
diff changeset
2629 PR c++/70466
kono
parents:
diff changeset
2630 * call.c (convert_like_real): Check that we are actually converting
kono
parents:
diff changeset
2631 from an init list.
kono
parents:
diff changeset
2632
kono
parents:
diff changeset
2633 2016-05-16 Matthew Wahab <matthew.wahab@arm.com>
kono
parents:
diff changeset
2634
kono
parents:
diff changeset
2635 * decl.c (grokdeclarator): Remove errmsg and use of
kono
parents:
diff changeset
2636 targetm.invalid_return_type.
kono
parents:
diff changeset
2637 (grokparms): Remove errmsg and use of
kono
parents:
diff changeset
2638 targetm.invalid_parameter_type.
kono
parents:
diff changeset
2639
kono
parents:
diff changeset
2640 2016-05-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2641
kono
parents:
diff changeset
2642 PR c++/10200
kono
parents:
diff changeset
2643 PR c++/69753
kono
parents:
diff changeset
2644 * pt.c (tsubst_decl): Use uses_template_parms.
kono
parents:
diff changeset
2645 (instantiate_template_1): Handle non-dependent calls in templates.
kono
parents:
diff changeset
2646 (value_dependent_expression_p): Handle BASELINK, FUNCTION_DECL.
kono
parents:
diff changeset
2647 (type_dependent_expression_p): Only consider innermost template args.
kono
parents:
diff changeset
2648 (dependent_template_arg_p): Check enclosing class of a template here.
kono
parents:
diff changeset
2649 (dependent_template_p): Not here.
kono
parents:
diff changeset
2650 (type_dependent_object_expression_p): New.
kono
parents:
diff changeset
2651 * typeck.c (finish_class_member_access_expr): Use it.
kono
parents:
diff changeset
2652 * parser.c (cp_parser_postfix_expression): Use it.
kono
parents:
diff changeset
2653 (cp_parser_postfix_dot_deref_expression): Use it. Use comptypes
kono
parents:
diff changeset
2654 to detect the current instantiation.
kono
parents:
diff changeset
2655 (cp_parser_lookup_name): Really implement DR 141.
kono
parents:
diff changeset
2656 * search.c (lookup_field_r): Prefer a dependent using-declaration.
kono
parents:
diff changeset
2657 (any_dependent_bases_p): Split out from...
kono
parents:
diff changeset
2658 * name-lookup.c (do_class_using_decl): ...here.
kono
parents:
diff changeset
2659 * call.c (build_new_method_call_1): Use it.
kono
parents:
diff changeset
2660 * semantics.c (finish_call_expr): 'this' doesn't make a call dependent.
kono
parents:
diff changeset
2661 * tree.c (non_static_member_function_p): Remove.
kono
parents:
diff changeset
2662 * typeck2.c (build_x_arrow): Use dependent_scope_p.
kono
parents:
diff changeset
2663
kono
parents:
diff changeset
2664 * parser.c (cp_parser_postfix_dot_deref_expression): Use
kono
parents:
diff changeset
2665 complete_type_or_else for unknown_type_node, too.
kono
parents:
diff changeset
2666
kono
parents:
diff changeset
2667 2016-05-12 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2668
kono
parents:
diff changeset
2669 PR c/70756
kono
parents:
diff changeset
2670 * call.c (build_new_op_1): Pass LOC to cp_build_modify_expr.
kono
parents:
diff changeset
2671 * cp-tree.h (cp_build_modify_expr): Update declaration.
kono
parents:
diff changeset
2672 (cxx_incomplete_type_error, cxx_incomplete_type_diagnostic): New inline
kono
parents:
diff changeset
2673 overloads.
kono
parents:
diff changeset
2674 * cp-ubsan.c (cp_ubsan_dfs_initialize_vtbl_ptrs): Pass INPUT_LOCATION to
kono
parents:
diff changeset
2675 cp_build_modify_expr.
kono
parents:
diff changeset
2676 * decl2.c (set_guard): Likewise.
kono
parents:
diff changeset
2677 (handle_tls_init): Likewise.
kono
parents:
diff changeset
2678 * init.c (perform_member_init): Likewise.
kono
parents:
diff changeset
2679 (expand_virtual_init): Likewise.
kono
parents:
diff changeset
2680 (build_new_1): Likewise.
kono
parents:
diff changeset
2681 (build_vec_delete_1): Likewise.
kono
parents:
diff changeset
2682 (get_temp_regvar): Likewise.
kono
parents:
diff changeset
2683 (build_vec_init): Likewise.
kono
parents:
diff changeset
2684 * method.c (do_build_copy_assign): Likewise.
kono
parents:
diff changeset
2685 (assignable_expr): Likewise.
kono
parents:
diff changeset
2686 * semantics.c (finish_omp_for): Likewise.
kono
parents:
diff changeset
2687 * typeck.c (cp_build_binary_op): Pass LOCATION to pointer_diff and
kono
parents:
diff changeset
2688 cp_pointer_int_sum.
kono
parents:
diff changeset
2689 (cp_pointer_int_sum): Add location parameter. Pass it down to
kono
parents:
diff changeset
2690 pointer_int_sum.
kono
parents:
diff changeset
2691 (pointer_diff): Add location parameter. Use it.
kono
parents:
diff changeset
2692 (build_modify_expr): Pass location down to cp_build_modify_expr.
kono
parents:
diff changeset
2693 (cp_build_modify_expr): Add location parameter. Use it.
kono
parents:
diff changeset
2694 (build_x_modify_expr): Pass location down to cp_build_modify_expr.
kono
parents:
diff changeset
2695 * typeck2.c (cxx_incomplete_type_diagnostic,
kono
parents:
diff changeset
2696 cxx_incomplete_type_error): Add location parameter.
kono
parents:
diff changeset
2697
kono
parents:
diff changeset
2698 2016-05-11 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2699
kono
parents:
diff changeset
2700 PR c++/71024
kono
parents:
diff changeset
2701 * decl.c (duplicate_decls): Call diagnose_mismatched_decls.
kono
parents:
diff changeset
2702
kono
parents:
diff changeset
2703 2016-05-05 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2704
kono
parents:
diff changeset
2705 * parser.c (cp_parser_selection_statement): For RID_SWITCH,
kono
parents:
diff changeset
2706 pass if_p instead of NULL to cp_parser_implicitly_scoped_statement.
kono
parents:
diff changeset
2707
kono
parents:
diff changeset
2708 2016-05-04 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2709
kono
parents:
diff changeset
2710 * parser.c (cp_parser_selection_statement): Replace OPT_Wparentheses
kono
parents:
diff changeset
2711 with OPT_Wdangling_else.
kono
parents:
diff changeset
2712
kono
parents:
diff changeset
2713 2016-05-03 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
2714
kono
parents:
diff changeset
2715 PR c++/66561
kono
parents:
diff changeset
2716 * tree.c (builtin_valid_in_constant_expr_p): Treat BUILT_IN_FILE,
kono
parents:
diff changeset
2717 BUILT_IN_FUNCTION, and BUILT_IN_LINE as constant expressions.
kono
parents:
diff changeset
2718
kono
parents:
diff changeset
2719 2016-05-03 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2720
kono
parents:
diff changeset
2721 PR c/70859
kono
parents:
diff changeset
2722 * call.c (build_cxx_call): Pass location and vNULL down to
kono
parents:
diff changeset
2723 check_builtin_function_arguments.
kono
parents:
diff changeset
2724
kono
parents:
diff changeset
2725 2016-05-03 Richard Biener <rguenther@suse.de>
kono
parents:
diff changeset
2726
kono
parents:
diff changeset
2727 * Make-lang.in (cc1plus-checksum.c): For stage-final re-use
kono
parents:
diff changeset
2728 the checksum from the previous stage.
kono
parents:
diff changeset
2729
kono
parents:
diff changeset
2730 2016-05-02 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
2731
kono
parents:
diff changeset
2732 PR c++/62314
kono
parents:
diff changeset
2733 * typeck.c (finish_class_member_access_expr): When
kono
parents:
diff changeset
2734 giving a hint about a possibly-misspelled member name,
kono
parents:
diff changeset
2735 add a fix-it replacement hint.
kono
parents:
diff changeset
2736
kono
parents:
diff changeset
2737 2016-05-02 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
2738
kono
parents:
diff changeset
2739 * cp-tree.h (finish_omp_clauses): Update prototype.
kono
parents:
diff changeset
2740 * parser.c (cp_parser_oacc_all_clauses): Update call to
kono
parents:
diff changeset
2741 finish_omp_clauses.
kono
parents:
diff changeset
2742 (cp_parser_omp_all_clauses): Likewise.
kono
parents:
diff changeset
2743 (cp_parser_omp_for_loop): Likewise.
kono
parents:
diff changeset
2744 (cp_omp_split_clauses): Likewise.
kono
parents:
diff changeset
2745 (cp_parser_oacc_cache): Likewise.
kono
parents:
diff changeset
2746 (cp_parser_oacc_loop): Likewise.
kono
parents:
diff changeset
2747 (cp_parser_omp_declare_target):
kono
parents:
diff changeset
2748 (cp_parser_cilk_simd_all_clauses): Likewise.
kono
parents:
diff changeset
2749 (cp_parser_cilk_for): Likewise.
kono
parents:
diff changeset
2750 * pt.c (tsubst_omp_clauses): Replace allow_fields and declare_simd
kono
parents:
diff changeset
2751 arguments with enum c_omp_region_type ort.
kono
parents:
diff changeset
2752 (tsubst_omp_clauses): Update calls to finish_omp_clauses.
kono
parents:
diff changeset
2753 (tsubst_omp_attribute): Update calls to tsubst_omp_clauses.
kono
parents:
diff changeset
2754 (tsubst_omp_for_iterator): Update calls to finish_omp_clauses.
kono
parents:
diff changeset
2755 (tsubst_expr): Update calls to tsubst_omp_clauses.
kono
parents:
diff changeset
2756 * semantics.c (finish_omp_clauses): Replace bool arguments
kono
parents:
diff changeset
2757 allow_fields, declare_simd, and is_cilk with bitmask ort.
kono
parents:
diff changeset
2758 (finish_omp_for): Update call to finish_omp_clauses.
kono
parents:
diff changeset
2759
kono
parents:
diff changeset
2760 2016-05-02 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
2761
kono
parents:
diff changeset
2762 PR c++/62314
kono
parents:
diff changeset
2763 * parser.c (cp_parser_class_head): Capture the start location;
kono
parents:
diff changeset
2764 use it to emit a fix-it insertion hint when complaining
kono
parents:
diff changeset
2765 about missing "template <> " in explicit specializations.
kono
parents:
diff changeset
2766
kono
parents:
diff changeset
2767 2016-05-02 Richard Sandiford <richard.sandiford@arm.com>
kono
parents:
diff changeset
2768
kono
parents:
diff changeset
2769 * init.c (build_new_1): Use shift operators instead of wi:: shifts.
kono
parents:
diff changeset
2770
kono
parents:
diff changeset
2771 2016-05-02 Richard Biener <rguenther@suse.de>
kono
parents:
diff changeset
2772
kono
parents:
diff changeset
2773 * decl.c (grokdeclarator): Properly insert a DECL_EXPR for
kono
parents:
diff changeset
2774 anonymous VLAs.
kono
parents:
diff changeset
2775
kono
parents:
diff changeset
2776 2016-04-29 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2777
kono
parents:
diff changeset
2778 PR c++/66644
kono
parents:
diff changeset
2779 * class.c (check_field_decl): Remove final int* parameter, change
kono
parents:
diff changeset
2780 the return type to bool; fix logic in order not to reject multiple
kono
parents:
diff changeset
2781 initialized fields in anonymous struct.
kono
parents:
diff changeset
2782 (check_field_decls): Adjust call.
kono
parents:
diff changeset
2783
kono
parents:
diff changeset
2784 2016-04-29 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
2785
kono
parents:
diff changeset
2786 PR middle-end/70626
kono
parents:
diff changeset
2787 * parser.c (cp_parser_oacc_loop): Don't augment mask with
kono
parents:
diff changeset
2788 OACC_LOOP_CLAUSE_MASK.
kono
parents:
diff changeset
2789 (cp_parser_oacc_kernels_parallel): Update call to
kono
parents:
diff changeset
2790 c_oacc_split_loop_clauses.
kono
parents:
diff changeset
2791
kono
parents:
diff changeset
2792 2016-04-28 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2793
kono
parents:
diff changeset
2794 Implement C++17 [[nodiscard]] attribute.
kono
parents:
diff changeset
2795 PR c++/38172
kono
parents:
diff changeset
2796 PR c++/54379
kono
parents:
diff changeset
2797 * parser.c (cp_parser_std_attribute): Handle [[nodiscard]].
kono
parents:
diff changeset
2798 * tree.c (handle_nodiscard_attribute): New.
kono
parents:
diff changeset
2799 (cxx_attribute_table): Add [[nodiscard]].
kono
parents:
diff changeset
2800 * cvt.c (cp_get_fndecl_from_callee, cp_get_callee_fndecl): New.
kono
parents:
diff changeset
2801 (maybe_warn_nodiscard): New.
kono
parents:
diff changeset
2802 (convert_to_void): Call it.
kono
parents:
diff changeset
2803
kono
parents:
diff changeset
2804 * cvt.c (cp_get_callee): New.
kono
parents:
diff changeset
2805 * constexpr.c (get_function_named_in_call): Use it.
kono
parents:
diff changeset
2806 * cxx-pretty-print.c (postfix_expression): Use it.
kono
parents:
diff changeset
2807 * except.c (check_noexcept_r): Use it.
kono
parents:
diff changeset
2808 * method.c (check_nontriv): Use it.
kono
parents:
diff changeset
2809 * tree.c (build_aggr_init_expr): Use it.
kono
parents:
diff changeset
2810 * cp-tree.h: Declare it.
kono
parents:
diff changeset
2811
kono
parents:
diff changeset
2812 2015-04-27 Ryan Burn <contact@rnburn.com>
kono
parents:
diff changeset
2813 Jeff Law <law@redhat.com>
kono
parents:
diff changeset
2814
kono
parents:
diff changeset
2815 PR c++/69024
kono
parents:
diff changeset
2816 PR c++/68997
kono
parents:
diff changeset
2817 * cp-gimplify.c (cp_gimplify_expr): Call cilk_cp_detect_spawn_and_unwrap
kono
parents:
diff changeset
2818 instead of cilk_detect_spawn_and_unwrap.
kono
parents:
diff changeset
2819 * cp-cilkplus.c (is_conversion_operator_function_decl_p): New.
kono
parents:
diff changeset
2820 (find_spawn): New.
kono
parents:
diff changeset
2821 (cilk_cp_detect_spawn_and_unwrap): New.
kono
parents:
diff changeset
2822 * lambda.c: Include cp-cilkplus.h.
kono
parents:
diff changeset
2823 * parser.c: Include cp-cilkplus.h.
kono
parents:
diff changeset
2824 * cp-tree.h (cpp_validate_cilk_plus_loop): Move prototype into...
kono
parents:
diff changeset
2825 * cp-cilkpus.h: New file.
kono
parents:
diff changeset
2826
kono
parents:
diff changeset
2827 2016-04-27 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
2828
kono
parents:
diff changeset
2829 * constexpr.c (get_fundef_copy): Use the original function for
kono
parents:
diff changeset
2830 non-recursive evaluations.
kono
parents:
diff changeset
2831 (save_fundef_copy): Always expect a slot to be available.
kono
parents:
diff changeset
2832
kono
parents:
diff changeset
2833 2016-04-27 Bernd Schmidt <bschmidt@redhat.com>
kono
parents:
diff changeset
2834
kono
parents:
diff changeset
2835 * parser.c (cp_parser_postfix_expression): Call
kono
parents:
diff changeset
2836 warn_for_memset instead of warning directly here.
kono
parents:
diff changeset
2837
kono
parents:
diff changeset
2838 2016-04-26 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2839
kono
parents:
diff changeset
2840 PR c++/70241
kono
parents:
diff changeset
2841 * decl.c (build_enumerator): Set current_access_specifier when
kono
parents:
diff changeset
2842 declaring an enumerator belonging to an in-class enumeration.
kono
parents:
diff changeset
2843 * parser.c (cp_parser_check_access_in_redecleration): Also
kono
parents:
diff changeset
2844 consider in-class enumerations.
kono
parents:
diff changeset
2845
kono
parents:
diff changeset
2846 2016-04-26 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2847
kono
parents:
diff changeset
2848 PR c++/70744
kono
parents:
diff changeset
2849 * call.c (build_conditional_expr_1): Call cp_stabilize_reference
kono
parents:
diff changeset
2850 instead of stabilize_reference.
kono
parents:
diff changeset
2851 (build_over_call): Likewise.
kono
parents:
diff changeset
2852 * cp-tree.h (cp_stabilize_reference): Declare.
kono
parents:
diff changeset
2853 * tree.c (cp_stabilize_reference): New function.
kono
parents:
diff changeset
2854 * typeck.c (cp_build_unary_op): Call cp_stabilize_reference instead of
kono
parents:
diff changeset
2855 stabilize_reference.
kono
parents:
diff changeset
2856 (unary_complex_lvalue): Likewise.
kono
parents:
diff changeset
2857 (cp_build_modify_expr): Likewise.
kono
parents:
diff changeset
2858
kono
parents:
diff changeset
2859 2016-04-26 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2860
kono
parents:
diff changeset
2861 PR bootstrap/70704
kono
parents:
diff changeset
2862 * pt.c (build_non_dependent_expr): Use flag_checking > 1 instead of
kono
parents:
diff changeset
2863 just flag_checking.
kono
parents:
diff changeset
2864
kono
parents:
diff changeset
2865 2016-04-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2866
kono
parents:
diff changeset
2867 * tree.c (std_attribute_table): New.
kono
parents:
diff changeset
2868 (init_tree): Register it.
kono
parents:
diff changeset
2869
kono
parents:
diff changeset
2870 2016-04-22 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2871
kono
parents:
diff changeset
2872 * parser.c (cp_parser_perform_range_for_lookup): Decay the array.
kono
parents:
diff changeset
2873
kono
parents:
diff changeset
2874 2016-04-21 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2875
kono
parents:
diff changeset
2876 * name-lookup.c (free_saved_scope): New free list of saved_scope
kono
parents:
diff changeset
2877 structures.
kono
parents:
diff changeset
2878 (push_to_top_level): Attempt to reuse a saved_scope struct
kono
parents:
diff changeset
2879 from free_saved_scope instead of allocating a new one each time.
kono
parents:
diff changeset
2880 (pop_from_top_level_1): Chain the now-unused saved_scope structure
kono
parents:
diff changeset
2881 onto free_saved_scope.
kono
parents:
diff changeset
2882
kono
parents:
diff changeset
2883 2016-04-21 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2884
kono
parents:
diff changeset
2885 PR c++/70540
kono
parents:
diff changeset
2886 * semantics.c (process_outer_var_ref): Unconditionally return
kono
parents:
diff changeset
2887 error_mark_node when mark_used returns false.
kono
parents:
diff changeset
2888
kono
parents:
diff changeset
2889 2016-04-21 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2890
kono
parents:
diff changeset
2891 PR c++/70513
kono
parents:
diff changeset
2892 * parser.c (cp_parser_enum_specifier): Check and possibly error for
kono
parents:
diff changeset
2893 extra qualification.
kono
parents:
diff changeset
2894
kono
parents:
diff changeset
2895 2016-04-20 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
2896
kono
parents:
diff changeset
2897 PR c++/55635
kono
parents:
diff changeset
2898 * init.c (build_vec_delete_1): Protect operator delete call in try
kono
parents:
diff changeset
2899 finally.
kono
parents:
diff changeset
2900 (build_delete): Likewise.
kono
parents:
diff changeset
2901 * optimize.c (build_delete_destructor_body): Likewise.
kono
parents:
diff changeset
2902
kono
parents:
diff changeset
2903 2016-04-20 Ilya Verbin <ilya.verbin@intel.com>
kono
parents:
diff changeset
2904
kono
parents:
diff changeset
2905 PR c++/69363
kono
parents:
diff changeset
2906 * cp-tree.h (finish_omp_clauses): Add new default argument.
kono
parents:
diff changeset
2907 * parser.c (cp_parser_cilk_simd_all_clauses): Use finish_omp_clauses
kono
parents:
diff changeset
2908 instead of c_finish_cilk_clauses.
kono
parents:
diff changeset
2909 * semantics.c (finish_omp_clauses): Add new argument. Allow
kono
parents:
diff changeset
2910 floating-point variables in the linear clause for Cilk Plus.
kono
parents:
diff changeset
2911
kono
parents:
diff changeset
2912 2016-04-20 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
2913
kono
parents:
diff changeset
2914 * semantics.c (finish_compound_lteral): Don't wrap VECTOR_TYPEs in a
kono
parents:
diff changeset
2915 TARGET_EXPR.
kono
parents:
diff changeset
2916
kono
parents:
diff changeset
2917 2016-04-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2918
kono
parents:
diff changeset
2919 PR c++/66543
kono
parents:
diff changeset
2920 * expr.c (mark_exp_read): Handle NON_DEPENDENT_EXPR.
kono
parents:
diff changeset
2921 * pt.c (make_pack_expansion): Call mark_exp_read.
kono
parents:
diff changeset
2922 * semantics.c (finish_id_expression): Call mark_type_use in
kono
parents:
diff changeset
2923 unevaluated context.
kono
parents:
diff changeset
2924
kono
parents:
diff changeset
2925 DR 2137
kono
parents:
diff changeset
2926 * call.c (implicit_conversion): If we choose a copy constructor
kono
parents:
diff changeset
2927 for list-initialization from the same type, the conversion is an
kono
parents:
diff changeset
2928 exact match.
kono
parents:
diff changeset
2929
kono
parents:
diff changeset
2930 * constexpr.c (breaks): Handle EXIT_EXPR.
kono
parents:
diff changeset
2931 (cxx_eval_loop_expr): Handle COMPOUND_EXPR body.
kono
parents:
diff changeset
2932 (cxx_eval_constant_expression): Handle EXIT_EXPR, improve handling
kono
parents:
diff changeset
2933 of COMPOUND_EXPR.
kono
parents:
diff changeset
2934
kono
parents:
diff changeset
2935 PR c++/68206
kono
parents:
diff changeset
2936 PR c++/68530
kono
parents:
diff changeset
2937 * constexpr.c (potential_constant_expression_1): Handle LOOP_EXPR
kono
parents:
diff changeset
2938 and GOTO_EXPR.
kono
parents:
diff changeset
2939
kono
parents:
diff changeset
2940 * pt.c (tsubst_expr): Remove shadowing declaration.
kono
parents:
diff changeset
2941 (tsubst_pack_expansion): Add assert.
kono
parents:
diff changeset
2942
kono
parents:
diff changeset
2943 * semantics.c (add_decl_expr): Use DECL_SOURCE_LOCATION.
kono
parents:
diff changeset
2944
kono
parents:
diff changeset
2945 PR c++/70522
kono
parents:
diff changeset
2946 * name-lookup.c (qualified_lookup_using_namespace): Look through
kono
parents:
diff changeset
2947 hidden names.
kono
parents:
diff changeset
2948
kono
parents:
diff changeset
2949 2016-04-18 Michael Matz <matz@suse.de>
kono
parents:
diff changeset
2950
kono
parents:
diff changeset
2951 * class.c (build_vtable): Use SET_DECL_ALIGN and SET_TYPE_ALIGN.
kono
parents:
diff changeset
2952 (layout_class_type): Ditto.
kono
parents:
diff changeset
2953 (build_base_field): Use SET_DECL_ALIGN.
kono
parents:
diff changeset
2954 (fixup_attribute_variants): Use SET_TYPE_ALIGN.
kono
parents:
diff changeset
2955 * decl.c (duplicate_decls): Use SET_DECL_ALIGN.
kono
parents:
diff changeset
2956 (record_unknown_type): Use SET_TYPE_ALIGN.
kono
parents:
diff changeset
2957 (cxx_init_decl_processing): Ditto.
kono
parents:
diff changeset
2958 (copy_type_enum): Ditto.
kono
parents:
diff changeset
2959 (grokfndecl): Use SET_DECL_ALIGN.
kono
parents:
diff changeset
2960 (copy_type_enum): Use SET_TYPE_ALIGN.
kono
parents:
diff changeset
2961 * pt.c (instantiate_class_template_1): Use SET_TYPE_ALIGN.
kono
parents:
diff changeset
2962 (tsubst): Ditto.
kono
parents:
diff changeset
2963 * tree.c (cp_build_qualified_type_real): Use SET_TYPE_ALIGN.
kono
parents:
diff changeset
2964 * lambda.c (maybe_add_lambda_conv_op): Use SET_DECL_ALIGN.
kono
parents:
diff changeset
2965 * method.c (implicitly_declare_fn): Use SET_DECL_ALIGN.
kono
parents:
diff changeset
2966 * rtti.c (emit_tinfo_decl): Ditto.
kono
parents:
diff changeset
2967
kono
parents:
diff changeset
2968 2016-04-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2969
kono
parents:
diff changeset
2970 PR c++/70690
kono
parents:
diff changeset
2971 PR c++/70528
kono
parents:
diff changeset
2972 * class.c (type_maybe_constexpr_default_constructor): New.
kono
parents:
diff changeset
2973 (type_has_constexpr_default_constructor): Revert.
kono
parents:
diff changeset
2974
kono
parents:
diff changeset
2975 2016-04-16 Sandra Loosemore <sandra@codesourcery.com>
kono
parents:
diff changeset
2976
kono
parents:
diff changeset
2977 PR target/1078
kono
parents:
diff changeset
2978
kono
parents:
diff changeset
2979 * tree.c (cxx_attribute_table): Remove "com_interface" entry.
kono
parents:
diff changeset
2980 (handle_com_interface_attribute): Delete.
kono
parents:
diff changeset
2981
kono
parents:
diff changeset
2982 2016-04-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2983
kono
parents:
diff changeset
2984 PR c++/70685
kono
parents:
diff changeset
2985 * constexpr.c (get_fundef_copy): Handle null *slot.
kono
parents:
diff changeset
2986
kono
parents:
diff changeset
2987 PR c++/70505
kono
parents:
diff changeset
2988 * pt.c (tsubst_baselink): Give the new TEMPLATE_ID_EXPR
kono
parents:
diff changeset
2989 unknown_type_node, too.
kono
parents:
diff changeset
2990
kono
parents:
diff changeset
2991 2016-04-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2992 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
2993
kono
parents:
diff changeset
2994 PR c++/70594
kono
parents:
diff changeset
2995 * constexpr.c (constexpr_call_table): Preserve in GC.
kono
parents:
diff changeset
2996 (struct fundef_copy, struct fundef_copies_table_t): Delete.
kono
parents:
diff changeset
2997 (fundef_copies_table): Preserve in GC. Change to pointer to
kono
parents:
diff changeset
2998 tree->tree hash.
kono
parents:
diff changeset
2999 (maybe_initialize_fundef_copies_table): Adjust.
kono
parents:
diff changeset
3000 (get_fundef_copy): Return a TREE_LIST. Use non-inserting search.
kono
parents:
diff changeset
3001 (save_fundef_copy): Adjust for a TREE_LIST.
kono
parents:
diff changeset
3002 (cxx_eval_call_expression): Adjust for a fundef_copy TREE_LIST.
kono
parents:
diff changeset
3003 (fini_constexpr): New.
kono
parents:
diff changeset
3004 * cp-tree.h (fini_constexpr): Declare.
kono
parents:
diff changeset
3005 * decl2.c (c_parse_final_cleanups): Call fini_constexpr.
kono
parents:
diff changeset
3006
kono
parents:
diff changeset
3007 2016-04-15 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3008
kono
parents:
diff changeset
3009 PR c/70436
kono
parents:
diff changeset
3010 * parser.c (cp_parser_pragma): Add IF_P argument, pass it down
kono
parents:
diff changeset
3011 where needed.
kono
parents:
diff changeset
3012 (cp_parser_declaration_seq_opt, cp_parser_member_specification_opt,
kono
parents:
diff changeset
3013 cp_parser_objc_interstitial_code, cp_parser_omp_declare_simd,
kono
parents:
diff changeset
3014 cp_parser_oacc_routine): Adjust cp_parser_pragma callers.
kono
parents:
diff changeset
3015 (cp_parser_statement): Likewise. Adjust cp_parser_cilk_for caller.
kono
parents:
diff changeset
3016 (cp_parser_omp_structured_block): Add IF_P argument, pass it down to
kono
parents:
diff changeset
3017 cp_parser_statement.
kono
parents:
diff changeset
3018 (cp_parser_oacc_data, cp_parser_oacc_host_data, cp_parser_oacc_loop,
kono
parents:
diff changeset
3019 cp_parser_oacc_kernels_parallel, cp_parser_omp_critical,
kono
parents:
diff changeset
3020 cp_parser_omp_simd, cp_parser_omp_for, cp_parser_omp_master,
kono
parents:
diff changeset
3021 cp_parser_omp_ordered, cp_parser_omp_parallel, cp_parser_omp_single,
kono
parents:
diff changeset
3022 cp_parser_omp_task, cp_parser_omp_taskgroup, cp_parser_omp_distribute,
kono
parents:
diff changeset
3023 cp_parser_omp_teams, cp_parser_omp_target_data, cp_parser_omp_target,
kono
parents:
diff changeset
3024 cp_parser_omp_taskloop, cp_parser_omp_construct,
kono
parents:
diff changeset
3025 cp_parser_cilk_grainsize, cp_parser_cilk_simd, cp_parser_cilk_for):
kono
parents:
diff changeset
3026 Add IF_P argument, pass it down where needed.
kono
parents:
diff changeset
3027 (cp_parser_omp_for_loop): Likewise. Clear IF_P if nbraces.
kono
parents:
diff changeset
3028 (cp_parser_omp_sections_scope): Adjust cp_parser_omp_structured_block
kono
parents:
diff changeset
3029 calls.
kono
parents:
diff changeset
3030
kono
parents:
diff changeset
3031 2016-04-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3032
kono
parents:
diff changeset
3033 PR c++/70494
kono
parents:
diff changeset
3034 * decl.c (cxx_maybe_build_cleanup): Handle non-decls.
kono
parents:
diff changeset
3035 * typeck2.c (split_nonconstant_init_1): Use it.
kono
parents:
diff changeset
3036
kono
parents:
diff changeset
3037 PR c++/70528
kono
parents:
diff changeset
3038 * class.c (type_has_constexpr_default_constructor): Return true
kono
parents:
diff changeset
3039 for an implicitly declared constructor.
kono
parents:
diff changeset
3040
kono
parents:
diff changeset
3041 PR c++/70622
kono
parents:
diff changeset
3042 * parser.c (cp_parser_init_declarator): Add auto_result parm.
kono
parents:
diff changeset
3043 (cp_parser_simple_declaration): Pass it.
kono
parents:
diff changeset
3044 (strip_declarator_types): New.
kono
parents:
diff changeset
3045
kono
parents:
diff changeset
3046 PR c++/70543
kono
parents:
diff changeset
3047 * pt.c (value_dependent_expression_p) [VAR_DECL]: A type-dependent
kono
parents:
diff changeset
3048 initializer also makes the variable value-dependent.
kono
parents:
diff changeset
3049
kono
parents:
diff changeset
3050 PR c++/70648
kono
parents:
diff changeset
3051 * constexpr.c (cxx_eval_store_expression): Also copy
kono
parents:
diff changeset
3052 CONSTRUCTOR_NO_IMPLICIT_ZERO.
kono
parents:
diff changeset
3053
kono
parents:
diff changeset
3054 2016-04-14 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
3055
kono
parents:
diff changeset
3056 PR c++/69517
kono
parents:
diff changeset
3057 PR c++/70019
kono
parents:
diff changeset
3058 PR c++/70588
kono
parents:
diff changeset
3059 * cp-tree.h, decl.c, init.c, typeck2.c: Revert.
kono
parents:
diff changeset
3060
kono
parents:
diff changeset
3061 2016-04-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3062
kono
parents:
diff changeset
3063 * call.c, decl.c, error.c, cp-tree.h, decl.c: Revert empty
kono
parents:
diff changeset
3064 parameter ABI change.
kono
parents:
diff changeset
3065
kono
parents:
diff changeset
3066 2016-04-13 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
3067
kono
parents:
diff changeset
3068 PR c++/69517
kono
parents:
diff changeset
3069 PR c++/70019
kono
parents:
diff changeset
3070 PR c++/70588
kono
parents:
diff changeset
3071 * cp-tree.h (throw_bad_array_length, build_vla_check): Declare new
kono
parents:
diff changeset
3072 functions.
kono
parents:
diff changeset
3073 * decl.c (check_initializer, cp_finish_decl): Call them.
kono
parents:
diff changeset
3074 (reshape_init_r): Reject incompletely braced intializer-lists
kono
parents:
diff changeset
3075 for VLAs.
kono
parents:
diff changeset
3076 * init.c (throw_bad_array_length, build_vla_check)
kono
parents:
diff changeset
3077 (build_vla_size_check, build_vla_init_check): Define new functions.
kono
parents:
diff changeset
3078 * typeck2.c (split_nonconstant_init_1): Use variably_modified_type_p()
kono
parents:
diff changeset
3079 to detect a VLA.
kono
parents:
diff changeset
3080 (store_init_value): Same.
kono
parents:
diff changeset
3081
kono
parents:
diff changeset
3082 2016-04-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3083
kono
parents:
diff changeset
3084 Warn about empty parameter ABI with -Wabi=9.
kono
parents:
diff changeset
3085 * call.c (empty_class_msg, mark_for_abi_warning)
kono
parents:
diff changeset
3086 (warn_empty_class_abi): New.
kono
parents:
diff changeset
3087 (build_call_a): Use them.
kono
parents:
diff changeset
3088 * decl.c (store_parm_decls): Use mark_for_abi_warning.
kono
parents:
diff changeset
3089 * error.c (pp_format_to_string): New.
kono
parents:
diff changeset
3090
kono
parents:
diff changeset
3091 Pass empty class parameters like C.
kono
parents:
diff changeset
3092 * call.c (pass_as_empty_struct, empty_class_arg): New.
kono
parents:
diff changeset
3093 (type_passed_as, build_x_va_arg): Use pass_as_empty_struct.
kono
parents:
diff changeset
3094 (build_call_a): Use empty_class_arg.
kono
parents:
diff changeset
3095 * cp-tree.h (CPTI_EMPTY_STRUCT, empty_struct_type): New.
kono
parents:
diff changeset
3096 * decl.c (cxx_init_decl_processing): Create empty_struct_type.
kono
parents:
diff changeset
3097
kono
parents:
diff changeset
3098 2016-04-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3099
kono
parents:
diff changeset
3100 PR c++/70627
kono
parents:
diff changeset
3101 * decl.c (start_enum): Don't change an existing ENUM_UNDERLYING_TYPE.
kono
parents:
diff changeset
3102
kono
parents:
diff changeset
3103 2016-04-13 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3104
kono
parents:
diff changeset
3105 PR c++/70635
kono
parents:
diff changeset
3106 * pt.c (resolve_typename_type): Fix typos in infinite recursion
kono
parents:
diff changeset
3107 avoidance mechanism.
kono
parents:
diff changeset
3108
kono
parents:
diff changeset
3109 2016-04-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3110
kono
parents:
diff changeset
3111 PR c++/70634
kono
parents:
diff changeset
3112 * pt.c (instantiation_dependent_uneval_expression_p): Split out
kono
parents:
diff changeset
3113 from instantiation_dependent_expression_p.
kono
parents:
diff changeset
3114 (value_dependent_expression_p): Use it for unevaluated operands.
kono
parents:
diff changeset
3115 (instantiation_dependent_r): Don't check value-dependence.
kono
parents:
diff changeset
3116 (instantiation_dependent_expression_p): Check
kono
parents:
diff changeset
3117 value-dependence of the expression as a whole.
kono
parents:
diff changeset
3118 * cp-tree.h: Declare instantiation_dependent_uneval_expression_p.
kono
parents:
diff changeset
3119 * semantics.c (finish_decltype_type): Use it.
kono
parents:
diff changeset
3120
kono
parents:
diff changeset
3121 * constexpr.c (potential_nondependent_constant_expression): New.
kono
parents:
diff changeset
3122 (potential_nondependent_static_init_expression): New.
kono
parents:
diff changeset
3123 (maybe_constant_value_1, fold_non_dependent_expr)
kono
parents:
diff changeset
3124 (maybe_constant_init): Use them.
kono
parents:
diff changeset
3125 * pt.c (instantiate_non_dependent_expr_sfinae)
kono
parents:
diff changeset
3126 (instantiate_non_dependent_or_null, convert_nontype_argument): Use
kono
parents:
diff changeset
3127 them.
kono
parents:
diff changeset
3128 * cp-tree.h: Declare them.
kono
parents:
diff changeset
3129
kono
parents:
diff changeset
3130 2016-04-13 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3131
kono
parents:
diff changeset
3132 PR c++/70594
kono
parents:
diff changeset
3133 * decl.c (pop_labels_1): Removed.
kono
parents:
diff changeset
3134 (note_label, sort_labels): New functions.
kono
parents:
diff changeset
3135 (pop_labels): During named_labels traversal, just push the slot
kono
parents:
diff changeset
3136 pointers into a vector, then qsort it by DECL_UID and only then
kono
parents:
diff changeset
3137 call pop_label and chain it into BLOCK_VARS.
kono
parents:
diff changeset
3138
kono
parents:
diff changeset
3139 2016-04-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3140
kono
parents:
diff changeset
3141 PR c++/70615
kono
parents:
diff changeset
3142 * cp-gimplify.c (cp_genericize_r): Expand PTRMEM_CST here.
kono
parents:
diff changeset
3143 (cp_gimplify_expr): Not here.
kono
parents:
diff changeset
3144
kono
parents:
diff changeset
3145 2016-04-12 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3146
kono
parents:
diff changeset
3147 PR c++/70610
kono
parents:
diff changeset
3148 * tree.c (lvalue_kind) [NON_DEPENDENT_EXPR]: Unconditionally
kono
parents:
diff changeset
3149 recurse into it.
kono
parents:
diff changeset
3150 * typeck.c (build_x_conditional_expr): Unconditionally remember
kono
parents:
diff changeset
3151 that the result is an lvalue or xvalue.
kono
parents:
diff changeset
3152
kono
parents:
diff changeset
3153 2016-04-12 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3154
kono
parents:
diff changeset
3155 * class.c (is_really_empty_class): A zero-length array is empty.
kono
parents:
diff changeset
3156 An unnamed bit-field doesn't make a class non-empty.
kono
parents:
diff changeset
3157
kono
parents:
diff changeset
3158 2016-04-12 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3159
kono
parents:
diff changeset
3160 PR c++/68722
kono
parents:
diff changeset
3161 * parser.c (cp_parser_cache_defarg): When file ends in default
kono
parents:
diff changeset
3162 argument simply return error_mark_node.
kono
parents:
diff changeset
3163
kono
parents:
diff changeset
3164 2016-04-12 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
3165
kono
parents:
diff changeset
3166 PR c++/70501
kono
parents:
diff changeset
3167 * constexpr.c (cxx_eval_bare_aggregate): Handle VECTOR_TYPE
kono
parents:
diff changeset
3168 similarly to PMF.
kono
parents:
diff changeset
3169
kono
parents:
diff changeset
3170 2016-04-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3171
kono
parents:
diff changeset
3172 * mangle.c (decl_is_template_id): The template itself counts as a
kono
parents:
diff changeset
3173 template-id.
kono
parents:
diff changeset
3174
kono
parents:
diff changeset
3175 2016-04-08 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3176
kono
parents:
diff changeset
3177 PR c++/70590
kono
parents:
diff changeset
3178 PR c++/70452
kono
parents:
diff changeset
3179 * constexpr.c (cxx_eval_outermost_expression): Call unshare_expr
kono
parents:
diff changeset
3180 on the result if it's not a CONSTRUCTOR.
kono
parents:
diff changeset
3181
kono
parents:
diff changeset
3182 2016-04-07 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3183
kono
parents:
diff changeset
3184 PR c++/70452
kono
parents:
diff changeset
3185 * constexpr.c (find_constructor): New function.
kono
parents:
diff changeset
3186 (unshare_constructor): New function.
kono
parents:
diff changeset
3187 (cxx_eval_call_expression): Use unshare_constructor instead of
kono
parents:
diff changeset
3188 unshare_expr.
kono
parents:
diff changeset
3189 (find_array_ctor_elt): Likewise.
kono
parents:
diff changeset
3190 (cxx_eval_vec_init_1): Likewise.
kono
parents:
diff changeset
3191 (cxx_eval_store_expression): Likewise.
kono
parents:
diff changeset
3192 (cxx_eval_constant_expression): Likewise.
kono
parents:
diff changeset
3193
kono
parents:
diff changeset
3194 2016-04-06 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3195
kono
parents:
diff changeset
3196 PR c/70436
kono
parents:
diff changeset
3197 * cp-tree.h (FOR_EACH_CLONE): Restructure macro to avoid
kono
parents:
diff changeset
3198 potentially generating a future -Wparentheses warning in its
kono
parents:
diff changeset
3199 callers.
kono
parents:
diff changeset
3200
kono
parents:
diff changeset
3201 2016-04-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3202
kono
parents:
diff changeset
3203 * class.c (check_abi_tags): Fix function template handling.
kono
parents:
diff changeset
3204
kono
parents:
diff changeset
3205 2016-04-05 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
3206
kono
parents:
diff changeset
3207 PR c++/70512
kono
parents:
diff changeset
3208 * class.c (fixup_may_alias): New.
kono
parents:
diff changeset
3209 (fixup_attribute_variants): Call it.
kono
parents:
diff changeset
3210
kono
parents:
diff changeset
3211 2016-04-05 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3212
kono
parents:
diff changeset
3213 PR c++/70452
kono
parents:
diff changeset
3214 * constexpr.c (struct fundef_copy): New struct.
kono
parents:
diff changeset
3215 (struct fundef_copies_table_t): New struct.
kono
parents:
diff changeset
3216 (fundef_copies_table): New static variable.
kono
parents:
diff changeset
3217 (maybe_initialize_fundef_copies_table): New static function.
kono
parents:
diff changeset
3218 (get_fundef_copy): New static function.
kono
parents:
diff changeset
3219 (save_fundef_copy): New static function.
kono
parents:
diff changeset
3220 (cxx_eval_call_expression): Use get_fundef_copy, and
kono
parents:
diff changeset
3221 save_fundef_copy.
kono
parents:
diff changeset
3222 (constexpr_call_table): Add "deletable" GTY marker.
kono
parents:
diff changeset
3223
kono
parents:
diff changeset
3224 2016-04-05 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3225
kono
parents:
diff changeset
3226 PR c++/70452
kono
parents:
diff changeset
3227 * cp-tree.h (class cache_map): Remove.
kono
parents:
diff changeset
3228 * constexpr.c (cv_cache): Change type to
kono
parents:
diff changeset
3229 GTY((deletable)) hash_map<tree, tree> *.
kono
parents:
diff changeset
3230 (maybe_constant_value): Adjust following the change to cv_cache.
kono
parents:
diff changeset
3231 (clear_cv_cache): New static function.
kono
parents:
diff changeset
3232 (clear_cv_and_fold_caches): Use it.
kono
parents:
diff changeset
3233 * cp-gimplify.c (fold_cache): Change type to
kono
parents:
diff changeset
3234 GTY((deletable)) hash_map<tree, tree> *.
kono
parents:
diff changeset
3235 (clear_fold_cache): Adjust following the change to fold_cache.
kono
parents:
diff changeset
3236 (cp_fold): Likewise.
kono
parents:
diff changeset
3237
kono
parents:
diff changeset
3238 2016-04-02 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
3239
kono
parents:
diff changeset
3240 PR c++/67376
kono
parents:
diff changeset
3241 PR c++/70170
kono
parents:
diff changeset
3242 PR c++/70172
kono
parents:
diff changeset
3243 PR c++/70228
kono
parents:
diff changeset
3244 * constexpr.c (diag_array_subscript): New function.
kono
parents:
diff changeset
3245 (cxx_eval_array_reference): Detect out of bounds array indices.
kono
parents:
diff changeset
3246
kono
parents:
diff changeset
3247 2016-04-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3248
kono
parents:
diff changeset
3249 PR c++/70449
kono
parents:
diff changeset
3250 PR c++/70344
kono
parents:
diff changeset
3251 * pt.c (instantiate_decl): A function isn't fully defined if
kono
parents:
diff changeset
3252 DECL_INITIAL is error_mark_node.
kono
parents:
diff changeset
3253 * constexpr.c (cxx_eval_call_expression): Likewise.
kono
parents:
diff changeset
3254
kono
parents:
diff changeset
3255 2016-04-01 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3256 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3257
kono
parents:
diff changeset
3258 PR c++/70488
kono
parents:
diff changeset
3259 * init.c (warn_placement_new_too_small): Test whether
kono
parents:
diff changeset
3260 DECL_SIZE_UNIT or TYPE_SIZE_UNIT are integers that fit into uhwi.
kono
parents:
diff changeset
3261
kono
parents:
diff changeset
3262 2016-04-01 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
3263
kono
parents:
diff changeset
3264 PR c++/68475
kono
parents:
diff changeset
3265 * decl.c (check_redeclaration_exception_specification): Check
kono
parents:
diff changeset
3266 regardless of -fno-exceptions.
kono
parents:
diff changeset
3267 * typeck2.c (merge_exception_specifiers): Relax assert by checking
kono
parents:
diff changeset
3268 flag_exceptions too.
kono
parents:
diff changeset
3269
kono
parents:
diff changeset
3270 2016-03-31 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
3271
kono
parents:
diff changeset
3272 * decl.c (start_preparsed_function): Remove unnecessary bracing.
kono
parents:
diff changeset
3273 (finish_destructor_body): Don't emit operator delete here.
kono
parents:
diff changeset
3274
kono
parents:
diff changeset
3275 2016-03-31 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
3276
kono
parents:
diff changeset
3277 PR c++/70393
kono
parents:
diff changeset
3278 * constexpr.c (cxx_eval_store_expression): Keep CONSTRUCTOR
kono
parents:
diff changeset
3279 elements in field order.
kono
parents:
diff changeset
3280
kono
parents:
diff changeset
3281 2016-03-31 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3282
kono
parents:
diff changeset
3283 PR c/70297
kono
parents:
diff changeset
3284 * decl.c (duplicate_decls): Also set TYPE_ALIGN and TYPE_USER_ALIGN.
kono
parents:
diff changeset
3285
kono
parents:
diff changeset
3286 2016-03-31 Richard Biener <rguenther@suse.de>
kono
parents:
diff changeset
3287
kono
parents:
diff changeset
3288 PR c++/70430
kono
parents:
diff changeset
3289 * typeck.c (cp_build_binary_op): Fix operand order of vector
kono
parents:
diff changeset
3290 conditional in truth op handling.
kono
parents:
diff changeset
3291
kono
parents:
diff changeset
3292 2016-03-29 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3293
kono
parents:
diff changeset
3294 PR c++/70353
kono
parents:
diff changeset
3295 * decl.c (make_rtl_for_nonlocal_decl): Don't defer local statics
kono
parents:
diff changeset
3296 in constexpr functions.
kono
parents:
diff changeset
3297
kono
parents:
diff changeset
3298 2016-03-28 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3299
kono
parents:
diff changeset
3300 PR c++/70422
kono
parents:
diff changeset
3301 PR c++/64266
kono
parents:
diff changeset
3302 PR c++/70353
kono
parents:
diff changeset
3303 * decl.c, pt.c, constexpr.c: Revert last patch.
kono
parents:
diff changeset
3304
kono
parents:
diff changeset
3305 2016-03-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3306 Martin Liška <mliska@suse.cz>
kono
parents:
diff changeset
3307
kono
parents:
diff changeset
3308 PR c++/64266
kono
parents:
diff changeset
3309 PR c++/70353
kono
parents:
diff changeset
3310 Core issue 1962
kono
parents:
diff changeset
3311 * decl.c (cp_fname_init): Decay the initializer to pointer.
kono
parents:
diff changeset
3312 (cp_make_fname_decl): Set DECL_DECLARED_CONSTEXPR_P,
kono
parents:
diff changeset
3313 DECL_VALUE_EXPR, DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P.
kono
parents:
diff changeset
3314 Don't call cp_finish_decl.
kono
parents:
diff changeset
3315 * pt.c (tsubst_expr) [DECL_EXPR]: Set DECL_VALUE_EXPR,
kono
parents:
diff changeset
3316 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P. Don't call cp_finish_decl.
kono
parents:
diff changeset
3317 * constexpr.c (cxx_eval_constant_expression) [VAR_DECL]:
kono
parents:
diff changeset
3318 Handle DECL_VALUE_EXPR.
kono
parents:
diff changeset
3319
kono
parents:
diff changeset
3320 2016-03-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3321
kono
parents:
diff changeset
3322 PR c++/70386
kono
parents:
diff changeset
3323 * constexpr.c (cxx_eval_bare_aggregate): Handle PMFs.
kono
parents:
diff changeset
3324
kono
parents:
diff changeset
3325 PR c++/70323
kono
parents:
diff changeset
3326 * constexpr.c (cxx_eval_call_expression): Don't cache result if
kono
parents:
diff changeset
3327 *overflow_p.
kono
parents:
diff changeset
3328
kono
parents:
diff changeset
3329 2016-03-24 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3330
kono
parents:
diff changeset
3331 PR c++/62212
kono
parents:
diff changeset
3332 * tree.c (build_cplus_array_type): Determine type-dependentess
kono
parents:
diff changeset
3333 with uses_template_parms instead of with dependent_type_p.
kono
parents:
diff changeset
3334
kono
parents:
diff changeset
3335 2016-03-23 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3336
kono
parents:
diff changeset
3337 PR c++/70347
kono
parents:
diff changeset
3338 * typeck.c (process_init_constructor_union): If the initializer
kono
parents:
diff changeset
3339 is empty, use the union's NSDMI if it has one.
kono
parents:
diff changeset
3340
kono
parents:
diff changeset
3341 2016-03-23 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3342
kono
parents:
diff changeset
3343 PR c++/70332
kono
parents:
diff changeset
3344 * pt.c (tsubst_copy) [PARM_DECL]: Handle the use of 'this' in an
kono
parents:
diff changeset
3345 NSDMI that's part of an aggregrate initialization.
kono
parents:
diff changeset
3346
kono
parents:
diff changeset
3347 2016-03-23 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3348
kono
parents:
diff changeset
3349 PR c++/70001
kono
parents:
diff changeset
3350 * constexpr.c (cxx_eval_vec_init_1): Reuse CONSTRUCTOR initializers
kono
parents:
diff changeset
3351 for 1..max even for multi-dimensional arrays. Call unshare_expr
kono
parents:
diff changeset
3352 on it.
kono
parents:
diff changeset
3353
kono
parents:
diff changeset
3354 PR c++/70323
kono
parents:
diff changeset
3355 * constexpr.c (cxx_eval_constant_expression): Diagnose overflow
kono
parents:
diff changeset
3356 on TREE_OVERFLOW constants.
kono
parents:
diff changeset
3357
kono
parents:
diff changeset
3358 PR c++/70376
kono
parents:
diff changeset
3359 * cp-gimplify.c (genericize_omp_for_stmt): Don't walk OMP_FOR_CLAUSES
kono
parents:
diff changeset
3360 for OMP_TASKLOOP here.
kono
parents:
diff changeset
3361 (cp_genericize_r): Handle OMP_TASKLOOP like OMP_TASK, except do call
kono
parents:
diff changeset
3362 genericize_omp_for_stmt instead of cp_walk_tree on OMP_BODY.
kono
parents:
diff changeset
3363
kono
parents:
diff changeset
3364 2016-03-23 Alexandre Oliva <aoliva@redhat.com>
kono
parents:
diff changeset
3365 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3366 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3367
kono
parents:
diff changeset
3368 PR c++/69315
kono
parents:
diff changeset
3369 * cp-tree.h (defer_mark_used_calls, deferred_mark_used_calls): Remove.
kono
parents:
diff changeset
3370 * decl.c (defer_mark_used_calls, deferred_mark_used_calls): Remove.
kono
parents:
diff changeset
3371 (finish_function): Don't set or test them.
kono
parents:
diff changeset
3372 * decl2.c (mark_used): Don't handle defer_mark_used_calls.
kono
parents:
diff changeset
3373
kono
parents:
diff changeset
3374 2016-03-23 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3375
kono
parents:
diff changeset
3376 PR c++/70344
kono
parents:
diff changeset
3377 * constexpr.c (cxx_eval_call_expression): Catch invalid recursion.
kono
parents:
diff changeset
3378
kono
parents:
diff changeset
3379 2016-03-23 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3380
kono
parents:
diff changeset
3381 PR c++/69884
kono
parents:
diff changeset
3382 * pt.c (canonicalize_type_argument): Use OPT_Wignored_attributes.
kono
parents:
diff changeset
3383
kono
parents:
diff changeset
3384 2016-03-22 Ilya Enkovich <enkovich.gnu@gmail.com>
kono
parents:
diff changeset
3385
kono
parents:
diff changeset
3386 * call.c (build_conditional_expr_1): Always use original
kono
parents:
diff changeset
3387 condition type for vector type checks and build.
kono
parents:
diff changeset
3388
kono
parents:
diff changeset
3389 2016-03-22 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3390
kono
parents:
diff changeset
3391 PR c++/70096
kono
parents:
diff changeset
3392 * pt.c (tsubst_decl): Clear the DECL_MODE of the new decl.
kono
parents:
diff changeset
3393
kono
parents:
diff changeset
3394 2016-03-22 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3395
kono
parents:
diff changeset
3396 PR c++/70204
kono
parents:
diff changeset
3397 * constexpr.c (non_const_var_error): Check
kono
parents:
diff changeset
3398 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P.
kono
parents:
diff changeset
3399
kono
parents:
diff changeset
3400 2016-03-21 Richard Henderson <rth@redhat.com>
kono
parents:
diff changeset
3401
kono
parents:
diff changeset
3402 PR c++/70273
kono
parents:
diff changeset
3403 * decl.c (notice_forced_label_r): New.
kono
parents:
diff changeset
3404 (cp_finish_decl): Use it.
kono
parents:
diff changeset
3405
kono
parents:
diff changeset
3406 2016-03-21 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3407
kono
parents:
diff changeset
3408 PR c++/70285
kono
parents:
diff changeset
3409 * cp-gimplify.c (cp_fold) [COND_EXPR]: Handle bit-fields.
kono
parents:
diff changeset
3410
kono
parents:
diff changeset
3411 2016-03-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3412
kono
parents:
diff changeset
3413 PR c++/70139
kono
parents:
diff changeset
3414 * constexpr.c (cxx_eval_call_expression): Fix trivial copy.
kono
parents:
diff changeset
3415
kono
parents:
diff changeset
3416 PR c++/70147
kono
parents:
diff changeset
3417 * class.c (vptr_via_virtual_p): New.
kono
parents:
diff changeset
3418 (most_primary_binfo): Factor out of build_rtti_vtbl_entries.
kono
parents:
diff changeset
3419 * cp-ubsan.c (cp_ubsan_dfs_initialize_vtbl_ptrs): Don't clear
kono
parents:
diff changeset
3420 a vptr from any virtual base in a not-in-charge 'structor.
kono
parents:
diff changeset
3421
kono
parents:
diff changeset
3422 * decl.c (build_clobber_this): Factor out of
kono
parents:
diff changeset
3423 start_preparsed_function and begin_destructor_body. Handle
kono
parents:
diff changeset
3424 virtual bases better.
kono
parents:
diff changeset
3425
kono
parents:
diff changeset
3426 * class.c (build_if_in_charge): Split out from build_base_path.
kono
parents:
diff changeset
3427 * init.c (expand_virtual_init, expand_default_init): Use it.
kono
parents:
diff changeset
3428 * call.c (build_special_member_call): Use it.
kono
parents:
diff changeset
3429
kono
parents:
diff changeset
3430 2016-03-18 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3431
kono
parents:
diff changeset
3432 PR c++/70267
kono
parents:
diff changeset
3433 * init.c (build_new_1): Complain and return error_mark_node
kono
parents:
diff changeset
3434 if alloc_fn is not _Jv_AllocObject function returning pointer.
kono
parents:
diff changeset
3435
kono
parents:
diff changeset
3436 2016-03-18 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3437
kono
parents:
diff changeset
3438 PR c++/70205
kono
parents:
diff changeset
3439 * search.c (adjust_result_of_qualified_name_lookup): Don't
kono
parents:
diff changeset
3440 update the BASELINK_BINFO of DECL if the second call
kono
parents:
diff changeset
3441 to lookup_base fails.
kono
parents:
diff changeset
3442
kono
parents:
diff changeset
3443 2016-03-18 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3444
kono
parents:
diff changeset
3445 PR c++/70218
kono
parents:
diff changeset
3446 * parser.c (cp_parser_lambda_expression): Move call to
kono
parents:
diff changeset
3447 pop_deferring_access_checks ahead of the call to
kono
parents:
diff changeset
3448 cp_parser_end_tentative_firewall.
kono
parents:
diff changeset
3449
kono
parents:
diff changeset
3450 2016-03-17 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3451
kono
parents:
diff changeset
3452 PR c++/70144
kono
parents:
diff changeset
3453 * cp-tree.h (magic_varargs_p): Return int instead of bool.
kono
parents:
diff changeset
3454 * call.c (magic_varargs_p): Return int instead of bool, return 2 for
kono
parents:
diff changeset
3455 Cilk+ reductions, otherwise 1 for magic varargs and 0 for normal
kono
parents:
diff changeset
3456 varargs.
kono
parents:
diff changeset
3457 (build_over_call): If magic_varargs_p == 2, call reject_gcc_builtin,
kono
parents:
diff changeset
3458 if magic_varargs_p == 1, call decay_conversion
kono
parents:
diff changeset
3459 instead of mark_type_use. Don't store error_mark_node arguments to
kono
parents:
diff changeset
3460 argarray, instead return error_mark_node.
kono
parents:
diff changeset
3461
kono
parents:
diff changeset
3462 PR c++/70272
kono
parents:
diff changeset
3463 * decl.c (begin_destructor_body): Don't insert clobber if
kono
parents:
diff changeset
3464 is_empty_class (current_class_type).
kono
parents:
diff changeset
3465
kono
parents:
diff changeset
3466 2016-03-17 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3467
kono
parents:
diff changeset
3468 PR c++/70194
kono
parents:
diff changeset
3469 * typeck.c (warn_for_null_address): New function.
kono
parents:
diff changeset
3470 (cp_build_binary_op): Call it.
kono
parents:
diff changeset
3471
kono
parents:
diff changeset
3472 2016-03-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3473
kono
parents:
diff changeset
3474 PR c++/70259
kono
parents:
diff changeset
3475 * decl.c (start_preparsed_function): Don't clobber an empty base.
kono
parents:
diff changeset
3476
kono
parents:
diff changeset
3477 2016-03-16 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3478
kono
parents:
diff changeset
3479 PR c++/70147
kono
parents:
diff changeset
3480 * cp-ubsan.c (cp_ubsan_dfs_initialize_vtbl_ptrs): Conditionalize
kono
parents:
diff changeset
3481 BINFO_VIRTUAL_P vtable clearing on current_in_charge_parm.
kono
parents:
diff changeset
3482
kono
parents:
diff changeset
3483 PR c++/70147
kono
parents:
diff changeset
3484 * cp-ubsan.c (cp_ubsan_maybe_initialize_vtbl_ptrs): Temporarily
kono
parents:
diff changeset
3485 set in_base_initializer.
kono
parents:
diff changeset
3486
kono
parents:
diff changeset
3487 2016-03-15 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3488
kono
parents:
diff changeset
3489 PR c++/70209
kono
parents:
diff changeset
3490 * tree.c (strip_typedefs): Call strip_typedefs again on the
kono
parents:
diff changeset
3491 DECL_ORIGINAL_TYPE result.
kono
parents:
diff changeset
3492
kono
parents:
diff changeset
3493 2016-03-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3494
kono
parents:
diff changeset
3495 PR c++/70095
kono
parents:
diff changeset
3496 * pt.c (instantiate_decl): Fix call to variable_template_p.
kono
parents:
diff changeset
3497
kono
parents:
diff changeset
3498 PR c++/70141
kono
parents:
diff changeset
3499 * pt.c (for_each_template_parm_r): Always walk into TYPENAME_TYPE.
kono
parents:
diff changeset
3500
kono
parents:
diff changeset
3501 2016-03-14 Casey Carter <casey@carter.net>
kono
parents:
diff changeset
3502 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3503
kono
parents:
diff changeset
3504 P0184R0: Generalizing the Range-Based For Loop
kono
parents:
diff changeset
3505 * parser.c (cp_convert_range_for): Set the type of __end separately.
kono
parents:
diff changeset
3506 (cp_parser_perform_range_for_lookup): Allow different begin/end
kono
parents:
diff changeset
3507 types if they are comparable.
kono
parents:
diff changeset
3508
kono
parents:
diff changeset
3509 2016-03-12 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3510
kono
parents:
diff changeset
3511 PR c++/70106
kono
parents:
diff changeset
3512 * semantics.c (force_paren_expr): Just build a PAREN_EXPR when
kono
parents:
diff changeset
3513 processing_template_decl and EXPR is a SCOPE_REF.
kono
parents:
diff changeset
3514
kono
parents:
diff changeset
3515 2016-03-10 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3516 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3517
kono
parents:
diff changeset
3518 PR c++/70001
kono
parents:
diff changeset
3519 * constexpr.c (cxx_eval_vec_init_1): For pre_init case, reuse
kono
parents:
diff changeset
3520 return value from cxx_eval_constant_expression from earlier
kono
parents:
diff changeset
3521 elements if it is valid constant initializer requiring no
kono
parents:
diff changeset
3522 relocations.
kono
parents:
diff changeset
3523
kono
parents:
diff changeset
3524 2016-03-10 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3525
kono
parents:
diff changeset
3526 PR c++/70153
kono
parents:
diff changeset
3527 * cp-gimplify.c (cp_fold): Handle UNARY_PLUS_EXPR.
kono
parents:
diff changeset
3528
kono
parents:
diff changeset
3529 2016-03-09 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
3530
kono
parents:
diff changeset
3531 * parser.c (cp_parser_oacc_loop): Update cclauses and clauses
kono
parents:
diff changeset
3532 when calling c_finish_omp_clauses.
kono
parents:
diff changeset
3533
kono
parents:
diff changeset
3534 2016-03-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3535
kono
parents:
diff changeset
3536 * parser.c (cp_parser_diagnose_invalid_type_name): Give helpful
kono
parents:
diff changeset
3537 diagnostic for use of "concept".
kono
parents:
diff changeset
3538 (cp_parser_requires_clause_opt): And "requires".
kono
parents:
diff changeset
3539 (cp_parser_type_parameter, cp_parser_late_return_type_opt)
kono
parents:
diff changeset
3540 (cp_parser_explicit_template_declaration): Adjust.
kono
parents:
diff changeset
3541 * Make-lang.in (check-c++-all): Add "concepts" to std list.
kono
parents:
diff changeset
3542
kono
parents:
diff changeset
3543 P0036R0: Unary Folds and Empty Parameter Packs
kono
parents:
diff changeset
3544 * pt.c (expand_empty_fold): Remove special cases for *,+,&,|.
kono
parents:
diff changeset
3545
kono
parents:
diff changeset
3546 2016-03-08 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3547
kono
parents:
diff changeset
3548 PR c++/70135
kono
parents:
diff changeset
3549 * constexpr.c (cxx_eval_loop_expr): Forget saved values of SAVE_EXPRs
kono
parents:
diff changeset
3550 even after the last iteration of the loop.
kono
parents:
diff changeset
3551
kono
parents:
diff changeset
3552 * decl.c (duplicate_decls): Fix spelling - becuase -> because.
kono
parents:
diff changeset
3553
kono
parents:
diff changeset
3554 2016-03-07 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3555
kono
parents:
diff changeset
3556 PR c++/66786
kono
parents:
diff changeset
3557 * pt.c (get_template_info): Handle PARM_DECL.
kono
parents:
diff changeset
3558 (template_class_depth): Check DECL_P instead of
kono
parents:
diff changeset
3559 VAR_OR_FUNCTION_DECL_P.
kono
parents:
diff changeset
3560
kono
parents:
diff changeset
3561 2016-03-05 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3562
kono
parents:
diff changeset
3563 PR c++/67364
kono
parents:
diff changeset
3564 * constexpr.c (cxx_eval_store_expression): Replace
kono
parents:
diff changeset
3565 CONSTRUCTOR_ELTS in nested CONSTRUCTORs, too.
kono
parents:
diff changeset
3566
kono
parents:
diff changeset
3567 2016-03-05 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3568
kono
parents:
diff changeset
3569 PR c++/66786
kono
parents:
diff changeset
3570 * pt.c (template_class_depth): Given a lambda type, iterate
kono
parents:
diff changeset
3571 into its LAMBDA_TYPE_EXTRA_SCOPE field instead of its
kono
parents:
diff changeset
3572 TYPE_CONTEXT. Given a VAR_DECL, iterate into its
kono
parents:
diff changeset
3573 CP_DECL_CONTEXT.
kono
parents:
diff changeset
3574
kono
parents:
diff changeset
3575 2016-03-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3576
kono
parents:
diff changeset
3577 PR c++/69203
kono
parents:
diff changeset
3578 * cp-tree.h (COND_EXPR_IS_VEC_DELETE): New.
kono
parents:
diff changeset
3579 * init.c (build_vec_delete_1): Set it.
kono
parents:
diff changeset
3580 * constexpr.c (potential_constant_expression_1) [COND_EXPR]: Check it.
kono
parents:
diff changeset
3581
kono
parents:
diff changeset
3582 2016-03-04 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3583
kono
parents:
diff changeset
3584 * decl.c (start_preparsed_function): Don't emit start clobber at the
kono
parents:
diff changeset
3585 start of constructor clones.
kono
parents:
diff changeset
3586
kono
parents:
diff changeset
3587 PR c++/70035
kono
parents:
diff changeset
3588 * cp-tree.h (cp_ubsan_maybe_initialize_vtbl_ptrs): New prototype.
kono
parents:
diff changeset
3589 * decl.c (start_preparsed_function): Call
kono
parents:
diff changeset
3590 cp_ubsan_maybe_initialize_vtbl_ptrs if needed.
kono
parents:
diff changeset
3591 * cp-ubsan.c (cp_ubsan_dfs_initialize_vtbl_ptrs,
kono
parents:
diff changeset
3592 cp_ubsan_maybe_initialize_vtbl_ptrs): New functions.
kono
parents:
diff changeset
3593
kono
parents:
diff changeset
3594 2016-03-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3595
kono
parents:
diff changeset
3596 PR c++/67364
kono
parents:
diff changeset
3597 * constexpr.c (cxx_eval_component_reference): Further tweak.
kono
parents:
diff changeset
3598
kono
parents:
diff changeset
3599 * constexpr.c (struct constexpr_ctx): Add save_exprs field.
kono
parents:
diff changeset
3600 (cxx_eval_loop_expr): Discard SAVE_EXPR values before looping.
kono
parents:
diff changeset
3601 (cxx_eval_constant_expression) [SAVE_EXPR]: Add it to the set.
kono
parents:
diff changeset
3602 (cxx_eval_outermost_constant_expr, is_sub_constant_expr): Initialize.
kono
parents:
diff changeset
3603
kono
parents:
diff changeset
3604 PR c++/70067
kono
parents:
diff changeset
3605 * tree.c (strip_typedefs): Handle TYPENAME_TYPE lookup finding the
kono
parents:
diff changeset
3606 same type.
kono
parents:
diff changeset
3607
kono
parents:
diff changeset
3608 2016-03-03 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3609
kono
parents:
diff changeset
3610 * method.c (synthesized_method_walk): operator= can also be constexpr.
kono
parents:
diff changeset
3611
kono
parents:
diff changeset
3612 * pt.c (tsubst_copy_and_build) [LAMBDA_EXPR]: Get
kono
parents:
diff changeset
3613 LAMBDA_EXPR_RETURN_TYPE from the instantiated closure.
kono
parents:
diff changeset
3614
kono
parents:
diff changeset
3615 PR c++/67164
kono
parents:
diff changeset
3616 * pt.c (copy_template_args): New.
kono
parents:
diff changeset
3617 (tsubst_pack_expansion): Use it.
kono
parents:
diff changeset
3618
kono
parents:
diff changeset
3619 * call.c (build_aggr_conv): Use get_nsdmi.
kono
parents:
diff changeset
3620
kono
parents:
diff changeset
3621 PR c++/51406
kono
parents:
diff changeset
3622 * typeck.c (build_static_cast_1): Avoid folding back to lvalue.
kono
parents:
diff changeset
3623
kono
parents:
diff changeset
3624 PR c++/67364
kono
parents:
diff changeset
3625 * constexpr.c (cxx_eval_component_reference): Just return an empty
kono
parents:
diff changeset
3626 CONSTRUCTOR for an empty class.
kono
parents:
diff changeset
3627
kono
parents:
diff changeset
3628 2016-03-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3629
kono
parents:
diff changeset
3630 PR c++/70036
kono
parents:
diff changeset
3631 * parser.c (cp_parser_requires_clause): Call
kono
parents:
diff changeset
3632 check_for_bare_parameter_packs.
kono
parents:
diff changeset
3633
kono
parents:
diff changeset
3634 PR c++/51489
kono
parents:
diff changeset
3635 * constexpr.c (cxx_eval_binary_expression): Don't VERIFY_CONSTANT
kono
parents:
diff changeset
3636 the operands.
kono
parents:
diff changeset
3637
kono
parents:
diff changeset
3638 PR c++/69995
kono
parents:
diff changeset
3639 * constexpr.c (cxx_eval_call_expression): Unshare arg.
kono
parents:
diff changeset
3640 (cxx_eval_constant_expression) [DECL_EXPR]: Unshare init.
kono
parents:
diff changeset
3641 [TARGET_EXPR]: Unshare init.
kono
parents:
diff changeset
3642
kono
parents:
diff changeset
3643 2016-03-01 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3644
kono
parents:
diff changeset
3645 PR c++/68948
kono
parents:
diff changeset
3646 PR c++/69961
kono
parents:
diff changeset
3647 * pt.c (tsubst_baselink): Reinstate the check for an invalid
kono
parents:
diff changeset
3648 constructor call.
kono
parents:
diff changeset
3649
kono
parents:
diff changeset
3650 2016-02-28 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3651
kono
parents:
diff changeset
3652 PR c++/69995
kono
parents:
diff changeset
3653 * constexpr.c (cxx_eval_store_expression): Unshare init.
kono
parents:
diff changeset
3654
kono
parents:
diff changeset
3655 2016-02-26 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3656
kono
parents:
diff changeset
3657 PR c++/69958
kono
parents:
diff changeset
3658 * pt.c (make_argument_pack): New.
kono
parents:
diff changeset
3659 (tsubst_copy) [SIZEOF_EXPR]: Handle partial expansion.
kono
parents:
diff changeset
3660 (tsubst_copy_and_build): Likewise.
kono
parents:
diff changeset
3661
kono
parents:
diff changeset
3662 2016-02-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3663
kono
parents:
diff changeset
3664 PR c++/69889
kono
parents:
diff changeset
3665 * cp-tree.h (AGGR_INIT_FROM_THUNK_P): New.
kono
parents:
diff changeset
3666 * tree.c (build_aggr_init_expr): Set it.
kono
parents:
diff changeset
3667 * semantics.c (simplify_aggr_init_expr): Check it.
kono
parents:
diff changeset
3668 * cp-gimplify.c (cp_genericize_r): Don't walk into
kono
parents:
diff changeset
3669 a call/aggr_init from a thunk.
kono
parents:
diff changeset
3670
kono
parents:
diff changeset
3671 PR c++/69842
kono
parents:
diff changeset
3672 * method.c (forward_parm): Handle parameter packs.
kono
parents:
diff changeset
3673 * lambda.c (maybe_add_lambda_conv_op): Use it for them.
kono
parents:
diff changeset
3674
kono
parents:
diff changeset
3675 PR c++/67364
kono
parents:
diff changeset
3676 * constexpr.c (cxx_eval_component_reference): Don't complain about
kono
parents:
diff changeset
3677 unevaluated empty classes.
kono
parents:
diff changeset
3678
kono
parents:
diff changeset
3679 PR c++/68049
kono
parents:
diff changeset
3680 * tree.c (strip_typedefs): Use DECL_ORIGINAL_TYPE.
kono
parents:
diff changeset
3681
kono
parents:
diff changeset
3682 2016-02-25 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3683
kono
parents:
diff changeset
3684 PR c++/69736
kono
parents:
diff changeset
3685 * cp-tree.h (REF_PARENTHESIZED_P): Adjust documentation.
kono
parents:
diff changeset
3686 (maybe_undo_parenthesized_ref): Declare.
kono
parents:
diff changeset
3687 * semantics.c (maybe_undo_parenthesized_ref): Split out from
kono
parents:
diff changeset
3688 check_return_expr.
kono
parents:
diff changeset
3689 (finish_call_expr): Use it.
kono
parents:
diff changeset
3690 * typeck.c (check_return_expr): Use it.
kono
parents:
diff changeset
3691 * pt.c (tsubst_copy_and_build) [INDIRECT_REF]: Retain the
kono
parents:
diff changeset
3692 REF_PARENTHESIZED_P flag.
kono
parents:
diff changeset
3693
kono
parents:
diff changeset
3694 2016-02-24 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3695
kono
parents:
diff changeset
3696 PR c++/69922
kono
parents:
diff changeset
3697 * class.c (build_base_path): Set TREE_NO_WARNING on the null_test.
kono
parents:
diff changeset
3698 Avoid folding it.
kono
parents:
diff changeset
3699 * init.c (build_vec_delete_1, build_delete): Don't fold the non-NULL
kono
parents:
diff changeset
3700 tests.
kono
parents:
diff changeset
3701 * cp-gimplify.c (cp_fold): For TREE_NO_WARNING comparisons with NULL,
kono
parents:
diff changeset
3702 unless they are folded into INTEGER_CST, error_mark_node or some
kono
parents:
diff changeset
3703 comparison with NULL, avoid folding them and use either the original
kono
parents:
diff changeset
3704 comparison or non-folded comparison of folded arguments.
kono
parents:
diff changeset
3705 * cp-ubsan.c (cp_ubsan_instrument_vptr): Set TREE_NO_WARNING on the
kono
parents:
diff changeset
3706 comparison, don't fold the comparison right away.
kono
parents:
diff changeset
3707
kono
parents:
diff changeset
3708 2016-02-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3709
kono
parents:
diff changeset
3710 PR c++/69323
kono
parents:
diff changeset
3711 * friend.c (make_friend_class): Likewise.
kono
parents:
diff changeset
3712 * decl.c (lookup_and_check_tag): Diagnose invalid dependent friend.
kono
parents:
diff changeset
3713
kono
parents:
diff changeset
3714 2016-02-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3715
kono
parents:
diff changeset
3716 PR c++/69323
kono
parents:
diff changeset
3717 * pt.c (instantiate_class_template_1): Set
kono
parents:
diff changeset
3718 processing_template_decl before substituting friend_type.
kono
parents:
diff changeset
3719
kono
parents:
diff changeset
3720 016-02-24 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
3721
kono
parents:
diff changeset
3722 PR c++/69912
kono
parents:
diff changeset
3723 * tree.c (build_ctor_subob_ref): Compare types' main variants
kono
parents:
diff changeset
3724 instead of the types as they are.
kono
parents:
diff changeset
3725
kono
parents:
diff changeset
3726 2016-02-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3727
kono
parents:
diff changeset
3728 * decl.c (start_preparsed_function): Condition ctor clobber on
kono
parents:
diff changeset
3729 flag_lifetime_dse > 1.
kono
parents:
diff changeset
3730
kono
parents:
diff changeset
3731 * cp-gimplify.c (cp_fold): Don't fold constexpr calls if -fno-inline.
kono
parents:
diff changeset
3732
kono
parents:
diff changeset
3733 2016-02-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3734
kono
parents:
diff changeset
3735 PR c++/69743
kono
parents:
diff changeset
3736 * call.c (remaining_arguments): No longer static.
kono
parents:
diff changeset
3737 * cp-tree.h: Declare it.
kono
parents:
diff changeset
3738 * pt.c (more_specialized_fn): Use it.
kono
parents:
diff changeset
3739
kono
parents:
diff changeset
3740 2016-02-19 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3741 Bernd Edlinger <bernd.edlinger@hotmail.de>
kono
parents:
diff changeset
3742
kono
parents:
diff changeset
3743 * Make-lang.in: Invoke gperf with -L C++.
kono
parents:
diff changeset
3744 * cfns.gperf: Remove prototypes for hash and libc_name_p
kono
parents:
diff changeset
3745 inlines.
kono
parents:
diff changeset
3746 * cfns.h: Regenerated.
kono
parents:
diff changeset
3747 * except.c (nothrow_libfn_p): Adjust.
kono
parents:
diff changeset
3748
kono
parents:
diff changeset
3749 2016-02-19 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3750
kono
parents:
diff changeset
3751 PR c++/69850
kono
parents:
diff changeset
3752 * rtti.c (ifnonnull): Set TREE_NO_WARNING on the condition, use
kono
parents:
diff changeset
3753 NE_EXPR instead of EQ_EXPR and swap last two arguments on COND_EXPR.
kono
parents:
diff changeset
3754
kono
parents:
diff changeset
3755 2016-02-19 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3756
kono
parents:
diff changeset
3757 PR c++/68948
kono
parents:
diff changeset
3758 * pt.c (tsubst_baselink): Don't diagnose an invalid constructor
kono
parents:
diff changeset
3759 call here.
kono
parents:
diff changeset
3760 * semantics.c (finish_call_expr): Don't assume a constructor
kono
parents:
diff changeset
3761 call is dependent if only the "this" pointer is dependent. When
kono
parents:
diff changeset
3762 building a constructor call, always use a dummy object.
kono
parents:
diff changeset
3763
kono
parents:
diff changeset
3764 2016-02-19 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3765
kono
parents:
diff changeset
3766 PR c++/69850
kono
parents:
diff changeset
3767 * init.c (build_vec_delete_1): Set TREE_NO_WARNING on the NE_EXPR
kono
parents:
diff changeset
3768 condition.
kono
parents:
diff changeset
3769 * cp-gimplify.c (cp_fold): Propagate TREE_NO_WARNING from binary
kono
parents:
diff changeset
3770 operators if folding preserved the binop, just with different
kono
parents:
diff changeset
3771 arguments.
kono
parents:
diff changeset
3772
kono
parents:
diff changeset
3773 PR c++/67767
kono
parents:
diff changeset
3774 * parser.c (cp_parser_std_attribute_spec_seq): Don't assume
kono
parents:
diff changeset
3775 attr_spec is always single element chain, chain all the attributes
kono
parents:
diff changeset
3776 properly together in the right order.
kono
parents:
diff changeset
3777
kono
parents:
diff changeset
3778 2016-02-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3779
kono
parents:
diff changeset
3780 * mangle.c (maybe_check_abi_tags): Add for_decl parm. Call
kono
parents:
diff changeset
3781 mangle_decl.
kono
parents:
diff changeset
3782 (mangle_decl): Call maybe_check_abi_tags for function scope.
kono
parents:
diff changeset
3783 (mangle_guard_variable): Call maybe_check_abi_tags here.
kono
parents:
diff changeset
3784 (write_guarded_var_name): Not here.
kono
parents:
diff changeset
3785
kono
parents:
diff changeset
3786 2016-02-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3787
kono
parents:
diff changeset
3788 PR c++/65985
kono
parents:
diff changeset
3789 * constexpr.c (build_constexpr_constructor_member_initializers):
kono
parents:
diff changeset
3790 Handle an additional STATEMENT_LIST.
kono
parents:
diff changeset
3791
kono
parents:
diff changeset
3792 PR c++/68585
kono
parents:
diff changeset
3793 * constexpr.c (cxx_eval_bare_aggregate): Fix 'changed' detection.
kono
parents:
diff changeset
3794
kono
parents:
diff changeset
3795 PR c++/68679
kono
parents:
diff changeset
3796 * decl2.c (reset_type_linkage_2): Look through member templates.
kono
parents:
diff changeset
3797
kono
parents:
diff changeset
3798 2016-02-17 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3799
kono
parents:
diff changeset
3800 PR c++/69850
kono
parents:
diff changeset
3801 * init.c (build_delete): Set TREE_NO_WARNING on ifexp.
kono
parents:
diff changeset
3802
kono
parents:
diff changeset
3803 2016-02-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3804
kono
parents:
diff changeset
3805 PR c++/69842
kono
parents:
diff changeset
3806 * method.c (forward_parm): Split out from...
kono
parents:
diff changeset
3807 (add_one_base_init): ...here.
kono
parents:
diff changeset
3808 * lambda.c (maybe_add_lambda_conv_op): Use it.
kono
parents:
diff changeset
3809
kono
parents:
diff changeset
3810 2016-02-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3811
kono
parents:
diff changeset
3812 PR c++/10200
kono
parents:
diff changeset
3813 PR c++/69753
kono
parents:
diff changeset
3814 * call.c, cp-tree.h, name-lookup.c, pt.c, search.c, semantics.c,
kono
parents:
diff changeset
3815 tree.c, typeck2.c: Revert earlier changes.
kono
parents:
diff changeset
3816 * parser.c (cp_parser_lookup_name): Ignore namespace-scope
kono
parents:
diff changeset
3817 non-type templates after -> or .
kono
parents:
diff changeset
3818
kono
parents:
diff changeset
3819 2016-02-16 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3820
kono
parents:
diff changeset
3821 PR c/69835
kono
parents:
diff changeset
3822 * typeck.c (cp_build_binary_op): Revert 2015-09-09 change.
kono
parents:
diff changeset
3823
kono
parents:
diff changeset
3824 2016-02-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3825
kono
parents:
diff changeset
3826 PR c++/69657
kono
parents:
diff changeset
3827 * name-lookup.c (lookup_qualified_name): Add find_hidden parm.
kono
parents:
diff changeset
3828 (set_decl_namespace): Pass it. Complain about finding a hidden friend.
kono
parents:
diff changeset
3829 * name-lookup.h: Adjust.
kono
parents:
diff changeset
3830
kono
parents:
diff changeset
3831 2016-02-16 James Norris <jnorris@codesourcery.com>
kono
parents:
diff changeset
3832
kono
parents:
diff changeset
3833 * parser.c (cp_parser_oacc_data_clause_deviceptr): Remove checking.
kono
parents:
diff changeset
3834 * semantics.c (finish_omp_clauses): Add deviceptr checking.
kono
parents:
diff changeset
3835
kono
parents:
diff changeset
3836 2016-02-15 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3837
kono
parents:
diff changeset
3838 PR c++/69658
kono
parents:
diff changeset
3839 * init.c (expand_default_init): Only call reshape_init
kono
parents:
diff changeset
3840 in the direct-initialization from an initializer list case.
kono
parents:
diff changeset
3841
kono
parents:
diff changeset
3842 2016-02-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3843
kono
parents:
diff changeset
3844 PR c++/69753
kono
parents:
diff changeset
3845 * semantics.c (finish_call_expr): Implicit 'this' does not make
kono
parents:
diff changeset
3846 the call dependent.
kono
parents:
diff changeset
3847 * search.c (any_dependent_bases_p): Split out...
kono
parents:
diff changeset
3848 * name-lookup.c (do_class_using_decl): ...from here.
kono
parents:
diff changeset
3849 * call.c (build_new_method_call_1): Don't complain about missing object
kono
parents:
diff changeset
3850 if there are dependent bases. Tweak error.
kono
parents:
diff changeset
3851 * tree.c (non_static_member_function_p): Remove.
kono
parents:
diff changeset
3852 * pt.c (type_dependent_expression_p): A member template of a
kono
parents:
diff changeset
3853 dependent type is dependent.
kono
parents:
diff changeset
3854 * cp-tree.h: Adjust.
kono
parents:
diff changeset
3855
kono
parents:
diff changeset
3856 PR c++/68890
kono
parents:
diff changeset
3857 * constexpr.c (verify_ctor_sanity): Remove CONSTRUCTOR_NELTS check.
kono
parents:
diff changeset
3858
kono
parents:
diff changeset
3859 2016-02-12 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3860
kono
parents:
diff changeset
3861 PR c++/69098
kono
parents:
diff changeset
3862 * pt.c (lookup_and_finish_template_variable): New function,
kono
parents:
diff changeset
3863 extracted from ...
kono
parents:
diff changeset
3864 (tsubst_copy_and_build) [TEMPLATE_ID_EXPR]: ... here. Use it.
kono
parents:
diff changeset
3865 (tsubst_qualified_id): Consider that EXPR might be a variable
kono
parents:
diff changeset
3866 template.
kono
parents:
diff changeset
3867 * typeck.c (check_template_keyword): Don't emit an error
kono
parents:
diff changeset
3868 if DECL is a variable template.
kono
parents:
diff changeset
3869
kono
parents:
diff changeset
3870 2016-02-12 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3871
kono
parents:
diff changeset
3872 * error.c: Spelling fixes - behaviour -> behavior and
kono
parents:
diff changeset
3873 neighbour -> neighbor.
kono
parents:
diff changeset
3874 * decl.c: Likewise.
kono
parents:
diff changeset
3875 * typeck.c (cp_build_binary_op): Fix up behavior spelling in
kono
parents:
diff changeset
3876 diagnostics.
kono
parents:
diff changeset
3877 * init.c (build_delete): Likewise.
kono
parents:
diff changeset
3878
kono
parents:
diff changeset
3879 2016-02-11 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3880
kono
parents:
diff changeset
3881 PR c/69768
kono
parents:
diff changeset
3882 * typeck.c (cp_build_binary_op): cp_fully_fold integer_zerop
kono
parents:
diff changeset
3883 arguments for -Waddress warning. Fix up formatting.
kono
parents:
diff changeset
3884
kono
parents:
diff changeset
3885 2016-02-11 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3886
kono
parents:
diff changeset
3887 PR c++/68726
kono
parents:
diff changeset
3888 * pt.c (lookup_template_class_1): Check tsubst return value for
kono
parents:
diff changeset
3889 error_mark_node.
kono
parents:
diff changeset
3890
kono
parents:
diff changeset
3891 2016-02-10 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3892
kono
parents:
diff changeset
3893 PR c++/68926
kono
parents:
diff changeset
3894 * pt.c (resolve_nondeduced_context): Add complain parm.
kono
parents:
diff changeset
3895 (do_auto_deduction): Pass it.
kono
parents:
diff changeset
3896 * cvt.c (convert_to_void): Likewise.
kono
parents:
diff changeset
3897 * decl.c (cp_finish_decl): Likewise.
kono
parents:
diff changeset
3898 * init.c (build_new): Likewise.
kono
parents:
diff changeset
3899 * rtti.c (get_tinfo_decl_dynamic): Likewise.
kono
parents:
diff changeset
3900 * semantics.c (finish_decltype_type): Likewise.
kono
parents:
diff changeset
3901 * typeck.c (decay_conversion): Likewise.
kono
parents:
diff changeset
3902 * cp-tree.h: Adjust declaration.
kono
parents:
diff changeset
3903 * call.c (standard_conversion): Add complain parm, pass it along.
kono
parents:
diff changeset
3904 (implicit_conversion): Pass it.
kono
parents:
diff changeset
3905
kono
parents:
diff changeset
3906 PR c++/69657
kono
parents:
diff changeset
3907 * name-lookup.c (ambiguous_decl): Call remove_hidden_names.
kono
parents:
diff changeset
3908 (lookup_name_real_1): Likewise.
kono
parents:
diff changeset
3909 (remove_hidden_names): Handle non-functions too.
kono
parents:
diff changeset
3910
kono
parents:
diff changeset
3911 PR c++/10200
kono
parents:
diff changeset
3912 * parser.c (cp_parser_lookup_name): When looking for a template
kono
parents:
diff changeset
3913 after . or ->, only consider class templates.
kono
parents:
diff changeset
3914 (cp_parser_postfix_dot_deref_expression): Handle the current
kono
parents:
diff changeset
3915 instantiation. Remember a dependent object expression.
kono
parents:
diff changeset
3916 * typeck2.c (build_x_arrow): Handle the current instantiation.
kono
parents:
diff changeset
3917
kono
parents:
diff changeset
3918 * ptree.c (debug_tree): Implement for cp_expr.
kono
parents:
diff changeset
3919
kono
parents:
diff changeset
3920 2016-02-08 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3921
kono
parents:
diff changeset
3922 PR c++/69139
kono
parents:
diff changeset
3923 * parser.c (cp_parser_simple_type_specifier): Make the check
kono
parents:
diff changeset
3924 for disambiguating between an 'auto' placeholder and an implicit
kono
parents:
diff changeset
3925 template parameter more robust.
kono
parents:
diff changeset
3926
kono
parents:
diff changeset
3927 2016-02-08 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3928
kono
parents:
diff changeset
3929 PR c++/69283
kono
parents:
diff changeset
3930 PR c++/67835
kono
parents:
diff changeset
3931 * decl2.c (mark_used): When given a TEMPLATE_DECL, return after
kono
parents:
diff changeset
3932 setting its TREE_USED flag.
kono
parents:
diff changeset
3933
kono
parents:
diff changeset
3934 2016-02-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3935
kono
parents:
diff changeset
3936 PR c++/69657
kono
parents:
diff changeset
3937 * name-lookup.c (do_nonmember_using_decl): Leave anticipated
kono
parents:
diff changeset
3938 built-ins alone.
kono
parents:
diff changeset
3939
kono
parents:
diff changeset
3940 2016-02-08 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3941
kono
parents:
diff changeset
3942 PR c++/59627
kono
parents:
diff changeset
3943 * parser.c (cp_parser_omp_declare_reduction): Set assembler name
kono
parents:
diff changeset
3944 of the DECL_OMP_DECLARE_REDUCTION_P decls.
kono
parents:
diff changeset
3945
kono
parents:
diff changeset
3946 2016-02-08 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3947
kono
parents:
diff changeset
3948 PR c++/69688
kono
parents:
diff changeset
3949 * constexpr.c (clear_cv_and_fold_caches): Renamed from clear_cv_cache.
kono
parents:
diff changeset
3950 Call clear_fold_cache.
kono
parents:
diff changeset
3951 * cp-tree.h: Adjust declaration.
kono
parents:
diff changeset
3952 * decl.c (finish_enum_value_list): Call clear_cv_and_fold_caches
kono
parents:
diff changeset
3953 rather than clear_cv_cache and clear_fold_cache.
kono
parents:
diff changeset
3954 * typeck2.c (store_init_value): Call clear_cv_and_fold_caches.
kono
parents:
diff changeset
3955
kono
parents:
diff changeset
3956 2016-02-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3957
kono
parents:
diff changeset
3958 * cp-tree.h (CONV_FOLD, CONV_BACKEND_CONVERT): New.
kono
parents:
diff changeset
3959 * cvt.c (convert): Pass CONV_BACKEND_CONVERT.
kono
parents:
diff changeset
3960 (ocp_convert): Use *_maybe_fold.
kono
parents:
diff changeset
3961 (cp_convert_to_pointer): Add dofold parameter.
kono
parents:
diff changeset
3962 * cp-gimplify.c (cp_fold) [CONVERT_EXPR]: Call convert.
kono
parents:
diff changeset
3963
kono
parents:
diff changeset
3964 2016-02-05 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
3965
kono
parents:
diff changeset
3966 PR c++/69662
kono
parents:
diff changeset
3967 * init.c (find_field_init): New function.
kono
parents:
diff changeset
3968 (warn_placement_new_too_small): Call it. Handle one-element arrays
kono
parents:
diff changeset
3969 at ends of structures special.
kono
parents:
diff changeset
3970
kono
parents:
diff changeset
3971 2016-02-05 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3972
kono
parents:
diff changeset
3973 PR c++/68948
kono
parents:
diff changeset
3974 * semantics.c (finish_expr_stmt): If expr is error_mark_node,
kono
parents:
diff changeset
3975 make sure we've seen_error().
kono
parents:
diff changeset
3976
kono
parents:
diff changeset
3977 2016-02-05 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3978
kono
parents:
diff changeset
3979 PR c++/68948
kono
parents:
diff changeset
3980 * pt.c (tsubst_baselink): Diagnose an invalid constructor call
kono
parents:
diff changeset
3981 if lookup_fnfields returns NULL_TREE and the name being looked
kono
parents:
diff changeset
3982 up has the form A::A.
kono
parents:
diff changeset
3983
kono
parents:
diff changeset
3984 2016-02-04 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
3985
kono
parents:
diff changeset
3986 * constexpr.c (cxx_eval_binary_expression): Fold equality
kono
parents:
diff changeset
3987 comparisons involving PTRMEM_CSTs.
kono
parents:
diff changeset
3988
kono
parents:
diff changeset
3989 2016-02-04 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3990
kono
parents:
diff changeset
3991 * class.c (find_flexarrays): Don't declare dom variable.
kono
parents:
diff changeset
3992 (diagnose_flexarray): Likewise.
kono
parents:
diff changeset
3993
kono
parents:
diff changeset
3994 2016-02-02 Martain Sebor <msebor@redhat.com>
kono
parents:
diff changeset
3995
kono
parents:
diff changeset
3996 PR c++/69251
kono
parents:
diff changeset
3997 PR c++/69253
kono
parents:
diff changeset
3998 PR c++/69290
kono
parents:
diff changeset
3999 PR c++/69277
kono
parents:
diff changeset
4000 PR c++/69349
kono
parents:
diff changeset
4001 * class.c (walk_subobject_offsets): Avoid testing the upper bound
kono
parents:
diff changeset
4002 of a flexible array member for equality to null.
kono
parents:
diff changeset
4003 (find_flexarrays): Remove spurious whitespace introduced in r231665.
kono
parents:
diff changeset
4004 (diagnose_flexarrays): Avoid checking the upper bound of arrays.
kono
parents:
diff changeset
4005 (check_flexarrays): Same.
kono
parents:
diff changeset
4006 * decl.c (compute_array_index_type): Avoid special case for flexible
kono
parents:
diff changeset
4007 array members.
kono
parents:
diff changeset
4008 (grokdeclarator): Avoid calling compute_array_index_type for flexible
kono
parents:
diff changeset
4009 array members.
kono
parents:
diff changeset
4010 * error.c (dump_type_suffix): Revert changes introduced in r231665
kono
parents:
diff changeset
4011 and rendered unnecessary by the changes above.
kono
parents:
diff changeset
4012 * pt.c (tsubst): Same.
kono
parents:
diff changeset
4013 * tree.c (build_ctor_subob_ref): Handle flexible array members.
kono
parents:
diff changeset
4014 * typeck2.c (digest_init_r): Revert changes introduced in r231665.
kono
parents:
diff changeset
4015 (process_init_constructor_array): Same.
kono
parents:
diff changeset
4016 (process_init_constructor_record): Same.
kono
parents:
diff changeset
4017
kono
parents:
diff changeset
4018 2016-02-03 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
4019
kono
parents:
diff changeset
4020 PR c++/69056
kono
parents:
diff changeset
4021 * pt.c (try_one_overload): Handle comparing argument packs so
kono
parents:
diff changeset
4022 that there is no conflict if we deduced more arguments of an
kono
parents:
diff changeset
4023 argument pack than were explicitly specified.
kono
parents:
diff changeset
4024
kono
parents:
diff changeset
4025 2016-01-31 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
4026 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4027
kono
parents:
diff changeset
4028 PR c++/68763
kono
parents:
diff changeset
4029 * tree.c (strip_typedefs) [FUNCTION_TYPE]: Avoid building a new
kono
parents:
diff changeset
4030 function type if nothing is changing.
kono
parents:
diff changeset
4031
kono
parents:
diff changeset
4032 2016-01-31 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4033
kono
parents:
diff changeset
4034 PR c++/69009
kono
parents:
diff changeset
4035 * pt.c (partial_specialization_p, impartial_args): New.
kono
parents:
diff changeset
4036 (instantiate_decl): Call impartial_args.
kono
parents:
diff changeset
4037
kono
parents:
diff changeset
4038 * mangle.c (maybe_check_abi_tags): New.
kono
parents:
diff changeset
4039 (write_guarded_var_name): Call it.
kono
parents:
diff changeset
4040 (mangle_ref_init_variable): Call check_abi_tags.
kono
parents:
diff changeset
4041
kono
parents:
diff changeset
4042 * pt.c (lookup_template_class_1): Don't share TYPE_ATTRIBUTES
kono
parents:
diff changeset
4043 between template and instantiation.
kono
parents:
diff changeset
4044
kono
parents:
diff changeset
4045 2016-01-29 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
4046
kono
parents:
diff changeset
4047 PR debug/66869
kono
parents:
diff changeset
4048 * decl.c (wrapup_globals_for_namespace): Warn about unused static
kono
parents:
diff changeset
4049 function declarations.
kono
parents:
diff changeset
4050
kono
parents:
diff changeset
4051 2016-01-29 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
4052
kono
parents:
diff changeset
4053 PR c++/69509
kono
parents:
diff changeset
4054 PR c++/69516
kono
parents:
diff changeset
4055 * constexpr.c (cxx_eval_array_reference): Give the "array subscript
kono
parents:
diff changeset
4056 out of bound" error earlier.
kono
parents:
diff changeset
4057 * init.c (build_vec_init): Change NE_EXPR into GT_EXPR. Update the
kono
parents:
diff changeset
4058 commentary.
kono
parents:
diff changeset
4059
kono
parents:
diff changeset
4060 2016-01-29 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
4061
kono
parents:
diff changeset
4062 * name-lookup.c (begin_scope): After reusing a cp_binding_level
kono
parents:
diff changeset
4063 structure, update free_binding_level before the structure's
kono
parents:
diff changeset
4064 level_chain field gets cleared, not after.
kono
parents:
diff changeset
4065
kono
parents:
diff changeset
4066 2016-01-28 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4067
kono
parents:
diff changeset
4068 PR c++/67407
kono
parents:
diff changeset
4069 * search.c (dfs_walk_once, dfs_walk_once_r)
kono
parents:
diff changeset
4070 (dfs_walk_once_accessible_r, dfs_walk_once_accessible): Use
kono
parents:
diff changeset
4071 hash_set instead of BINFO_MARKED.
kono
parents:
diff changeset
4072 (dfs_unmark_r): Remove.
kono
parents:
diff changeset
4073
kono
parents:
diff changeset
4074 2016-01-28 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
4075
kono
parents:
diff changeset
4076 PR c++/24208
kono
parents:
diff changeset
4077 * parser.c (LEXER_DEBUGGING_ENABLED_P): New macro.
kono
parents:
diff changeset
4078 (cp_lexer_debugging_p): Use it.
kono
parents:
diff changeset
4079 (cp_lexer_start_debugging): Likewise.
kono
parents:
diff changeset
4080 (cp_lexer_stop_debugging): Likewise.
kono
parents:
diff changeset
4081
kono
parents:
diff changeset
4082 2016-01-27 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
4083
kono
parents:
diff changeset
4084 PR c/68062
kono
parents:
diff changeset
4085 * typeck.c (cp_build_binary_op): Promote operand to unsigned, if
kono
parents:
diff changeset
4086 needed. Add -Wsign-compare warning.
kono
parents:
diff changeset
4087
kono
parents:
diff changeset
4088 2016-01-27 Ryan Burn <contact@rnburn.com>
kono
parents:
diff changeset
4089
kono
parents:
diff changeset
4090 PR cilkplus/69267
kono
parents:
diff changeset
4091 * cp-gimplify.c (cilk_cp_gimplify_call_params_in_spawned_fn): Removed
kono
parents:
diff changeset
4092 superfluous post_p argument in call to
kono
parents:
diff changeset
4093 cilk_gimplify_call_params_in_spawned_fn.
kono
parents:
diff changeset
4094
kono
parents:
diff changeset
4095 2016-01-27 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
4096
kono
parents:
diff changeset
4097 PR c++/69379
kono
parents:
diff changeset
4098 * constexpr.c (cxx_eval_constant_expression): Handle PTRMEM_CSTs
kono
parents:
diff changeset
4099 wrapped in NOP_EXPRs.
kono
parents:
diff changeset
4100
kono
parents:
diff changeset
4101 2016-01-27 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
4102
kono
parents:
diff changeset
4103 PR c++/69317
kono
parents:
diff changeset
4104 * mangle.c (mangle_decl): Reference the correct (saved) version
kono
parents:
diff changeset
4105 of the ABI in -Wabi diagnostics.
kono
parents:
diff changeset
4106
kono
parents:
diff changeset
4107 2016-01-27 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
4108
kono
parents:
diff changeset
4109 PR c++/69496
kono
parents:
diff changeset
4110 * constexpr.c (cxx_eval_array_reference): Evaluate the number of
kono
parents:
diff changeset
4111 elements of the array.
kono
parents:
diff changeset
4112
kono
parents:
diff changeset
4113 2016-01-26 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4114
kono
parents:
diff changeset
4115 PR c++/68949
kono
parents:
diff changeset
4116 * constexpr.c (register_constexpr_fundef): Keep the un-massaged body.
kono
parents:
diff changeset
4117 (cxx_eval_call_expression): Don't look through clones.
kono
parents:
diff changeset
4118 * optimize.c (maybe_clone_body): Clear DECL_SAVED_TREE of the alias.
kono
parents:
diff changeset
4119 * semantics.c (expand_or_defer_fn_1): Keep DECL_SAVED_TREE of
kono
parents:
diff changeset
4120 maybe-in-charge *tor.
kono
parents:
diff changeset
4121
kono
parents:
diff changeset
4122 2016-01-26 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4123
kono
parents:
diff changeset
4124 PR c++/68782
kono
parents:
diff changeset
4125 * constexpr.c (cxx_eval_bare_aggregate): Update TREE_CONSTANT
kono
parents:
diff changeset
4126 and TREE_SIDE_EFFECTS.
kono
parents:
diff changeset
4127 (cxx_eval_constant_expression) [CONSTRUCTOR]: Call
kono
parents:
diff changeset
4128 verify_constructor_flags.
kono
parents:
diff changeset
4129
kono
parents:
diff changeset
4130 2016-01-26 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
4131
kono
parents:
diff changeset
4132 PR c++/68357
kono
parents:
diff changeset
4133 * cp-gimplify.c (cp_fold): If some operand folds to error_mark_node,
kono
parents:
diff changeset
4134 return error_mark_node instead of building trees with error_mark_node
kono
parents:
diff changeset
4135 operands.
kono
parents:
diff changeset
4136
kono
parents:
diff changeset
4137 2016-01-26 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
4138
kono
parents:
diff changeset
4139 PR other/69006
kono
parents:
diff changeset
4140 * error.c (print_instantiation_partial_context_line): Add missing
kono
parents:
diff changeset
4141 newlines from output for the t == NULL case.
kono
parents:
diff changeset
4142 (print_instantiation_partial_context): Remove call to pp_newline.
kono
parents:
diff changeset
4143
kono
parents:
diff changeset
4144 2016-01-24 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
4145
kono
parents:
diff changeset
4146 Revert:
kono
parents:
diff changeset
4147 2016-01-18 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
4148
kono
parents:
diff changeset
4149 PR c++/11858
kono
parents:
diff changeset
4150 PR c++/24663
kono
parents:
diff changeset
4151 PR c++/24664
kono
parents:
diff changeset
4152 * decl.c (grokdeclarator): Don't decay array parameter type to
kono
parents:
diff changeset
4153 a pointer type if it's dependent.
kono
parents:
diff changeset
4154 (grokparms): Invoke strip_top_quals instead of directly invoking
kono
parents:
diff changeset
4155 cp_build_qualified_type.
kono
parents:
diff changeset
4156 * pt.c (decay_dependent_array_parm_type): New static function.
kono
parents:
diff changeset
4157 (type_unification_real): Call decay_dependent_array_parm_type
kono
parents:
diff changeset
4158 to decay a dependent array parameter type to its corresponding
kono
parents:
diff changeset
4159 pointer type before unification.
kono
parents:
diff changeset
4160 (more_specialized_fn): Likewise.
kono
parents:
diff changeset
4161 (get_bindings): Likewise.
kono
parents:
diff changeset
4162 * tree.c (cp_build_qualified_type): Trivial typofix in
kono
parents:
diff changeset
4163 documentation.
kono
parents:
diff changeset
4164
kono
parents:
diff changeset
4165 2016-01-23 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
4166
kono
parents:
diff changeset
4167 PR c++/58109
kono
parents:
diff changeset
4168 PR c++/69022
kono
parents:
diff changeset
4169 * decl2.c (is_late_template_attribute): Handle dependent argument
kono
parents:
diff changeset
4170 to attribute align and attribute vector_size.
kono
parents:
diff changeset
4171
kono
parents:
diff changeset
4172 2016-01-21 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4173
kono
parents:
diff changeset
4174 PR c++/69392
kono
parents:
diff changeset
4175 * lambda.c (lambda_capture_field_type): Handle 'this' specially
kono
parents:
diff changeset
4176 for init-capture, too.
kono
parents:
diff changeset
4177
kono
parents:
diff changeset
4178 PR c++/65687
kono
parents:
diff changeset
4179 * decl.c (type_is_deprecated): Don't look into a typedef.
kono
parents:
diff changeset
4180
kono
parents:
diff changeset
4181 PR c++/40751
kono
parents:
diff changeset
4182 PR c++/64987
kono
parents:
diff changeset
4183 * decl.c (copy_type_enum): Respect TYPE_USER_ALIGN.
kono
parents:
diff changeset
4184
kono
parents:
diff changeset
4185 PR c++/43407
kono
parents:
diff changeset
4186 * decl.c (start_enum): Add attributes parameter.
kono
parents:
diff changeset
4187 * parser.c (cp_parser_enum_specifier): Pass it.
kono
parents:
diff changeset
4188 * pt.c (lookup_template_class_1): Pass it.
kono
parents:
diff changeset
4189 * cp-tree.h: Adjust.
kono
parents:
diff changeset
4190
kono
parents:
diff changeset
4191 2016-01-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4192
kono
parents:
diff changeset
4193 PR c++/59759
kono
parents:
diff changeset
4194 * pt.c (convert_template_argument): Handle VAR_DECL properly.
kono
parents:
diff changeset
4195
kono
parents:
diff changeset
4196 2016-01-19 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
4197
kono
parents:
diff changeset
4198 PR c++/68586
kono
parents:
diff changeset
4199 * constexpr.c (clear_cv_cache): New.
kono
parents:
diff changeset
4200 * cp-gimplify.c (clear_fold_cache): New.
kono
parents:
diff changeset
4201 * cp-tree.h (clear_cv_cache, clear_fold_cache): Declare.
kono
parents:
diff changeset
4202 * decl.c (finish_enum_value_list): Call them.
kono
parents:
diff changeset
4203
kono
parents:
diff changeset
4204 PR c++/68965
kono
parents:
diff changeset
4205 * pt.c (tsubst_copy): Mark elements in expanded vector as used.
kono
parents:
diff changeset
4206
kono
parents:
diff changeset
4207 2016-01-18 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
4208
kono
parents:
diff changeset
4209 PR c++/11858
kono
parents:
diff changeset
4210 PR c++/24663
kono
parents:
diff changeset
4211 PR c++/24664
kono
parents:
diff changeset
4212 * decl.c (grokdeclarator): Don't decay array parameter type to
kono
parents:
diff changeset
4213 a pointer type if it's dependent.
kono
parents:
diff changeset
4214 (grokparms): Invoke strip_top_quals instead of directly invoking
kono
parents:
diff changeset
4215 cp_build_qualified_type.
kono
parents:
diff changeset
4216 * pt.c (decay_dependent_array_parm_type): New static function.
kono
parents:
diff changeset
4217 (type_unification_real): Call decay_dependent_array_parm_type
kono
parents:
diff changeset
4218 to decay a dependent array parameter type to its corresponding
kono
parents:
diff changeset
4219 pointer type before unification.
kono
parents:
diff changeset
4220 (more_specialized_fn): Likewise.
kono
parents:
diff changeset
4221 (get_bindings): Likewise.
kono
parents:
diff changeset
4222 * tree.c (cp_build_qualified_type): Trivial typofix in
kono
parents:
diff changeset
4223 documentation.
kono
parents:
diff changeset
4224
kono
parents:
diff changeset
4225 2016-01-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4226
kono
parents:
diff changeset
4227 * cp-gimplify.c (cp_fold) [CONSTRUCTOR]: Don't clobber the input.
kono
parents:
diff changeset
4228
kono
parents:
diff changeset
4229 * cp-gimplify.c (cp_fold): Remove unnecessary special cases.
kono
parents:
diff changeset
4230
kono
parents:
diff changeset
4231 PR c++/68767
kono
parents:
diff changeset
4232 * cp-gimplify.c (cp_fold) [COND_EXPR]: Simplify. Do fold COND_EXPR.
kono
parents:
diff changeset
4233 (contains_label_1, contains_label_p): Remove.
kono
parents:
diff changeset
4234
kono
parents:
diff changeset
4235 2016-01-16 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
4236
kono
parents:
diff changeset
4237 PR c++/69091
kono
parents:
diff changeset
4238 * pt.c (type_dependent_expression_p): For a function template
kono
parents:
diff changeset
4239 specialization, a type is dependent iff any of its template
kono
parents:
diff changeset
4240 arguments are.
kono
parents:
diff changeset
4241
kono
parents:
diff changeset
4242 2016-01-16 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
4243
kono
parents:
diff changeset
4244 * cp-array-notation.c (cp_expand_cond_array_notations): Return
kono
parents:
diff changeset
4245 error_mark_node only if find_rank failed, not if it was
kono
parents:
diff changeset
4246 successful.
kono
parents:
diff changeset
4247
kono
parents:
diff changeset
4248 2016-01-16 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
4249
kono
parents:
diff changeset
4250 PR c++/68936
kono
parents:
diff changeset
4251 * tree.c (build_min_non_dep_call_vec): Don't retain the
kono
parents:
diff changeset
4252 KOENIG_LOOKUP_P flag of the non-dependent expression that's
kono
parents:
diff changeset
4253 been built.
kono
parents:
diff changeset
4254 (build_min_non_dep_op_overload): Instead, do it here.
kono
parents:
diff changeset
4255
kono
parents:
diff changeset
4256 2016-01-15 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
4257
kono
parents:
diff changeset
4258 PR bootstrap/68271
kono
parents:
diff changeset
4259 * parser.h (cp_token): Remove pragma_kind field. Add comment
kono
parents:
diff changeset
4260 with number of unused bits.
kono
parents:
diff changeset
4261 * parser.c (eof_token): Remove pragma_kind field initializer.
kono
parents:
diff changeset
4262 (cp_lexer_get_preprocessor_token): Don't set pragma_kind
kono
parents:
diff changeset
4263 field, don't clear CPP_PRAGMA u.value.
kono
parents:
diff changeset
4264 (cp_parser_pragma_kind): New function.
kono
parents:
diff changeset
4265 (cp_parser_omp_sections_scope, cp_parser_oacc_kernels_parallel,
kono
parents:
diff changeset
4266 cp_parser_omp_construct, cp_parser_initial_pragma,
kono
parents:
diff changeset
4267 cp_parser_pragma): Use cp_parser_pragma_kind instead of accessing
kono
parents:
diff changeset
4268 pragma_kind field.
kono
parents:
diff changeset
4269
kono
parents:
diff changeset
4270 2016-01-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4271
kono
parents:
diff changeset
4272 PR c++/68847
kono
parents:
diff changeset
4273 * call.c (build_cxx_call): Use fold_non_dependent_expr.
kono
parents:
diff changeset
4274
kono
parents:
diff changeset
4275 * typeck2.c (cxx_incomplete_type_diagnostic): Use the location of
kono
parents:
diff changeset
4276 value.
kono
parents:
diff changeset
4277
kono
parents:
diff changeset
4278 PR c++/69257
kono
parents:
diff changeset
4279 * typeck.c (decay_conversion): Don't call mark_rvalue_use for
kono
parents:
diff changeset
4280 array/function-to-pointer conversion. Call
kono
parents:
diff changeset
4281 complete_type_or_maybe_complain for lvalue-to-rvalue conversion.
kono
parents:
diff changeset
4282 * call.c (convert_like_real): Print call context if
kono
parents:
diff changeset
4283 decay_conversion errors.
kono
parents:
diff changeset
4284
kono
parents:
diff changeset
4285 2016-01-14 Tom de Vries <tom@codesourcery.com>
kono
parents:
diff changeset
4286
kono
parents:
diff changeset
4287 PR tree-optimization/68773
kono
parents:
diff changeset
4288 * parser.c (cp_parser_oacc_declare, cp_parser_omp_declare_target): Don't
kono
parents:
diff changeset
4289 set force_output.
kono
parents:
diff changeset
4290
kono
parents:
diff changeset
4291 2016-01-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4292
kono
parents:
diff changeset
4293 PR c++/69261
kono
parents:
diff changeset
4294 * constexpr.c (find_array_ctor_elt): Handle splitting RANGE_EXPR.
kono
parents:
diff changeset
4295
kono
parents:
diff changeset
4296 2016-01-12 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
4297
kono
parents:
diff changeset
4298 PR c++/68979
kono
parents:
diff changeset
4299 * constexpr.c (cxx_eval_check_shift_p): Use permerror rather than
kono
parents:
diff changeset
4300 error_at and adjust the return value.
kono
parents:
diff changeset
4301
kono
parents:
diff changeset
4302 2016-01-12 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
4303
kono
parents:
diff changeset
4304 PR objc++/68511
kono
parents:
diff changeset
4305 PR c++/69213
kono
parents:
diff changeset
4306 * cp-gimplify.c (cp_gimplify_expr) <case INIT_EXPR>: Don't return
kono
parents:
diff changeset
4307 GS_ERROR whenever seen_error (), only if *expr_p contains
kono
parents:
diff changeset
4308 cilk spawn stmt, but cilk_detect_spawn_and_unwrap failed.
kono
parents:
diff changeset
4309
kono
parents:
diff changeset
4310 PR c++/66808
kono
parents:
diff changeset
4311 PR c++/69000
kono
parents:
diff changeset
4312 * pt.c (tsubst_decl): If not local_p, clear DECL_TEMPLATE_INFO.
kono
parents:
diff changeset
4313
kono
parents:
diff changeset
4314 2016-01-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4315
kono
parents:
diff changeset
4316 PR c++/69131
kono
parents:
diff changeset
4317 * method.c (walk_field_subobs): Add dtor_from_ctor parm.
kono
parents:
diff changeset
4318 (process_subob_fn): Likewise. Don't consider triviality if true.
kono
parents:
diff changeset
4319 (synthesize_method_walk): Pass it.
kono
parents:
diff changeset
4320
kono
parents:
diff changeset
4321 2016-01-11 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
4322
kono
parents:
diff changeset
4323 PR c++/68795
kono
parents:
diff changeset
4324 * parser.c (cp_parser_postfix_expression): Initialize
kono
parents:
diff changeset
4325 close_paren_loc to UNKNOWN_LOCATION; only use it if
kono
parents:
diff changeset
4326 it has been written to by
kono
parents:
diff changeset
4327 cp_parser_parenthesized_expression_list.
kono
parents:
diff changeset
4328 (cp_parser_parenthesized_expression_list): Document the behavior
kono
parents:
diff changeset
4329 with respect to the CLOSE_PAREN_LOC param.
kono
parents:
diff changeset
4330
kono
parents:
diff changeset
4331 2016-01-11 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
4332
kono
parents:
diff changeset
4333 PR c++/69211
kono
parents:
diff changeset
4334 * cp-gimplify.c (cp_fold): If COMPOUND_EXPR or MODIFY_EXPR
kono
parents:
diff changeset
4335 folded operands have side-effects, but folding changed any of them,
kono
parents:
diff changeset
4336 build a new tree with the folded operands instead of returning the
kono
parents:
diff changeset
4337 unfolded tree.
kono
parents:
diff changeset
4338
kono
parents:
diff changeset
4339 2016-01-09 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
4340
kono
parents:
diff changeset
4341 PR c++/69113
kono
parents:
diff changeset
4342 * decl2.c (comdat_linkage): Only set DECL_COMDAT if TREE_PUBLIC is set.
kono
parents:
diff changeset
4343
kono
parents:
diff changeset
4344 2016-01-09 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
4345
kono
parents:
diff changeset
4346 PR c++/69164
kono
parents:
diff changeset
4347 * class.c (layout_class_type): Use copy_node to copy FIELD_DECLs.
kono
parents:
diff changeset
4348
kono
parents:
diff changeset
4349 2016-01-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4350
kono
parents:
diff changeset
4351 PR c++/69158
kono
parents:
diff changeset
4352 * constexpr.c (cxx_fold_indirect_ref): Handle array type differing
kono
parents:
diff changeset
4353 in completion.
kono
parents:
diff changeset
4354
kono
parents:
diff changeset
4355 2016-01-08 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
4356
kono
parents:
diff changeset
4357 PR c++/68449
kono
parents:
diff changeset
4358 * constexpr.c (cxx_eval_constant_expression): Handle NULL initializer.
kono
parents:
diff changeset
4359
kono
parents:
diff changeset
4360 2016-01-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4361
kono
parents:
diff changeset
4362 * constexpr.c (cxx_eval_call_expression): Remove convert_to_void
kono
parents:
diff changeset
4363 workaround.
kono
parents:
diff changeset
4364
kono
parents:
diff changeset
4365 PR c++/68983
kono
parents:
diff changeset
4366 PR c++/67557
kono
parents:
diff changeset
4367 * cvt.c (convert_to_void): Don't strip a TARGET_EXPR of
kono
parents:
diff changeset
4368 TREE_ADDRESSABLE type.
kono
parents:
diff changeset
4369
kono
parents:
diff changeset
4370 PR c++/68983
kono
parents:
diff changeset
4371 PR c++/67557
kono
parents:
diff changeset
4372 * call.c (unsafe_copy_elision_p): Look through COMPOUND_EXPR.
kono
parents:
diff changeset
4373
kono
parents:
diff changeset
4374 2016-01-05 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
4375
kono
parents:
diff changeset
4376 PR c++/58583
kono
parents:
diff changeset
4377 * pt.c (build_non_dependent_expr): Don't try a checking fold when
kono
parents:
diff changeset
4378 parsing an nsdmi.
kono
parents:
diff changeset
4379
kono
parents:
diff changeset
4380 2016-01-04 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
4381
kono
parents:
diff changeset
4382 Update copyright years.
kono
parents:
diff changeset
4383
kono
parents:
diff changeset
4384 Copyright (C) 2016 Free Software Foundation, Inc.
kono
parents:
diff changeset
4385
kono
parents:
diff changeset
4386 Copying and distribution of this file, with or without modification,
kono
parents:
diff changeset
4387 are permitted in any medium without royalty provided the copyright
kono
parents:
diff changeset
4388 notice and this notice are preserved.