Merge #383

383: Reuse fold-const.c from GCC to enforce const array capacities r=philberty a=philberty

Rust allows for constant eval for cases like array capacity, the initial
version of this code forced the programmer to only use literals which was
not correct but got the type system off the ground.

This now takes advantage of the GCC backend object to offer 3 helprs.

 1. check for constant Bexpression* are equal
 2. extract a size_t constant value from the Bexpression*
 3. to string the Bexpression constant

We can get away with the extraction of the value here because we know its going to be a usize for array capacity but some thought is needed if these methods are to be reused in other cases.

There is a new ConstFold namespace which should be extensible for const
functions later on and const generics.

Fixes: #296

Co-authored-by: Philip Herron <[email protected]>

Author: bors[bot]

gcc/rust/Make-lang.in

@@ -79,7 +79,8 @@ GRS_OBJS = \
     rust/rust-hir-type-check.o \
     rust/rust-tyty.o \
     rust/rust-tyctx.o \
-	rust/rust-hir-liveness.o \
+    rust/rust-hir-const-fold.o \
+    rust/rust-hir-liveness.o \
     $(END)
 # removed object files from here
 

gcc/rust/backend/rust-compile-context.h

@@ -27,6 +27,7 @@
 #include "rust-compile-tyty.h"
 #include "rust-ast-full.h"
 #include "rust-hir-full.h"
+#include "rust-hir-const-fold-ctx.h"
 
 namespace Rust {
 namespace Compile {
@@ -43,7 +44,8 @@ class Context
   Context (::Backend *backend)
     : backend (backend), resolver (Resolver::Resolver::get ()),
       tyctx (Resolver::TypeCheckContext::get ()),
-      mappings (Analysis::Mappings::get ())
+      mappings (Analysis::Mappings::get ()),
+      const_ctx (ConstFold::Context::get ())
   {
     // insert the builtins
     auto builtins = resolver->get_builtin_types ();
@@ -104,6 +106,7 @@ class Context
   Resolver::Resolver *get_resolver () { return resolver; }
   Resolver::TypeCheckContext *get_tyctx () { return tyctx; }
   Analysis::Mappings *get_mappings () { return mappings; }
+  ConstFold::Context *get_const_ctx () { return const_ctx; }
 
   void push_block (Bblock *scope)
   {
@@ -260,6 +263,7 @@ class Context
   Resolver::Resolver *resolver;
   Resolver::TypeCheckContext *tyctx;
   Analysis::Mappings *mappings;
+  ConstFold::Context *const_ctx;
 
   // state
   std::vector<fncontext> fn_stack;
@@ -420,16 +424,10 @@ class TyTyResolveCompile : public TyTy::TyVisitor
 
   void visit (TyTy::ArrayType &type) override
   {
-    mpz_t ival;
-    mpz_init_set_ui (ival, type.get_capacity ());
-
-    Btype *capacity_type = ctx->get_backend ()->integer_type (true, 32);
-    Bexpression *length
-      = ctx->get_backend ()->integer_constant_expression (capacity_type, ival);
-
     Btype *element_type
       = TyTyResolveCompile::compile (ctx, type.get_element_type ());
-    translated = ctx->get_backend ()->array_type (element_type, length);
+    translated
+      = ctx->get_backend ()->array_type (element_type, type.get_capacity ());
   }
 
   void visit (TyTy::BoolType &type) override

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

@@ -275,7 +275,12 @@ class CompileExpr : public HIRCompileBase
 	return;
       }
 
-    Btype *array_type = TyTyResolveCompile::compile (ctx, tyty);
+    rust_assert (tyty->get_kind () == TyTy::TypeKind::ARRAY);
+    TyTy::ArrayType *array_tyty = static_cast<TyTy::ArrayType *> (tyty);
+    capacity_expr = array_tyty->get_capacity ();
+
+    Btype *array_type = TyTyResolveCompile::compile (ctx, array_tyty);
+    rust_assert (array_type != nullptr);
 
     expr.get_internal_elements ()->accept_vis (*this);
     std::vector<unsigned long> indexes;
@@ -302,7 +307,11 @@ class CompileExpr : public HIRCompileBase
     Bexpression *translated_expr
       = CompileExpr::Compile (elems.get_elem_to_copy (), ctx);
 
-    for (size_t i = 0; i < elems.get_num_elements (); ++i)
+    size_t capacity;
+    bool ok = ctx->get_backend ()->const_size_cast (capacity_expr, &capacity);
+    rust_assert (ok);
+
+    for (size_t i = 0; i < capacity; ++i)
       constructor.push_back (translated_expr);
   }
 
@@ -786,9 +795,12 @@ class CompileExpr : public HIRCompileBase
   }
 
 private:
-  CompileExpr (Context *ctx) : HIRCompileBase (ctx), translated (nullptr) {}
+  CompileExpr (Context *ctx)
+    : HIRCompileBase (ctx), translated (nullptr), capacity_expr (nullptr)
+  {}
 
   Bexpression *translated;
+  Bexpression *capacity_expr;
   std::vector<Bexpression *> constructor;
 };
 

gcc/rust/hir/rust-ast-lower-expr.h

@@ -27,42 +27,6 @@
 namespace Rust {
 namespace HIR {
 
-class ArrayCapacityConstant : public ASTLoweringBase
-{
-  using Rust::HIR::ASTLoweringBase::visit;
-
-public:
-  static bool fold (AST::Expr *expr, size_t *folded_result)
-  {
-    ArrayCapacityConstant folder;
-    expr->accept_vis (folder);
-    *folded_result = folder.result;
-    return folder.ok;
-  }
-
-  void visit (AST::LiteralExpr &expr) override
-  {
-    switch (expr.get_lit_type ())
-      {
-	case AST::Literal::LitType::INT: {
-	  ok = true;
-	  std::stringstream ss (expr.as_string ());
-	  ss >> result;
-	}
-	break;
-
-      default:
-	return;
-      }
-  }
-
-private:
-  ArrayCapacityConstant () : ok (false), result (-1) {}
-
-  bool ok;
-  size_t result;
-}; // namespace Resolver
-
 class ASTLowerPathInExpression : public ASTLoweringBase
 {
   using Rust::HIR::ASTLoweringBase::visit;
@@ -332,18 +296,9 @@ class ASTLoweringExpr : public ASTLoweringBase
     HIR::Expr *num_copies
       = ASTLoweringExpr::translate (elems.get_num_copies ().get ());
 
-    size_t folded;
-    if (!ArrayCapacityConstant::fold (elems.get_num_copies ().get (), &folded))
-      {
-	rust_fatal_error (elems.get_num_copies ()->get_locus_slow (),
-			  "failed to fold capacity constant");
-	return;
-      }
-
     translated_array_elems
       = new HIR::ArrayElemsCopied (std::unique_ptr<HIR::Expr> (element),
-				   std::unique_ptr<HIR::Expr> (num_copies),
-				   folded);
+				   std::unique_ptr<HIR::Expr> (num_copies));
   }
 
   void visit (AST::LiteralExpr &expr) override

gcc/rust/hir/tree/rust-hir-expr.h

@@ -825,8 +825,6 @@ class ArrayElems
 
   virtual void accept_vis (HIRVisitor &vis) = 0;
 
-  virtual size_t get_num_elements () const = 0;
-
 protected:
   // pure virtual clone implementation
   virtual ArrayElems *clone_array_elems_impl () const = 0;
@@ -870,7 +868,7 @@ class ArrayElemsValues : public ArrayElems
 
   void accept_vis (HIRVisitor &vis) override;
 
-  size_t get_num_elements () const override { return values.size (); }
+  size_t get_num_elements () const { return values.size (); }
 
   void iterate (std::function<bool (Expr *)> cb)
   {
@@ -893,33 +891,26 @@ class ArrayElemsCopied : public ArrayElems
 {
   std::unique_ptr<Expr> elem_to_copy;
   std::unique_ptr<Expr> num_copies;
-  size_t folded_copy_amount;
-
-  // TODO: should this store location data?
 
 public:
   // Constructor requires pointers for polymorphism
   ArrayElemsCopied (std::unique_ptr<Expr> copied_elem,
-		    std::unique_ptr<Expr> copy_amount,
-		    size_t folded_copy_amount)
+		    std::unique_ptr<Expr> copy_amount)
     : elem_to_copy (std::move (copied_elem)),
-      num_copies (std::move (copy_amount)),
-      folded_copy_amount (folded_copy_amount)
+      num_copies (std::move (copy_amount))
   {}
 
   // Copy constructor required due to unique_ptr - uses custom clone
   ArrayElemsCopied (ArrayElemsCopied const &other)
     : elem_to_copy (other.elem_to_copy->clone_expr ()),
-      num_copies (other.num_copies->clone_expr ()),
-      folded_copy_amount (other.folded_copy_amount)
+      num_copies (other.num_copies->clone_expr ())
   {}
 
   // Overloaded assignment operator for deep copying
   ArrayElemsCopied &operator= (ArrayElemsCopied const &other)
   {
     elem_to_copy = other.elem_to_copy->clone_expr ();
     num_copies = other.num_copies->clone_expr ();
-    folded_copy_amount = other.folded_copy_amount;
 
     return *this;
   }
@@ -932,10 +923,10 @@ class ArrayElemsCopied : public ArrayElems
 
   void accept_vis (HIRVisitor &vis) override;
 
-  size_t get_num_elements () const override { return folded_copy_amount; }
-
   Expr *get_elem_to_copy () { return elem_to_copy.get (); }
 
+  Expr *get_num_copies_expr () { return num_copies.get (); }
+
 protected:
   ArrayElemsCopied *clone_array_elems_impl () const override
   {

gcc/rust/resolve/rust-ast-resolve-type.h

@@ -217,10 +217,7 @@ class ResolveType : public ResolverBase
       }
   }
 
-  void visit (AST::ArrayType &type) override
-  {
-    type.get_elem_type ()->accept_vis (*this);
-  }
+  void visit (AST::ArrayType &type) override;
 
   void visit (AST::ReferenceType &type) override
   {

gcc/rust/resolve/rust-ast-resolve.cc

@@ -589,5 +589,14 @@ ResolvePath::resolve_path (AST::PathInExpression *expr)
     }
 }
 
+// rust-ast-resolve-type.h
+
+void
+ResolveType::visit (AST::ArrayType &type)
+{
+  type.get_elem_type ()->accept_vis (*this);
+  ResolveExpr::go (type.get_size_expr ().get (), type.get_node_id ());
+}
+
 } // namespace Resolver
 } // namespace Rust

gcc/rust/rust-backend.h

@@ -93,6 +93,11 @@ class Backend
   virtual void debug (Bvariable *) = 0;
   virtual void debug (Blabel *) = 0;
 
+  // const folder helpers
+  virtual bool const_size_cast (Bexpression *, size_t *) = 0;
+  virtual std::string const_size_val_to_string (Bexpression *) = 0;
+  virtual bool const_values_equal (Bexpression *, Bexpression *) = 0;
+
   // Types.
 
   // Produce an error type.  Actually the backend could probably just
@@ -283,6 +288,9 @@ class Backend
   // going without crashing.
   virtual Bexpression *error_expression () = 0;
 
+  // return whether this is error_mark_node
+  virtual bool is_error_expression (Bexpression *) = 0;
+
   // Create a nil pointer expression.
   virtual Bexpression *nil_pointer_expression () = 0;
 

gcc/rust/rust-gcc.cc

@@ -167,7 +167,6 @@ class Gcc_backend : public Backend
   void debug (Blabel *t) { debug_tree (t->get_tree ()); };
 
   // Types.
-
   Btype *error_type () { return this->make_type (error_mark_node); }
 
   Btype *void_type () { return this->make_type (void_type_node); }
@@ -176,6 +175,46 @@ class Gcc_backend : public Backend
 
   Btype *char_type () { return this->make_type (char_type_node); }
 
+  bool const_size_cast (Bexpression *expr, size_t *result)
+  {
+    rust_assert (TREE_CONSTANT (expr->get_tree ()));
+
+    unsigned char buf[sizeof (size_t) + 1];
+    memset (buf, 0, sizeof (buf));
+
+    int ret = native_encode_expr (expr->get_tree (), buf, sizeof (buf), 0);
+    if (ret <= 0)
+      return false;
+
+    size_t *tmp = (size_t *) buf;
+    *result = *tmp;
+    return true;
+  }
+
+  std::string const_size_val_to_string (Bexpression *expr)
+  {
+    rust_assert (TREE_CONSTANT (expr->get_tree ()));
+
+    unsigned char buf[sizeof (size_t) + 1];
+    memset (buf, 0, sizeof (buf));
+
+    int ret = native_encode_expr (expr->get_tree (), buf, sizeof (buf), 0);
+    rust_assert (ret > 0);
+
+    size_t *ptr = (size_t *) buf;
+    return std::to_string (*ptr);
+  }
+
+  bool const_values_equal (Bexpression *a, Bexpression *b)
+  {
+    return operand_equal_p (a->get_tree (), b->get_tree (),
+			    OEP_ONLY_CONST | OEP_PURE_SAME);
+    // printf ("comparing!\n");
+    // debug_tree (a->get_tree ());
+    // debug_tree (b->get_tree ());
+    // printf ("ok = %s\n", ok ? "true" : "false");
+  }
+
   Btype *wchar_type ()
   {
     // i think this is meant to be 32 bit from
@@ -250,6 +289,11 @@ class Gcc_backend : public Backend
     return this->make_expression (error_mark_node);
   }
 
+  bool is_error_expression (Bexpression *expr)
+  {
+    return expr->get_tree () == error_mark_node;
+  }
+
   Bexpression *nil_pointer_expression ()
   {
     return this->make_expression (null_pointer_node);

gcc/rust/rust-session-manager.cc

@@ -52,6 +52,7 @@
 #include "rust-hir-scan-deadcode.h"
 #include "rust-tycheck-dump.h"
 #include "rust-ast-resolve-unused.h"
+#include "rust-hir-const-fold.h"
 #include "rust-compile.h"
 
 extern Linemap *
@@ -325,6 +326,9 @@ Session::init ()
 
   // setup backend to GCC GIMPLE
   backend = rust_get_backend ();
+
+  // the constant folder uses gcc
+  ConstFold::Context::init (backend);
 }
 
 /* Initialise default options. Actually called before handle_option, unlike init