Merge branch 'origin/master'

Author: lrh2000

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/hir/tree/rust-hir-path.h

@@ -165,11 +165,11 @@ struct GenericArgs
   GenericArgs &operator= (GenericArgs &&other) = default;
 
   // Creates an empty GenericArgs (no arguments)
-  static GenericArgs create_empty ()
+  static GenericArgs create_empty (Location locus = Location ())
   {
     return GenericArgs (std::vector<Lifetime> (),
 			std::vector<std::unique_ptr<Type> > (),
-			std::vector<GenericArgsBinding> ());
+			std::vector<GenericArgsBinding> (), locus);
   }
 
   bool is_empty () const

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