Fix address expression to respect reference/pointer types

7 files changed, 53 insertions, 20 deletions

diff --git a/gcc/rust/backend/rust-compile-base.cc b/gcc/rust/backend/rust-compile-base.cc
index b969b7a..928306f 100644
--- a/gcc/rust/backend/rust-compile-base.cc
+++ b/gcc/rust/backend/rust-compile-base.cc
@@ -317,7 +317,7 @@ HIRCompileBase::mark_addressable (tree exp, Location locus)
 }
 
 tree
-HIRCompileBase::address_expression (tree expr, Location location)
+HIRCompileBase::address_expression (tree expr, tree ptrtype, Location location)
 {
   if (expr == error_mark_node)
     return error_mark_node;
@@ -325,7 +325,8 @@ HIRCompileBase::address_expression (tree expr, Location location)
   if (!mark_addressable (expr, location))
     return error_mark_node;
 
-  return build_fold_addr_expr_loc (location.gcc_location (), expr);
+  return build_fold_addr_expr_with_type_loc (location.gcc_location (), expr,
+					     ptrtype);
 }
 
 std::vector<Bvariable *>
diff --git a/gcc/rust/backend/rust-compile-base.h b/gcc/rust/backend/rust-compile-base.h
index c09c562..d58fd19 100644
--- a/gcc/rust/backend/rust-compile-base.h
+++ b/gcc/rust/backend/rust-compile-base.h
@@ -98,7 +98,7 @@ protected:
 
   static void setup_abi_options (tree fndecl, ABI abi);
 
-  static tree address_expression (tree, Location);
+  static tree address_expression (tree expr, tree ptrtype, Location locus);
 
   static bool mark_addressable (tree, Location);
 
diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc
index edeea8d..5f9334c 100644
--- a/gcc/rust/backend/rust-compile-expr.cc
+++ b/gcc/rust/backend/rust-compile-expr.cc
@@ -123,7 +123,14 @@ void
 CompileExpr::visit (HIR::BorrowExpr &expr)
 {
   tree main_expr = CompileExpr::Compile (expr.get_expr ().get (), ctx);
-  translated = address_expression (main_expr, expr.get_locus ());
+
+  TyTy::BaseType *tyty = nullptr;
+  if (!ctx->get_tyctx ()->lookup_type (expr.get_mappings ().get_hirid (),
+				       &tyty))
+    return;
+
+  tree ptrtype = TyTyResolveCompile::compile (ctx, tyty);
+  translated = address_expression (main_expr, ptrtype, expr.get_locus ());
 }
 
 void
@@ -707,7 +714,8 @@ CompileExpr::resolve_method_address (TyTy::FnType *fntype, HirId ref,
   tree fn = NULL_TREE;
   if (ctx->lookup_function_decl (fntype->get_ty_ref (), &fn))
     {
-      return address_expression (fn, expr_locus);
+      return address_expression (fn, build_pointer_type (TREE_TYPE (fn)),
+				 expr_locus);
     }
 
   // Now we can try and resolve the address since this might be a forward
@@ -983,7 +991,8 @@ CompileExpr::compile_string_literal (const HIR::LiteralExpr &expr,
 
   auto base = ctx->get_backend ()->string_constant_expression (
     literal_value.as_string ());
-  return address_expression (base, expr.get_locus ());
+  return address_expression (base, build_pointer_type (TREE_TYPE (base)),
+			     expr.get_locus ());
 }
 
 tree
@@ -1016,7 +1025,8 @@ CompileExpr::compile_byte_string_literal (const HIR::LiteralExpr &expr,
 							 vals,
 							 expr.get_locus ());
 
-  return address_expression (constructed, expr.get_locus ());
+  return address_expression (constructed, build_pointer_type (array_type),
+			     expr.get_locus ());
 }
 
 tree
@@ -1233,8 +1243,11 @@ HIRCompileBase::resolve_adjustements (
 	  return error_mark_node;
 
 	case Resolver::Adjustment::AdjustmentType::IMM_REF:
-	case Resolver::Adjustment::AdjustmentType::MUT_REF:
-	  e = address_expression (e, locus);
+	  case Resolver::Adjustment::AdjustmentType::MUT_REF: {
+	    tree ptrtype
+	      = TyTyResolveCompile::compile (ctx, adjustment.get_expected ());
+	    e = address_expression (e, ptrtype, locus);
+	  }
 	  break;
 
 	case Resolver::Adjustment::AdjustmentType::DEREF:
@@ -1280,7 +1293,10 @@ HIRCompileBase::resolve_deref_adjustment (Resolver::Adjustment &adjustment,
 		      != Resolver::Adjustment::AdjustmentType::ERROR;
   if (needs_borrow)
     {
-      adjusted_argument = address_expression (expression, locus);
+      adjusted_argument
+	= address_expression (expression,
+			      build_reference_type (TREE_TYPE (expression)),
+			      locus);
     }
 
   // make the call
@@ -1316,7 +1332,9 @@ HIRCompileBase::resolve_unsized_adjustment (Resolver::Adjustment &adjustment,
     = TyTyResolveCompile::compile (ctx, adjustment.get_expected ());
 
   // make a constructor for this
-  tree data = address_expression (expression, locus);
+  tree data
+    = address_expression (expression,
+			  build_reference_type (TREE_TYPE (expression)), locus);
 
   // fetch the size from the domain
   tree domain = TYPE_DOMAIN (expr_type);
@@ -1414,7 +1432,8 @@ CompileExpr::visit (HIR::IdentifierExpr &expr)
   else if (ctx->lookup_function_decl (ref, &fn))
     {
       TREE_USED (fn) = 1;
-      translated = address_expression (fn, expr.get_locus ());
+      translated = address_expression (fn, build_pointer_type (TREE_TYPE (fn)),
+				       expr.get_locus ());
     }
   else if (ctx->lookup_var_decl (ref, &var))
     {
diff --git a/gcc/rust/backend/rust-compile-implitem.cc b/gcc/rust/backend/rust-compile-implitem.cc
index 9dc6d14..c13556a 100644
--- a/gcc/rust/backend/rust-compile-implitem.cc
+++ b/gcc/rust/backend/rust-compile-implitem.cc
@@ -68,7 +68,10 @@ CompileTraitItem::visit (HIR::TraitItemFunc &func)
 	    {
 	      ctx->insert_function_decl (fntype, lookup);
 	    }
-	  reference = address_expression (lookup, ref_locus);
+	  reference
+	    = address_expression (lookup,
+				  build_pointer_type (TREE_TYPE (lookup)),
+				  ref_locus);
 	  return;
 	}
     }
@@ -95,7 +98,9 @@ CompileTraitItem::visit (HIR::TraitItemFunc &func)
 			func.get_outer_attrs (), func.get_locus (),
 			func.get_block_expr ().get (), canonical_path, fntype,
 			function.has_return_type ());
-  reference = address_expression (fndecl, ref_locus);
+  reference
+    = address_expression (fndecl, build_pointer_type (TREE_TYPE (fndecl)),
+			  ref_locus);
 }
 
 } // namespace Compile
diff --git a/gcc/rust/backend/rust-compile-item.cc b/gcc/rust/backend/rust-compile-item.cc
index 969c852..36fa787 100644
--- a/gcc/rust/backend/rust-compile-item.cc
+++ b/gcc/rust/backend/rust-compile-item.cc
@@ -146,7 +146,10 @@ CompileItem::visit (HIR::Function &function)
 	      ctx->insert_function_decl (fntype, lookup);
 	    }
 
-	  reference = address_expression (lookup, ref_locus);
+	  reference
+	    = address_expression (lookup,
+				  build_pointer_type (TREE_TYPE (lookup)),
+				  ref_locus);
 	  return;
 	}
     }
@@ -171,7 +174,9 @@ CompileItem::visit (HIR::Function &function)
 			function.get_outer_attrs (), function.get_locus (),
 			function.get_definition ().get (), canonical_path,
 			fntype, function.has_function_return_type ());
-  reference = address_expression (fndecl, ref_locus);
+  reference
+    = address_expression (fndecl, build_pointer_type (TREE_TYPE (fndecl)),
+			  ref_locus);
 }
 
 void
diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc
index 55a2fff..bd44bf4 100644
--- a/gcc/rust/backend/rust-compile-resolve-path.cc
+++ b/gcc/rust/backend/rust-compile-resolve-path.cc
@@ -141,14 +141,16 @@ ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment,
       if (ctx->lookup_function_decl (fntype->get_ty_ref (), &fn))
 	{
 	  TREE_USED (fn) = 1;
-	  return address_expression (fn, expr_locus);
+	  return address_expression (fn, build_pointer_type (TREE_TYPE (fn)),
+				     expr_locus);
 	}
       else if (fntype->get_abi () == ABI::INTRINSIC)
 	{
 	  Intrinsics compile (ctx);
 	  fn = compile.compile (fntype);
 	  TREE_USED (fn) = 1;
-	  return address_expression (fn, expr_locus);
+	  return address_expression (fn, build_pointer_type (TREE_TYPE (fn)),
+				     expr_locus);
 	}
     }
 
diff --git a/gcc/rust/backend/rust-compile.cc b/gcc/rust/backend/rust-compile.cc
index bd782b0..ad36a37 100644
--- a/gcc/rust/backend/rust-compile.cc
+++ b/gcc/rust/backend/rust-compile.cc
@@ -299,8 +299,9 @@ HIRCompileBase::coerce_to_dyn_object (tree compiled_ref,
 	  || it->get_type () == Resolver::Adjustment::AdjustmentType::MUT_REF;
       rust_assert (ok);
 
-      resulting_dyn_object_ref
-	= address_expression (resulting_dyn_object_ref, locus);
+      resulting_dyn_object_ref = address_expression (
+	resulting_dyn_object_ref,
+	build_reference_type (TREE_TYPE (resulting_dyn_object_ref)), locus);
     }
   return resulting_dyn_object_ref;
 }