Merge pull request #31 from iains/contracts-nonattr-add-eval-semantic-opt

Contracts nonattr add eval semantic opt

Author: villevoutilainen

gcc/c-family/c.opt

@@ -1840,6 +1840,25 @@ fcontract-semantic=
 C++ Joined RejectNegative
 -fcontract-semantic=<level>:<semantic>	Specify the concrete semantics for level.
 
+Enum
+Name(p2900_semantic) Type(int)  UnknownError(unrecognized contract evaluation semantic %qs)
+
+EnumValue
+Enum(p2900_semantic) String(ignore) Value(1)
+
+EnumValue
+Enum(p2900_semantic) String(enforce) Value(3)
+
+EnumValue
+Enum(p2900_semantic) String(observe) Value(4)
+
+EnumValue
+Enum(p2900_semantic) String(quick_enforce) Value(5)
+
+fcontract-evaluation-semantic=
+C++ Joined RejectNegative Enum(p2900_semantic) Var(flag_contract_evaluation_semantic) Init (3)
+-fcontract-evaluation-semantic=[ignore,observe,enforce,quick_enforce]	Select the contract evaluation semantic (defaults to enforce).
+
 fcontract-disable-optimized-checks
 C++ Var(flag_contract_disable_optimized_checks) Init(0)
 -fcontract-disable-optimized-checks	Disable optimisation of contract checks.

gcc/cp/contracts.cc

@@ -146,6 +146,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "stor-layout.h"
 #include "intl.h"
 #include "cgraph.h"
+#include "opts.h"
 
 const int max_custom_roles = 32;
 static contract_role contract_build_roles[max_custom_roles] = {
@@ -761,8 +762,14 @@ grok_contract (tree attribute, tree mode, tree result, cp_expr condition,
   else
     contract = build4_loc (loc, code, type, mode, NULL_TREE, NULL_TREE, result);
 
-  /* Determine the concrete semantic.  */
-  set_contract_semantic (contract, compute_concrete_semantic (contract));
+  /* Determine the evaluation semantic:
+     First, apply the c++2a rules
+     FIXME: this is a convenience to avoid updating many tests.  */
+  contract_semantic semantic = compute_concrete_semantic (contract);
+  if (flag_contracts_nonattr
+      && OPTION_SET_P (flag_contract_evaluation_semantic))
+    semantic = static_cast<contract_semantic>(flag_contract_evaluation_semantic);
+  set_contract_semantic (contract, semantic);
 
   /* If the contract is deferred, don't do anything with the condition.  */
   if (TREE_CODE (condition) == DEFERRED_PARSE)
@@ -1881,13 +1888,22 @@ get_contract_role_name (tree contract)
 /* Build C++20 contract_violation layout compatible object. */
 
 static tree
-build_contract_violation_cpp20 (tree contract, contract_continuation cmode)
+build_contract_violation_cpp20 (tree contract)
 {
   expanded_location loc = expand_location (EXPR_LOCATION (contract));
   const char *function = fndecl_name (DECL_ORIGIN (current_function_decl));
   const char *level = get_contract_level_name (contract);
   const char *role = get_contract_role_name (contract);
 
+  /* Get the continuation mode.  */
+  contract_continuation cmode;
+  switch (get_contract_semantic (contract))
+    {
+    case CCS_NEVER: cmode = NEVER_CONTINUE; break;
+    case CCS_MAYBE: cmode = MAYBE_CONTINUE; break;
+    default: gcc_unreachable ();
+    }
+
   /* Must match the type layout in get_pseudo_contract_violation_type.  */
   tree ctor = build_constructor_va
     (init_list_type_node, 7,
@@ -1923,8 +1939,7 @@ get_contract_assertion_kind(tree contract)
   gcc_unreachable ();
 }
 
-/* Get constract_evaluation_semantic of the specified contract. Used when building
- P2900R7 contract_violation object. */
+/* Get contract_evaluation_semantic of the specified contract.  */
 static int
 get_evaluation_semantic(tree contract)
 {
@@ -1937,16 +1952,17 @@ get_evaluation_semantic(tree contract)
       return CES_OBSERVE;
     }
 
+  /* Used when building P2900R10 contract_violation object. Note that we do not
+     build such objects unless we are going to use them - so that we should not
+     get asked for 'ignore' or 'quick'.  */
   switch (semantic)
     {
       default:
 	gcc_unreachable ();
-      case CCS_MAYBE:
+      case CCS_OBSERVE:
 	return CES_OBSERVE;
-	break;
-      case CCS_NEVER:
+      case CCS_ENFORCE:
 	return CES_ENFORCE;
-	break;
     }
 }
 
@@ -1979,12 +1995,12 @@ build_contract_violation_P2900 (tree contract)
 /* Return a VAR_DECL to pass to handle_contract_violation.  */
 
 static tree
-build_contract_violation (tree contract, contract_continuation cmode)
+build_contract_violation (tree contract)
 {
   if (flag_contracts_nonattr)
     return build_contract_violation_P2900(contract);
 
-  return build_contract_violation_cpp20(contract, cmode);
+  return build_contract_violation_cpp20(contract);
 }
 
 /* Return handle_contract_violation(), declaring it if needed.  */
@@ -2054,10 +2070,9 @@ declare_handle_contract_violation ()
 /* Build the call to handle_contract_violation for CONTRACT.  */
 
 static void
-build_contract_handler_call (tree contract,
-			     contract_continuation cmode)
+build_contract_handler_call (tree contract)
 {
-  tree violation = build_contract_violation (contract, cmode);
+  tree violation = build_contract_violation (contract);
   tree violation_fn = declare_handle_contract_violation ();
   tree call = build_call_n (violation_fn, 1, build_address (violation));
   finish_expr_stmt (call);
@@ -2094,17 +2109,17 @@ build_contract_check (tree contract)
 				tf_warning_or_error);
   finish_if_stmt_cond (cond, if_stmt);
 
-  /* Get the continuation mode.  */
-  contract_continuation cmode;
-  switch (semantic)
+  /* Using the P2900 names here c++24 ENFORCE=NEVER, OBSERVE=MAYBE.  */
+  if (semantic == CCS_ENFORCE || semantic == CCS_OBSERVE)
+    build_contract_handler_call (contract);
+  if (semantic == CCS_QUICK)
     {
-    case CCS_NEVER: cmode = NEVER_CONTINUE; break;
-    case CCS_MAYBE: cmode = MAYBE_CONTINUE; break;
-    default: gcc_unreachable ();
+      tree fn = builtin_decl_explicit (BUILT_IN_ABORT);
+      releasing_vec vec;
+      finish_expr_stmt (finish_call_expr (fn, &vec, false, false,
+					  tf_warning_or_error));
     }
-
-  build_contract_handler_call (contract, cmode);
-  if (cmode == NEVER_CONTINUE)
+  else if (semantic == CCS_ENFORCE)
     finish_expr_stmt (build_call_a (terminate_fn, 0, nullptr));
 
   finish_then_clause (if_stmt);

gcc/cp/contracts.h

@@ -36,14 +36,16 @@ enum contract_level
 
 enum contract_semantic
 {
-  CCS_INVALID,
-  CCS_IGNORE,
-  CCS_ASSUME,
-  CCS_NEVER,
-  CCS_MAYBE
+  CCS_INVALID = 0,
+  CCS_IGNORE = 1,
+  CCS_ASSUME = 2,
+  CCS_NEVER = 3,
+  CCS_ENFORCE = CCS_NEVER,
+  CCS_MAYBE = 4,
+  CCS_OBSERVE = CCS_MAYBE,
+  CCS_QUICK = 5
 };
 
-
 /* True if the contract is unchecked.  */
 
 inline bool
@@ -86,14 +88,15 @@ enum constract_assertion_kind {
   CAK_ASSERT = 3
 };
 
-enum constract_evaluation_semantic {
+enum contract_evaluation_semantic {
   CES_INVALID = 0,
-  CES_ENFORCE = 1 ,
-  CES_OBSERVE = 2
+  CES_ENFORCE = 1,
+  CES_OBSERVE = 2,
+  CES_QUICK = 3
 };
 
 enum constract_detection_mode {
-  CDM_PREDICATE_FALSE = 1 ,
+  CDM_PREDICATE_FALSE = 1,
   CDM_EVAL_EXCEPTION = 2
 };