#include "fold-const.h"
#include "realmpfr.h"
#include "convert.h"
+#include "print-tree.h"
namespace Rust {
namespace Compile {
CompileExpr::visit (HIR::BorrowExpr &expr)
{
tree main_expr = CompileExpr::Compile (expr.get_expr ().get (), ctx);
- if (SLICE_TYPE_P (TREE_TYPE (main_expr)))
+ if (RS_DST_FLAG_P (TREE_TYPE (main_expr)))
{
translated = main_expr;
return;
}
tree expected_type = TyTyResolveCompile::compile (ctx, tyty);
- if (SLICE_TYPE_P (TREE_TYPE (main_expr)) && SLICE_TYPE_P (expected_type))
+ if (RS_DST_FLAG_P (TREE_TYPE (main_expr)) && RS_DST_FLAG_P (expected_type))
{
translated = main_expr;
return;
expected, expr.get_lhs ()->get_locus (),
expr.get_rhs ()->get_locus ());
+ // rust_debug_loc (expr.get_locus (), "XXXXXX assignment");
+ // debug_tree (rvalue);
+ // debug_tree (lvalue);
+
tree assignment
= ctx->get_backend ()->assignment_statement (lvalue, rvalue,
expr.get_locus ());
if (ref == nullptr)
return error_mark_node;
- // get any indirection sorted out
- if (receiver->get_kind () == TyTy::TypeKind::REF)
- {
- tree indirect = indirect_expression (receiver_ref, expr_locus);
- receiver_ref = indirect;
- }
-
// cast it to the correct fntype
tree expected_fntype = TyTyResolveCompile::compile (ctx, fntype, true);
tree idx = build_int_cst (size_type_node, offs);
TyTy::FnType *fntype, tree receiver_ref,
Location expr_locus)
{
- // get any indirection sorted out
- if (receiver->get_kind () == TyTy::TypeKind::REF)
- {
- tree indirect = indirect_expression (receiver_ref, expr_locus);
- receiver_ref = indirect;
- }
-
// access the offs + 1 for the fnptr and offs=0 for the reciever obj
return ctx->get_backend ()->struct_field_expression (receiver_ref, 0,
expr_locus);
type_to_cast_to, expr_tree);
}
else if (TREE_CODE (type_to_cast_to) == POINTER_TYPE
- && SLICE_TYPE_P (TREE_TYPE (expr_tree)))
+ && RS_DST_FLAG (TREE_TYPE (expr_tree)))
{
// returning a raw cast using NOP_EXPR seems to resut in an ICE:
//
case Resolver::Adjustment::AdjustmentType::IMM_REF:
case Resolver::Adjustment::AdjustmentType::MUT_REF: {
- if (!SLICE_TYPE_P (TREE_TYPE (e)))
+ if (!RS_DST_FLAG (TREE_TYPE (e)))
{
e = address_expression (e, locus);
}
{
const TyTy::SliceType *slice = nullptr;
const TyTy::StrType *str = nullptr;
+ const TyTy::DynamicObjectType *dyn = nullptr;
if (type.is_dyn_slice_type (&slice))
{
tree type_record = create_slice_type_record (*slice);
return;
}
+ else if (type.is_dyn_obj_type (&dyn))
+ {
+ tree type_record = create_dyn_obj_record (*dyn);
+ std::string dyn_str_type_str
+ = std::string (type.is_mutable () ? "&mut " : "& ") + dyn->get_name ();
+
+ translated
+ = ctx->get_backend ()->named_type (dyn_str_type_str, type_record,
+ dyn->get_locus ());
+
+ return;
+ }
tree base_compiled_type
= TyTyResolveCompile::compile (ctx, type.get_base (), trait_object_mode);
{
const TyTy::SliceType *slice = nullptr;
const TyTy::StrType *str = nullptr;
+ const TyTy::DynamicObjectType *dyn = nullptr;
if (type.is_dyn_slice_type (&slice))
{
tree type_record = create_slice_type_record (*slice);
return;
}
+ else if (type.is_dyn_obj_type (&dyn))
+ {
+ tree type_record = create_dyn_obj_record (*dyn);
+ std::string dyn_str_type_str
+ = std::string (type.is_mutable () ? "*mut " : "*const ")
+ + dyn->get_name ();
+
+ translated
+ = ctx->get_backend ()->named_type (dyn_str_type_str, type_record,
+ dyn->get_locus ());
+
+ return;
+ }
tree base_compiled_type
= TyTyResolveCompile::compile (ctx, type.get_base (), trait_object_mode);
return;
}
+ tree type_record = create_dyn_obj_record (type);
+ translated = ctx->get_backend ()->named_type (type.get_name (), type_record,
+ type.get_ident ().locus);
+}
+
+tree
+TyTyResolveCompile::create_dyn_obj_record (const TyTy::DynamicObjectType &type)
+{
// create implicit struct
auto items = type.get_object_items ();
std::vector<Backend::typed_identifier> fields;
type.get_ty_ref ()));
fields.push_back (std::move (vtf));
- tree type_record = ctx->get_backend ()->struct_type (fields);
- translated = ctx->get_backend ()->named_type (type.get_name (), type_record,
- type.get_ident ().locus);
+ tree record = ctx->get_backend ()->struct_type (fields);
+ RS_DST_FLAG (record) = 1;
+ TYPE_MAIN_VARIANT (record) = ctx->insert_main_variant (record);
+
+ return record;
}
tree
Backend::typed_identifier len_field ("len", len_field_ty, type.get_locus ());
tree record = ctx->get_backend ()->struct_type ({data_field, len_field});
- SLICE_FLAG (record) = 1;
+ RS_DST_FLAG (record) = 1;
TYPE_MAIN_VARIANT (record) = ctx->insert_main_variant (record);
return record;
Backend::typed_identifier len_field ("len", len_field_ty, type.get_locus ());
tree record = ctx->get_backend ()->struct_type ({data_field, len_field});
- SLICE_FLAG (record) = 1;
+ RS_DST_FLAG (record) = 1;
TYPE_MAIN_VARIANT (record) = ctx->insert_main_variant (record);
return record;
protected:
tree create_slice_type_record (const TyTy::SliceType &type);
tree create_str_type_record (const TyTy::StrType &type);
+ tree create_dyn_obj_record (const TyTy::DynamicObjectType &type);
private:
TyTyResolveCompile (Context *ctx, bool trait_object_mode);
if (expected->get_kind () == TyTy::TypeKind::REF)
{
// this is a dyn object
- if (SLICE_TYPE_P (TREE_TYPE (rvalue)))
+ if (RS_DST_FLAG_P (TREE_TYPE (rvalue)))
{
return rvalue;
}
tree coerced
= coercion_site1 (deref_rvalue, act->get_base (), exp->get_base (),
lvalue_locus, rvalue_locus);
- if (exp->is_dyn_object () && SLICE_TYPE_P (TREE_TYPE (coerced)))
+ if (exp->is_dyn_object () && RS_DST_FLAG_P (TREE_TYPE (coerced)))
return coerced;
return address_expression (coerced, rvalue_locus);
else if (expected->get_kind () == TyTy::TypeKind::POINTER)
{
// this is a dyn object
- if (SLICE_TYPE_P (TREE_TYPE (rvalue)))
+ if (RS_DST_FLAG_P (TREE_TYPE (rvalue)))
{
return rvalue;
}
= coercion_site1 (deref_rvalue, actual_base, exp->get_base (),
lvalue_locus, rvalue_locus);
- if (exp->is_dyn_object () && SLICE_TYPE_P (TREE_TYPE (coerced)))
+ if (exp->is_dyn_object () && RS_DST_FLAG_P (TREE_TYPE (coerced)))
return coerced;
return address_expression (coerced, rvalue_locus);
const TyTy::DynamicObjectType *ty,
Location locus)
{
- tree dynamic_object = TyTyResolveCompile::compile (ctx, ty);
+ // DST's get wrapped in a pseudo reference that doesnt exist...
+ const TyTy::ReferenceType r (ctx->get_mappings ()->get_next_hir_id (),
+ TyTy::TyVar (ty->get_ref ()), Mutability::Imm);
+
+ tree dynamic_object = TyTyResolveCompile::compile (ctx, &r);
tree dynamic_object_fields = TYPE_FIELDS (dynamic_object);
tree vtable_field = DECL_CHAIN (dynamic_object_fields);
rust_assert (TREE_CODE (TREE_TYPE (vtable_field)) == ARRAY_TYPE);
// this is a helper to differentiate RECORD types between actual records and
// slices
-#define SLICE_FLAG TREE_LANG_FLAG_0
-#define SLICE_TYPE_P(TYPE) \
+#define RS_DST_FLAG TREE_LANG_FLAG_0
+#define RS_DST_FLAG_P(TYPE) \
(TREE_CODE (TYPE) == RECORD_TYPE && TREE_LANG_FLAG_0 (TYPE))
// lambda?
bool
ReferenceType::is_dyn_object () const
{
- return is_dyn_slice_type () || is_dyn_str_type ();
+ return is_dyn_slice_type () || is_dyn_str_type () || is_dyn_obj_type ();
}
bool
return true;
}
+bool
+ReferenceType::is_dyn_obj_type (const TyTy::DynamicObjectType **dyn) const
+{
+ const TyTy::BaseType *element = get_base ()->destructure ();
+ if (element->get_kind () != TyTy::TypeKind::DYNAMIC)
+ return false;
+ if (dyn == nullptr)
+ return true;
+
+ *dyn = static_cast<const TyTy::DynamicObjectType *> (element);
+ return true;
+}
+
void
ReferenceType::accept_vis (TyVisitor &vis)
{
bool
PointerType::is_dyn_object () const
{
- return is_dyn_slice_type () || is_dyn_str_type ();
+ return is_dyn_slice_type () || is_dyn_str_type () || is_dyn_obj_type ();
}
bool
return true;
}
+bool
+PointerType::is_dyn_obj_type (const TyTy::DynamicObjectType **dyn) const
+{
+ const TyTy::BaseType *element = get_base ()->destructure ();
+ if (element->get_kind () != TyTy::TypeKind::DYNAMIC)
+ return false;
+ if (dyn == nullptr)
+ return true;
+
+ *dyn = static_cast<const TyTy::DynamicObjectType *> (element);
+ return true;
+}
+
void
PointerType::accept_vis (TyVisitor &vis)
{
BaseType *clone () const final override;
};
+class DynamicObjectType : public BaseType
+{
+public:
+ DynamicObjectType (HirId ref, RustIdent ident,
+ std::vector<TypeBoundPredicate> specified_bounds,
+ std::set<HirId> refs = std::set<HirId> ());
+
+ DynamicObjectType (HirId ref, HirId ty_ref, RustIdent ident,
+ std::vector<TypeBoundPredicate> specified_bounds,
+ std::set<HirId> refs = std::set<HirId> ());
+
+ void accept_vis (TyVisitor &vis) override;
+ void accept_vis (TyConstVisitor &vis) const override;
+
+ std::string as_string () const override;
+
+ bool can_eq (const BaseType *other, bool emit_errors) const override final;
+
+ bool is_equal (const BaseType &other) const override;
+
+ BaseType *clone () const final override;
+
+ std::string get_name () const override final;
+
+ // this returns a flat list of items including super trait bounds
+ const std::vector<
+ std::pair<const Resolver::TraitItemReference *, const TypeBoundPredicate *>>
+ get_object_items () const;
+};
+
class ReferenceType : public BaseType
{
public:
bool is_dyn_object () const;
bool is_dyn_slice_type (const TyTy::SliceType **slice = nullptr) const;
bool is_dyn_str_type (const TyTy::StrType **str = nullptr) const;
+ bool is_dyn_obj_type (const TyTy::DynamicObjectType **dyn = nullptr) const;
private:
TyVar base;
bool is_dyn_object () const;
bool is_dyn_slice_type (const TyTy::SliceType **slice = nullptr) const;
bool is_dyn_str_type (const TyTy::StrType **str = nullptr) const;
+ bool is_dyn_obj_type (const TyTy::DynamicObjectType **dyn = nullptr) const;
private:
TyVar base;
DefId item;
};
-class DynamicObjectType : public BaseType
-{
-public:
- DynamicObjectType (HirId ref, RustIdent ident,
- std::vector<TypeBoundPredicate> specified_bounds,
- std::set<HirId> refs = std::set<HirId> ());
-
- DynamicObjectType (HirId ref, HirId ty_ref, RustIdent ident,
- std::vector<TypeBoundPredicate> specified_bounds,
- std::set<HirId> refs = std::set<HirId> ());
-
- void accept_vis (TyVisitor &vis) override;
- void accept_vis (TyConstVisitor &vis) const override;
-
- std::string as_string () const override;
-
- bool can_eq (const BaseType *other, bool emit_errors) const override final;
-
- bool is_equal (const BaseType &other) const override;
-
- BaseType *clone () const final override;
-
- std::string get_name () const override final;
-
- // this returns a flat list of items including super trait bounds
- const std::vector<
- std::pair<const Resolver::TraitItemReference *, const TypeBoundPredicate *>>
- get_object_items () const;
-};
-
} // namespace TyTy
} // namespace Rust
--- /dev/null
+// { dg-output "123\n" }
+trait A {
+ fn get_int(&self) -> i32;
+}
+
+impl A for i32 {
+ fn get_int(&self) -> i32 {
+ *self
+ }
+}
+
+fn get_dyn_a(x: &i32) -> &dyn A {
+ x as &dyn A
+}
+
+fn clobber_stack() {
+ let _z: [usize; 8] = [1, 2, 3, 4, 5, 6, 7, 8];
+}
+
+extern "C" {
+ fn printf(s: *const i8, ...) -> i32;
+}
+
+fn main() -> i32 {
+ let x = 123;
+ let y = get_dyn_a(&x);
+ clobber_stack();
+ let value = y.get_int();
+ let fmt_string = "%d\n\0" as *const str as *const i8;
+ unsafe {
+ printf(fmt_string, value);
+ }
+ return 0;
+}
projects / thirdparty / gcc.git / commitdiff
