Merge #1408 #1503 #1511

1408: Experiment: add optional error codes to diagnostics r=CohenArthur a=davidmalcolm

rustc has error codes to identify specific errors, with URLs documenting each error.

In GCC 13 I've extended GCC's diagnostic subsystem so that a diagnostic can be associated with zero or more `diagnostic_metadata::rule` instances, which have a textual description and a URL.  I meant this for rules in coding standards and specifications, but it struck me that potentially gccrs could reuse the same error codes as rustc.

The following pull request implements an experimental form of this; I picked a single error at random: [E0054](https://doc.rust-lang.org/error-index.html#E0054).  

With this patch, gccrs emits e.g.:

```
bad_as_bool_char.rs:8:19: error: invalid cast [u8] to [bool] [E0054]
    8 |   let nb = 0u8 as bool;
      |            ~      ^

```
where the trailing [E0054] is colorized, and, in a suitably capable terminal is a clickable URL to https://doc.rust-lang.org/error-index.html#E0054.

The error code is after the diagnostic message, whereas rustc puts it after the word "error".  I could change that in gcc's diagnostic.cc, perhaps.

I'm not sure if this is a good idea (e.g. is it OK and maintainable to share error codes with rustc?), but thought it was worth sharing.


1503: Add overflow traps r=CohenArthur a=CohenArthur

Opening as a draft since the code is really ugly and some tests still fail. I am looking for feedback on the implementation and my approximative use of functions like `temporary_variable` which I feel I might be using the wrong way.

I'll open up an issue of what still needs to be done, namely:
- [x] Properly handle sub and mul operations
- [ ] Disable the check in `release` mode (`-frust-disable-overflow-checks`)
- [ ] Handle specific rust overflow attribute (needs checkup on the name)

I'll open up some PRs to clean up some parts of the backend as well.

1511: lint: Do not emit unused warnings for public items r=CohenArthur a=CohenArthur

This fixes the overzealous warnings on public items from the unused pass

Co-authored-by: David Malcolm <[email protected]>
Co-authored-by: Arthur Cohen <[email protected]>

Author: 3 people

.github/bors_log_expected_warnings

@@ -84,7 +84,7 @@
 ../../gcc/config/i386/i386.cc:2565:8: warning: too many arguments for format [-Wformat-extra-args]
 ../../gcc/config/i386/i386.cc:2565:8: warning: unknown conversion type character ‘{’ in format [-Wformat=]
 ../../gcc/config/i386/i386.cc:2565:8: warning: unknown conversion type character ‘}’ in format [-Wformat=]
-../../gcc/diagnostic.cc:2191:52: warning: format not a string literal and no format arguments [-Wformat-security]
+../../gcc/diagnostic.cc:2206:52: warning: format not a string literal and no format arguments [-Wformat-security]
 ../../gcc/doc/sourcebuild.texi:1452: warning: node `Add Options' is next for `Effective-Target Keywords' in menu but not in sectioning
 ../../gcc/doc/sourcebuild.texi:2946: warning: node `Effective-Target Keywords' is prev for `Add Options' in menu but not in sectioning
 ../../gcc/fold-const.cc:314:42: warning: format not a string literal and no format arguments [-Wformat-security]

gcc/diagnostic-core.h

@@ -92,6 +92,9 @@ extern void error_n (location_t, unsigned HOST_WIDE_INT, const char *,
 extern void error_at (location_t, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3);
 extern void error_at (rich_location *, const char *, ...)
   ATTRIBUTE_GCC_DIAG(2,3);
+extern void error_meta (rich_location *, const diagnostic_metadata &,
+			const char *, ...)
+  ATTRIBUTE_GCC_DIAG(3,4);
 extern void fatal_error (location_t, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3)
      ATTRIBUTE_NORETURN;
 /* Pass one of the OPT_W* from options.h as the second parameter.  */

gcc/diagnostic.cc

@@ -2050,6 +2050,21 @@ error_at (rich_location *richloc, const char *gmsgid, ...)
   va_end (ap);
 }
 
+/* Same as above, but with metadata.  */
+
+void
+error_meta (rich_location *richloc, const diagnostic_metadata &metadata,
+	    const char *gmsgid, ...)
+{
+  gcc_assert (richloc);
+
+  auto_diagnostic_group d;
+  va_list ap;
+  va_start (ap, gmsgid);
+  diagnostic_impl (richloc, &metadata, -1, gmsgid, &ap, DK_ERROR);
+  va_end (ap);
+}
+
 /* "Sorry, not implemented."  Use for a language feature which is
    required by the relevant specification but not implemented by GCC.
    An object file will not be produced.  */

gcc/rust/backend/rust-builtins.h

@@ -18,8 +18,9 @@
 #define RUST_BUILTINS_H
 
 #include "rust-system.h"
-#include "tree.h"
+#include "rust-tree.h"
 #include "langhooks.h"
+#include "tree.h"
 
 namespace Rust {
 namespace Compile {
@@ -99,16 +100,34 @@ class BuiltinsContext
 
   BuiltinsContext () { setup (); }
 
-  void setup ()
+  void setup_overflow_fns ()
+  {
+    tree overflow_type
+      = build_varargs_function_type_list (boolean_type_node, NULL_TREE);
+
+    define_builtin ("add_overflow", BUILT_IN_ADD_OVERFLOW,
+		    "__builtin_add_overflow", "add_overflow", overflow_type, 0);
+    define_builtin ("sub_overflow", BUILT_IN_SUB_OVERFLOW,
+		    "__builtin_sub_overflow", "sub_overflow", overflow_type, 0);
+    define_builtin ("mul_overflow", BUILT_IN_MUL_OVERFLOW,
+		    "__builtin_mul_overflow", "mul_overflow", overflow_type, 0);
+  }
+
+  void setup_math_fns ()
   {
     tree math_function_type_f32
       = build_function_type_list (float_type_node, float_type_node, NULL_TREE);
 
     define_builtin ("sinf32", BUILT_IN_SINF, "__builtin_sinf", "sinf",
 		    math_function_type_f32, builtin_const);
-
     define_builtin ("sqrtf32", BUILT_IN_SQRTF, "__builtin_sqrtf", "sqrtf",
 		    math_function_type_f32, builtin_const);
+  }
+
+  void setup ()
+  {
+    setup_math_fns ();
+    setup_overflow_fns ();
 
     define_builtin ("unreachable", BUILT_IN_UNREACHABLE,
 		    "__builtin_unreachable", NULL,
@@ -132,6 +151,16 @@ class BuiltinsContext
       0);
   }
 
+  static void handle_flags (tree decl, int flags)
+  {
+    if (flags & builtin_const)
+      TREE_READONLY (decl) = 1;
+    if (flags & builtin_noreturn)
+      TREE_READONLY (decl) = 1;
+    if (flags & builtin_novops)
+      DECL_IS_NOVOPS (decl) = 1;
+  }
+
   // Define a builtin function.  BCODE is the builtin function code
   // defined by builtins.def.  NAME is the name of the builtin function.
   // LIBNAME is the name of the corresponding library function, and is
@@ -144,24 +173,16 @@ class BuiltinsContext
   {
     tree decl = add_builtin_function (name, fntype, bcode, BUILT_IN_NORMAL,
 				      libname, NULL_TREE);
-    if ((flags & builtin_const) != 0)
-      TREE_READONLY (decl) = 1;
-    if ((flags & builtin_noreturn) != 0)
-      TREE_THIS_VOLATILE (decl) = 1;
-    if ((flags & builtin_novops) != 0)
-      DECL_IS_NOVOPS (decl) = 1;
+    handle_flags (decl, flags);
     set_builtin_decl (bcode, decl, true);
+
     this->builtin_functions_[name] = decl;
     if (libname != NULL)
       {
 	decl = add_builtin_function (libname, fntype, bcode, BUILT_IN_NORMAL,
 				     NULL, NULL_TREE);
-	if ((flags & builtin_const) != 0)
-	  TREE_READONLY (decl) = 1;
-	if ((flags & builtin_noreturn) != 0)
-	  TREE_THIS_VOLATILE (decl) = 1;
-	if ((flags & builtin_novops) != 0)
-	  DECL_IS_NOVOPS (decl) = 1;
+	handle_flags (decl, flags);
+
 	this->builtin_functions_[libname] = decl;
       }
 

gcc/rust/backend/rust-compile-expr.cc

@@ -26,6 +26,7 @@
 #include "rust-compile-block.h"
 #include "rust-compile-implitem.h"
 #include "rust-constexpr.h"
+#include "rust-gcc.h"
 
 #include "fold-const.h"
 #include "realmpfr.h"
@@ -146,9 +147,26 @@ CompileExpr::visit (HIR::ArithmeticOrLogicalExpr &expr)
       return;
     }
 
-  translated
-    = ctx->get_backend ()->arithmetic_or_logical_expression (op, lhs, rhs,
-							     expr.get_locus ());
+  if (ctx->in_fn () && !ctx->const_context_p ())
+    {
+      auto receiver_tmp = NULL_TREE;
+      auto receiver
+	= ctx->get_backend ()->temporary_variable (ctx->peek_fn ().fndecl,
+						   NULL_TREE, TREE_TYPE (lhs),
+						   lhs, true, expr.get_locus (),
+						   &receiver_tmp);
+      auto check
+	= ctx->get_backend ()->arithmetic_or_logical_expression_checked (
+	  op, lhs, rhs, expr.get_locus (), receiver);
+
+      ctx->add_statement (check);
+      translated = receiver->get_tree (expr.get_locus ());
+    }
+  else
+    {
+      translated = ctx->get_backend ()->arithmetic_or_logical_expression (
+	op, lhs, rhs, expr.get_locus ());
+    }
 }
 
 void
@@ -176,13 +194,27 @@ CompileExpr::visit (HIR::CompoundAssignmentExpr &expr)
       return;
     }
 
-  auto operator_expr
-    = ctx->get_backend ()->arithmetic_or_logical_expression (op, lhs, rhs,
-							     expr.get_locus ());
-  tree assignment
-    = ctx->get_backend ()->assignment_statement (lhs, operator_expr,
-						 expr.get_locus ());
-  ctx->add_statement (assignment);
+  if (ctx->in_fn () && !ctx->const_context_p ())
+    {
+      auto tmp = NULL_TREE;
+      auto receiver
+	= ctx->get_backend ()->temporary_variable (ctx->peek_fn ().fndecl,
+						   NULL_TREE, TREE_TYPE (lhs),
+						   lhs, true, expr.get_locus (),
+						   &tmp);
+      auto check
+	= ctx->get_backend ()->arithmetic_or_logical_expression_checked (
+	  op, lhs, rhs, expr.get_locus (), receiver);
+      ctx->add_statement (check);
+
+      translated = ctx->get_backend ()->assignment_statement (
+	lhs, receiver->get_tree (expr.get_locus ()), expr.get_locus ());
+    }
+  else
+    {
+      translated = ctx->get_backend ()->arithmetic_or_logical_expression (
+	op, lhs, rhs, expr.get_locus ());
+    }
 }
 
 void
@@ -2378,7 +2410,10 @@ CompileExpr::array_copied_expr (Location expr_locus,
       return error_mark_node;
     }
 
+  ctx->push_const_context ();
   tree capacity_expr = CompileExpr::Compile (elems.get_num_copies_expr (), ctx);
+  ctx->pop_const_context ();
+
   if (!TREE_CONSTANT (capacity_expr))
     {
       rust_error_at (expr_locus, "non const num copies %qT", array_type);

gcc/rust/backend/rust-compile-item.cc

@@ -160,6 +160,9 @@ CompileItem::visit (HIR::Function &function)
     function.get_mappings ().get_nodeid (), &canonical_path);
   rust_assert (ok);
 
+  if (function.get_qualifiers ().is_const ())
+    ctx->push_const_context ();
+
   tree fndecl
     = compile_function (ctx, function.get_function_name (),
 			function.get_self_param (),
@@ -169,6 +172,9 @@ CompileItem::visit (HIR::Function &function)
 			function.get_definition ().get (), canonical_path,
 			fntype, function.has_function_return_type ());
   reference = address_expression (fndecl, ref_locus);
+
+  if (function.get_qualifiers ().is_const ())
+    ctx->pop_const_context ();
 }
 
 void

gcc/rust/backend/rust-compile-type.cc

@@ -370,7 +370,11 @@ TyTyResolveCompile::visit (const TyTy::ArrayType &type)
 {
   tree element_type
     = TyTyResolveCompile::compile (ctx, type.get_element_type ());
+
+  ctx->push_const_context ();
   tree capacity_expr = CompileExpr::Compile (&type.get_capacity_expr (), ctx);
+  ctx->pop_const_context ();
+
   tree folded_capacity_expr = fold_expr (capacity_expr);
 
   translated

gcc/rust/checks/lints/rust-lint-scan-deadcode.h

@@ -53,7 +53,7 @@ class ScanDeadcode : public MarkLiveBase
   void visit (HIR::Function &function) override
   {
     HirId hirId = function.get_mappings ().get_hirid ();
-    if (should_warn (hirId))
+    if (should_warn (hirId) && !function.get_visibility ().is_public ())
       {
 	if (mappings->is_impl_item (hirId))
 	  {
@@ -78,7 +78,7 @@ class ScanDeadcode : public MarkLiveBase
   void visit (HIR::StructStruct &stct) override
   {
     HirId hirId = stct.get_mappings ().get_hirid ();
-    if (should_warn (hirId))
+    if (should_warn (hirId) && !stct.get_visibility ().is_public ())
       {
 	bool name_starts_underscore = stct.get_identifier ().at (0) == '_';
 	if (!name_starts_underscore)
@@ -92,7 +92,8 @@ class ScanDeadcode : public MarkLiveBase
 	for (auto &field : stct.get_fields ())
 	  {
 	    HirId field_hir_id = field.get_mappings ().get_hirid ();
-	    if (should_warn (field_hir_id))
+	    if (should_warn (field_hir_id)
+		&& !field.get_visibility ().is_public ())
 	      {
 		rust_warning_at (field.get_locus (), 0,
 				 "field is never read: %<%s%>",
@@ -106,7 +107,7 @@ class ScanDeadcode : public MarkLiveBase
   {
     // only warn tuple struct unconstructed, and ignoring unused field
     HirId hirId = stct.get_mappings ().get_hirid ();
-    if (should_warn (hirId))
+    if (should_warn (hirId) && !stct.get_visibility ().is_public ())
       {
 	rust_warning_at (stct.get_locus (), 0,
 			 "struct is never constructed: %<%s%>",

gcc/rust/rust-backend.h

@@ -235,13 +235,24 @@ class Backend
   // Supported values of OP are enumerated in ArithmeticOrLogicalOperator.
   virtual tree arithmetic_or_logical_expression (ArithmeticOrLogicalOperator op,
 						 tree left, tree right,
-						 Location)
+						 Location loc)
+    = 0;
+
+  // Return an expression for the operation LEFT OP RIGHT.
+  // Supported values of OP are enumerated in ArithmeticOrLogicalOperator.
+  // This function adds overflow checking and returns a list of statements to
+  // add to the current function context. The `receiver` variable refers to the
+  // variable which will contain the result of that operation.
+  virtual tree
+  arithmetic_or_logical_expression_checked (ArithmeticOrLogicalOperator op,
+					    tree left, tree right, Location loc,
+					    Bvariable *receiver)
     = 0;
 
   // Return an expression for the operation LEFT OP RIGHT.
   // Supported values of OP are enumerated in ComparisonOperator.
   virtual tree comparison_expression (ComparisonOperator op, tree left,
-				      tree right, Location)
+				      tree right, Location loc)
     = 0;
 
   // Return an expression for the operation LEFT OP RIGHT.
@@ -416,8 +427,8 @@ class Backend
   // variable, and may not be very useful.  This function should
   // return a variable which can be referenced later and should set
   // *PSTATEMENT to a statement which initializes the variable.
-  virtual Bvariable *temporary_variable (tree, tree, tree, tree init,
-					 bool address_is_taken,
+  virtual Bvariable *temporary_variable (tree fndecl, tree bind_tree, tree type,
+					 tree init, bool address_is_taken,
 					 Location location, tree *pstatement)
     = 0;
 

gcc/rust/rust-diagnostics.cc

@@ -166,6 +166,17 @@ rust_error_at (const Location location, const char *fmt, ...)
   va_end (ap);
 }
 
+void
+rust_error_at (const RichLocation &location, const ErrorCode code,
+	       const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start (ap, fmt);
+  rust_be_error_at (location, code, expand_message (fmt, ap));
+  va_end (ap);
+}
+
 void
 rust_warning_at (const Location location, int opt, const char *fmt, ...)
 {