diff options
Diffstat (limited to 'gcc/rust/backend/rust-compile-intrinsic.cc')
| -rw-r--r-- | gcc/rust/backend/rust-compile-intrinsic.cc | 325 |
1 files changed, 275 insertions, 50 deletions
diff --git a/gcc/rust/backend/rust-compile-intrinsic.cc b/gcc/rust/backend/rust-compile-intrinsic.cc index de3bb6e..4888e23 100644 --- a/gcc/rust/backend/rust-compile-intrinsic.cc +++ b/gcc/rust/backend/rust-compile-intrinsic.cc @@ -17,23 +17,19 @@ #include "rust-compile-intrinsic.h" #include "rust-compile-context.h" #include "rust-compile-type.h" -#include "rust-compile-expr.h" #include "rust-compile-fnparam.h" #include "rust-builtins.h" #include "rust-diagnostics.h" #include "rust-location.h" #include "rust-constexpr.h" +#include "rust-session-manager.h" #include "rust-tree.h" #include "tree-core.h" #include "rust-gcc.h" -#include "print-tree.h" #include "fold-const.h" #include "langhooks.h" -#include "rust-gcc.h" #include "rust-constexpr.h" -#include "print-tree.h" - // declaration taken from "stringpool.h" // the get_identifier macro causes compilation issues extern tree @@ -92,6 +88,10 @@ static tree move_val_init_handler (Context *ctx, TyTy::FnType *fntype); static tree assume_handler (Context *ctx, TyTy::FnType *fntype); +static tree +discriminant_value_handler (Context *ctx, TyTy::FnType *fntype); +static tree +variant_count_handler (Context *ctx, TyTy::FnType *fntype); enum class Prefetch { @@ -194,6 +194,17 @@ expect_handler (bool likely) }; } +static tree +try_handler_inner (Context *ctx, TyTy::FnType *fntype, bool is_new_api); + +const static std::function<tree (Context *, TyTy::FnType *)> +try_handler (bool is_new_api) +{ + return [is_new_api] (Context *ctx, TyTy::FnType *fntype) { + return try_handler_inner (ctx, fntype, is_new_api); + }; +} + inline tree sorry_handler (Context *ctx, TyTy::FnType *fntype) { @@ -205,43 +216,46 @@ sorry_handler (Context *ctx, TyTy::FnType *fntype) static const std::map<std::string, std::function<tree (Context *, TyTy::FnType *)>> - generic_intrinsics = { - {"offset", offset_handler}, - {"size_of", sizeof_handler}, - {"transmute", transmute_handler}, - {"rotate_left", rotate_left_handler}, - {"rotate_right", rotate_right_handler}, - {"wrapping_add", wrapping_op_handler (PLUS_EXPR)}, - {"wrapping_sub", wrapping_op_handler (MINUS_EXPR)}, - {"wrapping_mul", wrapping_op_handler (MULT_EXPR)}, - {"add_with_overflow", op_with_overflow (PLUS_EXPR)}, - {"sub_with_overflow", op_with_overflow (MINUS_EXPR)}, - {"mul_with_overflow", op_with_overflow (MULT_EXPR)}, - {"copy", copy_handler (true)}, - {"copy_nonoverlapping", copy_handler (false)}, - {"prefetch_read_data", prefetch_read_data}, - {"prefetch_write_data", prefetch_write_data}, - {"atomic_store_seqcst", atomic_store_handler (__ATOMIC_SEQ_CST)}, - {"atomic_store_release", atomic_store_handler (__ATOMIC_RELEASE)}, - {"atomic_store_relaxed", atomic_store_handler (__ATOMIC_RELAXED)}, - {"atomic_store_unordered", atomic_store_handler (__ATOMIC_RELAXED)}, - {"atomic_load_seqcst", atomic_load_handler (__ATOMIC_SEQ_CST)}, - {"atomic_load_acquire", atomic_load_handler (__ATOMIC_ACQUIRE)}, - {"atomic_load_relaxed", atomic_load_handler (__ATOMIC_RELAXED)}, - {"atomic_load_unordered", atomic_load_handler (__ATOMIC_RELAXED)}, - {"unchecked_add", unchecked_op_handler (PLUS_EXPR)}, - {"unchecked_sub", unchecked_op_handler (MINUS_EXPR)}, - {"unchecked_mul", unchecked_op_handler (MULT_EXPR)}, - {"unchecked_div", unchecked_op_handler (TRUNC_DIV_EXPR)}, - {"unchecked_rem", unchecked_op_handler (TRUNC_MOD_EXPR)}, - {"unchecked_shl", unchecked_op_handler (LSHIFT_EXPR)}, - {"unchecked_shr", unchecked_op_handler (RSHIFT_EXPR)}, - {"uninit", uninit_handler}, - {"move_val_init", move_val_init_handler}, - {"likely", expect_handler (true)}, - {"unlikely", expect_handler (false)}, - {"assume", assume_handler}, -}; + generic_intrinsics + = {{"offset", offset_handler}, + {"size_of", sizeof_handler}, + {"transmute", transmute_handler}, + {"rotate_left", rotate_left_handler}, + {"rotate_right", rotate_right_handler}, + {"wrapping_add", wrapping_op_handler (PLUS_EXPR)}, + {"wrapping_sub", wrapping_op_handler (MINUS_EXPR)}, + {"wrapping_mul", wrapping_op_handler (MULT_EXPR)}, + {"add_with_overflow", op_with_overflow (PLUS_EXPR)}, + {"sub_with_overflow", op_with_overflow (MINUS_EXPR)}, + {"mul_with_overflow", op_with_overflow (MULT_EXPR)}, + {"copy", copy_handler (true)}, + {"copy_nonoverlapping", copy_handler (false)}, + {"prefetch_read_data", prefetch_read_data}, + {"prefetch_write_data", prefetch_write_data}, + {"atomic_store_seqcst", atomic_store_handler (__ATOMIC_SEQ_CST)}, + {"atomic_store_release", atomic_store_handler (__ATOMIC_RELEASE)}, + {"atomic_store_relaxed", atomic_store_handler (__ATOMIC_RELAXED)}, + {"atomic_store_unordered", atomic_store_handler (__ATOMIC_RELAXED)}, + {"atomic_load_seqcst", atomic_load_handler (__ATOMIC_SEQ_CST)}, + {"atomic_load_acquire", atomic_load_handler (__ATOMIC_ACQUIRE)}, + {"atomic_load_relaxed", atomic_load_handler (__ATOMIC_RELAXED)}, + {"atomic_load_unordered", atomic_load_handler (__ATOMIC_RELAXED)}, + {"unchecked_add", unchecked_op_handler (PLUS_EXPR)}, + {"unchecked_sub", unchecked_op_handler (MINUS_EXPR)}, + {"unchecked_mul", unchecked_op_handler (MULT_EXPR)}, + {"unchecked_div", unchecked_op_handler (TRUNC_DIV_EXPR)}, + {"unchecked_rem", unchecked_op_handler (TRUNC_MOD_EXPR)}, + {"unchecked_shl", unchecked_op_handler (LSHIFT_EXPR)}, + {"unchecked_shr", unchecked_op_handler (RSHIFT_EXPR)}, + {"uninit", uninit_handler}, + {"move_val_init", move_val_init_handler}, + {"likely", expect_handler (true)}, + {"unlikely", expect_handler (false)}, + {"assume", assume_handler}, + {"try", try_handler (false)}, + {"catch_unwind", try_handler (true)}, + {"discriminant_value", discriminant_value_handler}, + {"variant_count", variant_count_handler}}; Intrinsics::Intrinsics (Context *ctx) : ctx (ctx) {} @@ -315,11 +329,11 @@ compile_fn_params (Context *ctx, TyTy::FnType *fntype, tree fndecl, { for (auto &parm : fntype->get_params ()) { - auto &referenced_param = parm.first; - auto ¶m_tyty = parm.second; + auto &referenced_param = parm.get_pattern (); + auto param_tyty = parm.get_type (); auto compiled_param_type = TyTyResolveCompile::compile (ctx, param_tyty); - location_t param_locus = referenced_param->get_locus (); + location_t param_locus = referenced_param.get_locus (); Bvariable *compiled_param_var = CompileFnParam::compile (ctx, fndecl, referenced_param, compiled_param_type, param_locus); @@ -496,9 +510,10 @@ transmute_handler (Context *ctx, TyTy::FnType *fntype) rust_error_at (fntype->get_locus (), "cannot transmute between types of different sizes, or " "dependently-sized types"); - rust_inform (fntype->get_ident ().locus, "source type: %qs (%lu bits)", - fntype->get_params ().at (0).second->as_string ().c_str (), - (unsigned long) source_size); + rust_inform ( + fntype->get_ident ().locus, "source type: %qs (%lu bits)", + fntype->get_params ().at (0).get_type ()->as_string ().c_str (), + (unsigned long) source_size); rust_inform (fntype->get_ident ().locus, "target type: %qs (%lu bits)", fntype->get_return_type ()->as_string ().c_str (), (unsigned long) target_size); @@ -1226,7 +1241,7 @@ assume_handler (Context *ctx, TyTy::FnType *fntype) // TODO: make sure this is actually helping the compiler optimize rust_assert (fntype->get_params ().size () == 1); - rust_assert (fntype->param_at (0).second->get_kind () + rust_assert (fntype->param_at (0).get_type ()->get_kind () == TyTy::TypeKind::BOOL); tree lookup = NULL_TREE; @@ -1258,7 +1273,217 @@ assume_handler (Context *ctx, TyTy::FnType *fntype) TREE_SIDE_EFFECTS (assume_expr) = 1; ctx->add_statement (assume_expr); - // BUILTIN size_of FN BODY END + // BUILTIN assume FN BODY END + + finalize_intrinsic_block (ctx, fndecl); + + return fndecl; +} + +static tree +try_handler_inner (Context *ctx, TyTy::FnType *fntype, bool is_new_api) +{ + rust_assert (fntype->get_params ().size () == 3); + + tree lookup = NULL_TREE; + if (check_for_cached_intrinsic (ctx, fntype, &lookup)) + return lookup; + auto fndecl = compile_intrinsic_function (ctx, fntype); + + enter_intrinsic_block (ctx, fndecl); + + // The following tricks are needed to make sure the try-catch blocks are not + // optimized away + TREE_READONLY (fndecl) = 0; + DECL_DISREGARD_INLINE_LIMITS (fndecl) = 1; + DECL_ATTRIBUTES (fndecl) = tree_cons (get_identifier ("always_inline"), + NULL_TREE, DECL_ATTRIBUTES (fndecl)); + + // BUILTIN try_handler FN BODY BEGIN + // setup the params + std::vector<Bvariable *> param_vars; + compile_fn_params (ctx, fntype, fndecl, ¶m_vars); + if (!Backend::function_set_parameters (fndecl, param_vars)) + return error_mark_node; + tree enclosing_scope = NULL_TREE; + + bool panic_is_abort = Session::get_instance ().options.get_panic_strategy () + == CompileOptions::PanicStrategy::Abort; + tree try_fn = Backend::var_expression (param_vars[0], UNDEF_LOCATION); + tree user_data = Backend::var_expression (param_vars[1], UNDEF_LOCATION); + tree catch_fn = Backend::var_expression (param_vars[2], UNDEF_LOCATION); + tree normal_return_stmt = NULL_TREE; + tree error_return_stmt = NULL_TREE; + tree try_call = Backend::call_expression (try_fn, {user_data}, nullptr, + BUILTINS_LOCATION); + tree catch_call = NULL_TREE; + tree try_block = Backend::block (fndecl, enclosing_scope, {}, UNDEF_LOCATION, + UNDEF_LOCATION); + + if (is_new_api) + { + auto ret_type = TyTyResolveCompile::get_unit_type (ctx); + auto ret_expr = Backend::constructor_expression (ret_type, false, {}, -1, + UNDEF_LOCATION); + normal_return_stmt + = Backend::return_statement (fndecl, ret_expr, BUILTINS_LOCATION); + error_return_stmt + = Backend::return_statement (fndecl, ret_expr, BUILTINS_LOCATION); + } + else + { + normal_return_stmt = Backend::return_statement (fndecl, integer_zero_node, + BUILTINS_LOCATION); + error_return_stmt = Backend::return_statement (fndecl, integer_one_node, + BUILTINS_LOCATION); + } + Backend::block_add_statements (try_block, + std::vector<tree>{try_call, + normal_return_stmt}); + if (panic_is_abort) + { + // skip building the try-catch construct + ctx->add_statement (try_block); + finalize_intrinsic_block (ctx, fndecl); + return fndecl; + } + + tree eh_pointer + = build_call_expr (builtin_decl_explicit (BUILT_IN_EH_POINTER), 1, + integer_zero_node); + catch_call = Backend::call_expression (catch_fn, {user_data, eh_pointer}, + NULL_TREE, BUILTINS_LOCATION); + + tree catch_block = Backend::block (fndecl, enclosing_scope, {}, + UNDEF_LOCATION, UNDEF_LOCATION); + Backend::block_add_statements (catch_block, + std::vector<tree>{catch_call, + error_return_stmt}); + // emulate what cc1plus is doing for C++ try-catch + tree inner_eh_construct + = Backend::exception_handler_statement (catch_call, NULL_TREE, + error_return_stmt, + BUILTINS_LOCATION); + // TODO(liushuyu): eh_personality needs to be implemented as a runtime thing + auto eh_construct + = Backend::exception_handler_statement (try_block, inner_eh_construct, + NULL_TREE, BUILTINS_LOCATION); + ctx->add_statement (eh_construct); + // BUILTIN try_handler FN BODY END + finalize_intrinsic_block (ctx, fndecl); + + return fndecl; +} + +static tree +discriminant_value_handler (Context *ctx, TyTy::FnType *fntype) +{ + rust_assert (fntype->get_params ().size () == 1); + rust_assert (fntype->get_return_type ()->is<TyTy::PlaceholderType> ()); + rust_assert (fntype->has_substitutions ()); + rust_assert (fntype->get_num_type_params () == 1); + auto &mapping = fntype->get_substs ().at (0); + auto param_ty = mapping.get_param_ty (); + rust_assert (param_ty->can_resolve ()); + auto resolved = param_ty->resolve (); + auto p = static_cast<TyTy::PlaceholderType *> (fntype->get_return_type ()); + + TyTy::BaseType *return_type = nullptr; + bool ok = ctx->get_tyctx ()->lookup_builtin ("isize", &return_type); + rust_assert (ok); + + bool is_adt = resolved->is<TyTy::ADTType> (); + bool is_enum = false; + if (is_adt) + { + const auto &adt = *static_cast<TyTy::ADTType *> (resolved); + return_type = adt.get_repr_options ().repr; + rust_assert (return_type != nullptr); + is_enum = adt.is_enum (); + } + + p->set_associated_type (return_type->get_ref ()); + + tree lookup = NULL_TREE; + if (check_for_cached_intrinsic (ctx, fntype, &lookup)) + return lookup; + + auto fndecl = compile_intrinsic_function (ctx, fntype); + + std::vector<Bvariable *> param_vars; + compile_fn_params (ctx, fntype, fndecl, ¶m_vars); + + if (!Backend::function_set_parameters (fndecl, param_vars)) + return error_mark_node; + + enter_intrinsic_block (ctx, fndecl); + + // BUILTIN disriminant_value FN BODY BEGIN + + tree result = integer_zero_node; + if (is_enum) + { + tree val = Backend::var_expression (param_vars[0], UNDEF_LOCATION); + tree deref = build_fold_indirect_ref_loc (UNKNOWN_LOCATION, val); + result = Backend::struct_field_expression (deref, 0, UNKNOWN_LOCATION); + } + + auto return_statement + = Backend::return_statement (fndecl, result, BUILTINS_LOCATION); + ctx->add_statement (return_statement); + + // BUILTIN disriminant_value FN BODY END + + finalize_intrinsic_block (ctx, fndecl); + + return fndecl; +} + +static tree +variant_count_handler (Context *ctx, TyTy::FnType *fntype) +{ + rust_assert (fntype->get_num_type_params () == 1); + auto &mapping = fntype->get_substs ().at (0); + auto param_ty = mapping.get_param_ty (); + rust_assert (param_ty->can_resolve ()); + auto resolved = param_ty->resolve (); + + size_t variant_count = 0; + bool is_adt = resolved->is<TyTy::ADTType> (); + if (is_adt) + { + const auto &adt = *static_cast<TyTy::ADTType *> (resolved); + variant_count = adt.number_of_variants (); + } + + tree lookup = NULL_TREE; + if (check_for_cached_intrinsic (ctx, fntype, &lookup)) + return lookup; + + auto fndecl = compile_intrinsic_function (ctx, fntype); + + std::vector<Bvariable *> param_vars; + compile_fn_params (ctx, fntype, fndecl, ¶m_vars); + + if (!Backend::function_set_parameters (fndecl, param_vars)) + return error_mark_node; + + enter_intrinsic_block (ctx, fndecl); + + // BUILTIN disriminant_value FN BODY BEGIN + tree result_decl = DECL_RESULT (fndecl); + tree type = TREE_TYPE (result_decl); + + mpz_t ival; + mpz_init_set_ui (ival, variant_count); + tree result = wide_int_to_tree (type, wi::from_mpz (type, ival, true)); + mpz_clear (ival); + + auto return_statement + = Backend::return_statement (fndecl, result, BUILTINS_LOCATION); + ctx->add_statement (return_statement); + + // BUILTIN disriminant_value FN BODY END finalize_intrinsic_block (ctx, fndecl); |