From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR04-VI1-obe.outbound.protection.outlook.com (mail-eopbgr80133.outbound.protection.outlook.com [40.107.8.133]) by sourceware.org (Postfix) with ESMTPS id 0B53D3856974 for ; Fri, 21 Oct 2022 13:54:44 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 0B53D3856974 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=syrmia.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=Syrmia.com ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=NiS7ArjZfj6Ge3KKpd2eSc0H6/g1z50IqfwG1ge9aAFuTOF6RXPlz+2CzUeiHSapjaOxo63BNZt/yJTPxmpa4Qh3hSmnl/o62HXVTFknM6e/WsBFrEVdpkMyUZxOSGL6QPWfb4yrXBYo/lapgnJEWG//7e1QWXPicDwb8d+ZofIRm8CQy4vHTaS8lVAmayRlFgGI9zbH+110+qKvxgdXDV2nga8Q9KobpoTtvzGftcFVMqnW4hnHVtidY6W2njmcQ1jw7mLM0rC4kLa4MLnvWTxyqPDG0uZ9zRXMaJQE5r9xRbJdQPKvAvoIOamNY8J7AkGiH7gay9Pvfme+Tar4qg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=aIXxHE6n6od9v/yNESc7COqIJl2XI210mA3dBsj3rr8=; b=dSLMEOb5UeXDmC3+V0quWgqjDRUvWQWs6sQnoy1m95H0JvSxZCZ7EQa0Z3tyMPqmdZLgoCuE+dPCTrZ4A8n/8nwLnRkNPswBaogacljLdUwiEHwq4i6Cf8NuHUt0FH38Jb8ZlPP1pzvtcDdpM1BKd69ATtrw/iS0beJ7YeAXyk67oS5cYCD5JHs1xkUYioTJErrCGuAnrICpieQ8XDNtrgqt0Mw85mh0aRjcIE7vNMMtiplZz0cxLcCS9MzKjuWTQ/1c5t5SFwhypWM/D/dcbvbA6pwZtEMuhQzvj+b0ELlELERKUH+paacGeAver7xRkoK6jWHn43E43SuSKTuZ4A== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=syrmia.com; dmarc=pass action=none header.from=syrmia.com; dkim=pass header.d=syrmia.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=syrmia.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=aIXxHE6n6od9v/yNESc7COqIJl2XI210mA3dBsj3rr8=; b=OVkOKfR3eC/cBg1z57zl4VwiccDUcgtLu0Ip3BNsGNEgLHTyxEUZ9BSlaXYhf9kw6TdEkdNNQDxvoAoIyZRRWXtUyxL8pV692jWTSV61tZ2r8mPXkez7CSnkQYSDMCQnRz3hojm80ywTJL+poXpmykRmGRAYd9WjhgeSRcZbA6I= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=syrmia.com; Received: from AM0PR03MB4882.eurprd03.prod.outlook.com (2603:10a6:208:fb::17) by VI1PR03MB6189.eurprd03.prod.outlook.com (2603:10a6:800:142::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5723.30; Fri, 21 Oct 2022 13:54:39 +0000 Received: from AM0PR03MB4882.eurprd03.prod.outlook.com ([fe80::7f26:4554:fc25:8412]) by AM0PR03MB4882.eurprd03.prod.outlook.com ([fe80::7f26:4554:fc25:8412%3]) with mapi id 15.20.5723.035; Fri, 21 Oct 2022 13:54:39 +0000 From: Dimitrije Milosevic To: gcc-patches@gcc.gnu.org Cc: djordje.todorovic@syrmia.com, =?UTF-8?q?Dimitrije=20Milo=C5=A1evi=C4=87?= Subject: [PATCH 1/2] ivopts: Revert computation of address cost complexity. Date: Fri, 21 Oct 2022 15:52:02 +0200 Message-Id: <20221021135203.626255-2-dimitrije.milosevic@syrmia.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20221021135203.626255-1-dimitrije.milosevic@syrmia.com> References: <20221021135203.626255-1-dimitrije.milosevic@syrmia.com> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-ClientProxiedBy: VE1PR03CA0044.eurprd03.prod.outlook.com (2603:10a6:803:118::33) To AM0PR03MB4882.eurprd03.prod.outlook.com (2603:10a6:208:fb::17) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: AM0PR03MB4882:EE_|VI1PR03MB6189:EE_ X-MS-Office365-Filtering-Correlation-Id: 62693db1-6611-47e6-2a69-08dab36bcbcf X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: OidOZcyaI5/gtVIggdS3pRPt1H7py82dl2ahI4QpUzEJO1p8yQtwSGw7HlORe9FrQS2/h7DxvR1Fg+DDm03z+BFXmvvieJrPmLmHVeB4QuB3TQHUbwG7v1Ln3d8c1HSfJMsVblEqQEwYfKJP9dE57zwkEH5IG7mQ4hBXmiVtzH/cUPuOMPn15I3WqoCAhYN0v0We3QSfsOJh5AHUe5iqdcUPN+zQuXATH1qolQU4qfE2SoAprsZRSS13sfBMUqkejum2v1z+1B8EWAQBMIJwvpUlo2cZXeOmdxAyQcuXpSFHOEXlUBJFF9lqid7rwKSrjRM4h9+0RjoupYr0IaQ2i/+TpAAFUktBAICKXq25EF0uxoTKdGFF7+2SsgpRVM59Gr01RYkQmdwOSWfElbIPNd28jo+a6cM0iQc1rK8YkWQryDBrvWT7oPRpfPtZt0uaU8TNLYyuVbZdN3CAWZM3GJU7iS5QE3cbKM/wRZLZoCYX8uwcme5EvJrdZJJhRS/Qths0anEMFrI/2Asqs73rDluR7XgPIw0uVHDk38mATKffGkEm6HJH+L2+EwUGtonn8hmOrol5zDCCg7+5A19Agt9/lKN8BBJLwcIpklmLi6LefSTSQRdxmx6aH46Hy/YBKRplmgCyBP9rQ0UkH5ZiXbi+a6uHU+Oep5fKYaZ/DF4AAG3PMnhBKAlF0EmJM8zOzmVhmLPeE0BCauCr06xw2PMW/rpIayMI5+sCZsGbBfbfiOOyGxNxHx0q2yItOd5RE6j5gbazxWlvBhwXWC9epg== X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:AM0PR03MB4882.eurprd03.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230022)(366004)(39830400003)(376002)(136003)(346002)(396003)(451199015)(66556008)(66946007)(6916009)(44832011)(107886003)(36756003)(41300700001)(26005)(6512007)(52116002)(6506007)(8676002)(66476007)(5660300002)(6666004)(4326008)(8936002)(316002)(2616005)(38350700002)(38100700002)(1076003)(2906002)(186003)(83380400001)(86362001)(6486002)(478600001);DIR:OUT;SFP:1102; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?ZjdlcC94bmpnbUREbUVnS3BqWllZakxiOXVOUjNQaUxNVE1PR3l1MHVReFlL?= =?utf-8?B?bVlRRkxqVUFDeXhQekJkWEthcG9Pb0lRQVNzL09vRnl0WGpxL1pGV1lxRVF0?= =?utf-8?B?dm9URjQxS1Zyc2pvSE1lNmFZbDZ2cmdlSTk3V2k0U25VeFZ0VDkvSlF1b1pN?= =?utf-8?B?ZGFGb2FqbDNnWDlSS2dQdndxdDdIL2hnbzlpMWhTNmtXWE5UbFdZdFpoZkFi?= =?utf-8?B?UHV2SnVscE1ZcktuZWRnTFFwVy9TMy8zb2hNbTZ2aHFwbE9jVm4yeTFVcFhy?= =?utf-8?B?dWdUZmtKdVhhcURLYk5hUVFuNDRtVFdpWDZZaFdZUDVwZlFXMTNxSWNjcjh4?= =?utf-8?B?Z0hNWFFtU2wvOHNaZ2h3dDQ5RHBiQytaVWJTZUgza2N4MXZqSk4wQzI2RWdT?= =?utf-8?B?MVlzK2hnQTl1ZkZ3ME5saUJVYkYya3dqQk9tMU9HVjFiUnhOMm80Nkd0YlVX?= =?utf-8?B?R1hCOTJuNGhiS0pUczhWZWdwSWhLL2JoZVE1VXovSmJxeUZBV2Y1VlhmaVR0?= =?utf-8?B?WmlWYnZTVXE1eUFnNzlZV2xaTDBKUWp3dVBPUmZsU3FCNlhMbWx2WGFhaGxq?= =?utf-8?B?K2diMzVQdmFwNHZnb0J0d2dMNm9jcXNKRDhiUmcxUXh4d1Yyd1FGTCtxSkk2?= =?utf-8?B?OUhxZmlDNGFoTUxHNGNjb0FacitHQ0ZNbVF1VitUVjViZ1V0RzZ2a0lERlp6?= =?utf-8?B?cCtYb3lYZDRVU1NCSW1YUk1rNHRPZGF5SXdzL2UzclNhZ0dlcnBNcWViU2R5?= =?utf-8?B?MkI4RVRuay9aLzZsUXJYQ0xMblduanJJbzU2QjYrZDRBRGhvLzNEamdqTDBz?= =?utf-8?B?RFVyWXc5NmVJR0xGdmd2Q3k3ejE0NzRFcnRFSnlwTXlsRHQwRTM2K1VTVy9D?= =?utf-8?B?N0d6Vld0YVZndUZuVktwQ3F4akZieDRDbWsrejhCbHVRL1BxU29mS0dyNXF5?= =?utf-8?B?ZFIyWVpDRHRNd1NXai9ScFhoNFJPZGNocmtEamdSU0lwdk0vT3JObUdLTm1r?= =?utf-8?B?R0tpUmJHaTh1QzdyQlI4NjlNTDRtakt2VDVvWWwyN2RJVDJVR2ZlTDVQQS9s?= =?utf-8?B?YUVwdGI2ay9pczBlMmI2bXZVd3RQRlNQd253ck9PU3BXMlc0SVJSTlQ3VEZT?= =?utf-8?B?YjNsVmJ0VFpSTFIzcXorNTJRYmtaWE9pMFVvLzNTWFFYVW1QNHhzV29ocjNZ?= =?utf-8?B?eU56OW14OWNmdEliQzRaejk4RFh2QUhxUGttYTRNcTFIQnIwZzJpMXR3cC9j?= =?utf-8?B?dlQrYytnUEV3clhQYTFsT2p1WEtrdWhCRkw3emdoWDhBMHFoUUxiZnZuQjFY?= =?utf-8?B?UXlxQ1BGRjBQQzczenM1VFhBUzYvTEFYVzVFWnNzOTMrdVhad2pRY1lBek03?= =?utf-8?B?MzRaZHFRNGNIZC9NSkVENlZxdU1qejJoREs5Skd4emNJTGpCcjR2YlRYbldk?= =?utf-8?B?S2RmSVliM0Njc294QXBUZlpGMjVCcFNweEFzN1dEUHBIRjY2amFQa3VqRUx6?= =?utf-8?B?T2laRmkxNkdOWDBDUjF0ZEFhYUg3QUc1dFpybWw4MW96dFhGUTRjVWF4dXJD?= =?utf-8?B?Q0JTTFhPKzYxaTgyek1MME5BYjBuYlRlTlpWUGkyK3doNktKUkNaME1QbitG?= =?utf-8?B?OGxzeXVUZWJFNDVMa0JYNDFLSFRzRGlFVzF3Qm4wS3dKbk1UdGRVQ0FTQkR6?= =?utf-8?B?cllLOW9FTzFDU0FxTHhoSXV3eGRYNFQvU3NTT2lUSG1kdCtJNDhVYlBqODc5?= =?utf-8?B?SkZPYUt2NGpjdzFzbzh4NEZhZVdXM2NHVS8xZ0hVQXJuZ0hncHFQQXVhekVV?= =?utf-8?B?V1pZZFZrRUpjTVNIbE45dk4zRlplaTU0MGZZdlByT2JPT2VYODJmVWQwcVBO?= =?utf-8?B?WDNCUlEyMCtValFFREt2SXJEQytaU2lBZzJjNG4wZFJiUDhTVUQyNG9VL2ZL?= =?utf-8?B?MVkzRHdEVHVWV3ppM2JlVVBaNitmM0cyaFVjUHpmakRoeEJvQzNXQlg3ZTNs?= =?utf-8?B?ZHp0R05Gc3NJZHV4Q2h2SGx6Qi9CcDJHc05WQmpMNmRjazRqRkZUTW1ITXJo?= =?utf-8?B?TkxYVFAzTm12YUs2QUtUMzMrRW9mK2N3RDVUWkFGWi9QaHJpeTFNRWREMU03?= =?utf-8?B?SktiQkFEY2RzTkJyUmI1Q0ovdHhzdTNTV0lzbUpWUU9BQ1lkcDY5SmptLzhO?= =?utf-8?Q?WDxFAx9oa2qDbWIbevN1wTg=3D?= X-OriginatorOrg: syrmia.com X-MS-Exchange-CrossTenant-Network-Message-Id: 62693db1-6611-47e6-2a69-08dab36bcbcf X-MS-Exchange-CrossTenant-AuthSource: AM0PR03MB4882.eurprd03.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 21 Oct 2022 13:54:38.9664 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 19214a73-c1ab-4e19-8f59-14bdcb09a66e X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: fctMpf/wpgnu2GwfnFiNXM4M2ecg7yrTl369he4+VwXSepv03om5Js0kWD3gCXeigtx157vY/uto3n9xm1XraqQ+cXnoB2THrXmFY5hn2uA= X-MS-Exchange-Transport-CrossTenantHeadersStamped: VI1PR03MB6189 X-Spam-Status: No, score=-12.9 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_PASS,SPF_PASS,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: From: Dimitrije Milošević This patch reverts the computation of address cost complexity to the legacy one. After f9f69dd, complexity is calculated using the valid_mem_ref_p target hook. Architectures like Mips only allow BASE + OFFSET addressing modes, which in turn prevents the calculation of complexity for other addressing modes, resulting in non-optimal candidate selection. gcc/ChangeLog: * tree-ssa-address.cc (multiplier_allowed_in_address_p): Change to non-static. * tree-ssa-address.h (multiplier_allowed_in_address_p): Declare. * tree-ssa-loop-ivopts.cc (compute_symbol_and_var_present): Reintroduce. (compute_min_and_max_offset): Likewise. (get_address_cost): Revert complexity calculation. Signed-off-by: Dimitrije Milosevic --- gcc/tree-ssa-address.cc | 2 +- gcc/tree-ssa-address.h | 2 + gcc/tree-ssa-loop-ivopts.cc | 214 ++++++++++++++++++++++++++++++++++-- 3 files changed, 207 insertions(+), 11 deletions(-) diff --git a/gcc/tree-ssa-address.cc b/gcc/tree-ssa-address.cc index ba7b7c93162..442f54f0165 100644 --- a/gcc/tree-ssa-address.cc +++ b/gcc/tree-ssa-address.cc @@ -561,7 +561,7 @@ add_to_parts (struct mem_address *parts, tree elt) validity for a memory reference accessing memory of mode MODE in address space AS. */ -static bool +bool multiplier_allowed_in_address_p (HOST_WIDE_INT ratio, machine_mode mode, addr_space_t as) { diff --git a/gcc/tree-ssa-address.h b/gcc/tree-ssa-address.h index 95143a099b9..09f36ee2f19 100644 --- a/gcc/tree-ssa-address.h +++ b/gcc/tree-ssa-address.h @@ -38,6 +38,8 @@ tree create_mem_ref (gimple_stmt_iterator *, tree, class aff_tree *, tree, tree, tree, bool); extern void copy_ref_info (tree, tree); tree maybe_fold_tmr (tree); +bool multiplier_allowed_in_address_p (HOST_WIDE_INT ratio, machine_mode mode, + addr_space_t as); extern unsigned int preferred_mem_scale_factor (tree base, machine_mode mem_mode, diff --git a/gcc/tree-ssa-loop-ivopts.cc b/gcc/tree-ssa-loop-ivopts.cc index a6f926a68ef..d53ba05a4f6 100644 --- a/gcc/tree-ssa-loop-ivopts.cc +++ b/gcc/tree-ssa-loop-ivopts.cc @@ -4774,6 +4774,135 @@ get_address_cost_ainc (poly_int64 ainc_step, poly_int64 ainc_offset, return infinite_cost; } +static void +compute_symbol_and_var_present (tree e1, tree e2, + bool *symbol_present, bool *var_present) +{ + poly_uint64_pod off1, off2; + + e1 = strip_offset (e1, &off1); + e2 = strip_offset (e2, &off2); + + STRIP_NOPS (e1); + STRIP_NOPS (e2); + + if (TREE_CODE (e1) == ADDR_EXPR) + { + poly_int64_pod diff; + if (ptr_difference_const (e1, e2, &diff)) + { + *symbol_present = false; + *var_present = false; + return; + } + + if (integer_zerop (e2)) + { + tree core; + poly_int64_pod bitsize; + poly_int64_pod bitpos; + widest_int mul; + tree toffset; + machine_mode mode; + int unsignedp, reversep, volatilep; + + core = get_inner_reference (TREE_OPERAND (e1, 0), &bitsize, &bitpos, + &toffset, &mode, &unsignedp, &reversep, &volatilep); + + if (toffset != 0 + || !constant_multiple_p (bitpos, BITS_PER_UNIT, &mul) + || reversep + || !VAR_P (core)) + { + *symbol_present = false; + *var_present = true; + return; + } + + if (TREE_STATIC (core) + || DECL_EXTERNAL (core)) + { + *symbol_present = true; + *var_present = false; + return; + } + + *symbol_present = false; + *var_present = true; + return; + } + + *symbol_present = false; + *var_present = true; + } + *symbol_present = false; + + if (operand_equal_p (e1, e2, 0)) + { + *var_present = false; + return; + } + + *var_present = true; +} + +static void +compute_min_and_max_offset (addr_space_t as, + machine_mode mem_mode, poly_int64_pod *min_offset, + poly_int64_pod *max_offset) +{ + machine_mode address_mode = targetm.addr_space.address_mode (as); + HOST_WIDE_INT i; + poly_int64_pod off, width; + rtx addr; + rtx reg1; + + reg1 = gen_raw_REG (address_mode, LAST_VIRTUAL_REGISTER + 1); + + width = GET_MODE_BITSIZE (address_mode) - 1; + if (known_gt (width, HOST_BITS_PER_WIDE_INT - 1)) + width = HOST_BITS_PER_WIDE_INT - 1; + gcc_assert (width.is_constant ()); + addr = gen_rtx_fmt_ee (PLUS, address_mode, reg1, NULL_RTX); + + off = 0; + for (i = width.to_constant (); i >= 0; i--) + { + off = -(HOST_WIDE_INT_1U << i); + XEXP (addr, 1) = gen_int_mode (off, address_mode); + if (memory_address_addr_space_p (mem_mode, addr, as)) + break; + } + if (i == -1) + *min_offset = 0; + else + *min_offset = off; + // *min_offset = (i == -1? 0 : off); + + for (i = width.to_constant (); i >= 0; i--) + { + off = (HOST_WIDE_INT_1U << i) - 1; + XEXP (addr, 1) = gen_int_mode (off, address_mode); + if (memory_address_addr_space_p (mem_mode, addr, as)) + break; + /* For some strict-alignment targets, the offset must be naturally + aligned. Try an aligned offset if mem_mode is not QImode. */ + off = mem_mode != QImode + ? (HOST_WIDE_INT_1U << i) + - (GET_MODE_SIZE (mem_mode)) + : 0; + if (known_gt (off, 0)) + { + XEXP (addr, 1) = gen_int_mode (off, address_mode); + if (memory_address_addr_space_p (mem_mode, addr, as)) + break; + } + } + if (i == -1) + off = 0; + *max_offset = off; +} + /* Return cost of computing USE's address expression by using CAND. AFF_INV and AFF_VAR represent invariant and variant parts of the address expression, respectively. If AFF_INV is simple, store @@ -4802,6 +4931,13 @@ get_address_cost (struct ivopts_data *data, struct iv_use *use, /* Only true if ratio != 1. */ bool ok_with_ratio_p = false; bool ok_without_ratio_p = false; + tree ubase = use->iv->base; + tree cbase = cand->iv->base, cstep = cand->iv->step; + tree utype = TREE_TYPE (ubase), ctype; + unsigned HOST_WIDE_INT cstepi; + bool symbol_present = false, var_present = false, stmt_is_after_increment; + poly_int64_pod min_offset, max_offset; + bool offset_p, ratio_p; if (!aff_combination_const_p (aff_inv)) { @@ -4915,16 +5051,74 @@ get_address_cost (struct ivopts_data *data, struct iv_use *use, gcc_assert (memory_address_addr_space_p (mem_mode, addr, as)); cost += address_cost (addr, mem_mode, as, speed); - if (parts.symbol != NULL_TREE) - cost.complexity += 1; - /* Don't increase the complexity of adding a scaled index if it's - the only kind of index that the target allows. */ - if (parts.step != NULL_TREE && ok_without_ratio_p) - cost.complexity += 1; - if (parts.base != NULL_TREE && parts.index != NULL_TREE) - cost.complexity += 1; - if (parts.offset != NULL_TREE && !integer_zerop (parts.offset)) - cost.complexity += 1; + if (cst_and_fits_in_hwi (cstep)) + cstepi = int_cst_value (cstep); + else + cstepi = 0; + + STRIP_NOPS (cbase); + ctype = TREE_TYPE (cbase); + + stmt_is_after_increment = stmt_after_increment (data->current_loop, cand, + use->stmt); + + if (cst_and_fits_in_hwi (cbase)) + compute_symbol_and_var_present (ubase, build_int_cst (utype, 0), + &symbol_present, &var_present); + else if (ratio == 1) + { + tree real_cbase = cbase; + + /* Check to see if any adjustment is needed. */ + if (!cst_and_fits_in_hwi (cstep) && stmt_is_after_increment) + { + aff_tree real_cbase_aff; + aff_tree cstep_aff; + + tree_to_aff_combination (cbase, TREE_TYPE (real_cbase), + &real_cbase_aff); + tree_to_aff_combination (cstep, TREE_TYPE (cstep), &cstep_aff); + + aff_combination_add (&real_cbase_aff, &cstep_aff); + real_cbase = aff_combination_to_tree (&real_cbase_aff); + } + compute_symbol_and_var_present (ubase, real_cbase, + &symbol_present, &var_present); + } + else if (!POINTER_TYPE_P (ctype) + && multiplier_allowed_in_address_p + (ratio, mem_mode, + TYPE_ADDR_SPACE (TREE_TYPE (utype)))) + { + tree real_cbase = cbase; + + if (cstepi == 0 && stmt_is_after_increment) + { + if (POINTER_TYPE_P (ctype)) + real_cbase = fold_build2 (POINTER_PLUS_EXPR, ctype, cbase, cstep); + else + real_cbase = fold_build2 (PLUS_EXPR, ctype, cbase, cstep); + } + real_cbase = fold_build2 (MULT_EXPR, ctype, real_cbase, + build_int_cst (ctype, ratio)); + compute_symbol_and_var_present (ubase, real_cbase, + &symbol_present, &var_present); + } + else + { + compute_symbol_and_var_present (ubase, build_int_cst (utype, 0), + &symbol_present, &var_present); + } + + compute_min_and_max_offset (as, mem_mode, &min_offset, &max_offset); + offset_p = maybe_ne (aff_inv->offset, 0) + && known_le (min_offset, aff_inv->offset) + && known_le (aff_inv->offset, max_offset); + ratio_p = (ratio != 1 + && multiplier_allowed_in_address_p (ratio, mem_mode, as)); + + cost.complexity = (symbol_present != 0) + (var_present != 0) + + offset_p + ratio_p; return cost; } -- 2.25.1