C front-end: refactor type checking __builtin_*_overflow

Move the implementation to a method of its own. This avoids repeatedly
testing the name to derive the underlying arithmetic operation. This
change is to support upcoming extensions to handle further built-ins via
this code path. No changes in behaviour intended with just this commit,
and additional testing should ensure that this is also true for error
handling.

The function refactored from remains too large, and cpplint rightly
complains about that, but this issue cannot be fixed in a single commit.
Hence, adding an override.

Author: tautschnig

regression/cbmc/gcc_builtin_add_overflow/type-conflict-2.desc

@@ -0,0 +1,6 @@
+CORE
+type-conflict.c
+
+line 14 function main: __builtin_add_overflow takes exactly 3 arguments, but 2 were provided$
+^EXIT=6$
+^SIGNAL=0$

regression/cbmc/gcc_builtin_add_overflow/type-conflict.c

@@ -0,0 +1,15 @@
+#include <assert.h>
+
+#ifndef __GNUC__
+_Bool __builtin_add_overflow();
+_Bool __builtin_add_overflow_p();
+#endif
+
+int main(void)
+{
+  int a, b, c, d, r;
+#ifdef CONFLICT1
+  assert(!__builtin_add_overflow(a, b, r));
+#endif
+  assert(__builtin_add_overflow(c, d));
+}

regression/cbmc/gcc_builtin_add_overflow/type-conflict.desc

@@ -0,0 +1,6 @@
+CORE
+type-conflict.c
+-DCONFLICT1
+line 12 function main: __builtin_add_overflow has signature __builtin_add_overflow\(integral, integral, integral\*\), but argument 3 \(r\) has type `signed int`$
+^EXIT=6$
+^SIGNAL=0$

src/ansi-c/c_typecheck_base.h

@@ -202,6 +202,9 @@ class c_typecheck_baset:
   virtual void typecheck_function_call_arguments(
     side_effect_expr_function_callt &expr);
   virtual exprt do_special_functions(side_effect_expr_function_callt &expr);
+  exprt typecheck_builtin_overflow(
+    side_effect_expr_function_callt &expr,
+    const irep_idt &arith_op);
   virtual optionalt<symbol_exprt> typecheck_gcc_polymorphic_builtin(
     const irep_idt &identifier,
     const exprt::operandst &arguments,

src/ansi-c/c_typecheck_expr.cpp

@@ -3170,76 +3170,88 @@ exprt c_typecheck_baset::do_special_functions(
   }
   else if(
     identifier == "__builtin_add_overflow" ||
+    identifier == "__builtin_add_overflow_p")
+  {
+    return typecheck_builtin_overflow(expr, ID_plus);
+  }
+  else if(
     identifier == "__builtin_sub_overflow" ||
+    identifier == "__builtin_sub_overflow_p")
+  {
+    return typecheck_builtin_overflow(expr, ID_minus);
+  }
+  else if(
     identifier == "__builtin_mul_overflow" ||
-    identifier == "__builtin_add_overflow_p" ||
-    identifier == "__builtin_sub_overflow_p" ||
     identifier == "__builtin_mul_overflow_p")
   {
-    // check function signature
-    if(expr.arguments().size() != 3)
-    {
-      std::ostringstream error_message;
-      error_message << expr.source_location().as_string() << ": " << identifier
-                    << " takes exactly 3 arguments, but "
-                    << expr.arguments().size() << " were provided";
-      throw invalid_source_file_exceptiont{error_message.str()};
-    }
+    return typecheck_builtin_overflow(expr, ID_mult);
+  }
+  else
+    return nil_exprt();
+  // NOLINTNEXTLINE(readability/fn_size)
+}
 
-    typecheck_function_call_arguments(expr);
+exprt c_typecheck_baset::typecheck_builtin_overflow(
+  side_effect_expr_function_callt &expr,
+  const irep_idt &arith_op)
+{
+  const irep_idt &identifier = to_symbol_expr(expr.function()).get_identifier();
 
-    auto lhs = expr.arguments()[0];
-    auto rhs = expr.arguments()[1];
-    auto result = expr.arguments()[2];
-
-    const bool is__p_variant = has_suffix(id2string(identifier), "_p");
-
-    {
-      auto const raise_wrong_argument_error =
-        [this, identifier](
-          const exprt &wrong_argument, std::size_t argument_number, bool _p) {
-          std::ostringstream error_message;
-          error_message << wrong_argument.source_location().as_string() << ": "
-                        << identifier << " has signature " << identifier
-                        << "(integral, integral, integral" << (_p ? "" : "*")
-                        << "), "
-                        << "but argument " << argument_number << " ("
-                        << expr2c(wrong_argument, *this) << ") has type `"
-                        << type2c(wrong_argument.type(), *this) << '`';
-          throw invalid_source_file_exceptiont{error_message.str()};
-        };
-      for(int arg_index = 0; arg_index <= (!is__p_variant ? 1 : 2); ++arg_index)
-      {
-        auto const &argument = expr.arguments()[arg_index];
+  // check function signature
+  if(expr.arguments().size() != 3)
+  {
+    std::ostringstream error_message;
+    error_message << expr.source_location().as_string() << ": " << identifier
+                  << " takes exactly 3 arguments, but "
+                  << expr.arguments().size() << " were provided";
+    throw invalid_source_file_exceptiont{error_message.str()};
+  }
 
-        if(!is_signed_or_unsigned_bitvector(argument.type()))
-        {
-          raise_wrong_argument_error(argument, arg_index + 1, is__p_variant);
-        }
-      }
-      if(
-        !is__p_variant &&
-        (result.type().id() != ID_pointer ||
-         !is_signed_or_unsigned_bitvector(result.type().subtype())))
+  typecheck_function_call_arguments(expr);
+
+  auto lhs = expr.arguments()[0];
+  auto rhs = expr.arguments()[1];
+  auto result = expr.arguments()[2];
+
+  const bool is__p_variant = has_suffix(id2string(identifier), "_p");
+
+  {
+    auto const raise_wrong_argument_error =
+      [this, identifier](
+        const exprt &wrong_argument, std::size_t argument_number, bool _p) {
+        std::ostringstream error_message;
+        error_message << wrong_argument.source_location().as_string() << ": "
+                      << identifier << " has signature " << identifier
+                      << "(integral, integral, integral" << (_p ? "" : "*")
+                      << "), "
+                      << "but argument " << argument_number << " ("
+                      << expr2c(wrong_argument, *this) << ") has type `"
+                      << type2c(wrong_argument.type(), *this) << '`';
+        throw invalid_source_file_exceptiont{error_message.str()};
+      };
+    for(int arg_index = 0; arg_index <= (!is__p_variant ? 1 : 2); ++arg_index)
+    {
+      auto const &argument = expr.arguments()[arg_index];
+
+      if(!is_signed_or_unsigned_bitvector(argument.type()))
       {
-        raise_wrong_argument_error(result, 3, is__p_variant);
+        raise_wrong_argument_error(argument, arg_index + 1, is__p_variant);
       }
     }
-
-    irep_idt kind =
-      has_prefix(id2string(identifier), "__builtin_add_overflow")
-        ? ID_plus
-        : has_prefix(id2string(identifier), "__builtin_sub_overflow") ? ID_minus
-                                                                      : ID_mult;
-
-    return side_effect_expr_overflowt{kind,
-                                      std::move(lhs),
-                                      std::move(rhs),
-                                      std::move(result),
-                                      expr.source_location()};
+    if(
+      !is__p_variant &&
+      (result.type().id() != ID_pointer ||
+       !is_signed_or_unsigned_bitvector(result.type().subtype())))
+    {
+      raise_wrong_argument_error(result, 3, is__p_variant);
+    }
   }
-  else
-    return nil_exprt();
+
+  return side_effect_expr_overflowt{arith_op,
+                                    std::move(lhs),
+                                    std::move(rhs),
+                                    std::move(result),
+                                    expr.source_location()};
 }
 
 /// Typecheck the parameters in a function call expression, and where