From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTP id ECC49385802A for ; Wed, 29 Sep 2021 18:56:28 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org ECC49385802A Received: from mail-qk1-f199.google.com (mail-qk1-f199.google.com [209.85.222.199]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-356-F90nFlwsNc-tp1S5o_SwbA-1; Wed, 29 Sep 2021 14:56:27 -0400 X-MC-Unique: F90nFlwsNc-tp1S5o_SwbA-1 Received: by mail-qk1-f199.google.com with SMTP id i16-20020a05620a249000b004558dcb5663so10548866qkn.9 for ; Wed, 29 Sep 2021 11:56:27 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=GGpk7Wpp2Ffwe+fRb0fOtKTM+o5DYSGbvE4UoZt+jtI=; b=H9TpA+NmkAjxnIoUUzcOK/mcVpcyl9D+XpsCKdN09u1MfPSKkEBc3RQHWGMsHqJN9m XnLNEibJyGFr1Xeo9TfUmOm1odSSIIThTRQP92D7uGEisBEXBlk9mr/INl5d4Fmu7ytR EPBZgIgv7oq9z2aXI0n+udtwm5z4ahNWghnaad8vD0SySSdKc5KqMYYwBjxTI3u5RTZ6 QjMFIlL0hQVMor39SK+h2BJqS9DGABCjufqE0fgcpuLGBZNmn0NjknviPTkQVDLB1TzZ o3k1nlPRmbBKdX3YHMTkY8Nr3llZxC8x6+adtqXVVFXWxE4fWojWX6Rz6wfdjHznpc66 VQEA== X-Gm-Message-State: AOAM530O1t11Jk4kJJqUE1Gv0GOeKZk9APZ4v8MSPJANEQLI7/w+KCj+ zcFJTWbCB//RowhinKeetMiAFwnym7NHmpsjHf+3lOBLlQaHumJREejr3vDqk2e/zfLjUikLgYG JiNhuvsXWw6qzHJE128mnYrhS8H3l00cjjo+XKNkhBq6ZVS8BzlOtTDYm5YitnBKs4Gkmxv8S8o I= X-Received: by 2002:ad4:53a7:: with SMTP id j7mr1227003qvv.15.1632941786563; Wed, 29 Sep 2021 11:56:26 -0700 (PDT) X-Google-Smtp-Source: ABdhPJy6vKkDaIuLxa9fUXFalhnYQB+RoeIFHJIu4GQx27B7C0UM3T86I1IuC4TitSdP94my4thmug== X-Received: by 2002:ad4:53a7:: with SMTP id j7mr1226961qvv.15.1632941786142; Wed, 29 Sep 2021 11:56:26 -0700 (PDT) Received: from haro.redhat.com ([75.183.81.126]) by smtp.gmail.com with ESMTPSA id a2sm339712qkk.53.2021.09.29.11.56.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 29 Sep 2021 11:56:25 -0700 (PDT) From: William Cohen To: elfutils-devel@sourceware.org Cc: William Cohen Subject: [PATCH] RISC-V: PR27925 Add support for LP64 and LP64F ABIs return values Date: Wed, 29 Sep 2021 14:56:15 -0400 Message-Id: <20210929185615.387853-1-wcohen@redhat.com> X-Mailer: git-send-email 2.31.1 MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="US-ASCII" X-Spam-Status: No, score=-14.3 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: elfutils-devel@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Elfutils-devel mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 29 Sep 2021 18:56:30 -0000 The RISC-V Linux kernel is compiled without floating point (the LP64 ABI) and elfutils could not obtain return value locations for functions in the kernel. This issue was noticed when Systemtap generated RISC-V kernel modules for scripts that used $return target variables in function return probes. This patch adds the needed support to provide return value information for the LP64 and LP64F ABIs. Signed-off-by: William Cohen --- backends/riscv_init.c | 20 ++++++++--- backends/riscv_retval.c | 73 ++++++++++++++++++++++++++++++++++++++--- 2 files changed, 84 insertions(+), 9 deletions(-) diff --git a/backends/riscv_init.c b/backends/riscv_init.c index 551e7bb6..8389d8cd 100644 --- a/backends/riscv_init.c +++ b/backends/riscv_init.c @@ -41,6 +41,12 @@ extern __typeof (EBLHOOK (return_value_location)) riscv_return_value_location_lp64d attribute_hidden; +extern __typeof (EBLHOOK (return_value_location)) + riscv_return_value_location_lp64f attribute_hidden; + +extern __typeof (EBLHOOK (return_value_location)) + riscv_return_value_location_lp64 attribute_hidden; + extern __typeof (EBLHOOK (core_note)) riscv64_core_note attribute_hidden; Ebl * @@ -63,10 +69,16 @@ riscv_init (Elf *elf, eh->core_note = riscv64_core_note; else HOOK (eh, core_note); - if (eh->class == ELFCLASS64 - && ((elf->state.elf64.ehdr->e_flags & EF_RISCV_FLOAT_ABI) - == EF_RISCV_FLOAT_ABI_DOUBLE)) - eh->return_value_location = riscv_return_value_location_lp64d; + if (eh->class == ELFCLASS64){ + if ((elf->state.elf64.ehdr->e_flags & EF_RISCV_FLOAT_ABI) + == EF_RISCV_FLOAT_ABI_DOUBLE) + eh->return_value_location = riscv_return_value_location_lp64d; + else if ((elf->state.elf64.ehdr->e_flags & EF_RISCV_FLOAT_ABI) + == EF_RISCV_FLOAT_ABI_SINGLE) + eh->return_value_location = riscv_return_value_location_lp64f; + else + eh->return_value_location = riscv_return_value_location_lp64; + } return eh; } diff --git a/backends/riscv_retval.c b/backends/riscv_retval.c index 35b6010b..95d9b453 100644 --- a/backends/riscv_retval.c +++ b/backends/riscv_retval.c @@ -40,6 +40,7 @@ #define BACKEND riscv_ #include "libebl_CPU.h" + static int dwarf_bytesize_aux (Dwarf_Die *die, Dwarf_Word *sizep) { @@ -125,8 +126,9 @@ pass_by_flattened_arg (const Dwarf_Op **locp __attribute__ ((unused)), } int -riscv_return_value_location_lp64d (Dwarf_Die *functypedie, - const Dwarf_Op **locp) +riscv_return_value_location_lp64ifd (int fp, + Dwarf_Die *functypedie, + const Dwarf_Op **locp) { /* Start with the function's type, and get the DW_AT_type attribute, which is the type of the return value. */ @@ -211,8 +213,25 @@ riscv_return_value_location_lp64d (Dwarf_Die *functypedie, switch (size) { case 4: /* single */ + switch (fp){ + case EF_RISCV_FLOAT_ABI_DOUBLE: + case EF_RISCV_FLOAT_ABI_SINGLE: + return pass_in_fpr_lp64d (locp, size); + case EF_RISCV_FLOAT_ABI_SOFT: + return pass_in_gpr_lp64 (locp, size); + default: + return -2; + } case 8: /* double */ - return pass_in_fpr_lp64d (locp, size); + switch (fp){ + case EF_RISCV_FLOAT_ABI_DOUBLE: + return pass_in_fpr_lp64d (locp, size); + case EF_RISCV_FLOAT_ABI_SINGLE: + case EF_RISCV_FLOAT_ABI_SOFT: + return pass_in_gpr_lp64 (locp, size); + default: + return -2; + } case 16: /* quad */ return pass_in_gpr_lp64 (locp, size); @@ -227,10 +246,27 @@ riscv_return_value_location_lp64d (Dwarf_Die *functypedie, switch (size) { case 8: /* float _Complex */ - return pass_in_fpr_lp64f (locp, size); + switch (fp){ + case EF_RISCV_FLOAT_ABI_DOUBLE: + case EF_RISCV_FLOAT_ABI_SINGLE: + return pass_in_fpr_lp64f (locp, size); + case EF_RISCV_FLOAT_ABI_SOFT: + /* Double the size so the vals are two registers. */ + return pass_in_gpr_lp64 (locp, size*2); + default: + return -2; + } case 16: /* double _Complex */ - return pass_in_fpr_lp64d (locp, size); + switch (fp){ + case EF_RISCV_FLOAT_ABI_DOUBLE: + return pass_in_fpr_lp64d (locp, size); + case EF_RISCV_FLOAT_ABI_SINGLE: + case EF_RISCV_FLOAT_ABI_SOFT: + return pass_in_gpr_lp64 (locp, size); + default: + return -2; + } case 32: /* long double _Complex */ return pass_by_ref (locp); @@ -249,3 +285,30 @@ riscv_return_value_location_lp64d (Dwarf_Die *functypedie, *locp = NULL; return 0; } + +int +riscv_return_value_location_lp64d (Dwarf_Die *functypedie, + const Dwarf_Op **locp) +{ + return riscv_return_value_location_lp64ifd (EF_RISCV_FLOAT_ABI_DOUBLE, + functypedie, + locp); +} + +int +riscv_return_value_location_lp64f (Dwarf_Die *functypedie, + const Dwarf_Op **locp) +{ + return riscv_return_value_location_lp64ifd (EF_RISCV_FLOAT_ABI_SINGLE, + functypedie, + locp); +} + +int +riscv_return_value_location_lp64 (Dwarf_Die *functypedie, + const Dwarf_Op **locp) +{ + return riscv_return_value_location_lp64ifd (EF_RISCV_FLOAT_ABI_SOFT, + functypedie, + locp); +} -- 2.31.1