annotate gcc/cp/ChangeLog-2015 @ 131:84e7813d76e9

gcc-8.2
author mir3636
date Thu, 25 Oct 2018 07:37:49 +0900
parents 04ced10e8804
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
111
kono
parents:
diff changeset
1 2015-12-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2
kono
parents:
diff changeset
3 PR c++/69005
kono
parents:
diff changeset
4 * call.c (add_template_candidate_real): Don't try to deduce X(X).
kono
parents:
diff changeset
5
kono
parents:
diff changeset
6 2015-12-22 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
7
kono
parents:
diff changeset
8 PR c++/66921
kono
parents:
diff changeset
9 * decl.c (cp_complete_array_type): Allow an initializer that
kono
parents:
diff changeset
10 already has array type.
kono
parents:
diff changeset
11
kono
parents:
diff changeset
12 PR c++/67257
kono
parents:
diff changeset
13 * parser.c (cp_parser_single_declaration): Reject a class template
kono
parents:
diff changeset
14 that also declares a variable.
kono
parents:
diff changeset
15
kono
parents:
diff changeset
16 PR c++/67339
kono
parents:
diff changeset
17 * parser.c (cp_parser_elaborated_type_specifier): Use CLASS_TYPE_P
kono
parents:
diff changeset
18 rather than check for RECORD_TYPE.
kono
parents:
diff changeset
19
kono
parents:
diff changeset
20 2015-12-22 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
21
kono
parents:
diff changeset
22 * pt.c (make_pack_expansion): Make sure to initialize
kono
parents:
diff changeset
23 ppd.type_pack_expansion_p.
kono
parents:
diff changeset
24
kono
parents:
diff changeset
25 2015-12-21 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
26
kono
parents:
diff changeset
27 * typeck.c (cp_build_binary_op): Update for change in signature
kono
parents:
diff changeset
28 of build_binary_op. Use error_at to replace an implicit use
kono
parents:
diff changeset
29 of input_location with param "location" in "invalid operands"
kono
parents:
diff changeset
30 error.
kono
parents:
diff changeset
31 (cp_build_binary_op): Replace an error with an error_at, using
kono
parents:
diff changeset
32 "location", rather than implicitly using input_location.
kono
parents:
diff changeset
33
kono
parents:
diff changeset
34 2015-12-20 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
35
kono
parents:
diff changeset
36 PR c++/67411
kono
parents:
diff changeset
37 * decl2.c (decl_maybe_constant_var_p): Use DECL_HAS_VALUE_EXPR_P.
kono
parents:
diff changeset
38
kono
parents:
diff changeset
39 PR c++/67411
kono
parents:
diff changeset
40 * lambda.c (generic_lambda_fn_p): Split out from...
kono
parents:
diff changeset
41 (maybe_add_lambda_conv_op): ...here.
kono
parents:
diff changeset
42 * semantics.c (process_outer_var_ref): Don't defer maybe-constant
kono
parents:
diff changeset
43 variables in a generic lambda.
kono
parents:
diff changeset
44 * pt.c (instantiate_non_dependent_or_null): New.
kono
parents:
diff changeset
45 * init.c (constant_value_1): Use it.
kono
parents:
diff changeset
46 * cp-tree.h: Declare it and generic_lambda_fn_p.
kono
parents:
diff changeset
47
kono
parents:
diff changeset
48 PR c++/67411
kono
parents:
diff changeset
49 * decl2.c (decl_maybe_constant_var_p): A proxy isn't constant.
kono
parents:
diff changeset
50
kono
parents:
diff changeset
51 2015-12-18 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
52
kono
parents:
diff changeset
53 PR c++/68978
kono
parents:
diff changeset
54 * tree.c (lvalue_kind) [MODOP_EXPR]: New case.
kono
parents:
diff changeset
55
kono
parents:
diff changeset
56 2015-12-18 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
57
kono
parents:
diff changeset
58 PR c++/67592
kono
parents:
diff changeset
59 * decl.c (grokdeclarator): Reject constexpr virtual member functions;
kono
parents:
diff changeset
60 in error messages, prefer %<virtual%> and %<constexpr%> to virtual
kono
parents:
diff changeset
61 and constexpr, respectively.
kono
parents:
diff changeset
62
kono
parents:
diff changeset
63 2015-12-18 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
64
kono
parents:
diff changeset
65 PR c++/68831
kono
parents:
diff changeset
66 * init.c (build_delete): Use a warning sentinel to disable
kono
parents:
diff changeset
67 -Waddress warnings when building the conditional that tests
kono
parents:
diff changeset
68 if the operand is NULL.
kono
parents:
diff changeset
69
kono
parents:
diff changeset
70 2015-12-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
71
kono
parents:
diff changeset
72 PR c++/67550
kono
parents:
diff changeset
73 * init.c (constant_value_1): Don't return a CONSTRUCTOR missing
kono
parents:
diff changeset
74 non-constant elements.
kono
parents:
diff changeset
75
kono
parents:
diff changeset
76 PR c++/67576
kono
parents:
diff changeset
77 PR c++/25466
kono
parents:
diff changeset
78 * rtti.c (build_typeid): Use save_expr, not stabilize_reference.
kono
parents:
diff changeset
79
kono
parents:
diff changeset
80 2015-12-16 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
81
kono
parents:
diff changeset
82 PR c++/16333
kono
parents:
diff changeset
83 PR c++/41426
kono
parents:
diff changeset
84 PR c++/59879
kono
parents:
diff changeset
85 PR c++/66895
kono
parents:
diff changeset
86 * typeck.c (convert_for_initialization): Don't perform an early
kono
parents:
diff changeset
87 decaying conversion if converting to a class type.
kono
parents:
diff changeset
88
kono
parents:
diff changeset
89 2015-12-16 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
90
kono
parents:
diff changeset
91 * tree.c (cp_tree_operand_length): Define in terms of
kono
parents:
diff changeset
92 cp_tree_code_length.
kono
parents:
diff changeset
93
kono
parents:
diff changeset
94 2015-12-16 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
95
kono
parents:
diff changeset
96 PR objc++/68932
kono
parents:
diff changeset
97 * decl.c (grokdeclarator): Avoid assuming ctype is non-null when
kono
parents:
diff changeset
98 checking the validity of a flexible array member.
kono
parents:
diff changeset
99
kono
parents:
diff changeset
100 2015-12-16 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
101
kono
parents:
diff changeset
102 * pt.c (comp_template_args): Remove.
kono
parents:
diff changeset
103 (comp_template_args_with_info): Rename to comp_template_args;
kono
parents:
diff changeset
104 not static.
kono
parents:
diff changeset
105 (add_pending_template): Adjust call.
kono
parents:
diff changeset
106 * cp-tree.h (comp_template_args): Add default arguments.
kono
parents:
diff changeset
107
kono
parents:
diff changeset
108 2015-12-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
109
kono
parents:
diff changeset
110 PR c++/68309
kono
parents:
diff changeset
111 * pt.c (instantiate_decl): Revert earlier change.
kono
parents:
diff changeset
112
kono
parents:
diff changeset
113 PR c++/63628
kono
parents:
diff changeset
114 * pt.c (tsubst_pack_expansion): Also make dummy decls if
kono
parents:
diff changeset
115 retrieve_local_specialization fails.
kono
parents:
diff changeset
116
kono
parents:
diff changeset
117 2015-12-16 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
118
kono
parents:
diff changeset
119 * parser.c (cp_lexer_peek_conflict_marker): New function.
kono
parents:
diff changeset
120 (cp_parser_error): Detect conflict markers and report them as
kono
parents:
diff changeset
121 such.
kono
parents:
diff changeset
122
kono
parents:
diff changeset
123 2015-12-15 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
124
kono
parents:
diff changeset
125 PR c++/42121
kono
parents:
diff changeset
126 PR c++/68478
kono
parents:
diff changeset
127 PR c++/68613
kono
parents:
diff changeset
128 PR c++/68689
kono
parents:
diff changeset
129 PR c++/68710
kono
parents:
diff changeset
130 * class.c (walk_subobject_offsets): Avoid assuming type domain
kono
parents:
diff changeset
131 is non-null or has an upper bound.
kono
parents:
diff changeset
132 (layout_class_type): Include type size in error message.
kono
parents:
diff changeset
133 (flexmems_t): New type.
kono
parents:
diff changeset
134 (field_nonempty_p, find_flexarrays, diagnose_flexarrays)
kono
parents:
diff changeset
135 (check_flexarrays): New functions.
kono
parents:
diff changeset
136 (finish_struct_1): Call check_flexarrays.
kono
parents:
diff changeset
137 * decl.c (compute_array_index_type): Distinguish flexible array
kono
parents:
diff changeset
138 members from zero-length arrays.
kono
parents:
diff changeset
139 (grokdeclarator): Reject flexible array members in unions. Avoid
kono
parents:
diff changeset
140 rejecting members of incomplete types that are flexible array members.
kono
parents:
diff changeset
141 * error.c (dump_type_suffix): Handle flexible array members with null
kono
parents:
diff changeset
142 upper bound.
kono
parents:
diff changeset
143 * init.c (perform_member_init): Same.
kono
parents:
diff changeset
144 * pt.c (instantiate_class_template_1): Allow flexible array members.
kono
parents:
diff changeset
145 (tsubst): Handle flexible array members with null upper bound.
kono
parents:
diff changeset
146 * typeck2.c (digest_init_r): Warn for initialization of flexible
kono
parents:
diff changeset
147 array members.
kono
parents:
diff changeset
148 (process_init_constructor_record): Handle flexible array members.
kono
parents:
diff changeset
149
kono
parents:
diff changeset
150 2015-12-15 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
151
kono
parents:
diff changeset
152 PR c++/21802
kono
parents:
diff changeset
153 PR c++/53223
kono
parents:
diff changeset
154 * cp-tree.h (cp_tree_code_length): Declare.
kono
parents:
diff changeset
155 (build_min_non_dep_op_overload): Declare.
kono
parents:
diff changeset
156 * tree.c (cp_tree_code_length): Define.
kono
parents:
diff changeset
157 (build_min_non_dep_op_overload): Define.
kono
parents:
diff changeset
158 (build_win_non_dep_call_vec): Copy the KOENIG_LOOKUP_P flag.
kono
parents:
diff changeset
159 * typeck.c (build_x_indirect_ref): Use
kono
parents:
diff changeset
160 build_min_non_dep_op_overload when the given expression
kono
parents:
diff changeset
161 has been resolved to an operator overload.
kono
parents:
diff changeset
162 (build_x_binary_op): Likewise.
kono
parents:
diff changeset
163 (build_x_array_ref): Likewise.
kono
parents:
diff changeset
164 (build_x_unary_op): Likewise.
kono
parents:
diff changeset
165 (build_x_compound_expr): Likewise.
kono
parents:
diff changeset
166 (build_x_modify_expr): Likewise.
kono
parents:
diff changeset
167 * decl2.c (grok_array_decl): Likewise.
kono
parents:
diff changeset
168 * call.c (build_new_op_1): If during template processing we
kono
parents:
diff changeset
169 chose an operator overload that is a hidden friend function, set
kono
parents:
diff changeset
170 the call's KOENIG_LOOKUP_P flag to 1.
kono
parents:
diff changeset
171
kono
parents:
diff changeset
172 2015-12-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
173
kono
parents:
diff changeset
174 PR c++/68309
kono
parents:
diff changeset
175 * pt.c (instantiate_decl): Copy local_specializations for nested
kono
parents:
diff changeset
176 function.
kono
parents:
diff changeset
177
kono
parents:
diff changeset
178 2015-12-09 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
179
kono
parents:
diff changeset
180 PR c++/60218
kono
parents:
diff changeset
181 * semantics.c (calculate_bases_helper): Don't call dfs_walk_all
kono
parents:
diff changeset
182 when TYPE_BINFO (type) is null.
kono
parents:
diff changeset
183 (calculate_bases): Handle gracefully a null vector->length ().
kono
parents:
diff changeset
184
kono
parents:
diff changeset
185 2015-12-08 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
186
kono
parents:
diff changeset
187 PR c++/68711
kono
parents:
diff changeset
188 * typeck.c (build_class_member_access_expr): Strip NOPs before
kono
parents:
diff changeset
189 testing a potentially null operand for equality to zero.
kono
parents:
diff changeset
190
kono
parents:
diff changeset
191 2015-12-07 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
192
kono
parents:
diff changeset
193 PR c++/68760
kono
parents:
diff changeset
194 * error.c (dump_global_iord): Use DECL_SOURCE_FILE (t)
kono
parents:
diff changeset
195 instead of LOCATION_FILE (input_location).
kono
parents:
diff changeset
196
kono
parents:
diff changeset
197 2015-12-07 Ryan Burn <contact@rnburn.com>
kono
parents:
diff changeset
198
kono
parents:
diff changeset
199 PR c++/68683
kono
parents:
diff changeset
200 * constraint.cc (satisfy_argument_deduction_constraint): Set
kono
parents:
diff changeset
201 TYPE_CANONICAL to NULL_TREE if PLACEHOLDER_TYPE_CONSTRAINTS are
kono
parents:
diff changeset
202 changed.
kono
parents:
diff changeset
203
kono
parents:
diff changeset
204 2015-12-07 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
205
kono
parents:
diff changeset
206 PR c++/68464
kono
parents:
diff changeset
207 * cp-gimplify.c (cp_fold): Don't assume X has TREE_TYPE.
kono
parents:
diff changeset
208 (cp_genericize): Don't do cp_fold_r here.
kono
parents:
diff changeset
209 (cp_fold_function): New.
kono
parents:
diff changeset
210 * cp-tree.h: Declare it.
kono
parents:
diff changeset
211 * decl.c (finish_function): Call it and the pre-genericize plugin
kono
parents:
diff changeset
212 before NRV processing.
kono
parents:
diff changeset
213
kono
parents:
diff changeset
214 PR c++/68170
kono
parents:
diff changeset
215 * pt.c (maybe_new_partial_specialization): The injected-class-name
kono
parents:
diff changeset
216 is not a new partial specialization.
kono
parents:
diff changeset
217
kono
parents:
diff changeset
218 * Make-lang.in (check-c++1z, check-c++-all): Use GXX_TESTSUITE_STDS.
kono
parents:
diff changeset
219
kono
parents:
diff changeset
220 2015-12-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
221
kono
parents:
diff changeset
222 * parser.c (struct tentative_firewall): New.
kono
parents:
diff changeset
223 (cp_parser_template_id, cp_parser_decltype_expr): Use it.
kono
parents:
diff changeset
224
kono
parents:
diff changeset
225 * parser.h (struct cp_token): Tell GTY that CPP_DECLTYPE uses
kono
parents:
diff changeset
226 tree_check_value.
kono
parents:
diff changeset
227 * parser.c (cp_parser_decltype): Use tree_check_value.
kono
parents:
diff changeset
228 (saved_checks_value): New.
kono
parents:
diff changeset
229 (cp_parser_nested_name_specifier_opt): Use it.
kono
parents:
diff changeset
230 (cp_parser_template_id): Use it.
kono
parents:
diff changeset
231 (cp_parser_simple_type_specifier): Use it.
kono
parents:
diff changeset
232 (cp_parser_pre_parsed_nested_name_specifier): Use it.
kono
parents:
diff changeset
233
kono
parents:
diff changeset
234 * semantics.c (finish_qualified_id_expr): Handle
kono
parents:
diff changeset
235 UNBOUND_CLASS_TEMPLATE.
kono
parents:
diff changeset
236
kono
parents:
diff changeset
237 * parser.c (cp_parser_template_argument): Handle references in
kono
parents:
diff changeset
238 C++1z mode.
kono
parents:
diff changeset
239 * constexpr.c (potential_constant_expression_1): Don't error about
kono
parents:
diff changeset
240 TREE_THIS_VOLATILE on declarations.
kono
parents:
diff changeset
241 [COMPONENT_REF]: Don't consider the object if we're dealing with
kono
parents:
diff changeset
242 an overloaded function.
kono
parents:
diff changeset
243
kono
parents:
diff changeset
244 * constraint.cc (strictly_subsumes): New.
kono
parents:
diff changeset
245 * cp-tree.h: Declare it.
kono
parents:
diff changeset
246 * pt.c (process_partial_specialization): Use it instead of
kono
parents:
diff changeset
247 subsumes_constraints.
kono
parents:
diff changeset
248 (maybe_new_partial_specialization): Do compare null constraints.
kono
parents:
diff changeset
249 * search.c (lookup_member): Handle currently_open_class returning null.
kono
parents:
diff changeset
250
kono
parents:
diff changeset
251 PR c++/68597, fix auto9.C and auto-neg1.C with -std=c++1z.
kono
parents:
diff changeset
252 * decl.c (check_tag_decl): Use ds_type_spec in auto diagnostic.
kono
parents:
diff changeset
253 * typeck.c (check_return_expr): Check for inconsistent deduction.
kono
parents:
diff changeset
254 * parser.c (class type_id_in_expr_sentinel): New.
kono
parents:
diff changeset
255 (cp_parser_primary_expression) [RID_VA_ARG]: Use it.
kono
parents:
diff changeset
256 (cp_parser_new_expression): Use it.
kono
parents:
diff changeset
257 (cp_parser_trait_expr): Use it.
kono
parents:
diff changeset
258 (cp_parser_type_id_1): Complain about auto if in_type_id_in_expr_p.
kono
parents:
diff changeset
259 (cp_parser_default_type_template_argument): Check for auto.
kono
parents:
diff changeset
260 (cp_parser_type_id_list): Likewise.
kono
parents:
diff changeset
261 (cp_parser_simple_type_specifier): Allow auto parms if flag_concepts.
kono
parents:
diff changeset
262 * pt.c (do_auto_deduction): Handle erroneous type.
kono
parents:
diff changeset
263
kono
parents:
diff changeset
264 2015-12-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
265
kono
parents:
diff changeset
266 PR c++/68645
kono
parents:
diff changeset
267 * parser.c (cp_parser_direct_declarator)
kono
parents:
diff changeset
268 (cp_parser_late_return_type_opt): Put Cilk+ attributes on
kono
parents:
diff changeset
269 declarator->attributes, not std_attributes.
kono
parents:
diff changeset
270
kono
parents:
diff changeset
271 2015-12-04 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
272
kono
parents:
diff changeset
273 * cp-tree.h (class cp_expr): New class.
kono
parents:
diff changeset
274 (finish_parenthesized_expr): Convert return type and param to
kono
parents:
diff changeset
275 cp_expr.
kono
parents:
diff changeset
276 (perform_koenig_lookup): Convert return type and param from tree
kono
parents:
diff changeset
277 to cp_expr.
kono
parents:
diff changeset
278 (finish_increment_expr): Likewise.
kono
parents:
diff changeset
279 (finish_unary_op_expr): Likewise.
kono
parents:
diff changeset
280 (finish_id_expression): Likewise for return type.
kono
parents:
diff changeset
281 (build_class_member_access_expr): Likewise for param.
kono
parents:
diff changeset
282 (finish_class_member_access_expr): Likewise.
kono
parents:
diff changeset
283 (build_x_unary_op): Likewise.
kono
parents:
diff changeset
284 (build_c_cast): New decl.
kono
parents:
diff changeset
285 (build_x_modify_expr): Convert return type from tree to cp_expr.
kono
parents:
diff changeset
286 * cvt.c (cp_convert_and_check): When warning about conversions,
kono
parents:
diff changeset
287 attempt to use the location of "expr" if available, otherwise
kono
parents:
diff changeset
288 falling back to the old behavior of using input_location.
kono
parents:
diff changeset
289 * name-lookup.c (lookup_arg_dependent_1): Convert return type from
kono
parents:
diff changeset
290 tree to cp_expr.
kono
parents:
diff changeset
291 (lookup_arg_dependent): Likewise; also for local "ret".
kono
parents:
diff changeset
292 * name-lookup.h (lookup_arg_dependent): Likewise for return type.
kono
parents:
diff changeset
293 * parser.c (cp_lexer_previous_token): Skip past purged tokens.
kono
parents:
diff changeset
294 (struct cp_parser_expression_stack_entry): Convert field "lhs" to
kono
parents:
diff changeset
295 cp_expr.
kono
parents:
diff changeset
296 (cp_parser_identifier): Likewise for return type. Use cp_expr
kono
parents:
diff changeset
297 ctor to preserve the token's location.
kono
parents:
diff changeset
298 (cp_parser_string_literal): Likewise, building up a meaningful
kono
parents:
diff changeset
299 location for the case where a compound string literal is built by
kono
parents:
diff changeset
300 concatentation.
kono
parents:
diff changeset
301 (cp_parser_userdef_char_literal): Likewise for return type.
kono
parents:
diff changeset
302 (cp_parser_userdef_numeric_literal): Likewise.
kono
parents:
diff changeset
303 (cp_parser_statement_expr): Convert return type to cp_expr.
kono
parents:
diff changeset
304 Generate a suitable location for the expr and return it via the
kono
parents:
diff changeset
305 cp_expr ctor.
kono
parents:
diff changeset
306 (cp_parser_fold_expression): Convert return type to cp_expr.
kono
parents:
diff changeset
307 (cp_parser_primary_expression): Likewise, and for locals "expr",
kono
parents:
diff changeset
308 "lam", "id_expression", "decl".
kono
parents:
diff changeset
309 Use cp_expr ctor when parsing literals, to preserve the spelling
kono
parents:
diff changeset
310 location of the token. Preserve the locations of parentheses.
kono
parents:
diff changeset
311 Preserve location when calling objc_lookup_ivar.
kono
parents:
diff changeset
312 Preserve the location for "this" tokens. Generate suitable
kono
parents:
diff changeset
313 locations for "__builtin_va_arg" constructs and for
kono
parents:
diff changeset
314 Objective C 2.0 dot-syntax. Set the location for the result of
kono
parents:
diff changeset
315 finish_id_expression.
kono
parents:
diff changeset
316 (cp_parser_primary_expression): Convert return type from tree to
kono
parents:
diff changeset
317 cp_expr.
kono
parents:
diff changeset
318 (cp_parser_id_expression): Likewise.
kono
parents:
diff changeset
319 (cp_parser_unqualified_id): Likewise. Also for local "id".
kono
parents:
diff changeset
320 (cp_parser_postfix_expression): Likewise, also for local
kono
parents:
diff changeset
321 "postfix_expression". Generate suitable locations for
kono
parents:
diff changeset
322 C++-style casts, "_Cilk_spawn" constructs. Convert local
kono
parents:
diff changeset
323 "initializer" to cp_expr and use it to preserve the location of
kono
parents:
diff changeset
324 compound literals. Capture the location of the closing
kono
parents:
diff changeset
325 parenthesis of a call site via
kono
parents:
diff changeset
326 cp_parser_parenthesized_expression_list, and use it to build
kono
parents:
diff changeset
327 a source range for a call. Use cp_expr in ternary expression.
kono
parents:
diff changeset
328 (cp_parser_postfix_dot_deref_expression): Convert param from tree to
kono
parents:
diff changeset
329 cp_expr. Generate and set a location.
kono
parents:
diff changeset
330 (cp_parser_parenthesized_expression_list): Add "close_paren_loc"
kono
parents:
diff changeset
331 out-param, and write back to it.
kono
parents:
diff changeset
332 (cp_parser_unary_expression): Convert return type from tree to
kono
parents:
diff changeset
333 cp_expr. Also for locals "cast_expression" and "expression".
kono
parents:
diff changeset
334 Generate and use suitable locations for addresses of
kono
parents:
diff changeset
335 labels and for cast expressions. Call cp_expr::set_location where
kono
parents:
diff changeset
336 necessary. Preserve the locations of negated numeric literals.
kono
parents:
diff changeset
337 (cp_parser_new_expression): Generate meaningful locations/ranges.
kono
parents:
diff changeset
338 (cp_parser_cast_expression): Convert return type from tree to
kono
parents:
diff changeset
339 cp_expr; also for local "expr". Use the paren location to generate a
kono
parents:
diff changeset
340 meaningful range for the expression.
kono
parents:
diff changeset
341 (cp_parser_binary_expression): Convert return type from tree to
kono
parents:
diff changeset
342 cp_expr; also for local "rhs". Generate a meaningful location
kono
parents:
diff changeset
343 for the expression, and use it. Replace call to
kono
parents:
diff changeset
344 protected_set_expr_location by converting a build2 to a build2_loc
kono
parents:
diff changeset
345 and using the location in the call to build_x_binary_op, adding a
kono
parents:
diff changeset
346 cp_expr::set_location to the latter case.
kono
parents:
diff changeset
347 (cp_parser_question_colon_clause): Convert param from tree to
kono
parents:
diff changeset
348 cp_expr; also for local "assignment_expr". Set the spelling range
kono
parents:
diff changeset
349 of the expression.
kono
parents:
diff changeset
350 (cp_parser_assignment_expression): Likewise for return type and
kono
parents:
diff changeset
351 locals "expr" and "rhs". Build a meaningful spelling range for
kono
parents:
diff changeset
352 the expression. Remove saving of input_location in favor of a
kono
parents:
diff changeset
353 call to cp_expr::set_location.
kono
parents:
diff changeset
354 (cp_parser_expression): Convert return type and locals
kono
parents:
diff changeset
355 "expression" and "assignment_expression" to cp_expr. Build a
kono
parents:
diff changeset
356 meaningful spelling range for assignment expressions.
kono
parents:
diff changeset
357 (cp_parser_constant_expression): Likewise for return type and
kono
parents:
diff changeset
358 local "expression".
kono
parents:
diff changeset
359 (cp_parser_builtin_offsetof): Convert return type and local "expr"
kono
parents:
diff changeset
360 to cp_expr. Generate suitable locations.
kono
parents:
diff changeset
361 (cp_parser_lambda_expression): Convert return return type to
kono
parents:
diff changeset
362 cp_expr.
kono
parents:
diff changeset
363 (cp_parser_operator_function_id): Likewise.
kono
parents:
diff changeset
364 (cp_parser_operator): Likewise. Generate a meaningful range,
kono
parents:
diff changeset
365 using cp_expr's ctor to return it.
kono
parents:
diff changeset
366 (cp_parser_template_id): When converting a token to
kono
parents:
diff changeset
367 CPP_TEMPLATE_ID, update the location.
kono
parents:
diff changeset
368 (cp_parser_initializer_clause): Convert return type and local
kono
parents:
diff changeset
369 "initializer" to cp_expr.
kono
parents:
diff changeset
370 (cp_parser_braced_list): Likewise for return type. Generate
kono
parents:
diff changeset
371 suitable locations.
kono
parents:
diff changeset
372 (cp_parser_lookup_name): Likewise for return type. Use cp_expr's
kono
parents:
diff changeset
373 ctor to preserve the location_t of the name.
kono
parents:
diff changeset
374 (cp_parser_simple_cast_expression): Likewise for return type.
kono
parents:
diff changeset
375 (cp_parser_functional_cast): Convert return type and local "cast"
kono
parents:
diff changeset
376 to cp_expr. Generate suitable locations.
kono
parents:
diff changeset
377 (cp_parser_objc_expression): Convert return type to cp_expr.k Generate
kono
parents:
diff changeset
378 (cp_parser_objc_message_expression): Generate suitable locations.
kono
parents:
diff changeset
379 (cp_parser_objc_encode_expression): Convert return type to
kono
parents:
diff changeset
380 cp_expr. Generate suitable locations.
kono
parents:
diff changeset
381 (cp_parser_objc_protocol_expression): Generate suitable locations.
kono
parents:
diff changeset
382 (cp_parser_objc_selector_expression): Generate suitable locations.
kono
parents:
diff changeset
383 (cp_parser_omp_for_cond): Attempt to use the location
kono
parents:
diff changeset
384 of "cond" for the binary op.
kono
parents:
diff changeset
385 (cp_parser_transaction_expression): Issue the tm-not-enabled error
kono
parents:
diff changeset
386 at the location of the __transaction_foo token, rather than at
kono
parents:
diff changeset
387 input_location.
kono
parents:
diff changeset
388 * semantics.c (finish_parenthesized_expr): Convert return type and
kono
parents:
diff changeset
389 param to cp_expr. Preserve location.
kono
parents:
diff changeset
390 (perform_koenig_lookup): Likewise for return type
kono
parents:
diff changeset
391 and param.
kono
parents:
diff changeset
392 (finish_increment_expr): Likewise. Generate suitable locations.
kono
parents:
diff changeset
393 (finish_unary_op_expr): Likewise for return type and local "result".
kono
parents:
diff changeset
394 Generate suitable locations.
kono
parents:
diff changeset
395 (finish_id_expression): Convert return type to cp_expr and use
kono
parents:
diff changeset
396 cp_expr ctor to preserve location information.
kono
parents:
diff changeset
397 * typeck.c (build_class_member_access_expr): Convert param to
kono
parents:
diff changeset
398 cp_expr.
kono
parents:
diff changeset
399 (finish_class_member_access_expr): Likewise.
kono
parents:
diff changeset
400 (cp_build_binary_op): Convert a build2 to a build2_loc.
kono
parents:
diff changeset
401 (build_x_unary_op): Convert param from tree to cp_expr.
kono
parents:
diff changeset
402 (build_nop): Preserve the location of EXPR.
kono
parents:
diff changeset
403 (build_c_cast): Provide an overloaded variant that takes a cp_expr
kono
parents:
diff changeset
404 and returns a cp_expr.
kono
parents:
diff changeset
405 (build_x_modify_expr): Convert return type from tree to cp_expr.
kono
parents:
diff changeset
406
kono
parents:
diff changeset
407 2015-12-03 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
408
kono
parents:
diff changeset
409 * parser.c (cp_ensure_no_oacc_routine): Update error message.
kono
parents:
diff changeset
410 (cp_parser_oacc_routine): Likewise.
kono
parents:
diff changeset
411 (cp_parser_late_parsing_oacc_routine): Likewise. Update comment
kono
parents:
diff changeset
412 describing this function.
kono
parents:
diff changeset
413 (cp_finalize_oacc_routine): Update error message.
kono
parents:
diff changeset
414
kono
parents:
diff changeset
415 2015-12-02 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
416
kono
parents:
diff changeset
417 * Make-lang.in (check-c++1z, check-c++-all): New.
kono
parents:
diff changeset
418
kono
parents:
diff changeset
419 2015-12-02 Markus Trippelsdorf <markus@trippelsdorf.de>
kono
parents:
diff changeset
420
kono
parents:
diff changeset
421 PR c++/67337
kono
parents:
diff changeset
422 * mangle.c (write_template_prefix): Guard against context==NULL.
kono
parents:
diff changeset
423
kono
parents:
diff changeset
424 2015-12-02 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
425
kono
parents:
diff changeset
426 * call.c (build_new_op_1): Don't fold arguments to
kono
parents:
diff changeset
427 warn_logical_operator or maybe_warn_bool_compare.
kono
parents:
diff changeset
428
kono
parents:
diff changeset
429 * cp-gimplify.c (cp_fold_maybe_rvalue, cp_fold_rvalue): New.
kono
parents:
diff changeset
430 (c_fully_fold): Use cp_fold_rvalue.
kono
parents:
diff changeset
431 (cp_fold): Use them for rvalue operands.
kono
parents:
diff changeset
432
kono
parents:
diff changeset
433 * cp-gimplify.c (c_fully_fold): Define.
kono
parents:
diff changeset
434
kono
parents:
diff changeset
435 * cp-gimplify.c (cp_fold): Use fold_build*.
kono
parents:
diff changeset
436
kono
parents:
diff changeset
437 2015-12-02 Joseph Myers <joseph@codesourcery.com>
kono
parents:
diff changeset
438
kono
parents:
diff changeset
439 PR c/68162
kono
parents:
diff changeset
440 * tree.c (c_build_qualified_type): Add extra arguments.
kono
parents:
diff changeset
441
kono
parents:
diff changeset
442 2015-12-02 Eric Botcazou <ebotcazou@adacore.com>
kono
parents:
diff changeset
443
kono
parents:
diff changeset
444 PR c++/68290
kono
parents:
diff changeset
445 * constraint.cc (make_constrained_auto): Move to...
kono
parents:
diff changeset
446 * pt.c (make_auto_1): Add set_canonical parameter and set
kono
parents:
diff changeset
447 TYPE_CANONICAL on the type only if it is true.
kono
parents:
diff changeset
448 (make_decltype_auto): Adjust call to make_auto_1.
kono
parents:
diff changeset
449 (make_auto): Likewise.
kono
parents:
diff changeset
450 (splice_late_return_type): Likewise.
kono
parents:
diff changeset
451 (make_constrained_auto): ...here. Call make_auto_1 instead of
kono
parents:
diff changeset
452 make_auto and pass false. Set TYPE_CANONICAL directly.
kono
parents:
diff changeset
453
kono
parents:
diff changeset
454 2015-12-02 Thomas Schwinge <thomas@codesourcery.com>
kono
parents:
diff changeset
455
kono
parents:
diff changeset
456 * parser.c (cp_parser_omp_clause_name)
kono
parents:
diff changeset
457 (cp_parser_oacc_all_clauses): Alphabetical sorting.
kono
parents:
diff changeset
458 * pt.c (tsubst_omp_clauses): Handle OMP_CLAUSE_USE_DEVICE.
kono
parents:
diff changeset
459
kono
parents:
diff changeset
460 2015-12-02 Andreas Arnez <arnez@linux.vnet.ibm.com>
kono
parents:
diff changeset
461
kono
parents:
diff changeset
462 PR gcov-profile/68603
kono
parents:
diff changeset
463 * cp-gimplify.c (genericize_cp_loop): For the back-jump's location
kono
parents:
diff changeset
464 use the start of the loop body only if the loop is unconditional.
kono
parents:
diff changeset
465
kono
parents:
diff changeset
466 2015-11-26 Andreas Arnez <arnez@linux.vnet.ibm.com>
kono
parents:
diff changeset
467
kono
parents:
diff changeset
468 * cp-gimplify.c (genericize_cp_loop): Change LOOP_EXPR's location
kono
parents:
diff changeset
469 to start of loop body instead of start of loop.
kono
parents:
diff changeset
470
kono
parents:
diff changeset
471 2015-12-01 Julian Brown <julian@codesourcery.com>
kono
parents:
diff changeset
472 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
473 James Norris <James_Norris@mentor.com>
kono
parents:
diff changeset
474
kono
parents:
diff changeset
475 * cp-tree.h (finish_oacc_host_data): Add prototype.
kono
parents:
diff changeset
476 * parser.c (cp_parser_omp_clause_name): Add use_device support.
kono
parents:
diff changeset
477 (cp_parser_oacc_all_clauses): Add use_device support.
kono
parents:
diff changeset
478 (OACC_HOST_DATA_CLAUSE_MASK): New macro.
kono
parents:
diff changeset
479 (cp_parser_oacc_host_data): New function.
kono
parents:
diff changeset
480 (cp_parser_omp_construct): Add host_data support.
kono
parents:
diff changeset
481 (cp_parser_pragma): Add host_data support.
kono
parents:
diff changeset
482 * semantics.c (finish_omp_clauses): Add use_device support.
kono
parents:
diff changeset
483 (finish_oacc_host_data): New function.
kono
parents:
diff changeset
484
kono
parents:
diff changeset
485 2015-11-27 Martin Liska <mliska@suse.cz>
kono
parents:
diff changeset
486
kono
parents:
diff changeset
487 PR c++/68312
kono
parents:
diff changeset
488 * cp-array-notation.c (expand_sec_reduce_builtin):
kono
parents:
diff changeset
489 Likewise.
kono
parents:
diff changeset
490 (create_array_refs): Replace argument with const reference.
kono
parents:
diff changeset
491 (expand_an_in_modify_expr): Likewise.
kono
parents:
diff changeset
492 (cp_expand_cond_array_notations): Likewise.
kono
parents:
diff changeset
493 (expand_unary_array_notation_exprs): Likewise.
kono
parents:
diff changeset
494
kono
parents:
diff changeset
495 2015-11-27 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
496
kono
parents:
diff changeset
497 PR c/63326
kono
parents:
diff changeset
498 * parser.c (cp_parser_statement): Clear in_compound after labels.
kono
parents:
diff changeset
499
kono
parents:
diff changeset
500 2015-11-27 Martin Liska <mliska@suse.cz>
kono
parents:
diff changeset
501
kono
parents:
diff changeset
502 * parser.c (cp_parser_late_parsing_cilk_simd_fn_info):
kono
parents:
diff changeset
503 Release tokens.
kono
parents:
diff changeset
504
kono
parents:
diff changeset
505 2015-11-26 Andreas Arnez <arnez@linux.vnet.ibm.com>
kono
parents:
diff changeset
506
kono
parents:
diff changeset
507 * cp-gimplify.c (genericize_cp_loop): Change LOOP_EXPR's location
kono
parents:
diff changeset
508 to start of loop body instead of start of loop.
kono
parents:
diff changeset
509
kono
parents:
diff changeset
510 2015-11-26 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
511
kono
parents:
diff changeset
512 PR c++/68508
kono
parents:
diff changeset
513 * cp-tree.h (cp_ubsan_maybe_instrument_downcast): Add INTYPE argument.
kono
parents:
diff changeset
514 * cp-ubsan.c (cp_ubsan_maybe_instrument_downcast): Likewise. Use
kono
parents:
diff changeset
515 it instead of or in addition to TREE_TYPE (op). Use
kono
parents:
diff changeset
516 is_properly_derived_from, return NULL_TREE if TREE_TYPE (intype) and
kono
parents:
diff changeset
517 TREE_TYPE (type) are the same type minus qualifiers.
kono
parents:
diff changeset
518 * typeck.c (build_static_cast_1): Adjust callers.
kono
parents:
diff changeset
519
kono
parents:
diff changeset
520 2015-11-25 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
521
kono
parents:
diff changeset
522 PR c++/67876
kono
parents:
diff changeset
523 * pt.c (convert_template_argument): Make sure number of tree
kono
parents:
diff changeset
524 operands is greater than zero before attempting to extract one.
kono
parents:
diff changeset
525
kono
parents:
diff changeset
526 2015-11-25 Ryan Burn <contact@rnburn.com>
kono
parents:
diff changeset
527
kono
parents:
diff changeset
528 PR c++/68434
kono
parents:
diff changeset
529 * pt.c (tsubst): Set PLACEHOLDER_TYPE_CONSTRAINTS before
kono
parents:
diff changeset
530 calling canonical_type_parameter.
kono
parents:
diff changeset
531
kono
parents:
diff changeset
532 2015-11-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
533
kono
parents:
diff changeset
534 * lambda.c (maybe_add_lambda_conv_op): Only set
kono
parents:
diff changeset
535 no_sanitize_undefined if SANITIZE_NULL.
kono
parents:
diff changeset
536
kono
parents:
diff changeset
537 PR c++/67941
kono
parents:
diff changeset
538 * lambda.c (maybe_add_lambda_conv_op): Mark _FUN as
kono
parents:
diff changeset
539 no_sanitize_undefined.
kono
parents:
diff changeset
540
kono
parents:
diff changeset
541 * cp-ubsan.c (cp_ubsan_instrument_vptr_p): Use
kono
parents:
diff changeset
542 do_ubsan_in_current_function.
kono
parents:
diff changeset
543
kono
parents:
diff changeset
544 2015-11-25 Markus Trippelsdorf <markus@trippelsdorf.de>
kono
parents:
diff changeset
545 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
546
kono
parents:
diff changeset
547 PR c++/68087
kono
parents:
diff changeset
548 * constexpr.c (cxx_eval_array_reference): Use tree_fits_shwi_p before
kono
parents:
diff changeset
549 tree_to_shwi to avoid ICEs.
kono
parents:
diff changeset
550
kono
parents:
diff changeset
551 2015-11-24 Ilya Verbin <ilya.verbin@intel.com>
kono
parents:
diff changeset
552
kono
parents:
diff changeset
553 * parser.c (cp_parser_oacc_declare): Replace "ifdef ENABLE_OFFLOADING"
kono
parents:
diff changeset
554 with "if (ENABLE_OFFLOADING)".
kono
parents:
diff changeset
555
kono
parents:
diff changeset
556 2015-11-23 Igor Zamyatin <igor.zamyatin@intel.com>
kono
parents:
diff changeset
557
kono
parents:
diff changeset
558 PR c++/68001
kono
parents:
diff changeset
559 * cp-gimplify.c (cp_gimplify_expr): Stop the process if see an error.
kono
parents:
diff changeset
560
kono
parents:
diff changeset
561 2015-11-20 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
562
kono
parents:
diff changeset
563 PR c++/67354
kono
parents:
diff changeset
564 * cp-tree.h (defer_mangling_aliases): Declare.
kono
parents:
diff changeset
565 (generate_mangling_aliases): New prototype.
kono
parents:
diff changeset
566 * decl2.c (defer_mangling_aliases): New variable.
kono
parents:
diff changeset
567 (note_mangling_alias): Use !defer_mangling_aliases
kono
parents:
diff changeset
568 instead of at_eof.
kono
parents:
diff changeset
569 (generate_mangling_aliases): No longer static. Clear
kono
parents:
diff changeset
570 defer_mangling_aliases.
kono
parents:
diff changeset
571 * optimize.c (maybe_thunk_body): Defer emitting mangling aliases
kono
parents:
diff changeset
572 if !defer_mangling_aliases until the fns are put into the same
kono
parents:
diff changeset
573 comdat group.
kono
parents:
diff changeset
574
kono
parents:
diff changeset
575 2015-11-19 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
576
kono
parents:
diff changeset
577 * cp-tree.h (lookup_member_fuzzy): New decl.
kono
parents:
diff changeset
578 * search.c: Include spellcheck.h.
kono
parents:
diff changeset
579 (class lookup_field_fuzzy_info): New class.
kono
parents:
diff changeset
580 (lookup_field_fuzzy_info::fuzzy_lookup_fnfields): New.
kono
parents:
diff changeset
581 (lookup_field_fuzzy_info::fuzzy_lookup_field): New.
kono
parents:
diff changeset
582 (lookup_field_fuzzy_r): New.
kono
parents:
diff changeset
583 (lookup_member_fuzzy): New.
kono
parents:
diff changeset
584 * typeck.c (finish_class_member_access_expr): When issuing
kono
parents:
diff changeset
585 a "has no member named" error, call lookup_member_fuzzy, and
kono
parents:
diff changeset
586 offer any result as a suggestion.
kono
parents:
diff changeset
587
kono
parents:
diff changeset
588 2015-11-19 Torvald Riegel <triegel@redhat.com>
kono
parents:
diff changeset
589
kono
parents:
diff changeset
590 * except.c (do_free_exception): Use transactional wrapper.
kono
parents:
diff changeset
591
kono
parents:
diff changeset
592 2015-11-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
593
kono
parents:
diff changeset
594 PR c++/68422
kono
parents:
diff changeset
595 * cp-tree.h (PACK_EXPANSION_SIZEOF_P): New.
kono
parents:
diff changeset
596 * parser.c (cp_parser_sizeof_pack): Set it.
kono
parents:
diff changeset
597 * pt.c (tsubst_copy) [SIZEOF_EXPR]: Likewise.
kono
parents:
diff changeset
598 (tsubst_pack_expansion): Improve T... shortcut for expression packs.
kono
parents:
diff changeset
599
kono
parents:
diff changeset
600 2015-11-19 Ryan Burn <contact@rnburn.com>
kono
parents:
diff changeset
601
kono
parents:
diff changeset
602 PR c++/68396
kono
parents:
diff changeset
603 * pt.c (find_parameter_packs_r) [DECLTYPE_TYPE]: When traversing
kono
parents:
diff changeset
604 the DECLTYPE_TYPE_EXPR, set type_pack_expansion_p to false.
kono
parents:
diff changeset
605
kono
parents:
diff changeset
606 2015-11-19 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
607 Manuel López-Ibáñez <manu@gcc.gnu.org>
kono
parents:
diff changeset
608
kono
parents:
diff changeset
609 PR c++/67409
kono
parents:
diff changeset
610 * decl.c (identify_goto): Add LOC and DIAG_KIND arguments, call
kono
parents:
diff changeset
611 emit_diagnostic instead of permerror.
kono
parents:
diff changeset
612 (check_previous_goto_1): Adjust identify_goto callers, treat all
kono
parents:
diff changeset
613 cases but crossing initialization and entering scope of decl with
kono
parents:
diff changeset
614 non-trivial dtor as unconditional hard errors.
kono
parents:
diff changeset
615 (check_goto): Use identify_goto. Treat all cases but crossing
kono
parents:
diff changeset
616 initialization and entering scope of decl with non-trivial dtor
kono
parents:
diff changeset
617 as unconditional hard errors.
kono
parents:
diff changeset
618
kono
parents:
diff changeset
619 2015-11-19 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
620
kono
parents:
diff changeset
621 * parser.h (struct cp_omp_declare_simd_data): Add clauses member.
kono
parents:
diff changeset
622 (struct cp_parser): Change type the of oacc_routine to
kono
parents:
diff changeset
623 cp_omp_declare_simd_data.
kono
parents:
diff changeset
624 * parser.c (cp_ensure_no_oacc_routine): Rework to use
kono
parents:
diff changeset
625 cp_omp_declare_simd_data.
kono
parents:
diff changeset
626 (cp_parser_simple_declaration): Remove boolean first. Update call to
kono
parents:
diff changeset
627 cp_parser_init_declarator. Don't NULL out oacc_routine.
kono
parents:
diff changeset
628 (cp_parser_init_declarator): Remove boolean first parameter. Update
kono
parents:
diff changeset
629 calls to cp_finalize_oacc_routine.
kono
parents:
diff changeset
630 (cp_parser_late_return_type_opt): Handle acc routines.
kono
parents:
diff changeset
631 (cp_parser_member_declaration): Remove first variable. Handle
kono
parents:
diff changeset
632 acc routines like omp declare simd.
kono
parents:
diff changeset
633 (cp_parser_function_definition_from_specifiers_and_declarator): Update
kono
parents:
diff changeset
634 call to cp_finalize_oacc_routine.
kono
parents:
diff changeset
635 (cp_parser_single_declaration): Update call to
kono
parents:
diff changeset
636 cp_parser_init_declarator.
kono
parents:
diff changeset
637 (cp_parser_save_member_function_body): Remove first_decl parameter.
kono
parents:
diff changeset
638 Update call to cp_finalize_oacc_routine.
kono
parents:
diff changeset
639 (cp_parser_finish_oacc_routine): Delete.
kono
parents:
diff changeset
640 (cp_parser_oacc_routine): Rework to use cp_omp_declare_simd_data.
kono
parents:
diff changeset
641 (cp_parser_late_parsing_oacc_routine): New function.
kono
parents:
diff changeset
642 (cp_finalize_oacc_routine): Remove first argument. Add more error
kono
parents:
diff changeset
643 handling and set the acc routine and 'omp declare target' attributes.
kono
parents:
diff changeset
644 (cp_parser_pragma): Remove unnecessary call to
kono
parents:
diff changeset
645 cp_ensure_no_oacc_routine.
kono
parents:
diff changeset
646
kono
parents:
diff changeset
647 2015-11-17 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
648
kono
parents:
diff changeset
649 * cp-gimplify.c (cp_fold_r): Add support for OACC_LOOP.
kono
parents:
diff changeset
650
kono
parents:
diff changeset
651 2015-11-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
652
kono
parents:
diff changeset
653 PR bootstrap/68346
kono
parents:
diff changeset
654 * typeck.c (build_static_cast_1): Force a NOP when converting to
kono
parents:
diff changeset
655 the same type.
kono
parents:
diff changeset
656
kono
parents:
diff changeset
657 * cp-tree.h (LITERAL_ZERO_P): Remove.
kono
parents:
diff changeset
658 * parser.c (cp_parser_postfix_expression, literal_zeros)
kono
parents:
diff changeset
659 (cp_parser_parenthesized_expression_list): Don't mess with it.
kono
parents:
diff changeset
660
kono
parents:
diff changeset
661 * parser.c (cp_parser_unary_expression): Fold -constant here.
kono
parents:
diff changeset
662 * typeck.c (cp_build_unary_op): Not here.
kono
parents:
diff changeset
663
kono
parents:
diff changeset
664 PR bootstrap/68361
kono
parents:
diff changeset
665 * cvt.c (cp_convert_and_check): Use warning_sentinel to suppress
kono
parents:
diff changeset
666 -Wparentheses.
kono
parents:
diff changeset
667
kono
parents:
diff changeset
668 2015-11-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
669
kono
parents:
diff changeset
670 * constexpr.c (cxx_eval_builtin_function_call): Use cp_fully_fold
kono
parents:
diff changeset
671 to fold arguments to __builtin_constant_p.
kono
parents:
diff changeset
672
kono
parents:
diff changeset
673 2015-11-16 Kirill Yukhin <kirill.yukhin@intel.com>
kono
parents:
diff changeset
674
kono
parents:
diff changeset
675 * parser.c (cp_parser_late_parsing_cilk_simd_fn_info): Look for
kono
parents:
diff changeset
676 "simd" attribute as well. Update error message.
kono
parents:
diff changeset
677
kono
parents:
diff changeset
678 2015-11-14 Trevor Saunders <tbsaunde+gcc@tbsaunde.org>
kono
parents:
diff changeset
679
kono
parents:
diff changeset
680 * parser.c (cp_parser_omp_declare_target): Adjust.
kono
parents:
diff changeset
681
kono
parents:
diff changeset
682 2015-11-14 Trevor Saunders <tbsaunde+gcc@tbsaunde.org>
kono
parents:
diff changeset
683
kono
parents:
diff changeset
684 * vtable-class-hierarchy.c (vtv_generate_init_routine): Adjust.
kono
parents:
diff changeset
685
kono
parents:
diff changeset
686 2015-11-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
687
kono
parents:
diff changeset
688 PR bootstrap/68346
kono
parents:
diff changeset
689 * call.c (build_new_op_1): Don't fold arguments to
kono
parents:
diff changeset
690 warn_tautological_cmp.
kono
parents:
diff changeset
691
kono
parents:
diff changeset
692 2015-11-14 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
693
kono
parents:
diff changeset
694 * semantics.c (finish_omp_clauses): Don't mark
kono
parents:
diff changeset
695 GOMP_MAP_FIRSTPRIVATE_POINTER decls addressable.
kono
parents:
diff changeset
696
kono
parents:
diff changeset
697 2015-11-13 Kai Tietz <ktietz70@googlemail.com>
kono
parents:
diff changeset
698 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
699 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
700
kono
parents:
diff changeset
701 * call.c (build_conditional_expr_1, convert_like_real)
kono
parents:
diff changeset
702 (convert_arg_to_ellipsis, convert_for_arg_passing): Don't fold.
kono
parents:
diff changeset
703 (build_new_op_1, build_over_call, build_cxx_call): Fold for warnings.
kono
parents:
diff changeset
704 * class.c (build_base_path, determine_primary_bases)
kono
parents:
diff changeset
705 (update_vtable_entry_for_fn, check_bitfield_decl)
kono
parents:
diff changeset
706 (layout_nonempty_base_or_field, layout_empty_base)
kono
parents:
diff changeset
707 (propagate_binfo_offsets, include_empty_classes)
kono
parents:
diff changeset
708 (layout_class_type, build_vbase_offset_vtbl_entries): Use
kono
parents:
diff changeset
709 fold_convert.
kono
parents:
diff changeset
710 * constexpr.c (cxx_eval_builtin_function_call): Fold away the NOP_EXPR.
kono
parents:
diff changeset
711 (cxx_eval_call_expression): Handle MEM_REF.
kono
parents:
diff changeset
712 (cxx_eval_pointer_plus_expression): Fold the second operand.
kono
parents:
diff changeset
713 (cxx_eval_constant_expression): Handle MEM_REF, UNARY_PLUS_EXPR.
kono
parents:
diff changeset
714 (fold_simple_1, fold_simple): New.
kono
parents:
diff changeset
715 (maybe_constant_value_1): Factor out from maybe_constant_value.
kono
parents:
diff changeset
716 (cv_cache, maybe_constant_value): Cache results.
kono
parents:
diff changeset
717 (maybe_constant_init): Handle null input.
kono
parents:
diff changeset
718 (potential_constant_expression_1): Handle RESULT_DECL, EMPTY_CLASS_EXPR.
kono
parents:
diff changeset
719 * cp-array-notation.c (build_array_notation_ref): Fold operands.
kono
parents:
diff changeset
720 * cp-gimplify.c (cp_fold_r, cp_fold): New.
kono
parents:
diff changeset
721 (cp_genericize_r): Use fold_convert. Don't fold SIZEOF_EXPR.
kono
parents:
diff changeset
722 (cp_genericize): Fold everything.
kono
parents:
diff changeset
723 (contains_label_1, contains_label_p): New.
kono
parents:
diff changeset
724 (cp_fold, cp_fully_fold): New.
kono
parents:
diff changeset
725 * cp-tree.h (class cache_map): New.
kono
parents:
diff changeset
726 * cvt.c (cp_convert_to_pointer, ocp_convert): Use convert_to_*_nofold.
kono
parents:
diff changeset
727 (cp_convert_and_check): Use cp_fully_fold.
kono
parents:
diff changeset
728 (convert, convert_force): Don't fold.
kono
parents:
diff changeset
729 * decl.c (fold_sizeof_expr): Change from fold_sizeof_expr_r.
kono
parents:
diff changeset
730 (compute_array_index_type): Use cp_fully_fold.
kono
parents:
diff changeset
731 (build_enumerator): Use fold_convert.
kono
parents:
diff changeset
732 * decl2.c (get_guard_cond, set_guard): Use fold_convert.
kono
parents:
diff changeset
733 * init.c (build_zero_init_1): Fold zero-initializers.
kono
parents:
diff changeset
734 (build_new_1): Fold nelts calculations.
kono
parents:
diff changeset
735 (build_vec_delete_1): Fold conversions.
kono
parents:
diff changeset
736 (build_vec_init): Fold maxindex.
kono
parents:
diff changeset
737 * parser.c (cp_parser_binary_expression): Fold LHS of || and &&.
kono
parents:
diff changeset
738 (cp_parser_question_colon_clause): Fold LHS.
kono
parents:
diff changeset
739 * pt.c (convert_nontype_argument): Fold nullptr conversion.
kono
parents:
diff changeset
740 * semantics.c (finish_unary_op_expr): Fold for warnings.
kono
parents:
diff changeset
741 (handle_omp_array_sections_1): Fold length and low bound.
kono
parents:
diff changeset
742 (handle_omp_for_class_iterator): Fold various things.
kono
parents:
diff changeset
743 * tree.c (builtin_valid_in_constant_expr_p): Add
kono
parents:
diff changeset
744 BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE.
kono
parents:
diff changeset
745 (convert_bitfield_to_declared_type): Don't fold.
kono
parents:
diff changeset
746 (handle_init_priority_attribute): Fold.
kono
parents:
diff changeset
747 (fold_if_not_in_template): Remove.
kono
parents:
diff changeset
748 * typeck.c (decay_conversion, build_class_member_access_expr)
kono
parents:
diff changeset
749 (build_simple_component_ref, cp_build_array_ref, build_vec_cmp)
kono
parents:
diff changeset
750 (cp_pointer_int_sum, pointer_diff): Don't fold.
kono
parents:
diff changeset
751 (cp_build_binary_op): Fold for warnings and PMF ops.
kono
parents:
diff changeset
752 (cp_build_unary_op): Fold negation of a constant, nothing else.
kono
parents:
diff changeset
753 (expand_ptrmemfunc_cst): Fold operations.
kono
parents:
diff changeset
754 * typeck2.c (split_nonconstant_init): Fold initializer.
kono
parents:
diff changeset
755 (store_init_value): Likewise.
kono
parents:
diff changeset
756 (check_narrowing): Try folding.
kono
parents:
diff changeset
757 * config-lang.in (gtfiles): Add cp-gimplify.c.
kono
parents:
diff changeset
758
kono
parents:
diff changeset
759 2015-11-13 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
760
kono
parents:
diff changeset
761 * error.c (pedwarn_cxx98): Pass line_table to rich_location ctor.
kono
parents:
diff changeset
762
kono
parents:
diff changeset
763 2015-11-12 James Norris <jnorris@codesourcery.com>
kono
parents:
diff changeset
764
kono
parents:
diff changeset
765 * parser.c (cp_parser_oacc_declare): Remove unused.
kono
parents:
diff changeset
766
kono
parents:
diff changeset
767 2015-11-12 James Norris <jnorris@codesourcery.com>
kono
parents:
diff changeset
768 Joseph Myers <joseph@codesourcery.com>
kono
parents:
diff changeset
769
kono
parents:
diff changeset
770 * parser.c (cp_parser_omp_clause_name): Handle 'device_resident'
kono
parents:
diff changeset
771 clause.
kono
parents:
diff changeset
772 (cp_parser_oacc_data_clause): Handle PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT
kono
parents:
diff changeset
773 and PRAGMA_OMP_CLAUSE_LINK.
kono
parents:
diff changeset
774 (cp_paser_oacc_all_clauses): Handle PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT
kono
parents:
diff changeset
775 and PRAGMA_OMP_CLAUSE_LINK.
kono
parents:
diff changeset
776 (OACC_DECLARE_CLAUSE_MASK): New definition.
kono
parents:
diff changeset
777 (cp_parser_oacc_declare): New function.
kono
parents:
diff changeset
778 (cp_parser_pragma): Handle PRAGMA_OACC_DECLARE.
kono
parents:
diff changeset
779 * pt.c (tsubst_expr): Handle OACC_DECLARE.
kono
parents:
diff changeset
780
kono
parents:
diff changeset
781 2015-11-12 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
782
kono
parents:
diff changeset
783 * pt.c (check_explicit_specialization): Check the namespace after
kono
parents:
diff changeset
784 we choose a template.
kono
parents:
diff changeset
785
kono
parents:
diff changeset
786 2015-11-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
787
kono
parents:
diff changeset
788 * decl.c (duplicate_decls): When combining typedefs, remove the
kono
parents:
diff changeset
789 new type from the variants list.
kono
parents:
diff changeset
790
kono
parents:
diff changeset
791 2015-11-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
792
kono
parents:
diff changeset
793 * pt.c (instantiate_class_template_1): Set function_depth around
kono
parents:
diff changeset
794 instantiation of lambda op().
kono
parents:
diff changeset
795
kono
parents:
diff changeset
796 2015-11-11 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
797
kono
parents:
diff changeset
798 PR c/68107
kono
parents:
diff changeset
799 PR c++/68266
kono
parents:
diff changeset
800 * decl.c (grokdeclarator): Call valid_array_size_p. Remove code
kono
parents:
diff changeset
801 checking the size of an array.
kono
parents:
diff changeset
802
kono
parents:
diff changeset
803 2015-11-11 Dominique d'Humieres <dominiq@lps.ens.fr>
kono
parents:
diff changeset
804
kono
parents:
diff changeset
805 PR bootstrap/68271
kono
parents:
diff changeset
806 * parser.h (cp_token): Update pragma_kind to 8.
kono
parents:
diff changeset
807
kono
parents:
diff changeset
808 2015-11-11 Andrew MacLeod <amacleod@redhat.com>
kono
parents:
diff changeset
809
kono
parents:
diff changeset
810 * call.c: Remove unused header files.
kono
parents:
diff changeset
811 * class.c: Likewise.
kono
parents:
diff changeset
812 * constexpr.c: Likewise.
kono
parents:
diff changeset
813 * cp-array-notation.c: Likewise.
kono
parents:
diff changeset
814 * cp-cilkplus.c: Likewise.
kono
parents:
diff changeset
815 * cp-gimplify.c: Likewise.
kono
parents:
diff changeset
816 * cp-lang.c: Likewise.
kono
parents:
diff changeset
817 * cp-objcp-common.c: Likewise.
kono
parents:
diff changeset
818 * cp-ubsan.c: Likewise.
kono
parents:
diff changeset
819 * cvt.c: Likewise.
kono
parents:
diff changeset
820 * cxx-pretty-print.c: Likewise.
kono
parents:
diff changeset
821 * decl.c: Likewise.
kono
parents:
diff changeset
822 * decl2.c: Likewise.
kono
parents:
diff changeset
823 * dump.c: Likewise.
kono
parents:
diff changeset
824 * error.c: Likewise.
kono
parents:
diff changeset
825 * except.c: Likewise.
kono
parents:
diff changeset
826 * expr.c: Likewise.
kono
parents:
diff changeset
827 * friend.c: Likewise.
kono
parents:
diff changeset
828 * g++spec.c: Likewise.
kono
parents:
diff changeset
829 * init.c: Likewise.
kono
parents:
diff changeset
830 * lambda.c: Likewise.
kono
parents:
diff changeset
831 * lex.c: Likewise.
kono
parents:
diff changeset
832 * mangle.c: Likewise.
kono
parents:
diff changeset
833 * method.c: Likewise.
kono
parents:
diff changeset
834 * name-lookup.c: Likewise.
kono
parents:
diff changeset
835 * optimize.c: Likewise.
kono
parents:
diff changeset
836 * parser.c: Likewise.
kono
parents:
diff changeset
837 * pt.c: Likewise.
kono
parents:
diff changeset
838 * ptree.c: Likewise.
kono
parents:
diff changeset
839 * repo.c: Likewise.
kono
parents:
diff changeset
840 * rtti.c: Likewise.
kono
parents:
diff changeset
841 * search.c: Likewise.
kono
parents:
diff changeset
842 * semantics.c: Likewise.
kono
parents:
diff changeset
843 * tree.c: Likewise.
kono
parents:
diff changeset
844 * typeck.c: Likewise.
kono
parents:
diff changeset
845 * typeck2.c: Likewise.
kono
parents:
diff changeset
846 * vtable-class-hierarchy.c: Likewise.
kono
parents:
diff changeset
847
kono
parents:
diff changeset
848 2015-11-09 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
849
kono
parents:
diff changeset
850 * parser.c (cp_finalize_oacc_routine): New boolean first argument.
kono
parents:
diff changeset
851 (cp_ensure_no_oacc_routine): Update call to cp_finalize_oacc_routine.
kono
parents:
diff changeset
852 (cp_parser_simple_declaration): Maintain a boolean first to keep track
kono
parents:
diff changeset
853 of each new declarator. Propagate it to cp_parser_init_declarator.
kono
parents:
diff changeset
854 (cp_parser_init_declarator): New boolean first argument. Propagate it
kono
parents:
diff changeset
855 to cp_parser_save_member_function_body and cp_finalize_oacc_routine.
kono
parents:
diff changeset
856 (cp_parser_member_declaration): Likewise.
kono
parents:
diff changeset
857 (cp_parser_single_declaration): Update call to
kono
parents:
diff changeset
858 cp_parser_init_declarator.
kono
parents:
diff changeset
859 (cp_parser_save_member_function_body): New boolean first_decl argument.
kono
parents:
diff changeset
860 Propagate it to cp_finalize_oacc_routine.
kono
parents:
diff changeset
861 (cp_parser_finish_oacc_routine): New boolean first argument. Use it to
kono
parents:
diff changeset
862 determine if multiple declarators follow a routine construct.
kono
parents:
diff changeset
863 (cp_parser_oacc_routine): Update call to cp_parser_finish_oacc_routine.
kono
parents:
diff changeset
864
kono
parents:
diff changeset
865 2015-10-19 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
866
kono
parents:
diff changeset
867 PR c++/67913
kono
parents:
diff changeset
868 PR c++/67927
kono
parents:
diff changeset
869 * call.c (build_operator_new_call): Do not assume size_check
kono
parents:
diff changeset
870 is non-null, analogously to the top half of the function.
kono
parents:
diff changeset
871 * init.c (build_new_1): Detect and diagnose array sizes in
kono
parents:
diff changeset
872 excess of the maximum of roughly SIZE_MAX / 2.
kono
parents:
diff changeset
873 Insert a runtime check only for arrays with a non-constant size.
kono
parents:
diff changeset
874 (build_new): Detect and diagnose negative array sizes.
kono
parents:
diff changeset
875
kono
parents:
diff changeset
876 2015-11-09 Thomas Schwinge <thomas@codesourcery.com>
kono
parents:
diff changeset
877 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
878 James Norris <jnorris@codesourcery.com>
kono
parents:
diff changeset
879 Julian Brown <julian@codesourcery.com>
kono
parents:
diff changeset
880 Nathan Sidwell <nathan@codesourcery.com>
kono
parents:
diff changeset
881
kono
parents:
diff changeset
882 * parser.h (struct cp_parser): Add oacc_routine field.
kono
parents:
diff changeset
883 * parser.c (cp_ensure_no_oacc_routine): New.
kono
parents:
diff changeset
884 (cp_parser_new): Initialize oacc_routine field.
kono
parents:
diff changeset
885 (cp_parser_linkage_specification): Call cp_ensure_no_oacc_routine.
kono
parents:
diff changeset
886 (cp_parser_namespace_definition,
kono
parents:
diff changeset
887 cp_parser_class_specifier_1): Likewise.
kono
parents:
diff changeset
888 (cp_parser_init_declarator): Call cp_finalize_oacc_routine.
kono
parents:
diff changeset
889 (cp_parser_function_definition,
kono
parents:
diff changeset
890 cp_parser_save_member_function_body): Likewise.
kono
parents:
diff changeset
891 (OACC_ROUTINE_CLAUSE_MASK): New.
kono
parents:
diff changeset
892 (cp_parser_finish_oacc_routine, cp_parser_oacc_routine,
kono
parents:
diff changeset
893 cp_finalize_oacc_routine): New.
kono
parents:
diff changeset
894 (cp_parser_pragma): Adjust omp_declare_simd checking. Call
kono
parents:
diff changeset
895 cp_ensure_no_oacc_routine.
kono
parents:
diff changeset
896 (cp_parser_pragma): Add OpenACC routine handling.
kono
parents:
diff changeset
897
kono
parents:
diff changeset
898 2015-11-08 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
899
kono
parents:
diff changeset
900 PR c++/67942
kono
parents:
diff changeset
901 * cp/init.c (warn_placement_new_too_small): Convert integer
kono
parents:
diff changeset
902 operand of POINTER_PLUS_EXPR to ssize_t to determine its signed
kono
parents:
diff changeset
903 value.
kono
parents:
diff changeset
904
kono
parents:
diff changeset
905 2015-11-06 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
906
kono
parents:
diff changeset
907 * error.c (cp_printer): Update for new "caret_p" param for
kono
parents:
diff changeset
908 textinfo::set_location.
kono
parents:
diff changeset
909 (pedwarn_cxx98): Update for change in signature of
kono
parents:
diff changeset
910 diagnostic_set_info.
kono
parents:
diff changeset
911
kono
parents:
diff changeset
912 2015-11-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
913
kono
parents:
diff changeset
914 Support non-type constrained-type-specifiers.
kono
parents:
diff changeset
915 * parser.c (check_type_concept): Remove.
kono
parents:
diff changeset
916 (cp_parser_maybe_constrained_type_specifier): Don't call it.
kono
parents:
diff changeset
917 (synthesize_implicit_template_parm): Handle non-type and template
kono
parents:
diff changeset
918 template parameters. Also compare extra args. Return the decl.
kono
parents:
diff changeset
919 (cp_parser_template_argument): Handle constrained-type-specifiers for
kono
parents:
diff changeset
920 non-type template parameters.
kono
parents:
diff changeset
921 (finish_constrained_template_template_parm): Split out from
kono
parents:
diff changeset
922 cp_parser_constrained_template_template_parm.
kono
parents:
diff changeset
923 (cp_parser_nonclass_name): Move some logic into
kono
parents:
diff changeset
924 cp_parser_maybe_concept_name.
kono
parents:
diff changeset
925 (cp_parser_init_declarator): Fix error recovery.
kono
parents:
diff changeset
926 (get_concept_from_constraint): Remove.
kono
parents:
diff changeset
927 (cp_parser_simple_type_specifier): Adjust for
kono
parents:
diff changeset
928 synthesize_implicit_template_parm returning the decl.
kono
parents:
diff changeset
929 * constraint.cc (placeholder_extract_concept_and_args)
kono
parents:
diff changeset
930 (equivalent_placeholder_constraints): Also handle TYPE_DECL
kono
parents:
diff changeset
931 constrained parms.
kono
parents:
diff changeset
932
kono
parents:
diff changeset
933 * pt.c (push_inline_template_parms_recursive): Don't recreate the
kono
parents:
diff changeset
934 CONST_DECL.
kono
parents:
diff changeset
935
kono
parents:
diff changeset
936 2015-11-06 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
kono
parents:
diff changeset
937
kono
parents:
diff changeset
938 * init.c (warn_placement_new_too_small): Use %wu format
kono
parents:
diff changeset
939 rather than %lu when printing bytes_avail.
kono
parents:
diff changeset
940
kono
parents:
diff changeset
941 2015-11-05 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
942 Thomas Schwinge <thomas@codesourcery.com>
kono
parents:
diff changeset
943 James Norris <jnorris@codesourcery.com>
kono
parents:
diff changeset
944
kono
parents:
diff changeset
945 * parser.c (cp_parser_omp_clause_name): Add support for
kono
parents:
diff changeset
946 PRAGMA_OACC_CLAUSE_INDEPENDENT and PRAGMA_OACC_CLAUSE_TILE.
kono
parents:
diff changeset
947 (cp_parser_oacc_shape_clause): Allow pointer variables as gang static
kono
parents:
diff changeset
948 arguments.
kono
parents:
diff changeset
949 (cp_parser_oacc_clause_tile): New function.
kono
parents:
diff changeset
950 (cp_parser_omp_clause_default): Add is_oacc argument. Handle
kono
parents:
diff changeset
951 default(none) in OpenACC.
kono
parents:
diff changeset
952 (cp_parser_oacc_all_clauses): Add support for
kono
parents:
diff changeset
953 (cp_parser_omp_all_clauses): Update call to
kono
parents:
diff changeset
954 cp_parser_omp_clause_default.
kono
parents:
diff changeset
955 PRAGMA_OACC_CLAUSE_{DEFAULT,INDEPENDENT,TILE,PRIVATE,FIRSTPRIVATE}.
kono
parents:
diff changeset
956 (OACC_LOOP_CLAUSE_MASK): Add PRAGMA_OACC_CLAUSE_{PRIVATE,INDEPENDENT,
kono
parents:
diff changeset
957 TILE}.
kono
parents:
diff changeset
958 (OACC_KERNELS_MASK): Add PRAGMA_OACC_CLAUSE_DEFAULT.
kono
parents:
diff changeset
959 (OACC_PARALLEL_MASK): Add PRAGMA_OACC_CLAUSE_{DEFAULT,PRIVATE,
kono
parents:
diff changeset
960 FIRSTPRIVATE}.
kono
parents:
diff changeset
961 (cp_parser_oacc_update): Update the error message for missing clauses.
kono
parents:
diff changeset
962 * semantics.c (finish_omp_clauses): Add support for
kono
parents:
diff changeset
963 OMP_CLAUSE_INDEPENDENT and OMP_CLAUSE_TILE.
kono
parents:
diff changeset
964
kono
parents:
diff changeset
965 2015-11-05 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
966
kono
parents:
diff changeset
967 PR c++/67942
kono
parents:
diff changeset
968 * cp/init.c (warn_placement_new_too_small): Avoid assuming
kono
parents:
diff changeset
969 the size of the first operand of placement new or its type
kono
parents:
diff changeset
970 is known.
kono
parents:
diff changeset
971
kono
parents:
diff changeset
972 2015-11-05 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
973
kono
parents:
diff changeset
974 PR c++/67942
kono
parents:
diff changeset
975 * cp/init.c (warn_placement_new_too_small): New function.
kono
parents:
diff changeset
976 (build_new_1): Call it.
kono
parents:
diff changeset
977
kono
parents:
diff changeset
978 2015-11-05 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
979
kono
parents:
diff changeset
980 PR c++/67846
kono
parents:
diff changeset
981 * parser.c (cp_parser_lambda_body): Check lambda_return_type
kono
parents:
diff changeset
982 return value.
kono
parents:
diff changeset
983 * typeck2.c (cxx_incomplete_type_diagnostic): Print member or
kono
parents:
diff changeset
984 member function used invalidly.
kono
parents:
diff changeset
985
kono
parents:
diff changeset
986 2015-11-05 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
987 Ilya Verbin <ilya.verbin@intel.com>
kono
parents:
diff changeset
988
kono
parents:
diff changeset
989 * cp-tree.h (finish_omp_for): Add ORIG_INITS argument.
kono
parents:
diff changeset
990 (omp_privatize_field): Add SHARED argument.
kono
parents:
diff changeset
991 * parser.c: Include context.h.
kono
parents:
diff changeset
992 (cp_parser_omp_clause_schedule): Parse schedule
kono
parents:
diff changeset
993 modifiers, diagnose monotonic together with nonmonotonic.
kono
parents:
diff changeset
994 (cp_parser_omp_clause_linear): Add DECLARE_SIMD argument. Parse
kono
parents:
diff changeset
995 parameter name as linear step as id-expression rather than expression.
kono
parents:
diff changeset
996 (cp_parser_omp_all_clauses): Adjust caller.
kono
parents:
diff changeset
997 (cp_parser_omp_for_loop_init): Add ORIG_INIT argument,
kono
parents:
diff changeset
998 initialize it. Adjust omp_privatize_field caller.
kono
parents:
diff changeset
999 (cp_parser_omp_for_loop): Compute orig_inits, pass it's address
kono
parents:
diff changeset
1000 to finish_omp_for.
kono
parents:
diff changeset
1001 (OMP_DISTRIBUTE_CLAUSE_MASK): Add lastprivate clause.
kono
parents:
diff changeset
1002 (cp_parser_omp_target_data,
kono
parents:
diff changeset
1003 cp_parser_omp_target_enter_data,
kono
parents:
diff changeset
1004 cp_parser_omp_target_exit_data): Allow GOMP_MAP_ALWAYS_POINTER
kono
parents:
diff changeset
1005 and GOMP_MAP_FIRSTPRIVATE_REFERENCE.
kono
parents:
diff changeset
1006 (cp_parser_omp_target): Likewise. Evaluate num_teams and
kono
parents:
diff changeset
1007 thread_limit expressions on combined target teams before the target.
kono
parents:
diff changeset
1008 (cp_parser_omp_declare_target): If decl has "omp declare target" or
kono
parents:
diff changeset
1009 "omp declare target link" attribute, and cgraph or varpool node already
kono
parents:
diff changeset
1010 exists, then set corresponding flags. Call finish_omp_clauses
kono
parents:
diff changeset
1011 in the parenthesized extended-list syntax case. Call
kono
parents:
diff changeset
1012 cp_parser_require_pragma_eol instead of cp_parser_skip_to_pragma_eol.
kono
parents:
diff changeset
1013 (cp_parser_omp_end_declare_target): Call cp_parser_require_pragma_eol
kono
parents:
diff changeset
1014 instead of cp_parser_skip_to_pragma_eol.
kono
parents:
diff changeset
1015 * decl2.c (cplus_decl_attributes): Don't diagnose block scope vars
kono
parents:
diff changeset
1016 inside declare target.
kono
parents:
diff changeset
1017 * pt.c (tsubst_omp_clauses): If OMP_CLAUSE_LINEAR_VARIABLE_STRIDE,
kono
parents:
diff changeset
1018 use tsubst_omp_clause_decl instead of tsubst_expr on
kono
parents:
diff changeset
1019 OMP_CLAUSE_LINEAR_STEP. Handle non-static data members in shared
kono
parents:
diff changeset
1020 clauses.
kono
parents:
diff changeset
1021 (tsubst_omp_for_iterator): Adjust omp_privatize_field caller.
kono
parents:
diff changeset
1022 (tsubst_find_omp_teams): New function.
kono
parents:
diff changeset
1023 (tsubst_expr): Evaluate num_teams and thread_limit expressions on
kono
parents:
diff changeset
1024 combined target teams before the target. Use OMP_FOR_ORIG_DECLS for
kono
parents:
diff changeset
1025 all OpenMP/OpenACC/Cilk+ looping constructs. Adjust finish_omp_for
kono
parents:
diff changeset
1026 caller.
kono
parents:
diff changeset
1027 * semantics.c (omp_privatize_field): Add SHARED argument, if true,
kono
parents:
diff changeset
1028 always create artificial var and never put it into the hash table
kono
parents:
diff changeset
1029 or vector.
kono
parents:
diff changeset
1030 (handle_omp_array_sections_1): Adjust omp_privatize_field caller.
kono
parents:
diff changeset
1031 Allow non-zero low-bound on OMP_CLAUSE_REDUCTION array sections.
kono
parents:
diff changeset
1032 (handle_omp_array_sections): For structure element
kono
parents:
diff changeset
1033 based array sections use GOMP_MAP_ALWAYS_POINTER instead of
kono
parents:
diff changeset
1034 GOMP_MAP_FIRSTPRIVATE_POINTER. Encode low-bound into the MEM_REF,
kono
parents:
diff changeset
1035 either into the constant offset, or for variable low-bound using
kono
parents:
diff changeset
1036 POINTER_PLUS_EXPR.
kono
parents:
diff changeset
1037 (finish_omp_clauses): Adjust omp_privatize_field caller. Drop
kono
parents:
diff changeset
1038 generic_field_head, structure elements are now always mapped even
kono
parents:
diff changeset
1039 as array section bases, diagnose same var in data sharing and
kono
parents:
diff changeset
1040 mapping clauses. For references map what they refer to using
kono
parents:
diff changeset
1041 GOMP_MAP_ALWAYS_POINTER for structure elements and
kono
parents:
diff changeset
1042 GOMP_MAP_FIRSTPRIVATE_REFERENCE otherwise. Diagnose if linear step
kono
parents:
diff changeset
1043 on declare simd is neither a constant nor a uniform parameter.
kono
parents:
diff changeset
1044 Allow non-static data members on shared clauses. Look through
kono
parents:
diff changeset
1045 POINTER_PLUS_EXPR for array section reductions. Diagnose nonmonotonic
kono
parents:
diff changeset
1046 modifier on kinds other than dynamic or guided or nonmonotonic
kono
parents:
diff changeset
1047 modifier together with ordered clause. Diagnose the same var or
kono
parents:
diff changeset
1048 function appearing multiple times on the same directive. Fix up
kono
parents:
diff changeset
1049 wording for the to clause if t is neither a FUNCTION_DECL nor a
kono
parents:
diff changeset
1050 VAR_DECL, use special wording for OVERLOADs and TEMPLATE_ID_EXPR.
kono
parents:
diff changeset
1051 (handle_omp_for_class_iterator): Add ORIG_DECLS argument. Call
kono
parents:
diff changeset
1052 c_omp_check_loop_iv_exprs on cond.
kono
parents:
diff changeset
1053 (finish_omp_for): Add ORIG_INITS argument. Call
kono
parents:
diff changeset
1054 c_omp_check_loop_iv_exprs on ORIG_INITS elements. Adjust
kono
parents:
diff changeset
1055 handle_omp_for_class_iterator caller. Call c_omp_check_loop_iv.
kono
parents:
diff changeset
1056 Call add_stmt.
kono
parents:
diff changeset
1057 (finish_omp_atomic): Adjust c_finish_omp_atomic caller.
kono
parents:
diff changeset
1058
kono
parents:
diff changeset
1059 2015-11-04 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
1060
kono
parents:
diff changeset
1061 * (cp_parser_oacc_single_int_clause): New function.
kono
parents:
diff changeset
1062 (cp_parser_oacc_clause_vector_length): Delete.
kono
parents:
diff changeset
1063 (cp_parser_omp_clause_num_gangs): Delete.
kono
parents:
diff changeset
1064 (cp_parser_omp_clause_num_workers): Delete.
kono
parents:
diff changeset
1065 (cp_parser_oacc_all_clauses): Use cp_parser_oacc_single_int_clause
kono
parents:
diff changeset
1066 for num_gangs, num_workers and vector_length.
kono
parents:
diff changeset
1067
kono
parents:
diff changeset
1068 2015-11-04 Mikhail Maltsev <maltsevm@gmail.com>
kono
parents:
diff changeset
1069
kono
parents:
diff changeset
1070 * call.c (validate_conversion_obstack): Define unconditionally.
kono
parents:
diff changeset
1071 * constexpr.c (maybe_constant_value, fold_non_dependent_expr): Use
kono
parents:
diff changeset
1072 gcc_checking_assert.
kono
parents:
diff changeset
1073 * cp-tree.h: Use CHECKING_P instead of ENABLE_CHECKING.
kono
parents:
diff changeset
1074 * decl2.c (cxx_post_compilation_parsing_cleanups): Use flag_checking.
kono
parents:
diff changeset
1075 * mangle.c (add_substitution): Likewise.
kono
parents:
diff changeset
1076 * method.c (maybe_explain_implicit_delete): Likewise.
kono
parents:
diff changeset
1077 * parser.c (cp_parser_template_argument_list): Remove conditional
kono
parents:
diff changeset
1078 compilation.
kono
parents:
diff changeset
1079 * pt.c (check_unstripped_args): Rename to...
kono
parents:
diff changeset
1080 (verify_unstripped_args): ... this and remove conditional compilation.
kono
parents:
diff changeset
1081 (retrieve_specialization): Guard call of verify_unstripped_args with
kono
parents:
diff changeset
1082 flag_checking.
kono
parents:
diff changeset
1083 (template_parm_to_arg): Remove conditional compilation.
kono
parents:
diff changeset
1084 (template_parms_to_args, coerce_template_parameter_pack,
kono
parents:
diff changeset
1085 coerce_template_parms): Likewise.
kono
parents:
diff changeset
1086 (tsubst_copy): Use flag_checking.
kono
parents:
diff changeset
1087 (type_unification_real): Remove conditional compilation.
kono
parents:
diff changeset
1088 (build_non_dependent_expr): Use flag_checking.
kono
parents:
diff changeset
1089 * tree.c (build_target_expr): Remove conditional compilation, use
kono
parents:
diff changeset
1090 gcc_checking_assert.
kono
parents:
diff changeset
1091 * typeck.c (comptypes): Likewise.
kono
parents:
diff changeset
1092 * typeck2.c (digest_init_r): Likewise.
kono
parents:
diff changeset
1093
kono
parents:
diff changeset
1094 2015-11-03 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1095
kono
parents:
diff changeset
1096 * pt.c (struct find_parameter_pack_data): Add
kono
parents:
diff changeset
1097 type_pack_expansion_p field.
kono
parents:
diff changeset
1098 (find_parameter_packs_r): Use it to turn 'auto' into a parameter pack.
kono
parents:
diff changeset
1099 (uses_parameter_packs, make_pack_expansion)
kono
parents:
diff changeset
1100 (check_for_bare_parameter_packs, fixed_parameter_pack_p): Set it.
kono
parents:
diff changeset
1101
kono
parents:
diff changeset
1102 2015-11-03 Thomas Schwinge <thomas@codesourcery.com>
kono
parents:
diff changeset
1103 Chung-Lin Tang <cltang@codesourcery.com>
kono
parents:
diff changeset
1104
kono
parents:
diff changeset
1105 * parser.c (cp_parser_omp_construct, cp_parser_pragma): Handle
kono
parents:
diff changeset
1106 PRAGMA_OACC_ATOMIC.
kono
parents:
diff changeset
1107
kono
parents:
diff changeset
1108 2015-10-31 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
1109
kono
parents:
diff changeset
1110 Remove the implementation of N3994, terse range-for loops.
kono
parents:
diff changeset
1111 * parser.c (cp_parser_for_init_statement): Remove the parsing
kono
parents:
diff changeset
1112 of a terse range-for.
kono
parents:
diff changeset
1113
kono
parents:
diff changeset
1114 2015-10-31 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1115
kono
parents:
diff changeset
1116 Implement multiple 'auto' feature from Concepts TS.
kono
parents:
diff changeset
1117 * parser.c (cp_parser_type_id_1): Allow 'auto' if -fconcepts.
kono
parents:
diff changeset
1118 (cp_parser_template_type_arg): Likewise.
kono
parents:
diff changeset
1119 (get_concept_from_constraint): Split out most logic to...
kono
parents:
diff changeset
1120 * constraint.cc (placeholder_extract_concept_and_args): ...here.
kono
parents:
diff changeset
1121 (equivalent_placeholder_constraints, hash_placeholder_constraint): New.
kono
parents:
diff changeset
1122 * cxx-pretty-print.c (pp_cxx_constrained_type_spec): New.
kono
parents:
diff changeset
1123 * cxx-pretty-print.h: Declare it.
kono
parents:
diff changeset
1124 * error.c (dump_type) [TEMPLATE_TYPE_PARM]: Call it.
kono
parents:
diff changeset
1125 * pt.c (is_auto_r, extract_autos_r, extract_autos, auto_hash): New.
kono
parents:
diff changeset
1126 (type_uses_auto): Use is_auto_r.
kono
parents:
diff changeset
1127 (do_auto_deduction): Handle multiple 'auto's if -fconcepts.
kono
parents:
diff changeset
1128 * typeck.c (structural_comptypes) [TEMPLATE_TYPE_PARM]: Compare
kono
parents:
diff changeset
1129 constraints.
kono
parents:
diff changeset
1130
kono
parents:
diff changeset
1131 * pt.c (for_each_template_parm_r): Use WALK_SUBTREE.
kono
parents:
diff changeset
1132 Return a meaningful value rather than error_mark_node.
kono
parents:
diff changeset
1133 (for_each_template_parm): Return a tree.
kono
parents:
diff changeset
1134 (uses_template_parms_level): Return bool.
kono
parents:
diff changeset
1135 * cp-tree.h: Adjust.
kono
parents:
diff changeset
1136
kono
parents:
diff changeset
1137 * pt.c (unify): Don't diagnose no common base if we already have
kono
parents:
diff changeset
1138 the same template.
kono
parents:
diff changeset
1139 (do_auto_deduction): Explain deduction failure.
kono
parents:
diff changeset
1140
kono
parents:
diff changeset
1141 * pt.c (hash_tmpl_and_args): Use iterative_hash_object on template
kono
parents:
diff changeset
1142 uid.
kono
parents:
diff changeset
1143
kono
parents:
diff changeset
1144 * parser.c (synthesize_implicit_template_parm)
kono
parents:
diff changeset
1145 (finish_fully_implicit_template): Make static.
kono
parents:
diff changeset
1146
kono
parents:
diff changeset
1147 2015-10-29 Andrew MacLeod <amacleod@redhat.com>
kono
parents:
diff changeset
1148
kono
parents:
diff changeset
1149 * call.c: Reorder #include's and remove duplicates.
kono
parents:
diff changeset
1150 * class.c: Likewise.
kono
parents:
diff changeset
1151 * constexpr.c: Likewise.
kono
parents:
diff changeset
1152 * cp-array-notation.c: Likewise.
kono
parents:
diff changeset
1153 * cp-cilkplus.c: Likewise.
kono
parents:
diff changeset
1154 * cp-gimplify.c: Likewise.
kono
parents:
diff changeset
1155 * cp-lang.c: Likewise.
kono
parents:
diff changeset
1156 * cp-objcp-common.c: Likewise.
kono
parents:
diff changeset
1157 * cp-ubsan.c: Likewise.
kono
parents:
diff changeset
1158 * cvt.c: Likewise.
kono
parents:
diff changeset
1159 * cxx-pretty-print.c: Likewise.
kono
parents:
diff changeset
1160 * decl.c: Likewise.
kono
parents:
diff changeset
1161 * decl2.c: Likewise.
kono
parents:
diff changeset
1162 * dump.c: Likewise.
kono
parents:
diff changeset
1163 * error.c: Likewise.
kono
parents:
diff changeset
1164 * except.c: Likewise.
kono
parents:
diff changeset
1165 * expr.c: Likewise.
kono
parents:
diff changeset
1166 * friend.c: Likewise.
kono
parents:
diff changeset
1167 * init.c: Likewise.
kono
parents:
diff changeset
1168 * lambda.c: Likewise.
kono
parents:
diff changeset
1169 * lex.c: Likewise.
kono
parents:
diff changeset
1170 * mangle.c: Likewise.
kono
parents:
diff changeset
1171 * method.c: Likewise.
kono
parents:
diff changeset
1172 * name-lookup.c: Likewise.
kono
parents:
diff changeset
1173 * optimize.c: Likewise.
kono
parents:
diff changeset
1174 * parser.c: Likewise.
kono
parents:
diff changeset
1175 * pt.c: Likewise.
kono
parents:
diff changeset
1176 * ptree.c: Likewise.
kono
parents:
diff changeset
1177 * repo.c: Likewise.
kono
parents:
diff changeset
1178 * rtti.c: Likewise.
kono
parents:
diff changeset
1179 * search.c: Likewise.
kono
parents:
diff changeset
1180 * semantics.c: Likewise.
kono
parents:
diff changeset
1181 * tree.c: Likewise.
kono
parents:
diff changeset
1182 * typeck.c: Likewise.
kono
parents:
diff changeset
1183 * typeck2.c: Likewise.
kono
parents:
diff changeset
1184 * vtable-class-hierarchy.c: Likewise.
kono
parents:
diff changeset
1185
kono
parents:
diff changeset
1186 2015-10-29 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1187
kono
parents:
diff changeset
1188 PR c++/67845
kono
parents:
diff changeset
1189 * decl.c (grokfndecl): In case of erroneous cv-qualified non-member
kono
parents:
diff changeset
1190 functions consistently reset TREE_TYPE (decl) too.
kono
parents:
diff changeset
1191
kono
parents:
diff changeset
1192 2015-10-28 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1193
kono
parents:
diff changeset
1194 DR 1518
kono
parents:
diff changeset
1195 * class.c (type_has_user_provided_or_explicit_constructor): New.
kono
parents:
diff changeset
1196 (check_bases_and_members): Use it.
kono
parents:
diff changeset
1197 * cp-tree.h: Declare it.
kono
parents:
diff changeset
1198
kono
parents:
diff changeset
1199 2015-10-27 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
1200 Thomas Schwinge <thomas@codesourcery.com>
kono
parents:
diff changeset
1201 James Norris <jnorris@codesourcery.com>
kono
parents:
diff changeset
1202 Joseph Myers <joseph@codesourcery.com>
kono
parents:
diff changeset
1203 Julian Brown <julian@codesourcery.com>
kono
parents:
diff changeset
1204 Nathan Sidwell <nathan@codesourcery.com>
kono
parents:
diff changeset
1205 Bernd Schmidt <bschmidt@redhat.com>
kono
parents:
diff changeset
1206
kono
parents:
diff changeset
1207 * parser.c (cp_parser_omp_clause_name): Add auto, gang, seq,
kono
parents:
diff changeset
1208 vector, worker.
kono
parents:
diff changeset
1209 (cp_parser_oacc_simple_clause): New.
kono
parents:
diff changeset
1210 (cp_parser_oacc_shape_clause): New.
kono
parents:
diff changeset
1211 (cp_parser_oacc_all_clauses): Add auto, gang, seq, vector, worker.
kono
parents:
diff changeset
1212 (OACC_LOOP_CLAUSE_MASK): Likewise.
kono
parents:
diff changeset
1213 * semantics.c (finish_omp_clauses): Add auto, gang, seq, vector,
kono
parents:
diff changeset
1214 worker. Unify the handling of teams, tasks and vector_length with
kono
parents:
diff changeset
1215 the other loop shape clauses.
kono
parents:
diff changeset
1216
kono
parents:
diff changeset
1217 2015-10-27 Thomas Schwinge <thomas@codesourcery.com>
kono
parents:
diff changeset
1218 James Norris <jnorris@codesourcery.com>
kono
parents:
diff changeset
1219 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
1220
kono
parents:
diff changeset
1221 PR c/64765
kono
parents:
diff changeset
1222 PR c/64880
kono
parents:
diff changeset
1223 * cp-tree.h (finish_oacc_kernels, finish_oacc_parallel): Don't
kono
parents:
diff changeset
1224 declare functions.
kono
parents:
diff changeset
1225 (finish_omp_construct): Declare function.
kono
parents:
diff changeset
1226 * parser.c (cp_parser_oacc_loop): Add p_name, mask, cclauses
kono
parents:
diff changeset
1227 formal parameters, and handle these. Adjust all users.
kono
parents:
diff changeset
1228 (cp_parser_oacc_kernels, cp_parser_oacc_parallel): Merge functions
kono
parents:
diff changeset
1229 into...
kono
parents:
diff changeset
1230 (cp_parser_oacc_kernels_parallel): ... this new function. Adjust
kono
parents:
diff changeset
1231 all users.
kono
parents:
diff changeset
1232 * semantics.c (finish_oacc_kernels, finish_oacc_parallel): Merge functions into...
kono
parents:
diff changeset
1233 (finish_omp_construct): ... this new function.
kono
parents:
diff changeset
1234
kono
parents:
diff changeset
1235 2015-10-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1236
kono
parents:
diff changeset
1237 DR 2179
kono
parents:
diff changeset
1238 * pt.c (process_partial_specialization): Handle error_mark_node
kono
parents:
diff changeset
1239 from most_specialized_partial_spec.
kono
parents:
diff changeset
1240
kono
parents:
diff changeset
1241 2015-10-23 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1242
kono
parents:
diff changeset
1243 DR 1518
kono
parents:
diff changeset
1244 DR 1630
kono
parents:
diff changeset
1245 PR c++/54835
kono
parents:
diff changeset
1246 PR c++/60417
kono
parents:
diff changeset
1247 * call.c (convert_like_real): Value-initialization can't use
kono
parents:
diff changeset
1248 explicit constructors in C++11 and up.
kono
parents:
diff changeset
1249
kono
parents:
diff changeset
1250 PR c++/67813
kono
parents:
diff changeset
1251 * constexpr.c (cxx_eval_store_expression): Always use *valp if
kono
parents:
diff changeset
1252 set.
kono
parents:
diff changeset
1253
kono
parents:
diff changeset
1254 2015-10-22 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1255
kono
parents:
diff changeset
1256 * call.c (add_template_conv_candidate): Pass DEDUCE_CALL.
kono
parents:
diff changeset
1257 (add_template_candidate_real): Handle it.
kono
parents:
diff changeset
1258 * pt.c (fn_type_unification): Handle it.
kono
parents:
diff changeset
1259
kono
parents:
diff changeset
1260 * call.c (add_conv_candidate): Remove first_arg parm.
kono
parents:
diff changeset
1261 (add_template_conv_candidate): Likewise.
kono
parents:
diff changeset
1262 (add_template_candidate_real): Don't pass it.
kono
parents:
diff changeset
1263 (build_op_call_1): Likewise.
kono
parents:
diff changeset
1264
kono
parents:
diff changeset
1265 2015-10-22 Richard Biener <rguenther@suse.de>
kono
parents:
diff changeset
1266
kono
parents:
diff changeset
1267 * semantics.c (cp_finish_omp_clause_depend_sink): Properly convert
kono
parents:
diff changeset
1268 before folding a MINUS_EXPR.
kono
parents:
diff changeset
1269 (finish_omp_clauses): Likewise.
kono
parents:
diff changeset
1270
kono
parents:
diff changeset
1271 2015-10-21 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1272
kono
parents:
diff changeset
1273 PR c++/66781
kono
parents:
diff changeset
1274 * parser.c (cp_parser_enum_specifier): Upon error_at set
kono
parents:
diff changeset
1275 nested_name_specifier to error_mark_node; improve error message.
kono
parents:
diff changeset
1276
kono
parents:
diff changeset
1277 2015-10-21 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1278
kono
parents:
diff changeset
1279 PR c++/67847
kono
parents:
diff changeset
1280 * parser.c (cp_parser_enum_specifier): Reject a nested_name_specifier
kono
parents:
diff changeset
1281 which doesn't name a class or namespace.
kono
parents:
diff changeset
1282
kono
parents:
diff changeset
1283 2015-10-21 Ilya Enkovich <enkovich.gnu@gmail.com>
kono
parents:
diff changeset
1284
kono
parents:
diff changeset
1285 * call.c (build_conditional_expr_1): Use boolean vector
kono
parents:
diff changeset
1286 type for vector comparison.
kono
parents:
diff changeset
1287 * typeck.c (build_vec_cmp): New.
kono
parents:
diff changeset
1288 (cp_build_binary_op): Use build_vec_cmp for comparison.
kono
parents:
diff changeset
1289
kono
parents:
diff changeset
1290 2015-10-20 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1291
kono
parents:
diff changeset
1292 PR c++/66583
kono
parents:
diff changeset
1293 * init.c (innermost_aggr_scope): New.
kono
parents:
diff changeset
1294 (build_field_list): Change uses_unions_p to uses_unions_or_anon_p.
kono
parents:
diff changeset
1295 (sort_mem_initializers): Handle initializers for entire anonymous
kono
parents:
diff changeset
1296 aggregates.
kono
parents:
diff changeset
1297
kono
parents:
diff changeset
1298 2015-10-20 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1299
kono
parents:
diff changeset
1300 * parser.c (is_cilkplus_vector_p): Don't define here.
kono
parents:
diff changeset
1301
kono
parents:
diff changeset
1302 2015-10-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1303
kono
parents:
diff changeset
1304 PR c++/67064
kono
parents:
diff changeset
1305 * semantics.c (force_paren_expr): Don't mess with hard register vars.
kono
parents:
diff changeset
1306
kono
parents:
diff changeset
1307 Implement N4268, Do constant evaluation of all non-type template args.
kono
parents:
diff changeset
1308 * parser.c (cp_parser_template_argument): For C++1z just parse a
kono
parents:
diff changeset
1309 constant-expression.
kono
parents:
diff changeset
1310 * pt.c (convert_nontype_argument): For C++1z always call
kono
parents:
diff changeset
1311 maybe_constant_value.
kono
parents:
diff changeset
1312
kono
parents:
diff changeset
1313 * constexpr.c (cxx_eval_constant_expression): Expand PTRMEM_CST
kono
parents:
diff changeset
1314 only when necessary.
kono
parents:
diff changeset
1315 (cxx_eval_component_reference): Like here.
kono
parents:
diff changeset
1316 * decl2.c (lower_var_init): And here.
kono
parents:
diff changeset
1317 (c_parse_final_cleanups): Call it.
kono
parents:
diff changeset
1318 * typeck2.c (digest_init_r): Not here.
kono
parents:
diff changeset
1319 * decl.c (complete_vars): Or here.
kono
parents:
diff changeset
1320 (cp_finish_decl): Add local statics to symbol table.
kono
parents:
diff changeset
1321
kono
parents:
diff changeset
1322 2015-10-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1323
kono
parents:
diff changeset
1324 PR c++/68006
kono
parents:
diff changeset
1325 * decl.c (implicit_default_ctor_p): New.
kono
parents:
diff changeset
1326 (start_preparsed_function): Don't clobber on entry to one.
kono
parents:
diff changeset
1327
kono
parents:
diff changeset
1328 2015-10-16 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1329
kono
parents:
diff changeset
1330 PR c++/67926
kono
parents:
diff changeset
1331 * constexpr.c (potential_constant_expression_1): Handle
kono
parents:
diff changeset
1332 UNARY_LEFT_FOLD_EXPR, UNARY_RIGHT_FOLD_EXPR, BINARY_LEFT_FOLD_EXPR,
kono
parents:
diff changeset
1333 BINARY_RIGHT_FOLD_EXPR.
kono
parents:
diff changeset
1334
kono
parents:
diff changeset
1335 2015-10-13 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1336 Aldy Hernandez <aldyh@redhat.com>
kono
parents:
diff changeset
1337
kono
parents:
diff changeset
1338 * class.c (finish_struct_1): Call finish_omp_declare_simd_methods.
kono
parents:
diff changeset
1339 * cp-gimplify.c (cp_gimplify_expr): Handle OMP_TASKLOOP.
kono
parents:
diff changeset
1340 (cp_genericize_r): Likewise.
kono
parents:
diff changeset
1341 (cxx_omp_finish_clause): Don't diagnose references.
kono
parents:
diff changeset
1342 (cxx_omp_disregard_value_expr): New function.
kono
parents:
diff changeset
1343 * cp-objcp-common.h (LANG_HOOKS_OMP_DISREGARD_VALUE_EXPR): Redefine.
kono
parents:
diff changeset
1344 * cp-tree.h (OMP_FOR_GIMPLIFYING_P): Document for OMP_TASKLOOP.
kono
parents:
diff changeset
1345 (DECL_OMP_PRIVATIZED_MEMBER): Define.
kono
parents:
diff changeset
1346 (finish_omp_declare_simd_methods, push_omp_privatization_clauses,
kono
parents:
diff changeset
1347 pop_omp_privatization_clauses, save_omp_privatization_clauses,
kono
parents:
diff changeset
1348 restore_omp_privatization_clauses, omp_privatize_field,
kono
parents:
diff changeset
1349 cxx_omp_disregard_value_expr): New prototypes.
kono
parents:
diff changeset
1350 (finish_omp_clauses): Add two new arguments.
kono
parents:
diff changeset
1351 (finish_omp_for): Add ORIG_DECLV argument.
kono
parents:
diff changeset
1352 * parser.c (cp_parser_lambda_body): Call
kono
parents:
diff changeset
1353 save_omp_privatization_clauses and restore_omp_privatization_clauses.
kono
parents:
diff changeset
1354 (cp_parser_omp_clause_name): Handle OpenMP 4.5 clauses.
kono
parents:
diff changeset
1355 (cp_parser_omp_var_list_no_open): Handle structure elements for
kono
parents:
diff changeset
1356 map, to and from clauses. Handle array sections in reduction
kono
parents:
diff changeset
1357 clause. Parse this keyword. Formatting fixes.
kono
parents:
diff changeset
1358 (cp_parser_omp_clause_if): Add IS_OMP argument, handle parsing of
kono
parents:
diff changeset
1359 if clause modifiers.
kono
parents:
diff changeset
1360 (cp_parser_omp_clause_num_tasks, cp_parser_omp_clause_grainsize,
kono
parents:
diff changeset
1361 cp_parser_omp_clause_priority, cp_parser_omp_clause_hint,
kono
parents:
diff changeset
1362 cp_parser_omp_clause_defaultmap): New functions.
kono
parents:
diff changeset
1363 (cp_parser_omp_clause_ordered): Parse optional parameter.
kono
parents:
diff changeset
1364 (cp_parser_omp_clause_reduction): Handle array reductions.
kono
parents:
diff changeset
1365 (cp_parser_omp_clause_schedule): Parse optional simd modifier.
kono
parents:
diff changeset
1366 (cp_parser_omp_clause_nogroup, cp_parser_omp_clause_orderedkind):
kono
parents:
diff changeset
1367 New functions.
kono
parents:
diff changeset
1368 (cp_parser_omp_clause_linear): Parse linear clause modifiers.
kono
parents:
diff changeset
1369 (cp_parser_omp_clause_depend_sink): New function.
kono
parents:
diff changeset
1370 (cp_parser_omp_clause_depend): Parse source/sink depend kinds.
kono
parents:
diff changeset
1371 (cp_parser_omp_clause_map): Parse release/delete map kinds and
kono
parents:
diff changeset
1372 optional always modifier.
kono
parents:
diff changeset
1373 (cp_parser_oacc_all_clauses): Adjust cp_parser_omp_clause_if
kono
parents:
diff changeset
1374 and finish_omp_clauses callers.
kono
parents:
diff changeset
1375 (cp_parser_omp_all_clauses): Likewise. Parse OpenMP 4.5 clauses.
kono
parents:
diff changeset
1376 Parse "to" as OMP_CLAUSE_TO_DECLARE if on declare target directive.
kono
parents:
diff changeset
1377 (OMP_CRITICAL_CLAUSE_MASK): Define.
kono
parents:
diff changeset
1378 (cp_parser_omp_critical): Parse critical clauses.
kono
parents:
diff changeset
1379 (cp_parser_omp_for_incr): Use cp_tree_equal if
kono
parents:
diff changeset
1380 processing_template_decl.
kono
parents:
diff changeset
1381 (cp_parser_omp_for_loop_init): Return tree instead of bool. Handle
kono
parents:
diff changeset
1382 non-static data member iterators.
kono
parents:
diff changeset
1383 (cp_parser_omp_for_loop): Handle doacross loops, adjust
kono
parents:
diff changeset
1384 finish_omp_for and finish_omp_clauses callers.
kono
parents:
diff changeset
1385 (cp_omp_split_clauses): Adjust finish_omp_clauses caller.
kono
parents:
diff changeset
1386 (OMP_SIMD_CLAUSE_MASK): Add simdlen clause.
kono
parents:
diff changeset
1387 (cp_parser_omp_simd): Allow ordered clause if it has no parameter.
kono
parents:
diff changeset
1388 (OMP_FOR_CLAUSE_MASK): Add linear clause.
kono
parents:
diff changeset
1389 (cp_parser_omp_for): Disallow ordered clause when combined with
kono
parents:
diff changeset
1390 distribute. Disallow linear clause when combined with distribute
kono
parents:
diff changeset
1391 and not combined with simd.
kono
parents:
diff changeset
1392 (OMP_ORDERED_CLAUSE_MASK, OMP_ORDERED_DEPEND_CLAUSE_MASK): Define.
kono
parents:
diff changeset
1393 (cp_parser_omp_ordered): Add CONTEXT argument, return bool instead
kono
parents:
diff changeset
1394 of tree, parse clauses and if depend clause is found, don't parse
kono
parents:
diff changeset
1395 a body.
kono
parents:
diff changeset
1396 (cp_parser_omp_parallel): Disallow copyin clause on target parallel.
kono
parents:
diff changeset
1397 Allow target parallel without for after it.
kono
parents:
diff changeset
1398 (OMP_TASK_CLAUSE_MASK): Add priority clause.
kono
parents:
diff changeset
1399 (OMP_TARGET_DATA_CLAUSE_MASK): Add use_device_ptr clause.
kono
parents:
diff changeset
1400 (cp_parser_omp_target_data): Diagnose no map clauses or clauses with
kono
parents:
diff changeset
1401 invalid kinds.
kono
parents:
diff changeset
1402 (OMP_TARGET_UPDATE_CLAUSE_MASK): Add depend and nowait clauses.
kono
parents:
diff changeset
1403 (OMP_TARGET_ENTER_DATA_CLAUSE_MASK,
kono
parents:
diff changeset
1404 OMP_TARGET_EXIT_DATA_CLAUSE_MASK): Define.
kono
parents:
diff changeset
1405 (cp_parser_omp_target_enter_data, cp_parser_omp_target_exit_data): New
kono
parents:
diff changeset
1406 functions.
kono
parents:
diff changeset
1407 (OMP_TARGET_CLAUSE_MASK): Add depend, nowait, private, firstprivate,
kono
parents:
diff changeset
1408 defaultmap and is_device_ptr clauses.
kono
parents:
diff changeset
1409 (cp_parser_omp_target): Parse target parallel and target simd. Set
kono
parents:
diff changeset
1410 OMP_TARGET_COMBINED on combined constructs. Parse target enter data
kono
parents:
diff changeset
1411 and target exit data. Diagnose invalid map kinds.
kono
parents:
diff changeset
1412 (cp_parser_oacc_cache): Adjust finish_omp_clauses caller.
kono
parents:
diff changeset
1413 (OMP_DECLARE_TARGET_CLAUSE_MASK): Define.
kono
parents:
diff changeset
1414 (cp_parser_omp_declare_target): Parse OpenMP 4.5 forms of this
kono
parents:
diff changeset
1415 construct.
kono
parents:
diff changeset
1416 (OMP_TASKLOOP_CLAUSE_MASK): Define.
kono
parents:
diff changeset
1417 (cp_parser_omp_taskloop): New function.
kono
parents:
diff changeset
1418 (cp_parser_omp_construct): Don't handle PRAGMA_OMP_ORDERED here,
kono
parents:
diff changeset
1419 handle PRAGMA_OMP_TASKLOOP.
kono
parents:
diff changeset
1420 (cp_parser_pragma): Handle PRAGMA_OMP_ORDERED here directly,
kono
parents:
diff changeset
1421 handle PRAGMA_OMP_TASKLOOP, call push_omp_privatization_clauses
kono
parents:
diff changeset
1422 and pop_omp_privatization_clauses around parsing calls.
kono
parents:
diff changeset
1423 (cp_parser_cilk_for): Adjust finish_omp_clauses caller.
kono
parents:
diff changeset
1424 * pt.c (apply_late_template_attributes): Adjust tsubst_omp_clauses
kono
parents:
diff changeset
1425 and finish_omp_clauses callers.
kono
parents:
diff changeset
1426 (tsubst_omp_clause_decl): Return NULL if decl is NULL.
kono
parents:
diff changeset
1427 For TREE_LIST, copy over OMP_CLAUSE_DEPEND_SINK_NEGATIVE bit.
kono
parents:
diff changeset
1428 Use tsubst_expr instead of tsubst_copy, undo convert_from_reference
kono
parents:
diff changeset
1429 effects.
kono
parents:
diff changeset
1430 (tsubst_omp_clauses): Add ALLOW_FIELDS argument. Handle new
kono
parents:
diff changeset
1431 OpenMP 4.5 clauses. Use tsubst_omp_clause_decl for more clauses.
kono
parents:
diff changeset
1432 If ALLOW_FIELDS, handle non-static data members in the clauses.
kono
parents:
diff changeset
1433 Clear OMP_CLAUSE_LINEAR_STEP if it has been cleared before.
kono
parents:
diff changeset
1434 (omp_parallel_combined_clauses): New variable.
kono
parents:
diff changeset
1435 (tsubst_omp_for_iterator): Add ORIG_DECLV argument, recur on
kono
parents:
diff changeset
1436 OMP_FOR_ORIG_DECLS, handle non-static data member iterators.
kono
parents:
diff changeset
1437 Improve handling of clauses on combined constructs.
kono
parents:
diff changeset
1438 (tsubst_expr): Call push_omp_privatization_clauses and
kono
parents:
diff changeset
1439 pop_omp_privatization_clauses around instantiation of certain
kono
parents:
diff changeset
1440 OpenMP constructs, improve handling of clauses on combined
kono
parents:
diff changeset
1441 constructs, handle OMP_TASKLOOP, adjust tsubst_omp_for_iterator,
kono
parents:
diff changeset
1442 tsubst_omp_clauses and finish_omp_for callers, handle clauses on
kono
parents:
diff changeset
1443 critical and ordered, handle OMP_TARGET_{ENTER,EXIT}_DATA.
kono
parents:
diff changeset
1444 (instantiate_decl): Call save_omp_privatization_clauses and
kono
parents:
diff changeset
1445 restore_omp_privatization_clauses around instantiation.
kono
parents:
diff changeset
1446 (dependent_omp_for_p): Fix up comment typo. Handle SCOPE_REF.
kono
parents:
diff changeset
1447 * semantics.c (omp_private_member_map, omp_private_member_vec,
kono
parents:
diff changeset
1448 omp_private_member_ignore_next): New variables.
kono
parents:
diff changeset
1449 (finish_non_static_data_member): Return dummy decl for privatized
kono
parents:
diff changeset
1450 non-static data members.
kono
parents:
diff changeset
1451 (omp_clause_decl_field, omp_clause_printable_decl,
kono
parents:
diff changeset
1452 omp_note_field_privatization, omp_privatize_field): New functions.
kono
parents:
diff changeset
1453 (handle_omp_array_sections_1): Fix comment typo.
kono
parents:
diff changeset
1454 Add IS_OMP argument, handle structure element bases, diagnose
kono
parents:
diff changeset
1455 bitfields, pass IS_OMP recursively, diagnose known zero length
kono
parents:
diff changeset
1456 array sections in depend clauses, handle array sections in reduction
kono
parents:
diff changeset
1457 clause, diagnose negative length even for pointers.
kono
parents:
diff changeset
1458 (handle_omp_array_sections): Add IS_OMP argument, use auto_vec for
kono
parents:
diff changeset
1459 types, pass IS_OMP down to handle_omp_array_sections_1, handle
kono
parents:
diff changeset
1460 array sections in reduction clause, set
kono
parents:
diff changeset
1461 OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION if map could be zero
kono
parents:
diff changeset
1462 length array section, use GOMP_MAP_FIRSTPRIVATE_POINTER for IS_OMP.
kono
parents:
diff changeset
1463 (finish_omp_reduction_clause): Handle array sections and arrays.
kono
parents:
diff changeset
1464 Use omp_clause_printable_decl.
kono
parents:
diff changeset
1465 (finish_omp_declare_simd_methods, cp_finish_omp_clause_depend_sink):
kono
parents:
diff changeset
1466 New functions.
kono
parents:
diff changeset
1467 (finish_omp_clauses): Add ALLOW_FIELDS and DECLARE_SIMD arguments.
kono
parents:
diff changeset
1468 Handle new OpenMP 4.5 clauses and new restrictions for the old
kono
parents:
diff changeset
1469 ones, handle non-static data members, reject this keyword when not
kono
parents:
diff changeset
1470 allowed.
kono
parents:
diff changeset
1471 (push_omp_privatization_clauses, pop_omp_privatization_clauses,
kono
parents:
diff changeset
1472 save_omp_privatization_clauses, restore_omp_privatization_clauses):
kono
parents:
diff changeset
1473 New functions.
kono
parents:
diff changeset
1474 (handle_omp_for_class_iterator): Handle OMP_TASKLOOP class iterators.
kono
parents:
diff changeset
1475 Add collapse and ordered arguments. Fix handling of lastprivate
kono
parents:
diff changeset
1476 iterators in doacross loops.
kono
parents:
diff changeset
1477 (finish_omp_for): Add ORIG_DECLV argument, handle doacross loops,
kono
parents:
diff changeset
1478 adjust c_finish_omp_for, handle_omp_for_class_iterator and
kono
parents:
diff changeset
1479 finish_omp_clauses callers. Fill in OMP_CLAUSE_LINEAR_STEP on simd
kono
parents:
diff changeset
1480 loops with non-static data member iterators.
kono
parents:
diff changeset
1481
kono
parents:
diff changeset
1482 2015-10-12 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
1483
kono
parents:
diff changeset
1484 PR c++/58566
kono
parents:
diff changeset
1485 * lambda.c (lambda_return_type): Return error_mark_node
kono
parents:
diff changeset
1486 instead of void_type_node for the error cases.
kono
parents:
diff changeset
1487
kono
parents:
diff changeset
1488 2015-10-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1489
kono
parents:
diff changeset
1490 * cp-tree.h (SIMPLE_TARGET_EXPR_P): New.
kono
parents:
diff changeset
1491 * init.c (get_nsdmi): Use it.
kono
parents:
diff changeset
1492 * typeck2.c (massage_init_elt): Use it.
kono
parents:
diff changeset
1493
kono
parents:
diff changeset
1494 2015-10-07 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1495
kono
parents:
diff changeset
1496 PR c++/67557
kono
parents:
diff changeset
1497 * call.c (is_base_field_ref): New.
kono
parents:
diff changeset
1498 (unsafe_copy_elision_p): New.
kono
parents:
diff changeset
1499 (build_over_call): Use it.
kono
parents:
diff changeset
1500
kono
parents:
diff changeset
1501 2015-10-07 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1502
kono
parents:
diff changeset
1503 PR sanitizer/67867
kono
parents:
diff changeset
1504 * search.c (accessible_p): Initialize OTYPE to NULL_TREE.
kono
parents:
diff changeset
1505
kono
parents:
diff changeset
1506 2015-10-07 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1507
kono
parents:
diff changeset
1508 * cp-gimplify.c (genericize_if_stmt): Use protected_set_expr_location.
kono
parents:
diff changeset
1509 (genericize_cp_loop): Likewise.
kono
parents:
diff changeset
1510 * decl.c (cxx_maybe_build_cleanup): Likewise.
kono
parents:
diff changeset
1511 * parser.c (cp_parser_binary_expression): Likewise.
kono
parents:
diff changeset
1512 (cp_parser_omp_for_loop): Likewise.
kono
parents:
diff changeset
1513 (cp_parser_omp_construct): Likewise.
kono
parents:
diff changeset
1514 * semantics.c (finish_transaction_stmt): Likewise.
kono
parents:
diff changeset
1515 (build_transaction_expr): Likewise.
kono
parents:
diff changeset
1516
kono
parents:
diff changeset
1517 2015-10-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1518
kono
parents:
diff changeset
1519 PR c++/67810
kono
parents:
diff changeset
1520 * parser.c (cp_parser_fold_expr_p): Remove.
kono
parents:
diff changeset
1521 (is_binary_op): New.
kono
parents:
diff changeset
1522 (cp_parser_fold_expression): Take LHS as parameter.
kono
parents:
diff changeset
1523 (cp_parser_primary_expression): Call it after parsing an expression.
kono
parents:
diff changeset
1524 (cp_parser_binary_expression, cp_parser_assignment_operator_opt)
kono
parents:
diff changeset
1525 (cp_parser_expression): Ignore an operator followed by '...'.
kono
parents:
diff changeset
1526 (is_binary_op): New.
kono
parents:
diff changeset
1527 * pt.c (tsubst_unary_left_fold, tsubst_binary_left_fold)
kono
parents:
diff changeset
1528 (tsubst_unary_right_fold, tsubst_binary_right_fold): Handle errors.
kono
parents:
diff changeset
1529
kono
parents:
diff changeset
1530 2015-10-06 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1531
kono
parents:
diff changeset
1532 PR c++/67863
kono
parents:
diff changeset
1533 * call.c (build_conditional_expr_1): Build the COND_EXPR with
kono
parents:
diff changeset
1534 a location.
kono
parents:
diff changeset
1535
kono
parents:
diff changeset
1536 2015-10-05 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1537
kono
parents:
diff changeset
1538 PR c++/53856
kono
parents:
diff changeset
1539 * pt.c (check_default_tmpl_args): Per [temp.param]/9, do not
kono
parents:
diff changeset
1540 reject default template arguments in out of class definitions
kono
parents:
diff changeset
1541 of members of non-template classes.
kono
parents:
diff changeset
1542
kono
parents:
diff changeset
1543 2015-10-05 Richard Sandiford <richard.sandiford@arm.com>
kono
parents:
diff changeset
1544
kono
parents:
diff changeset
1545 * tree.c (cp_tree_equal): Use real_equal instead of
kono
parents:
diff changeset
1546 REAL_VALUES_EQUAL.
kono
parents:
diff changeset
1547
kono
parents:
diff changeset
1548 2015-10-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1549
kono
parents:
diff changeset
1550 Implement N4514, C++ Extensions for Transactional Memory.
kono
parents:
diff changeset
1551 * cp-tree.h (struct cp_declarator): Add tx_qualifier field.
kono
parents:
diff changeset
1552 (BCS_NORMAL, BCS_TRANSACTION): New enumerators.
kono
parents:
diff changeset
1553 * lex.c (init_reswords): Limit TM kewords to -fgnu-tm.
kono
parents:
diff changeset
1554 * parser.c (cp_lexer_get_preprocessor_token): Fix @synchronized.
kono
parents:
diff changeset
1555 (make_call_declarator): Take tx_qualifier.
kono
parents:
diff changeset
1556 (cp_parser_tx_qualifier_opt): New.
kono
parents:
diff changeset
1557 (cp_parser_lambda_declarator_opt): Use it.
kono
parents:
diff changeset
1558 (cp_parser_direct_declarator): Likewise.
kono
parents:
diff changeset
1559 (cp_parser_statement): Handle atomic_noexcept, atomic_cancel.
kono
parents:
diff changeset
1560 (cp_parser_compound_statement): Change in_try parameter to bcs_flags.
kono
parents:
diff changeset
1561 (cp_parser_std_attribute): Map optimize_for_synchronized to
kono
parents:
diff changeset
1562 transaction_callable.
kono
parents:
diff changeset
1563 (cp_parser_transaction): Take the token. Handle atomic_noexcept.
kono
parents:
diff changeset
1564 * lambda.c (maybe_add_lambda_conv_op): Handle transaction-safety.
kono
parents:
diff changeset
1565 * call.c (enum conversion_kind): Add ck_tsafe.
kono
parents:
diff changeset
1566 (standard_conversion): Handle transaction-safety conversion.
kono
parents:
diff changeset
1567 (convert_like_real, resolve_address_of_overloaded_function): Likewise.
kono
parents:
diff changeset
1568 (check_methods): Diagnose transaction_safe_dynamic on non-virtual
kono
parents:
diff changeset
1569 function.
kono
parents:
diff changeset
1570 (look_for_tm_attr_overrides): Don't inherit transaction_safe_dynamic.
kono
parents:
diff changeset
1571 * cvt.c (tx_safe_fn_type_p, tx_unsafe_fn_variant)
kono
parents:
diff changeset
1572 (can_convert_tx_safety): New.
kono
parents:
diff changeset
1573 * typeck.c (composite_pointer_type): Handle transaction-safety.
kono
parents:
diff changeset
1574 * name-lookup.h (enum scope_kind): Add sk_transaction.
kono
parents:
diff changeset
1575 * name-lookup.c (begin_scope): Handle it.
kono
parents:
diff changeset
1576 * semantics.c (begin_compound_stmt): Pass it.
kono
parents:
diff changeset
1577 * decl.c (check_previous_goto_1): Check it.
kono
parents:
diff changeset
1578 (struct named_label_entry): Add in_transaction_scope.
kono
parents:
diff changeset
1579 (poplevel_named_label_1): Set it.
kono
parents:
diff changeset
1580 (check_goto): Check it.
kono
parents:
diff changeset
1581 (duplicate_decls): A specialization can be transaction_safe
kono
parents:
diff changeset
1582 independently of its template.
kono
parents:
diff changeset
1583 (grokdeclarator): Handle tx-qualifier.
kono
parents:
diff changeset
1584 * rtti.c (ptr_initializer): Handle transaction-safe.
kono
parents:
diff changeset
1585 * search.c (check_final_overrider): Check transaction_safe_dynamic.
kono
parents:
diff changeset
1586 Don't check transaction_safe.
kono
parents:
diff changeset
1587 * mangle.c (write_function_type): Mangle transaction_safe here.
kono
parents:
diff changeset
1588 (write_CV_qualifiers_for_type): Not here.
kono
parents:
diff changeset
1589 (write_type): Preserve transaction_safe when stripping attributes.
kono
parents:
diff changeset
1590 * error.c (dump_type_suffix): Print transaction_safe.
kono
parents:
diff changeset
1591
kono
parents:
diff changeset
1592 2015-10-02 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
1593
kono
parents:
diff changeset
1594 PR c/64249
kono
parents:
diff changeset
1595 * parser.c (cp_parser_statement): Add CHAIN parameter and pass it
kono
parents:
diff changeset
1596 down to cp_parser_selection_statement.
kono
parents:
diff changeset
1597 (cp_parser_selection_statement): Add CHAIN parameter. Add code to
kono
parents:
diff changeset
1598 warn about duplicated if-else-if conditions.
kono
parents:
diff changeset
1599 (cp_parser_implicitly_scoped_statement): Add CHAIN parameter and pass
kono
parents:
diff changeset
1600 it down to cp_parser_statement.
kono
parents:
diff changeset
1601
kono
parents:
diff changeset
1602 2015-10-01 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
1603
kono
parents:
diff changeset
1604 PR c++/54430
kono
parents:
diff changeset
1605 * name-lookup.c (push_binding): Make non-static.
kono
parents:
diff changeset
1606 * name-lookup.h (push_binding): Declare it.
kono
parents:
diff changeset
1607 * parser.c (cp_parser_range_for): Use it, get the range
kono
parents:
diff changeset
1608 declaration away from the scope until the range expression
kono
parents:
diff changeset
1609 has been parsed, then restore the declaration.
kono
parents:
diff changeset
1610
kono
parents:
diff changeset
1611 2015-09-23 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
1612
kono
parents:
diff changeset
1613 Fix small typos in the coding rule enforcement warnings.
kono
parents:
diff changeset
1614 * parser.c (cp_parser_namespace_definition): Replace 'namepace'
kono
parents:
diff changeset
1615 with 'namespace'.
kono
parents:
diff changeset
1616
kono
parents:
diff changeset
1617 2015-09-22 Nathan Sidwell <nathan@codesourcery.com>
kono
parents:
diff changeset
1618
kono
parents:
diff changeset
1619 * decl.c (xref_basetypes): Check virtual and/or multiple
kono
parents:
diff changeset
1620 inheritance warning.
kono
parents:
diff changeset
1621 * parser.c (cp_parser_namespace_definition): Check namespaces
kono
parents:
diff changeset
1622 warning.
kono
parents:
diff changeset
1623 * pt.c (push_template_decl_real): Check templates warning.
kono
parents:
diff changeset
1624
kono
parents:
diff changeset
1625 2015-09-22 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1626
kono
parents:
diff changeset
1627 * mangle.c (abi_warn_or_compat_version_crosses): New.
kono
parents:
diff changeset
1628 Use it instead of abi_version_crosses.
kono
parents:
diff changeset
1629 (mangle_decl): Deal with -fabi-compat-version and -Wabi separately.
kono
parents:
diff changeset
1630
kono
parents:
diff changeset
1631 2015-09-21 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
1632
kono
parents:
diff changeset
1633 Complete the implementation of N4230, Nested namespace definition.
kono
parents:
diff changeset
1634 * parser.c (cp_parser_namespace_definition): Support namespace
kono
parents:
diff changeset
1635 attributes both before and after the namespace identifier.
kono
parents:
diff changeset
1636
kono
parents:
diff changeset
1637 2015-09-19 Trevor Saunders <tbsaunde@tbsaunde.org>
kono
parents:
diff changeset
1638
kono
parents:
diff changeset
1639 * cp-gimplify.c (gimplify_must_not_throw_expr): Adjust.
kono
parents:
diff changeset
1640
kono
parents:
diff changeset
1641 2015-09-18 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
1642
kono
parents:
diff changeset
1643 Implement nested namespace definitions.
kono
parents:
diff changeset
1644 * parser.c (cp_parser_namespace_definition): Grok nested namespace
kono
parents:
diff changeset
1645 definitions.
kono
parents:
diff changeset
1646
kono
parents:
diff changeset
1647 2015-09-18 Manuel López-Ibáñez <manu@gcc.gnu.org>
kono
parents:
diff changeset
1648
kono
parents:
diff changeset
1649 * parser.c (pragma_lex): Add loc argument. Rearrange the code to
kono
parents:
diff changeset
1650 make it more similar to the C version.
kono
parents:
diff changeset
1651
kono
parents:
diff changeset
1652 2015-09-17 Andrew Sutton <andrew.n.sutton@gmail.com>
kono
parents:
diff changeset
1653 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1654
kono
parents:
diff changeset
1655 Implement N4295 fold-expressions.
kono
parents:
diff changeset
1656 * cp-tree.def: Add UNARY_LEFT_FOLD_EXPR, UNARY_RIGHT_FOLD_EXPR,
kono
parents:
diff changeset
1657 BINARY_LEFT_FOLD_EXPR, BINARY_RIGHT_FOLD_EXPR.
kono
parents:
diff changeset
1658 * cp-objcp-common.c (cp_common_init_ts): Handle them.
kono
parents:
diff changeset
1659 * cp-tree.h (FOLD_EXPR_CHECK, BINARY_FOLD_EXPR_CHECK, FOLD_EXPR_P)
kono
parents:
diff changeset
1660 (FOLD_EXPR_MODIFY_P, FOLD_EXPR_OP, FOLD_EXPR_PACK, FOLD_EXPR_INIT): New.
kono
parents:
diff changeset
1661 * parser.c (cp_parser_skip_to_closing_parenthesis): Split out...
kono
parents:
diff changeset
1662 (cp_parser_skip_to_closing_parenthesis_1): This function. Change
kono
parents:
diff changeset
1663 or_comma parameter to or_ttype.
kono
parents:
diff changeset
1664 (cp_parser_fold_operator, cp_parser_fold_expr_p)
kono
parents:
diff changeset
1665 (cp_parser_fold_expression): New.
kono
parents:
diff changeset
1666 (cp_parser_primary_expression): Use them.
kono
parents:
diff changeset
1667 * pt.c (expand_empty_fold, fold_expression, tsubst_fold_expr_pack)
kono
parents:
diff changeset
1668 (tsubst_fold_expr_init, expand_left_fold, tsubst_unary_left_fold)
kono
parents:
diff changeset
1669 (tsubst_binary_left_fold, expand_right_fold)
kono
parents:
diff changeset
1670 (tsubst_unary_right_fold, tsubst_binary_right_fold): New.
kono
parents:
diff changeset
1671 (tsubst_copy): Use them.
kono
parents:
diff changeset
1672 (type_dependent_expression_p): Handle fold-expressions.
kono
parents:
diff changeset
1673 * semantics.c (finish_unary_fold_expr)
kono
parents:
diff changeset
1674 (finish_left_unary_fold_expr, finish_right_unary_fold_expr)
kono
parents:
diff changeset
1675 (finish_binary_fold_expr): New.
kono
parents:
diff changeset
1676
kono
parents:
diff changeset
1677 2015-09-17 Richard Biener <rguenther@suse.de>
kono
parents:
diff changeset
1678
kono
parents:
diff changeset
1679 * cp-tree.h (note_decl_for_pch): Remove.
kono
parents:
diff changeset
1680 * class.c (build_clone): Do not call note_decl_for_pch.
kono
parents:
diff changeset
1681 * semantics.c (finish_member_declaration): Likewise.
kono
parents:
diff changeset
1682 (note_decl_for_pch): Remove.
kono
parents:
diff changeset
1683 * decl2.c (c_parse_final_cleanups): Mangle all globals before
kono
parents:
diff changeset
1684 writing the PCH.
kono
parents:
diff changeset
1685
kono
parents:
diff changeset
1686 2015-09-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1687
kono
parents:
diff changeset
1688 PR c++/44282
kono
parents:
diff changeset
1689 * mangle.c (write_CV_qualifiers_for_type): Also warn about regparm
kono
parents:
diff changeset
1690 mangling with lower -fabi-version.
kono
parents:
diff changeset
1691
kono
parents:
diff changeset
1692 2015-09-14 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1693
kono
parents:
diff changeset
1694 PR c++/51911
kono
parents:
diff changeset
1695 * parser.c (cp_parser_new_expression): Enforce 5.3.4/2 (as amended
kono
parents:
diff changeset
1696 per the spirit of DR 1467).
kono
parents:
diff changeset
1697
kono
parents:
diff changeset
1698 2015-09-11 Mark Wielaard <mjw@redhat.com>
kono
parents:
diff changeset
1699
kono
parents:
diff changeset
1700 PR c/28901
kono
parents:
diff changeset
1701 * cp-objcp-common.c (cxx_warn_unused_global_decl): Remove hard-coded
kono
parents:
diff changeset
1702 VAR_P TREE_READONLY override.
kono
parents:
diff changeset
1703
kono
parents:
diff changeset
1704 2015-09-10 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1705
kono
parents:
diff changeset
1706 PR c++/67318
kono
parents:
diff changeset
1707 * parser.c (cp_parser_parameter_declaration): Consume the ellipsis
kono
parents:
diff changeset
1708 and set template_parameter_pack_p also when the type is null.
kono
parents:
diff changeset
1709
kono
parents:
diff changeset
1710 2015-09-09 Mark Wielaard <mjw@redhat.com>
kono
parents:
diff changeset
1711
kono
parents:
diff changeset
1712 * typeck.c (cp_build_binary_op): Check and warn when nonnull arg
kono
parents:
diff changeset
1713 parm against NULL.
kono
parents:
diff changeset
1714
kono
parents:
diff changeset
1715 2015-09-10 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1716
kono
parents:
diff changeset
1717 PR c++/67522
kono
parents:
diff changeset
1718 * semantics.c (handle_omp_array_sections_1): Only run
kono
parents:
diff changeset
1719 type_dependent_expression_p on VAR_DECL/PARM_DECLs.
kono
parents:
diff changeset
1720 (finish_omp_clauses) <case OMP_CLAUSE_LINEAR>: Likewise.
kono
parents:
diff changeset
1721 Don't adjust OMP_CLAUSE_LINEAR_STEP if OMP_CLAUSE_DECL
kono
parents:
diff changeset
1722 is not a VAR_DECL/PARM_DECL.
kono
parents:
diff changeset
1723
kono
parents:
diff changeset
1724 PR c++/67511
kono
parents:
diff changeset
1725 * semantics.c (handle_omp_for_class_iterator): Don't wrap
kono
parents:
diff changeset
1726 error_mark_node into a NOP_EXPR to void_type_node.
kono
parents:
diff changeset
1727
kono
parents:
diff changeset
1728 2015-09-09 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1729
kono
parents:
diff changeset
1730 PR c++/53184
kono
parents:
diff changeset
1731 * decl2.c (constrain_class_visibility): Use Wsubobject-linkage.
kono
parents:
diff changeset
1732
kono
parents:
diff changeset
1733 2015-09-09 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
1734
kono
parents:
diff changeset
1735 PR c++/67504
kono
parents:
diff changeset
1736 * parser.c (cp_parser_omp_clause_collapse): Test tree_fits_shwi_p
kono
parents:
diff changeset
1737 before INTEGRAL_TYPE_P test.
kono
parents:
diff changeset
1738
kono
parents:
diff changeset
1739 2015-09-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1740
kono
parents:
diff changeset
1741 PR c++/67041
kono
parents:
diff changeset
1742 * pt.c (tsubst_copy_and_build): Handle variables like functions.
kono
parents:
diff changeset
1743
kono
parents:
diff changeset
1744 2015-09-08 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1745
kono
parents:
diff changeset
1746 PR c++/67369
kono
parents:
diff changeset
1747 * pt.c (tsubst_copy, [case FUNCTION_DECL]): Do not call tsubst
kono
parents:
diff changeset
1748 if the first argument isn't a template.
kono
parents:
diff changeset
1749
kono
parents:
diff changeset
1750 2015-09-03 Martin Sebor <msebor@redhat.com>
kono
parents:
diff changeset
1751
kono
parents:
diff changeset
1752 PR c/66516
kono
parents:
diff changeset
1753 * cp-tree.h (mark_rvalue_use, decay_conversion): Add new
kono
parents:
diff changeset
1754 argument(s).
kono
parents:
diff changeset
1755 * expr.c (mark_rvalue_use): Use new argument.
kono
parents:
diff changeset
1756 * call.c (build_addr_func): Call decay_conversion with new
kono
parents:
diff changeset
1757 argument.
kono
parents:
diff changeset
1758 * pt.c (convert_template_argument): Call reject_gcc_builtin.
kono
parents:
diff changeset
1759 * typeck.c (decay_conversion): Use new argument.
kono
parents:
diff changeset
1760 (c_decl_implicit): Define.
kono
parents:
diff changeset
1761
kono
parents:
diff changeset
1762 2015-09-02 Balaji V. Iyer <balaji.v.iyer@intel.com>
kono
parents:
diff changeset
1763
kono
parents:
diff changeset
1764 PR middle-end/60586
kono
parents:
diff changeset
1765 * cp-gimplify.c (cilk_cp_gimplify_call_params_in_spawned_fn): New
kono
parents:
diff changeset
1766 function.
kono
parents:
diff changeset
1767 (cp_gimplify_expr): Added a call to the function
kono
parents:
diff changeset
1768 cilk_cp_gimplify_call_params_in_spawned_fn.
kono
parents:
diff changeset
1769
kono
parents:
diff changeset
1770 2015-09-01 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1771
kono
parents:
diff changeset
1772 PR c++/61753
kono
parents:
diff changeset
1773 * decl.c (smallest_type_quals_location): New.
kono
parents:
diff changeset
1774 (check_special_function_return_type): Use the latter; add int and
kono
parents:
diff changeset
1775 const location_t* parameters.
kono
parents:
diff changeset
1776 (grokdeclarator): Adjust check_special_function_return_type call.
kono
parents:
diff changeset
1777
kono
parents:
diff changeset
1778 2015-08-29 Markus Trippelsdorf <markus@trippelsdorf.de>
kono
parents:
diff changeset
1779
kono
parents:
diff changeset
1780 PR c++/67371
kono
parents:
diff changeset
1781 * constexpr.c (potential_constant_expression_1): Remove IF_STMT
kono
parents:
diff changeset
1782 case. Move label to COND_EXPR case. Remove checking of
kono
parents:
diff changeset
1783 SWITCH_STMT_BODY.
kono
parents:
diff changeset
1784
kono
parents:
diff changeset
1785 2015-08-22 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1786
kono
parents:
diff changeset
1787 PR c++/63693
kono
parents:
diff changeset
1788 * pt.c (resolve_typename_type): Use CLASSTYPE_PRIMARY_TEMPLATE_TYPE
kono
parents:
diff changeset
1789 only on class types.
kono
parents:
diff changeset
1790
kono
parents:
diff changeset
1791 2015-08-21 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1792
kono
parents:
diff changeset
1793 PR c++/67240
kono
parents:
diff changeset
1794 * constraint.cc (satisfy_implicit_conversion_constraint): Also
kono
parents:
diff changeset
1795 check for NULL_TREE.
kono
parents:
diff changeset
1796
kono
parents:
diff changeset
1797 2015-08-21 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1798
kono
parents:
diff changeset
1799 * decl.c (grokvardecl): Simplify the latter.
kono
parents:
diff changeset
1800
kono
parents:
diff changeset
1801 2015-08-21 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1802
kono
parents:
diff changeset
1803 * decl.c (grokvardecl): Complete check added for c++/67065.
kono
parents:
diff changeset
1804
kono
parents:
diff changeset
1805 2015-08-20 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1806
kono
parents:
diff changeset
1807 * name-lookup.c (hidden_name_p): Handle OVERLOAD.
kono
parents:
diff changeset
1808
kono
parents:
diff changeset
1809 2015-08-20 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1810
kono
parents:
diff changeset
1811 PR c++/67065
kono
parents:
diff changeset
1812 * decl.c (grokvardecl): Reject 'main' as global variable.
kono
parents:
diff changeset
1813
kono
parents:
diff changeset
1814 2015-08-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1815
kono
parents:
diff changeset
1816 PR c++/66957
kono
parents:
diff changeset
1817 * search.c (protected_accessible_p): Remove redundant access_in_type.
kono
parents:
diff changeset
1818 Add otype parm instead of walking binfo.
kono
parents:
diff changeset
1819 (friend_accessible_p): Check SCOPE itself. Handle class
kono
parents:
diff changeset
1820 templates. Pass through otype.
kono
parents:
diff changeset
1821 (dfs_accessible_post): Handle all accessibility cases.
kono
parents:
diff changeset
1822 (dfs_accessible_pre): New.
kono
parents:
diff changeset
1823 (accessible_p): Use it. Don't check protected access here. Pass
kono
parents:
diff changeset
1824 decl and otype to dfs_walk.
kono
parents:
diff changeset
1825 (member_declared_in_type, dfs_access_in_type_pre): New.
kono
parents:
diff changeset
1826 (access_in_type): Use dfs_access_in_type_pre.
kono
parents:
diff changeset
1827 * friend.c (add_friend): Fix multiple friends with the same name.
kono
parents:
diff changeset
1828
kono
parents:
diff changeset
1829 * lambda.c (current_nonlambda_scope): New.
kono
parents:
diff changeset
1830
kono
parents:
diff changeset
1831 2015-08-18 Trevor Saunders <tbsaunde@tbsaunde.org>
kono
parents:
diff changeset
1832
kono
parents:
diff changeset
1833 * call.c, class.c, cp-tree.h, decl.c, except.c, mangle.c,
kono
parents:
diff changeset
1834 method.c, name-lookup.h, parser.c, parser.h, rtti.c,
kono
parents:
diff changeset
1835 semantics.c, typeck2.c: Remove useless typedefs.
kono
parents:
diff changeset
1836
kono
parents:
diff changeset
1837 2015-08-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1838
kono
parents:
diff changeset
1839 DR 1155
kono
parents:
diff changeset
1840 * pt.c (convert_nontype_argument): Allow internal linkage in C++11
kono
parents:
diff changeset
1841 and up.
kono
parents:
diff changeset
1842
kono
parents:
diff changeset
1843 2015-08-17 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
1844
kono
parents:
diff changeset
1845 PR c++/67216
kono
parents:
diff changeset
1846 * call.c (null_ptr_cst_p): In C++11 return 'false' for 'false'.
kono
parents:
diff changeset
1847
kono
parents:
diff changeset
1848 2015-08-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1849
kono
parents:
diff changeset
1850 PR c++/67244
kono
parents:
diff changeset
1851 * pt.c (tsubst_copy_and_build): Call insert_pending_capture_proxies.
kono
parents:
diff changeset
1852
kono
parents:
diff changeset
1853 PR c++/67104
kono
parents:
diff changeset
1854 * constexpr.c (array_index_cmp, find_array_ctor_elt): New.
kono
parents:
diff changeset
1855 (cxx_eval_array_reference, cxx_eval_store_expression): Use them.
kono
parents:
diff changeset
1856
kono
parents:
diff changeset
1857 * constexpr.c (cxx_eval_store_expression): Don't set
kono
parents:
diff changeset
1858 CONSTRUCTOR_NO_IMPLICIT_ZERO if we have an enclosing CONSTRUCTOR
kono
parents:
diff changeset
1859 without it.
kono
parents:
diff changeset
1860 (cxx_eval_array_reference): Check it.
kono
parents:
diff changeset
1861
kono
parents:
diff changeset
1862 * except.c (check_noexcept_r): Assert that fn is POINTER_TYPE_P.
kono
parents:
diff changeset
1863
kono
parents:
diff changeset
1864 2015-08-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1865
kono
parents:
diff changeset
1866 PR c++/65974
kono
parents:
diff changeset
1867 * decl2.c (mark_vtable_entries): Suppress -Wdeprecated.
kono
parents:
diff changeset
1868
kono
parents:
diff changeset
1869 2015-08-12 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1870
kono
parents:
diff changeset
1871 PR c++/67104
kono
parents:
diff changeset
1872 * constexpr.c (cxx_eval_array_reference): Fix typo.
kono
parents:
diff changeset
1873
kono
parents:
diff changeset
1874 PR c++/67104
kono
parents:
diff changeset
1875 * constexpr.c (cxx_eval_array_reference): Handle sparse
kono
parents:
diff changeset
1876 CONSTRUCTORs.
kono
parents:
diff changeset
1877
kono
parents:
diff changeset
1878 PR c++/67108
kono
parents:
diff changeset
1879 * decl2.c (c_parse_final_cleanups): Set at_eof to 2 at end.
kono
parents:
diff changeset
1880 * error.c (dump_template_bindings): Don't tsubst in that case.
kono
parents:
diff changeset
1881
kono
parents:
diff changeset
1882 PR c++/67161
kono
parents:
diff changeset
1883 * error.c (dump_decl) [TEMPLATE_ID_EXPR]: Pass
kono
parents:
diff changeset
1884 TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS.
kono
parents:
diff changeset
1885
kono
parents:
diff changeset
1886 2015-08-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1887
kono
parents:
diff changeset
1888 PR c++/67152
kono
parents:
diff changeset
1889 * pt.c (process_partial_specialization): Call
kono
parents:
diff changeset
1890 associate_classtype_constraints.
kono
parents:
diff changeset
1891
kono
parents:
diff changeset
1892 PR c++/67159
kono
parents:
diff changeset
1893 * constraint.cc (finish_template_introduction):
kono
parents:
diff changeset
1894 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT.
kono
parents:
diff changeset
1895
kono
parents:
diff changeset
1896 PR c++/67142
kono
parents:
diff changeset
1897 * pt.c (equal): Make sure tmpl is actually a template.
kono
parents:
diff changeset
1898
kono
parents:
diff changeset
1899 PR c++/67144
kono
parents:
diff changeset
1900 * call.c (joust): Only call more_constrained on decls.
kono
parents:
diff changeset
1901
kono
parents:
diff changeset
1902 2015-08-06 Andrew Sutton <andrew.n.sutton@gmail.com>
kono
parents:
diff changeset
1903 Braden Obrzut <admin@maniacsvault.net>
kono
parents:
diff changeset
1904 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
1905 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
1906
kono
parents:
diff changeset
1907 Add C++ Concepts TS support.
kono
parents:
diff changeset
1908 * constraint.cc, logic.cc: New files.
kono
parents:
diff changeset
1909 * Make-lang.in (CXX_AND_OBJCXX_OBJS): Add constraint.o and logic.o.
kono
parents:
diff changeset
1910 (c++.tags): Also process .cc files.
kono
parents:
diff changeset
1911 * call.c (enum rejection_reason_code): Add rr_constraint_failure.
kono
parents:
diff changeset
1912 (print_z_candidate): Handle it.
kono
parents:
diff changeset
1913 (constraint_failure): New.
kono
parents:
diff changeset
1914 (add_function_candidate): Check constraints.
kono
parents:
diff changeset
1915 (build_new_function_call): Handle evaluating concepts.
kono
parents:
diff changeset
1916 (joust): Check more_constrained.
kono
parents:
diff changeset
1917 * class.c (add_method): Check equivalently_constrained.
kono
parents:
diff changeset
1918 (build_clone): Copy constraints.
kono
parents:
diff changeset
1919 (currently_open_class): Return tree.
kono
parents:
diff changeset
1920 (resolve_address_of_overloaded_function): Check constraints.
kono
parents:
diff changeset
1921 * constexpr.c (cxx_eval_constant_expression): Handle REQUIRES_EXPR.
kono
parents:
diff changeset
1922 (potential_constant_expression_1): Likewise.
kono
parents:
diff changeset
1923 * cp-objcp-common.c (cp_tree_size): Handle CONSTRAINT_INFO.
kono
parents:
diff changeset
1924 (cp_common_init_ts): Handle WILDCARD_DECL and REQUIRES_EXPR.
kono
parents:
diff changeset
1925 * cp-tree.def: Add CONSTRAINT_INFO, WILDCARD_DECL, REQUIRES_EXPR,
kono
parents:
diff changeset
1926 SIMPLE_REQ, TYPE_REQ, COMPOUND_REQ, NESTED_REQ, PRED_CONSTR,
kono
parents:
diff changeset
1927 EXPR_CONSTR, TYPE_CONSTR, ICONV_CONSTR, DEDUCT_CONSTR,
kono
parents:
diff changeset
1928 EXCEPT_CONSTR, PARM_CONSTR, CONJ_CONSTR, DISJ_CONSTR.
kono
parents:
diff changeset
1929 * cp-tree.h (struct tree_constraint_info, check_nonnull)
kono
parents:
diff changeset
1930 (check_constraint_info, CI_TEMPLATE_REQS, CI_DECLARATOR_REQS)
kono
parents:
diff changeset
1931 (CI_ASSOCIATED_CONSTRAINTS, CI_NORMALIZED_CONSTRAINTS)
kono
parents:
diff changeset
1932 (CI_ASSUMPTIONS, TEMPLATE_PARMS_CONSTRAINTS)
kono
parents:
diff changeset
1933 (TEMPLATE_PARM_CONSTRAINTS, COMPOUND_REQ_NOEXCEPT_P)
kono
parents:
diff changeset
1934 (PLACEHOLDER_TYPE_CONSTRAINTS, PRED_CONSTR_EXPR, EXPR_CONSTR_EXPR)
kono
parents:
diff changeset
1935 (TYPE_CONSTR_TYPE, ICONV_CONSTR_EXPR, ICONV_CONSTR_TYPE)
kono
parents:
diff changeset
1936 (DEDUCT_CONSTR_EXPR, DEDUCT_CONSTR_PATTERN)
kono
parents:
diff changeset
1937 (DEDUCT_CONSTR_PLACEHOLDER, EXCEPT_CONSTR_EXPR, PARM_CONSTR_PARMS)
kono
parents:
diff changeset
1938 (PARM_CONSTR_OPERAND, CONSTRAINT_VAR_P, CONSTRAINED_PARM_CONCEPT)
kono
parents:
diff changeset
1939 (CONSTRAINED_PARM_EXTRA_ARGS, CONSTRAINED_PARM_PROTOTYPE)
kono
parents:
diff changeset
1940 (DECL_DECLARED_CONCEPT_P, WILDCARD_PACK_P, struct cp_unevaluated)
kono
parents:
diff changeset
1941 (struct local_specialization_stack, enum auto_deduction_context)
kono
parents:
diff changeset
1942 (variable_concept_p, concept_template_p)
kono
parents:
diff changeset
1943 (struct deferring_access_check_sentinel): New.
kono
parents:
diff changeset
1944 (enum cp_tree_node_structure_enum): Add TS_CP_CONSTRAINT_INFO.
kono
parents:
diff changeset
1945 (union lang_tree_node): Add constraint_info field.
kono
parents:
diff changeset
1946 (struct lang_decl_base): Add concept_p flag.
kono
parents:
diff changeset
1947 (enum cp_decl_spec): Add ds_concept.
kono
parents:
diff changeset
1948 (struct cp_declarator): Add requires_clause.
kono
parents:
diff changeset
1949 * cxx-pretty-print.c (cxx_pretty_printer::primary_expression)
kono
parents:
diff changeset
1950 (cxx_pretty_printer::expression): Handle REQUIRES_EXPR,
kono
parents:
diff changeset
1951 TRAIT_EXPR, *_CONSTR.
kono
parents:
diff changeset
1952 (pp_cxx_parameter_declaration_clause): Accept a chain of
kono
parents:
diff changeset
1953 PARM_DECLs.
kono
parents:
diff changeset
1954 (cxx_pretty_printer::declarator): Print requires-clause.
kono
parents:
diff changeset
1955 (pp_cxx_template_declaration): Likewise.
kono
parents:
diff changeset
1956 (pp_cxx_trait_expression): Handle CPTK_IS_SAME_AS.
kono
parents:
diff changeset
1957 (pp_cxx_requires_clause, pp_cxx_requirement)
kono
parents:
diff changeset
1958 (pp_cxx_requirement_list, pp_cxx_requirement_body)
kono
parents:
diff changeset
1959 (pp_cxx_requires_expr, pp_cxx_simple_requirement)
kono
parents:
diff changeset
1960 (pp_cxx_type_requirement, pp_cxx_compound_requirement)
kono
parents:
diff changeset
1961 (pp_cxx_nested_requirement, pp_cxx_predicate_constraint)
kono
parents:
diff changeset
1962 (pp_cxx_expression_constraint, pp_cxx_type_constraint)
kono
parents:
diff changeset
1963 (pp_cxx_implicit_conversion_constraint)
kono
parents:
diff changeset
1964 (pp_cxx_argument_deduction_constraint)
kono
parents:
diff changeset
1965 (pp_cxx_exception_constraint, pp_cxx_parameterized_constraint)
kono
parents:
diff changeset
1966 (pp_cxx_conjunction, pp_cxx_disjunction, pp_cxx_constraint): New.
kono
parents:
diff changeset
1967 * cxx-pretty-print.h: Declare them.
kono
parents:
diff changeset
1968 * decl.c (decls_match): Compare constraints.
kono
parents:
diff changeset
1969 (duplicate_decls): Likewise. Remove constraints before freeing.
kono
parents:
diff changeset
1970 (cxx_init_decl_processing): Call init_constraint_processing.
kono
parents:
diff changeset
1971 (cp_finish_decl): Diagnose concept without initializer.
kono
parents:
diff changeset
1972 (grokfndecl, grokvardecl): Handle concepts and constraints.
kono
parents:
diff changeset
1973 (grokdeclarator): Handle concept, requires-clause.
kono
parents:
diff changeset
1974 (grokparms): No longer static.
kono
parents:
diff changeset
1975 (xref_tag_1): Check constraints.
kono
parents:
diff changeset
1976 (finish_function): Call check_function_concept.
kono
parents:
diff changeset
1977 (cp_tree_node_structure): Handle CONSTRAINT_INFO.
kono
parents:
diff changeset
1978 (check_concept_refinement, is_concept_var, check_concept_fn): New.
kono
parents:
diff changeset
1979 * decl2.c (check_classfn): Compare constraints.
kono
parents:
diff changeset
1980 (mark_used): Don't instantiate concepts.
kono
parents:
diff changeset
1981 * error.c (dump_template_decl): Print constraints.
kono
parents:
diff changeset
1982 (dump_function_decl): Likewise.
kono
parents:
diff changeset
1983 (dump_expr): Handle REQUIRES_EXPR, *_REQ, *_CONSTR.
kono
parents:
diff changeset
1984 * lex.c (init_reswords): Set D_CXX_CONCEPTS.
kono
parents:
diff changeset
1985 * method.c (implicitly_declare_fn): Copy constraints from
kono
parents:
diff changeset
1986 inherited ctor.
kono
parents:
diff changeset
1987 * parser.h (struct cp_parser): Add in_result_type_constraint_p and
kono
parents:
diff changeset
1988 prevent_constrained_type_specifiers fields.
kono
parents:
diff changeset
1989 * parser.c (make_call_declarator): Add requires_clause parm.
kono
parents:
diff changeset
1990 (cp_parser_new): Clear prevent_constrained_type_specifiers.
kono
parents:
diff changeset
1991 (cp_parser_primary_expression): Handle RID_IS_SAME_AS, RID_REQUIRES.
kono
parents:
diff changeset
1992 (cp_parser_postfix_expression): Set prevent_constrained_type_specifiers.
kono
parents:
diff changeset
1993 (cp_parser_trait_expr): Handle RID_IS_SAME_AS.
kono
parents:
diff changeset
1994 (cp_parser_declaration): Handle concept introduction.
kono
parents:
diff changeset
1995 (cp_parser_member_declaration): Likewise.
kono
parents:
diff changeset
1996 (cp_parser_template_parameter): Handle constrained parameter.
kono
parents:
diff changeset
1997 (cp_parser_type_parameter): Handle constraints.
kono
parents:
diff changeset
1998 (cp_parser_decl_specifier_seq): Handle RID_CONCEPT.
kono
parents:
diff changeset
1999 (cp_parser_template_id): Handle partial concept id.
kono
parents:
diff changeset
2000 (cp_parser_type_name): Add overload that takes typename_keyword_p.
kono
parents:
diff changeset
2001 Handle constrained parameter.
kono
parents:
diff changeset
2002 (cp_parser_nonclass_name): Handle concept names.
kono
parents:
diff changeset
2003 (cp_parser_alias_declaration): Handle constraints.
kono
parents:
diff changeset
2004 (cp_parser_late_return_type_opt): Also handle requires-clause.
kono
parents:
diff changeset
2005 (cp_parser_type_id_1): Handle deduction constraint.
kono
parents:
diff changeset
2006 (cp_parser_parameter_declaration): Handle constrained parameters.
kono
parents:
diff changeset
2007 (cp_parser_class_specifier_1): Handle constraints.
kono
parents:
diff changeset
2008 (cp_parser_template_declaration_after_parameters): Split out from
kono
parents:
diff changeset
2009 cp_parser_template_declaration_after_export.
kono
parents:
diff changeset
2010 (cp_parser_single_declaration): Handle constraints.
kono
parents:
diff changeset
2011 (synthesize_implicit_template_parm): Handle constraints.
kono
parents:
diff changeset
2012 (cp_parser_maybe_concept_name, cp_parser_maybe_partial_concept_id)
kono
parents:
diff changeset
2013 (cp_parser_introduction_list, get_id_declarator)
kono
parents:
diff changeset
2014 (get_unqualified_id, is_constrained_parameter)
kono
parents:
diff changeset
2015 (cp_parser_check_constrained_type_parm)
kono
parents:
diff changeset
2016 (cp_parser_constrained_type_template_parm)
kono
parents:
diff changeset
2017 (cp_parser_constrained_template_template_parm)
kono
parents:
diff changeset
2018 (constrained_non_type_template_parm, finish_constrained_parameter)
kono
parents:
diff changeset
2019 (declares_constrained_type_template_parameter)
kono
parents:
diff changeset
2020 (declares_constrained_template_template_parameter)
kono
parents:
diff changeset
2021 (check_type_concept, cp_parser_maybe_constrained_type_specifier)
kono
parents:
diff changeset
2022 (cp_parser_maybe_concept_name, cp_parser_maybe_partial_concept_id)
kono
parents:
diff changeset
2023 (cp_parser_requires_clause, cp_parser_requires_clause_opt)
kono
parents:
diff changeset
2024 (cp_parser_requires_expression)
kono
parents:
diff changeset
2025 (cp_parser_requirement_parameter_list, cp_parser_requirement_body)
kono
parents:
diff changeset
2026 (cp_parser_requirement_list, cp_parser_requirement)
kono
parents:
diff changeset
2027 (cp_parser_simple_requirement, cp_parser_type_requirement)
kono
parents:
diff changeset
2028 (cp_parser_compound_requirement, cp_parser_nested_requirement)
kono
parents:
diff changeset
2029 (cp_parser_template_introduction)
kono
parents:
diff changeset
2030 (cp_parser_explicit_template_declaration)
kono
parents:
diff changeset
2031 (get_concept_from_constraint): New.
kono
parents:
diff changeset
2032 * pt.c (local_specialization_stack): Implement.
kono
parents:
diff changeset
2033 (maybe_new_partial_specialization): New.
kono
parents:
diff changeset
2034 (maybe_process_partial_specialization): Use it.
kono
parents:
diff changeset
2035 (retrieve_local_specialization, register_local_specialization)
kono
parents:
diff changeset
2036 (template_parm_to_arg, build_template_decl, extract_fnparm_pack)
kono
parents:
diff changeset
2037 (tsubst_expr): No longer static.
kono
parents:
diff changeset
2038 (spec_hasher::equal): Compare constraints.
kono
parents:
diff changeset
2039 (determine_specialization): Handle constraints.
kono
parents:
diff changeset
2040 (check_explicit_specialization): Handle concepts.
kono
parents:
diff changeset
2041 (process_template_parm): Handle constraints.
kono
parents:
diff changeset
2042 (end_template_parm_list): Add overload taking no arguments.
kono
parents:
diff changeset
2043 (process_partial_specialization): Handle concepts and constraints.
kono
parents:
diff changeset
2044 Register partial specializations of variable templates.
kono
parents:
diff changeset
2045 (redeclare_class_template): Handle constraints.
kono
parents:
diff changeset
2046 (convert_template_argument): Handle WILDCARD_DECL. Check
kono
parents:
diff changeset
2047 is_compatible_template_arg.
kono
parents:
diff changeset
2048 (coerce_template_parameter_pack): Handle wildcard packs.
kono
parents:
diff changeset
2049 (coerce_template_parms): DR 1430 also applies to concepts. Add
kono
parents:
diff changeset
2050 overloads taking fewer parameters.
kono
parents:
diff changeset
2051 (lookup_template_class_1): Handle constraints.
kono
parents:
diff changeset
2052 (lookup_template_variable): Concepts are always bool.
kono
parents:
diff changeset
2053 (finish_template_variable): Handle concepts and constraints.
kono
parents:
diff changeset
2054 (tsubst_friend_class): Handle constraints.
kono
parents:
diff changeset
2055 (gen_elem_of_pack_expansion_instantiation): Handle constraints.
kono
parents:
diff changeset
2056 (tsubst_pack_expansion): Handle local parameters.
kono
parents:
diff changeset
2057 (tsubst_decl) [FUNCTION_DECL]: Handle constraints.
kono
parents:
diff changeset
2058 (tsubst) [TEMPLATE_TYPE_PARM]: Handle deduction constraints.
kono
parents:
diff changeset
2059 (tsubst_copy_and_build): Handle REQUIRES_EXPR.
kono
parents:
diff changeset
2060 (more_specialized_fn, more_specialized_partial_spec): Check constraints.
kono
parents:
diff changeset
2061 (more_specialized_inst): Split out from most_specialized_instantiation.
kono
parents:
diff changeset
2062 (most_specialized_partial_spec): Check constraints.
kono
parents:
diff changeset
2063 (instantiate_decl): Never instantiate a concept.
kono
parents:
diff changeset
2064 (value_dependent_expression_p): Handle REQUIRES_EXPR, TYPE_REQ,
kono
parents:
diff changeset
2065 variable concepts.
kono
parents:
diff changeset
2066 (type_dependent_expression_p): Handle WILDCARD_DECL, REQUIRES_EXPR.
kono
parents:
diff changeset
2067 (instantiation_dependent_r): Handle REQUIRES_EXPR and concepts.
kono
parents:
diff changeset
2068 (do_auto_deduction): Add overload taking tsubst flags and context enum.
kono
parents:
diff changeset
2069 Handle constraints.
kono
parents:
diff changeset
2070 (get_template_for_ordering, most_constrained_function)
kono
parents:
diff changeset
2071 (is_compatible_template_arg, convert_wildcard_argument)
kono
parents:
diff changeset
2072 (struct constr_entry, struct constr_hasher, decl_constraints)
kono
parents:
diff changeset
2073 (valid_constraints_p, get_constraints, set_constraints)
kono
parents:
diff changeset
2074 (remove_constraints, init_constraint_processing): New.
kono
parents:
diff changeset
2075 * ptree.c (cxx_print_xnode): Handle CONSTRAINT_INFO.
kono
parents:
diff changeset
2076 * search.c (lookup_member): Do lookup in the open partial
kono
parents:
diff changeset
2077 instantiation.
kono
parents:
diff changeset
2078 * semantics.c (finish_template_template_parm): Handle constraints.
kono
parents:
diff changeset
2079 (fixup_template_type): New.
kono
parents:
diff changeset
2080 (finish_template_type): Call it.
kono
parents:
diff changeset
2081 (trait_expr_value, finish_trait_expr): Handle CPTK_IS_SAME_AS.
kono
parents:
diff changeset
2082 * tree.c (cp_tree_equal): Handle local parameters, CONSTRAINT_INFO.
kono
parents:
diff changeset
2083 (cp_walk_subtrees): Handle REQUIRES_EXPR.
kono
parents:
diff changeset
2084 * typeck.c (cp_build_function_call_vec): Check constraints.
kono
parents:
diff changeset
2085
kono
parents:
diff changeset
2086 2015-08-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2087
kono
parents:
diff changeset
2088 PR c++/66533
kono
parents:
diff changeset
2089 * parser.c (cp_parser_primary_expression): Don't skip to the end
kono
parents:
diff changeset
2090 of the statement if we're parsing tentatively.
kono
parents:
diff changeset
2091
kono
parents:
diff changeset
2092 PR c++/67130
kono
parents:
diff changeset
2093 PR c++/67131
kono
parents:
diff changeset
2094 PR c++/66260
kono
parents:
diff changeset
2095 * mangle.c (write_expression) [TEMPLATE_ID_EXPR]: Handle variable
kono
parents:
diff changeset
2096 templates.
kono
parents:
diff changeset
2097 * pt.c (tsubst_copy_and_build): Check for argument substitution
kono
parents:
diff changeset
2098 failure.
kono
parents:
diff changeset
2099
kono
parents:
diff changeset
2100 2015-08-05 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2101
kono
parents:
diff changeset
2102 * pt.c (determine_specialization): Print candidates after 'no
kono
parents:
diff changeset
2103 match' error.
kono
parents:
diff changeset
2104
kono
parents:
diff changeset
2105 * decl.c (cp_finish_decl): Tidy.
kono
parents:
diff changeset
2106 * typeck.c (finish_class_member_access_expr): Use
kono
parents:
diff changeset
2107 type_dependent_expression_p.
kono
parents:
diff changeset
2108 * semantics.c (finish_id_expression): Use
kono
parents:
diff changeset
2109 type_dependent_expression_p. Don't build_qualified_name for a
kono
parents:
diff changeset
2110 decl in non-dependent scope.
kono
parents:
diff changeset
2111 * pt.c (type_dependent_expression_p): A TEMPLATE_ID_EXPR of an
kono
parents:
diff changeset
2112 identifier is dependent. Remove variable_template_p check.
kono
parents:
diff changeset
2113
kono
parents:
diff changeset
2114 PR c++/66260
kono
parents:
diff changeset
2115 PR c++/66596
kono
parents:
diff changeset
2116 PR c++/66649
kono
parents:
diff changeset
2117 PR c++/66923
kono
parents:
diff changeset
2118 * pt.c (lookup_template_variable): Use NULL_TREE for type.
kono
parents:
diff changeset
2119 (instantiate_template_1): Also set DECL_TI_ARGS based on
kono
parents:
diff changeset
2120 the immediate parent.
kono
parents:
diff changeset
2121 (tsubst_copy_and_build) [TEMPLATE_ID_EXPR]: Handle variable templates.
kono
parents:
diff changeset
2122 (finish_template_variable): Add complain parm.
kono
parents:
diff changeset
2123 * cp-tree.h: Adjust.
kono
parents:
diff changeset
2124
kono
parents:
diff changeset
2125 PR c++/65195
kono
parents:
diff changeset
2126 PR c++/66619
kono
parents:
diff changeset
2127 * semantics.c (finish_id_expression): Call convert_from_reference
kono
parents:
diff changeset
2128 for variable template.
kono
parents:
diff changeset
2129
kono
parents:
diff changeset
2130 2015-08-04 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2131
kono
parents:
diff changeset
2132 * pt.c (lookup_template_class_1): Clear elt.spec.
kono
parents:
diff changeset
2133
kono
parents:
diff changeset
2134 * tree.c (build_target_expr): Copy the location from value.
kono
parents:
diff changeset
2135
kono
parents:
diff changeset
2136 2015-08-02 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2137
kono
parents:
diff changeset
2138 * parser.c (cp_parser_selection_statement): Move handling of
kono
parents:
diff changeset
2139 semicolon body to ...
kono
parents:
diff changeset
2140 (cp_parser_implicitly_scoped_statement): .. here. Call
kono
parents:
diff changeset
2141 warn_for_misleading_indentation even when the body is a
kono
parents:
diff changeset
2142 semicolon. Extract token_indent_infos corresponding to the
kono
parents:
diff changeset
2143 guard, body and next tokens. Adjust call to
kono
parents:
diff changeset
2144 warn_for_misleading_indentation accordingly. Take
kono
parents:
diff changeset
2145 token_indent_info argument.
kono
parents:
diff changeset
2146 (cp_parser_already_scoped_statement): Likewise.
kono
parents:
diff changeset
2147 (cp_parser_selection_statement, cp_parser_iteration_statement):
kono
parents:
diff changeset
2148 Extract a token_indent_info corresponding to the guard token.
kono
parents:
diff changeset
2149
kono
parents:
diff changeset
2150 2015-08-01 Caroline Tice <cmtice@google.com>
kono
parents:
diff changeset
2151
kono
parents:
diff changeset
2152 PR 66521
kono
parents:
diff changeset
2153 * mangle.c : Add vtable-verify.h to include files.
kono
parents:
diff changeset
2154 (get_mangled_vtable_map_var_name): If the DECL_ASSEMBLER_NAME
kono
parents:
diff changeset
2155 is "<anon>" get the real mangled name for the class instead, and
kono
parents:
diff changeset
2156 also store the real mangled name in a vector for use later.
kono
parents:
diff changeset
2157
kono
parents:
diff changeset
2158 2015-07-31 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2159
kono
parents:
diff changeset
2160 PR sanitizer/66977
kono
parents:
diff changeset
2161 * typeck.c (get_member_function_from_ptrfunc): Don't sanitize
kono
parents:
diff changeset
2162 RSHIFT_EXPR.
kono
parents:
diff changeset
2163
kono
parents:
diff changeset
2164 2015-07-30 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2165
kono
parents:
diff changeset
2166 * class.c (check_for_override): Use DECL_SOURCE_LOCATION and "%qD"
kono
parents:
diff changeset
2167 in warning_at instead of "%q+D" in warning.
kono
parents:
diff changeset
2168 (warn_hidden): Likewise but use location_of.
kono
parents:
diff changeset
2169 (finish_struct_anon_r): Likewise use DECL_SOURCE_LOCATION in permerror.
kono
parents:
diff changeset
2170 (check_bitfield_decl, check_field_decls): Likewise in warning_at.
kono
parents:
diff changeset
2171 (check_field_decls): Likewise for permerror.
kono
parents:
diff changeset
2172 (explain_non_literal_class): Likewise for inform.
kono
parents:
diff changeset
2173 (check_bases_and_members, layout_class_type): Likewise for warning_at.
kono
parents:
diff changeset
2174 (note_name_declared_in_class): Use location_of in permerror.
kono
parents:
diff changeset
2175 * name-lookup.c (diagnose_name_conflict): Use location_of in inform.
kono
parents:
diff changeset
2176 (pushdecl_maybe_friend_1): Use DECL_SOURCE_LOCATION in pedwarn,
kono
parents:
diff changeset
2177 inform, and warning_at.
kono
parents:
diff changeset
2178 (check_for_out_of_scope_variable): Likewise for warning_at and
kono
parents:
diff changeset
2179 permerror.
kono
parents:
diff changeset
2180
kono
parents:
diff changeset
2181 2015-07-30 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2182
kono
parents:
diff changeset
2183 DR 1558
kono
parents:
diff changeset
2184 PR c++/67021
kono
parents:
diff changeset
2185 * pt.c (tsubst_decl) [TYPE_DECL]: Clear TYPE_DEPENDENT_P_VALID.
kono
parents:
diff changeset
2186
kono
parents:
diff changeset
2187 2015-07-28 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2188
kono
parents:
diff changeset
2189 * call.c (build_op_delete_call, convert_like_real, build_over_call):
kono
parents:
diff changeset
2190 Use Use DECL_SOURCE_LOCATION and "%qD" in inform and pedwarn instead
kono
parents:
diff changeset
2191 of "%q+D".
kono
parents:
diff changeset
2192 * constexpr.c (explain_invalid_constexpr_fn): Likewise.
kono
parents:
diff changeset
2193 * decl.c (duplicate_decls): Likewise for warning/warning_at.
kono
parents:
diff changeset
2194 * except.c (maybe_noexcept_warning): Likewise.
kono
parents:
diff changeset
2195 * friend.c (make_friend_class): Likewise for inform.
kono
parents:
diff changeset
2196 * mangle.c (mangle_decl): Likewise for warning/warning_at.
kono
parents:
diff changeset
2197 * method.c (process_subob_fn, walk_field_subobs,
kono
parents:
diff changeset
2198 maybe_explain_implicit_delete): Likewise for inform.
kono
parents:
diff changeset
2199 * parser.c (cp_parser_lambda_introducer): Likewise.
kono
parents:
diff changeset
2200 * pt.c (check_specialization_namespace,
kono
parents:
diff changeset
2201 maybe_process_partial_specialization): Likewise for permerror.
kono
parents:
diff changeset
2202 (redeclare_class_template): Likewise for inform_n.
kono
parents:
diff changeset
2203 (coerce_template_parms, tsubst_copy_and_build): Likewise for inform.
kono
parents:
diff changeset
2204 * search.c (check_final_overrider): Likewise.
kono
parents:
diff changeset
2205 * semantics.c (process_outer_var_ref): Likewise.
kono
parents:
diff changeset
2206
kono
parents:
diff changeset
2207 2015-07-27 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2208
kono
parents:
diff changeset
2209 * constexpr.c (cxx_eval_call_expression): Don't add this call to
kono
parents:
diff changeset
2210 the hash table if !depth_ok.
kono
parents:
diff changeset
2211
kono
parents:
diff changeset
2212 2015-07-27 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2213
kono
parents:
diff changeset
2214 PR c++/66555
kono
parents:
diff changeset
2215 PR c/54979
kono
parents:
diff changeset
2216 * call.c (build_new_op_1): Call warn_tautological_cmp.
kono
parents:
diff changeset
2217 * pt.c (tsubst_copy_and_build): Use sentinel to suppress tautological
kono
parents:
diff changeset
2218 compare warnings.
kono
parents:
diff changeset
2219
kono
parents:
diff changeset
2220 2015-07-26 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2221
kono
parents:
diff changeset
2222 PR c++/18969
kono
parents:
diff changeset
2223 * typeck.c (check_return_expr): Also do the basic return-value
kono
parents:
diff changeset
2224 validity checking if processing_template_decl and yet types are
kono
parents:
diff changeset
2225 not dependent. Remove obsolete code.
kono
parents:
diff changeset
2226
kono
parents:
diff changeset
2227 2015-07-26 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2228
kono
parents:
diff changeset
2229 * decl.c (poplevel): Use Use DECL_SOURCE_LOCATION and "%qD"
kono
parents:
diff changeset
2230 in warning_at instead of "%q+D" in warning.
kono
parents:
diff changeset
2231 (warn_extern_redeclared_static): Likewise for inform.
kono
parents:
diff changeset
2232 (check_redeclaration_no_default_args): Likewise for permerror.
kono
parents:
diff changeset
2233 (duplicate_decls): Likewise.
kono
parents:
diff changeset
2234 (check_previous_goto_1): Likewise for inform.
kono
parents:
diff changeset
2235 (check_goto, start_decl, check_for_uninitialized_const_var,
kono
parents:
diff changeset
2236 start_preparsed_function, finish_function§): Likewise.
kono
parents:
diff changeset
2237 * decl2.c (build_anon_union_vars, c_parse_final_cleanups): Likewise.
kono
parents:
diff changeset
2238 * init.c (sort_mem_initializers): Likewise.
kono
parents:
diff changeset
2239 * typeck.c (convert_for_initialization): Likewise for inform.
kono
parents:
diff changeset
2240 (maybe_warn_about_returning_address_of_local): Likewise.
kono
parents:
diff changeset
2241 * typeck2.c (abstract_virtuals_error_sfinae): Likewise for inform.
kono
parents:
diff changeset
2242 (cxx_incomplete_type_diagnostic): Likewise for emit_diagnostic.
kono
parents:
diff changeset
2243
kono
parents:
diff changeset
2244 2015-07-25 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2245
kono
parents:
diff changeset
2246 PR c++/66857
kono
parents:
diff changeset
2247 * cvt.c (ocp_convert): Don't call scalar_constant_value when
kono
parents:
diff changeset
2248 converting to a class type.
kono
parents:
diff changeset
2249
kono
parents:
diff changeset
2250 2015-07-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2251
kono
parents:
diff changeset
2252 PR c++/64969
kono
parents:
diff changeset
2253 * pt.c (splice_late_return_type): Correct deduced return type for
kono
parents:
diff changeset
2254 abbreviated function template.
kono
parents:
diff changeset
2255
kono
parents:
diff changeset
2256 2015-07-24 Richard Biener <rguenther@suse.de>
kono
parents:
diff changeset
2257
kono
parents:
diff changeset
2258 * init.c (build_vec_init): Build iterator bound in the same
kono
parents:
diff changeset
2259 type as the iterator.
kono
parents:
diff changeset
2260
kono
parents:
diff changeset
2261 2015-07-23 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2262
kono
parents:
diff changeset
2263 PR c++/66572
kono
parents:
diff changeset
2264 * pt.c (tsubst_copy_and_build): Add warn_logical_op sentinel.
kono
parents:
diff changeset
2265
kono
parents:
diff changeset
2266 2015-07-23 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2267
kono
parents:
diff changeset
2268 PR c++/52987
kono
parents:
diff changeset
2269 * parser.c (cp_parser_simple_declaration): Robustify check avoiding
kono
parents:
diff changeset
2270 redundant error messages.
kono
parents:
diff changeset
2271
kono
parents:
diff changeset
2272 2015-07-21 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2273
kono
parents:
diff changeset
2274 * decl.c (grokdeclarator): For an erroneous template parameter
kono
parents:
diff changeset
2275 propagate error_mark_node as type.
kono
parents:
diff changeset
2276
kono
parents:
diff changeset
2277 2015-07-20 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2278
kono
parents:
diff changeset
2279 PR c++/55095
kono
parents:
diff changeset
2280 * typeck.c (cp_build_binary_op): Warn about left shift overflows.
kono
parents:
diff changeset
2281
kono
parents:
diff changeset
2282 2015-07-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2283
kono
parents:
diff changeset
2284 PR c++/65091
kono
parents:
diff changeset
2285 * parser.c (cp_parser_unqualified_id): Don't accept ~x in a
kono
parents:
diff changeset
2286 template if there is no type x in scope.
kono
parents:
diff changeset
2287
kono
parents:
diff changeset
2288 2015-07-14 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2289
kono
parents:
diff changeset
2290 PR c++/66850
kono
parents:
diff changeset
2291 * pt.c (redeclare_class_template): Set the DECL_CONTEXTs of each
kono
parents:
diff changeset
2292 template template parm in the redeclaration.
kono
parents:
diff changeset
2293 (lookup_template_class_1): Peel off irrelevant template levels
kono
parents:
diff changeset
2294 from current_template_parms before augmenting the argument
kono
parents:
diff changeset
2295 list.
kono
parents:
diff changeset
2296
kono
parents:
diff changeset
2297 2015-07-14 Andrea Azzarone <azzaronea@gmail.com>
kono
parents:
diff changeset
2298
kono
parents:
diff changeset
2299 PR c++/65071
kono
parents:
diff changeset
2300 * parser.c (cp_parser_sizeof_pack): Also consider template template
kono
parents:
diff changeset
2301 parameters.
kono
parents:
diff changeset
2302
kono
parents:
diff changeset
2303 2015-07-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2304
kono
parents:
diff changeset
2305 * call.c (build_new_method_call_1): Call reshape_init.
kono
parents:
diff changeset
2306
kono
parents:
diff changeset
2307 2015-07-14 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2308
kono
parents:
diff changeset
2309 * pt.c (check_template_shadow): Emit error + inform instead of
kono
parents:
diff changeset
2310 two errors.
kono
parents:
diff changeset
2311
kono
parents:
diff changeset
2312 2015-07-13 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2313
kono
parents:
diff changeset
2314 PR c++/65186
kono
parents:
diff changeset
2315 * pt.c (invalid_nontype_parm_type_p): Accept a bound template
kono
parents:
diff changeset
2316 template parm type under C++11 and later.
kono
parents:
diff changeset
2317
kono
parents:
diff changeset
2318 2015-07-12 Aldy Hernandez <aldyh@redhat.com>
kono
parents:
diff changeset
2319
kono
parents:
diff changeset
2320 * call.c: Fix double word typos.
kono
parents:
diff changeset
2321 * cp-array-notation.c: Same.
kono
parents:
diff changeset
2322 * cp-tree.h: Same.
kono
parents:
diff changeset
2323 * init.c: Same.
kono
parents:
diff changeset
2324 * name-lookup.c: Same.
kono
parents:
diff changeset
2325 * parser.c: Same.
kono
parents:
diff changeset
2326
kono
parents:
diff changeset
2327 2015-07-10 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2328
kono
parents:
diff changeset
2329 PR c++/30044
kono
parents:
diff changeset
2330 * pt.c (begin_template_parm_list): Add a dummy parameter level
kono
parents:
diff changeset
2331 to current_template_parms.
kono
parents:
diff changeset
2332 (end_template_parm_list): Remove the dummy parameter level
kono
parents:
diff changeset
2333 before adding the real one.
kono
parents:
diff changeset
2334 (tsubst): Don't attempt to substitute for template parameters
kono
parents:
diff changeset
2335 corresponding to a dummy argument level.
kono
parents:
diff changeset
2336 (template_parms_to_args): Remove obsolete hack for
kono
parents:
diff changeset
2337 giving template template arguments the proper level.
kono
parents:
diff changeset
2338 (splite_late_return_type): Remove obsolete hack for giving
kono
parents:
diff changeset
2339 template template arguments the proper level.
kono
parents:
diff changeset
2340 * error.c (dump_template_decl): Don't print dummy template
kono
parents:
diff changeset
2341 levels.
kono
parents:
diff changeset
2342
kono
parents:
diff changeset
2343 2015-07-10 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2344
kono
parents:
diff changeset
2345 PR c++/54521
kono
parents:
diff changeset
2346 * call.c (convert_like_real): Do not set LOOKUP_ONLYCONVERTING for
kono
parents:
diff changeset
2347 the second step of copy-initialization.
kono
parents:
diff changeset
2348
kono
parents:
diff changeset
2349 2015-07-10 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2350
kono
parents:
diff changeset
2351 * pt.c (find_parameter_packs_r): Handle variable templates.
kono
parents:
diff changeset
2352 (variable_template_specialization_p): New.
kono
parents:
diff changeset
2353 * cp-tree.h: Declare it.
kono
parents:
diff changeset
2354
kono
parents:
diff changeset
2355 * parser.c (cp_parser_template_id): SET_EXPR_LOCATION.
kono
parents:
diff changeset
2356
kono
parents:
diff changeset
2357 2015-07-10 Eric Botcazou <ebotcazou@adacore.com>
kono
parents:
diff changeset
2358
kono
parents:
diff changeset
2359 * decl2.c (cpp_check): Revert latest change.
kono
parents:
diff changeset
2360
kono
parents:
diff changeset
2361 2015-07-09 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2362
kono
parents:
diff changeset
2363 * pt.c (instantiation_dependent_r) [TRAIT_EXPR]: Call
kono
parents:
diff changeset
2364 value_dependent_expression_p.
kono
parents:
diff changeset
2365
kono
parents:
diff changeset
2366 * cp-tree.h (struct cp_parameter_declarator): Rename ellipsis_p to
kono
parents:
diff changeset
2367 template_parameter_pack_p.
kono
parents:
diff changeset
2368 * parser.c (declarator_can_be_parameter_pack): False if
kono
parents:
diff changeset
2369 parameter_pack_p is set.
kono
parents:
diff changeset
2370 (make_parameter_declarator): Add template_parameter_pack_p parm.
kono
parents:
diff changeset
2371 (cp_parser_template_parameter): Remove parameter pack parsing.
kono
parents:
diff changeset
2372 (cp_parser_parameter_declaration): Handle all parameter packs.
kono
parents:
diff changeset
2373 Tweak default argument permerror.
kono
parents:
diff changeset
2374
kono
parents:
diff changeset
2375 2015-07-09 Andrew Sutton <andrew.n.sutton@gmail.com>
kono
parents:
diff changeset
2376
kono
parents:
diff changeset
2377 * parser.c (cp_parser_default_type_template_argument)
kono
parents:
diff changeset
2378 (cp_parser_default_template_template_argument): Factor out from
kono
parents:
diff changeset
2379 cp_parser_type_parameter.
kono
parents:
diff changeset
2380
kono
parents:
diff changeset
2381 2015-07-09 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2382
kono
parents:
diff changeset
2383 * typeck.c (warn_args_num): Rename to error_args_num.
kono
parents:
diff changeset
2384 (convert_arguments): Adjust calls.
kono
parents:
diff changeset
2385
kono
parents:
diff changeset
2386 2015-07-09 Andrew MacLeod <amacleod@redhat.com>
kono
parents:
diff changeset
2387
kono
parents:
diff changeset
2388 * cp-ubsan.c: Don't include alloc-pool.h or lto-streamer.h.
kono
parents:
diff changeset
2389
kono
parents:
diff changeset
2390 2015-07-08 Eric Botcazou <ebotcazou@adacore.com>
kono
parents:
diff changeset
2391
kono
parents:
diff changeset
2392 * decl2.c (cpp_check): Deal with IS_CONSTEXPR.
kono
parents:
diff changeset
2393
kono
parents:
diff changeset
2394 2015-07-08 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2395
kono
parents:
diff changeset
2396 * decl.c (grokfndecl): Handle flag_openmp_simd like flag_openmp.
kono
parents:
diff changeset
2397 * pt.c (apply_late_template_attributes): Likewise.
kono
parents:
diff changeset
2398
kono
parents:
diff changeset
2399 2015-07-08 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2400
kono
parents:
diff changeset
2401 PR c++/66748
kono
parents:
diff changeset
2402 * tree.c (handle_abi_tag_attribute): Check for CLASS_TYPE_P before
kono
parents:
diff changeset
2403 accessing TYPE_LANG_SPECIFIC node.
kono
parents:
diff changeset
2404
kono
parents:
diff changeset
2405 2015-07-07 Andrew MacLeod <amacleod@redhat.com>
kono
parents:
diff changeset
2406
kono
parents:
diff changeset
2407 * call.c: Adjust includes.
kono
parents:
diff changeset
2408 * class.c: Likewise.
kono
parents:
diff changeset
2409 * constexpr.c: Likewise.
kono
parents:
diff changeset
2410 * cp-array-notation.c: Likewise.
kono
parents:
diff changeset
2411 * cp-gimplify.c: Likewise.
kono
parents:
diff changeset
2412 * cp-lang.c: Likewise.
kono
parents:
diff changeset
2413 * cp-objcp-common.c: Likewise.
kono
parents:
diff changeset
2414 * cp-ubsan.c: Likewise.
kono
parents:
diff changeset
2415 * cvt.c: Likewise.
kono
parents:
diff changeset
2416 * decl.c: Likewise.
kono
parents:
diff changeset
2417 * decl2.c: Likewise.
kono
parents:
diff changeset
2418 * dump.c: Likewise.
kono
parents:
diff changeset
2419 * error.c: Likewise.
kono
parents:
diff changeset
2420 * except.c: Likewise.
kono
parents:
diff changeset
2421 * expr.c: Likewise.
kono
parents:
diff changeset
2422 * friend.c: Likewise.
kono
parents:
diff changeset
2423 * init.c: Likewise.
kono
parents:
diff changeset
2424 * lambda.c: Likewise.
kono
parents:
diff changeset
2425 * lex.c: Likewise.
kono
parents:
diff changeset
2426 * mangle.c: Likewise.
kono
parents:
diff changeset
2427 * method.c: Likewise.
kono
parents:
diff changeset
2428 * name-lookup.c: Likewise.
kono
parents:
diff changeset
2429 * optimize.c: Likewise.
kono
parents:
diff changeset
2430 * parser.c: Likewise.
kono
parents:
diff changeset
2431 * pt.c: Likewise.
kono
parents:
diff changeset
2432 * ptree.c: Likewise.
kono
parents:
diff changeset
2433 * repo.c: Likewise.
kono
parents:
diff changeset
2434 * rtti.c: Likewise.
kono
parents:
diff changeset
2435 * search.c: Likewise.
kono
parents:
diff changeset
2436 * semantics.c: Likewise.
kono
parents:
diff changeset
2437 * tree.c: Likewise.
kono
parents:
diff changeset
2438 * typeck.c: Likewise.
kono
parents:
diff changeset
2439 * typeck2.c: Likewise.
kono
parents:
diff changeset
2440
kono
parents:
diff changeset
2441 2015-07-07 Eric Botcazou <ebotcazou@adacore.com>
kono
parents:
diff changeset
2442
kono
parents:
diff changeset
2443 * decl2.c (cpp_check): Deal with IS_MOVE_CONSTRUCTOR.
kono
parents:
diff changeset
2444
kono
parents:
diff changeset
2445 2015-07-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2446
kono
parents:
diff changeset
2447 * pt.c (reduce_template_parm_level): Also build the TYPE_DECL
kono
parents:
diff changeset
2448 for a template template parameter.
kono
parents:
diff changeset
2449 (tsubst_decl) [TEMPLATE_DECL]: Use the TEMPLATE_DECL built
kono
parents:
diff changeset
2450 by reduce_template_parm_level.
kono
parents:
diff changeset
2451
kono
parents:
diff changeset
2452 * pt.c (argument_pack_element_is_expansion_p): A decl pack is an
kono
parents:
diff changeset
2453 expansion.
kono
parents:
diff changeset
2454
kono
parents:
diff changeset
2455 2015-07-02 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2456
kono
parents:
diff changeset
2457 PR c++/66743
kono
parents:
diff changeset
2458 * pt.c (for_each_template_parm_r) [UNDERLYING_TYPE]: Use
kono
parents:
diff changeset
2459 TYPE_VALUES_RAW rather than TYPE_FIELDS.
kono
parents:
diff changeset
2460
kono
parents:
diff changeset
2461 2015-07-02 Andrew Sutton <andrew.n.sutton@gmail.com>
kono
parents:
diff changeset
2462
kono
parents:
diff changeset
2463 * pt.c (type_dependent_expression_p): Handle expressions
kono
parents:
diff changeset
2464 that refer to variable templates.
kono
parents:
diff changeset
2465
kono
parents:
diff changeset
2466 2015-07-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2467
kono
parents:
diff changeset
2468 * lex.c (init_reswords): s/CXX0X/CXX11/.
kono
parents:
diff changeset
2469 * parser.c (cp_lexer_get_preprocessor_token): Likewise.
kono
parents:
diff changeset
2470
kono
parents:
diff changeset
2471 * mangle.c (write_CV_qualifiers_for_type, write_nested_name):
kono
parents:
diff changeset
2472 Attribute mangling is now -fabi-version=10.
kono
parents:
diff changeset
2473
kono
parents:
diff changeset
2474 PR c++/65945
kono
parents:
diff changeset
2475 * decl.c (cxx_init_decl_processing): Set TYPE_ALIGN of nullptr_t.
kono
parents:
diff changeset
2476 * class.c (layout_nonempty_base_or_field): Warn if that affects
kono
parents:
diff changeset
2477 the offset of a field.
kono
parents:
diff changeset
2478
kono
parents:
diff changeset
2479 2015-07-01 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2480
kono
parents:
diff changeset
2481 PR c++/60365
kono
parents:
diff changeset
2482 * parser.c (cp_parser_check_std_attribute): New.
kono
parents:
diff changeset
2483 (cp_parser_std_attribute_list): Call it.
kono
parents:
diff changeset
2484
kono
parents:
diff changeset
2485 2015-07-01 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2486
kono
parents:
diff changeset
2487 PR c++/66686
kono
parents:
diff changeset
2488 * pt.c (coerce_template_template_parm) [PARM_DECL]: Don't
kono
parents:
diff changeset
2489 return 0 if tsubst returns a dependent type.
kono
parents:
diff changeset
2490
kono
parents:
diff changeset
2491 2015-06-30 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2492
kono
parents:
diff changeset
2493 PR debug/66653
kono
parents:
diff changeset
2494 * decl2.c (is_late_template_attribute): True for tls_model.
kono
parents:
diff changeset
2495
kono
parents:
diff changeset
2496 PR debug/66653
kono
parents:
diff changeset
2497 * cp-tree.h (CP_DECL_THREAD_LOCAL_P): New.
kono
parents:
diff changeset
2498 (DECL_GNU_TLS_P): Use DECL_LANG_SPECIFIC field.
kono
parents:
diff changeset
2499 (SET_DECL_GNU_TLS_P): New.
kono
parents:
diff changeset
2500 * call.c (make_temporary_var_for_ref_to_temp): Use
kono
parents:
diff changeset
2501 CP_DECL_THREAD_LOCAL_P.
kono
parents:
diff changeset
2502 (set_up_extended_ref_temp): Likewise.
kono
parents:
diff changeset
2503 * decl.c (duplicate_decls, expand_static_init): Likewise.
kono
parents:
diff changeset
2504 (redeclaration_error_message, grokvardecl): Likewise.
kono
parents:
diff changeset
2505 (start_decl, register_dtor_fn, grokdeclarator): Likewise.
kono
parents:
diff changeset
2506 * decl2.c (get_guard, var_needs_tls_wrapper): Likewise.
kono
parents:
diff changeset
2507 (handle_tls_init): Likewise.
kono
parents:
diff changeset
2508 * pt.c (tsubst_decl, tsubst_copy_and_build): Likewise.
kono
parents:
diff changeset
2509 * semantics.c (finish_id_expression): Likewise.
kono
parents:
diff changeset
2510 (handle_omp_array_sections_1, finish_omp_clauses): Likewise.
kono
parents:
diff changeset
2511 (finish_omp_threadprivate): Likewise.
kono
parents:
diff changeset
2512 * tree.c (decl_storage_duration): Likewise.
kono
parents:
diff changeset
2513 * cp-gimplify.c (omp_var_to_track): Likewise.
kono
parents:
diff changeset
2514 (cp_genericize_r): Check that it matches DECL_THREAD_LOCAL_P.
kono
parents:
diff changeset
2515 * lex.c (retrofit_lang_decl): Return if DECL_LANG_SPECIFIC is
kono
parents:
diff changeset
2516 already set.
kono
parents:
diff changeset
2517
kono
parents:
diff changeset
2518 2015-06-30 Edward Smith-Rowland <3dw4rd@verizon.net>
kono
parents:
diff changeset
2519
kono
parents:
diff changeset
2520 Implement N4197 - Adding u8 character literals
kono
parents:
diff changeset
2521 * parser.c (cp_parser_primary_expression()): Treat CPP_UTF8CHAR
kono
parents:
diff changeset
2522 and CPP_UTF8CHAR_USERDEF tokens;
kono
parents:
diff changeset
2523 (cp_parser_parenthesized_expression_list()): Treat CPP_UTF8CHAR token.
kono
parents:
diff changeset
2524
kono
parents:
diff changeset
2525 2015-06-29 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2526
kono
parents:
diff changeset
2527 PR c++/65977
kono
parents:
diff changeset
2528 * decl.c (grokfndecl): Allow constexpr declarations of friend
kono
parents:
diff changeset
2529 template specializations.
kono
parents:
diff changeset
2530
kono
parents:
diff changeset
2531 2015-06-29 Manuel López-Ibáñez <manu@gcc.gnu.org>
kono
parents:
diff changeset
2532
kono
parents:
diff changeset
2533 PR fortran/66605
kono
parents:
diff changeset
2534 * decl.c (finish_function): Call do_warn_unused_parameter.
kono
parents:
diff changeset
2535
kono
parents:
diff changeset
2536 2015-06-29 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2537
kono
parents:
diff changeset
2538 PR c/66322
kono
parents:
diff changeset
2539 * decl.c (struct cp_switch): Add OUTSIDE_RANGE_P.
kono
parents:
diff changeset
2540 (push_switch): Set OUTSIDE_RANGE_P.
kono
parents:
diff changeset
2541 (pop_switch): Update c_do_switch_warnings call.
kono
parents:
diff changeset
2542 (finish_case_label): Update c_add_case_label call.
kono
parents:
diff changeset
2543 * semantics.c (finish_switch_cond): Don't warn about -Wswitch-bool
kono
parents:
diff changeset
2544 here.
kono
parents:
diff changeset
2545
kono
parents:
diff changeset
2546 2015-06-27 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2547
kono
parents:
diff changeset
2548 * call.c: Use VECTOR_TYPE_P.
kono
parents:
diff changeset
2549 * constexpr.c: Likewise.
kono
parents:
diff changeset
2550 * cvt.c: Likewise.
kono
parents:
diff changeset
2551 * decl.c: Likewise.
kono
parents:
diff changeset
2552 * decl2.c: Likewise.
kono
parents:
diff changeset
2553 * init.c: Likewise.
kono
parents:
diff changeset
2554 * semantics.c: Likewise.
kono
parents:
diff changeset
2555 * tree.c: Likewise.
kono
parents:
diff changeset
2556 * typeck.c: Likewise.
kono
parents:
diff changeset
2557 * typeck2.c: Likewise.
kono
parents:
diff changeset
2558
kono
parents:
diff changeset
2559 2015-06-27 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2560
kono
parents:
diff changeset
2561 * call.c (set_up_extended_ref_temp): Use VAR_P.
kono
parents:
diff changeset
2562 * class.c: Use VAR_P throughout.
kono
parents:
diff changeset
2563 * constexpr.c (cxx_eval_constant_expression): Use VAR_P.
kono
parents:
diff changeset
2564 * cp-array-notation.c (make_triplet_val_inv): Likewise.
kono
parents:
diff changeset
2565 * decl.c: Use VAR_OR_FUNCTION_DECL_P or VAR_P
kono
parents:
diff changeset
2566 throughout.
kono
parents:
diff changeset
2567 * decl2.c: Likewise.
kono
parents:
diff changeset
2568 * error.c (dump_decl): Use VAR_P.
kono
parents:
diff changeset
2569 * mangle.c (decl_implicit_alias_p): Likewise.
kono
parents:
diff changeset
2570 * parser.c: Use VAR_P throughout.
kono
parents:
diff changeset
2571 * pt.c: Likewise.
kono
parents:
diff changeset
2572 * semantics.c: Likewise.
kono
parents:
diff changeset
2573 * vtable-class-hierarchy.c: Likewise.
kono
parents:
diff changeset
2574 * tree.c (handle_abi_tag_attribute): Use VAR_OR_FUNCTION_DECL_P.
kono
parents:
diff changeset
2575
kono
parents:
diff changeset
2576 2015-06-27 Andreas Schwab <schwab@linux-m68k.org>
kono
parents:
diff changeset
2577
kono
parents:
diff changeset
2578 * pt.c (check_unstripped_args): Mark parameter as unused.
kono
parents:
diff changeset
2579
kono
parents:
diff changeset
2580 2015-06-26 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2581
kono
parents:
diff changeset
2582 PR c++/66216
kono
parents:
diff changeset
2583 * class.c (finish_struct): Call fixup_attribute_variants.
kono
parents:
diff changeset
2584
kono
parents:
diff changeset
2585 PR c++/66684
kono
parents:
diff changeset
2586 * typeck2.c (merge_exception_specifiers): Allow different
kono
parents:
diff changeset
2587 noexcept-specifiers if we've had errors.
kono
parents:
diff changeset
2588
kono
parents:
diff changeset
2589 PR c++/66255
kono
parents:
diff changeset
2590 * pt.c (check_unstripped_args): Split out from...
kono
parents:
diff changeset
2591 (retrieve_specialization): ...here. Allow typedefs in the type of
kono
parents:
diff changeset
2592 a non-type argument.
kono
parents:
diff changeset
2593
kono
parents:
diff changeset
2594 PR c++/66067
kono
parents:
diff changeset
2595 * mangle.c (write_nested_name): Limit TYPENAME_TYPE handling to
kono
parents:
diff changeset
2596 TYPE_DECLs.
kono
parents:
diff changeset
2597 * mangle.c (write_template_args): Handle 0 length TREE_VEC.
kono
parents:
diff changeset
2598
kono
parents:
diff changeset
2599 PR c++/66654
kono
parents:
diff changeset
2600 * typeck2.c (digest_init_r): Only expect reshaping if the class is
kono
parents:
diff changeset
2601 aggregate.
kono
parents:
diff changeset
2602
kono
parents:
diff changeset
2603 2015-06-26 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
2604
kono
parents:
diff changeset
2605 * cp-array-notation.c (expand_sec_reduce_builtin): Use INDIRECT_REF_P.
kono
parents:
diff changeset
2606 * cp-ubsan.c (cp_ubsan_check_member_access_r): Likewise.
kono
parents:
diff changeset
2607
kono
parents:
diff changeset
2608 2015-06-25 Andrew MacLeod <amacleod@redhat.com>
kono
parents:
diff changeset
2609
kono
parents:
diff changeset
2610 * call.c: Remove ipa-ref.h and plugin-api.h from include list.
kono
parents:
diff changeset
2611 * class.c: Likewise.
kono
parents:
diff changeset
2612 * cp-ubsan.c: Likewise.
kono
parents:
diff changeset
2613 * decl.c: Likewise.
kono
parents:
diff changeset
2614 * decl2.c: Likewise.
kono
parents:
diff changeset
2615 * lambda.c: Likewise.
kono
parents:
diff changeset
2616 * mangle.c: Likewise.
kono
parents:
diff changeset
2617 * method.c: Likewise.
kono
parents:
diff changeset
2618 * optimize.c: Likewise.
kono
parents:
diff changeset
2619 * parser.c: Likewise.
kono
parents:
diff changeset
2620 * semantics.c: Likewise.
kono
parents:
diff changeset
2621 * tree.c: Likewise.
kono
parents:
diff changeset
2622 * vtable-class-hierarchy.c: Likewise.
kono
parents:
diff changeset
2623
kono
parents:
diff changeset
2624 2015-06-25 Richard Sandiford <richard.sandiford@arm.com>
kono
parents:
diff changeset
2625
kono
parents:
diff changeset
2626 * constexpr.c (constexpr_fundef_hasher): Inherit from ggc_ptr_hash
kono
parents:
diff changeset
2627 rather than ggc_hasher.
kono
parents:
diff changeset
2628 (constexpr_call_hasher): Likewise.
kono
parents:
diff changeset
2629 * cp-tree.h (cxx_int_tree_map_hasher, named_label_hasher): Likewise.
kono
parents:
diff changeset
2630 * decl.c (typename_hasher): Likewise.
kono
parents:
diff changeset
2631 * mangle.c (conv_type_hasher): Likewise.
kono
parents:
diff changeset
2632 * pt.c (spec_hasher): Likewise.
kono
parents:
diff changeset
2633 * tree.c (cplus_array_hasher, list_hasher): Likewise.
kono
parents:
diff changeset
2634 * typeck2.c (abstract_type_hasher): Likewise.
kono
parents:
diff changeset
2635
kono
parents:
diff changeset
2636 2015-06-25 Richard Sandiford <richard.sandiford@arm.com>
kono
parents:
diff changeset
2637
kono
parents:
diff changeset
2638 * class.c (fixed_type_or_null_ref_ht): Inherit from nofree_ptr_hash
kono
parents:
diff changeset
2639 rather than pointer_hash.
kono
parents:
diff changeset
2640 (fixed_type_or_null): Use nofree_ptr_hash instead of pointer_hash.
kono
parents:
diff changeset
2641 * semantics.c (nrv_data): Likewise.
kono
parents:
diff changeset
2642 * tree.c (verify_stmt_tree_r, verify_stmt_tree): Likewise.
kono
parents:
diff changeset
2643
kono
parents:
diff changeset
2644 2015-06-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2645
kono
parents:
diff changeset
2646 PR c++/66647
kono
parents:
diff changeset
2647 * pt.c (dependent_type_p_r): Check for dependent alias template
kono
parents:
diff changeset
2648 specialization sooner.
kono
parents:
diff changeset
2649
kono
parents:
diff changeset
2650 PR c++/66501
kono
parents:
diff changeset
2651 * class.c (type_has_nontrivial_assignment): Remove.
kono
parents:
diff changeset
2652 * cp-tree.h: Remove declaration.
kono
parents:
diff changeset
2653 * init.c (vec_copy_assign_is_trivial): New.
kono
parents:
diff changeset
2654 (build_vec_init): Use it.
kono
parents:
diff changeset
2655
kono
parents:
diff changeset
2656 2015-06-24 Edward Smith-Rowland <3dw4rd@verizon.net>
kono
parents:
diff changeset
2657
kono
parents:
diff changeset
2658 Implement N3928 - Extending static_assert
kono
parents:
diff changeset
2659 * parser.c (cp_parser_static_assert): Support static_assert with
kono
parents:
diff changeset
2660 no message string. Supply an empty string in this case.
kono
parents:
diff changeset
2661 * semantics.c (finish_static_assert): Don't try to print a message if
kono
parents:
diff changeset
2662 the message strnig is empty.
kono
parents:
diff changeset
2663
kono
parents:
diff changeset
2664 2015-06-24 Adam Butcher <adam@jessamine.co.uk>
kono
parents:
diff changeset
2665
kono
parents:
diff changeset
2666 PR c++/65750
kono
parents:
diff changeset
2667 * parser.c (cp_parser_simple_type_specifier): Don't synthesize
kono
parents:
diff changeset
2668 implicit template parm if 'auto' is a placeholder for trailing
kono
parents:
diff changeset
2669 return type.
kono
parents:
diff changeset
2670
kono
parents:
diff changeset
2671 2015-06-24 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2672
kono
parents:
diff changeset
2673 Revert:
kono
parents:
diff changeset
2674 2015-06-23 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2675
kono
parents:
diff changeset
2676 PR c++/30044
kono
parents:
diff changeset
2677 * parser.c (cp_parser_template_parameter_list): Update
kono
parents:
diff changeset
2678 current_template_parms right after processing a paramater.
kono
parents:
diff changeset
2679 * pt.c (template_parms_to_args): Remove obsolete hack for
kono
parents:
diff changeset
2680 giving template template arguments the proper level.
kono
parents:
diff changeset
2681 (check_default_tmpl_args): Account for tested template
kono
parents:
diff changeset
2682 parameter_lists.
kono
parents:
diff changeset
2683 (splite_late_return_type): Remove obsolete hack for giving
kono
parents:
diff changeset
2684 template template arguments the proper level.
kono
parents:
diff changeset
2685
kono
parents:
diff changeset
2686 2015-06-24 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2687
kono
parents:
diff changeset
2688 PR c++/65811
kono
parents:
diff changeset
2689 * decl.c (duplicate_decls): Adjust DECL_COMDAT of newdecl.
kono
parents:
diff changeset
2690
kono
parents:
diff changeset
2691 2015-06-23 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2692
kono
parents:
diff changeset
2693 PR c++/30044
kono
parents:
diff changeset
2694 * parser.c (cp_parser_template_parameter_list): Update
kono
parents:
diff changeset
2695 current_template_parms right after processing a paramater.
kono
parents:
diff changeset
2696 * pt.c (template_parms_to_args): Remove obsolete hack for
kono
parents:
diff changeset
2697 giving template template arguments the proper level.
kono
parents:
diff changeset
2698 (check_default_tmpl_args): Account for tested template
kono
parents:
diff changeset
2699 parameter_lists.
kono
parents:
diff changeset
2700 (splite_late_return_type): Remove obsolete hack for giving
kono
parents:
diff changeset
2701 template template arguments the proper level.
kono
parents:
diff changeset
2702
kono
parents:
diff changeset
2703 2015-06-23 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2704
kono
parents:
diff changeset
2705 PR c++/65879
kono
parents:
diff changeset
2706 * decl.c (grokfndecl): Check the linkage of ctype, not just
kono
parents:
diff changeset
2707 TYPE_ANONYMOUS_P.
kono
parents:
diff changeset
2708 * tree.c (no_linkage_check): Skip the 'this' pointer.
kono
parents:
diff changeset
2709
kono
parents:
diff changeset
2710 PR c++/66501
kono
parents:
diff changeset
2711 * class.c (type_has_nontrivial_assignment): New.
kono
parents:
diff changeset
2712 * init.c (build_vec_init): Use it.
kono
parents:
diff changeset
2713 * cp-tree.h: Declare it.
kono
parents:
diff changeset
2714 * method.c (trivial_fn_p): Templates aren't trivial.
kono
parents:
diff changeset
2715
kono
parents:
diff changeset
2716 PR c++/66542
kono
parents:
diff changeset
2717 * decl.c (expand_static_init): Make sure the destructor is callable
kono
parents:
diff changeset
2718 here even if we have an initializer.
kono
parents:
diff changeset
2719
kono
parents:
diff changeset
2720 2015-06-04 Pierre-Marie de Rodat <derodat@adacore.com>
kono
parents:
diff changeset
2721
kono
parents:
diff changeset
2722 * lang-specs.h: Pass "-o %g.s" to cc1plus for headers even if
kono
parents:
diff changeset
2723 -fdump-ada-spec is passed.
kono
parents:
diff changeset
2724
kono
parents:
diff changeset
2725 2015-06-22 Pierre-Marie de Rodat <derodat@adacore.com>
kono
parents:
diff changeset
2726
kono
parents:
diff changeset
2727 * decl2.c (cpp_check): Deal with HAS_DEPENDENT_TEMPLATE_ARGS.
kono
parents:
diff changeset
2728
kono
parents:
diff changeset
2729 2015-06-22 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2730
kono
parents:
diff changeset
2731 * decl.c (grokdeclarator): Use declspecs->locations[ds_virtual].
kono
parents:
diff changeset
2732
kono
parents:
diff changeset
2733 2015-06-22 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2734
kono
parents:
diff changeset
2735 * decl.c (grokdeclarator): Remove pointless code.
kono
parents:
diff changeset
2736
kono
parents:
diff changeset
2737 2015-06-22 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2738
kono
parents:
diff changeset
2739 PR c++/66515
kono
parents:
diff changeset
2740 * call.c (implicit_conversion): Only reshape for classes.
kono
parents:
diff changeset
2741
kono
parents:
diff changeset
2742 2015-06-22 Mikhail Maltsev <maltsevm@gmail.com>
kono
parents:
diff changeset
2743
kono
parents:
diff changeset
2744 * pt.c (maybe_adjust_types_for_deduction): Use std::swap instead of
kono
parents:
diff changeset
2745 manually swapping.
kono
parents:
diff changeset
2746 * semantics.c (finish_omp_atomic): Likewise.
kono
parents:
diff changeset
2747 * typeck.c (cp_build_array_ref): Likewise.
kono
parents:
diff changeset
2748
kono
parents:
diff changeset
2749 2015-06-20 Mikhail Maltsev <maltsevm@gmail.com>
kono
parents:
diff changeset
2750
kono
parents:
diff changeset
2751 PR c++/65882
kono
parents:
diff changeset
2752 * call.c (build_new_op_1): Check tf_warning flag in all cases.
kono
parents:
diff changeset
2753
kono
parents:
diff changeset
2754 2015-06-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2755
kono
parents:
diff changeset
2756 PR c++/66585
kono
parents:
diff changeset
2757 * pt.c (instantiate_class_template_1): Clear
kono
parents:
diff changeset
2758 cp_unevaluated_operand and c_inhibit_evaluation_warnings.
kono
parents:
diff changeset
2759
kono
parents:
diff changeset
2760 PR c++/65880
kono
parents:
diff changeset
2761 * decl.c (build_ptrmemfunc_type): Check TYPE_GET_PTRMEMFUNC_TYPE after
kono
parents:
diff changeset
2762 cv-qualifiers.
kono
parents:
diff changeset
2763 * typeck.c (merge_types): build_ptrmemfunc_type before applying
kono
parents:
diff changeset
2764 quals and attributes.
kono
parents:
diff changeset
2765
kono
parents:
diff changeset
2766 PR c++/65973
kono
parents:
diff changeset
2767 * constexpr.c (build_constexpr_constructor_member_initializers):
kono
parents:
diff changeset
2768 Handle an empty STATEMENT_LIST.
kono
parents:
diff changeset
2769
kono
parents:
diff changeset
2770 PR c++/65843
kono
parents:
diff changeset
2771 * pt.c (tsubst_copy_and_build): Register a capture proxy in
kono
parents:
diff changeset
2772 local_specializations.
kono
parents:
diff changeset
2773
kono
parents:
diff changeset
2774 2015-06-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2775
kono
parents:
diff changeset
2776 PR c++/66001
kono
parents:
diff changeset
2777 * constexpr.c (cxx_eval_constant_expression): Handle TRY_BLOCK and
kono
parents:
diff changeset
2778 TRY_FINALLY_EXPR.
kono
parents:
diff changeset
2779 (potential_constant_expression_1): Likewise.
kono
parents:
diff changeset
2780
kono
parents:
diff changeset
2781 2015-06-17 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2782
kono
parents:
diff changeset
2783 PR c++/66515
kono
parents:
diff changeset
2784 * call.c (implicit_conversion): Call reshape_init here, early.
kono
parents:
diff changeset
2785 (build_aggr_conv): Not here.
kono
parents:
diff changeset
2786
kono
parents:
diff changeset
2787 2015-06-17 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
2788
kono
parents:
diff changeset
2789 PR c++/66571
kono
parents:
diff changeset
2790 * pt.c (tsubst_omp_clause_decl): New function.
kono
parents:
diff changeset
2791 (tsubst_omp_clauses): Use it or tsubst_copy instead of
kono
parents:
diff changeset
2792 tsubst_expr on OMP_CLAUSE_DECL.
kono
parents:
diff changeset
2793
kono
parents:
diff changeset
2794 2015-06-17 Andrew MacLeod <amacleod@redhat.com>
kono
parents:
diff changeset
2795
kono
parents:
diff changeset
2796 * cp-lang.c (cxx_dwarf_name): Use anon_aggrname_p.
kono
parents:
diff changeset
2797 * cp-tree.h (TYPE_ANONYMOUS_P): Likewise.
kono
parents:
diff changeset
2798 * decl.c (grokdeclarator, xref_tag_1): Likewise.
kono
parents:
diff changeset
2799 * error.c (dump_aggr_type): likewise.
kono
parents:
diff changeset
2800 * pt.c (push_template_decl_real): Likewise.
kono
parents:
diff changeset
2801 * name-lookup.c (make_anon_name): Use anon_aggrname_format.
kono
parents:
diff changeset
2802
kono
parents:
diff changeset
2803 2015-06-17 Andrew MacLeod <amacleod@redhat.com>
kono
parents:
diff changeset
2804
kono
parents:
diff changeset
2805 * call.c: Do not include input.h, line-map.h or is-a.h.
kono
parents:
diff changeset
2806 * class.c: Likewise.
kono
parents:
diff changeset
2807 * constexpr.c: Likewise.
kono
parents:
diff changeset
2808 * cp-array-notation.c: Likewise.
kono
parents:
diff changeset
2809 * cp-gimplify.c: Likewise.
kono
parents:
diff changeset
2810 * cp-lang.c: Likewise.
kono
parents:
diff changeset
2811 * cp-objcp-common.c: Likewise.
kono
parents:
diff changeset
2812 * cp-tree.h: Likewise.
kono
parents:
diff changeset
2813 * cp-ubsan.c: Likewise.
kono
parents:
diff changeset
2814 * cvt.c: Likewise.
kono
parents:
diff changeset
2815 * decl.c: Likewise.
kono
parents:
diff changeset
2816 * decl2.c: Likewise.
kono
parents:
diff changeset
2817 * dump.c: Likewise.
kono
parents:
diff changeset
2818 * error.c: Likewise.
kono
parents:
diff changeset
2819 * except.c: Likewise.
kono
parents:
diff changeset
2820 * expr.c: Likewise.
kono
parents:
diff changeset
2821 * friend.c: Likewise.
kono
parents:
diff changeset
2822 * init.c: Likewise.
kono
parents:
diff changeset
2823 * lambda.c: Likewise.
kono
parents:
diff changeset
2824 * lex.c: Likewise.
kono
parents:
diff changeset
2825 * mangle.c: Likewise.
kono
parents:
diff changeset
2826 * method.c: Likewise.
kono
parents:
diff changeset
2827 * name-lookup.c: Likewise.
kono
parents:
diff changeset
2828 * optimize.c: Likewise.
kono
parents:
diff changeset
2829 * parser.c: Likewise.
kono
parents:
diff changeset
2830 * pt.c: Likewise.
kono
parents:
diff changeset
2831 * ptree.c: Likewise.
kono
parents:
diff changeset
2832 * repo.c: Likewise.
kono
parents:
diff changeset
2833 * rtti.c: Likewise.
kono
parents:
diff changeset
2834 * search.c: Likewise.
kono
parents:
diff changeset
2835 * semantics.c: Likewise.
kono
parents:
diff changeset
2836 * tree.c: Likewise.
kono
parents:
diff changeset
2837 * typeck.c: Likewise.
kono
parents:
diff changeset
2838 * typeck2.c: Likewise.
kono
parents:
diff changeset
2839 * vtable-class-hierarchy.c: Likewise.
kono
parents:
diff changeset
2840
kono
parents:
diff changeset
2841 2015-06-16 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2842
kono
parents:
diff changeset
2843 PR c++/59682
kono
parents:
diff changeset
2844 * parser.c (cp_parser_new_placement): Reject an empty expression-list.
kono
parents:
diff changeset
2845
kono
parents:
diff changeset
2846 2015-06-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2847
kono
parents:
diff changeset
2848 PR c++/66536
kono
parents:
diff changeset
2849 * tree.c (replace_placeholders_r) [CONSTRUCTOR]: Handle type
kono
parents:
diff changeset
2850 mismatch.
kono
parents:
diff changeset
2851
kono
parents:
diff changeset
2852 PR c++/58063
kono
parents:
diff changeset
2853 * tree.c (bot_manip): Remap SAVE_EXPR.
kono
parents:
diff changeset
2854
kono
parents:
diff changeset
2855 PR c++/66387
kono
parents:
diff changeset
2856 * pt.c (tsubst_copy) [VAR_DECL]: Use process_outer_var_ref.
kono
parents:
diff changeset
2857
kono
parents:
diff changeset
2858 2015-06-15 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
2859
kono
parents:
diff changeset
2860 PR c++/58583
kono
parents:
diff changeset
2861 * cp-tree.h (DECL_INSTANTIATING_NSDMI_P): New.
kono
parents:
diff changeset
2862 * init.c (get_nsdmi): Check for DEFAULT_ARG in template case and
kono
parents:
diff changeset
2863 protect it from recursive instantiation.
kono
parents:
diff changeset
2864
kono
parents:
diff changeset
2865 2015-06-15 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2866
kono
parents:
diff changeset
2867 PR c++/51048
kono
parents:
diff changeset
2868 * decl2.c (no_linkage_error): Do not issue a permerror if the DECL
kono
parents:
diff changeset
2869 using a local type is pure virtual.
kono
parents:
diff changeset
2870
kono
parents:
diff changeset
2871 2015-06-13 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2872
kono
parents:
diff changeset
2873 * call.c: Remove comment documenting the long-deleted
kono
parents:
diff changeset
2874 function build_method_call.
kono
parents:
diff changeset
2875
kono
parents:
diff changeset
2876 2015-06-13 Patrick Palka <ppalka@gcc.gnu.org>
kono
parents:
diff changeset
2877
kono
parents:
diff changeset
2878 PR c++/65168
kono
parents:
diff changeset
2879 * typeck.c (cp_build_binary_op): Warn when comparing an address
kono
parents:
diff changeset
2880 of a reference against NULL.
kono
parents:
diff changeset
2881
kono
parents:
diff changeset
2882 2015-06-12 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2883
kono
parents:
diff changeset
2884 PR c++/65719
kono
parents:
diff changeset
2885 * pt.c (tsubst_decl) [VAR_DECL]: Mark namespace-scope
kono
parents:
diff changeset
2886 variables as DECL_NOT_REALLY_EXTERN.
kono
parents:
diff changeset
2887
kono
parents:
diff changeset
2888 2015-06-11 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2889
kono
parents:
diff changeset
2890 PR c++/66445
kono
parents:
diff changeset
2891 * constexpr.c (potential_constant_expression_1): Handle a
kono
parents:
diff changeset
2892 DECL_EXPR of TYPE_DECL.
kono
parents:
diff changeset
2893
kono
parents:
diff changeset
2894 PR c++/66450
kono
parents:
diff changeset
2895 * constexpr.c (cxx_eval_store_expression): Avoid messing up outer
kono
parents:
diff changeset
2896 ctx->ctor.
kono
parents:
diff changeset
2897
kono
parents:
diff changeset
2898 2015-06-11 Pierre-Marie de Rodat <derodat@adacore.com>
kono
parents:
diff changeset
2899
kono
parents:
diff changeset
2900 * decl.c (cxx_init_decl_processing): Register the main
kono
parents:
diff changeset
2901 translation unit through the new debug hook.
kono
parents:
diff changeset
2902
kono
parents:
diff changeset
2903 2015-06-10 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2904
kono
parents:
diff changeset
2905 PR c++/66289
kono
parents:
diff changeset
2906 * cp-tree.h (TEMPLATE_DECL_COMPLEX_ALIAS_P): New.
kono
parents:
diff changeset
2907 * pt.c (push_template_decl_real): Set it.
kono
parents:
diff changeset
2908 (dependent_alias_template_spec_p): Use it.
kono
parents:
diff changeset
2909 (dependent_type_p_r): Use dependent_alias_template_spec_p.
kono
parents:
diff changeset
2910 (uses_all_template_parms_data, uses_all_template_parms_r)
kono
parents:
diff changeset
2911 (complex_alias_template_p): New.
kono
parents:
diff changeset
2912 (get_template_parm_index): Handle BOUND_TEMPLATE_TEMPLATE_PARM.
kono
parents:
diff changeset
2913
kono
parents:
diff changeset
2914 2015-06-09 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2915
kono
parents:
diff changeset
2916 DR 1467
kono
parents:
diff changeset
2917 PR c++/51747
kono
parents:
diff changeset
2918 * typeck2.c (digest_init_r): Replace previous change with
kono
parents:
diff changeset
2919 gcc_unreachable.
kono
parents:
diff changeset
2920
kono
parents:
diff changeset
2921 PR c++/66387
kono
parents:
diff changeset
2922 * semantics.c (process_outer_var_ref): Make sure the value is
kono
parents:
diff changeset
2923 actually constant before returning it.
kono
parents:
diff changeset
2924 * typeck.c (cp_build_array_ref): Allow subscripting non-lvalue
kono
parents:
diff changeset
2925 array.
kono
parents:
diff changeset
2926
kono
parents:
diff changeset
2927 2015-06-09 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
2928
kono
parents:
diff changeset
2929 PR c++/65815
kono
parents:
diff changeset
2930 * typeck2.c (digest_nsdmi_init): On aggregates use reshape_init.
kono
parents:
diff changeset
2931 * init.c (expand_default_init): Likewise.
kono
parents:
diff changeset
2932
kono
parents:
diff changeset
2933 2015-06-09 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2934
kono
parents:
diff changeset
2935 PR c++/66383
kono
parents:
diff changeset
2936 * tree.c (replace_placeholders_r): Handle placeholders for an
kono
parents:
diff changeset
2937 outer object.
kono
parents:
diff changeset
2938 * typeck2.c (store_init_value): Only replace_placeholders for
kono
parents:
diff changeset
2939 objects of class type.
kono
parents:
diff changeset
2940
kono
parents:
diff changeset
2941 2015-06-08 Andrew MacLeod <amacleod@redhat.com>
kono
parents:
diff changeset
2942
kono
parents:
diff changeset
2943 * call.c : Adjust include files.
kono
parents:
diff changeset
2944 * class.c : Likewise.
kono
parents:
diff changeset
2945 * constexpr.c : Likewise.
kono
parents:
diff changeset
2946 * cp-array-notation.c : Likewise.
kono
parents:
diff changeset
2947 * cp-cilkplus.c : Likewise.
kono
parents:
diff changeset
2948 * cp-gimplify.c : Likewise.
kono
parents:
diff changeset
2949 * cp-lang.c : Likewise.
kono
parents:
diff changeset
2950 * cp-objcp-common.c : Likewise.
kono
parents:
diff changeset
2951 * cp-tree.h : Likewise.
kono
parents:
diff changeset
2952 * cp-ubsan.c : Likewise.
kono
parents:
diff changeset
2953 * cvt.c : Likewise.
kono
parents:
diff changeset
2954 * decl.c : Likewise.
kono
parents:
diff changeset
2955 * decl2.c : Likewise.
kono
parents:
diff changeset
2956 * dump.c : Likewise.
kono
parents:
diff changeset
2957 * error.c : Likewise.
kono
parents:
diff changeset
2958 * except.c : Likewise.
kono
parents:
diff changeset
2959 * expr.c : Likewise.
kono
parents:
diff changeset
2960 * friend.c : Likewise.
kono
parents:
diff changeset
2961 * init.c : Likewise.
kono
parents:
diff changeset
2962 * lambda.c : Likewise.
kono
parents:
diff changeset
2963 * lex.c : Likewise.
kono
parents:
diff changeset
2964 * mangle.c : Likewise.
kono
parents:
diff changeset
2965 * method.c : Likewise.
kono
parents:
diff changeset
2966 * name-lookup.c : Likewise.
kono
parents:
diff changeset
2967 * optimize.c : Likewise.
kono
parents:
diff changeset
2968 * parser.c : Likewise.
kono
parents:
diff changeset
2969 * pt.c : Likewise.
kono
parents:
diff changeset
2970 * ptree.c : Likewise.
kono
parents:
diff changeset
2971 * repo.c : Likewise.
kono
parents:
diff changeset
2972 * rtti.c : Likewise.
kono
parents:
diff changeset
2973 * search.c : Likewise.
kono
parents:
diff changeset
2974 * semantics.c : Likewise.
kono
parents:
diff changeset
2975 * tree.c : Likewise.
kono
parents:
diff changeset
2976 * typeck.c : Likewise.
kono
parents:
diff changeset
2977 * typeck2.c : Likewise.
kono
parents:
diff changeset
2978 * vtable-class-hierarchy.c : Likewise.
kono
parents:
diff changeset
2979
kono
parents:
diff changeset
2980 2015-06-05 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
2981
kono
parents:
diff changeset
2982 PR c++/66405
kono
parents:
diff changeset
2983 * pt.c (argument_pack_element_is_expansion_p): Return 2 if
kono
parents:
diff changeset
2984 the expansion has extra args.
kono
parents:
diff changeset
2985 (use_pack_expansion_extra_args_p): Return true in that case.
kono
parents:
diff changeset
2986
kono
parents:
diff changeset
2987 PR c++/66405
kono
parents:
diff changeset
2988 * pt.c (type_dependent_expression_p): EXPR_PACK_EXPANSION is
kono
parents:
diff changeset
2989 dependent even if it has a type.
kono
parents:
diff changeset
2990
kono
parents:
diff changeset
2991 2015-06-05 Aldy Hernandez <aldyh@redhat.com>
kono
parents:
diff changeset
2992
kono
parents:
diff changeset
2993 * cp-objcp-common.c: Adjust comment for
kono
parents:
diff changeset
2994 cxx_warn_unused_global_decl.
kono
parents:
diff changeset
2995 * cp-objcp-common.h (LANG_HOOKS_WRITE_GLOBALS): Remove
kono
parents:
diff changeset
2996 (LANG_HOOKS_POST_COMPILATION_PARSING_CLEANUPS): New.
kono
parents:
diff changeset
2997 * cp-tree.h (note_mangling_alias): Protoize.
kono
parents:
diff changeset
2998 (cp_write_global_declarations): Remove.
kono
parents:
diff changeset
2999 (cxx_post_compilation_parsing_cleanups): Protoize.
kono
parents:
diff changeset
3000 * decl.c (wrapup_globals_for_namespace): Remove use of DATA
kono
parents:
diff changeset
3001 argument.
kono
parents:
diff changeset
3002 * decl2.c (mangling_aliases): New global.
kono
parents:
diff changeset
3003 (build_java_method_aliases): New. Adapted from
kono
parents:
diff changeset
3004 collect_candidates_for_java_method_aliases.
kono
parents:
diff changeset
3005 (collect_candidates_for_java_method_aliases): Remove.
kono
parents:
diff changeset
3006 (build_java_method_aliases): Remove.
kono
parents:
diff changeset
3007 (generate_mangling_aliases): New.
kono
parents:
diff changeset
3008 (note_mangling_alias): New. Moved from mangle_decl.
kono
parents:
diff changeset
3009 (locus_at_end_of_parsing): New global.
kono
parents:
diff changeset
3010 (c_parse_final_cleanups): Rename from
kono
parents:
diff changeset
3011 cp_write_global_declarations.
kono
parents:
diff changeset
3012 Use locus_at_end_of_parsing.
kono
parents:
diff changeset
3013 Call generate_mangling_aliases.
kono
parents:
diff changeset
3014 Rename call to collect_candidates_for_java_method_aliases into
kono
parents:
diff changeset
3015 build_java_method_aliases.
kono
parents:
diff changeset
3016 Remove call to finalize_compilation_unit.
kono
parents:
diff changeset
3017 Move vtable handling into cxx_post_compilation_parsing_cleanups.
kono
parents:
diff changeset
3018 Do not call check_global_declarations or
kono
parents:
diff changeset
3019 emit_debug_global_declarations.
kono
parents:
diff changeset
3020 (cxx_post_compilation_parsing_cleanups): New.
kono
parents:
diff changeset
3021 * mangle.c (mangle_decl): Move code to note_mangling_alias.
kono
parents:
diff changeset
3022 * name-lookup.c (do_namespace_alias): Call early_global_decl.
kono
parents:
diff changeset
3023
kono
parents:
diff changeset
3024 2015-06-05 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
3025
kono
parents:
diff changeset
3026 PR c++/52595
kono
parents:
diff changeset
3027 * parser.c (cp_parser_cache_defarg): Continue looking for
kono
parents:
diff changeset
3028 declarators when scanning a potential template argument list of an
kono
parents:
diff changeset
3029 NSDMI.
kono
parents:
diff changeset
3030
kono
parents:
diff changeset
3031 2015-06-04 Andrew MacLeod <amacleod@redhat.com>
kono
parents:
diff changeset
3032
kono
parents:
diff changeset
3033 * call.c: Adjust includes for restructured coretypes.h.
kono
parents:
diff changeset
3034 * class.c: Likewise.
kono
parents:
diff changeset
3035 * constexpr.c: Likewise.
kono
parents:
diff changeset
3036 * cp-array-notation.c: Likewise.
kono
parents:
diff changeset
3037 * cp-gimplify.c: Likewise.
kono
parents:
diff changeset
3038 * cp-lang.c: Likewise.
kono
parents:
diff changeset
3039 * cp-objcp-common.c: Likewise.
kono
parents:
diff changeset
3040 * cp-tree.h: Likewise.
kono
parents:
diff changeset
3041 * cp-ubsan.c: Likewise.
kono
parents:
diff changeset
3042 * cvt.c: Likewise.
kono
parents:
diff changeset
3043 * decl.c: Likewise.
kono
parents:
diff changeset
3044 * decl2.c: Likewise.
kono
parents:
diff changeset
3045 * dump.c: Likewise.
kono
parents:
diff changeset
3046 * error.c: Likewise.
kono
parents:
diff changeset
3047 * except.c: Likewise.
kono
parents:
diff changeset
3048 * expr.c: Likewise.
kono
parents:
diff changeset
3049 * friend.c: Likewise.
kono
parents:
diff changeset
3050 * init.c: Likewise.
kono
parents:
diff changeset
3051 * lambda.c: Likewise.
kono
parents:
diff changeset
3052 * lex.c: Likewise.
kono
parents:
diff changeset
3053 * mangle.c: Likewise.
kono
parents:
diff changeset
3054 * method.c: Likewise.
kono
parents:
diff changeset
3055 * name-lookup.c: Likewise.
kono
parents:
diff changeset
3056 * optimize.c: Likewise.
kono
parents:
diff changeset
3057 * parser.c: Likewise.
kono
parents:
diff changeset
3058 * pt.c: Likewise.
kono
parents:
diff changeset
3059 * ptree.c: Likewise.
kono
parents:
diff changeset
3060 * repo.c: Likewise.
kono
parents:
diff changeset
3061 * rtti.c: Likewise.
kono
parents:
diff changeset
3062 * search.c: Likewise.
kono
parents:
diff changeset
3063 * semantics.c: Likewise.
kono
parents:
diff changeset
3064 * tree.c: Likewise.
kono
parents:
diff changeset
3065 * typeck.c: Likewise.
kono
parents:
diff changeset
3066 * typeck2.c: Likewise.
kono
parents:
diff changeset
3067 * vtable-class-hierarchy.c: Likewise.
kono
parents:
diff changeset
3068
kono
parents:
diff changeset
3069 2015-06-04 Ramana Radhakrishnan <ramana.radhakrishnan@arm.com>
kono
parents:
diff changeset
3070
kono
parents:
diff changeset
3071 PR c++/66192
kono
parents:
diff changeset
3072 PR target/66200
kono
parents:
diff changeset
3073 * cp-tree.h (get_guard_cond): Adjust declaration
kono
parents:
diff changeset
3074 * decl.c (expand_static_init): Use atomic load acquire
kono
parents:
diff changeset
3075 and adjust call to get_guard_cond.
kono
parents:
diff changeset
3076 * decl2.c (build_atomic_load_byte): New function.
kono
parents:
diff changeset
3077 (get_guard_cond): Handle thread_safety.
kono
parents:
diff changeset
3078 (one_static_initialization_or_destruction): Adjust call to
kono
parents:
diff changeset
3079 get_guard_cond.
kono
parents:
diff changeset
3080
kono
parents:
diff changeset
3081 2015-06-03 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3082
kono
parents:
diff changeset
3083 PR c++/44282
kono
parents:
diff changeset
3084 * mangle.c (mangle_decl): Always SET_IDENTIFIER_GLOBAL_VALUE.
kono
parents:
diff changeset
3085 (write_CV_qualifiers_for_type): Set G.need_abi_warning.
kono
parents:
diff changeset
3086 (decl_implicit_alias_p): Split out from maybe_remove_implicit_alias.
kono
parents:
diff changeset
3087 * cp-tree.h (DECL_REALLY_EXTERN): Handle null DECL_LANG_SPECIFIC.
kono
parents:
diff changeset
3088
kono
parents:
diff changeset
3089 2015-06-03 Manuel López-Ibáñez <manu@gcc.gnu.org>
kono
parents:
diff changeset
3090 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3091
kono
parents:
diff changeset
3092 PR c++/66130
kono
parents:
diff changeset
3093 * typeck.c (invalid_nonstatic_memfn_p): Add location_t parameter and
kono
parents:
diff changeset
3094 use it in the diagnostic.
kono
parents:
diff changeset
3095 (decay_conversion): Adjust call.
kono
parents:
diff changeset
3096 * semantics.c (finish_decltype_type): Likewise.
kono
parents:
diff changeset
3097 * call.c (resolve_args, build_new_op_1,
kono
parents:
diff changeset
3098 perform_implicit_conversion_flags): Adjust calls.
kono
parents:
diff changeset
3099 * cvt.c (ocp_convert, convert_to_void): Likewise.
kono
parents:
diff changeset
3100 * cp-tree.h (invalid_nonstatic_memfn_p): Update declaration.
kono
parents:
diff changeset
3101
kono
parents:
diff changeset
3102 2015-06-03 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3103
kono
parents:
diff changeset
3104 * decl.c (check_tag_decl): Use declspecs->locations as locations in
kono
parents:
diff changeset
3105 error_at and warning_at calls.
kono
parents:
diff changeset
3106
kono
parents:
diff changeset
3107 2015-06-03 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3108
kono
parents:
diff changeset
3109 PR sanitizer/66190
kono
parents:
diff changeset
3110 * cp-gimplify.c (struct cp_genericize_data): Add no_sanitize_p.
kono
parents:
diff changeset
3111 (cp_genericize_r): Don't instrument static initializers.
kono
parents:
diff changeset
3112 (cp_genericize_tree): Initialize wtd.no_sanitize_p.
kono
parents:
diff changeset
3113
kono
parents:
diff changeset
3114 2015-06-02 Andres Tiraboschi <andres.tiraboschi@tallertechnologies.com>
kono
parents:
diff changeset
3115
kono
parents:
diff changeset
3116 * decl.c (start_function): Call plugin before parsing.
kono
parents:
diff changeset
3117 (finish_function): Call plugin after parsing.
kono
parents:
diff changeset
3118
kono
parents:
diff changeset
3119 2015-06-02 Patrick Palka <patrick@parcs.ath.cx>
kono
parents:
diff changeset
3120
kono
parents:
diff changeset
3121 * cp-tree.h (init_error): Remove declaration.
kono
parents:
diff changeset
3122 * error.c (scratch_pretty_printer): Rename to ...
kono
parents:
diff changeset
3123 (actual_pretty_printer): ... this.
kono
parents:
diff changeset
3124 (cxx_pp): Constify and update accordingly.
kono
parents:
diff changeset
3125 (init_error): Remove definition.
kono
parents:
diff changeset
3126 * lex.c (cxx_init): Do not call init_error.
kono
parents:
diff changeset
3127
kono
parents:
diff changeset
3128 2015-06-02 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3129
kono
parents:
diff changeset
3130 PR c++/61683
kono
parents:
diff changeset
3131 * parser.c (cp_parser_mem_initializer): Allow for decltype-specifier.
kono
parents:
diff changeset
3132
kono
parents:
diff changeset
3133 2015-06-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3134
kono
parents:
diff changeset
3135 PR c++/65942
kono
parents:
diff changeset
3136 * decl2.c (mark_used): Don't always instantiate constexpr fns.
kono
parents:
diff changeset
3137 * constexpr.c (cxx_eval_call_expression): Instantiate them here.
kono
parents:
diff changeset
3138
kono
parents:
diff changeset
3139 PR c++/44282
kono
parents:
diff changeset
3140 * mangle.c (attr_strcmp): New.
kono
parents:
diff changeset
3141 (write_CV_qualifiers_for_type): Also write out attributes that
kono
parents:
diff changeset
3142 affect type identity.
kono
parents:
diff changeset
3143 (write_type): Strip all attributes after writing qualifiers.
kono
parents:
diff changeset
3144
kono
parents:
diff changeset
3145 2015-05-31 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3146
kono
parents:
diff changeset
3147 * constexpr.c (cxx_eval_indirect_ref): Try folding first.
kono
parents:
diff changeset
3148
kono
parents:
diff changeset
3149 PR c++/66320
kono
parents:
diff changeset
3150 * constexpr.c (cxx_eval_constant_expression): Treat a placeholder
kono
parents:
diff changeset
3151 with the wrong type as non-constant.
kono
parents:
diff changeset
3152
kono
parents:
diff changeset
3153 2015-05-27 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3154
kono
parents:
diff changeset
3155 * decl.c (check_redeclaration_exception_specification): Depend on
kono
parents:
diff changeset
3156 -Wsystem-headers rather than -pedantic.
kono
parents:
diff changeset
3157
kono
parents:
diff changeset
3158 * decl.c (warn_extern_redeclared_static): Use the location of
kono
parents:
diff changeset
3159 newdecl in diagnostics, not input_location.
kono
parents:
diff changeset
3160 (validate_constexpr_redeclaration): Likewise.
kono
parents:
diff changeset
3161 (check_redeclaration_no_default_args): Likewise.
kono
parents:
diff changeset
3162 (duplicate_decls): Likewise.
kono
parents:
diff changeset
3163 (check_redeclaration_exception_specification): Likewise.
kono
parents:
diff changeset
3164 Change second diagnostic to inform.
kono
parents:
diff changeset
3165
kono
parents:
diff changeset
3166 2015-05-24 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
3167
kono
parents:
diff changeset
3168 PR c++/66243
kono
parents:
diff changeset
3169 * decl.c (build_enumerator): Don't silently convert scoped enums.
kono
parents:
diff changeset
3170
kono
parents:
diff changeset
3171 2015-05-24 Jan Hubicka <hubicka@ucw.cz>
kono
parents:
diff changeset
3172
kono
parents:
diff changeset
3173 PR lto/66180
kono
parents:
diff changeset
3174 * mangle.c (mangle_decl): Mangle anonymous namespace types as
kono
parents:
diff changeset
3175 "<anon>".
kono
parents:
diff changeset
3176
kono
parents:
diff changeset
3177 2015-05-23 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
3178
kono
parents:
diff changeset
3179 PR c++/65936
kono
parents:
diff changeset
3180 * pt.c (lookup_template_class_1): Copy may_alias attribute too.
kono
parents:
diff changeset
3181
kono
parents:
diff changeset
3182 2015-05-22 Jim Wilson <jim.wilson@linaro.org>
kono
parents:
diff changeset
3183
kono
parents:
diff changeset
3184 * Make-lang.in (check_g++_parallelize): Update comment.
kono
parents:
diff changeset
3185
kono
parents:
diff changeset
3186 2015-05-22 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3187
kono
parents:
diff changeset
3188 PR c++/65598
kono
parents:
diff changeset
3189 * decl.c (grokdeclarator): Use the correct location in error
kono
parents:
diff changeset
3190 messages about 'explicit'.
kono
parents:
diff changeset
3191
kono
parents:
diff changeset
3192 2015-05-22 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3193 Edward Smith-Rowland <3dw4rd@verizon.net>
kono
parents:
diff changeset
3194
kono
parents:
diff changeset
3195 PR c/47043
kono
parents:
diff changeset
3196 * cp-tree.h (build_enumerator): Update declaration.
kono
parents:
diff changeset
3197 * decl.c (build_enumerator): Add attributes parameter. Call
kono
parents:
diff changeset
3198 cplus_decl_attributes.
kono
parents:
diff changeset
3199 * init.c (constant_value_1): Pass tf_none to mark_used.
kono
parents:
diff changeset
3200 * parser.c (cp_parser_enumerator_definition): Parse attributes and
kono
parents:
diff changeset
3201 pass them down to build_enumerator.
kono
parents:
diff changeset
3202 * pt.c (tsubst_enum): Pass decl attributes to build_enumerator.
kono
parents:
diff changeset
3203 * semantics.c (finish_id_expression): Don't warn_deprecated_use here.
kono
parents:
diff changeset
3204
kono
parents:
diff changeset
3205 2015-05-21 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
3206
kono
parents:
diff changeset
3207 PR c++/60943
kono
parents:
diff changeset
3208 * decl2.c (change_return_type): Propagate FUNCTION_REF_QUALIFIED.
kono
parents:
diff changeset
3209
kono
parents:
diff changeset
3210 2015-05-21 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3211
kono
parents:
diff changeset
3212 * typeck.c (warn_args_num): Don't print "declare here" for builtins.
kono
parents:
diff changeset
3213
kono
parents:
diff changeset
3214 2015-05-20 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3215
kono
parents:
diff changeset
3216 * pt.c (tsubst_decl) [VAR_DECL]: SET_DECL_IMPLICIT_INSTANTIATION
kono
parents:
diff changeset
3217 before register_specialization.
kono
parents:
diff changeset
3218
kono
parents:
diff changeset
3219 * decl.c (grok_op_properties): Don't complain about size_t
kono
parents:
diff changeset
3220 placement delete here.
kono
parents:
diff changeset
3221 * call.c (second_parm_is_size_t): Split out from...
kono
parents:
diff changeset
3222 (non_placement_deallocation_fn_p): ...here.
kono
parents:
diff changeset
3223 (build_op_delete_call): Warn about size_t placement delete with
kono
parents:
diff changeset
3224 -Wc++14-compat.
kono
parents:
diff changeset
3225
kono
parents:
diff changeset
3226 2015-05-19 Nathan Sidwell <nathan@acm.org>
kono
parents:
diff changeset
3227
kono
parents:
diff changeset
3228 PR c++/65954
kono
parents:
diff changeset
3229 * typeck.c (finish_class_member_access_expr): Diagnose failed
kono
parents:
diff changeset
3230 lookup of enum class member.
kono
parents:
diff changeset
3231
kono
parents:
diff changeset
3232 2015-05-19 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3233
kono
parents:
diff changeset
3234 PR middle-end/66199
kono
parents:
diff changeset
3235 * parser.c (cp_parser_omp_for_loop): Don't add
kono
parents:
diff changeset
3236 OMP_CLAUSE_SHARED to OMP_PARALLEL_CLAUSES when moving
kono
parents:
diff changeset
3237 OMP_CLAUSE_LASTPRIVATE clause to OMP_FOR_CLAUSES.
kono
parents:
diff changeset
3238 (cp_parser_omp_teams): Set OMP_TEAMS_COMBINED for combined
kono
parents:
diff changeset
3239 constructs.
kono
parents:
diff changeset
3240
kono
parents:
diff changeset
3241 2015-05-19 Mikhail Maltsev <maltsevm@gmail.com>
kono
parents:
diff changeset
3242
kono
parents:
diff changeset
3243 * typeck.c (composite_pointer_type): Use std::swap instead of explicit
kono
parents:
diff changeset
3244 swaps.
kono
parents:
diff changeset
3245
kono
parents:
diff changeset
3246 2015-05-18 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3247
kono
parents:
diff changeset
3248 * pt.c (retrieve_specialization): Make sure our arguments have
kono
parents:
diff changeset
3249 gone through strip_typedefs.
kono
parents:
diff changeset
3250
kono
parents:
diff changeset
3251 * pt.c (tsubst_decl) [VAR_DECL]: Call coerce_innermost_template_parms.
kono
parents:
diff changeset
3252 (determine_specialization): Call coerce_template_parms.
kono
parents:
diff changeset
3253
kono
parents:
diff changeset
3254 DR 1391
kono
parents:
diff changeset
3255 * pt.c (type_unification_real): Check convertibility here.
kono
parents:
diff changeset
3256 (unify_one_argument): Not here.
kono
parents:
diff changeset
3257
kono
parents:
diff changeset
3258 * tree.c (strip_typedefs_expr) [TRAIT_EXPR]: Fix typo.
kono
parents:
diff changeset
3259 (strip_typedefs) [DECLTYPE_TYPE]: Fix typedef of decltype.
kono
parents:
diff changeset
3260 [TREE_LIST]: Fix no-change case.
kono
parents:
diff changeset
3261
kono
parents:
diff changeset
3262 * ptree.c (cxx_print_xnode): Handle TRAIT_EXPR.
kono
parents:
diff changeset
3263
kono
parents:
diff changeset
3264 2015-05-16 Manuel López-Ibáñez <manu@gcc.gnu.org>
kono
parents:
diff changeset
3265
kono
parents:
diff changeset
3266 PR fortran/44054
kono
parents:
diff changeset
3267 * error.c (cp_diagnostic_starter): Use diagnostic_location
kono
parents:
diff changeset
3268 function.
kono
parents:
diff changeset
3269 (cp_print_error_function): Likewise.
kono
parents:
diff changeset
3270 (cp_printer): Replace locus pointer with accessor function.
kono
parents:
diff changeset
3271
kono
parents:
diff changeset
3272 2015-05-12 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
3273
kono
parents:
diff changeset
3274 * parser.c (cp_parser_selection_statement): Add location and
kono
parents:
diff changeset
3275 guard_kind arguments to calls to
kono
parents:
diff changeset
3276 cp_parser_implicitly_scoped_statement.
kono
parents:
diff changeset
3277 (cp_parser_iteration_statement): Likewise for calls to
kono
parents:
diff changeset
3278 cp_parser_already_scoped_statement.
kono
parents:
diff changeset
3279 (cp_parser_implicitly_scoped_statement): Add "guard_loc" and
kono
parents:
diff changeset
3280 "guard_kind" params; use them to warn for misleading
kono
parents:
diff changeset
3281 indentation.
kono
parents:
diff changeset
3282 (cp_parser_already_scoped_statement): Likewise.
kono
parents:
diff changeset
3283
kono
parents:
diff changeset
3284 2015-05-11 Jan Hubicka <hubicka@ucw.cz>
kono
parents:
diff changeset
3285
kono
parents:
diff changeset
3286 * class.c (fixup_type_variants): Do not copy TYPE_METHODS
kono
parents:
diff changeset
3287 (one_inheriting_sig): Assert tat we always set TYPE_METHODS of main variant.
kono
parents:
diff changeset
3288 * semantics.c (finish_member_declaration): Likewise.
kono
parents:
diff changeset
3289 * method.c (lazily_declare_fn): Allways add method to main variant list.
kono
parents:
diff changeset
3290
kono
parents:
diff changeset
3291 2015-05-09 Aldy Hernandez <aldyh@redhat.com>
kono
parents:
diff changeset
3292
kono
parents:
diff changeset
3293 PR bootstrap/66085
kono
parents:
diff changeset
3294 * decl2.c (note_mangling_alias): Declare arguments as unused.
kono
parents:
diff changeset
3295
kono
parents:
diff changeset
3296 2015-05-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3297
kono
parents:
diff changeset
3298 * cp-gimplify.c, parser.c: Adjust to -Wc++11-compat replacing
kono
parents:
diff changeset
3299 -Wc++0x-compat.
kono
parents:
diff changeset
3300
kono
parents:
diff changeset
3301 2015-05-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3302
kono
parents:
diff changeset
3303 * decl2.c (mangling_aliases): New variable.
kono
parents:
diff changeset
3304 (note_mangling_alias, generate_mangling_aliases): New.
kono
parents:
diff changeset
3305 (cp_write_global_declarations): Call generate_mangling_aliases.
kono
parents:
diff changeset
3306 (generate_mangling_alias): Split out from...
kono
parents:
diff changeset
3307 * mangle.c (mangle_decl): ...here.
kono
parents:
diff changeset
3308 * cp-tree.h: Declare note_mangling_alias.
kono
parents:
diff changeset
3309
kono
parents:
diff changeset
3310 2015-05-08 Aldy Hernandez <aldyh@redhat.com>
kono
parents:
diff changeset
3311
kono
parents:
diff changeset
3312 * decl2.c (collect_candidates_for_java_method_aliases): Remove.
kono
parents:
diff changeset
3313 (build_java_method_aliases): Adapt to use create_same_body_alias
kono
parents:
diff changeset
3314 instead of assemble_alias. Move variable declarations to
kono
parents:
diff changeset
3315 definition and tidy up.
kono
parents:
diff changeset
3316 (cp_write_global_declarations): Call build_java_method_aliases
kono
parents:
diff changeset
3317 instead of collecting candidates first.
kono
parents:
diff changeset
3318
kono
parents:
diff changeset
3319 2015-05-07 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3320
kono
parents:
diff changeset
3321 PR c++/59012
kono
parents:
diff changeset
3322 * parser.c (cp_parser_std_attribute_list): Handle attribute expansion.
kono
parents:
diff changeset
3323 (cp_parser_std_attribute_spec): Handle alignas pack expansion.
kono
parents:
diff changeset
3324 * decl2.c (is_late_template_attribute): An attribute exp is dependent.
kono
parents:
diff changeset
3325 * pt.c (make_pack_expansion): Allow TREE_LIST for attribute expansion.
kono
parents:
diff changeset
3326 (apply_late_template_attributes): Handle attribute pack expansion.
kono
parents:
diff changeset
3327
kono
parents:
diff changeset
3328 2015-05-07 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3329
kono
parents:
diff changeset
3330 PR c/65179
kono
parents:
diff changeset
3331 * typeck.c (cp_build_binary_op): Warn when left shifting a negative
kono
parents:
diff changeset
3332 value.
kono
parents:
diff changeset
3333
kono
parents:
diff changeset
3334 2015-05-07 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3335
kono
parents:
diff changeset
3336 DR 1467
kono
parents:
diff changeset
3337 PR c++/51747
kono
parents:
diff changeset
3338 * typeck2.c (digest_init_r): Fix single element list.
kono
parents:
diff changeset
3339
kono
parents:
diff changeset
3340 2015-05-05 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3341
kono
parents:
diff changeset
3342 * cp-gimplify.c (cp_genericize_r): Track TRY_BLOCK and
kono
parents:
diff changeset
3343 MUST_NOT_THROW_EXPR, warn about a THROW_EXPR directly within a
kono
parents:
diff changeset
3344 MUST_NOT_THROW_EXPR.
kono
parents:
diff changeset
3345 (cp_genericize_data): Add try_block field.
kono
parents:
diff changeset
3346 (cp_genericize_tree): Initialize it.
kono
parents:
diff changeset
3347 * except.c (expand_end_catch_block): Set TREE_NO_WARNING on
kono
parents:
diff changeset
3348 implicit rethrow.
kono
parents:
diff changeset
3349
kono
parents:
diff changeset
3350 * constexpr.c (potential_constant_expression_1) [AT_ENCODE_EXPR]:
kono
parents:
diff changeset
3351 Return false.
kono
parents:
diff changeset
3352
kono
parents:
diff changeset
3353 * semantics.c (finish_call_expr): Check complain.
kono
parents:
diff changeset
3354
kono
parents:
diff changeset
3355 * decl2.c (reset_type_linkage_2): Update the DECL_NAME of a
kono
parents:
diff changeset
3356 maybe-in-charge constructor.
kono
parents:
diff changeset
3357
kono
parents:
diff changeset
3358 * decl.c (start_decl): Don't push the plain VAR_DECL for a
kono
parents:
diff changeset
3359 variable template.
kono
parents:
diff changeset
3360
kono
parents:
diff changeset
3361 DR 1518
kono
parents:
diff changeset
3362 DR 1630
kono
parents:
diff changeset
3363 PR c++/54835
kono
parents:
diff changeset
3364 PR c++/60417
kono
parents:
diff changeset
3365 * call.c (convert_like_real): Check value-initialization before
kono
parents:
diff changeset
3366 explicit.
kono
parents:
diff changeset
3367 * typeck2.c (process_init_constructor_record): Don't set
kono
parents:
diff changeset
3368 CONSTRUCTOR_IS_DIRECT_INIT.
kono
parents:
diff changeset
3369 (process_init_constructor_array): Likewise.
kono
parents:
diff changeset
3370 * init.c (build_vec_init): Likewise.
kono
parents:
diff changeset
3371
kono
parents:
diff changeset
3372 2015-05-05 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
3373
kono
parents:
diff changeset
3374 * parser.c (cp_parser_asm_definition): Only test for
kono
parents:
diff changeset
3375 error_mark_node if "outputs" was just set. Likewise for "inputs".
kono
parents:
diff changeset
3376
kono
parents:
diff changeset
3377 2015-05-04 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3378 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3379
kono
parents:
diff changeset
3380 PR c++/66007
kono
parents:
diff changeset
3381 * typeck2.c (check_narrowing): Check by-hand that the pedwarn didn't
kono
parents:
diff changeset
3382 result in an actual error.
kono
parents:
diff changeset
3383
kono
parents:
diff changeset
3384 2015-05-01 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3385 Prathamesh Kulharni <prathamesh.kulkarni@linaro.org>
kono
parents:
diff changeset
3386
kono
parents:
diff changeset
3387 PR c++/65858
kono
parents:
diff changeset
3388 * typeck2.c (check_narrowing): Set ok = true when pedwarn returns
kono
parents:
diff changeset
3389 false.
kono
parents:
diff changeset
3390
kono
parents:
diff changeset
3391 2015-04-30 David Malcolm <dmalcolm@redhat.com>
kono
parents:
diff changeset
3392
kono
parents:
diff changeset
3393 * cp-tree.h (ARGUMENT_PACK_SELECT_ARG): Remove spurious
kono
parents:
diff changeset
3394 trailing semicolon.
kono
parents:
diff changeset
3395
kono
parents:
diff changeset
3396 2015-04-29 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3397
kono
parents:
diff changeset
3398 PR c++/50800
kono
parents:
diff changeset
3399 * tree.c (apply_identity_attributes): Fix handling of classes.
kono
parents:
diff changeset
3400
kono
parents:
diff changeset
3401 2015-04-29 Thomas Schwinge <thomas@codesourcery.com>
kono
parents:
diff changeset
3402
kono
parents:
diff changeset
3403 * parser.c (cp_parser_oacc_enter_exit_data): Use
kono
parents:
diff changeset
3404 OMP_STANDALONE_CLAUSES.
kono
parents:
diff changeset
3405
kono
parents:
diff changeset
3406 2015-04-29 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3407
kono
parents:
diff changeset
3408 PR c++/64667
kono
parents:
diff changeset
3409 * init.c (perform_member_init): Handle references for -Winit-self.
kono
parents:
diff changeset
3410
kono
parents:
diff changeset
3411 2015-04-29 Thomas Schwinge <thomas@codesourcery.com>
kono
parents:
diff changeset
3412
kono
parents:
diff changeset
3413 * pt.c (tsubst_expr) <OMP_TARGET_UPDATE>: Use
kono
parents:
diff changeset
3414 OMP_TARGET_UPDATE_CLAUSES instead of OMP_CLAUSES.
kono
parents:
diff changeset
3415
kono
parents:
diff changeset
3416 2015-04-28 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3417
kono
parents:
diff changeset
3418 PR c++/65896
kono
parents:
diff changeset
3419 * constexpr.c (cxx_eval_store_expression): Don't try to actually
kono
parents:
diff changeset
3420 store an empty class.
kono
parents:
diff changeset
3421
kono
parents:
diff changeset
3422 PR c++/65656
kono
parents:
diff changeset
3423 * constexpr.c (cxx_eval_builtin_function_call): Fix
kono
parents:
diff changeset
3424 __builtin_constant_p.
kono
parents:
diff changeset
3425
kono
parents:
diff changeset
3426 PR c++/50800
kono
parents:
diff changeset
3427 * tree.c (strip_typedefs): Add remove_attributes parm.
kono
parents:
diff changeset
3428 (strip_typedefs_expr): Likewise.
kono
parents:
diff changeset
3429 (apply_identity_attributes): New subroutine of strip_typedefs.
kono
parents:
diff changeset
3430 * pt.c (canonicalize_type_argument): Let strip_typedefs handle attrs.
kono
parents:
diff changeset
3431 (convert_nontype_argument, unify): Likewise.
kono
parents:
diff changeset
3432 * cp-tree.h: Adjust.
kono
parents:
diff changeset
3433
kono
parents:
diff changeset
3434 PR c++/65734
kono
parents:
diff changeset
3435 * class.c (fixup_attribute_variants): Respect TYPE_USER_ALIGN.
kono
parents:
diff changeset
3436
kono
parents:
diff changeset
3437 2015-04-27 Trevor Saunders <tbsaunde+gcc@tbsaunde.org>
kono
parents:
diff changeset
3438
kono
parents:
diff changeset
3439 * class.c (layout_class_type): Remove check if
kono
parents:
diff changeset
3440 PCC_BITFIELD_TYPE_MATTERS is defined.
kono
parents:
diff changeset
3441
kono
parents:
diff changeset
3442 2015-04-27 Jim Wilson <jim.wilson@linaro.org>
kono
parents:
diff changeset
3443
kono
parents:
diff changeset
3444 * Make-lang.in (c++.mostlyclean): Remove xg++, g++-cross, and cc1plus.
kono
parents:
diff changeset
3445
kono
parents:
diff changeset
3446 2015-04-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3447
kono
parents:
diff changeset
3448 PR c++/50800
kono
parents:
diff changeset
3449 * typeck.c (structural_comptypes): Don't check TYPE_REF_CAN_ALIAS_ALL.
kono
parents:
diff changeset
3450
kono
parents:
diff changeset
3451 * constexpr.c (potential_constant_expression_1) [MINUS_EXPR]:
kono
parents:
diff changeset
3452 Remove obsolete code.
kono
parents:
diff changeset
3453 [NE_EXPR]: Likewise.
kono
parents:
diff changeset
3454
kono
parents:
diff changeset
3455 2015-04-23 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3456
kono
parents:
diff changeset
3457 PR c++/65646
kono
parents:
diff changeset
3458 * pt.c (check_explicit_specialization): Don't
kono
parents:
diff changeset
3459 SET_DECL_TEMPLATE_SPECIALIZATION for a variable with no template
kono
parents:
diff changeset
3460 headers.
kono
parents:
diff changeset
3461 * decl.c (grokvardecl): Revert earlier fix.
kono
parents:
diff changeset
3462
kono
parents:
diff changeset
3463 2015-04-20 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3464
kono
parents:
diff changeset
3465 PR c++/65801
kono
parents:
diff changeset
3466 * typeck2.c (check_narrowing): In C++11 mode too, -Wno-narrowing
kono
parents:
diff changeset
3467 suppresses the diagnostic.
kono
parents:
diff changeset
3468
kono
parents:
diff changeset
3469 2015-04-20 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
3470
kono
parents:
diff changeset
3471 Reject trailing return type for an operator auto().
kono
parents:
diff changeset
3472 * decl.c (grokdeclarator): Reject trailing return types for
kono
parents:
diff changeset
3473 all conversion operators, don't handle conversion operators
kono
parents:
diff changeset
3474 in the previous checks that deal with auto.
kono
parents:
diff changeset
3475
kono
parents:
diff changeset
3476 2015-04-20 Ilya Verbin <ilya.verbin@intel.com>
kono
parents:
diff changeset
3477
kono
parents:
diff changeset
3478 * parser.c (cp_parser_omp_target_update): Add missed %> to error_at ().
kono
parents:
diff changeset
3479
kono
parents:
diff changeset
3480 2015-04-16 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3481
kono
parents:
diff changeset
3482 * class.c (resolve_address_of_overloaded_function, instantiate_type):
kono
parents:
diff changeset
3483 Rename tsubst_flags_t parameter flags -> complain.
kono
parents:
diff changeset
3484
kono
parents:
diff changeset
3485 2015-04-16 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3486
kono
parents:
diff changeset
3487 * call.c (build_op_delete_call, build_over_call): Check mark_used
kono
parents:
diff changeset
3488 return value.
kono
parents:
diff changeset
3489 * class.c (resolve_address_of_overloaded_function): Likewise.
kono
parents:
diff changeset
3490 * decl.c (cxx_maybe_build_cleanup): Likewise.
kono
parents:
diff changeset
3491 * pt.c (gen_elem_of_pack_expansion_instantiation, tsubst_baselink,
kono
parents:
diff changeset
3492 tsubst_qualified_id, tsubst_copy, tsubst_copy_and_build): Likewise.
kono
parents:
diff changeset
3493 * rtti.c (build_dynamic_cast_1): Likewise.
kono
parents:
diff changeset
3494 * semantics.c (process_outer_var_ref): Likewise.
kono
parents:
diff changeset
3495 * typeck.c (build_class_member_access_expr,
kono
parents:
diff changeset
3496 cp_build_function_call_vec, cp_build_addr_expr_1): Likewise.
kono
parents:
diff changeset
3497
kono
parents:
diff changeset
3498 2015-04-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3499
kono
parents:
diff changeset
3500 * constexpr.c (cxx_eval_store_expression): Ignore clobbers.
kono
parents:
diff changeset
3501 (build_constexpr_constructor_member_initializers): Loop to find
kono
parents:
diff changeset
3502 the BIND_EXPR.
kono
parents:
diff changeset
3503 * decl.c (start_preparsed_function): Clobber the object at the
kono
parents:
diff changeset
3504 beginning of a constructor.
kono
parents:
diff changeset
3505
kono
parents:
diff changeset
3506 * decl.c (grokmethod): Only set DECL_COMDAT if TREE_PUBLIC is set.
kono
parents:
diff changeset
3507 * method.c (implicitly_declare_fn): Likewise.
kono
parents:
diff changeset
3508 * decl2.c (vague_linkage_p): Check TREE_PUBLIC first.
kono
parents:
diff changeset
3509
kono
parents:
diff changeset
3510 * decl2.c (determine_visibility): Use get_template_info.
kono
parents:
diff changeset
3511
kono
parents:
diff changeset
3512 2015-04-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3513 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3514
kono
parents:
diff changeset
3515 PR c++/65727
kono
parents:
diff changeset
3516 * lambda.c (lambda_expr_this_capture): In unevaluated context go
kono
parents:
diff changeset
3517 through the normal loop, just don't capture.
kono
parents:
diff changeset
3518 (maybe_resolve_dummy): Handle null return.
kono
parents:
diff changeset
3519
kono
parents:
diff changeset
3520 2015-04-15 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3521
kono
parents:
diff changeset
3522 * call.c (enforce_access): Emit error + inform.
kono
parents:
diff changeset
3523
kono
parents:
diff changeset
3524 2015-04-15 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3525
kono
parents:
diff changeset
3526 * constexpr.c (use_new_call): Remove #define.
kono
parents:
diff changeset
3527 (lookup_parameter_binding): Remove function.
kono
parents:
diff changeset
3528 (cxx_bind_parameters_in_call): Remove unused code.
kono
parents:
diff changeset
3529 (cxx_eval_call_expression): Likewise.
kono
parents:
diff changeset
3530 (cxx_eval_constant_expression): Likewise.
kono
parents:
diff changeset
3531
kono
parents:
diff changeset
3532 2015-04-14 Mikhail Maltsev <maltsevm@gmail.com>
kono
parents:
diff changeset
3533
kono
parents:
diff changeset
3534 * tree.c (replace_placeholders_t): Remove unused type.
kono
parents:
diff changeset
3535 (replace_placeholders): Remove unused pset.
kono
parents:
diff changeset
3536
kono
parents:
diff changeset
3537 2015-04-14 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3538
kono
parents:
diff changeset
3539 * pt.c (lookup_template_class_1): Use coerce_innermost_template_parms.
kono
parents:
diff changeset
3540
kono
parents:
diff changeset
3541 PR c++/65695
kono
parents:
diff changeset
3542 * cvt.c (cp_fold_convert): Avoid wrapping PTRMEM_CST in NOP_EXPR.
kono
parents:
diff changeset
3543
kono
parents:
diff changeset
3544 PR c++/65721
kono
parents:
diff changeset
3545 * name-lookup.c (do_class_using_decl): Complain about specifying
kono
parents:
diff changeset
3546 the current class even if there are dependent bases.
kono
parents:
diff changeset
3547
kono
parents:
diff changeset
3548 2015-04-14 David Krauss <david_work@me.com>
kono
parents:
diff changeset
3549
kono
parents:
diff changeset
3550 PR c++/59766
kono
parents:
diff changeset
3551 * decl.c (grokdeclarator): Do not flag friends with deduced return.
kono
parents:
diff changeset
3552
kono
parents:
diff changeset
3553 2015-04-14 Momchil Velikov <momchil.velikov@gmail.com>
kono
parents:
diff changeset
3554 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3555
kono
parents:
diff changeset
3556 PR c++/60994
kono
parents:
diff changeset
3557 * parser.c (cp_parser_class_name): Add enum_ok parameter.
kono
parents:
diff changeset
3558 (cp_parser_qualifying_entity): Use it instead of cp_parser_type_name.
kono
parents:
diff changeset
3559 (cp_parser_diagnose_invalid_type_name): Don't assume a template is
kono
parents:
diff changeset
3560 a class template.
kono
parents:
diff changeset
3561
kono
parents:
diff changeset
3562 2015-04-12 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3563
kono
parents:
diff changeset
3564 PR c++/65736
kono
parents:
diff changeset
3565 * constexpr.c (cxx_eval_pointer_plus_expression): Don't fold for VLAs,
kono
parents:
diff changeset
3566 don't fold if op01 isn't divisible by TYPE_SIZE_UNIT. Convert
kono
parents:
diff changeset
3567 the expression to the original type at the end.
kono
parents:
diff changeset
3568
kono
parents:
diff changeset
3569 2015-04-09 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3570
kono
parents:
diff changeset
3571 PR c++/65690
kono
parents:
diff changeset
3572 * tree.c (cp_build_qualified_type_real): Copy TYPE_ALIGN and
kono
parents:
diff changeset
3573 TYPE_USER_ALIGN.
kono
parents:
diff changeset
3574
kono
parents:
diff changeset
3575 PR c++/65690
kono
parents:
diff changeset
3576 * tree.c (build_cplus_array_type): Layout type before variants are
kono
parents:
diff changeset
3577 set, but copy over TYPE_SIZE and TYPE_SIZE_UNIT from the main
kono
parents:
diff changeset
3578 variant.
kono
parents:
diff changeset
3579
kono
parents:
diff changeset
3580 2015-04-03 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3581
kono
parents:
diff changeset
3582 PR c++/64085
kono
parents:
diff changeset
3583 * lambda.c (add_capture): Use dependent_type_p for capture by
kono
parents:
diff changeset
3584 reference too.
kono
parents:
diff changeset
3585
kono
parents:
diff changeset
3586 2015-04-02 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3587
kono
parents:
diff changeset
3588 PR c++/65642
kono
parents:
diff changeset
3589 * constexpr.c (cxx_eval_pointer_plus_expression): Call
kono
parents:
diff changeset
3590 cxx_eval_constant_expression on the first operand.
kono
parents:
diff changeset
3591
kono
parents:
diff changeset
3592 2015-04-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3593
kono
parents:
diff changeset
3594 PR c++/65625
kono
parents:
diff changeset
3595 * decl.c (make_typename_type): Handle seeing a variable template.
kono
parents:
diff changeset
3596
kono
parents:
diff changeset
3597 2015-04-01 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3598
kono
parents:
diff changeset
3599 PR c++/56100
kono
parents:
diff changeset
3600 * pt.c (instantiating_current_function_p): New.
kono
parents:
diff changeset
3601 * name-lookup.c (pushdecl_maybe_friend_1): Use it.
kono
parents:
diff changeset
3602 * cp-tree.h (instantiating_current_function_p): Declare.
kono
parents:
diff changeset
3603
kono
parents:
diff changeset
3604 2015-04-01 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3605
kono
parents:
diff changeset
3606 PR c++/65646
kono
parents:
diff changeset
3607 * decl.c (grokvardecl): Don't call check_explicit_specialization
kono
parents:
diff changeset
3608 for non-template members of a class template.
kono
parents:
diff changeset
3609
kono
parents:
diff changeset
3610 2015-04-01 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3611
kono
parents:
diff changeset
3612 PR c++/65554
kono
parents:
diff changeset
3613 * class.c (finish_struct): Require that the second field of a
kono
parents:
diff changeset
3614 user-defined initializer_list be of size type.
kono
parents:
diff changeset
3615
kono
parents:
diff changeset
3616 2015-03-31 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3617
kono
parents:
diff changeset
3618 PR c++/65390
kono
parents:
diff changeset
3619 * tree.c (build_cplus_array_type): Use dependent_type_p rather than
kono
parents:
diff changeset
3620 checking for constness.
kono
parents:
diff changeset
3621
kono
parents:
diff changeset
3622 2015-03-30 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3623
kono
parents:
diff changeset
3624 PR c++/65398
kono
parents:
diff changeset
3625 * constexpr.c (cxx_fold_indirect_ref): Don't perform the
kono
parents:
diff changeset
3626 *(&A[i] p+ j) => A[i + j] transformation here.
kono
parents:
diff changeset
3627 (cxx_eval_pointer_plus_expression): New function.
kono
parents:
diff changeset
3628 (cxx_eval_constant_expression): Use it here.
kono
parents:
diff changeset
3629
kono
parents:
diff changeset
3630 2015-03-27 Tobias Burnus <burnus@net-b.de>
kono
parents:
diff changeset
3631
kono
parents:
diff changeset
3632 PR c/65586
kono
parents:
diff changeset
3633 * parser.c (cp_parser_omp_for, cp_parser_omp_parallel,
kono
parents:
diff changeset
3634 cp_parser_omp_distribute, cp_parser_omp_teams, cp_parser_omp_target,
kono
parents:
diff changeset
3635 cp_parser_omp_declare): Don't show error for skipped omp pragmas with
kono
parents:
diff changeset
3636 -fopenmp-simd.
kono
parents:
diff changeset
3637
kono
parents:
diff changeset
3638 2015-03-27 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3639
kono
parents:
diff changeset
3640 PR c++/65556
kono
parents:
diff changeset
3641 * semantics.c (finish_switch_cond): If the unlowered type is not an
kono
parents:
diff changeset
3642 enum, use the type of the condition.
kono
parents:
diff changeset
3643
kono
parents:
diff changeset
3644 2015-03-27 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3645
kono
parents:
diff changeset
3646 PR c++/65509
kono
parents:
diff changeset
3647 * decl.c (make_rtl_for_nonlocal_decl): Don't defer static
kono
parents:
diff changeset
3648 constants.
kono
parents:
diff changeset
3649
kono
parents:
diff changeset
3650 2015-03-26 Mikhail Maltsev <maltsevm@gmail.com>
kono
parents:
diff changeset
3651
kono
parents:
diff changeset
3652 PR c++/65154
kono
parents:
diff changeset
3653 * init.c (build_vec_init): Fix initializing aggregates
kono
parents:
diff changeset
3654 with empty init list.
kono
parents:
diff changeset
3655
kono
parents:
diff changeset
3656 2015-03-26 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3657
kono
parents:
diff changeset
3658 PR c++/65525
kono
parents:
diff changeset
3659 * constexpr.c (potential_constant_expression_1): Handle MEM_REF.
kono
parents:
diff changeset
3660
kono
parents:
diff changeset
3661 2015-03-25 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3662
kono
parents:
diff changeset
3663 PR c++/65558
kono
parents:
diff changeset
3664 * name-lookup.c (handle_namespace_attrs): Ignore abi_tag attribute
kono
parents:
diff changeset
3665 on an anonymous namespace.
kono
parents:
diff changeset
3666
kono
parents:
diff changeset
3667 2015-03-25 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3668
kono
parents:
diff changeset
3669 PR c++/61670
kono
parents:
diff changeset
3670 * class.c (remove_zero_width_bit_fields): Check for null DECL_SIZE.
kono
parents:
diff changeset
3671
kono
parents:
diff changeset
3672 2015-03-24 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3673
kono
parents:
diff changeset
3674 PR c++/65046
kono
parents:
diff changeset
3675 * cp-tree.h (NAMESPACE_IS_INLINE): Remove.
kono
parents:
diff changeset
3676 * parser.c (cp_parser_namespace_definition): Don't set it.
kono
parents:
diff changeset
3677 * name-lookup.c (handle_namespace_attrs): Check
kono
parents:
diff changeset
3678 DECL_NAMESPACE_ASSOCIATIONS instead.
kono
parents:
diff changeset
3679
kono
parents:
diff changeset
3680 PR c++/65498
kono
parents:
diff changeset
3681 * pt.c (get_mostly_instantiated_function_type): Just return the
kono
parents:
diff changeset
3682 type of the partially instantiated template in DECL_TI_TEMPLATE.
kono
parents:
diff changeset
3683
kono
parents:
diff changeset
3684 2015-03-20 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3685
kono
parents:
diff changeset
3686 PR c++/65398
kono
parents:
diff changeset
3687 * constexpr.c (cxx_fold_indirect_ref): Transform *(&A[i] p+ j) into
kono
parents:
diff changeset
3688 A[i + j].
kono
parents:
diff changeset
3689
kono
parents:
diff changeset
3690 2015-03-20 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3691
kono
parents:
diff changeset
3692 PR c++/65072
kono
parents:
diff changeset
3693 * typeck.c (lookup_anon_field): Make sure we're dealing with the main
kono
parents:
diff changeset
3694 variant.
kono
parents:
diff changeset
3695
kono
parents:
diff changeset
3696 2015-03-19 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3697
kono
parents:
diff changeset
3698 PR c++/65046
kono
parents:
diff changeset
3699 Automatically propagate ABI tags to variables and functions
kono
parents:
diff changeset
3700 from their (return) type.
kono
parents:
diff changeset
3701 * class.c (check_tag): Handle variables and functions.
kono
parents:
diff changeset
3702 (mark_or_check_attr_tags): Split out from find_abi_tags_r.
kono
parents:
diff changeset
3703 (mark_or_check_tags): Likewise.
kono
parents:
diff changeset
3704 (mark_abi_tags): Use it. Rename from mark_type_abi_tags.
kono
parents:
diff changeset
3705 (check_abi_tags): Add single argument overload for decls.
kono
parents:
diff changeset
3706 Handle inheriting tags for decls.
kono
parents:
diff changeset
3707 * mangle.c (write_mangled_name): Call it.
kono
parents:
diff changeset
3708 (mangle_return_type_p): Split out from write_encoding.
kono
parents:
diff changeset
3709 (unmangled_name_p): Split out from write_mangled_name.
kono
parents:
diff changeset
3710 (write_mangled_name): Ignore abi_tag on namespace.
kono
parents:
diff changeset
3711 * cp-tree.h (NAMESPACE_IS_INLINE): Replace NAMESPACE_ABI_TAG.
kono
parents:
diff changeset
3712 * parser.c (cp_parser_namespace_definition): Set it.
kono
parents:
diff changeset
3713 * name-lookup.c (handle_namespace_attrs): Use arguments. Warn
kono
parents:
diff changeset
3714 about abi_tag attribute on non-inline namespace.
kono
parents:
diff changeset
3715 * tree.c (check_abi_tag_args): Split out from handle_abi_tag_attribute.
kono
parents:
diff changeset
3716 (handle_abi_tag_attribute): Allow tags on variables.
kono
parents:
diff changeset
3717
kono
parents:
diff changeset
3718 2015-03-19 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3719
kono
parents:
diff changeset
3720 * decl2.c (cplus_decl_attributes): Also add "omp declare target"
kono
parents:
diff changeset
3721 attribute for DECL_EXTERNAL VAR_DECLs.
kono
parents:
diff changeset
3722
kono
parents:
diff changeset
3723 2015-03-18 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3724
kono
parents:
diff changeset
3725 PR c++/65340
kono
parents:
diff changeset
3726 * call.c (build_over_call): Pass the tsubst_flags_t argument to
kono
parents:
diff changeset
3727 mark_used.
kono
parents:
diff changeset
3728 * decl2.c (mark_used): Inline the require_deduced_type call and
kono
parents:
diff changeset
3729 guard the error call.
kono
parents:
diff changeset
3730
kono
parents:
diff changeset
3731 2015-03-16 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3732
kono
parents:
diff changeset
3733 PR c++/65061
kono
parents:
diff changeset
3734 * parser.c (cp_parser_template_name): Call strip_using_decl.
kono
parents:
diff changeset
3735
kono
parents:
diff changeset
3736 2015-03-16 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3737
kono
parents:
diff changeset
3738 DR 1688
kono
parents:
diff changeset
3739 PR c++/65327
kono
parents:
diff changeset
3740 * decl.c (grokdeclarator): Allow volatile and constexpr together.
kono
parents:
diff changeset
3741
kono
parents:
diff changeset
3742 2015-03-12 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3743
kono
parents:
diff changeset
3744 PR c++/65323
kono
parents:
diff changeset
3745 * decl.c (check_default_argument): Don't call
kono
parents:
diff changeset
3746 maybe_warn_zero_as_null_pointer_constant.
kono
parents:
diff changeset
3747
kono
parents:
diff changeset
3748 2015-03-11 Aldy Hernandez <aldyh@redhat.com>
kono
parents:
diff changeset
3749
kono
parents:
diff changeset
3750 * cp-gimplify.c (simple_empty_class_p): New.
kono
parents:
diff changeset
3751 * cp-gimplify.c (cp_gimplify_expr): Handle RETURN_EXPR. Abstract
kono
parents:
diff changeset
3752 the code for empty class copies into simple_empty_class_p, and
kono
parents:
diff changeset
3753 adapt it to handle COMPOUND_EXPRs.
kono
parents:
diff changeset
3754
kono
parents:
diff changeset
3755 2015-03-10 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3756
kono
parents:
diff changeset
3757 PR c++/65370
kono
parents:
diff changeset
3758 * decl.c (duplicate_decls): Call check_redeclaration_no_default_args
kono
parents:
diff changeset
3759 only if the location of newdecl doesn't match the location of olddecl.
kono
parents:
diff changeset
3760
kono
parents:
diff changeset
3761 2015-03-10 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3762
kono
parents:
diff changeset
3763 PR c++/65127
kono
parents:
diff changeset
3764 * parser.c (parsing_nsdmi): Don't return true if current_class_ptr
kono
parents:
diff changeset
3765 is not a PARM_DECL.
kono
parents:
diff changeset
3766
kono
parents:
diff changeset
3767 2015-03-10 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3768
kono
parents:
diff changeset
3769 PR c++/65333
kono
parents:
diff changeset
3770 DR 1558
kono
parents:
diff changeset
3771 * pt.c (dependent_type_p_r): Check both class and alias template args.
kono
parents:
diff changeset
3772
kono
parents:
diff changeset
3773 2015-03-10 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3774
kono
parents:
diff changeset
3775 PR c/65120
kono
parents:
diff changeset
3776 * parser.c (cp_parser_binary_expression): Check for tcc_comparison
kono
parents:
diff changeset
3777 before preparing arguments to warn_logical_not_parentheses.
kono
parents:
diff changeset
3778 Use maybe_constant_value on rhs.
kono
parents:
diff changeset
3779
kono
parents:
diff changeset
3780 2015-03-09 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3781
kono
parents:
diff changeset
3782 PR c++/65339
kono
parents:
diff changeset
3783 * call.c: Don't call maybe_resolve_dummy when calling a constructor.
kono
parents:
diff changeset
3784
kono
parents:
diff changeset
3785 2015-03-09 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3786
kono
parents:
diff changeset
3787 PR c/65120
kono
parents:
diff changeset
3788 * parser.c (cp_parser_binary_expression): Don't warn for
kono
parents:
diff changeset
3789 !!x == y or !b == y where b is bool.
kono
parents:
diff changeset
3790
kono
parents:
diff changeset
3791 2015-03-06 Aldy Hernandez <aldyh@redhat.com>
kono
parents:
diff changeset
3792
kono
parents:
diff changeset
3793 * ptree.c (cxx_print_lambda_node): New.
kono
parents:
diff changeset
3794 (cxx_print_xnode): Handle LAMBDA_EXPR.
kono
parents:
diff changeset
3795
kono
parents:
diff changeset
3796 2015-03-03 Aldy Hernandez <aldyh@redhat.com>
kono
parents:
diff changeset
3797
kono
parents:
diff changeset
3798 PR c++/65295
kono
parents:
diff changeset
3799 * constexpr.c (cxx_eval_constant_expression): Remove assert in
kono
parents:
diff changeset
3800 RESULT_DECL handling.
kono
parents:
diff changeset
3801
kono
parents:
diff changeset
3802 2015-02-26 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
3803
kono
parents:
diff changeset
3804 PR c++/65202
kono
parents:
diff changeset
3805 * constexpr.c (cxx_eval_constant_expression): Don't evaluate
kono
parents:
diff changeset
3806 a RETURN_EXPR if its operand is null.
kono
parents:
diff changeset
3807
kono
parents:
diff changeset
3808 2015-02-25 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3809
kono
parents:
diff changeset
3810 PR c++/65209
kono
parents:
diff changeset
3811 * decl2.c (constrain_visibility) [VISIBILITY_ANON]: Clear
kono
parents:
diff changeset
3812 DECL_COMDAT.
kono
parents:
diff changeset
3813 (constrain_visibility_for_template): Handle reference arguments.
kono
parents:
diff changeset
3814
kono
parents:
diff changeset
3815 PR debug/58315
kono
parents:
diff changeset
3816 * decl.c (start_preparsed_function): Use create_artificial_label
kono
parents:
diff changeset
3817 for cdtor_label.
kono
parents:
diff changeset
3818
kono
parents:
diff changeset
3819 2015-02-17 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3820 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3821
kono
parents:
diff changeset
3822 PR c++/65075
kono
parents:
diff changeset
3823 * constexpr.c (check_constexpr_bind_expr_vars): Allow
kono
parents:
diff changeset
3824 implicit typedefs for lambda types.
kono
parents:
diff changeset
3825
kono
parents:
diff changeset
3826 2015-02-13 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3827
kono
parents:
diff changeset
3828 PR c++/60894
kono
parents:
diff changeset
3829 * decl.c (lookup_and_check_tag): Use strip_using_decl.
kono
parents:
diff changeset
3830
kono
parents:
diff changeset
3831 2015-02-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3832
kono
parents:
diff changeset
3833 PR c++/65054
kono
parents:
diff changeset
3834 * pt.c (template_args_equal): Look through conversions here.
kono
parents:
diff changeset
3835 * tree.c (cp_tree_equal): Not here.
kono
parents:
diff changeset
3836
kono
parents:
diff changeset
3837 2015-02-13 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3838
kono
parents:
diff changeset
3839 PR c++/60211
kono
parents:
diff changeset
3840 * parser.c (cp_parser_pragma): Diagnose PRAGMA_IVDEP at
kono
parents:
diff changeset
3841 pragma_external context.
kono
parents:
diff changeset
3842
kono
parents:
diff changeset
3843 2015-02-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3844
kono
parents:
diff changeset
3845 PR c++/65051
kono
parents:
diff changeset
3846 * call.c (reference_binding): Don't look for bad conversion
kono
parents:
diff changeset
3847 if TO is incomplete.
kono
parents:
diff changeset
3848
kono
parents:
diff changeset
3849 2015-02-13 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3850
kono
parents:
diff changeset
3851 PR c++/64970
kono
parents:
diff changeset
3852 * decl.c (make_typename_type): Pass tsubst_flags_t argument
kono
parents:
diff changeset
3853 to lookup_template_class.
kono
parents:
diff changeset
3854
kono
parents:
diff changeset
3855 2015-02-13 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3856
kono
parents:
diff changeset
3857 PR ipa/65034
kono
parents:
diff changeset
3858 * decl.c (start_preparsed_function): Use void_type_node instead
kono
parents:
diff changeset
3859 of NULL_TREE as LABEL_DECL type.
kono
parents:
diff changeset
3860
kono
parents:
diff changeset
3861 2015-02-12 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3862
kono
parents:
diff changeset
3863 PR c++/64898
kono
parents:
diff changeset
3864 * mangle.c (write_mangled_name): Fix test for variable template
kono
parents:
diff changeset
3865 instantiation.
kono
parents:
diff changeset
3866
kono
parents:
diff changeset
3867 * decl.c (begin_destructor_body): Condition clobber on
kono
parents:
diff changeset
3868 -flifetime-dse.
kono
parents:
diff changeset
3869
kono
parents:
diff changeset
3870 2015-02-12 Andrea Azzarone <azzaronea@gmail.com>
kono
parents:
diff changeset
3871
kono
parents:
diff changeset
3872 PR c++/64959
kono
parents:
diff changeset
3873 * parser.c (lookup_literal_operator): Return all candidates.
kono
parents:
diff changeset
3874 (cp_parser_userdef_char_literal): Simplify error handling.
kono
parents:
diff changeset
3875 (cp_parser_userdef_numeric_literal): Pass tf_warning_or_error.
kono
parents:
diff changeset
3876 (cp_parser_userdef_string_literal): Pass tf_warning_or_error.
kono
parents:
diff changeset
3877 Also give higher priority to standard string UDL operator.
kono
parents:
diff changeset
3878
kono
parents:
diff changeset
3879 2015-02-12 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3880
kono
parents:
diff changeset
3881 PR debug/55541
kono
parents:
diff changeset
3882 * cp-tree.h (BLOCK_OUTER_CURLY_BRACE_P): Define.
kono
parents:
diff changeset
3883 * decl.c (poplevel): If functionbody, try not to create an extra
kono
parents:
diff changeset
3884 BLOCK for function body and use subblocks as that, if it is non-NULL
kono
parents:
diff changeset
3885 and doesn't have siblings. Set BLOCK_OUTER_CURLY_BRACE_P flag.
kono
parents:
diff changeset
3886 (outer_curly_brace_block): Use BLOCK_OUTER_CURLY_BRACE_P flag.
kono
parents:
diff changeset
3887
kono
parents:
diff changeset
3888 PR sanitizer/64984
kono
parents:
diff changeset
3889 * except.c (check_noexcept_r): Return NULL for internal
kono
parents:
diff changeset
3890 calls.
kono
parents:
diff changeset
3891
kono
parents:
diff changeset
3892 2015-02-10 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3893
kono
parents:
diff changeset
3894 PR c++/64994
kono
parents:
diff changeset
3895 * constexpr.c (cxx_eval_call_expression): Walk the clone list.
kono
parents:
diff changeset
3896
kono
parents:
diff changeset
3897 2015-02-10 Jan Hubicka <hubicka@ucw.cz>
kono
parents:
diff changeset
3898
kono
parents:
diff changeset
3899 PR ipa/64982
kono
parents:
diff changeset
3900 * method.c (use_thunk): Do not check for stdarg thunks.
kono
parents:
diff changeset
3901
kono
parents:
diff changeset
3902 2015-02-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3903
kono
parents:
diff changeset
3904 PR c++/64899
kono
parents:
diff changeset
3905 * init.c (build_vec_init): Handle default-initialized array with
kono
parents:
diff changeset
3906 constexpr default constructor.
kono
parents:
diff changeset
3907
kono
parents:
diff changeset
3908 2015-02-04 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3909
kono
parents:
diff changeset
3910 PR c/64824
kono
parents:
diff changeset
3911 PR c/64868
kono
parents:
diff changeset
3912 * parser.c (cp_parser_omp_atomic): Handle RDIV_EXPR.
kono
parents:
diff changeset
3913
kono
parents:
diff changeset
3914 2015-02-03 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
3915
kono
parents:
diff changeset
3916 PR c++/64877
kono
parents:
diff changeset
3917 * typeck.c (cp_build_binary_op): Avoid spurious -Waddress warnings
kono
parents:
diff changeset
3918 for generated expressions.
kono
parents:
diff changeset
3919
kono
parents:
diff changeset
3920 2015-02-02 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
3921
kono
parents:
diff changeset
3922 PR c++/64901
kono
parents:
diff changeset
3923 * decl.c (duplicate_decls): Also duplicate DECL_FINAL_P and
kono
parents:
diff changeset
3924 DECL_OVERRIDE_P.
kono
parents:
diff changeset
3925
kono
parents:
diff changeset
3926 2015-02-02 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3927
kono
parents:
diff changeset
3928 * tree.c (handle_abi_tag_attribute): Diagnose invalid arguments.
kono
parents:
diff changeset
3929
kono
parents:
diff changeset
3930 2015-01-30 Joseph Myers <joseph@codesourcery.com>
kono
parents:
diff changeset
3931
kono
parents:
diff changeset
3932 * class.c, except.c, parser.c, pt.c: All callers of fatal_error
kono
parents:
diff changeset
3933 changed to pass input_location as first argument.
kono
parents:
diff changeset
3934
kono
parents:
diff changeset
3935 2015-01-29 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
3936
kono
parents:
diff changeset
3937 PR c++/64717
kono
parents:
diff changeset
3938 * cp-ubsan.c (cp_ubsan_instrument_vptr): Don't wrap vptr
kono
parents:
diff changeset
3939 into SAVE_EXPR.
kono
parents:
diff changeset
3940
kono
parents:
diff changeset
3941 2015-01-29 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3942
kono
parents:
diff changeset
3943 PR c++/49508
kono
parents:
diff changeset
3944 * semantics.c (finish_return_stmt): Suppress -Wreturn-type on
kono
parents:
diff changeset
3945 erroneous return statement.
kono
parents:
diff changeset
3946
kono
parents:
diff changeset
3947 PR c++/64521
kono
parents:
diff changeset
3948 * repo.c (repo_emit_p): It's OK for a clone to be extern at this
kono
parents:
diff changeset
3949 point.
kono
parents:
diff changeset
3950
kono
parents:
diff changeset
3951 2015-01-27 Caroline Tice <cmtice@google.com>
kono
parents:
diff changeset
3952
kono
parents:
diff changeset
3953 Committing VTV Cywin/Ming patch for Patrick Wollgast
kono
parents:
diff changeset
3954 * vtable-class-hierarchy.cc (vtv_generate_init_routine): Add
kono
parents:
diff changeset
3955 check for not TARGET_PECOFF at the VTV_PREINIT_PRIORITY checks.
kono
parents:
diff changeset
3956
kono
parents:
diff changeset
3957 2015-01-27 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3958
kono
parents:
diff changeset
3959 PR c++/58597
kono
parents:
diff changeset
3960 * lambda.c (maybe_add_lambda_conv_op): Check cfun rather than
kono
parents:
diff changeset
3961 current_function_decl.
kono
parents:
diff changeset
3962
kono
parents:
diff changeset
3963 PR c++/63889
kono
parents:
diff changeset
3964 * pt.c (finish_template_variable): Move from semantics.c.
kono
parents:
diff changeset
3965 Handle multiple template arg levels. Handle coercion here.
kono
parents:
diff changeset
3966 (lookup_template_variable): Not here.
kono
parents:
diff changeset
3967
kono
parents:
diff changeset
3968 2015-01-23 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3969
kono
parents:
diff changeset
3970 PR c++/64314
kono
parents:
diff changeset
3971 PR c++/57510
kono
parents:
diff changeset
3972 * typeck2.c (split_nonconstant_init_1): Remove a sub-CONSTRUCTOR
kono
parents:
diff changeset
3973 that has been completely split out.
kono
parents:
diff changeset
3974
kono
parents:
diff changeset
3975 PR c++/64701
kono
parents:
diff changeset
3976 * constexpr.c (cxx_eval_constant_expression): Don't crash on C++
kono
parents:
diff changeset
3977 statement codes.
kono
parents:
diff changeset
3978
kono
parents:
diff changeset
3979 PR c++/64727
kono
parents:
diff changeset
3980 * constexpr.c (cxx_eval_constant_expression): Allow for lvalue use
kono
parents:
diff changeset
3981 of CONST_DECL.
kono
parents:
diff changeset
3982
kono
parents:
diff changeset
3983 2015-01-21 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
3984
kono
parents:
diff changeset
3985 PR c++/64603
kono
parents:
diff changeset
3986 * constexpr.c (cxx_eval_constant_expression): Only shortcut
kono
parents:
diff changeset
3987 constant CONSTRUCTORs.
kono
parents:
diff changeset
3988
kono
parents:
diff changeset
3989 PR c++/64647
kono
parents:
diff changeset
3990 * constexpr.c (ensure_literal_type_for_constexpr_object): Don't
kono
parents:
diff changeset
3991 give a hard error in a template instantiation.
kono
parents:
diff changeset
3992
kono
parents:
diff changeset
3993 2015-01-21 Richard Biener <rguenther@suse.de>
kono
parents:
diff changeset
3994
kono
parents:
diff changeset
3995 PR middle-end/64313
kono
parents:
diff changeset
3996 * decl.c (duplicate_decls): Call set_builtin_decl_declared_p
kono
parents:
diff changeset
3997 for builtins the user declared correctly.
kono
parents:
diff changeset
3998
kono
parents:
diff changeset
3999 2015-01-16 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
4000
kono
parents:
diff changeset
4001 PR c++/58614
kono
parents:
diff changeset
4002 * pt.c (unify): When BRACE_ENCLOSED_INITIALIZER_P (arg), handle
kono
parents:
diff changeset
4003 TREE_TYPE (elt) == error_mark_node.
kono
parents:
diff changeset
4004
kono
parents:
diff changeset
4005 2015-01-15 Jan Hubicka <hubicka@ucw.cz>
kono
parents:
diff changeset
4006
kono
parents:
diff changeset
4007 PR tree-optimization/62053
kono
parents:
diff changeset
4008 * tree.c (build_cplus_array_type): Layout type after variants are set.
kono
parents:
diff changeset
4009
kono
parents:
diff changeset
4010 2015-01-15 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
4011
kono
parents:
diff changeset
4012 * cp-gimplify.c (cp_genericize_r): Call
kono
parents:
diff changeset
4013 cp_ubsan_maybe_instrument_member_call for member calls.
kono
parents:
diff changeset
4014 (cp_ubsan_check_member_access_r): New function.
kono
parents:
diff changeset
4015 (cp_genericize_tree): Call cp_ubsan_instrument_member_accesses.
kono
parents:
diff changeset
4016 * cp-tree.h (cp_ubsan_maybe_instrument_member_call,
kono
parents:
diff changeset
4017 cp_ubsan_instrument_member_accesses,
kono
parents:
diff changeset
4018 cp_ubsan_maybe_instrument_downcast,
kono
parents:
diff changeset
4019 cp_ubsan_maybe_instrument_cast_to_vbase): New prototypes.
kono
parents:
diff changeset
4020 * cp-ubsan.c: New file.
kono
parents:
diff changeset
4021 * Make-lang.in (CXX_AND_OBJCXX_OBJS): Add cp/cp-ubsan.o.
kono
parents:
diff changeset
4022 * constexpr.c (cxx_eval_call_expression): Return void_node
kono
parents:
diff changeset
4023 for IFN_UBSAN_VPTR.
kono
parents:
diff changeset
4024 (potential_constant_expression_1): Return true for
kono
parents:
diff changeset
4025 UBSAN_NULL, UBSAN_BOUNDS and UBSAN_VPTR internal calls.
kono
parents:
diff changeset
4026 * typeck.c (build_class_member_access_expr): Provide locus
kono
parents:
diff changeset
4027 for COMPONENT_REFs.
kono
parents:
diff changeset
4028 (build_static_cast_1): Instrument downcasts.
kono
parents:
diff changeset
4029 * class.c (build_base_path): For -fsanitize=vptr and !fixed_type_p
kono
parents:
diff changeset
4030 add ubsan instrumentation for virtual_access.
kono
parents:
diff changeset
4031 * call.c: Include internal-fn.h.
kono
parents:
diff changeset
4032 (set_flags_from_callee): Handle internal calls.
kono
parents:
diff changeset
4033
kono
parents:
diff changeset
4034 2015-01-15 Momchil Velikov <momchil.velikov@gmail.com>
kono
parents:
diff changeset
4035
kono
parents:
diff changeset
4036 PR c++/59366
kono
parents:
diff changeset
4037 * name-lookup.c (pushdecl_maybe_friend_1): Hide friend functions
kono
parents:
diff changeset
4038 and function templates, declared only in the class.
kono
parents:
diff changeset
4039 * decl.c (duplicate_decls): Reveal hidden friend functions or
kono
parents:
diff changeset
4040 function templates, if they are redeclared outside the class.
kono
parents:
diff changeset
4041
kono
parents:
diff changeset
4042 2015-01-15 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4043
kono
parents:
diff changeset
4044 PR c++/64356
kono
parents:
diff changeset
4045 * constexpr.c (cxx_eval_binary_expression): Fix pasto.
kono
parents:
diff changeset
4046
kono
parents:
diff changeset
4047 PR c++/63283
kono
parents:
diff changeset
4048 * constexpr.c (potential_constant_expression_1): Handle reference
kono
parents:
diff changeset
4049 args in templates.
kono
parents:
diff changeset
4050
kono
parents:
diff changeset
4051 2015-01-15 Thomas Schwinge <thomas@codesourcery.com>
kono
parents:
diff changeset
4052 James Norris <jnorris@codesourcery.com>
kono
parents:
diff changeset
4053 Cesar Philippidis <cesar@codesourcery.com>
kono
parents:
diff changeset
4054 Ilmir Usmanov <i.usmanov@samsung.com>
kono
parents:
diff changeset
4055 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
4056
kono
parents:
diff changeset
4057 * parser.c: Include "gomp-constants.h".
kono
parents:
diff changeset
4058 (cp_parser_omp_clause_map): Use enum gomp_map_kind instead of enum
kono
parents:
diff changeset
4059 omp_clause_map_kind. Use GOMP_MAP_* instead of OMP_CLAUSE_MAP_*.
kono
parents:
diff changeset
4060 Use OMP_CLAUSE_SET_MAP_KIND.
kono
parents:
diff changeset
4061 (cp_parser_omp_construct, cp_parser_pragma): Handle
kono
parents:
diff changeset
4062 PRAGMA_OACC_CACHE, PRAGMA_OACC_DATA, PRAGMA_OACC_ENTER_DATA,
kono
parents:
diff changeset
4063 PRAGMA_OACC_EXIT_DATA, PRAGMA_OACC_KERNELS, PRAGMA_OACC_PARALLEL,
kono
parents:
diff changeset
4064 PRAGMA_OACC_LOOP, PRAGMA_OACC_UPDATE, PRAGMA_OACC_WAIT.
kono
parents:
diff changeset
4065 (cp_parser_omp_clause_name): Handle "async", "copy", "copyout",
kono
parents:
diff changeset
4066 "create", "delete", "deviceptr", "host", "num_gangs",
kono
parents:
diff changeset
4067 "num_workers", "present", "present_or_copy", "pcopy",
kono
parents:
diff changeset
4068 "present_or_copyin", "pcopyin", "present_or_copyout", "pcopyout",
kono
parents:
diff changeset
4069 "present_or_create", "pcreate", "vector_length", "wait".
kono
parents:
diff changeset
4070 (OACC_DATA_CLAUSE_MASK, OACC_ENTER_DATA_CLAUSE_MASK)
kono
parents:
diff changeset
4071 (OACC_EXIT_DATA_CLAUSE_MASK, OACC_KERNELS_CLAUSE_MASK)
kono
parents:
diff changeset
4072 (OACC_LOOP_CLAUSE_MASK, OACC_PARALLEL_CLAUSE_MASK)
kono
parents:
diff changeset
4073 (OACC_UPDATE_CLAUSE_MASK, OACC_WAIT_CLAUSE_MASK): New macros.
kono
parents:
diff changeset
4074 (cp_parser_omp_var_list_no_open): Handle OMP_CLAUSE__CACHE_.
kono
parents:
diff changeset
4075 (cp_parser_oacc_data_clause, cp_parser_oacc_data_clause_deviceptr)
kono
parents:
diff changeset
4076 (cp_parser_oacc_clause_vector_length, cp_parser_oacc_wait_list)
kono
parents:
diff changeset
4077 (cp_parser_oacc_clause_wait, cp_parser_omp_clause_num_gangs)
kono
parents:
diff changeset
4078 (cp_parser_omp_clause_num_workers, cp_parser_oacc_clause_async)
kono
parents:
diff changeset
4079 (cp_parser_oacc_all_clauses, cp_parser_oacc_cache)
kono
parents:
diff changeset
4080 (cp_parser_oacc_data, cp_parser_oacc_enter_exit_data)
kono
parents:
diff changeset
4081 (cp_parser_oacc_kernels, cp_parser_oacc_loop)
kono
parents:
diff changeset
4082 (cp_parser_oacc_parallel, cp_parser_oacc_update)
kono
parents:
diff changeset
4083 (cp_parser_oacc_wait): New functions.
kono
parents:
diff changeset
4084 * cp-tree.h (finish_oacc_data, finish_oacc_kernels)
kono
parents:
diff changeset
4085 (finish_oacc_parallel): New prototypes.
kono
parents:
diff changeset
4086 * semantics.c: Include "gomp-constants.h".
kono
parents:
diff changeset
4087 (handle_omp_array_sections): Handle GOMP_MAP_FORCE_DEVICEPTR. Use
kono
parents:
diff changeset
4088 GOMP_MAP_* instead of OMP_CLAUSE_MAP_*. Use
kono
parents:
diff changeset
4089 OMP_CLAUSE_SET_MAP_KIND.
kono
parents:
diff changeset
4090 (finish_omp_clauses): Handle OMP_CLAUSE_ASYNC,
kono
parents:
diff changeset
4091 OMP_CLAUSE_VECTOR_LENGTH, OMP_CLAUSE_WAIT, OMP_CLAUSE__CACHE_.
kono
parents:
diff changeset
4092 Use GOMP_MAP_* instead of OMP_CLAUSE_MAP_*.
kono
parents:
diff changeset
4093 (finish_oacc_data, finish_oacc_kernels, finish_oacc_parallel): New
kono
parents:
diff changeset
4094 functions.
kono
parents:
diff changeset
4095
kono
parents:
diff changeset
4096 2015-01-14 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
4097
kono
parents:
diff changeset
4098 PR c++/58671
kono
parents:
diff changeset
4099 * decl2.c (var_defined_without_dynamic_init): Handle gracefully
kono
parents:
diff changeset
4100 self-initialization.
kono
parents:
diff changeset
4101
kono
parents:
diff changeset
4102 2015-01-13 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4103
kono
parents:
diff changeset
4104 PR c++/64356
kono
parents:
diff changeset
4105 PR libstdc++/58777
kono
parents:
diff changeset
4106 * constexpr.c (cxx_eval_binary_expression): Don't VERIFY_CONSTANT
kono
parents:
diff changeset
4107 pointer expressions.
kono
parents:
diff changeset
4108 (cxx_eval_increment_expression): Likewise.
kono
parents:
diff changeset
4109
kono
parents:
diff changeset
4110 PR c++/64514
kono
parents:
diff changeset
4111 * pt.c (coerce_template_parameter_pack): Return NULL for a
kono
parents:
diff changeset
4112 zero-length fixed parameter pack with a pack expansion arg.
kono
parents:
diff changeset
4113
kono
parents:
diff changeset
4114 PR c++/64520
kono
parents:
diff changeset
4115 * pt.c (unify): Don't try to deduce to std::initializer_list<T...>.
kono
parents:
diff changeset
4116
kono
parents:
diff changeset
4117 2015-01-12 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4118
kono
parents:
diff changeset
4119 PR c++/64547
kono
parents:
diff changeset
4120 * constexpr.c (cxx_eval_call_expression): A call to a void
kono
parents:
diff changeset
4121 function doesn't need to return a value.
kono
parents:
diff changeset
4122
kono
parents:
diff changeset
4123 2015-01-09 Michael Collison <michael.collison@linaro.org>
kono
parents:
diff changeset
4124
kono
parents:
diff changeset
4125 * call.c: Include hash-set.h, machmode.h, vec.h, double-int.h,
kono
parents:
diff changeset
4126 input.h, alias.h, symtab.h, options.h, fold-const.h,
kono
parents:
diff changeset
4127 wide-int.h, and inchash.h due to flattening of tree.h.
kono
parents:
diff changeset
4128 * class.c: Ditto.
kono
parents:
diff changeset
4129 * constexpr.c: Ditto.
kono
parents:
diff changeset
4130 * cp-array-notation.c: Ditto.
kono
parents:
diff changeset
4131 * cp-gimplify.c: Ditto.
kono
parents:
diff changeset
4132 * cp-lang.c: Ditto.
kono
parents:
diff changeset
4133 * cp-objcp-common.c: Ditto.
kono
parents:
diff changeset
4134 * cvt.c: Ditto.
kono
parents:
diff changeset
4135 * decl2.c: Ditto.
kono
parents:
diff changeset
4136 * decl.c: Ditto.
kono
parents:
diff changeset
4137 * dump.c: Ditto.
kono
parents:
diff changeset
4138 * error.c: Ditto.
kono
parents:
diff changeset
4139 * except.c: Ditto.
kono
parents:
diff changeset
4140 * expr.c: Ditto.
kono
parents:
diff changeset
4141 * friend.c: Ditto.
kono
parents:
diff changeset
4142 * init.c: Ditto.
kono
parents:
diff changeset
4143 * lambda.c: Ditto.
kono
parents:
diff changeset
4144 * lex.c: Ditto.
kono
parents:
diff changeset
4145 * mangle.c: Ditto.
kono
parents:
diff changeset
4146 * name-lookup.c: Ditto.
kono
parents:
diff changeset
4147 * optimize.c: Ditto.
kono
parents:
diff changeset
4148 * parser.c: Ditto.
kono
parents:
diff changeset
4149 * pt.c: Ditto.
kono
parents:
diff changeset
4150 * ptree.c: Ditto.
kono
parents:
diff changeset
4151 * repo.c: Ditto.
kono
parents:
diff changeset
4152 * rtti.c: Ditto.
kono
parents:
diff changeset
4153 * search.c: Ditto.
kono
parents:
diff changeset
4154 * semantics.c: Ditto.
kono
parents:
diff changeset
4155 * tree.c: Ditto.
kono
parents:
diff changeset
4156 * typeck2.c: Ditto.
kono
parents:
diff changeset
4157 * typeck.c: Ditto.
kono
parents:
diff changeset
4158
kono
parents:
diff changeset
4159 2015-01-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4160
kono
parents:
diff changeset
4161 * cp-gimplify.c (cp_genericize): Use do_ubsan_in_current_function.
kono
parents:
diff changeset
4162 * decl.c (compute_array_index_type): Likewise.
kono
parents:
diff changeset
4163 * init.c (build_vec_init): Likewise.
kono
parents:
diff changeset
4164 * typeck.c (cp_build_binary_op): Likewise.
kono
parents:
diff changeset
4165
kono
parents:
diff changeset
4166 2015-01-08 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4167
kono
parents:
diff changeset
4168 * init.c (build_vec_init): Call ubsan_instrument_bounds to check
kono
parents:
diff changeset
4169 whether an initializer-list is too big for a VLA.
kono
parents:
diff changeset
4170 (throw_bad_array_length): Remove.
kono
parents:
diff changeset
4171 * cp-tree.h: Remove prototype.
kono
parents:
diff changeset
4172
kono
parents:
diff changeset
4173 2015-01-08 Paolo Carlini <paolo.carlini@oracle.com>
kono
parents:
diff changeset
4174
kono
parents:
diff changeset
4175 PR c++/60753
kono
parents:
diff changeset
4176 * decl.c (grokfndecl): Add bool parameter.
kono
parents:
diff changeset
4177 (grokdeclarator): Adjust calls.
kono
parents:
diff changeset
4178 (start_decl): Don't set DECL_DELETED_FN here.
kono
parents:
diff changeset
4179
kono
parents:
diff changeset
4180 2015-01-06 Jason Merrill <jason@redhat.com>
kono
parents:
diff changeset
4181
kono
parents:
diff changeset
4182 * parser.c (cp_parser_nested_name_specifier_opt): Diagnose invalid
kono
parents:
diff changeset
4183 template-ids.
kono
parents:
diff changeset
4184
kono
parents:
diff changeset
4185 PR c++/64455
kono
parents:
diff changeset
4186 * pt.c (type_dependent_expression_p): Handle variable templates.
kono
parents:
diff changeset
4187 * constexpr.c (potential_constant_expression_1): Use it.
kono
parents:
diff changeset
4188
kono
parents:
diff changeset
4189 PR c++/64487
kono
parents:
diff changeset
4190 * semantics.c (finish_offsetof): Handle templates here.
kono
parents:
diff changeset
4191 * parser.c (cp_parser_builtin_offsetof): Not here.
kono
parents:
diff changeset
4192
kono
parents:
diff changeset
4193 PR c++/64496
kono
parents:
diff changeset
4194 * semantics.c (process_outer_var_ref): Diagnose lambda in local
kono
parents:
diff changeset
4195 class NSDMI.
kono
parents:
diff changeset
4196
kono
parents:
diff changeset
4197 2015-01-06 Ville Voutilainen <ville.voutilainen@gmail.com>
kono
parents:
diff changeset
4198
kono
parents:
diff changeset
4199 PR c++/64489
kono
parents:
diff changeset
4200 * class.c (check_field_decls): Make copy assignment operators
kono
parents:
diff changeset
4201 complex only in c++98 mode.
kono
parents:
diff changeset
4202
kono
parents:
diff changeset
4203 2015-01-05 Trevor Saunders <tsaunders@mozilla.com>
kono
parents:
diff changeset
4204
kono
parents:
diff changeset
4205 PR c++/31397
kono
parents:
diff changeset
4206 * class.c (check_for_override): Warn when a virtual function is an
kono
parents:
diff changeset
4207 override not marked override.
kono
parents:
diff changeset
4208
kono
parents:
diff changeset
4209 2015-01-05 Trevor Saunders <tsaunders@mozilla.com>
kono
parents:
diff changeset
4210
kono
parents:
diff changeset
4211 * class.c (warn_hidden): Use auto_vec<tree> instead of tree_list to
kono
parents:
diff changeset
4212 hold base_fndecls.
kono
parents:
diff changeset
4213 (get_basefndecls): Adjust.
kono
parents:
diff changeset
4214
kono
parents:
diff changeset
4215 2015-01-05 Jakub Jelinek <jakub@redhat.com>
kono
parents:
diff changeset
4216
kono
parents:
diff changeset
4217 Update copyright years.
kono
parents:
diff changeset
4218
kono
parents:
diff changeset
4219 2015-01-05 Marek Polacek <polacek@redhat.com>
kono
parents:
diff changeset
4220
kono
parents:
diff changeset
4221 PR c/64423
kono
parents:
diff changeset
4222 * typeck.c (cp_build_array_ref): Pass loc down to
kono
parents:
diff changeset
4223 warn_array_subscript_with_type_char.
kono
parents:
diff changeset
4224
kono
parents:
diff changeset
4225
kono
parents:
diff changeset
4226 Copyright (C) 2015 Free Software Foundation, Inc.
kono
parents:
diff changeset
4227
kono
parents:
diff changeset
4228 Copying and distribution of this file, with or without modification,
kono
parents:
diff changeset
4229 are permitted in any medium without royalty provided the copyright
kono
parents:
diff changeset
4230 notice and this notice are preserved.