From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 44993 invoked by alias); 16 Jul 2015 15:21:14 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 44916 invoked by uid 89); 16 Jul 2015 15:21:13 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.0 required=5.0 tests=AWL,BAYES_00,KAM_STOCKGEN,SPF_PASS autolearn=no version=3.3.2 X-HELO: eu-smtp-delivery-143.mimecast.com Received: from eu-smtp-delivery-143.mimecast.com (HELO eu-smtp-delivery-143.mimecast.com) (146.101.78.143) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 16 Jul 2015 15:21:08 +0000 Received: from cam-owa1.Emea.Arm.com (fw-tnat.cambridge.arm.com [217.140.96.140]) by eu-smtp-1.mimecast.com with ESMTP id uk-mta-3-27KKhMqJSKKoz-hqo4VaRQ-1; Thu, 16 Jul 2015 16:21:03 +0100 Received: from [10.2.207.50] ([10.1.2.79]) by cam-owa1.Emea.Arm.com with Microsoft SMTPSVC(6.0.3790.3959); Thu, 16 Jul 2015 16:21:02 +0100 Message-ID: <55A7CBDE.2090609@arm.com> Date: Thu, 16 Jul 2015 15:21:00 -0000 From: Kyrill Tkachov User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:31.0) Gecko/20100101 Thunderbird/31.2.0 MIME-Version: 1.0 To: GCC Patches CC: Marcus Shawcroft , Richard Earnshaw , James Greenhalgh Subject: [PATCH][AArch64][9/14] Implement TARGET_CAN_INLINE_P X-MC-Unique: 27KKhMqJSKKoz-hqo4VaRQ-1 Content-Type: multipart/mixed; boundary="------------090606020206060402040100" X-IsSubscribed: yes X-SW-Source: 2015-07/txt/msg01424.txt.bz2 This is a multi-part message in MIME format. --------------090606020206060402040100 Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: quoted-printable Content-length: 1489 Hi all, This patch implements the target-specific inlining rules. The basic philosophy is that we want to definitely reject inlining if the c= allee's architecture is not a subset, feature-wise, of the caller's. Beyond that, we want to allow inlining if the callee is always_inline. If it's not, we reject inlining if the TargetSave options don't match up in a way that's described in the comments in the patch. Generally, we try to allow as much inlining as possible for the benefit of = LTO. However, if the architectural features of the callee are not a subset of th= e features of the caller, then we must reject inlining. For example, inlining a functi= on with 'simd' into a function without 'simd' is not allowed. Also, inlining a non-strict-align function into a strict-align function is = not allowed. These two restrictions apply even when the callee is tagged with always_inl= ine because they can affect the correctness of the program. Beyond that, we reject inlining only if the user has explicitly specified a= ttributes/options for both the caller and the callee and they don't match up. An exception to that are the tuning CPUs. We want to allow inlining even wh= en the tuning CPUs don't match. Bootstrapped and tested on aarch64. Ok for trunk? Thanks, Kyrill 2015-07-16 Kyrylo Tkachov * config/aarch64/aarch64.c (aarch64_reject_inlining): New function. (aarch64_can_inline_p): Likewise. (TARGET_CAN_INLINE_P): Define. --------------090606020206060402040100 Content-Type: text/x-patch; name=aarch64-attrs-9.patch Content-Transfer-Encoding: quoted-printable Content-Disposition: attachment; filename="aarch64-attrs-9.patch" Content-length: 5005 commit 55e576c7ca01679551404dac9f6302443c2a6bae Author: Kyrylo Tkachov Date: Thu May 14 12:00:07 2015 +0100 [AArch64][9/N] Implement TARGET_CAN_INLINE_P diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c index 0a6ed70..34cd986 100644 --- a/gcc/config/aarch64/aarch64.c +++ b/gcc/config/aarch64/aarch64.c @@ -8486,6 +8486,113 @@ aarch64_option_valid_attribute_p (tree fndecl, tree= , tree args, int) return ret; } =20 +/* Helper for aarch64_can_inline_p. In the case where CALLER and CALLEE a= re + tri-bool options (yes, no, don't care) and the default value is + DEF, determine whether to reject inlining. */ + +static bool +aarch64_reject_inlining (int caller, int callee, int dont_care, int def) +{ + /* If both caller and callee care about the value then reject inlining + if they don't match up. */ + if (caller !=3D dont_care && callee !=3D dont_care && caller !=3D callee) + return true; + + /* If caller doesn't care then make sure that the default agrees + with the callee. */ + if (caller =3D=3D dont_care && callee !=3D dont_care && callee !=3D def) + return true; + + return false; +} + +/* Implement TARGET_CAN_INLINE_P. Decide whether it is valid + to inline CALLE into CALLER based on target-specific info. + Make sure that the caller and callee have compatible architectural + features. Then go through the other possible target attributes + and. Try not to reject always_inline callees unless they are + incompatible architecturally. */ + +static bool +aarch64_can_inline_p (tree caller, tree callee) +{ + bool ret =3D false; + tree caller_tree =3D DECL_FUNCTION_SPECIFIC_TARGET (caller); + tree callee_tree =3D DECL_FUNCTION_SPECIFIC_TARGET (callee); + + /* If callee has no option attributes, then it is ok to inline. */ + if (!callee_tree) + ret =3D true; + else + { + struct cl_target_option *caller_opts + =3D TREE_TARGET_OPTION (caller_tree ? caller_tree + : target_option_default_node); + struct cl_target_option *callee_opts =3D TREE_TARGET_OPTION (callee_= tree); + + + /* Callee's ISA flags should be a subset of the caller's. */ + if ((caller_opts->x_aarch64_isa_flags & callee_opts->x_aarch64_isa_f= lags) + =3D=3D callee_opts->x_aarch64_isa_flags) + ret =3D true; + + /* Allow non-strict aligned functions inlining into strict + aligned ones. */ + if ((TARGET_STRICT_ALIGN_P (caller_opts->x_target_flags) + !=3D TARGET_STRICT_ALIGN_P (callee_opts->x_target_flags)) + && !(!TARGET_STRICT_ALIGN_P (callee_opts->x_target_flags) + && TARGET_STRICT_ALIGN_P (caller_opts->x_target_flags))) + ret =3D false; + + bool always_inline =3D lookup_attribute ("always_inline", + DECL_ATTRIBUTES (callee)); + + /* If the architectural features match up and the callee is always_i= nline + then the other attributes don't matter. */ + if (always_inline) + return ret; + + if (caller_opts->x_aarch64_cmodel_var + !=3D callee_opts->x_aarch64_cmodel_var) + ret =3D false; + + if (caller_opts->x_aarch64_tls_dialect + !=3D callee_opts->x_aarch64_tls_dialect) + ret =3D false; + + + /* Honour explicit requests to workaround errata. */ + if (aarch64_reject_inlining (caller_opts->x_aarch64_fix_a53_err83576= 9, + callee_opts->x_aarch64_fix_a53_err835769, + 2, TARGET_FIX_ERR_A53_835769_DEFAULT)) + ret =3D false; + + /* If the user explicitly specified -momit-leaf-frame-pointer for the + caller and calle and they don't match up, reject inlining. */ + if (aarch64_reject_inlining (caller_opts->x_flag_omit_leaf_frame_poi= nter, + callee_opts->x_flag_omit_leaf_frame_pointer, + 2, 1)) + ret =3D false; + + /* If the callee has specific tuning overrides, respect them. */ + if (callee_opts->x_aarch64_override_tune_string !=3D NULL + && caller_opts->x_aarch64_override_tune_string =3D=3D NULL) + ret =3D false; + + /* If the user specified tuning override strings for the + caller and callee and they don't match up, reject inlining. + We just do a string compare here, we don't analyze the meaning + of the string, as it would be too costly for little gain. */ + if (callee_opts->x_aarch64_override_tune_string + && caller_opts->x_aarch64_override_tune_string + && (strcmp (callee_opts->x_aarch64_override_tune_string, + caller_opts->x_aarch64_override_tune_string) !=3D 0)) + ret =3D false; + } + + return ret; +} + /* Return true if SYMBOL_REF X binds locally. */ =20 static bool @@ -12963,6 +13070,9 @@ aarch64_unspec_may_trap_p (const_rtx x, unsigned fl= ags) #undef TARGET_OPTION_VALID_ATTRIBUTE_P #define TARGET_OPTION_VALID_ATTRIBUTE_P aarch64_option_valid_attribute_p =20 +#undef TARGET_CAN_INLINE_P +#define TARGET_CAN_INLINE_P aarch64_can_inline_p + #undef TARGET_PASS_BY_REFERENCE #define TARGET_PASS_BY_REFERENCE aarch64_pass_by_reference =20 --------------090606020206060402040100--