From patchwork Fri Apr 16 09:18:41 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 1466948 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=sourceware.org; envelope-from=gcc-patches-bounces@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=naIv0SeW; dkim-atps=neutral Received: from sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4FM9cs4pJpz9sV5 for ; Fri, 16 Apr 2021 19:18:53 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 0C1C03890428; Fri, 16 Apr 2021 09:18:51 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 0C1C03890428 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1618564731; bh=PkMZyb5nVxA4MZzQvbLnF7l3tssidf2BevHnaQEeKH4=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=naIv0SeWmckVkO847i46PhHcBvR7nWTYJF/TxqjHZ4cV0rkurTsJiSK7ytdmxmN0v sKmjnGQllN90wFu4iDsqhlkna0vE/1MwX1lwXfZ3WDvx+VBhpAmyB68myOBXCKWr1h lqQqbWjrDyaXmiWv/QGAL3CEHwEDkYV/xYaZjEI4= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by sourceware.org (Postfix) with ESMTP id 2D859389041A for ; Fri, 16 Apr 2021 09:18:43 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 2D859389041A Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 7B35F106F for ; Fri, 16 Apr 2021 02:18:42 -0700 (PDT) Received: from localhost (e121540-lin.manchester.arm.com [10.32.98.126]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 22B893FA35 for ; Fri, 16 Apr 2021 02:18:42 -0700 (PDT) To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@arm.com Subject: [PATCH 2/2] Mark untyped calls and handle them specially [PR98689] Date: Fri, 16 Apr 2021 10:18:41 +0100 Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.3 (gnu/linux) MIME-Version: 1.0 X-Spam-Status: No, score=-12.6 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_STATUS, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Richard Sandiford via Gcc-patches From: Richard Sandiford Reply-To: Richard Sandiford Errors-To: gcc-patches-bounces@gcc.gnu.org Sender: "Gcc-patches" This patch fixes a regression introduced by the rtl-ssa patches. It was seen on HPPA but it might be latent elsewhere. The problem is that the traditional way of expanding an untyped_call is to emit sequences like: (call (mem (symbol_ref "foo"))) (set (reg pseudo1) (reg result1)) ... (set (reg pseudon) (reg resultn)) The ABI specifies that result1..resultn are clobbered by the call but nothing in the RTL indicates that result1..resultn are the results of the call. Normally, using a clobbered value gives undefined results, but in this case the results are well-defined and matter for correctness. This seems like a niche case, so I think it would be better to mark it explicitly rather than try to detect it heuristically. Note that in expand_builtin_apply we already have an rtx_insn *, so it doesn't matter whether we call emit_call_insn or emit_insn. Calling emit_insn seems more natural now that the gen_* call has been split out. It also matches later code in the function. Tested on aarch64-linux-gnu, arm-linux-gnueabihf, armeb-eabi and x86_64-linux-gnu. OK to install? Richard gcc/ PR rtl-optimization/98689 * reg-notes.def (UNTYPED_CALL): New note. * combine.c (distribute_notes): Handle it. * emit-rtl.c (try_split): Likewise. * rtlanal.c (rtx_properties::try_to_add_insn): Likewise. Assume that calls with the note implicitly set all return value registers. * builtins.c (expand_builtin_apply): Add a REG_UNTYPED_CALL to untyped_calls. --- gcc/builtins.c | 8 ++++++-- gcc/combine.c | 1 + gcc/emit-rtl.c | 1 + gcc/reg-notes.def | 15 +++++++++++++++ gcc/rtlanal.c | 9 +++++++++ 5 files changed, 32 insertions(+), 2 deletions(-) diff --git a/gcc/builtins.c b/gcc/builtins.c index 196dda3fa5e..d30c4eb62fc 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -2490,8 +2490,12 @@ expand_builtin_apply (rtx function, rtx arguments, rtx argsize) if (targetm.have_untyped_call ()) { rtx mem = gen_rtx_MEM (FUNCTION_MODE, function); - emit_call_insn (targetm.gen_untyped_call (mem, result, - result_vector (1, result))); + rtx_insn *seq = targetm.gen_untyped_call (mem, result, + result_vector (1, result)); + for (rtx_insn *insn = seq; insn; insn = NEXT_INSN (insn)) + if (CALL_P (insn)) + add_reg_note (insn, REG_UNTYPED_CALL, NULL_RTX); + emit_insn (seq); } else if (targetm.have_call_value ()) { diff --git a/gcc/combine.c b/gcc/combine.c index 6cb5b0ca102..9063a07bd00 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -14337,6 +14337,7 @@ distribute_notes (rtx notes, rtx_insn *from_insn, rtx_insn *i3, rtx_insn *i2, case REG_SETJMP: case REG_TM: case REG_CALL_DECL: + case REG_UNTYPED_CALL: case REG_CALL_NOCF_CHECK: /* These notes must remain with the call. It should not be possible for both I2 and I3 to be a call. */ diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c index 1113c58c49e..07e908624a0 100644 --- a/gcc/emit-rtl.c +++ b/gcc/emit-rtl.c @@ -3964,6 +3964,7 @@ try_split (rtx pat, rtx_insn *trial, int last) break; case REG_CALL_DECL: + case REG_UNTYPED_CALL: gcc_assert (call_insn != NULL_RTX); add_reg_note (call_insn, REG_NOTE_KIND (note), XEXP (note, 0)); break; diff --git a/gcc/reg-notes.def b/gcc/reg-notes.def index d7f0bfdab0b..995052ebc28 100644 --- a/gcc/reg-notes.def +++ b/gcc/reg-notes.def @@ -233,6 +233,21 @@ REG_NOTE (STACK_CHECK) insn. This note is a SYMBOL_REF. */ REG_NOTE (CALL_DECL) +/* Indicates that the call is an untyped_call. These calls are special + in that they set all of the target ABI's return value registers to a + defined value without explicitly saying so. For example, a typical + untyped_call sequence has the form: + + (call (mem (symbol_ref "foo"))) + (set (reg pseudo1) (reg result1)) + ... + (set (reg pseudon) (reg resultn)) + + The ABI specifies that result1..resultn are clobbered by the call, + but the RTL does not indicate that result1..resultn are the results + of the call. */ +REG_NOTE (UNTYPED_CALL) + /* Indicate that a call should not be verified for control-flow consistency. The target address of the call is assumed as a valid address and no check to validate a branch to the target address is needed. The call is marked diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c index 170420a610b..67a49e65fd8 100644 --- a/gcc/rtlanal.c +++ b/gcc/rtlanal.c @@ -2333,6 +2333,15 @@ rtx_properties::try_to_add_insn (const rtx_insn *insn, bool include_notes) *ref_iter++ = rtx_obj_reference (regno, flags, reg_raw_mode[regno], 0); } + /* Untyped calls implicitly set all function value registers. + Again, we add them first in case the main pattern contains + a fixed-form clobber. */ + if (find_reg_note (insn, REG_UNTYPED_CALL, NULL_RTX)) + for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno) + if (targetm.calls.function_value_regno_p (regno) + && ref_iter != ref_end) + *ref_iter++ = rtx_obj_reference (regno, rtx_obj_flags::IS_WRITE, + reg_raw_mode[regno], 0); if (ref_iter != ref_end && !RTL_CONST_CALL_P (insn)) { auto mem_flags = rtx_obj_flags::IS_READ;