From patchwork Mon Aug 28 10:05:37 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 111136 Delivered-To: patch@linaro.org Received: by 10.140.95.78 with SMTP id h72csp4613763qge; Mon, 28 Aug 2017 03:06:15 -0700 (PDT) X-Received: by 10.84.224.10 with SMTP id r10mr34274plj.149.1503914775480; Mon, 28 Aug 2017 03:06:15 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1503914775; cv=none; d=google.com; s=arc-20160816; b=poTbo1X909jjGPKuDTN7vahG7iUxYNzoQvpWRHRQo6cV0oI1hAORqg7lBtw4lE66cB gKDUEMjnqXDLtSUt20wyuzAqd78f2iraP2CX0hYNQGMxZLfWO76uO/dYBvzMi43YL3Kg RXmg+aTQ7kq5BflbGu7He2SFWmTpQTwGb97XaYns0Q9hzO2bHkN0bmB2hAYgxLKWqvrV yGi7ldKutPe0njoj0EESTmcTdIuJrHST+lAkSVrLqkai0ynGkXSTiloyMSUaXL7D1VNO nRbGLUEKfo4DEz/3I7nmehxZs+pPkgEwNPBDstqMBWenAEuLCXZ3h9VRXv3hQnboCPae 5OSg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=mime-version:user-agent:message-id:date:subject:mail-followup-to:to :from:delivered-to:sender:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:mailing-list:dkim-signature :domainkey-signature:arc-authentication-results; bh=ILwZrzRQTi+BKJIAUr/aVJyjKI7x4gId6yAHC23Qdq4=; b=hgE+CM+zZRRzR+ya3Uoxnp1sf+j38ZBi85bm3S4O9wdlqXO3V/shC853+zicomWDGy mxK9sAvXAhzmA+dXyh70W7ivjyATzmSHDa973AG4d/+dS/Wo8fvvhTfIPswhIJCrJO5k XAgZieH2o8aKBlBbXr8i4CasaX5ax+ZeXnCURcdYVxy7CwZHgYzk2Metu/J3ciHclXh8 bg5x3vPc7OmaNdORfKK2GXpuknU/6MgYxJieAh7tsK/sJU6MR1Vsp/Fb+I8yV5JYfrlt w9LLMbwnGEvmcwE5y2QV2ReJKDzh8lhHGAKlCQ2d6iTrHtA0AsMZ36QlxRtwcNqvbiO+ TVww== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=d4WJXyDm; spf=pass (google.com: domain of gcc-patches-return-461006-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=gcc-patches-return-461006-patch=linaro.org@gcc.gnu.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id q68si20032pga.389.2017.08.28.03.06.15 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Aug 2017 03:06:15 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-return-461006-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=d4WJXyDm; spf=pass (google.com: domain of gcc-patches-return-461006-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=gcc-patches-return-461006-patch=linaro.org@gcc.gnu.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:date:message-id:mime-version:content-type; q=dns; s= default; b=f/VRE7QcPWWIs4OSxSr9GP8PwcenUlo63K5/51kXHmQu7xit1UA9f jCOB9zejDlHmlG1/odvtUhPrnCDdW+40ntmm4gM6tpmTgSxeeOuqwkeZ7SVXIfZb IK3RdPQynCWNSybGCdy3WFmEWvqvPsmGAWL5ItaeZPP9QK3MlYOPKw= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:date:message-id:mime-version:content-type; s= default; bh=lS5132wejWUbtY4VkOPRXnFeB+Y=; b=d4WJXyDmRkgZUlCQUuo+ UcQu/Ti5783FG2YPOuo94uljMhYGuHMbRiv/eN/wKHzpQbD9m4t5D0/nn9G7L9fw xltLvcW8OFKloQPbpZeyxus18jnzVmcpR8Q7LK3ALx61RG1b0yVfCCUV3H4zUACL qbceN+qrzA4ks88KSQ59VR8= Received: (qmail 66987 invoked by alias); 28 Aug 2017 10:05:51 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 65018 invoked by uid 89); 28 Aug 2017 10:05:50 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-11.1 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.2 spammy= X-HELO: mail-wm0-f48.google.com Received: from mail-wm0-f48.google.com (HELO mail-wm0-f48.google.com) (74.125.82.48) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 28 Aug 2017 10:05:39 +0000 Received: by mail-wm0-f48.google.com with SMTP id u26so520297wma.0 for ; Mon, 28 Aug 2017 03:05:38 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:mail-followup-to:subject:date:message-id :user-agent:mime-version; bh=ILwZrzRQTi+BKJIAUr/aVJyjKI7x4gId6yAHC23Qdq4=; b=ATdb5k5/0twqXU0Z71TruiEDQVe+VQ61CeEf0qDgNXD7PDoDoM3gYvSRShTf/0SB3l 5tU0dZTQ+qsfm359U9nhfQNLRwf0pYRcLCxK1aqdIaLVCkgOzwdCx1voXmvzMsZtoc8V AG5FTEpWR9etQKnyc7Heg2GYybUjiUFDgIHePQOGdIxg4D1CKZp+nv4sIrfS3Dkv2fvv OsvpldP2aIuBWvaznMFWCSTMeCWWBMDorX/WMbqkPrCsFmsQO8K9vY1aspm9gkGQAwUP nzajnz0Iou+yJ77ND9LsgHd8dQ8NKbhK4ErAFXGdFW5t0LuaWpyPloNohAfHNsoZYwcc Ifrg== X-Gm-Message-State: AHYfb5h6YcGkwzIDQKj7QMNwjYpYLx4z2t2A556AS0GDXRmkgedQn2Oz b6qkW5r62FzkmjR35y1anA== X-Received: by 10.28.144.194 with SMTP id s185mr38822wmd.92.1503914734400; Mon, 28 Aug 2017 03:05:34 -0700 (PDT) Received: from localhost ([95.145.139.63]) by smtp.gmail.com with ESMTPSA id z66sm31477wme.34.2017.08.28.03.05.29 for (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Aug 2017 03:05:33 -0700 (PDT) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@linaro.org Subject: Turn FUNCTION_ARG_PADDING into a target hook Date: Mon, 28 Aug 2017 11:05:37 +0100 Message-ID: <8760d8t3bi.fsf@linaro.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/25.2 (gnu/linux) MIME-Version: 1.0 This involved renaming the rather general-sounding "enum direction" to "enum pad_direction" to avoid a conflict with the Fortran frontend. Tested on aarch64-linux-gnu, x86_64-linux-gnu and powerpc64le-linux-gnu. Also tested by checking that there were no extra warnings or changes in testsuite assembly output for at least one target per CPU. OK to install? Richard 2017-08-28 Richard Sandiford Alan Hayward David Sherwood gcc/ * coretypes.h (pad_direction): New enum. * defaults.h (DEFAULT_FUNCTION_ARG_PADDING): Delete. (FUNCTION_ARG_PADDING): Likewise. * target.def (function_arg_padding): New hook. * targhooks.h (default_function_arg_padding): Declare. * targhooks.c (default_function_arg_padding): New function. * doc/tm.texi.in (FUNCTION_ARG_PADDING): Replace with... (TARGET_FUNCTION_ARG_PADDING): ...this. * doc/tm.texi: Regenerate. * calls.c (store_unaligned_arguments_into_pseudos): Use pad_direction instead of direction. (compute_argument_addresses): Likewise. (load_register_parameters): Likewise. (emit_library_call_value_1): Likewise. (store_one_arg): Use targetm.calls.function_arg_padding instead of FUNCTION_ARG_PADDING. (must_pass_in_stack_var_size_or_pad): Likewise. * expr.c (emit_group_load_1): Use pad_direction instead of direction. (emit_group_store): Likewise. (emit_single_push_insn_1): Use targetm.calls.function_arg_padding instead of FUNCTION_ARG_PADDING. (emit_push_insn): Likewise, and propagate enum change throughout function. * function.h (direction): Delete. (locate_and_pad_arg_data::where_pad): Use pad_direction instead of direction. * function.c (assign_parm_find_stack_rtl): Likewise. (assign_parm_setup_block_p): Likewise. (assign_parm_setup_block): Likewise. (gimplify_parameters): Likewise. (locate_and_pad_parm): Use targetm.calls.function_arg_padding instead of FUNCTION_ARG_PADDING, and propagate enum change throughout function. * config/aarch64/aarch64.h (FUNCTION_ARG_PADDING): Delete. (BLOCK_REG_PADDING): Use pad_direction instead of direction. * config/aarch64/aarch64-protos.h (aarch64_pad_arg_upward): Delete. * config/aarch64/aarch64.c (aarch64_pad_arg_upward): Replace with... (aarch64_function_arg_padding): ...this new function. (aarch64_gimplify_va_arg_expr): Use pad_direction instead of direction. (TARGET_FUNCTION_ARG_PADDING): Redefine. * config/arm/arm.h (FUNCTION_ARG_PADDING): Delete. (BLOCK_REG_PADDING): Use pad_direction instead of direction. * config/arm/arm-protos.h (arm_pad_arg_upward): Delete. * config/arm/arm.c (TARGET_FUNCTION_ARG_PADDING): Redefine. (arm_pad_arg_upward): Replace with... (arm_function_arg_padding): ...this new function. * config/c6x/c6x.h (BLOCK_REG_PADDING): Use pad_direction instead of direction. * config/ia64/hpux.h (FUNCTION_ARG_PADDING): Delete. * config/ia64/ia64-protos.h (ia64_hpux_function_arg_padding): Delete. * config/ia64/ia64.c (TARGET_FUNCTION_ARG_PADDING): Redefine. (ia64_hpux_function_arg_padding): Replace with... (ia64_function_arg_padding): ...this new function. Use pad_direction instead of direction. Check for TARGET_HPUX. * config/iq2000/iq2000.h (FUNCTION_ARG_PADDING): Delete. * config/iq2000/iq2000.c (TARGET_FUNCTION_ARG_PADDING): Redefine. (iq2000_function_arg_padding): New function. * config/mips/mips-protos.h (mips_pad_arg_upward): Delete. * config/mips/mips.c (mips_pad_arg_upward): Replace with... (mips_function_arg_padding): ...this new function. (mips_pad_reg_upward): Update accordingly. (TARGET_FUNCTION_ARG_PADDING): Redefine. * config/mips/mips.h (PAD_VARARGS_DOWN): Use targetm.calls.function_arg_padding. (FUNCTION_ARG_PADDING): Delete. (BLOCK_REG_PADDING): Use pad_direction instead of direction. * config/nios2/nios2.h (FUNCTION_ARG_PADDING): Delete. (PAD_VARARGS_DOWN): Use targetm.calls.function_arg_padding. * config/nios2/nios2-protos.h (nios2_function_arg_padding): Delete. (nios2_block_reg_padding): Return pad_direction instead of direction. * config/nios2/nios2.c (nios2_block_reg_padding): Return pad_direction instead of direction. (nios2_function_arg_padding): Likewise. Make static. (TARGET_FUNCTION_ARG_PADDING): Redefine. * config/pa/pa.h (FUNCTION_ARG_PADDING): Delete. (BLOCK_REG_PADDING): Use targetm.calls.function_arg_padding. * config/pa/pa-protos.h (pa_function_arg_padding): Delete. * config/pa/pa.c (TARGET_FUNCTION_ARG_PADDING): Redefine. (pa_function_arg_padding): Make static. Return pad_direction instead of direction. * config/powerpcspe/powerpcspe.h (FUNCTION_ARG_PADDING): Delete. (PAD_VARARGS_DOWN): Use targetm.calls.function_arg_padding. * config/powerpcspe/aix.h (BLOCK_REG_PADDING): Use pad_direction instead of direction. Use targetm.calls.function_arg_padding. * config/powerpcspe/darwin.h (BLOCK_REG_PADDING): Likewise. * config/powerpcspe/freebsd64.h (BLOCK_REG_PADDING): Likewise. * config/powerpcspe/linux64.h (BLOCK_REG_PADDING): Likewise. * config/powerpcspe/powerpcspe-protos.h (function_arg_padding): Delete. * config/powerpcspe/powerpcspe.c (TARGET_FUNCTION_ARG_PADDING): Redefine. (function_arg_padding): Rename to... (rs6000_function_arg_padding): ...this. Make static. Return pad_direction instead of direction. (rs6000_return_in_msb): Use rs6000_function_arg_padding. * config/rs6000/rs6000.h (FUNCTION_ARG_PADDING): Delete. (PAD_VARARGS_DOWN): Use targetm.calls.function_arg_padding. * config/rs6000/aix.h (BLOCK_REG_PADDING): Use pad_direction instead of direction. Use targetm.calls.function_arg_padding. * config/rs6000/darwin.h (BLOCK_REG_PADDING): Likewise. * config/rs6000/freebsd64.h (BLOCK_REG_PADDING): Likewise. * config/rs6000/linux64.h (BLOCK_REG_PADDING): Likewise. * config/rs6000/rs6000-protos.h (function_arg_padding): Delete. * config/rs6000/rs6000.c (TARGET_FUNCTION_ARG_PADDING): Redefine. (function_arg_padding): Rename to... (rs6000_function_arg_padding): ...this. Make static. Return pad_direction instead of direction. (rs6000_return_in_msb): Use rs6000_function_arg_padding. * config/s390/s390.h (FUNCTION_ARG_PADDING): Delete. * config/s390/s390.c (s390_function_arg_padding): New function. (TARGET_FUNCTION_ARG_PADDING): Redefine. * config/sparc/sparc.h (FUNCTION_ARG_PADDING): Delete. * config/sparc/sparc-protos.h (function_arg_padding): Delete. * config/sparc/sparc.c (TARGET_FUNCTION_ARG_PADDING): Redefine. (function_arg_padding): Rename to... (sparc_function_arg_padding): ...this. Make static. Return pad_direction instead of direction. * config/spu/spu.h (FUNCTION_ARG_PADDING): Delete. * config/spu/spu.c (spu_function_arg_padding): New function. (TARGET_FUNCTION_ARG_PADDING): Redefine. * system.h (FUNCTION_ARG_PADDING): Poison. Index: gcc/coretypes.h =================================================================== --- gcc/coretypes.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/coretypes.h 2017-08-28 11:03:59.142665850 +0100 @@ -219,6 +219,22 @@ enum optimization_type { OPTIMIZE_FOR_SIZE }; +/* Enumerates a padding direction. */ +enum pad_direction { + /* No padding is required. */ + PAD_NONE, + + /* Insert padding above the data, i.e. at higher memeory addresses + when dealing with memory, and at the most significant end when + dealing with registers. */ + PAD_UPWARD, + + /* Insert padding below the data, i.e. at lower memeory addresses + when dealing with memory, and at the least significant end when + dealing with registers. */ + PAD_DOWNWARD +}; + /* Possible initialization status of a variable. When requested by the user, this information is tracked and recorded in the DWARF debug information, along with the variable's location. */ Index: gcc/defaults.h =================================================================== --- gcc/defaults.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/defaults.h 2017-08-28 11:03:59.142665850 +0100 @@ -1355,24 +1355,6 @@ #define CLEAR_RATIO(speed) ((speed) ? 15 #define SET_RATIO(speed) MOVE_RATIO (speed) #endif -/* Supply a default definition for FUNCTION_ARG_PADDING: - usually pad upward, but pad short args downward on - big-endian machines. */ - -#define DEFAULT_FUNCTION_ARG_PADDING(MODE, TYPE) \ - (! BYTES_BIG_ENDIAN \ - ? upward \ - : (((MODE) == BLKmode \ - ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ - && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \ - : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \ - ? downward : upward)) - -#ifndef FUNCTION_ARG_PADDING -#define FUNCTION_ARG_PADDING(MODE, TYPE) \ - DEFAULT_FUNCTION_ARG_PADDING ((MODE), (TYPE)) -#endif - /* Supply a default definition of STACK_SAVEAREA_MODE for emit_stack_save. Normally move_insn, so Pmode stack pointer. */ Index: gcc/target.def =================================================================== --- gcc/target.def 2017-08-28 11:03:58.526233104 +0100 +++ gcc/target.def 2017-08-28 11:03:59.146688249 +0100 @@ -4533,6 +4533,24 @@ used for arguments without any special h (cumulative_args_t ca, machine_mode mode, const_tree type, bool named), default_function_arg_advance) +DEFHOOK +(function_arg_padding, + "This hook determines whether, and in which direction, to pad out\n\ +an argument of mode @var{mode} and type @var{type}. It returns\n\ +@code{PAD_UPWARD} to insert padding above the argument, @code{PAD_DOWNWARD}\n\ +to insert padding below the argument, or @code{PAD_NONE} to inhibit padding.\n\ +\n\ +The @emph{amount} of padding is not controlled by this hook, but by\n\ +@code{TARGET_FUNCTION_ARG_ROUND_BOUNDARY}. It is always just enough\n\ +to reach the next multiple of that boundary.\n\ +\n\ +This hook has a default definition that is right for most systems.\n\ +For little-endian machines, the default is to pad upward. For\n\ +big-endian machines, the default is to pad downward for an argument of\n\ +constant size shorter than an @code{int}, and upward otherwise.", + pad_direction, (machine_mode mode, const_tree type), + default_function_arg_padding) + /* Return zero if the argument described by the state of CA should be placed on a stack, or a hard register in which to store the argument. The values MODE, TYPE, and NAMED describe that Index: gcc/targhooks.h =================================================================== --- gcc/targhooks.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/targhooks.h 2017-08-28 11:03:59.146688249 +0100 @@ -132,6 +132,7 @@ extern bool hook_bool_CUMULATIVE_ARGS_tr (const_tree, const_tree, const_tree); extern void default_function_arg_advance (cumulative_args_t, machine_mode, const_tree, bool); +extern pad_direction default_function_arg_padding (machine_mode, const_tree); extern rtx default_function_arg (cumulative_args_t, machine_mode, const_tree, bool); extern rtx default_function_incoming_arg Index: gcc/targhooks.c =================================================================== --- gcc/targhooks.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/targhooks.c 2017-08-28 11:03:59.146688249 +0100 @@ -733,6 +733,31 @@ default_function_arg_advance (cumulative gcc_unreachable (); } +/* Default implementation of TARGET_FUNCTION_ARG_PADDING: usually pad + upward, but pad short args downward on big-endian machines. */ + +pad_direction +default_function_arg_padding (machine_mode mode, const_tree type) +{ + if (!BYTES_BIG_ENDIAN) + return PAD_UPWARD; + + unsigned HOST_WIDE_INT size; + if (mode == BLKmode) + { + if (!type || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) + return PAD_UPWARD; + size = int_size_in_bytes (type); + } + else + size = GET_MODE_SIZE (mode); + + if (size < (PARM_BOUNDARY / BITS_PER_UNIT)) + return PAD_DOWNWARD; + + return PAD_UPWARD; +} + rtx default_function_arg (cumulative_args_t ca ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED, Index: gcc/doc/tm.texi.in =================================================================== --- gcc/doc/tm.texi.in 2017-08-28 11:03:58.526233104 +0100 +++ gcc/doc/tm.texi.in 2017-08-28 11:03:59.144677050 +0100 @@ -3363,21 +3363,7 @@ slot that is in the middle of the quad w top. @end defmac -@defmac FUNCTION_ARG_PADDING (@var{mode}, @var{type}) -If defined, a C expression which determines whether, and in which direction, -to pad out an argument with extra space. The value should be of type -@code{enum direction}: either @code{upward} to pad above the argument, -@code{downward} to pad below, or @code{none} to inhibit padding. - -The @emph{amount} of padding is not controlled by this macro, but by the -target hook @code{TARGET_FUNCTION_ARG_ROUND_BOUNDARY}. It is -always just enough to reach the next multiple of that boundary. - -This macro has a default definition which is right for most systems. -For little-endian machines, the default is to pad upward. For -big-endian machines, the default is to pad downward for an argument of -constant size shorter than an @code{int}, and upward otherwise. -@end defmac +@hook TARGET_FUNCTION_ARG_PADDING @defmac PAD_VARARGS_DOWN If defined, a C expression which determines whether the default Index: gcc/doc/tm.texi =================================================================== --- gcc/doc/tm.texi 2017-08-28 11:03:58.526233104 +0100 +++ gcc/doc/tm.texi 2017-08-28 11:03:59.143671450 +0100 @@ -4096,21 +4096,21 @@ slot that is in the middle of the quad w top. @end defmac -@defmac FUNCTION_ARG_PADDING (@var{mode}, @var{type}) -If defined, a C expression which determines whether, and in which direction, -to pad out an argument with extra space. The value should be of type -@code{enum direction}: either @code{upward} to pad above the argument, -@code{downward} to pad below, or @code{none} to inhibit padding. +@deftypefn {Target Hook} pad_direction TARGET_FUNCTION_ARG_PADDING (machine_mode @var{mode}, const_tree @var{type}) +This hook determines whether, and in which direction, to pad out +an argument of mode @var{mode} and type @var{type}. It returns +@code{PAD_UPWARD} to insert padding above the argument, @code{PAD_DOWNWARD} +to insert padding below the argument, or @code{PAD_NONE} to inhibit padding. -The @emph{amount} of padding is not controlled by this macro, but by the -target hook @code{TARGET_FUNCTION_ARG_ROUND_BOUNDARY}. It is -always just enough to reach the next multiple of that boundary. +The @emph{amount} of padding is not controlled by this hook, but by +@code{TARGET_FUNCTION_ARG_ROUND_BOUNDARY}. It is always just enough +to reach the next multiple of that boundary. -This macro has a default definition which is right for most systems. +This hook has a default definition that is right for most systems. For little-endian machines, the default is to pad upward. For big-endian machines, the default is to pad downward for an argument of constant size shorter than an @code{int}, and upward otherwise. -@end defmac +@end deftypefn @defmac PAD_VARARGS_DOWN If defined, a C expression which determines whether the default Index: gcc/calls.c =================================================================== --- gcc/calls.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/calls.c 2017-08-28 11:03:59.120542652 +0100 @@ -1153,7 +1153,7 @@ store_unaligned_arguments_into_pseudos ( #ifdef BLOCK_REG_PADDING && (BLOCK_REG_PADDING (args[i].mode, TREE_TYPE (args[i].tree_value), 1) - == downward) + == PAD_DOWNWARD) #else && BYTES_BIG_ENDIAN #endif @@ -2221,7 +2221,7 @@ compute_argument_addresses (struct arg_d } align = BITS_PER_UNIT; boundary = args[i].locate.boundary; - if (args[i].locate.where_pad != downward) + if (args[i].locate.where_pad != PAD_DOWNWARD) align = boundary; else if (CONST_INT_P (offset)) { @@ -2518,7 +2518,7 @@ load_register_parameters (struct arg_dat upward on a BYTES_BIG_ENDIAN machine. */ if (size < UNITS_PER_WORD && (args[i].locate.where_pad - == (BYTES_BIG_ENDIAN ? upward : downward))) + == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD))) { rtx x; int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT; @@ -2579,7 +2579,7 @@ load_register_parameters (struct arg_dat /* Handle a BLKmode that needs shifting. */ if (nregs == 1 && size < UNITS_PER_WORD #ifdef BLOCK_REG_PADDING - && args[i].locate.where_pad == downward + && args[i].locate.where_pad == PAD_DOWNWARD #else && BYTES_BIG_ENDIAN #endif @@ -4900,7 +4900,7 @@ emit_library_call_value_1 (int retval, r upward on a BYTES_BIG_ENDIAN machine. */ if (size < UNITS_PER_WORD && (argvec[argnum].locate.where_pad - == (BYTES_BIG_ENDIAN ? upward : downward))) + == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD))) { rtx x; int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT; @@ -5423,14 +5423,16 @@ store_one_arg (struct arg_data *arg, rtx /* Compute how much space the argument should get: round up to a multiple of the alignment for arguments. */ - if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval))) + if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval)) + != PAD_NONE) used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1) / (PARM_BOUNDARY / BITS_PER_UNIT)) * (PARM_BOUNDARY / BITS_PER_UNIT)); /* Compute the alignment of the pushed argument. */ parm_align = arg->locate.boundary; - if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward) + if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval)) + == PAD_DOWNWARD) { int pad = used - size; if (pad) @@ -5489,7 +5491,8 @@ store_one_arg (struct arg_data *arg, rtx /* When an argument is padded down, the block is aligned to PARM_BOUNDARY, but the actual argument isn't. */ - if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward) + if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval)) + == PAD_DOWNWARD) { if (arg->locate.size.var) parm_align = BITS_PER_UNIT; @@ -5640,8 +5643,8 @@ must_pass_in_stack_var_size_or_pad (mach a register would put it into the wrong part of the register. */ if (mode == BLKmode && int_size_in_bytes (type) % (PARM_BOUNDARY / BITS_PER_UNIT) - && (FUNCTION_ARG_PADDING (mode, type) - == (BYTES_BIG_ENDIAN ? upward : downward))) + && (targetm.calls.function_arg_padding (mode, type) + == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD))) return true; return false; Index: gcc/expr.c =================================================================== --- gcc/expr.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/expr.c 2017-08-28 11:03:59.145682649 +0100 @@ -2134,7 +2134,7 @@ emit_group_load_1 (rtx *tmps, rtx dst, r if ( #ifdef BLOCK_REG_PADDING BLOCK_REG_PADDING (GET_MODE (orig_src), type, i == start) - == (BYTES_BIG_ENDIAN ? upward : downward) + == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD) #else BYTES_BIG_ENDIAN #endif @@ -2544,7 +2544,7 @@ emit_group_store (rtx orig_dst, rtx src, if ( #ifdef BLOCK_REG_PADDING BLOCK_REG_PADDING (GET_MODE (orig_dst), type, i == start) - == (BYTES_BIG_ENDIAN ? upward : downward) + == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD) #else BYTES_BIG_ENDIAN #endif @@ -4115,7 +4115,7 @@ emit_single_push_insn_1 (machine_mode mo then store X into the stack location using an offset. This is because emit_move_insn does not know how to pad; it does not have access to type. */ - else if (FUNCTION_ARG_PADDING (mode, type) == downward) + else if (targetm.calls.function_arg_padding (mode, type) == PAD_DOWNWARD) { unsigned padding_size = rounded_size - GET_MODE_SIZE (mode); HOST_WIDE_INT offset; @@ -4259,18 +4259,19 @@ emit_push_insn (rtx x, machine_mode mode rtx alignment_pad, bool sibcall_p) { rtx xinner; - enum direction stack_direction = STACK_GROWS_DOWNWARD ? downward : upward; + pad_direction stack_direction + = STACK_GROWS_DOWNWARD ? PAD_DOWNWARD : PAD_UPWARD; - /* Decide where to pad the argument: `downward' for below, - `upward' for above, or `none' for don't pad it. + /* Decide where to pad the argument: PAD_DOWNWARD for below, + PAD_UPWARD for above, or PAD_NONE for don't pad it. Default is below for small data on big-endian machines; else above. */ - enum direction where_pad = FUNCTION_ARG_PADDING (mode, type); + pad_direction where_pad = targetm.calls.function_arg_padding (mode, type); /* Invert direction if stack is post-decrement. FIXME: why? */ if (STACK_PUSH_CODE == POST_DEC) - if (where_pad != none) - where_pad = (where_pad == downward ? upward : downward); + if (where_pad != PAD_NONE) + where_pad = (where_pad == PAD_DOWNWARD ? PAD_UPWARD : PAD_DOWNWARD); xinner = x; @@ -4342,7 +4343,7 @@ emit_push_insn (rtx x, machine_mode mode or if padding below and stack grows up. But if space already allocated, this has already been done. */ if (extra && args_addr == 0 - && where_pad != none && where_pad != stack_direction) + && where_pad != PAD_NONE && where_pad != stack_direction) anti_adjust_stack (GEN_INT (extra)); move_by_pieces (NULL, xinner, INTVAL (size) - used, align, 0); @@ -4371,7 +4372,7 @@ emit_push_insn (rtx x, machine_mode mode A single stack adjust will do. */ if (! args_addr) { - temp = push_block (size, extra, where_pad == downward); + temp = push_block (size, extra, where_pad == PAD_DOWNWARD); extra = 0; } else if (CONST_INT_P (args_so_far)) @@ -4465,7 +4466,7 @@ emit_push_insn (rtx x, machine_mode mode or if padding below and stack grows up. But if space already allocated, this has already been done. */ if (extra && args_addr == 0 - && where_pad != none && where_pad != stack_direction) + && where_pad != PAD_NONE && where_pad != stack_direction) anti_adjust_stack (GEN_INT (extra)); /* If we make space by pushing it, we might as well push @@ -4516,7 +4517,7 @@ emit_push_insn (rtx x, machine_mode mode or if padding below and stack grows up. But if space already allocated, this has already been done. */ if (extra && args_addr == 0 - && where_pad != none && where_pad != stack_direction) + && where_pad != PAD_NONE && where_pad != stack_direction) anti_adjust_stack (GEN_INT (extra)); #ifdef PUSH_ROUNDING Index: gcc/function.h =================================================================== --- gcc/function.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/function.h 2017-08-28 11:03:59.145682649 +0100 @@ -469,8 +469,6 @@ #define VALUE_HISTOGRAMS(fun) (fun)->val data structures. */ extern struct machine_function * (*init_machine_status) (void); -enum direction {none, upward, downward}; - /* Structure to record the size of a sequence of arguments as the sum of a tree-expression and a constant. This structure is also used to store offsets from the stack, which might be negative, @@ -499,7 +497,7 @@ struct locate_and_pad_arg_data force alignment for the next argument. */ struct args_size alignment_pad; /* Which way we should pad this arg. */ - enum direction where_pad; + pad_direction where_pad; /* slot_offset is at least this aligned. */ unsigned int boundary; }; Index: gcc/function.c =================================================================== --- gcc/function.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/function.c 2017-08-28 11:03:59.145682649 +0100 @@ -2713,7 +2713,7 @@ assign_parm_find_stack_rtl (tree parm, s is TARGET_FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're intentionally forcing upward padding. Otherwise we have to come up with a guess at the alignment based on OFFSET_RTX. */ - if (data->locate.where_pad != downward || data->entry_parm) + if (data->locate.where_pad != PAD_DOWNWARD || data->entry_parm) align = boundary; else if (CONST_INT_P (offset_rtx)) { @@ -2867,7 +2867,7 @@ assign_parm_setup_block_p (struct assign if (REG_P (data->entry_parm) && GET_MODE_SIZE (data->promoted_mode) < UNITS_PER_WORD && (BLOCK_REG_PADDING (data->passed_mode, data->passed_type, 1) - == (BYTES_BIG_ENDIAN ? upward : downward))) + == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD))) return true; #endif @@ -2985,7 +2985,7 @@ assign_parm_setup_block (struct assign_p #ifdef BLOCK_REG_PADDING && (size == UNITS_PER_WORD || (BLOCK_REG_PADDING (mode, data->passed_type, 1) - != (BYTES_BIG_ENDIAN ? upward : downward))) + != (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD))) #endif ) { @@ -3025,7 +3025,7 @@ assign_parm_setup_block (struct assign_p gcc_checking_assert (BYTES_BIG_ENDIAN && (BLOCK_REG_PADDING (mode, data->passed_type, 1) - == upward)); + == PAD_UPWARD)); int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT; @@ -3046,7 +3046,7 @@ assign_parm_setup_block (struct assign_p else if (size != UNITS_PER_WORD #ifdef BLOCK_REG_PADDING && (BLOCK_REG_PADDING (mode, data->passed_type, 1) - == downward) + == PAD_DOWNWARD) #else && BYTES_BIG_ENDIAN #endif @@ -3070,7 +3070,7 @@ assign_parm_setup_block (struct assign_p #ifdef BLOCK_REG_PADDING gcc_checking_assert (BLOCK_REG_PADDING (GET_MODE (mem), data->passed_type, 0) - == upward); + == PAD_UPWARD); #endif emit_move_insn (mem, entry_parm); } @@ -4099,7 +4099,7 @@ gimplify_parameters (void) rounding affects the initial and starting offsets, but not the argument size. - The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY, + The second, controlled by TARGET_FUNCTION_ARG_PADDING and PARM_BOUNDARY, optionally rounds the size of the parm to PARM_BOUNDARY. The initial offset is not affected by this rounding, while the size always is and the starting offset may be. */ @@ -4117,7 +4117,7 @@ locate_and_pad_parm (machine_mode passed struct locate_and_pad_arg_data *locate) { tree sizetree; - enum direction where_pad; + pad_direction where_pad; unsigned int boundary, round_boundary; int part_size_in_regs; @@ -4143,7 +4143,7 @@ locate_and_pad_parm (machine_mode passed sizetree = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode)); - where_pad = FUNCTION_ARG_PADDING (passed_mode, type); + where_pad = targetm.calls.function_arg_padding (passed_mode, type); boundary = targetm.calls.function_arg_boundary (passed_mode, type); round_boundary = targetm.calls.function_arg_round_boundary (passed_mode, type); @@ -4192,7 +4192,7 @@ locate_and_pad_parm (machine_mode passed { tree s2 = sizetree; - if (where_pad != none + if (where_pad != PAD_NONE && (!tree_fits_uhwi_p (sizetree) || (tree_to_uhwi (sizetree) * BITS_PER_UNIT) % round_boundary)) s2 = round_up (s2, round_boundary / BITS_PER_UNIT); @@ -4217,7 +4217,7 @@ locate_and_pad_parm (machine_mode passed /* Pad_below needs the pre-rounded size to know how much to pad below. */ locate->offset = locate->slot_offset; - if (where_pad == downward) + if (where_pad == PAD_DOWNWARD) pad_below (&locate->offset, passed_mode, sizetree); } @@ -4236,10 +4236,10 @@ locate_and_pad_parm (machine_mode passed /* Pad_below needs the pre-rounded size to know how much to pad below so this must be done before rounding up. */ locate->offset = locate->slot_offset; - if (where_pad == downward) + if (where_pad == PAD_DOWNWARD) pad_below (&locate->offset, passed_mode, sizetree); - if (where_pad != none + if (where_pad != PAD_NONE && (!tree_fits_uhwi_p (sizetree) || (tree_to_uhwi (sizetree) * BITS_PER_UNIT) % round_boundary)) sizetree = round_up (sizetree, round_boundary / BITS_PER_UNIT); Index: gcc/config/aarch64/aarch64.h =================================================================== --- gcc/config/aarch64/aarch64.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/aarch64/aarch64.h 2017-08-28 11:03:59.122553852 +0100 @@ -668,11 +668,8 @@ typedef struct } CUMULATIVE_ARGS; #endif -#define FUNCTION_ARG_PADDING(MODE, TYPE) \ - (aarch64_pad_arg_upward (MODE, TYPE) ? upward : downward) - #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - (aarch64_pad_reg_upward (MODE, TYPE, FIRST) ? upward : downward) + (aarch64_pad_reg_upward (MODE, TYPE, FIRST) ? PAD_UPWARD : PAD_DOWNWARD) #define PAD_VARARGS_DOWN 0 Index: gcc/config/aarch64/aarch64-protos.h =================================================================== --- gcc/config/aarch64/aarch64-protos.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/aarch64/aarch64-protos.h 2017-08-28 11:03:59.120542652 +0100 @@ -347,7 +347,6 @@ rtx aarch64_reverse_mask (machine_mode); bool aarch64_offset_7bit_signed_scaled_p (machine_mode, HOST_WIDE_INT); char *aarch64_output_scalar_simd_mov_immediate (rtx, machine_mode); char *aarch64_output_simd_mov_immediate (rtx, machine_mode, unsigned); -bool aarch64_pad_arg_upward (machine_mode, const_tree); bool aarch64_pad_reg_upward (machine_mode, const_tree, bool); bool aarch64_regno_ok_for_base_p (int, bool); bool aarch64_regno_ok_for_index_p (int, bool); Index: gcc/config/aarch64/aarch64.c =================================================================== --- gcc/config/aarch64/aarch64.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/aarch64/aarch64.c 2017-08-28 11:03:59.121548252 +0100 @@ -2593,22 +2593,19 @@ aarch64_function_arg_boundary (machine_m return MIN (MAX (alignment, PARM_BOUNDARY), STACK_BOUNDARY); } -/* For use by FUNCTION_ARG_PADDING (MODE, TYPE). - - Return true if an argument passed on the stack should be padded upwards, - i.e. if the least-significant byte of the stack slot has useful data. +/* Implement TARGET_FUNCTION_ARG_PADDING. Small aggregate types are placed in the lowest memory address. The related parameter passing rules are B.4, C.3, C.5 and C.14. */ -bool -aarch64_pad_arg_upward (machine_mode mode, const_tree type) +static pad_direction +aarch64_function_arg_padding (machine_mode mode, const_tree type) { /* On little-endian targets, the least significant byte of every stack argument is passed at the lowest byte address of the stack slot. */ if (!BYTES_BIG_ENDIAN) - return true; + return PAD_UPWARD; /* Otherwise, integral, floating-point and pointer types are padded downward: the least significant byte of a stack argument is passed at the highest @@ -2617,10 +2614,10 @@ aarch64_pad_arg_upward (machine_mode mod ? (INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type) || POINTER_TYPE_P (type)) : (SCALAR_INT_MODE_P (mode) || SCALAR_FLOAT_MODE_P (mode))) - return false; + return PAD_DOWNWARD; /* Everything else padded upward, i.e. data in first byte of stack slot. */ - return true; + return PAD_UPWARD; } /* Similarly, for use by BLOCK_REG_PADDING (MODE, TYPE, FIRST). @@ -10622,7 +10619,7 @@ aarch64_gimplify_va_arg_expr (tree valis if (BYTES_BIG_ENDIAN && GET_MODE_SIZE (ag_mode) < UNITS_PER_VREG) adjust = UNITS_PER_VREG - GET_MODE_SIZE (ag_mode); } - else if (BLOCK_REG_PADDING (mode, type, 1) == downward + else if (BLOCK_REG_PADDING (mode, type, 1) == PAD_DOWNWARD && size < UNITS_PER_VREG) { adjust = UNITS_PER_VREG - size; @@ -10641,7 +10638,7 @@ aarch64_gimplify_va_arg_expr (tree valis if (align > 8) dw_align = true; - if (BLOCK_REG_PADDING (mode, type, 1) == downward + if (BLOCK_REG_PADDING (mode, type, 1) == PAD_DOWNWARD && size < UNITS_PER_WORD) { adjust = UNITS_PER_WORD - size; @@ -10716,7 +10713,7 @@ aarch64_gimplify_va_arg_expr (tree valis /* String up with arg */ on_stack = build2 (COMPOUND_EXPR, TREE_TYPE (arg), t, arg); /* Big-endianness related address adjustment. */ - if (BLOCK_REG_PADDING (mode, type, 1) == downward + if (BLOCK_REG_PADDING (mode, type, 1) == PAD_DOWNWARD && size < UNITS_PER_WORD) { t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (arg), arg, @@ -15370,6 +15367,9 @@ #define TARGET_FUNCTION_ARG_ADVANCE aarc #undef TARGET_FUNCTION_ARG_BOUNDARY #define TARGET_FUNCTION_ARG_BOUNDARY aarch64_function_arg_boundary +#undef TARGET_FUNCTION_ARG_PADDING +#define TARGET_FUNCTION_ARG_PADDING aarch64_function_arg_padding + #undef TARGET_FUNCTION_OK_FOR_SIBCALL #define TARGET_FUNCTION_OK_FOR_SIBCALL aarch64_function_ok_for_sibcall Index: gcc/config/arm/arm.h =================================================================== --- gcc/config/arm/arm.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/arm/arm.h 2017-08-28 11:03:59.124565051 +0100 @@ -1480,11 +1480,8 @@ typedef struct } CUMULATIVE_ARGS; #endif -#define FUNCTION_ARG_PADDING(MODE, TYPE) \ - (arm_pad_arg_upward (MODE, TYPE) ? upward : downward) - #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - (arm_pad_reg_upward (MODE, TYPE, FIRST) ? upward : downward) + (arm_pad_reg_upward (MODE, TYPE, FIRST) ? PAD_UPWARD : PAD_DOWNWARD) /* For AAPCS, padding should never be below the argument. For other ABIs, * mimic the default. */ Index: gcc/config/arm/arm-protos.h =================================================================== --- gcc/config/arm/arm-protos.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/arm/arm-protos.h 2017-08-28 11:03:59.122553852 +0100 @@ -177,7 +177,6 @@ extern bool arm_coproc_ldc_stc_legitimat #if defined TREE_CODE extern void arm_init_cumulative_args (CUMULATIVE_ARGS *, tree, rtx, tree); -extern bool arm_pad_arg_upward (machine_mode, const_tree); extern bool arm_pad_reg_upward (machine_mode, tree, int); #endif extern int arm_apply_result_size (void); Index: gcc/config/arm/arm.c =================================================================== --- gcc/config/arm/arm.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/arm/arm.c 2017-08-28 11:03:59.124565051 +0100 @@ -186,6 +186,7 @@ static rtx arm_function_arg (cumulative_ const_tree, bool); static void arm_function_arg_advance (cumulative_args_t, machine_mode, const_tree, bool); +static pad_direction arm_function_arg_padding (machine_mode, const_tree); static unsigned int arm_function_arg_boundary (machine_mode, const_tree); static rtx aapcs_allocate_return_reg (machine_mode, const_tree, const_tree); @@ -536,6 +537,8 @@ #define TARGET_ARG_PARTIAL_BYTES arm_arg #define TARGET_FUNCTION_ARG arm_function_arg #undef TARGET_FUNCTION_ARG_ADVANCE #define TARGET_FUNCTION_ARG_ADVANCE arm_function_arg_advance +#undef TARGET_FUNCTION_ARG_PADDING +#define TARGET_FUNCTION_ARG_PADDING arm_function_arg_padding #undef TARGET_FUNCTION_ARG_BOUNDARY #define TARGET_FUNCTION_ARG_BOUNDARY arm_function_arg_boundary @@ -15155,22 +15158,21 @@ arm_must_pass_in_stack (machine_mode mod } -/* For use by FUNCTION_ARG_PADDING (MODE, TYPE). - Return true if an argument passed on the stack should be padded upwards, - i.e. if the least-significant byte has useful data. - For legacy APCS ABIs we use the default. For AAPCS based ABIs small - aggregate types are placed in the lowest memory address. */ +/* Implement TARGET_FUNCTION_ARG_PADDING; return PAD_UPWARD if the lowest + byte of a stack argument has useful data. For legacy APCS ABIs we use + the default. For AAPCS based ABIs small aggregate types are placed + in the lowest memory address. */ -bool -arm_pad_arg_upward (machine_mode mode ATTRIBUTE_UNUSED, const_tree type) +static pad_direction +arm_function_arg_padding (machine_mode mode, const_tree type) { if (!TARGET_AAPCS_BASED) - return DEFAULT_FUNCTION_ARG_PADDING(mode, type) == upward; + return default_function_arg_padding (mode, type); if (type && BYTES_BIG_ENDIAN && INTEGRAL_TYPE_P (type)) - return false; + return PAD_DOWNWARD; - return true; + return PAD_UPWARD; } Index: gcc/config/c6x/c6x.h =================================================================== --- gcc/config/c6x/c6x.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/c6x/c6x.h 2017-08-28 11:03:59.125570651 +0100 @@ -345,7 +345,7 @@ #define INIT_CUMULATIVE_ARGS(cum, fntype c6x_init_cumulative_args (&cum, fntype, libname, n_named_args) #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - (c6x_block_reg_pad_upward (MODE, TYPE, FIRST) ? upward : downward) + (c6x_block_reg_pad_upward (MODE, TYPE, FIRST) ? PAD_UPWARD : PAD_DOWNWARD) #define FUNCTION_ARG_REGNO_P(r) \ (((r) >= REG_A4 && (r) <= REG_A13) || ((r) >= REG_B4 && (r) <= REG_B13)) Index: gcc/config/ia64/hpux.h =================================================================== --- gcc/config/ia64/hpux.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/ia64/hpux.h 2017-08-28 11:03:59.125570651 +0100 @@ -125,10 +125,6 @@ #define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE ASM_OUTPUT_TYPE_DIRECTIVE (FILE, XSTR (FUN, 0), "function"); \ } while (0) -#undef FUNCTION_ARG_PADDING -#define FUNCTION_ARG_PADDING(MODE, TYPE) \ - ia64_hpux_function_arg_padding ((MODE), (TYPE)) - #undef PAD_VARARGS_DOWN #define PAD_VARARGS_DOWN (!AGGREGATE_TYPE_P (type)) Index: gcc/config/ia64/ia64-protos.h =================================================================== --- gcc/config/ia64/ia64-protos.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/ia64/ia64-protos.h 2017-08-28 11:03:59.125570651 +0100 @@ -89,11 +89,6 @@ extern int ia64_dbx_register_number (int extern rtx ia64_return_addr_rtx (HOST_WIDE_INT, rtx); extern void ia64_split_return_addr_rtx (rtx); -#ifdef ARGS_SIZE_RTX -/* expr.h defines ARGS_SIZE_RTX and `enum direction'. */ -extern enum direction ia64_hpux_function_arg_padding (machine_mode, const_tree); -#endif /* ARGS_SIZE_RTX */ - extern void ia64_hpux_handle_builtin_pragma (struct cpp_reader *); extern void ia64_output_function_profiler (FILE *, int); extern void ia64_profile_hook (int); Index: gcc/config/ia64/ia64.c =================================================================== --- gcc/config/ia64/ia64.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/ia64/ia64.c 2017-08-28 11:03:59.126576251 +0100 @@ -209,6 +209,7 @@ static rtx ia64_function_incoming_arg (c machine_mode, const_tree, bool); static void ia64_function_arg_advance (cumulative_args_t, machine_mode, const_tree, bool); +static pad_direction ia64_function_arg_padding (machine_mode, const_tree); static unsigned int ia64_function_arg_boundary (machine_mode, const_tree); static bool ia64_function_ok_for_sibcall (tree, tree); @@ -509,6 +510,8 @@ #define TARGET_FUNCTION_ARG ia64_functio #define TARGET_FUNCTION_INCOMING_ARG ia64_function_incoming_arg #undef TARGET_FUNCTION_ARG_ADVANCE #define TARGET_FUNCTION_ARG_ADVANCE ia64_function_arg_advance +#undef TARGET_FUNCTION_ARG_PADDING +#define TARGET_FUNCTION_ARG_PADDING ia64_function_arg_padding #undef TARGET_FUNCTION_ARG_BOUNDARY #define TARGET_FUNCTION_ARG_BOUNDARY ia64_function_arg_boundary @@ -10608,20 +10611,23 @@ ia64_builtin_decl (unsigned code, bool i return ia64_builtins[code]; } -/* For the HP-UX IA64 aggregate parameters are passed stored in the +/* Implement TARGET_FUNCTION_ARG_PADDING. + + For the HP-UX IA64 aggregate parameters are passed stored in the most significant bits of the stack slot. */ -enum direction -ia64_hpux_function_arg_padding (machine_mode mode, const_tree type) +static pad_direction +ia64_function_arg_padding (machine_mode mode, const_tree type) { - /* Exception to normal case for structures/unions/etc. */ - - if (type && AGGREGATE_TYPE_P (type) - && int_size_in_bytes (type) < UNITS_PER_WORD) - return upward; + /* Exception to normal case for structures/unions/etc. */ + if (TARGET_HPUX + && type + && AGGREGATE_TYPE_P (type) + && int_size_in_bytes (type) < UNITS_PER_WORD) + return PAD_UPWARD; - /* Fall back to the default. */ - return DEFAULT_FUNCTION_ARG_PADDING (mode, type); + /* Fall back to the default. */ + return default_function_arg_padding (mode, type); } /* Emit text to declare externally defined variables and functions, because Index: gcc/config/iq2000/iq2000.h =================================================================== --- gcc/config/iq2000/iq2000.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/iq2000/iq2000.h 2017-08-28 11:03:59.126576251 +0100 @@ -308,16 +308,6 @@ typedef struct iq2000_args #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \ init_cumulative_args (& CUM, FNTYPE, LIBNAME) \ -#define FUNCTION_ARG_PADDING(MODE, TYPE) \ - (! BYTES_BIG_ENDIAN \ - ? upward \ - : (((MODE) == BLKmode \ - ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ - && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT))\ - : (GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY \ - && (GET_MODE_CLASS (MODE) == MODE_INT))) \ - ? downward : upward)) - #define FUNCTION_ARG_REGNO_P(N) \ (((N) >= GP_ARG_FIRST && (N) <= GP_ARG_LAST)) Index: gcc/config/iq2000/iq2000.c =================================================================== --- gcc/config/iq2000/iq2000.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/iq2000/iq2000.c 2017-08-28 11:03:59.126576251 +0100 @@ -165,6 +165,7 @@ static rtx iq2000_function_arg (cu machine_mode, const_tree, bool); static void iq2000_function_arg_advance (cumulative_args_t, machine_mode, const_tree, bool); +static pad_direction iq2000_function_arg_padding (machine_mode, const_tree); static unsigned int iq2000_function_arg_boundary (machine_mode, const_tree); static void iq2000_va_start (tree, rtx); @@ -231,6 +232,8 @@ #define TARGET_ARG_PARTIAL_BYTES iq2000_ #define TARGET_FUNCTION_ARG iq2000_function_arg #undef TARGET_FUNCTION_ARG_ADVANCE #define TARGET_FUNCTION_ARG_ADVANCE iq2000_function_arg_advance +#undef TARGET_FUNCTION_ARG_PADDING +#define TARGET_FUNCTION_ARG_PADDING iq2000_function_arg_padding #undef TARGET_FUNCTION_ARG_BOUNDARY #define TARGET_FUNCTION_ARG_BOUNDARY iq2000_function_arg_boundary @@ -1376,6 +1379,22 @@ iq2000_function_arg (cumulative_args_t c return ret; } +/* Implement TARGET_FUNCTION_ARG_PADDING. */ + +static pad_direction +iq2000_function_arg_padding (machine_mode mode, const_tree type) +{ + return (! BYTES_BIG_ENDIAN + ? PAD_UPWARD + : ((mode == BLKmode + ? (type + && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST + && int_size_in_bytes (type) < (PARM_BOUNDARY / BITS_PER_UNIT)) + : (GET_MODE_BITSIZE (mode) < PARM_BOUNDARY + && GET_MODE_CLASS (mode) == MODE_INT)) + ? PAD_DOWNWARD : PAD_UPWARD)); +} + static unsigned int iq2000_function_arg_boundary (machine_mode mode, const_tree type) { Index: gcc/config/mips/mips-protos.h =================================================================== --- gcc/config/mips/mips-protos.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/mips/mips-protos.h 2017-08-28 11:03:59.126576251 +0100 @@ -246,7 +246,6 @@ extern bool mips_expand_block_move (rtx, extern void mips_expand_synci_loop (rtx, rtx); extern void mips_init_cumulative_args (CUMULATIVE_ARGS *, tree); -extern bool mips_pad_arg_upward (machine_mode, const_tree); extern bool mips_pad_reg_upward (machine_mode, tree); extern bool mips_expand_ext_as_unaligned_load (rtx, rtx, HOST_WIDE_INT, Index: gcc/config/mips/mips.c =================================================================== --- gcc/config/mips/mips.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/mips/mips.c 2017-08-28 11:03:59.128587451 +0100 @@ -6117,18 +6117,17 @@ mips_get_reg_raw_mode (int regno) return default_get_reg_raw_mode (regno); } -/* Return true if FUNCTION_ARG_PADDING (MODE, TYPE) should return - upward rather than downward. In other words, return true if the - first byte of the stack slot has useful data, false if the last - byte does. */ +/* Implement TARGET_FUNCTION_ARG_PADDING; return PAD_UPWARD if the first + byte of the stack slot has useful data, PAD_DOWNWARD if the last byte + does. */ -bool -mips_pad_arg_upward (machine_mode mode, const_tree type) +static pad_direction +mips_function_arg_padding (machine_mode mode, const_tree type) { /* On little-endian targets, the first byte of every stack argument is passed in the first byte of the stack slot. */ if (!BYTES_BIG_ENDIAN) - return true; + return PAD_UPWARD; /* Otherwise, integral types are padded downward: the last byte of a stack argument is passed in the last byte of the stack slot. */ @@ -6138,22 +6137,24 @@ mips_pad_arg_upward (machine_mode mode, || FIXED_POINT_TYPE_P (type)) : (SCALAR_INT_MODE_P (mode) || ALL_SCALAR_FIXED_POINT_MODE_P (mode))) - return false; + return PAD_DOWNWARD; /* Big-endian o64 pads floating-point arguments downward. */ if (mips_abi == ABI_O64) if (type != 0 ? FLOAT_TYPE_P (type) : GET_MODE_CLASS (mode) == MODE_FLOAT) - return false; + return PAD_DOWNWARD; /* Other types are padded upward for o32, o64, n32 and n64. */ if (mips_abi != ABI_EABI) - return true; + return PAD_UPWARD; /* Arguments smaller than a stack slot are padded downward. */ - if (mode != BLKmode) - return GET_MODE_BITSIZE (mode) >= PARM_BOUNDARY; - else - return int_size_in_bytes (type) >= (PARM_BOUNDARY / BITS_PER_UNIT); + if (mode != BLKmode + ? GET_MODE_BITSIZE (mode) >= PARM_BOUNDARY + : int_size_in_bytes (type) >= (PARM_BOUNDARY / BITS_PER_UNIT)) + return PAD_UPWARD; + + return PAD_DOWNWARD; } /* Likewise BLOCK_REG_PADDING (MODE, TYPE, ...). Return !BYTES_BIG_ENDIAN @@ -6169,7 +6170,7 @@ mips_pad_reg_upward (machine_mode mode, /* Otherwise, apply the same padding to register arguments as we do to stack arguments. */ - return mips_pad_arg_upward (mode, type); + return mips_function_arg_padding (mode, type) == PAD_UPWARD; } /* Return nonzero when an argument must be passed by reference. */ @@ -22458,6 +22459,8 @@ #define TARGET_ARG_PARTIAL_BYTES mips_ar #define TARGET_FUNCTION_ARG mips_function_arg #undef TARGET_FUNCTION_ARG_ADVANCE #define TARGET_FUNCTION_ARG_ADVANCE mips_function_arg_advance +#undef TARGET_FUNCTION_ARG_PADDING +#define TARGET_FUNCTION_ARG_PADDING mips_function_arg_padding #undef TARGET_FUNCTION_ARG_BOUNDARY #define TARGET_FUNCTION_ARG_BOUNDARY mips_function_arg_boundary #undef TARGET_GET_RAW_RESULT_MODE Index: gcc/config/mips/mips.h =================================================================== --- gcc/config/mips/mips.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/mips/mips.h 2017-08-28 11:03:59.128587451 +0100 @@ -1679,7 +1679,7 @@ #define LOCAL_ALIGNMENT(TYPE, ALIGN) \ DATA_ALIGNMENT (TYPE, ALIGN) #define PAD_VARARGS_DOWN \ - (FUNCTION_ARG_PADDING (TYPE_MODE (type), type) == downward) + (targetm.calls.function_arg_padding (TYPE_MODE (type), type) == PAD_DOWNWARD) /* Define if operations between registers always perform the operation on the full register even if a narrower mode is specified. */ @@ -2521,11 +2521,8 @@ typedef struct mips_args { #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \ mips_init_cumulative_args (&CUM, FNTYPE) -#define FUNCTION_ARG_PADDING(MODE, TYPE) \ - (mips_pad_arg_upward (MODE, TYPE) ? upward : downward) - #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - (mips_pad_reg_upward (MODE, TYPE) ? upward : downward) + (mips_pad_reg_upward (MODE, TYPE) ? PAD_UPWARD : PAD_DOWNWARD) /* True if using EABI and varargs can be passed in floating-point registers. Under these conditions, we need a more complex form Index: gcc/config/nios2/nios2.h =================================================================== --- gcc/config/nios2/nios2.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/nios2/nios2.h 2017-08-28 11:03:59.129593051 +0100 @@ -294,11 +294,8 @@ #define NUM_ARG_REGS (LAST_ARG_REGNO - F #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \ do { (CUM).regs_used = 0; } while (0) -#define FUNCTION_ARG_PADDING(MODE, TYPE) \ - (nios2_function_arg_padding ((MODE), (TYPE))) - #define PAD_VARARGS_DOWN \ - (FUNCTION_ARG_PADDING (TYPE_MODE (type), type) == downward) + (targetm.calls.function_arg_padding (TYPE_MODE (type), type) == PAD_DOWNWARD) #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ (nios2_block_reg_padding ((MODE), (TYPE), (FIRST))) Index: gcc/config/nios2/nios2-protos.h =================================================================== --- gcc/config/nios2/nios2-protos.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/nios2/nios2-protos.h 2017-08-28 11:03:59.129593051 +0100 @@ -59,14 +59,8 @@ extern bool gen_ldstwm_peep (bool, int, extern void nios2_adjust_reg_alloc_order (void); -#ifdef TREE_CODE -#ifdef ARGS_SIZE_RTX -/* expr.h defines both ARGS_SIZE_RTX and `enum direction' */ -extern enum direction nios2_function_arg_padding (machine_mode, const_tree); -extern enum direction nios2_block_reg_padding (machine_mode, tree, int); -#endif /* ARGS_SIZE_RTX */ +extern pad_direction nios2_block_reg_padding (machine_mode, tree, int); -#endif /* TREE_CODE */ #endif /* RTX_CODE */ #endif /* GCC_NIOS2_PROTOS_H */ Index: gcc/config/nios2/nios2.c =================================================================== --- gcc/config/nios2/nios2.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/nios2/nios2.c 2017-08-28 11:03:59.129593051 +0100 @@ -2983,30 +2983,31 @@ nios2_function_arg_advance (cumulative_a cum->regs_used += param_size; } -enum direction +static pad_direction nios2_function_arg_padding (machine_mode mode, const_tree type) { /* On little-endian targets, the first byte of every stack argument is passed in the first byte of the stack slot. */ if (!BYTES_BIG_ENDIAN) - return upward; + return PAD_UPWARD; /* Otherwise, integral types are padded downward: the last byte of a stack argument is passed in the last byte of the stack slot. */ if (type != 0 ? INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type) : GET_MODE_CLASS (mode) == MODE_INT) - return downward; + return PAD_DOWNWARD; /* Arguments smaller than a stack slot are padded downward. */ if (mode != BLKmode) - return (GET_MODE_BITSIZE (mode) >= PARM_BOUNDARY) ? upward : downward; + return (GET_MODE_BITSIZE (mode) >= PARM_BOUNDARY + ? PAD_UPWARD : PAD_DOWNWARD); return ((int_size_in_bytes (type) >= (PARM_BOUNDARY / BITS_PER_UNIT)) - ? upward : downward); + ? PAD_UPWARD : PAD_DOWNWARD); } -enum direction +pad_direction nios2_block_reg_padding (machine_mode mode, tree type, int first ATTRIBUTE_UNUSED) { @@ -5009,6 +5010,9 @@ #define TARGET_FUNCTION_ARG nios2_functi #undef TARGET_FUNCTION_ARG_ADVANCE #define TARGET_FUNCTION_ARG_ADVANCE nios2_function_arg_advance +#undef TARGET_FUNCTION_ARG_PADDING +#define TARGET_FUNCTION_ARG_PADDING nios2_function_arg_padding + #undef TARGET_ARG_PARTIAL_BYTES #define TARGET_ARG_PARTIAL_BYTES nios2_arg_partial_bytes Index: gcc/config/pa/pa.h =================================================================== --- gcc/config/pa/pa.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/pa/pa.h 2017-08-28 11:03:59.130598651 +0100 @@ -663,11 +663,6 @@ #define FUNCTION_ARG_SIZE(MODE, TYPE) \ the standard parameter passing conventions on the RS6000. That's why you'll see lots of similar code in rs6000.h. */ -/* If defined, a C expression which determines whether, and in which - direction, to pad out an argument with extra space. */ -#define FUNCTION_ARG_PADDING(MODE, TYPE) \ - pa_function_arg_padding ((MODE), (TYPE)) - /* Specify padding for the last element of a block move between registers and memory. @@ -678,7 +673,7 @@ #define FUNCTION_ARG_PADDING(MODE, TYPE) so that there is only one element. This allows the object to be correctly padded. */ #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - pa_function_arg_padding ((MODE), (TYPE)) + targetm.calls.function_arg_padding ((MODE), (TYPE)) /* On HPPA, we emit profiling code as rtl via PROFILE_HOOK rather than Index: gcc/config/pa/pa-protos.h =================================================================== --- gcc/config/pa/pa-protos.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/pa/pa-protos.h 2017-08-28 11:03:59.129593051 +0100 @@ -71,12 +71,6 @@ extern rtx pa_legitimize_reload_address extern rtx pa_return_addr_rtx (int, rtx); -#ifdef ARGS_SIZE_RTX -/* expr.h defines ARGS_SIZE_RTX and `enum direction' */ -#ifdef TREE_CODE -extern enum direction pa_function_arg_padding (machine_mode, const_tree); -#endif -#endif /* ARGS_SIZE_RTX */ extern int pa_insn_refs_are_delayed (rtx_insn *); extern rtx pa_get_deferred_plabel (rtx); extern rtx pa_maybe_emit_compare_and_swap_exchange_loop (rtx, rtx, rtx); Index: gcc/config/pa/pa.c =================================================================== --- gcc/config/pa/pa.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/pa/pa.c 2017-08-28 11:03:59.130598651 +0100 @@ -172,6 +172,7 @@ static void pa_function_arg_advance (cum const_tree, bool); static rtx pa_function_arg (cumulative_args_t, machine_mode, const_tree, bool); +static pad_direction pa_function_arg_padding (machine_mode, const_tree); static unsigned int pa_function_arg_boundary (machine_mode, const_tree); static struct machine_function * pa_init_machine_status (void); static reg_class_t pa_secondary_reload (bool, rtx, reg_class_t, @@ -355,6 +356,8 @@ #define TARGET_ARG_PARTIAL_BYTES pa_arg_ #define TARGET_FUNCTION_ARG pa_function_arg #undef TARGET_FUNCTION_ARG_ADVANCE #define TARGET_FUNCTION_ARG_ADVANCE pa_function_arg_advance +#undef TARGET_FUNCTION_ARG_PADDING +#define TARGET_FUNCTION_ARG_PADDING pa_function_arg_padding #undef TARGET_FUNCTION_ARG_BOUNDARY #define TARGET_FUNCTION_ARG_BOUNDARY pa_function_arg_boundary @@ -6241,7 +6244,9 @@ pa_pass_by_reference (cumulative_args_t return size <= 0 || size > 8; } -enum direction +/* Implement TARGET_FUNCTION_ARG_PADDING. */ + +static pad_direction pa_function_arg_padding (machine_mode mode, const_tree type) { if (mode == BLKmode @@ -6251,11 +6256,11 @@ pa_function_arg_padding (machine_mode mo || TREE_CODE (type) == COMPLEX_TYPE || TREE_CODE (type) == VECTOR_TYPE))) { - /* Return none if justification is not required. */ + /* Return PAD_NONE if justification is not required. */ if (type && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST && (int_size_in_bytes (type) * BITS_PER_UNIT) % PARM_BOUNDARY == 0) - return none; + return PAD_NONE; /* The directions set here are ignored when a BLKmode argument larger than a word is placed in a register. Different code is used for @@ -6265,18 +6270,18 @@ pa_function_arg_padding (machine_mode mo the stack and in registers should be identical. */ if (TARGET_64BIT) /* The 64-bit runtime specifies left justification for aggregates. */ - return upward; + return PAD_UPWARD; else /* The 32-bit runtime architecture specifies right justification. When the argument is passed on the stack, the argument is padded with garbage on the left. The HP compiler pads with zeros. */ - return downward; + return PAD_DOWNWARD; } if (GET_MODE_BITSIZE (mode) < PARM_BOUNDARY) - return downward; + return PAD_DOWNWARD; else - return none; + return PAD_NONE; } Index: gcc/config/powerpcspe/powerpcspe.h =================================================================== --- gcc/config/powerpcspe/powerpcspe.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/powerpcspe/powerpcspe.h 2017-08-28 11:03:59.135626650 +0100 @@ -1901,16 +1901,8 @@ #define INIT_CUMULATIVE_LIBCALL_ARGS(CUM init_cumulative_args (&CUM, NULL_TREE, LIBNAME, FALSE, TRUE, \ 0, NULL_TREE, MODE) -/* If defined, a C expression which determines whether, and in which - direction, to pad out an argument with extra space. The value - should be of type `enum direction': either `upward' to pad above - the argument, `downward' to pad below, or `none' to inhibit - padding. */ - -#define FUNCTION_ARG_PADDING(MODE, TYPE) function_arg_padding (MODE, TYPE) - #define PAD_VARARGS_DOWN \ - (FUNCTION_ARG_PADDING (TYPE_MODE (type), type) == downward) + (targetm.calls.function_arg_padding (TYPE_MODE (type), type) == PAD_DOWNWARD) /* Output assembler code to FILE to increment profiler label # LABELNO for profiling a function entry. */ Index: gcc/config/powerpcspe/aix.h =================================================================== --- gcc/config/powerpcspe/aix.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/powerpcspe/aix.h 2017-08-28 11:03:59.131604251 +0100 @@ -248,7 +248,7 @@ #define AGGREGATES_PAD_UPWARD_ALWAYS 1 registers and memory. FIRST is nonzero if this is the only element. */ #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - (!(FIRST) ? upward : FUNCTION_ARG_PADDING (MODE, TYPE)) + (!(FIRST) ? PAD_UPWARD : targetm.calls.function_arg_padding (MODE, TYPE)) /* Indicate that jump tables go in the text section. */ Index: gcc/config/powerpcspe/darwin.h =================================================================== --- gcc/config/powerpcspe/darwin.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/powerpcspe/darwin.h 2017-08-28 11:03:59.131604251 +0100 @@ -344,7 +344,7 @@ #define ROUND_TYPE_ALIGN(STRUCT, COMPUTE registers and memory. FIRST is nonzero if this is the only element. */ #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - (!(FIRST) ? upward : FUNCTION_ARG_PADDING (MODE, TYPE)) + (!(FIRST) ? PAD_UPWARD : targetm.calls.function_arg_padding (MODE, TYPE)) #define DOUBLE_INT_ASM_OP "\t.quad\t" Index: gcc/config/powerpcspe/freebsd64.h =================================================================== --- gcc/config/powerpcspe/freebsd64.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/powerpcspe/freebsd64.h 2017-08-28 11:03:59.131604251 +0100 @@ -225,7 +225,7 @@ #define AGGREGATES_PAD_UPWARD_ALWAYS 0 registers and memory. FIRST is nonzero if this is the only element. */ #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - (!(FIRST) ? upward : FUNCTION_ARG_PADDING (MODE, TYPE)) + (!(FIRST) ? PAD_UPWARD : targetm.calls.function_arg_padding (MODE, TYPE)) /* FreeBSD doesn't support saving and restoring 64-bit regs with a 32-bit kernel. This is supported when running on a 64-bit kernel with Index: gcc/config/powerpcspe/linux64.h =================================================================== --- gcc/config/powerpcspe/linux64.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/powerpcspe/linux64.h 2017-08-28 11:03:59.131604251 +0100 @@ -340,7 +340,7 @@ #define AGGREGATES_PAD_UPWARD_ALWAYS 0 registers and memory. FIRST is nonzero if this is the only element. */ #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - (!(FIRST) ? upward : FUNCTION_ARG_PADDING (MODE, TYPE)) + (!(FIRST) ? PAD_UPWARD : targetm.calls.function_arg_padding (MODE, TYPE)) /* Linux doesn't support saving and restoring 64-bit regs in a 32-bit process. */ Index: gcc/config/powerpcspe/powerpcspe-protos.h =================================================================== --- gcc/config/powerpcspe/powerpcspe-protos.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/powerpcspe/powerpcspe-protos.h 2017-08-28 11:03:59.131604251 +0100 @@ -196,10 +196,6 @@ extern void rs6000_xcoff_asm_output_alig unsigned HOST_WIDE_INT); extern void rs6000_elf_declare_function_name (FILE *, const char *, tree); extern bool rs6000_elf_in_small_data_p (const_tree); -#ifdef ARGS_SIZE_RTX -/* expr.h defines ARGS_SIZE_RTX and `enum direction' */ -extern enum direction function_arg_padding (machine_mode, const_tree); -#endif /* ARGS_SIZE_RTX */ #endif /* TREE_CODE */ Index: gcc/config/powerpcspe/powerpcspe.c =================================================================== --- gcc/config/powerpcspe/powerpcspe.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/powerpcspe/powerpcspe.c 2017-08-28 11:03:59.134621050 +0100 @@ -88,6 +88,8 @@ #define TARGET_NO_PROTOTYPE 0 #define min(A,B) ((A) < (B) ? (A) : (B)) #define max(A,B) ((A) > (B) ? (A) : (B)) +static pad_direction rs6000_function_arg_padding (machine_mode, const_tree); + /* Structure used to define the rs6000 stack */ typedef struct rs6000_stack { int reload_completed; /* stack info won't change from here on */ @@ -1810,6 +1812,8 @@ #define TARGET_ARG_PARTIAL_BYTES rs6000_ #define TARGET_FUNCTION_ARG_ADVANCE rs6000_function_arg_advance #undef TARGET_FUNCTION_ARG #define TARGET_FUNCTION_ARG rs6000_function_arg +#undef TARGET_FUNCTION_ARG_PADDING +#define TARGET_FUNCTION_ARG_PADDING rs6000_function_arg_padding #undef TARGET_FUNCTION_ARG_BOUNDARY #define TARGET_FUNCTION_ARG_BOUNDARY rs6000_function_arg_boundary @@ -11814,7 +11818,8 @@ rs6000_return_in_msb (const_tree valtype return (DEFAULT_ABI == ABI_ELFv2 && BYTES_BIG_ENDIAN && AGGREGATE_TYPE_P (valtype) - && FUNCTION_ARG_PADDING (TYPE_MODE (valtype), valtype) == upward); + && rs6000_function_arg_padding (TYPE_MODE (valtype), + valtype) == PAD_UPWARD); } #ifdef HAVE_AS_GNU_ATTRIBUTE @@ -12031,17 +12036,13 @@ abi_v4_pass_in_fpr (machine_mode mode) return false; } -/* If defined, a C expression which determines whether, and in which - direction, to pad out an argument with extra space. The value - should be of type `enum direction': either `upward' to pad above - the argument, `downward' to pad below, or `none' to inhibit - padding. +/* Implement TARGET_FUNCTION_ARG_PADDING For the AIX ABI structs are always stored left shifted in their argument slot. */ -enum direction -function_arg_padding (machine_mode mode, const_tree type) +static pad_direction +rs6000_function_arg_padding (machine_mode mode, const_tree type) { #ifndef AGGREGATE_PADDING_FIXED #define AGGREGATE_PADDING_FIXED 0 @@ -12053,7 +12054,7 @@ #define AGGREGATES_PAD_UPWARD_ALWAYS 0 if (!AGGREGATE_PADDING_FIXED) { /* GCC used to pass structures of the same size as integer types as - if they were in fact integers, ignoring FUNCTION_ARG_PADDING. + if they were in fact integers, ignoring TARGET_FUNCTION_ARG_PADDING. i.e. Structures of size 1 or 2 (or 4 when TARGET_64BIT) were passed padded downward, except that -mstrict-align further muddied the water in that multi-component structures of 2 and 4 @@ -12074,19 +12075,19 @@ #define AGGREGATES_PAD_UPWARD_ALWAYS 0 size = GET_MODE_SIZE (mode); if (size == 1 || size == 2 || size == 4) - return downward; + return PAD_DOWNWARD; } - return upward; + return PAD_UPWARD; } if (AGGREGATES_PAD_UPWARD_ALWAYS) { if (type != 0 && AGGREGATE_TYPE_P (type)) - return upward; + return PAD_UPWARD; } /* Fall back to the default. */ - return DEFAULT_FUNCTION_ARG_PADDING (mode, type); + return default_function_arg_padding (mode, type); } /* If defined, a C expression that gives the alignment boundary, in bits, Index: gcc/config/rs6000/rs6000.h =================================================================== --- gcc/config/rs6000/rs6000.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/rs6000/rs6000.h 2017-08-28 11:03:59.138643450 +0100 @@ -1807,16 +1807,8 @@ #define INIT_CUMULATIVE_LIBCALL_ARGS(CUM init_cumulative_args (&CUM, NULL_TREE, LIBNAME, FALSE, TRUE, \ 0, NULL_TREE, MODE) -/* If defined, a C expression which determines whether, and in which - direction, to pad out an argument with extra space. The value - should be of type `enum direction': either `upward' to pad above - the argument, `downward' to pad below, or `none' to inhibit - padding. */ - -#define FUNCTION_ARG_PADDING(MODE, TYPE) function_arg_padding (MODE, TYPE) - #define PAD_VARARGS_DOWN \ - (FUNCTION_ARG_PADDING (TYPE_MODE (type), type) == downward) + (targetm.calls.function_arg_padding (TYPE_MODE (type), type) == PAD_DOWNWARD) /* Output assembler code to FILE to increment profiler label # LABELNO for profiling a function entry. */ Index: gcc/config/rs6000/aix.h =================================================================== --- gcc/config/rs6000/aix.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/rs6000/aix.h 2017-08-28 11:03:59.135626650 +0100 @@ -248,7 +248,7 @@ #define AGGREGATES_PAD_UPWARD_ALWAYS 1 registers and memory. FIRST is nonzero if this is the only element. */ #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - (!(FIRST) ? upward : FUNCTION_ARG_PADDING (MODE, TYPE)) + (!(FIRST) ? PAD_UPWARD : targetm.calls.function_arg_padding (MODE, TYPE)) /* Indicate that jump tables go in the text section. */ Index: gcc/config/rs6000/darwin.h =================================================================== --- gcc/config/rs6000/darwin.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/rs6000/darwin.h 2017-08-28 11:03:59.135626650 +0100 @@ -339,7 +339,7 @@ #define ROUND_TYPE_ALIGN(STRUCT, COMPUTE registers and memory. FIRST is nonzero if this is the only element. */ #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - (!(FIRST) ? upward : FUNCTION_ARG_PADDING (MODE, TYPE)) + (!(FIRST) ? PAD_UPWARD : targetm.calls.function_arg_padding (MODE, TYPE)) #define DOUBLE_INT_ASM_OP "\t.quad\t" Index: gcc/config/rs6000/freebsd64.h =================================================================== --- gcc/config/rs6000/freebsd64.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/rs6000/freebsd64.h 2017-08-28 11:03:59.135626650 +0100 @@ -225,7 +225,7 @@ #define AGGREGATES_PAD_UPWARD_ALWAYS 0 registers and memory. FIRST is nonzero if this is the only element. */ #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - (!(FIRST) ? upward : FUNCTION_ARG_PADDING (MODE, TYPE)) + (!(FIRST) ? PAD_UPWARD : targetm.calls.function_arg_padding (MODE, TYPE)) /* FreeBSD doesn't support saving and restoring 64-bit regs with a 32-bit kernel. This is supported when running on a 64-bit kernel with Index: gcc/config/rs6000/linux64.h =================================================================== --- gcc/config/rs6000/linux64.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/rs6000/linux64.h 2017-08-28 11:03:59.135626650 +0100 @@ -340,7 +340,7 @@ #define AGGREGATES_PAD_UPWARD_ALWAYS 0 registers and memory. FIRST is nonzero if this is the only element. */ #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ - (!(FIRST) ? upward : FUNCTION_ARG_PADDING (MODE, TYPE)) + (!(FIRST) ? PAD_UPWARD : targetm.calls.function_arg_padding (MODE, TYPE)) /* Linux doesn't support saving and restoring 64-bit regs in a 32-bit process. */ Index: gcc/config/rs6000/rs6000-protos.h =================================================================== --- gcc/config/rs6000/rs6000-protos.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/rs6000/rs6000-protos.h 2017-08-28 11:03:59.136632250 +0100 @@ -197,10 +197,6 @@ extern void rs6000_xcoff_asm_output_alig unsigned HOST_WIDE_INT); extern void rs6000_elf_declare_function_name (FILE *, const char *, tree); extern bool rs6000_elf_in_small_data_p (const_tree); -#ifdef ARGS_SIZE_RTX -/* expr.h defines ARGS_SIZE_RTX and `enum direction' */ -extern enum direction function_arg_padding (machine_mode, const_tree); -#endif /* ARGS_SIZE_RTX */ #endif /* TREE_CODE */ Index: gcc/config/rs6000/rs6000.c =================================================================== --- gcc/config/rs6000/rs6000.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/rs6000/rs6000.c 2017-08-28 11:03:59.138643450 +0100 @@ -89,6 +89,8 @@ #define TARGET_NO_PROTOTYPE 0 #define min(A,B) ((A) < (B) ? (A) : (B)) #define max(A,B) ((A) > (B) ? (A) : (B)) +static pad_direction rs6000_function_arg_padding (machine_mode, const_tree); + /* Structure used to define the rs6000 stack */ typedef struct rs6000_stack { int reload_completed; /* stack info won't change from here on */ @@ -1795,6 +1797,8 @@ #define TARGET_ARG_PARTIAL_BYTES rs6000_ #define TARGET_FUNCTION_ARG_ADVANCE rs6000_function_arg_advance #undef TARGET_FUNCTION_ARG #define TARGET_FUNCTION_ARG rs6000_function_arg +#undef TARGET_FUNCTION_ARG_PADDING +#define TARGET_FUNCTION_ARG_PADDING rs6000_function_arg_padding #undef TARGET_FUNCTION_ARG_BOUNDARY #define TARGET_FUNCTION_ARG_BOUNDARY rs6000_function_arg_boundary @@ -11324,7 +11328,8 @@ rs6000_return_in_msb (const_tree valtype return (DEFAULT_ABI == ABI_ELFv2 && BYTES_BIG_ENDIAN && AGGREGATE_TYPE_P (valtype) - && FUNCTION_ARG_PADDING (TYPE_MODE (valtype), valtype) == upward); + && (rs6000_function_arg_padding (TYPE_MODE (valtype), valtype) + == PAD_UPWARD)); } #ifdef HAVE_AS_GNU_ATTRIBUTE @@ -11541,17 +11546,13 @@ abi_v4_pass_in_fpr (machine_mode mode) return false; } -/* If defined, a C expression which determines whether, and in which - direction, to pad out an argument with extra space. The value - should be of type `enum direction': either `upward' to pad above - the argument, `downward' to pad below, or `none' to inhibit - padding. +/* Implement TARGET_FUNCTION_ARG_PADDING. For the AIX ABI structs are always stored left shifted in their argument slot. */ -enum direction -function_arg_padding (machine_mode mode, const_tree type) +static pad_direction +rs6000_function_arg_padding (machine_mode mode, const_tree type) { #ifndef AGGREGATE_PADDING_FIXED #define AGGREGATE_PADDING_FIXED 0 @@ -11563,7 +11564,7 @@ #define AGGREGATES_PAD_UPWARD_ALWAYS 0 if (!AGGREGATE_PADDING_FIXED) { /* GCC used to pass structures of the same size as integer types as - if they were in fact integers, ignoring FUNCTION_ARG_PADDING. + if they were in fact integers, ignoring TARGET_FUNCTION_ARG_PADDING. i.e. Structures of size 1 or 2 (or 4 when TARGET_64BIT) were passed padded downward, except that -mstrict-align further muddied the water in that multi-component structures of 2 and 4 @@ -11584,19 +11585,19 @@ #define AGGREGATES_PAD_UPWARD_ALWAYS 0 size = GET_MODE_SIZE (mode); if (size == 1 || size == 2 || size == 4) - return downward; + return PAD_DOWNWARD; } - return upward; + return PAD_UPWARD; } if (AGGREGATES_PAD_UPWARD_ALWAYS) { if (type != 0 && AGGREGATE_TYPE_P (type)) - return upward; + return PAD_UPWARD; } /* Fall back to the default. */ - return DEFAULT_FUNCTION_ARG_PADDING (mode, type); + return default_function_arg_padding (mode, type); } /* If defined, a C expression that gives the alignment boundary, in bits, Index: gcc/config/s390/s390.h =================================================================== --- gcc/config/s390/s390.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/s390/s390.h 2017-08-28 11:03:59.140654650 +0100 @@ -273,13 +273,6 @@ #define WORDS_BIG_ENDIAN 1 #define STACK_SIZE_MODE (Pmode) -/* Vector arguments are left-justified when placed on the stack during - parameter passing. */ -#define FUNCTION_ARG_PADDING(MODE, TYPE) \ - (s390_function_arg_vector ((MODE), (TYPE)) \ - ? upward \ - : DEFAULT_FUNCTION_ARG_PADDING ((MODE), (TYPE))) - #ifndef IN_LIBGCC2 /* Width of a word, in units (bytes). */ Index: gcc/config/s390/s390.c =================================================================== --- gcc/config/s390/s390.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/s390/s390.c 2017-08-28 11:03:59.140654650 +0100 @@ -12109,6 +12109,18 @@ s390_function_arg (cumulative_args_t cum gcc_unreachable (); } +/* Implement TARGET_FUNCTION_ARG_BOUNDARY. Vector arguments are + left-justified when placed on the stack during parameter passing. */ + +static pad_direction +s390_function_arg_padding (machine_mode mode, const_tree type) +{ + if (s390_function_arg_vector (mode, type)) + return PAD_UPWARD; + + return default_function_arg_padding (mode, type); +} + /* Return true if return values of type TYPE should be returned in a memory buffer whose address is passed by the caller as hidden first argument. */ @@ -15825,6 +15837,8 @@ #define TARGET_FUNCTION_OK_FOR_SIBCALL s #define TARGET_FUNCTION_ARG s390_function_arg #undef TARGET_FUNCTION_ARG_ADVANCE #define TARGET_FUNCTION_ARG_ADVANCE s390_function_arg_advance +#undef TARGET_FUNCTION_ARG_PADDING +#define TARGET_FUNCTION_ARG_PADDING s390_function_arg_padding #undef TARGET_FUNCTION_VALUE #define TARGET_FUNCTION_VALUE s390_function_value #undef TARGET_LIBCALL_VALUE Index: gcc/config/sparc/sparc.h =================================================================== --- gcc/config/sparc/sparc.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/sparc/sparc.h 2017-08-28 11:03:59.141660250 +0100 @@ -1215,14 +1215,6 @@ #define CUMULATIVE_ARGS struct sparc_arg #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \ init_cumulative_args (& (CUM), (FNTYPE), (LIBNAME), (FNDECL)); -/* If defined, a C expression which determines whether, and in which direction, - to pad out an argument with extra space. The value should be of type - `enum direction': either `upward' to pad above the argument, - `downward' to pad below, or `none' to inhibit padding. */ - -#define FUNCTION_ARG_PADDING(MODE, TYPE) \ -function_arg_padding ((MODE), (TYPE)) - /* Generate the special assembly code needed to tell the assembler whatever it might need to know about the return value of a function. Index: gcc/config/sparc/sparc-protos.h =================================================================== --- gcc/config/sparc/sparc-protos.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/sparc/sparc-protos.h 2017-08-28 11:03:59.140654650 +0100 @@ -28,10 +28,6 @@ #define __SPARC_PROTOS_H__ extern void init_cumulative_args (CUMULATIVE_ARGS *, tree, rtx, tree); #endif extern unsigned long sparc_type_code (tree); -#ifdef ARGS_SIZE_RTX -/* expr.h defines ARGS_SIZE_RTX and `enum direction' */ -extern enum direction function_arg_padding (machine_mode, const_tree); -#endif /* ARGS_SIZE_RTX */ #endif /* TREE_CODE */ extern void order_regs_for_local_alloc (void); Index: gcc/config/sparc/sparc.c =================================================================== --- gcc/config/sparc/sparc.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/sparc/sparc.c 2017-08-28 11:03:59.141660250 +0100 @@ -648,6 +648,7 @@ static rtx sparc_function_arg (cumulativ machine_mode, const_tree, bool); static rtx sparc_function_incoming_arg (cumulative_args_t, machine_mode, const_tree, bool); +static pad_direction sparc_function_arg_padding (machine_mode, const_tree); static unsigned int sparc_function_arg_boundary (machine_mode, const_tree); static int sparc_arg_partial_bytes (cumulative_args_t, @@ -796,6 +797,8 @@ #define TARGET_FUNCTION_ARG_ADVANCE spar #define TARGET_FUNCTION_ARG sparc_function_arg #undef TARGET_FUNCTION_INCOMING_ARG #define TARGET_FUNCTION_INCOMING_ARG sparc_function_incoming_arg +#undef TARGET_FUNCTION_ARG_PADDING +#define TARGET_FUNCTION_ARG_PADDING sparc_function_arg_padding #undef TARGET_FUNCTION_ARG_BOUNDARY #define TARGET_FUNCTION_ARG_BOUNDARY sparc_function_arg_boundary @@ -7315,18 +7318,17 @@ sparc_function_arg_advance (cumulative_a } } -/* Handle the FUNCTION_ARG_PADDING macro. - For the 64-bit ABI structs are always stored left shifted in their - argument slot. */ +/* Implement TARGET_FUNCTION_ARG_PADDING. For the 64-bit ABI structs + are always stored left shifted in their argument slot. */ -enum direction -function_arg_padding (machine_mode mode, const_tree type) +static pad_direction +sparc_function_arg_padding (machine_mode mode, const_tree type) { if (TARGET_ARCH64 && type && AGGREGATE_TYPE_P (type)) - return upward; + return PAD_UPWARD; /* Fall back to the default. */ - return DEFAULT_FUNCTION_ARG_PADDING (mode, type); + return default_function_arg_padding (mode, type); } /* Handle the TARGET_RETURN_IN_MEMORY target hook. Index: gcc/config/spu/spu.h =================================================================== --- gcc/config/spu/spu.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/spu/spu.h 2017-08-28 11:03:59.142665850 +0100 @@ -329,8 +329,6 @@ #define FUNCTION_ARG_OFFSET(MODE, TYPE) ? (4 - GET_MODE_SIZE (MODE)) \ : 0) -#define FUNCTION_ARG_PADDING(MODE,TYPE) upward - #define PAD_VARARGS_DOWN 0 #define FUNCTION_ARG_REGNO_P(N) ((N) >= (FIRST_ARG_REGNUM) && (N) <= (LAST_ARG_REGNUM)) Index: gcc/config/spu/spu.c =================================================================== --- gcc/config/spu/spu.c 2017-08-28 11:03:58.526233104 +0100 +++ gcc/config/spu/spu.c 2017-08-28 11:03:59.142665850 +0100 @@ -3876,6 +3876,14 @@ spu_function_arg_advance (cumulative_arg : HARD_REGNO_NREGS (cum, mode)); } +/* Implement TARGET_FUNCTION_ARG_PADDING. */ + +static pad_direction +spu_function_arg_padding (machine_mode, const_tree) +{ + return PAD_UPWARD; +} + /* Variable sized types are passed by reference. */ static bool spu_pass_by_reference (cumulative_args_t cum ATTRIBUTE_UNUSED, @@ -7268,6 +7276,9 @@ #define TARGET_FUNCTION_ARG spu_function #undef TARGET_FUNCTION_ARG_ADVANCE #define TARGET_FUNCTION_ARG_ADVANCE spu_function_arg_advance +#undef TARGET_FUNCTION_ARG_PADDING +#define TARGET_FUNCTION_ARG_PADDING spu_function_arg_padding + #undef TARGET_MUST_PASS_IN_STACK #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size Index: gcc/system.h =================================================================== --- gcc/system.h 2017-08-28 11:03:58.526233104 +0100 +++ gcc/system.h 2017-08-28 11:03:59.145682649 +0100 @@ -906,7 +906,7 @@ #define realloc xrealloc CLEAR_BY_PIECES_P MOVE_BY_PIECES_P SET_BY_PIECES_P \ STORE_BY_PIECES_P TARGET_FLT_EVAL_METHOD \ HARD_REGNO_CALL_PART_CLOBBERED HARD_REGNO_MODE_OK \ - MODES_TIEABLE_P + MODES_TIEABLE_P FUNCTION_ARG_PADDING /* Target macros only used for code built for the target, that have moved to libgcc-tm.h or have never been present elsewhere. */