Fix u128 rotate operation on 32 bit targets

gcc/rust/ChangeLog:

	* backend/rust-compile-intrinsic.cc: Include "convert.h".
	(rotate_handler): Convert the second parameter into an unsigned
	int.
	* rust-backend.h (rust_int_trees): Declare extern variable.
	(rust_int_names): Likewise.
	* rust-gcc.cc: Include "target.h".
	(rust_int_trees): Define variable.
	(rust_int_names): Likewise.
	(setup_normal_integers): Define static function.
	(init): Call setup_normal_integers.
	* backend/rust-compile-type.cc (TyTyResolveCompile::visit): Use
	rust_int_trees to obtain integer type trees.

gcc/testsuite/ChangeLog:

	* rust/execute/torture/sip-hasher.rs: Enable on 32 bit targets.

Signed-off-by: Owen Avery <[email protected]>

Author: powerboat9

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

@@ -28,6 +28,7 @@
 #include "rust-gcc.h"
 #include "fold-const.h"
 #include "langhooks.h"
+#include "convert.h"
 #include "rust-constexpr.h"
 
 // declaration taken from "stringpool.h"
@@ -557,8 +558,16 @@ rotate_handler (Context *ctx, TyTy::FnType *fntype, tree_code op)
   // BUILTIN rotate FN BODY BEGIN
   tree x = Backend::var_expression (x_param, UNDEF_LOCATION);
   tree y = Backend::var_expression (y_param, UNDEF_LOCATION);
+
+  tree y_mask
+    = build_int_cst (unsigned_type_node, TYPE_SIZE (TREE_TYPE (x)) - 1);
+
+  tree y_truncated
+    = fold_build2_loc (BUILTINS_LOCATION, BIT_AND_EXPR, unsigned_type_node,
+		       convert_to_integer (unsigned_type_node, y), y_mask);
+
   tree rotate_expr
-    = fold_build2_loc (BUILTINS_LOCATION, op, TREE_TYPE (x), x, y);
+    = fold_build2_loc (BUILTINS_LOCATION, op, TREE_TYPE (x), x, y_truncated);
   auto return_statement
     = Backend::return_statement (fndecl, rotate_expr, UNDEF_LOCATION);
   ctx->add_statement (return_statement);

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

@@ -504,32 +504,23 @@ TyTyResolveCompile::visit (const TyTy::IntType &type)
   switch (type.get_int_kind ())
     {
     case TyTy::IntType::I8:
-      translated = Backend::named_type ("i8", Backend::integer_type (false, 8),
-					BUILTINS_LOCATION);
+      translated = Backend::rust_int_trees[5];
       return;
 
     case TyTy::IntType::I16:
-      translated
-	= Backend::named_type ("i16", Backend::integer_type (false, 16),
-			       BUILTINS_LOCATION);
+      translated = Backend::rust_int_trees[6];
       return;
 
     case TyTy::IntType::I32:
-      translated
-	= Backend::named_type ("i32", Backend::integer_type (false, 32),
-			       BUILTINS_LOCATION);
+      translated = Backend::rust_int_trees[7];
       return;
 
     case TyTy::IntType::I64:
-      translated
-	= Backend::named_type ("i64", Backend::integer_type (false, 64),
-			       BUILTINS_LOCATION);
+      translated = Backend::rust_int_trees[8];
       return;
 
     case TyTy::IntType::I128:
-      translated
-	= Backend::named_type ("i128", Backend::integer_type (false, 128),
-			       BUILTINS_LOCATION);
+      translated = Backend::rust_int_trees[9];
       return;
     }
 }
@@ -540,29 +531,23 @@ TyTyResolveCompile::visit (const TyTy::UintType &type)
   switch (type.get_uint_kind ())
     {
     case TyTy::UintType::U8:
-      translated = Backend::named_type ("u8", Backend::integer_type (true, 8),
-					BUILTINS_LOCATION);
+      translated = Backend::rust_int_trees[0];
       return;
 
     case TyTy::UintType::U16:
-      translated = Backend::named_type ("u16", Backend::integer_type (true, 16),
-					BUILTINS_LOCATION);
+      translated = Backend::rust_int_trees[1];
       return;
 
     case TyTy::UintType::U32:
-      translated = Backend::named_type ("u32", Backend::integer_type (true, 32),
-					BUILTINS_LOCATION);
+      translated = Backend::rust_int_trees[2];
       return;
 
     case TyTy::UintType::U64:
-      translated = Backend::named_type ("u64", Backend::integer_type (true, 64),
-					BUILTINS_LOCATION);
+      translated = Backend::rust_int_trees[3];
       return;
 
     case TyTy::UintType::U128:
-      translated
-	= Backend::named_type ("u128", Backend::integer_type (true, 128),
-			       BUILTINS_LOCATION);
+      translated = Backend::rust_int_trees[4];
       return;
     }
 }

gcc/rust/rust-backend.h

@@ -50,6 +50,9 @@ using Rust::GGC::Ident;
 
 } // namespace GGC
 
+extern tree rust_int_trees[10];
+extern const char *rust_int_names[10];
+
 void init ();
 
 // Name/type/location.  Used for function parameters, struct fields,

gcc/rust/rust-gcc.cc

@@ -45,6 +45,7 @@
 #include "builtins.h"
 #include "print-tree.h"
 #include "attribs.h"
+#include "target.h"
 
 #include "rust-location.h"
 #include "rust-linemap.h"
@@ -95,9 +96,104 @@ namespace Backend {
 
 // Define the built-in functions that are exposed to GCCRust.
 
+// (u, i) X (8, 16, 32, 64, 128)
+tree rust_int_trees[10];
+const char *rust_int_names[10]
+  = {"u8", "u16", "u32", "u64", "u128", "i8", "i16", "i32", "i64", "i128"};
+
+static void
+setup_normal_integers ()
+{
+  // we should have QImode
+  rust_int_trees[0] = make_unsigned_type (8);
+  rust_int_trees[5] = make_signed_type (8);
+
+  // look through integer types intended for C
+  const int normal_int_sizes[4]
+    = {INT_TYPE_SIZE, SHORT_TYPE_SIZE, LONG_TYPE_SIZE, LONG_LONG_TYPE_SIZE};
+  const tree normal_int_trees[8]
+    = {unsigned_type_node,	     integer_type_node,
+       short_unsigned_type_node,     short_integer_type_node,
+       long_unsigned_type_node,	     long_integer_type_node,
+       long_long_unsigned_type_node, long_long_integer_type_node};
+
+  for (size_t i = 0; i < 4; i++)
+    {
+      // check for a power of 2 or 0
+      if (normal_int_sizes[i] & (normal_int_sizes[i] - 1))
+	continue;
+
+      // assume size is not 0
+      int idx = __builtin_ctz (normal_int_sizes[i]) - 3;
+      if (idx < 0 || idx > 5)
+	continue;
+
+      if (rust_int_trees[idx] != NULL_TREE)
+	continue;
+
+      rust_int_trees[idx] = normal_int_trees[2 * i];
+      rust_int_trees[5 + idx] = normal_int_trees[2 * i + 1];
+    }
+
+  // look through int_n_data for more integer types
+  for (size_t i = 0, j = 0; i < 5 && j < NUM_INT_N_ENTS;)
+    {
+      if (rust_int_trees[i] != NULL_TREE)
+	{
+	  i++;
+	  continue;
+	}
+
+      if (!int_n_enabled_p[j] || int_n_data[j].bitsize < (8u << i))
+	{
+	  j++;
+	}
+      else if (int_n_data[j].bitsize > (8u << i))
+	{
+	  i++;
+	}
+      else
+	{
+	  rust_int_trees[i] = make_unsigned_type (8 << i);
+	  rust_int_trees[5 + i] = make_signed_type (8 << i);
+	  i++;
+	  j++;
+	}
+    }
+
+  // use _BitInt where we have to (and can)
+  for (int i = 0; i < 5; i++)
+    {
+      if (rust_int_trees[i] == NULL_TREE)
+	{
+	  bitint_info b_info;
+	  if (targetm.c.bitint_type_info (8 << i, &b_info))
+	    {
+	      rust_debug ("filling in integer size %u with _BitInt", 8u << i);
+	      rust_int_trees[i] = build_bitint_type (8 << i, true);
+	      rust_int_trees[5 + i] = build_bitint_type (8 << i, false);
+	    }
+	}
+    }
+
+  // TODO: bootleg _BitInt where necessary?
+
+  // not much can be done for now -- fill with error_mark_node
+  for (size_t i = 0; i < 10; i++)
+    if (rust_int_trees[i] == NULL_TREE)
+      rust_int_trees[i] = error_mark_node;
+
+  // name types
+  for (size_t i = 0; i < 10; i++)
+    rust_int_trees[i]
+      = named_type (rust_int_names[i], rust_int_trees[i], BUILTINS_LOCATION);
+}
+
 void
 init ()
 {
+  setup_normal_integers ();
+
   /* We need to define the fetch_and_add functions, since we use them
      for ++ and --.  */
   // tree t = this->integer_type (true, BITS_PER_UNIT)->get_tree ();

gcc/testsuite/rust/execute/torture/sip-hasher.rs

@@ -1,4 +1,3 @@
-// { dg-skip-if "" { *-*-* } { "-m32" } { "" } }
 // { dg-options "-w" }
 // { dg-output "Hash: 0x63d53fd2170bbb8c\r*\n" }
 #![feature(intrinsics)]