Branch data Line data Source code
1 : : /* Definitions for C++ contract levels
2 : : Copyright (C) 2020-2024 Free Software Foundation, Inc.
3 : : Contributed by Jeff Chapman II (jchapman@lock3software.com)
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify
8 : : it under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3, or (at your option)
10 : : any later version.
11 : :
12 : : GCC is distributed in the hope that it will be useful,
13 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : : GNU General Public License for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : : /* Design Notes
22 : :
23 : : A function is called a "guarded" function if it has pre or post contract
24 : : attributes. A contract is considered an "active" contract if runtime code is
25 : : needed for the contract under the current contract configuration.
26 : :
27 : : pre and post contract attributes are parsed and stored in DECL_ATTRIBUTES.
28 : : assert contracts are parsed and wrapped in statements. When genericizing, all
29 : : active and assumed contracts are transformed into an if block. An observed
30 : : contract:
31 : :
32 : : [[ pre: v > 0 ]]
33 : :
34 : : is transformed into:
35 : :
36 : : if (!(v > 0)) {
37 : : handle_contract_violation(__pseudo_contract_violation{
38 : : 5, // line_number,
39 : : "main.cpp", // file_name,
40 : : "fun", // function_name,
41 : : "v > 0", // comment,
42 : : "default", // assertion_level,
43 : : "default", // assertion_role,
44 : : maybe_continue, // continuation_mode
45 : : });
46 : : terminate (); // if never_continue
47 : : }
48 : :
49 : : We use an internal type with the same layout as contract_violation rather
50 : : than try to define the latter internally and somehow deal with its actual
51 : : definition in a TU that includes <contract>.
52 : :
53 : : ??? is it worth factoring out the calls to handle_contract_violation and
54 : : terminate into a local function?
55 : :
56 : : Assumed contracts use the same implementation as C++23 [[assume]].
57 : :
58 : : Parsing of pre and post contract conditions need to be deferred when the
59 : : contracts are attached to a member function. The postcondition identifier
60 : : cannot be used before the deduced return type of an auto function is used,
61 : : except when used in a defining declaration in which case they conditions are
62 : : fully parsed once the body is finished (see cpp2a/contracts-deduced{1,2}.C).
63 : :
64 : : A list of pre and post contracts can either be repeated in their entirety or
65 : : completely absent in subsequent declarations. If contract lists appear on two
66 : : matching declarations, their contracts have to be equivalent. In general this
67 : : means that anything before the colon have to be token equivalent and the
68 : : condition must be cp_tree_equal (primarily to allow for parameter renaming).
69 : :
70 : : Contracts on overrides must match those present on (all of) the overridee(s).
71 : :
72 : : Template specializations may have their own contracts. If no contracts are
73 : : specified on the initial specialization they're assumed to be the same as
74 : : the primary template. Specialization redeclarations must then match either
75 : : the primary template (if they were unspecified originally), or those
76 : : specified on the specialization.
77 : :
78 : :
79 : : For non-cdtors two functions are generated for ease of implementation and to
80 : : avoid some cases where code bloat may occurr. These are the DECL_PRE_FN and
81 : : DECL_POST_FN. Each handles checking either the set of pre or post contracts
82 : : of a guarded function.
83 : :
84 : : int fun(int v)
85 : : [[ pre: v > 0 ]]
86 : : [[ post r: r < 0 ]]
87 : : {
88 : : return -v;
89 : : }
90 : :
91 : : We implement the checking as follows:
92 : :
93 : : For functions with no post-conditions we wrap the original function body as
94 : : follows:
95 : :
96 : : {
97 : : handle_pre_condition_checking ();
98 : : original_function_body ();
99 : : }
100 : :
101 : : This implements the intent that the preconditions are processed after the
102 : : function parameters are initialised but before any other actions.
103 : :
104 : : For functions with post-conditions:
105 : :
106 : : if (preconditions_exist)
107 : : handle_pre_condition_checking ();
108 : : try
109 : : {
110 : : original_function_body ();
111 : : }
112 : : finally
113 : : {
114 : : handle_post_condition_checking ();
115 : : }
116 : : else [only if the function is not marked noexcept(true) ]
117 : : {
118 : : ;
119 : : }
120 : :
121 : : In this, post-conditions [that might apply to the return value etc.] are
122 : : evaluated on every non-exceptional edge out of the function.
123 : :
124 : : FIXME outlining contract checks into separate functions was motivated
125 : : partly by wanting to call the postcondition function at each return
126 : : statement, which we no longer do; at this point outlining doesn't seem to
127 : : have any advantage over emitting the contracts directly in the function
128 : : body.
129 : :
130 : : More helpful for optimization might be to make the contracts a wrapper
131 : : function that could be inlined into the caller, the callee, or both. */
132 : :
133 : : #include "config.h"
134 : : #include "system.h"
135 : : #include "coretypes.h"
136 : : #include "cp-tree.h"
137 : : #include "stringpool.h"
138 : : #include "diagnostic.h"
139 : : #include "options.h"
140 : : #include "contracts.h"
141 : : #include "tree.h"
142 : : #include "tree-inline.h"
143 : : #include "attribs.h"
144 : : #include "tree-iterator.h"
145 : : #include "print-tree.h"
146 : : #include "stor-layout.h"
147 : : #include "intl.h"
148 : : #include "cgraph.h"
149 : :
150 : : const int max_custom_roles = 32;
151 : : static contract_role contract_build_roles[max_custom_roles] = {
152 : : };
153 : :
154 : : bool valid_configs[CCS_MAYBE + 1][CCS_MAYBE + 1] = {
155 : : { 0, 0, 0, 0, 0, },
156 : : { 0, 1, 0, 0, 0, },
157 : : { 0, 1, 1, 1, 1, },
158 : : { 0, 1, 1, 1, 1, },
159 : : { 0, 1, 0, 0, 1, },
160 : : };
161 : :
162 : : void
163 : 28 : validate_contract_role (contract_role *role)
164 : : {
165 : 28 : gcc_assert (role);
166 : 28 : if (!unchecked_contract_p (role->axiom_semantic))
167 : 0 : error ("axiom contract semantic must be %<assume%> or %<ignore%>");
168 : :
169 : 28 : if (!valid_configs[role->default_semantic][role->audit_semantic] )
170 : 0 : warning (0, "the %<audit%> semantic should be at least as strong as "
171 : : "the %<default%> semantic");
172 : 28 : }
173 : :
174 : : contract_semantic
175 : 78 : lookup_concrete_semantic (const char *name)
176 : : {
177 : 78 : if (strcmp (name, "ignore") == 0)
178 : : return CCS_IGNORE;
179 : 32 : if (strcmp (name, "assume") == 0)
180 : : return CCS_ASSUME;
181 : 31 : if (strcmp (name, "check_never_continue") == 0
182 : 31 : || strcmp (name, "never") == 0
183 : 28 : || strcmp (name, "abort") == 0)
184 : : return CCS_NEVER;
185 : 28 : if (strcmp (name, "check_maybe_continue") == 0
186 : 28 : || strcmp (name, "maybe") == 0)
187 : : return CCS_MAYBE;
188 : 0 : error ("'%s' is not a valid explicit concrete semantic", name);
189 : 0 : return CCS_INVALID;
190 : : }
191 : :
192 : : /* Compare role and name up to either the NUL terminator or the first
193 : : occurrence of colon. */
194 : :
195 : : static bool
196 : 1048 : role_name_equal (const char *role, const char *name)
197 : : {
198 : 1048 : size_t role_len = strcspn (role, ":");
199 : 1048 : size_t name_len = strcspn (name, ":");
200 : 1048 : if (role_len != name_len)
201 : : return false;
202 : 892 : return strncmp (role, name, role_len) == 0;
203 : : }
204 : :
205 : : static bool
206 : 2965 : role_name_equal (contract_role *role, const char *name)
207 : : {
208 : 0 : if (role->name == NULL)
209 : : return false;
210 : 0 : return role_name_equal (role->name, name);
211 : : }
212 : :
213 : : contract_role *
214 : 808 : get_contract_role (const char *name)
215 : : {
216 : 2915 : for (int i = 0; i < max_custom_roles; ++i)
217 : : {
218 : 2851 : contract_role *potential = contract_build_roles + i;
219 : 2851 : if (role_name_equal (potential, name))
220 : : return potential;
221 : : }
222 : 64 : if (role_name_equal (name, "default") || role_name_equal (name, "review"))
223 : : {
224 : 57 : setup_default_contract_role (false);
225 : 57 : return get_contract_role (name);
226 : : }
227 : : return NULL;
228 : : }
229 : :
230 : : contract_role *
231 : 241 : add_contract_role (const char *name,
232 : : contract_semantic des,
233 : : contract_semantic aus,
234 : : contract_semantic axs,
235 : : bool update)
236 : : {
237 : 353 : for (int i = 0; i < max_custom_roles; ++i)
238 : : {
239 : 353 : contract_role *potential = contract_build_roles + i;
240 : 465 : if (potential->name != NULL
241 : 353 : && !role_name_equal (potential, name))
242 : 112 : continue;
243 : 241 : if (potential->name != NULL && !update)
244 : : return potential;
245 : 241 : potential->name = name;
246 : 241 : potential->default_semantic = des;
247 : 241 : potential->audit_semantic = aus;
248 : 241 : potential->axiom_semantic = axs;
249 : 241 : return potential;
250 : : }
251 : : return NULL;
252 : : }
253 : :
254 : : enum contract_build_level { OFF, DEFAULT, AUDIT };
255 : : static bool flag_contract_continuation_mode = false;
256 : : static bool flag_contract_assumption_mode = true;
257 : : static int flag_contract_build_level = DEFAULT;
258 : :
259 : : static bool contracts_p1332_default = false, contracts_p1332_review = false,
260 : : contracts_std = false, contracts_p1429 = false;
261 : :
262 : : static contract_semantic
263 : 108 : get_concrete_check ()
264 : : {
265 : 0 : return flag_contract_continuation_mode ? CCS_MAYBE : CCS_NEVER;
266 : : }
267 : :
268 : : static contract_semantic
269 : 108 : get_concrete_axiom_semantic ()
270 : : {
271 : 0 : return flag_contract_assumption_mode ? CCS_ASSUME : CCS_IGNORE;
272 : : }
273 : :
274 : : void
275 : 108 : setup_default_contract_role (bool update)
276 : : {
277 : 108 : contract_semantic check = get_concrete_check ();
278 : 108 : contract_semantic axiom = get_concrete_axiom_semantic ();
279 : 108 : switch (flag_contract_build_level)
280 : : {
281 : 1 : case OFF:
282 : 1 : add_contract_role ("default", CCS_IGNORE, CCS_IGNORE, axiom, update);
283 : 1 : add_contract_role ("review", CCS_IGNORE, CCS_IGNORE, CCS_IGNORE, update);
284 : 1 : break;
285 : 104 : case DEFAULT:
286 : 104 : add_contract_role ("default", check, CCS_IGNORE, axiom, update);
287 : 104 : add_contract_role ("review", check, CCS_IGNORE, CCS_IGNORE, update);
288 : 104 : break;
289 : 3 : case AUDIT:
290 : 3 : add_contract_role ("default", check, check, axiom, update);
291 : 3 : add_contract_role ("review", check, check, CCS_IGNORE, update);
292 : 3 : break;
293 : : }
294 : 108 : }
295 : :
296 : : contract_semantic
297 : 198 : map_contract_semantic (const char *ident)
298 : : {
299 : 198 : if (strcmp (ident, "ignore") == 0)
300 : : return CCS_IGNORE;
301 : 176 : else if (strcmp (ident, "assume") == 0)
302 : : return CCS_ASSUME;
303 : 144 : else if (strcmp (ident, "check_never_continue") == 0)
304 : : return CCS_NEVER;
305 : 134 : else if (strcmp (ident, "check_maybe_continue") == 0)
306 : 20 : return CCS_MAYBE;
307 : : return CCS_INVALID;
308 : : }
309 : :
310 : : contract_level
311 : 230 : map_contract_level (const char *ident)
312 : : {
313 : 230 : if (strcmp (ident, "default") == 0)
314 : : return CONTRACT_DEFAULT;
315 : 195 : else if (strcmp (ident, "audit") == 0)
316 : : return CONTRACT_AUDIT;
317 : 147 : else if (strcmp (ident, "axiom") == 0)
318 : 30 : return CONTRACT_AXIOM;
319 : : return CONTRACT_INVALID;
320 : : }
321 : :
322 : :
323 : : void
324 : 4 : handle_OPT_fcontract_build_level_ (const char *arg)
325 : : {
326 : 4 : if (contracts_p1332_default || contracts_p1332_review || contracts_p1429)
327 : : {
328 : 0 : error ("%<-fcontract-build-level=%> cannot be mixed with p1332/p1429");
329 : 0 : return;
330 : : }
331 : : else
332 : 4 : contracts_std = true;
333 : :
334 : 4 : if (strcmp (arg, "off") == 0)
335 : 1 : flag_contract_build_level = OFF;
336 : 3 : else if (strcmp (arg, "default") == 0)
337 : 1 : flag_contract_build_level = DEFAULT;
338 : 2 : else if (strcmp (arg, "audit") == 0)
339 : 2 : flag_contract_build_level = AUDIT;
340 : : else
341 : 0 : error ("%<-fcontract-build-level=%> must be off|default|audit");
342 : :
343 : 4 : setup_default_contract_role ();
344 : : }
345 : :
346 : : void
347 : 0 : handle_OPT_fcontract_assumption_mode_ (const char *arg)
348 : : {
349 : 0 : if (contracts_p1332_default || contracts_p1332_review || contracts_p1429)
350 : : {
351 : 0 : error ("%<-fcontract-assumption-mode=%> cannot be mixed with p1332/p1429");
352 : 0 : return;
353 : : }
354 : : else
355 : 0 : contracts_std = true;
356 : :
357 : 0 : if (strcmp (arg, "on") == 0)
358 : 0 : flag_contract_assumption_mode = true;
359 : 0 : else if (strcmp (arg, "off") == 0)
360 : 0 : flag_contract_assumption_mode = false;
361 : : else
362 : 0 : error ("%<-fcontract-assumption-mode=%> must be %<on%> or %<off%>");
363 : :
364 : 0 : setup_default_contract_role ();
365 : : }
366 : :
367 : : void
368 : 47 : handle_OPT_fcontract_continuation_mode_ (const char *arg)
369 : : {
370 : 47 : if (contracts_p1332_default || contracts_p1332_review || contracts_p1429)
371 : : {
372 : 0 : error ("%<-fcontract-continuation-mode=%> cannot be mixed with p1332/p1429");
373 : 0 : return;
374 : : }
375 : : else
376 : 47 : contracts_std = true;
377 : :
378 : 47 : if (strcmp (arg, "on") == 0)
379 : 47 : flag_contract_continuation_mode = true;
380 : 0 : else if (strcmp (arg, "off") == 0)
381 : 0 : flag_contract_continuation_mode = false;
382 : : else
383 : 0 : error ("%<-fcontract-continuation-mode=%> must be %<on%> or %<off%>");
384 : :
385 : 47 : setup_default_contract_role ();
386 : : }
387 : :
388 : : void
389 : 25 : handle_OPT_fcontract_role_ (const char *arg)
390 : : {
391 : 25 : const char *name = arg;
392 : 25 : const char *vals = strchr (name, ':');
393 : 25 : if (vals == NULL)
394 : : {
395 : 0 : error ("%<-fcontract-role=%> must be in the form role:semantics");
396 : 0 : return;
397 : : }
398 : :
399 : 25 : contract_semantic dess = CCS_INVALID, auss = CCS_INVALID, axss = CCS_INVALID;
400 : 25 : char *des = NULL, *aus = NULL, *axs = NULL;
401 : 25 : des = xstrdup (vals + 1);
402 : :
403 : 25 : aus = strchr (des, ',');
404 : 25 : if (aus == NULL)
405 : : {
406 : 0 : error ("%<-fcontract-role=%> semantics must include default,audit,axiom values");
407 : 0 : goto validate;
408 : : }
409 : 25 : *aus = '\0'; // null terminate des
410 : 25 : aus = aus + 1; // move past null
411 : :
412 : 25 : axs = strchr (aus, ',');
413 : 25 : if (axs == NULL)
414 : : {
415 : 0 : error ("%<-fcontract-role=%> semantics must include default,audit,axiom values");
416 : 0 : goto validate;
417 : : }
418 : 25 : *axs = '\0'; // null terminate aus
419 : 25 : axs = axs + 1; // move past null
420 : :
421 : 25 : dess = lookup_concrete_semantic (des);
422 : 25 : auss = lookup_concrete_semantic (aus);
423 : 25 : axss = lookup_concrete_semantic (axs);
424 : 25 : validate:
425 : 25 : free (des);
426 : 25 : if (dess == CCS_INVALID || auss == CCS_INVALID || axss == CCS_INVALID)
427 : : return;
428 : :
429 : 25 : bool is_defalult_role = role_name_equal (name, "default");
430 : 25 : bool is_review_role = role_name_equal (name, "review");
431 : 25 : bool is_std_role = is_defalult_role || is_review_role;
432 : 25 : if ((contracts_std && is_std_role) || (contracts_p1429 && is_defalult_role))
433 : : {
434 : 0 : error ("%<-fcontract-role=%> cannot be mixed with std/p1429 contract flags");
435 : 0 : return;
436 : : }
437 : 25 : else if (is_std_role)
438 : : {
439 : 23 : contracts_p1332_default |= is_defalult_role;
440 : 23 : contracts_p1332_review |= is_review_role;
441 : : }
442 : :
443 : 25 : contract_role *role = add_contract_role (name, dess, auss, axss);
444 : :
445 : 25 : if (role == NULL)
446 : : {
447 : : // TODO: not enough space?
448 : 0 : error ("%<-fcontract-level=%> too many custom roles");
449 : 0 : return;
450 : : }
451 : : else
452 : 25 : validate_contract_role (role);
453 : : }
454 : :
455 : : void
456 : 3 : handle_OPT_fcontract_semantic_ (const char *arg)
457 : : {
458 : 3 : if (!strchr (arg, ':'))
459 : : {
460 : 0 : error ("%<-fcontract-semantic=%> must be in the form level:semantic");
461 : 0 : return;
462 : : }
463 : :
464 : 3 : if (contracts_std || contracts_p1332_default)
465 : : {
466 : 0 : error ("%<-fcontract-semantic=%> cannot be mixed with std/p1332 contract flags");
467 : 0 : return;
468 : : }
469 : 3 : contracts_p1429 = true;
470 : :
471 : 3 : contract_role *role = get_contract_role ("default");
472 : 3 : if (!role)
473 : : {
474 : 0 : error ("%<-fcontract-semantic=%> cannot find default role");
475 : 0 : return;
476 : : }
477 : :
478 : 3 : const char *semantic = strchr (arg, ':') + 1;
479 : 3 : contract_semantic sem = lookup_concrete_semantic (semantic);
480 : 3 : if (sem == CCS_INVALID)
481 : : return;
482 : :
483 : 3 : if (strncmp ("default:", arg, 8) == 0)
484 : 1 : role->default_semantic = sem;
485 : 2 : else if (strncmp ("audit:", arg, 6) == 0)
486 : 1 : role->audit_semantic = sem;
487 : 1 : else if (strncmp ("axiom:", arg, 6) == 0)
488 : 1 : role->axiom_semantic = sem;
489 : : else
490 : 0 : error ("%<-fcontract-semantic=%> level must be default, audit, or axiom");
491 : 3 : validate_contract_role (role);
492 : : }
493 : :
494 : : /* Convert a contract CONFIG into a contract_mode. */
495 : :
496 : : static contract_mode
497 : 840 : contract_config_to_mode (tree config)
498 : : {
499 : 840 : if (config == NULL_TREE)
500 : 724 : return contract_mode (CONTRACT_DEFAULT, get_default_contract_role ());
501 : :
502 : : /* TREE_LIST has TREE_VALUE is a level and TREE_PURPOSE is role. */
503 : 116 : if (TREE_CODE (config) == TREE_LIST)
504 : : {
505 : 74 : contract_role *role = NULL;
506 : 74 : if (TREE_PURPOSE (config))
507 : 31 : role = get_contract_role (IDENTIFIER_POINTER (TREE_PURPOSE (config)));
508 : 31 : if (!role)
509 : 50 : role = get_default_contract_role ();
510 : :
511 : 74 : contract_level level =
512 : 74 : map_contract_level (IDENTIFIER_POINTER (TREE_VALUE (config)));
513 : 74 : return contract_mode (level, role);
514 : : }
515 : :
516 : : /* Literal semantic. */
517 : 42 : gcc_assert (TREE_CODE (config) == IDENTIFIER_NODE);
518 : 42 : contract_semantic semantic =
519 : 42 : map_contract_semantic (IDENTIFIER_POINTER (config));
520 : 42 : return contract_mode (semantic);
521 : : }
522 : :
523 : : /* Convert a contract's config into a concrete semantic using the current
524 : : contract semantic mapping. */
525 : :
526 : : static contract_semantic
527 : 840 : compute_concrete_semantic (tree contract)
528 : : {
529 : 840 : contract_mode mode = contract_config_to_mode (CONTRACT_MODE (contract));
530 : : /* Compute the concrete semantic for the contract. */
531 : 840 : if (!flag_contract_mode)
532 : : /* If contracts are off, treat all contracts as ignore. */
533 : : return CCS_IGNORE;
534 : 837 : else if (mode.kind == contract_mode::cm_invalid)
535 : : return CCS_INVALID;
536 : 837 : else if (mode.kind == contract_mode::cm_explicit)
537 : 42 : return mode.get_semantic ();
538 : : else
539 : : {
540 : 795 : gcc_assert (mode.get_role ());
541 : 795 : gcc_assert (mode.get_level () != CONTRACT_INVALID);
542 : 795 : contract_level level = mode.get_level ();
543 : 795 : contract_role *role = mode.get_role ();
544 : 795 : if (level == CONTRACT_DEFAULT)
545 : 756 : return role->default_semantic;
546 : 39 : else if (level == CONTRACT_AUDIT)
547 : 24 : return role->audit_semantic;
548 : 15 : else if (level == CONTRACT_AXIOM)
549 : 15 : return role->axiom_semantic;
550 : : }
551 : 0 : gcc_assert (false);
552 : : }
553 : :
554 : : /* Return true if any contract in CONTRACT_ATTRs is not yet parsed. */
555 : :
556 : : bool
557 : 20 : contract_any_deferred_p (tree contract_attr)
558 : : {
559 : 50 : for (; contract_attr; contract_attr = CONTRACT_CHAIN (contract_attr))
560 : 30 : if (CONTRACT_CONDITION_DEFERRED_P (CONTRACT_STATEMENT (contract_attr)))
561 : : return true;
562 : : return false;
563 : : }
564 : :
565 : : /* Returns true if all attributes are contracts. */
566 : :
567 : : bool
568 : 29 : all_attributes_are_contracts_p (tree attributes)
569 : : {
570 : 31 : for (; attributes; attributes = TREE_CHAIN (attributes))
571 : 29 : if (!cxx_contract_attribute_p (attributes))
572 : : return false;
573 : : return true;
574 : : }
575 : :
576 : : /* Mark most of a contract as being invalid. */
577 : :
578 : : tree
579 : 23 : invalidate_contract (tree t)
580 : : {
581 : 23 : if (TREE_CODE (t) == POSTCONDITION_STMT && POSTCONDITION_IDENTIFIER (t))
582 : 6 : POSTCONDITION_IDENTIFIER (t) = error_mark_node;
583 : 23 : CONTRACT_CONDITION (t) = error_mark_node;
584 : 23 : CONTRACT_COMMENT (t) = error_mark_node;
585 : 23 : return t;
586 : : }
587 : :
588 : : /* Returns an invented parameter declration of the form 'TYPE ID' for the
589 : : purpose of parsing the postcondition.
590 : :
591 : : We use a PARM_DECL instead of a VAR_DECL so that tsubst forces a lookup
592 : : in local specializations when we instantiate these things later. */
593 : :
594 : : tree
595 : 73 : make_postcondition_variable (cp_expr id, tree type)
596 : : {
597 : 73 : if (id == error_mark_node)
598 : : return id;
599 : :
600 : 73 : tree decl = build_lang_decl (PARM_DECL, id, type);
601 : 73 : DECL_ARTIFICIAL (decl) = true;
602 : 73 : DECL_SOURCE_LOCATION (decl) = id.get_location ();
603 : :
604 : 73 : pushdecl (decl);
605 : 73 : return decl;
606 : : }
607 : :
608 : : /* As above, except that the type is unknown. */
609 : :
610 : : tree
611 : 69 : make_postcondition_variable (cp_expr id)
612 : : {
613 : 69 : return make_postcondition_variable (id, make_auto ());
614 : : }
615 : :
616 : : /* Check that the TYPE is valid for a named postcondition variable. Emit a
617 : : diagnostic if it is not. Returns TRUE if the result is OK and false
618 : : otherwise. */
619 : :
620 : : bool
621 : 90 : check_postcondition_result (tree decl, tree type, location_t loc)
622 : : {
623 : : /* Do not be confused by targetm.cxx.cdtor_return_this ();
624 : : conceptually, cdtors have no return value. */
625 : 90 : if (VOID_TYPE_P (type)
626 : 168 : || DECL_CONSTRUCTOR_P (decl)
627 : 174 : || DECL_DESTRUCTOR_P (decl))
628 : : {
629 : 18 : error_at (loc,
630 : 12 : DECL_CONSTRUCTOR_P (decl)
631 : : ? G_("constructor does not return a value to test")
632 : 5 : : DECL_DESTRUCTOR_P (decl)
633 : 5 : ? G_("destructor does not return a value to test")
634 : : : G_("function does not return a value to test"));
635 : 6 : return false;
636 : : }
637 : :
638 : : return true;
639 : : }
640 : :
641 : : /* Instantiate each postcondition with the return type to finalize the
642 : : attribute. */
643 : :
644 : : void
645 : 8616909 : rebuild_postconditions (tree decl)
646 : : {
647 : 8616909 : tree type = TREE_TYPE (TREE_TYPE (decl));
648 : 8616909 : tree attributes = DECL_CONTRACTS (decl);
649 : :
650 : 8617816 : for (; attributes ; attributes = TREE_CHAIN (attributes))
651 : : {
652 : 963 : if (!cxx_contract_attribute_p (attributes))
653 : 852 : continue;
654 : 963 : tree contract = TREE_VALUE (TREE_VALUE (attributes));
655 : 963 : if (TREE_CODE (contract) != POSTCONDITION_STMT)
656 : 825 : continue;
657 : 138 : tree condition = CONTRACT_CONDITION (contract);
658 : :
659 : : /* If any conditions are deferred, they're all deferred. Note that
660 : : we don't have to instantiate postconditions in that case because
661 : : the type is available through the declaration. */
662 : 138 : if (TREE_CODE (condition) == DEFERRED_PARSE)
663 : 56 : return;
664 : :
665 : 104 : tree oldvar = POSTCONDITION_IDENTIFIER (contract);
666 : 104 : if (!oldvar)
667 : 25 : continue;
668 : :
669 : : /* Always update the context of the result variable so that it can
670 : : be remapped by remap_contracts. */
671 : 79 : DECL_CONTEXT (oldvar) = decl;
672 : :
673 : : /* If the return type is undeduced, defer until later. */
674 : 79 : if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
675 : : return;
676 : :
677 : : /* Check the postcondition variable. */
678 : 57 : location_t loc = DECL_SOURCE_LOCATION (oldvar);
679 : 57 : if (!check_postcondition_result (decl, type, loc))
680 : : {
681 : 2 : invalidate_contract (contract);
682 : 2 : continue;
683 : : }
684 : :
685 : : /* "Instantiate" the result variable using the known type. Also update
686 : : the context so the inliner will actually remap this the parameter when
687 : : generating contract checks. */
688 : 55 : tree newvar = copy_node (oldvar);
689 : 55 : TREE_TYPE (newvar) = type;
690 : :
691 : : /* Make parameters and result available for substitution. */
692 : 55 : local_specialization_stack stack (lss_copy);
693 : 109 : for (tree t = DECL_ARGUMENTS (decl); t != NULL_TREE; t = TREE_CHAIN (t))
694 : 54 : register_local_identity (t);
695 : 55 : register_local_specialization (newvar, oldvar);
696 : :
697 : 55 : ++processing_contract_condition;
698 : 55 : condition = tsubst_expr (condition, make_tree_vec (0),
699 : : tf_warning_or_error, decl);
700 : 55 : --processing_contract_condition;
701 : :
702 : : /* Update the contract condition and result. */
703 : 55 : POSTCONDITION_IDENTIFIER (contract) = newvar;
704 : 55 : CONTRACT_CONDITION (contract) = finish_contract_condition (condition);
705 : 55 : }
706 : : }
707 : :
708 : : static tree
709 : 825 : build_comment (cp_expr condition)
710 : : {
711 : : /* Try to get the actual source text for the condition; if that fails pretty
712 : : print the resulting tree. */
713 : 825 : char *str = get_source_text_between (global_dc->get_file_cache (),
714 : : condition.get_start (),
715 : : condition.get_finish ());
716 : 825 : if (!str)
717 : : {
718 : : /* FIXME cases where we end up here
719 : : #line macro usage (oof)
720 : : contracts10.C
721 : : contracts11.C */
722 : 23 : const char *str = expr_to_string (condition);
723 : 23 : return build_string_literal (strlen (str) + 1, str);
724 : : }
725 : :
726 : 802 : tree t = build_string_literal (strlen (str) + 1, str);
727 : 802 : free (str);
728 : 802 : return t;
729 : : }
730 : :
731 : : /* Build a contract statement. */
732 : :
733 : : tree
734 : 849 : grok_contract (tree attribute, tree mode, tree result, cp_expr condition,
735 : : location_t loc)
736 : : {
737 : 849 : if (condition == error_mark_node)
738 : : return error_mark_node;
739 : :
740 : 840 : tree_code code;
741 : 840 : if (is_attribute_p ("assert", attribute))
742 : : code = ASSERTION_STMT;
743 : 682 : else if (is_attribute_p ("pre", attribute))
744 : : code = PRECONDITION_STMT;
745 : 119 : else if (is_attribute_p ("post", attribute))
746 : : code = POSTCONDITION_STMT;
747 : : else
748 : 0 : gcc_unreachable ();
749 : :
750 : : /* Build the contract. The condition is added later. In the case that
751 : : the contract is deferred, result an plain identifier, not a result
752 : : variable. */
753 : 840 : tree contract;
754 : 840 : tree type = void_type_node;
755 : 721 : if (code != POSTCONDITION_STMT)
756 : 721 : contract = build3_loc (loc, code, type, mode, NULL_TREE, NULL_TREE);
757 : : else
758 : 119 : contract = build4_loc (loc, code, type, mode, NULL_TREE, NULL_TREE, result);
759 : :
760 : : /* Determine the concrete semantic. */
761 : 840 : set_contract_semantic (contract, compute_concrete_semantic (contract));
762 : :
763 : : /* If the contract is deferred, don't do anything with the condition. */
764 : 840 : if (TREE_CODE (condition) == DEFERRED_PARSE)
765 : : {
766 : 242 : CONTRACT_CONDITION (contract) = condition;
767 : 242 : return contract;
768 : : }
769 : :
770 : : /* Generate the comment from the original condition. */
771 : 598 : CONTRACT_COMMENT (contract) = build_comment (condition);
772 : :
773 : : /* The condition is converted to bool. */
774 : 598 : condition = finish_contract_condition (condition);
775 : :
776 : 598 : if (condition == error_mark_node)
777 : : return error_mark_node;
778 : :
779 : 590 : CONTRACT_CONDITION (contract) = condition;
780 : :
781 : 590 : return contract;
782 : : }
783 : :
784 : : /* Build the contract attribute specifier where IDENTIFIER is one of 'pre',
785 : : 'post' or 'assert' and CONTRACT is the underlying statement. */
786 : : tree
787 : 846 : finish_contract_attribute (tree identifier, tree contract)
788 : : {
789 : 846 : if (contract == error_mark_node)
790 : : return error_mark_node;
791 : :
792 : 829 : tree attribute = build_tree_list (build_tree_list (NULL_TREE, identifier),
793 : : build_tree_list (NULL_TREE, contract));
794 : :
795 : : /* Mark the attribute as dependent if the condition is dependent.
796 : :
797 : : TODO: I'm not sure this is strictly necessary. It's going to be marked as
798 : : such by a subroutine of cplus_decl_attributes. */
799 : 829 : tree condition = CONTRACT_CONDITION (contract);
800 : 829 : if (TREE_CODE (condition) == DEFERRED_PARSE
801 : 829 : || value_dependent_expression_p (condition))
802 : 340 : ATTR_IS_DEPENDENT (attribute) = true;
803 : :
804 : : return attribute;
805 : : }
806 : :
807 : : /* Update condition of a late-parsed contract and postcondition variable,
808 : : if any. */
809 : :
810 : : void
811 : 227 : update_late_contract (tree contract, tree result, tree condition)
812 : : {
813 : 227 : if (TREE_CODE (contract) == POSTCONDITION_STMT)
814 : 31 : POSTCONDITION_IDENTIFIER (contract) = result;
815 : :
816 : : /* Generate the comment from the original condition. */
817 : 227 : CONTRACT_COMMENT (contract) = build_comment (condition);
818 : :
819 : : /* The condition is converted to bool. */
820 : 227 : condition = finish_contract_condition (condition);
821 : 227 : CONTRACT_CONDITION (contract) = condition;
822 : 227 : }
823 : :
824 : : /* Return TRUE iff ATTR has been parsed by the front-end as a c++2a contract
825 : : attribute. */
826 : :
827 : : bool
828 : 530087747 : cxx_contract_attribute_p (const_tree attr)
829 : : {
830 : 530087747 : if (attr == NULL_TREE
831 : 147785298 : || TREE_CODE (attr) != TREE_LIST)
832 : : return false;
833 : :
834 : 147785242 : if (!TREE_PURPOSE (attr) || TREE_CODE (TREE_PURPOSE (attr)) != TREE_LIST)
835 : : return false;
836 : 65084361 : if (!TREE_VALUE (attr) || TREE_CODE (TREE_VALUE (attr)) != TREE_LIST)
837 : : return false;
838 : 623605 : if (!TREE_VALUE (TREE_VALUE (attr)))
839 : : return false;
840 : :
841 : 623605 : return (TREE_CODE (TREE_VALUE (TREE_VALUE (attr))) == PRECONDITION_STMT
842 : 613012 : || TREE_CODE (TREE_VALUE (TREE_VALUE (attr))) == POSTCONDITION_STMT
843 : 1235104 : || TREE_CODE (TREE_VALUE (TREE_VALUE (attr))) == ASSERTION_STMT);
844 : : }
845 : :
846 : : /* True if ATTR is an assertion. */
847 : :
848 : : bool
849 : 382888813 : cp_contract_assertion_p (const_tree attr)
850 : : {
851 : : /* This is only an assertion if it is a valid cxx contract attribute and the
852 : : statement is an ASSERTION_STMT. */
853 : 382888813 : return cxx_contract_attribute_p (attr)
854 : 382889117 : && TREE_CODE (CONTRACT_STATEMENT (attr)) == ASSERTION_STMT;
855 : : }
856 : :
857 : : /* Remove all c++2a style contract attributes from the DECL_ATTRIBUTEs of the
858 : : FUNCTION_DECL FNDECL. */
859 : :
860 : : void
861 : 4891022 : remove_contract_attributes (tree fndecl)
862 : : {
863 : 4891022 : tree list = NULL_TREE;
864 : 5113066 : for (tree p = DECL_ATTRIBUTES (fndecl); p; p = TREE_CHAIN (p))
865 : 222044 : if (!cxx_contract_attribute_p (p))
866 : 221746 : list = tree_cons (TREE_PURPOSE (p), TREE_VALUE (p), list);
867 : 4891022 : DECL_ATTRIBUTES (fndecl) = nreverse (list);
868 : 4891022 : }
869 : :
870 : 0 : static tree find_first_non_contract (tree attributes)
871 : : {
872 : 0 : tree head = attributes;
873 : 0 : tree p = find_contract (attributes);
874 : :
875 : : /* There are no contracts. */
876 : 0 : if (!p)
877 : : return head;
878 : :
879 : : /* There are leading contracts. */
880 : 0 : if (p == head)
881 : : {
882 : 0 : while (cxx_contract_attribute_p (p))
883 : 0 : p = TREE_CHAIN (p);
884 : : head = p;
885 : : }
886 : :
887 : : return head;
888 : : }
889 : :
890 : : /* Remove contracts from ATTRIBUTES. */
891 : :
892 : 0 : tree splice_out_contracts (tree attributes)
893 : : {
894 : 0 : tree head = find_first_non_contract (attributes);
895 : 0 : if (!head)
896 : : return NULL_TREE;
897 : :
898 : : /* Splice out remaining contracts. */
899 : 0 : tree p = TREE_CHAIN (head);
900 : 0 : tree q = head;
901 : 0 : while (p)
902 : : {
903 : 0 : if (cxx_contract_attribute_p (p))
904 : : {
905 : : /* Skip a sequence of contracts and then link q to the next
906 : : non-contract attribute. */
907 : 0 : do
908 : 0 : p = TREE_CHAIN (p);
909 : 0 : while (cxx_contract_attribute_p (p));
910 : 0 : TREE_CHAIN (q) = p;
911 : : }
912 : : else
913 : 0 : p = TREE_CHAIN (p);
914 : : }
915 : :
916 : : return head;
917 : : }
918 : :
919 : : /* Copy contract attributes from NEWDECL onto the attribute list of OLDDECL. */
920 : :
921 : 8616442 : void copy_contract_attributes (tree olddecl, tree newdecl)
922 : : {
923 : 8616442 : tree attrs = NULL_TREE;
924 : 8616755 : for (tree c = DECL_CONTRACTS (newdecl); c; c = TREE_CHAIN (c))
925 : : {
926 : 313 : if (!cxx_contract_attribute_p (c))
927 : 1 : continue;
928 : 312 : attrs = tree_cons (TREE_PURPOSE (c), TREE_VALUE (c), attrs);
929 : : }
930 : 8616442 : attrs = chainon (DECL_ATTRIBUTES (olddecl), nreverse (attrs));
931 : 8616442 : DECL_ATTRIBUTES (olddecl) = attrs;
932 : :
933 : : /* And update DECL_CONTEXT of the postcondition result identifier. */
934 : 8616442 : rebuild_postconditions (olddecl);
935 : 8616442 : }
936 : :
937 : : /* Returns the parameter corresponding to the return value of a guarded
938 : : function D. Returns NULL_TREE if D has no postconditions or is void. */
939 : :
940 : : static tree
941 : 72 : get_postcondition_result_parameter (tree d)
942 : : {
943 : 72 : if (!d || d == error_mark_node)
944 : : return NULL_TREE;
945 : :
946 : 72 : if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (d))))
947 : : return NULL_TREE;
948 : :
949 : 64 : tree post = DECL_POST_FN (d);
950 : 64 : if (!post || post == error_mark_node)
951 : : return NULL_TREE;
952 : :
953 : 126 : for (tree arg = DECL_ARGUMENTS (post); arg; arg = TREE_CHAIN (arg))
954 : 126 : if (!TREE_CHAIN (arg))
955 : : return arg;
956 : :
957 : : return NULL_TREE;
958 : : }
959 : :
960 : :
961 : : /* For use with the tree inliner. This preserves non-mapped local variables,
962 : : such as postcondition result variables, during remapping. */
963 : :
964 : : static tree
965 : 1 : retain_decl (tree decl, copy_body_data *)
966 : : {
967 : 1 : return decl;
968 : : }
969 : :
970 : : /* Rewrite the condition of contract in place, so that references to SRC's
971 : : parameters are updated to refer to DST's parameters. The postcondition
972 : : result variable is left unchanged.
973 : :
974 : : This, along with remap_contracts, are subroutines of duplicate_decls.
975 : : When declarations are merged, we sometimes need to update contracts to
976 : : refer to new parameters.
977 : :
978 : : If DUPLICATE_P is true, this is called by duplicate_decls to rewrite contacts
979 : : in terms of a new set of parameters. In this case, we can retain local
980 : : variables appearing in the contract because the contract is not being
981 : : prepared for insertion into a new function. Importantly, this preserves the
982 : : references to postcondition results, which are not replaced during merging.
983 : :
984 : : If false, we're preparing to emit the contract condition into the body
985 : : of a new function, so we need to make copies of all local variables
986 : : appearing in the contract (e.g., if it includes a lambda expression). Note
987 : : that in this case, postcondition results are mapped to the last parameter
988 : : of DST.
989 : :
990 : : This is also used to reuse a parent type's contracts on virtual methods. */
991 : :
992 : : static void
993 : 751 : remap_contract (tree src, tree dst, tree contract, bool duplicate_p)
994 : : {
995 : 751 : copy_body_data id;
996 : 751 : hash_map<tree, tree> decl_map;
997 : :
998 : 751 : memset (&id, 0, sizeof (id));
999 : 751 : id.src_fn = src;
1000 : 751 : id.dst_fn = dst;
1001 : 751 : id.src_cfun = DECL_STRUCT_FUNCTION (src);
1002 : 751 : id.decl_map = &decl_map;
1003 : :
1004 : : /* If we're merging contracts, don't copy local variables. */
1005 : 751 : id.copy_decl = duplicate_p ? retain_decl : copy_decl_no_change;
1006 : :
1007 : 751 : id.transform_call_graph_edges = CB_CGE_DUPLICATE;
1008 : 751 : id.transform_new_cfg = false;
1009 : 751 : id.transform_return_to_modify = false;
1010 : 751 : id.transform_parameter = true;
1011 : :
1012 : : /* Make sure not to unshare trees behind the front-end's back
1013 : : since front-end specific mechanisms may rely on sharing. */
1014 : 751 : id.regimplify = false;
1015 : 751 : id.do_not_unshare = true;
1016 : 751 : id.do_not_fold = true;
1017 : :
1018 : : /* We're not inside any EH region. */
1019 : 751 : id.eh_lp_nr = 0;
1020 : :
1021 : 751 : bool do_remap = false;
1022 : :
1023 : : /* Insert parameter remappings. */
1024 : 751 : if (TREE_CODE (src) == FUNCTION_DECL)
1025 : 751 : src = DECL_ARGUMENTS (src);
1026 : 751 : if (TREE_CODE (dst) == FUNCTION_DECL)
1027 : 751 : dst = DECL_ARGUMENTS (dst);
1028 : :
1029 : : for (tree sp = src, dp = dst;
1030 : 2094 : sp || dp;
1031 : 1343 : sp = DECL_CHAIN (sp), dp = DECL_CHAIN (dp))
1032 : : {
1033 : 1414 : if (!sp && dp
1034 : 71 : && TREE_CODE (contract) == POSTCONDITION_STMT
1035 : 1485 : && DECL_CHAIN (dp) == NULL_TREE)
1036 : : {
1037 : 71 : gcc_assert (!duplicate_p);
1038 : 71 : if (tree result = POSTCONDITION_IDENTIFIER (contract))
1039 : : {
1040 : 64 : gcc_assert (DECL_P (result));
1041 : 64 : insert_decl_map (&id, result, dp);
1042 : 64 : do_remap = true;
1043 : : }
1044 : : break;
1045 : : }
1046 : 1343 : gcc_assert (sp && dp);
1047 : :
1048 : 1343 : if (sp == dp)
1049 : 0 : continue;
1050 : :
1051 : 1343 : insert_decl_map (&id, sp, dp);
1052 : 1343 : do_remap = true;
1053 : : }
1054 : 751 : if (!do_remap)
1055 : 22 : return;
1056 : :
1057 : 729 : walk_tree (&CONTRACT_CONDITION (contract), copy_tree_body_r, &id, NULL);
1058 : 751 : }
1059 : :
1060 : : /* Rewrite any references to SRC's PARM_DECLs to the corresponding PARM_DECL in
1061 : : DST in all of the contract attributes in CONTRACTS by calling remap_contract
1062 : : on each.
1063 : :
1064 : : This is used for two purposes: to rewrite contract attributes during
1065 : : duplicate_decls, and to prepare contracts for emission into a function's
1066 : : respective precondition and postcondition functions. DUPLICATE_P is used
1067 : : to determine the context in which this function is called. See above for
1068 : : the behavior described by this flag. */
1069 : :
1070 : : void
1071 : 161 : remap_contracts (tree src, tree dst, tree contracts, bool duplicate_p)
1072 : : {
1073 : 391 : for (tree attr = contracts; attr; attr = CONTRACT_CHAIN (attr))
1074 : : {
1075 : 230 : if (!cxx_contract_attribute_p (attr))
1076 : 0 : continue;
1077 : 230 : tree contract = CONTRACT_STATEMENT (attr);
1078 : 230 : if (TREE_CODE (CONTRACT_CONDITION (contract)) != DEFERRED_PARSE)
1079 : 223 : remap_contract (src, dst, contract, duplicate_p);
1080 : : }
1081 : 161 : }
1082 : :
1083 : : /* Helper to replace references to dummy this parameters with references to
1084 : : the first argument of the FUNCTION_DECL DATA. */
1085 : :
1086 : : static tree
1087 : 2516 : remap_dummy_this_1 (tree *tp, int *, void *data)
1088 : : {
1089 : 2516 : if (!is_this_parameter (*tp))
1090 : : return NULL_TREE;
1091 : 47 : tree fn = (tree)data;
1092 : 47 : *tp = DECL_ARGUMENTS (fn);
1093 : 47 : return NULL_TREE;
1094 : : }
1095 : :
1096 : : /* Replace all references to dummy this parameters in EXPR with references to
1097 : : the first argument of the FUNCTION_DECL FN. */
1098 : :
1099 : : static void
1100 : 722 : remap_dummy_this (tree fn, tree *expr)
1101 : : {
1102 : 0 : walk_tree (expr, remap_dummy_this_1, fn, NULL);
1103 : 0 : }
1104 : :
1105 : : /* Contract matching. */
1106 : :
1107 : : /* True if the contract is valid. */
1108 : :
1109 : : static bool
1110 : 224 : contract_valid_p (tree contract)
1111 : : {
1112 : 224 : return CONTRACT_CONDITION (contract) != error_mark_node;
1113 : : }
1114 : :
1115 : : /* True if the contract attribute is valid. */
1116 : :
1117 : : static bool
1118 : 224 : contract_attribute_valid_p (tree attribute)
1119 : : {
1120 : 224 : return contract_valid_p (TREE_VALUE (TREE_VALUE (attribute)));
1121 : : }
1122 : :
1123 : : /* Compare the contract conditions of OLD_ATTR and NEW_ATTR. Returns false
1124 : : if the conditions are equivalent, and true otherwise. */
1125 : :
1126 : : static bool
1127 : 109 : check_for_mismatched_contracts (tree old_attr, tree new_attr,
1128 : : contract_matching_context ctx)
1129 : : {
1130 : 109 : tree old_contract = CONTRACT_STATEMENT (old_attr);
1131 : 109 : tree new_contract = CONTRACT_STATEMENT (new_attr);
1132 : :
1133 : : /* Different kinds of contracts do not match. */
1134 : 109 : if (TREE_CODE (old_contract) != TREE_CODE (new_contract))
1135 : : {
1136 : 0 : auto_diagnostic_group d;
1137 : 0 : error_at (EXPR_LOCATION (new_contract),
1138 : : ctx == cmc_declaration
1139 : : ? "mismatched contract attribute in declaration"
1140 : : : "mismatched contract attribute in override");
1141 : 0 : inform (EXPR_LOCATION (old_contract), "previous contract here");
1142 : 0 : return true;
1143 : 0 : }
1144 : :
1145 : : /* A deferred contract tentatively matches. */
1146 : 109 : if (CONTRACT_CONDITION_DEFERRED_P (new_contract))
1147 : : return false;
1148 : :
1149 : : /* Compare the conditions of the contracts. We fold immediately to avoid
1150 : : issues comparing contracts on overrides that use parameters -- see
1151 : : contracts-pre3. */
1152 : 105 : tree t1 = cp_fully_fold_init (CONTRACT_CONDITION (old_contract));
1153 : 105 : tree t2 = cp_fully_fold_init (CONTRACT_CONDITION (new_contract));
1154 : :
1155 : : /* Compare the contracts. The fold doesn't eliminate conversions to members.
1156 : : Set the comparing_override_contracts flag to ensure that references
1157 : : through 'this' are equal if they designate the same member, regardless of
1158 : : the path those members. */
1159 : 105 : bool saved_comparing_contracts = comparing_override_contracts;
1160 : 105 : comparing_override_contracts = (ctx == cmc_override);
1161 : 105 : bool matching_p = cp_tree_equal (t1, t2);
1162 : 105 : comparing_override_contracts = saved_comparing_contracts;
1163 : :
1164 : 105 : if (!matching_p)
1165 : : {
1166 : 14 : auto_diagnostic_group d;
1167 : 22 : error_at (EXPR_LOCATION (CONTRACT_CONDITION (new_contract)),
1168 : : ctx == cmc_declaration
1169 : : ? "mismatched contract condition in declaration"
1170 : : : "mismatched contract condition in override");
1171 : 14 : inform (EXPR_LOCATION (CONTRACT_CONDITION (old_contract)),
1172 : : "previous contract here");
1173 : 14 : return true;
1174 : 14 : }
1175 : :
1176 : : return false;
1177 : : }
1178 : :
1179 : : /* Compare the contract attributes of OLDDECL and NEWDECL. Returns true
1180 : : if the contracts match, and false if they differ. */
1181 : :
1182 : : bool
1183 : 88 : match_contract_conditions (location_t oldloc, tree old_attrs,
1184 : : location_t newloc, tree new_attrs,
1185 : : contract_matching_context ctx)
1186 : : {
1187 : : /* Contracts only match if they are both specified. */
1188 : 88 : if (!old_attrs || !new_attrs)
1189 : : return true;
1190 : :
1191 : : /* Compare each contract in turn. */
1192 : 183 : while (old_attrs && new_attrs)
1193 : : {
1194 : : /* If either contract is ill-formed, skip the rest of the comparison,
1195 : : since we've already diagnosed an error. */
1196 : 115 : if (!contract_attribute_valid_p (new_attrs)
1197 : 115 : || !contract_attribute_valid_p (old_attrs))
1198 : : return false;
1199 : :
1200 : 109 : if (check_for_mismatched_contracts (old_attrs, new_attrs, ctx))
1201 : : return false;
1202 : 95 : old_attrs = CONTRACT_CHAIN (old_attrs);
1203 : 95 : new_attrs = CONTRACT_CHAIN (new_attrs);
1204 : : }
1205 : :
1206 : : /* If we didn't compare all attributes, the contracts don't match. */
1207 : 68 : if (old_attrs || new_attrs)
1208 : : {
1209 : 4 : auto_diagnostic_group d;
1210 : 4 : error_at (newloc,
1211 : : ctx == cmc_declaration
1212 : : ? "declaration has a different number of contracts than "
1213 : : "previously declared"
1214 : : : "override has a different number of contracts than "
1215 : : "previously declared");
1216 : 5 : inform (oldloc,
1217 : : new_attrs
1218 : : ? "original declaration with fewer contracts here"
1219 : : : "original declaration with more contracts here");
1220 : 4 : return false;
1221 : 4 : }
1222 : :
1223 : : return true;
1224 : : }
1225 : :
1226 : : /* Deferred contract mapping.
1227 : :
1228 : : This is used to compare late-parsed contracts on overrides with their
1229 : : base class functions.
1230 : :
1231 : : TODO: It seems like this could be replaced by a simple list that maps from
1232 : : overrides to their base functions. It's not clear that we really need
1233 : : a map to a function + a list of contracts. */
1234 : :
1235 : : /* Map from FNDECL to a tree list of contracts that have not been matched or
1236 : : diagnosed yet. The TREE_PURPOSE is the basefn we're overriding, and the
1237 : : TREE_VALUE is the list of contract attrs for BASEFN. */
1238 : :
1239 : : static hash_map<tree_decl_hash, tree> pending_guarded_decls;
1240 : :
1241 : : void
1242 : 24 : defer_guarded_contract_match (tree fndecl, tree fn, tree contracts)
1243 : : {
1244 : 24 : if (!pending_guarded_decls.get (fndecl))
1245 : : {
1246 : 21 : pending_guarded_decls.put (fndecl, build_tree_list (fn, contracts));
1247 : 21 : return;
1248 : : }
1249 : 3 : for (tree pending = *pending_guarded_decls.get (fndecl);
1250 : 6 : pending;
1251 : 3 : pending = TREE_CHAIN (pending))
1252 : : {
1253 : 6 : if (TREE_VALUE (pending) == contracts)
1254 : : return;
1255 : 3 : if (TREE_CHAIN (pending) == NULL_TREE)
1256 : 3 : TREE_CHAIN (pending) = build_tree_list (fn, contracts);
1257 : : }
1258 : : }
1259 : :
1260 : : /* If the FUNCTION_DECL DECL has any contracts that had their matching
1261 : : deferred earlier, do that checking now. */
1262 : :
1263 : : void
1264 : 163 : match_deferred_contracts (tree decl)
1265 : : {
1266 : 163 : tree *tp = pending_guarded_decls.get (decl);
1267 : 163 : if (!tp)
1268 : 163 : return;
1269 : :
1270 : 20 : gcc_assert(!contract_any_deferred_p (DECL_CONTRACTS (decl)));
1271 : :
1272 : 20 : processing_template_decl_sentinel ptds;
1273 : 20 : processing_template_decl = uses_template_parms (decl);
1274 : :
1275 : : /* Do late contract matching. */
1276 : 43 : for (tree pending = *tp; pending; pending = TREE_CHAIN (pending))
1277 : : {
1278 : 23 : tree new_contracts = TREE_VALUE (pending);
1279 : 23 : location_t new_loc = CONTRACT_SOURCE_LOCATION (new_contracts);
1280 : 23 : tree old_contracts = DECL_CONTRACTS (decl);
1281 : 23 : location_t old_loc = CONTRACT_SOURCE_LOCATION (old_contracts);
1282 : 23 : tree base = TREE_PURPOSE (pending);
1283 : 23 : match_contract_conditions (new_loc, new_contracts,
1284 : : old_loc, old_contracts,
1285 : : base ? cmc_override : cmc_declaration);
1286 : : }
1287 : :
1288 : : /* Clear out deferred match list so we don't check it twice. */
1289 : 20 : pending_guarded_decls.remove (decl);
1290 : 20 : }
1291 : :
1292 : : /* Map from FUNCTION_DECL to a FUNCTION_DECL for either the PRE_FN or POST_FN.
1293 : : These are used to parse contract conditions and are called inside the body
1294 : : of the guarded function. */
1295 : : static GTY(()) hash_map<tree, tree> *decl_pre_fn;
1296 : : static GTY(()) hash_map<tree, tree> *decl_post_fn;
1297 : :
1298 : : /* Returns the precondition funtion for D, or null if not set. */
1299 : :
1300 : : tree
1301 : 14955645 : get_precondition_function (tree d)
1302 : : {
1303 : 14955645 : hash_map_maybe_create<hm_ggc> (decl_pre_fn);
1304 : 14955645 : tree *result = decl_pre_fn->get (d);
1305 : 14955645 : return result ? *result : NULL_TREE;
1306 : : }
1307 : :
1308 : : /* Returns the postcondition funtion for D, or null if not set. */
1309 : :
1310 : : tree
1311 : 14954262 : get_postcondition_function (tree d)
1312 : : {
1313 : 14954262 : hash_map_maybe_create<hm_ggc> (decl_post_fn);
1314 : 14954262 : tree *result = decl_post_fn->get (d);
1315 : 14954262 : return result ? *result : NULL_TREE;
1316 : : }
1317 : :
1318 : : /* Makes PRE the precondition function for D. */
1319 : :
1320 : : void
1321 : 349 : set_precondition_function (tree d, tree pre)
1322 : : {
1323 : 349 : gcc_assert (pre);
1324 : 349 : hash_map_maybe_create<hm_ggc> (decl_pre_fn);
1325 : 349 : gcc_assert (!decl_pre_fn->get (d));
1326 : 349 : decl_pre_fn->put (d, pre);
1327 : 349 : }
1328 : :
1329 : : /* Makes POST the postcondition function for D. */
1330 : :
1331 : : void
1332 : 78 : set_postcondition_function (tree d, tree post)
1333 : : {
1334 : 78 : gcc_assert (post);
1335 : 78 : hash_map_maybe_create<hm_ggc> (decl_post_fn);
1336 : 78 : gcc_assert (!decl_post_fn->get (d));
1337 : 78 : decl_post_fn->put (d, post);
1338 : 78 : }
1339 : :
1340 : : /* Set the PRE and POST functions for D. Note that PRE and POST can be
1341 : : null in this case. If so the functions are not recorded. */
1342 : :
1343 : : void
1344 : 688148 : set_contract_functions (tree d, tree pre, tree post)
1345 : : {
1346 : 688148 : if (pre)
1347 : 349 : set_precondition_function (d, pre);
1348 : 688148 : if (post)
1349 : 71 : set_postcondition_function (d, post);
1350 : 688148 : }
1351 : :
1352 : : /* Return a copy of the FUNCTION_DECL IDECL with its own unshared
1353 : : PARM_DECL and DECL_ATTRIBUTEs. */
1354 : :
1355 : : static tree
1356 : 409 : copy_fn_decl (tree idecl)
1357 : : {
1358 : 409 : tree decl = copy_decl (idecl);
1359 : 409 : DECL_ATTRIBUTES (decl) = copy_list (DECL_ATTRIBUTES (idecl));
1360 : :
1361 : 409 : if (DECL_RESULT (idecl))
1362 : : {
1363 : 409 : DECL_RESULT (decl) = copy_decl (DECL_RESULT (idecl));
1364 : 409 : DECL_CONTEXT (DECL_RESULT (decl)) = decl;
1365 : : }
1366 : 409 : if (!DECL_ARGUMENTS (idecl) || VOID_TYPE_P (DECL_ARGUMENTS (idecl)))
1367 : : return decl;
1368 : :
1369 : 389 : tree last = DECL_ARGUMENTS (decl) = copy_decl (DECL_ARGUMENTS (decl));
1370 : 389 : DECL_CONTEXT (last) = decl;
1371 : 603 : for (tree p = TREE_CHAIN (DECL_ARGUMENTS (idecl)); p; p = TREE_CHAIN (p))
1372 : : {
1373 : 214 : if (VOID_TYPE_P (p))
1374 : : {
1375 : 0 : TREE_CHAIN (last) = void_list_node;
1376 : 0 : break;
1377 : : }
1378 : 214 : last = TREE_CHAIN (last) = copy_decl (p);
1379 : 214 : DECL_CONTEXT (last) = decl;
1380 : : }
1381 : : return decl;
1382 : : }
1383 : :
1384 : : /* Build a declaration for the pre- or postcondition of a guarded FNDECL. */
1385 : :
1386 : : static tree
1387 : 409 : build_contract_condition_function (tree fndecl, bool pre)
1388 : : {
1389 : 409 : if (TREE_TYPE (fndecl) == error_mark_node)
1390 : : return error_mark_node;
1391 : 409 : if (DECL_IOBJ_MEMBER_FUNCTION_P (fndecl)
1392 : 409 : && !TYPE_METHOD_BASETYPE (TREE_TYPE (fndecl)))
1393 : : return error_mark_node;
1394 : :
1395 : : /* Create and rename the unchecked function and give an internal name. */
1396 : 409 : tree fn = copy_fn_decl (fndecl);
1397 : 409 : DECL_RESULT (fn) = NULL_TREE;
1398 : 409 : tree value_type = pre ? void_type_node : TREE_TYPE (TREE_TYPE (fn));
1399 : :
1400 : : /* Don't propagate declaration attributes to the checking function,
1401 : : including the original contracts. */
1402 : 409 : DECL_ATTRIBUTES (fn) = NULL_TREE;
1403 : :
1404 : 409 : tree arg_types = NULL_TREE;
1405 : 409 : tree *last = &arg_types;
1406 : :
1407 : : /* FIXME will later optimizations delete unused args to prevent extra arg
1408 : : passing? do we care? */
1409 : 409 : tree class_type = NULL_TREE;
1410 : 409 : for (tree arg_type = TYPE_ARG_TYPES (TREE_TYPE (fn));
1411 : 1012 : arg_type && arg_type != void_list_node;
1412 : 603 : arg_type = TREE_CHAIN (arg_type))
1413 : : {
1414 : 603 : if (DECL_IOBJ_MEMBER_FUNCTION_P (fndecl)
1415 : 603 : && TYPE_ARG_TYPES (TREE_TYPE (fn)) == arg_type)
1416 : : {
1417 : 155 : class_type = TREE_TYPE (TREE_VALUE (arg_type));
1418 : 155 : continue;
1419 : : }
1420 : 448 : *last = build_tree_list (TREE_PURPOSE (arg_type), TREE_VALUE (arg_type));
1421 : 448 : last = &TREE_CHAIN (*last);
1422 : : }
1423 : :
1424 : 409 : if (pre || VOID_TYPE_P (value_type))
1425 : 345 : *last = void_list_node;
1426 : : else
1427 : : {
1428 : 64 : tree name = get_identifier ("__r");
1429 : 64 : tree parm = build_lang_decl (PARM_DECL, name, value_type);
1430 : 64 : DECL_CONTEXT (parm) = fn;
1431 : 64 : DECL_ARTIFICIAL (parm) = true;
1432 : 64 : DECL_ARGUMENTS (fn) = chainon (DECL_ARGUMENTS (fn), parm);
1433 : :
1434 : 64 : *last = build_tree_list (NULL_TREE, value_type);
1435 : 64 : TREE_CHAIN (*last) = void_list_node;
1436 : :
1437 : : /* The handler is a void return. */
1438 : 64 : value_type = void_type_node;
1439 : : }
1440 : :
1441 : 409 : TREE_TYPE (fn) = build_function_type (value_type, arg_types);
1442 : 409 : if (DECL_IOBJ_MEMBER_FUNCTION_P (fndecl))
1443 : 155 : TREE_TYPE (fn) = build_method_type (class_type, TREE_TYPE (fn));
1444 : :
1445 : 409 : DECL_NAME (fn) = copy_node (DECL_NAME (fn));
1446 : 409 : DECL_INITIAL (fn) = error_mark_node;
1447 : 409 : DECL_ABSTRACT_ORIGIN (fn) = fndecl;
1448 : :
1449 : 409 : IDENTIFIER_VIRTUAL_P (DECL_NAME (fn)) = false;
1450 : 409 : DECL_VIRTUAL_P (fn) = false;
1451 : :
1452 : : /* Make these functions internal if we can, i.e. if the guarded function is
1453 : : not vague linkage, or if we can put them in a comdat group with the
1454 : : guarded function. */
1455 : 409 : if (!DECL_WEAK (fndecl) || HAVE_COMDAT_GROUP)
1456 : : {
1457 : 409 : TREE_PUBLIC (fn) = false;
1458 : 409 : DECL_EXTERNAL (fn) = false;
1459 : 409 : DECL_WEAK (fn) = false;
1460 : 409 : DECL_COMDAT (fn) = false;
1461 : :
1462 : : /* We may not have set the comdat group on the guarded function yet.
1463 : : If we haven't, we'll add this to the same group in comdat_linkage
1464 : : later. Otherwise, add it to the same comdat group now. */
1465 : 409 : if (DECL_ONE_ONLY (fndecl))
1466 : : {
1467 : 4 : symtab_node *n = symtab_node::get (fndecl);
1468 : 4 : cgraph_node::get_create (fn)->add_to_same_comdat_group (n);
1469 : : }
1470 : :
1471 : 409 : DECL_INTERFACE_KNOWN (fn) = true;
1472 : : }
1473 : :
1474 : 409 : DECL_ARTIFICIAL (fn) = true;
1475 : :
1476 : : /* Update various inline related declaration properties. */
1477 : : //DECL_DECLARED_INLINE_P (fn) = true;
1478 : 409 : DECL_DISREGARD_INLINE_LIMITS (fn) = true;
1479 : 409 : TREE_NO_WARNING (fn) = 1;
1480 : :
1481 : 409 : return fn;
1482 : : }
1483 : :
1484 : : /* Return true if CONTRACT is checked or assumed under the current build
1485 : : configuration. */
1486 : :
1487 : : bool
1488 : 2175 : contract_active_p (tree contract)
1489 : : {
1490 : 2175 : return get_contract_semantic (contract) != CCS_IGNORE;
1491 : : }
1492 : :
1493 : : static bool
1494 : 611286 : has_active_contract_condition (tree d, tree_code c)
1495 : : {
1496 : 612323 : for (tree as = DECL_CONTRACTS (d) ; as != NULL_TREE; as = CONTRACT_CHAIN (as))
1497 : : {
1498 : 1941 : tree contract = TREE_VALUE (TREE_VALUE (as));
1499 : 1941 : if (TREE_CODE (contract) == c && contract_active_p (contract))
1500 : : return true;
1501 : : }
1502 : : return false;
1503 : : }
1504 : :
1505 : : /* True if D has any checked or assumed preconditions. */
1506 : :
1507 : : static bool
1508 : 783 : has_active_preconditions (tree d)
1509 : : {
1510 : 0 : return has_active_contract_condition (d, PRECONDITION_STMT);
1511 : : }
1512 : :
1513 : : /* True if D has any checked or assumed postconditions. */
1514 : :
1515 : : static bool
1516 : 610503 : has_active_postconditions (tree d)
1517 : : {
1518 : 0 : return has_active_contract_condition (d, POSTCONDITION_STMT);
1519 : : }
1520 : :
1521 : : /* Return true if any contract in the CONTRACT list is checked or assumed
1522 : : under the current build configuration. */
1523 : :
1524 : : bool
1525 : 21167 : contract_any_active_p (tree contract)
1526 : : {
1527 : 21185 : for (; contract != NULL_TREE; contract = CONTRACT_CHAIN (contract))
1528 : 1263 : if (contract_active_p (TREE_VALUE (TREE_VALUE (contract))))
1529 : : return true;
1530 : : return false;
1531 : : }
1532 : :
1533 : : /* Do we need to mess with contracts for DECL1? */
1534 : :
1535 : : static bool
1536 : 265298475 : handle_contracts_p (tree decl1)
1537 : : {
1538 : 265298475 : return (flag_contracts
1539 : 64307 : && !processing_template_decl
1540 : 27605 : && DECL_ABSTRACT_ORIGIN (decl1) == NULL_TREE
1541 : 265319642 : && contract_any_active_p (DECL_CONTRACTS (decl1)));
1542 : : }
1543 : :
1544 : : /* Should we break out DECL1's pre/post contracts into separate functions?
1545 : : FIXME I'd like this to default to 0, but that will need an overhaul to the
1546 : : return identifier handling to just refer to the RESULT_DECL. */
1547 : :
1548 : : static bool
1549 : 1679 : outline_contracts_p (tree decl1)
1550 : : {
1551 : 1679 : return (!DECL_CONSTRUCTOR_P (decl1)
1552 : 1679 : && !DECL_DESTRUCTOR_P (decl1));
1553 : : }
1554 : :
1555 : : /* Build the precondition checking function for D. */
1556 : :
1557 : : static tree
1558 : 368 : build_precondition_function (tree d)
1559 : : {
1560 : 368 : if (!has_active_preconditions (d))
1561 : : return NULL_TREE;
1562 : :
1563 : 337 : return build_contract_condition_function (d, /*pre=*/true);
1564 : : }
1565 : :
1566 : : /* Build the postcondition checking function for D. If the return
1567 : : type is undeduced, don't build the function yet. We do that in
1568 : : apply_deduced_return_type. */
1569 : :
1570 : : static tree
1571 : 375 : build_postcondition_function (tree d)
1572 : : {
1573 : 375 : if (!has_active_postconditions (d))
1574 : : return NULL_TREE;
1575 : :
1576 : 79 : tree type = TREE_TYPE (TREE_TYPE (d));
1577 : 79 : if (is_auto (type))
1578 : : return NULL_TREE;
1579 : :
1580 : 72 : return build_contract_condition_function (d, /*pre=*/false);
1581 : : }
1582 : :
1583 : : static void
1584 : 368 : build_contract_function_decls (tree d)
1585 : : {
1586 : : /* Constructors and destructors have their contracts inserted inline. */
1587 : 368 : if (!outline_contracts_p (d))
1588 : : return;
1589 : :
1590 : : /* Build the pre/post functions (or not). */
1591 : 368 : tree pre = build_precondition_function (d);
1592 : 368 : tree post = build_postcondition_function (d);
1593 : 368 : set_contract_functions (d, pre, post);
1594 : : }
1595 : :
1596 : : static const char *
1597 : 692 : get_contract_level_name (tree contract)
1598 : : {
1599 : 692 : if (CONTRACT_LITERAL_MODE_P (contract))
1600 : : return "";
1601 : 677 : if (tree mode = CONTRACT_MODE (contract))
1602 : 43 : if (tree level = TREE_VALUE (mode))
1603 : 43 : return IDENTIFIER_POINTER (level);
1604 : : return "default";
1605 : : }
1606 : :
1607 : : static const char *
1608 : 692 : get_contract_role_name (tree contract)
1609 : : {
1610 : 692 : if (CONTRACT_LITERAL_MODE_P (contract))
1611 : : return "";
1612 : 677 : if (tree mode = CONTRACT_MODE (contract))
1613 : 43 : if (tree role = TREE_PURPOSE (mode))
1614 : 24 : return IDENTIFIER_POINTER (role);
1615 : : return "default";
1616 : : }
1617 : :
1618 : : /* Build a layout-compatible internal version of std::contract_violation. */
1619 : :
1620 : : static tree
1621 : 692 : get_pseudo_contract_violation_type ()
1622 : : {
1623 : 692 : if (!pseudo_contract_violation_type)
1624 : : {
1625 : : /* Must match <contract>:
1626 : : class contract_violation {
1627 : : const char* _M_file;
1628 : : const char* _M_function;
1629 : : const char* _M_comment;
1630 : : const char* _M_level;
1631 : : const char* _M_role;
1632 : : uint_least32_t _M_line;
1633 : : signed char _M_continue;
1634 : : If this changes, also update the initializer in
1635 : : build_contract_violation. */
1636 : 112 : const tree types[] = { const_string_type_node,
1637 : : const_string_type_node,
1638 : : const_string_type_node,
1639 : : const_string_type_node,
1640 : : const_string_type_node,
1641 : 112 : uint_least32_type_node,
1642 : 112 : signed_char_type_node };
1643 : 112 : tree fields = NULL_TREE;
1644 : 896 : for (tree type : types)
1645 : : {
1646 : : /* finish_builtin_struct wants fieldss chained in reverse. */
1647 : 784 : tree next = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1648 : : NULL_TREE, type);
1649 : 784 : DECL_CHAIN (next) = fields;
1650 : 784 : fields = next;
1651 : : }
1652 : 112 : iloc_sentinel ils (input_location);
1653 : 112 : input_location = BUILTINS_LOCATION;
1654 : 112 : pseudo_contract_violation_type = make_class_type (RECORD_TYPE);
1655 : 112 : finish_builtin_struct (pseudo_contract_violation_type,
1656 : : "__pseudo_contract_violation",
1657 : : fields, NULL_TREE);
1658 : 224 : CLASSTYPE_AS_BASE (pseudo_contract_violation_type)
1659 : 112 : = pseudo_contract_violation_type;
1660 : 112 : DECL_CONTEXT (TYPE_NAME (pseudo_contract_violation_type))
1661 : 112 : = FROB_CONTEXT (global_namespace);
1662 : 112 : TREE_PUBLIC (TYPE_NAME (pseudo_contract_violation_type)) = true;
1663 : 112 : CLASSTYPE_LITERAL_P (pseudo_contract_violation_type) = true;
1664 : 112 : CLASSTYPE_LAZY_COPY_CTOR (pseudo_contract_violation_type) = true;
1665 : 112 : xref_basetypes (pseudo_contract_violation_type, /*bases=*/NULL_TREE);
1666 : 112 : pseudo_contract_violation_type
1667 : 112 : = cp_build_qualified_type (pseudo_contract_violation_type,
1668 : : TYPE_QUAL_CONST);
1669 : 112 : }
1670 : 692 : return pseudo_contract_violation_type;
1671 : : }
1672 : :
1673 : : /* Return a VAR_DECL to pass to handle_contract_violation. */
1674 : :
1675 : : static tree
1676 : 692 : build_contract_violation (tree contract, contract_continuation cmode)
1677 : : {
1678 : 692 : expanded_location loc = expand_location (EXPR_LOCATION (contract));
1679 : 880 : const char *function = fndecl_name (DECL_ORIGIN (current_function_decl));
1680 : 692 : const char *level = get_contract_level_name (contract);
1681 : 692 : const char *role = get_contract_role_name (contract);
1682 : :
1683 : : /* Must match the type layout in get_pseudo_contract_violation_type. */
1684 : 692 : tree ctor = build_constructor_va
1685 : 1384 : (init_list_type_node, 7,
1686 : : NULL_TREE, build_string_literal (loc.file),
1687 : : NULL_TREE, build_string_literal (function),
1688 : 692 : NULL_TREE, CONTRACT_COMMENT (contract),
1689 : : NULL_TREE, build_string_literal (level),
1690 : : NULL_TREE, build_string_literal (role),
1691 : 692 : NULL_TREE, build_int_cst (uint_least32_type_node, loc.line),
1692 : 692 : NULL_TREE, build_int_cst (signed_char_type_node, cmode));
1693 : :
1694 : 692 : ctor = finish_compound_literal (get_pseudo_contract_violation_type (),
1695 : : ctor, tf_none);
1696 : 692 : protected_set_expr_location (ctor, EXPR_LOCATION (contract));
1697 : 692 : return ctor;
1698 : : }
1699 : :
1700 : : /* Return handle_contract_violation(), declaring it if needed. */
1701 : :
1702 : : static tree
1703 : 692 : declare_handle_contract_violation ()
1704 : : {
1705 : 692 : tree fnname = get_identifier ("handle_contract_violation");
1706 : 692 : tree viol_name = get_identifier ("contract_violation");
1707 : 692 : tree l = lookup_qualified_name (global_namespace, fnname,
1708 : : LOOK_want::HIDDEN_FRIEND);
1709 : 775 : for (tree f: lkp_range (l))
1710 : 692 : if (TREE_CODE (f) == FUNCTION_DECL)
1711 : : {
1712 : 609 : tree parms = TYPE_ARG_TYPES (TREE_TYPE (f));
1713 : 609 : if (remaining_arguments (parms) != 1)
1714 : 0 : continue;
1715 : 609 : tree parmtype = non_reference (TREE_VALUE (parms));
1716 : 609 : if (CLASS_TYPE_P (parmtype)
1717 : 1218 : && TYPE_IDENTIFIER (parmtype) == viol_name)
1718 : 609 : return f;
1719 : : }
1720 : :
1721 : 83 : tree id_exp = get_identifier ("experimental");
1722 : 83 : tree ns_exp = lookup_qualified_name (std_node, id_exp);
1723 : :
1724 : 83 : tree violation = error_mark_node;
1725 : 83 : if (TREE_CODE (ns_exp) == NAMESPACE_DECL)
1726 : 0 : violation = lookup_qualified_name (ns_exp, viol_name,
1727 : : LOOK_want::TYPE
1728 : : |LOOK_want::HIDDEN_FRIEND);
1729 : :
1730 : 83 : if (TREE_CODE (violation) == TYPE_DECL)
1731 : 0 : violation = TREE_TYPE (violation);
1732 : : else
1733 : : {
1734 : 83 : push_nested_namespace (std_node);
1735 : 83 : push_namespace (id_exp, /*inline*/false);
1736 : 83 : violation = make_class_type (RECORD_TYPE);
1737 : 83 : create_implicit_typedef (viol_name, violation);
1738 : 83 : DECL_SOURCE_LOCATION (TYPE_NAME (violation)) = BUILTINS_LOCATION;
1739 : 83 : DECL_CONTEXT (TYPE_NAME (violation)) = current_namespace;
1740 : 83 : pushdecl_namespace_level (TYPE_NAME (violation), /*hidden*/true);
1741 : 83 : pop_namespace ();
1742 : 83 : pop_nested_namespace (std_node);
1743 : : }
1744 : :
1745 : 83 : tree argtype = cp_build_qualified_type (violation, TYPE_QUAL_CONST);
1746 : 83 : argtype = cp_build_reference_type (argtype, /*rval*/false);
1747 : 83 : tree fntype = build_function_type_list (void_type_node, argtype, NULL_TREE);
1748 : :
1749 : 83 : push_nested_namespace (global_namespace);
1750 : 83 : tree fn = build_cp_library_fn_ptr ("handle_contract_violation", fntype,
1751 : : ECF_COLD);
1752 : 83 : pushdecl_namespace_level (fn, /*hiding*/true);
1753 : 83 : pop_nested_namespace (global_namespace);
1754 : :
1755 : 83 : return fn;
1756 : : }
1757 : :
1758 : : /* Build the call to handle_contract_violation for CONTRACT. */
1759 : :
1760 : : static void
1761 : 692 : build_contract_handler_call (tree contract,
1762 : : contract_continuation cmode)
1763 : : {
1764 : 692 : tree violation = build_contract_violation (contract, cmode);
1765 : 692 : tree violation_fn = declare_handle_contract_violation ();
1766 : 692 : tree call = build_call_n (violation_fn, 1, build_address (violation));
1767 : 692 : finish_expr_stmt (call);
1768 : 692 : }
1769 : :
1770 : : /* Generate the code that checks or assumes a contract, but do not attach
1771 : : it to the current context. This is called during genericization. */
1772 : :
1773 : : tree
1774 : 752 : build_contract_check (tree contract)
1775 : : {
1776 : 752 : contract_semantic semantic = get_contract_semantic (contract);
1777 : 752 : if (semantic == CCS_INVALID)
1778 : : return NULL_TREE;
1779 : :
1780 : : /* Ignored contracts are never checked or assumed. */
1781 : 752 : if (semantic == CCS_IGNORE)
1782 : 30 : return void_node;
1783 : :
1784 : 722 : remap_dummy_this (current_function_decl, &CONTRACT_CONDITION (contract));
1785 : 722 : tree condition = CONTRACT_CONDITION (contract);
1786 : 722 : if (condition == error_mark_node)
1787 : : return NULL_TREE;
1788 : :
1789 : 722 : location_t loc = EXPR_LOCATION (contract);
1790 : :
1791 : 722 : if (semantic == CCS_ASSUME)
1792 : 30 : return build_assume_call (loc, condition);
1793 : :
1794 : 692 : tree if_stmt = begin_if_stmt ();
1795 : 692 : tree cond = build_x_unary_op (loc,
1796 : : TRUTH_NOT_EXPR,
1797 : : condition, NULL_TREE,
1798 : : tf_warning_or_error);
1799 : 692 : finish_if_stmt_cond (cond, if_stmt);
1800 : :
1801 : : /* Get the continuation mode. */
1802 : 692 : contract_continuation cmode;
1803 : 692 : switch (semantic)
1804 : : {
1805 : : case CCS_NEVER: cmode = NEVER_CONTINUE; break;
1806 : 468 : case CCS_MAYBE: cmode = MAYBE_CONTINUE; break;
1807 : 0 : default: gcc_unreachable ();
1808 : : }
1809 : :
1810 : 692 : build_contract_handler_call (contract, cmode);
1811 : 692 : if (cmode == NEVER_CONTINUE)
1812 : 224 : finish_expr_stmt (build_call_a (terminate_fn, 0, nullptr));
1813 : :
1814 : 692 : finish_then_clause (if_stmt);
1815 : 692 : tree scope = IF_SCOPE (if_stmt);
1816 : 692 : IF_SCOPE (if_stmt) = NULL;
1817 : 692 : return do_poplevel (scope);
1818 : : }
1819 : :
1820 : : /* Add the contract statement CONTRACT to the current block if valid. */
1821 : :
1822 : : static void
1823 : 749 : emit_contract_statement (tree contract)
1824 : : {
1825 : : /* Only add valid contracts. */
1826 : 749 : if (get_contract_semantic (contract) != CCS_INVALID
1827 : 749 : && CONTRACT_CONDITION (contract) != error_mark_node)
1828 : 747 : add_stmt (contract);
1829 : 749 : }
1830 : :
1831 : : /* Generate the statement for the given contract attribute by adding the
1832 : : statement to the current block. Returns the next contract in the chain. */
1833 : :
1834 : : static tree
1835 : 233 : emit_contract_attr (tree attr)
1836 : : {
1837 : 233 : gcc_assert (TREE_CODE (attr) == TREE_LIST);
1838 : :
1839 : 233 : emit_contract_statement (CONTRACT_STATEMENT (attr));
1840 : :
1841 : 233 : return CONTRACT_CHAIN (attr);
1842 : : }
1843 : :
1844 : : /* Add the statements of contract attributes ATTRS to the current block. */
1845 : :
1846 : : static void
1847 : 72 : emit_contract_conditions (tree attrs, tree_code code)
1848 : : {
1849 : 72 : if (!attrs) return;
1850 : 72 : gcc_assert (TREE_CODE (attrs) == TREE_LIST);
1851 : 72 : gcc_assert (code == PRECONDITION_STMT || code == POSTCONDITION_STMT);
1852 : 207 : while (attrs)
1853 : : {
1854 : 135 : tree contract = CONTRACT_STATEMENT (attrs);
1855 : 135 : if (TREE_CODE (contract) == code)
1856 : 82 : attrs = emit_contract_attr (attrs);
1857 : : else
1858 : 53 : attrs = CONTRACT_CHAIN (attrs);
1859 : : }
1860 : : }
1861 : :
1862 : : /* Emit the statement for an assertion attribute. */
1863 : :
1864 : : void
1865 : 151 : emit_assertion (tree attr)
1866 : : {
1867 : 151 : emit_contract_attr (attr);
1868 : 151 : }
1869 : :
1870 : : /* Emit statements for precondition attributes. */
1871 : :
1872 : : static void
1873 : 39 : emit_preconditions (tree attr)
1874 : : {
1875 : 0 : return emit_contract_conditions (attr, PRECONDITION_STMT);
1876 : : }
1877 : :
1878 : : /* Emit statements for postcondition attributes. */
1879 : :
1880 : : static void
1881 : 33 : emit_postconditions (tree attr)
1882 : : {
1883 : 0 : return emit_contract_conditions (attr, POSTCONDITION_STMT);
1884 : : }
1885 : :
1886 : : /* We're compiling the pre/postcondition function CONDFN; remap any FN
1887 : : attributes that match CODE and emit them. */
1888 : :
1889 : : static void
1890 : 399 : remap_and_emit_conditions (tree fn, tree condfn, tree_code code)
1891 : : {
1892 : 399 : gcc_assert (code == PRECONDITION_STMT || code == POSTCONDITION_STMT);
1893 : 1004 : for (tree attr = DECL_CONTRACTS (fn); attr;
1894 : 605 : attr = CONTRACT_CHAIN (attr))
1895 : : {
1896 : 605 : tree contract = CONTRACT_STATEMENT (attr);
1897 : 605 : if (TREE_CODE (contract) == code)
1898 : : {
1899 : 516 : contract = copy_node (contract);
1900 : 516 : remap_contract (fn, condfn, contract, /*duplicate_p=*/false);
1901 : 516 : emit_contract_statement (contract);
1902 : : }
1903 : : }
1904 : 399 : }
1905 : :
1906 : : /* Converts a contract condition to bool and ensures it has a locaiton. */
1907 : :
1908 : : tree
1909 : 880 : finish_contract_condition (cp_expr condition)
1910 : : {
1911 : : /* Ensure we have the condition location saved in case we later need to
1912 : : emit a conversion error during template instantiation and wouldn't
1913 : : otherwise have it. */
1914 : 880 : if (!CAN_HAVE_LOCATION_P (condition) || EXCEPTIONAL_CLASS_P (condition))
1915 : : {
1916 : 94 : condition = build1_loc (condition.get_location (), VIEW_CONVERT_EXPR,
1917 : 47 : TREE_TYPE (condition), condition);
1918 : 47 : EXPR_LOCATION_WRAPPER_P (condition) = 1;
1919 : : }
1920 : :
1921 : 880 : if (condition == error_mark_node || type_dependent_expression_p (condition))
1922 : : return condition;
1923 : :
1924 : 703 : return condition_conversion (condition);
1925 : : }
1926 : :
1927 : : void
1928 : 609713 : maybe_update_postconditions (tree fco)
1929 : : {
1930 : : /* Update any postconditions and the postcondition checking function
1931 : : as needed. If there are postconditions, we'll use those to rewrite
1932 : : return statements to check postconditions. */
1933 : 609713 : if (has_active_postconditions (fco))
1934 : : {
1935 : 7 : rebuild_postconditions (fco);
1936 : 7 : tree post = build_postcondition_function (fco);
1937 : 7 : set_postcondition_function (fco, post);
1938 : : }
1939 : 609713 : }
1940 : :
1941 : : /* Called on attribute lists that must not contain contracts. If any
1942 : : contracts are present, issue an error diagnostic and return true. */
1943 : :
1944 : : bool
1945 : 883987509 : diagnose_misapplied_contracts (tree attributes)
1946 : : {
1947 : 883987509 : if (attributes == NULL_TREE)
1948 : : return false;
1949 : :
1950 : 27331085 : tree contract_attr = find_contract (attributes);
1951 : 27331085 : if (!contract_attr)
1952 : : return false;
1953 : :
1954 : 17 : error_at (EXPR_LOCATION (CONTRACT_STATEMENT (contract_attr)),
1955 : : "contracts must appertain to a function type");
1956 : :
1957 : : /* Invalidate the contract so we don't treat it as valid later on. */
1958 : 17 : invalidate_contract (TREE_VALUE (TREE_VALUE (contract_attr)));
1959 : :
1960 : 17 : return true;
1961 : : }
1962 : :
1963 : : /* Build and return an argument list containing all the parameters of the
1964 : : (presumably guarded) FUNCTION_DECL FN. This can be used to forward all of
1965 : : FN's arguments to a function taking the same list of arguments -- namely
1966 : : the unchecked form of FN.
1967 : :
1968 : : We use CALL_FROM_THUNK_P instead of forward_parm for forwarding
1969 : : semantics. */
1970 : :
1971 : : static vec<tree, va_gc> *
1972 : 409 : build_arg_list (tree fn)
1973 : : {
1974 : 409 : vec<tree, va_gc> *args = make_tree_vector ();
1975 : 1012 : for (tree t = DECL_ARGUMENTS (fn); t; t = DECL_CHAIN (t))
1976 : 603 : vec_safe_push (args, t);
1977 : 409 : return args;
1978 : : }
1979 : :
1980 : : void
1981 : 132649046 : start_function_contracts (tree decl1)
1982 : : {
1983 : 132649046 : if (!handle_contracts_p (decl1))
1984 : : return;
1985 : :
1986 : : /* For cdtors, we evaluate the contracts check inline. */
1987 : 415 : if (!outline_contracts_p (decl1))
1988 : : return;
1989 : :
1990 : : /* Contracts may have just been added without a chance to parse them, though
1991 : : we still need the PRE_FN available to generate a call to it. */
1992 : 368 : if (!DECL_PRE_FN (decl1))
1993 : 368 : build_contract_function_decls (decl1);
1994 : :
1995 : : }
1996 : :
1997 : : /* If we have a precondition function and it's valid, call it. */
1998 : :
1999 : : static void
2000 : 337 : add_pre_condition_fn_call (tree fndecl)
2001 : : {
2002 : : /* If we're starting a guarded function with valid contracts, we need to
2003 : : insert a call to the pre function. */
2004 : 337 : gcc_checking_assert (DECL_PRE_FN (fndecl)
2005 : : && DECL_PRE_FN (fndecl) != error_mark_node);
2006 : :
2007 : 337 : releasing_vec args = build_arg_list (fndecl);
2008 : 337 : tree call = build_call_a (DECL_PRE_FN (fndecl), args->length (),
2009 : : args->address ());
2010 : 337 : CALL_FROM_THUNK_P (call) = true;
2011 : 337 : finish_expr_stmt (call);
2012 : 337 : }
2013 : :
2014 : : /* Build and add a call to the post-condition checking function, when that
2015 : : is in use. */
2016 : :
2017 : : static void
2018 : 72 : add_post_condition_fn_call (tree fndecl)
2019 : : {
2020 : 72 : gcc_checking_assert (DECL_POST_FN (fndecl)
2021 : : && DECL_POST_FN (fndecl) != error_mark_node);
2022 : :
2023 : 72 : releasing_vec args = build_arg_list (fndecl);
2024 : 72 : if (get_postcondition_result_parameter (fndecl))
2025 : 64 : vec_safe_push (args, DECL_RESULT (fndecl));
2026 : 72 : tree call = build_call_a (DECL_POST_FN (fndecl), args->length (),
2027 : : args->address ());
2028 : 72 : CALL_FROM_THUNK_P (call) = true;
2029 : 72 : finish_expr_stmt (call);
2030 : 72 : }
2031 : :
2032 : : /* Add a call or a direct evaluation of the pre checks. */
2033 : :
2034 : : static void
2035 : 376 : apply_preconditions (tree fndecl)
2036 : : {
2037 : 376 : if (outline_contracts_p (fndecl))
2038 : 337 : add_pre_condition_fn_call (fndecl);
2039 : : else
2040 : 39 : emit_preconditions (DECL_CONTRACTS (fndecl));
2041 : 376 : }
2042 : :
2043 : : /* Add a call or a direct evaluation of the post checks. */
2044 : :
2045 : : static void
2046 : 105 : apply_postconditions (tree fndecl)
2047 : : {
2048 : 105 : if (outline_contracts_p (fndecl))
2049 : 72 : add_post_condition_fn_call (fndecl);
2050 : : else
2051 : 33 : emit_postconditions (DECL_CONTRACTS (fndecl));
2052 : 105 : }
2053 : :
2054 : : /* Add contract handling to the function in FNDECL.
2055 : :
2056 : : When we have only pre-conditions, this simply prepends a call (or a direct
2057 : : evaluation, for cdtors) to the existing function body.
2058 : :
2059 : : When we have post conditions we build a try-finally block.
2060 : : If the function might throw then the handler in the try-finally is an
2061 : : EH_ELSE expression, where the post condition check is applied to the
2062 : : non-exceptional path, and an empty statement is added to the EH path. If
2063 : : the function has a non-throwing eh spec, then the handler is simply the
2064 : : post-condition checker. */
2065 : :
2066 : : void
2067 : 419 : maybe_apply_function_contracts (tree fndecl)
2068 : : {
2069 : 419 : if (!handle_contracts_p (fndecl))
2070 : : /* We did nothing and the original function body statement list will be
2071 : : popped by our caller. */
2072 : : return;
2073 : :
2074 : 415 : bool do_pre = has_active_preconditions (fndecl);
2075 : 415 : bool do_post = has_active_postconditions (fndecl);
2076 : : /* We should not have reached here with nothing to do... */
2077 : 415 : gcc_checking_assert (do_pre || do_post);
2078 : :
2079 : : /* This copies the approach used for function try blocks. */
2080 : 415 : tree fnbody = pop_stmt_list (DECL_SAVED_TREE (fndecl));
2081 : 415 : DECL_SAVED_TREE (fndecl) = push_stmt_list ();
2082 : 415 : tree compound_stmt = begin_compound_stmt (0);
2083 : 415 : current_binding_level->artificial = 1;
2084 : :
2085 : : /* Do not add locations for the synthesised code. */
2086 : 415 : location_t loc = UNKNOWN_LOCATION;
2087 : :
2088 : : /* For other cases, we call a function to process the check. */
2089 : :
2090 : : /* If we have a pre, but not a post, then just emit that and we are done. */
2091 : 415 : if (!do_post)
2092 : : {
2093 : 310 : apply_preconditions (fndecl);
2094 : 310 : add_stmt (fnbody);
2095 : 310 : finish_compound_stmt (compound_stmt);
2096 : 310 : return;
2097 : : }
2098 : :
2099 : 105 : if (do_pre)
2100 : : /* Add a precondition call, if we have one. */
2101 : 66 : apply_preconditions (fndecl);
2102 : 105 : tree try_fin = build_stmt (loc, TRY_FINALLY_EXPR, fnbody, NULL_TREE);
2103 : 105 : add_stmt (try_fin);
2104 : 105 : TREE_OPERAND (try_fin, 1) = push_stmt_list ();
2105 : : /* If we have exceptions, and a function that might throw, then add
2106 : : an EH_ELSE clause that allows the exception to propagate upwards
2107 : : without encountering the post-condition checks. */
2108 : 105 : if (flag_exceptions && !type_noexcept_p (TREE_TYPE (fndecl)))
2109 : : {
2110 : 96 : tree eh_else = build_stmt (loc, EH_ELSE_EXPR, NULL_TREE, NULL_TREE);
2111 : 96 : add_stmt (eh_else);
2112 : 96 : TREE_OPERAND (eh_else, 0) = push_stmt_list ();
2113 : 96 : apply_postconditions (fndecl);
2114 : 96 : TREE_OPERAND (eh_else, 0) = pop_stmt_list (TREE_OPERAND (eh_else, 0));
2115 : 96 : TREE_OPERAND (eh_else, 1) = build_empty_stmt (loc);
2116 : : }
2117 : : else
2118 : 9 : apply_postconditions (fndecl);
2119 : 105 : TREE_OPERAND (try_fin, 1) = pop_stmt_list (TREE_OPERAND (try_fin, 1));
2120 : 105 : finish_compound_stmt (compound_stmt);
2121 : : /* The DECL_SAVED_TREE stmt list will be popped by our caller. */
2122 : : }
2123 : :
2124 : : /* Finish up the pre & post function definitions for a guarded FNDECL,
2125 : : and compile those functions all the way to assembler language output. */
2126 : :
2127 : : void
2128 : 132649010 : finish_function_contracts (tree fndecl)
2129 : : {
2130 : 132649010 : if (!handle_contracts_p (fndecl)
2131 : 132649010 : || !outline_contracts_p (fndecl))
2132 : : return;
2133 : :
2134 : 884 : for (tree ca = DECL_CONTRACTS (fndecl); ca; ca = CONTRACT_CHAIN (ca))
2135 : : {
2136 : 526 : tree contract = CONTRACT_STATEMENT (ca);
2137 : 526 : if (!CONTRACT_CONDITION (contract)
2138 : 526 : || CONTRACT_CONDITION_DEFERRED_P (contract)
2139 : 1052 : || CONTRACT_CONDITION (contract) == error_mark_node)
2140 : : return;
2141 : : }
2142 : :
2143 : 358 : int flags = SF_DEFAULT | SF_PRE_PARSED;
2144 : :
2145 : : /* If either the pre or post functions are bad, don't bother emitting
2146 : : any contracts. The program is already ill-formed. */
2147 : 358 : tree pre = DECL_PRE_FN (fndecl);
2148 : 358 : tree post = DECL_POST_FN (fndecl);
2149 : 358 : if (pre == error_mark_node || post == error_mark_node)
2150 : : return;
2151 : :
2152 : 358 : if (pre && DECL_INITIAL (fndecl) != error_mark_node)
2153 : : {
2154 : 331 : DECL_PENDING_INLINE_P (pre) = false;
2155 : 331 : start_preparsed_function (pre, DECL_ATTRIBUTES (pre), flags);
2156 : 331 : remap_and_emit_conditions (fndecl, pre, PRECONDITION_STMT);
2157 : 331 : tree finished_pre = finish_function (false);
2158 : 331 : expand_or_defer_fn (finished_pre);
2159 : : }
2160 : :
2161 : 358 : if (post && DECL_INITIAL (fndecl) != error_mark_node)
2162 : : {
2163 : 68 : DECL_PENDING_INLINE_P (post) = false;
2164 : 68 : start_preparsed_function (post,
2165 : 68 : DECL_ATTRIBUTES (post),
2166 : : flags);
2167 : 68 : remap_and_emit_conditions (fndecl, post, POSTCONDITION_STMT);
2168 : 68 : if (!VOID_TYPE_P (TREE_TYPE (TREE_TYPE (post))))
2169 : 0 : finish_return_stmt (get_postcondition_result_parameter (fndecl));
2170 : :
2171 : 68 : tree finished_post = finish_function (false);
2172 : 68 : expand_or_defer_fn (finished_post);
2173 : : }
2174 : : }
2175 : :
2176 : :
2177 : : /* A subroutine of duplicate_decls. Diagnose issues in the redeclaration of
2178 : : guarded functions. */
2179 : :
2180 : : void
2181 : 16905556 : duplicate_contracts (tree newdecl, tree olddecl)
2182 : : {
2183 : 16905556 : if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2184 : 3397914 : newdecl = DECL_TEMPLATE_RESULT (newdecl);
2185 : 16905556 : if (TREE_CODE (olddecl) == TEMPLATE_DECL)
2186 : 3397914 : olddecl = DECL_TEMPLATE_RESULT (olddecl);
2187 : :
2188 : : /* Compare contracts to see if they match. */
2189 : 16905556 : tree old_contracts = DECL_CONTRACTS (olddecl);
2190 : 16905556 : tree new_contracts = DECL_CONTRACTS (newdecl);
2191 : :
2192 : 16905556 : if (!old_contracts && !new_contracts)
2193 : : return;
2194 : :
2195 : 197 : location_t old_loc = DECL_SOURCE_LOCATION (olddecl);
2196 : 197 : location_t new_loc = DECL_SOURCE_LOCATION (newdecl);
2197 : :
2198 : : /* If both declarations specify contracts, ensure they match.
2199 : :
2200 : : TODO: This handles a potential error a little oddly. Consider:
2201 : :
2202 : : struct B {
2203 : : virtual void f(int n) [[pre: n == 0]];
2204 : : };
2205 : : struct D : B {
2206 : : void f(int n) override; // inherits contracts
2207 : : };
2208 : : void D::f(int n) [[pre: n == 0]] // OK
2209 : : { }
2210 : :
2211 : : It's okay because we're explicitly restating the inherited contract.
2212 : : Changing the precondition on the definition D::f causes match_contracts
2213 : : to complain about the mismatch.
2214 : :
2215 : : This would previously have been diagnosed as adding contracts to an
2216 : : override, but this seems like it should be well-formed. */
2217 : 197 : if (old_contracts && new_contracts)
2218 : : {
2219 : 65 : if (!match_contract_conditions (old_loc, old_contracts,
2220 : : new_loc, new_contracts,
2221 : : cmc_declaration))
2222 : : return;
2223 : 55 : if (DECL_UNIQUE_FRIEND_P (newdecl))
2224 : : /* Newdecl's contracts are still DEFERRED_PARSE, and we're about to
2225 : : collapse it into olddecl, so stash away olddecl's contracts for
2226 : : later comparison. */
2227 : 4 : defer_guarded_contract_match (olddecl, olddecl, old_contracts);
2228 : : }
2229 : :
2230 : : /* Handle cases where contracts are omitted in one or the other
2231 : : declaration. */
2232 : 187 : if (old_contracts)
2233 : : {
2234 : : /* Contracts have been previously specified by are no omitted. The
2235 : : new declaration inherits the existing contracts. */
2236 : 127 : if (!new_contracts)
2237 : 72 : copy_contract_attributes (newdecl, olddecl);
2238 : :
2239 : : /* In all cases, remove existing contracts from OLDDECL to prevent the
2240 : : attribute merging function from adding excess contracts. */
2241 : 127 : remove_contract_attributes (olddecl);
2242 : : }
2243 : 60 : else if (!old_contracts)
2244 : : {
2245 : : /* We are adding contracts to a declaration. */
2246 : 60 : if (new_contracts)
2247 : : {
2248 : : /* We can't add to a previously defined function. */
2249 : 60 : if (DECL_INITIAL (olddecl))
2250 : : {
2251 : 4 : auto_diagnostic_group d;
2252 : 4 : error_at (new_loc, "cannot add contracts after definition");
2253 : 4 : inform (DECL_SOURCE_LOCATION (olddecl), "original definition here");
2254 : 4 : return;
2255 : 4 : }
2256 : :
2257 : : /* We can't add to an unguarded virtual function declaration. */
2258 : 56 : if (DECL_VIRTUAL_P (olddecl) && new_contracts)
2259 : : {
2260 : 3 : auto_diagnostic_group d;
2261 : 3 : error_at (new_loc, "cannot add contracts to a virtual function");
2262 : 3 : inform (DECL_SOURCE_LOCATION (olddecl), "original declaration here");
2263 : 3 : return;
2264 : 3 : }
2265 : :
2266 : : /* Depending on the "first declaration" rule, we may not be able
2267 : : to add contracts to a function after the fact. */
2268 : 53 : if (flag_contract_strict_declarations)
2269 : : {
2270 : 3 : warning_at (new_loc,
2271 : : OPT_fcontract_strict_declarations_,
2272 : : "declaration adds contracts to %q#D",
2273 : : olddecl);
2274 : 3 : return;
2275 : : }
2276 : :
2277 : : /* Copy the contracts from NEWDECL to OLDDECL. We shouldn't need to
2278 : : remap them because NEWDECL's parameters will replace those of
2279 : : OLDDECL. Remove the contracts from NEWDECL so they aren't
2280 : : cloned when merging. */
2281 : 50 : copy_contract_attributes (olddecl, newdecl);
2282 : 50 : remove_contract_attributes (newdecl);
2283 : : }
2284 : : }
2285 : : }
2286 : :
2287 : : /* Replace the any contract attributes on OVERRIDER with a copy where any
2288 : : references to BASEFN's PARM_DECLs have been rewritten to the corresponding
2289 : : PARM_DECL in OVERRIDER. */
2290 : :
2291 : : void
2292 : 12 : inherit_base_contracts (tree overrider, tree basefn)
2293 : : {
2294 : 12 : tree last = NULL_TREE, contract_attrs = NULL_TREE;
2295 : 12 : for (tree a = DECL_CONTRACTS (basefn);
2296 : 24 : a != NULL_TREE;
2297 : 12 : a = CONTRACT_CHAIN (a))
2298 : : {
2299 : 12 : tree c = copy_node (a);
2300 : 24 : TREE_VALUE (c) = build_tree_list (TREE_PURPOSE (TREE_VALUE (c)),
2301 : 12 : copy_node (CONTRACT_STATEMENT (c)));
2302 : :
2303 : 12 : tree src = basefn;
2304 : 12 : tree dst = overrider;
2305 : 12 : remap_contract (src, dst, CONTRACT_STATEMENT (c), /*duplicate_p=*/true);
2306 : :
2307 : 24 : CONTRACT_COMMENT (CONTRACT_STATEMENT (c)) =
2308 : 12 : copy_node (CONTRACT_COMMENT (CONTRACT_STATEMENT (c)));
2309 : :
2310 : 12 : chainon (last, c);
2311 : 12 : last = c;
2312 : 12 : if (!contract_attrs)
2313 : 12 : contract_attrs = c;
2314 : : }
2315 : :
2316 : 12 : set_decl_contracts (overrider, contract_attrs);
2317 : 12 : }
2318 : :
2319 : : #include "gt-cp-contracts.h"
|
