From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from t03.bc.larksuite.com (t03.bc.larksuite.com [209.127.231.38]) by sourceware.org (Postfix) with UTF8SMTPS id 410AA385842C for ; Tue, 11 Apr 2023 08:13:07 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 410AA385842C Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=oss.cipunited.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=oss.cipunited.com DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; s=s1; d=oss-cipunited-com.20200927.dkim.feishu.cn; t=1681200782; h=from:subject:mime-version:from:date:message-id:subject:to:cc: reply-to:content-type:mime-version:in-reply-to:message-id; bh=oyxTyKcgX76TiBUP+iCO3KuFHIGMu2JABwF6OAdTQvE=; b=I1Xw6YXs2JopvX66FEG8VCe9h2zLrVCEwCnzLeUdRplDYIBpSXPtVI8MGLcZXd/+hShV3g R9SVL74H4vXcCrrceoTYbHHQDlxDYKlOu6yE0jlcIAG905FHNU60jkyjHkYtIqD9ONV4Y6 zGR5ovxKKdDG3JobL/HEvavCZRS8N68QfvEOqlud4fbpELY6V3IW6VRHBFEl7+IAGbz/P/ w+PQ1qxZr937+k3cxb7zXkl+4WrP5PYxfpqyZ1AuM7ZkIfHpLMCNqhX75I+G86EPp7L3GH PtbEcO/AQOqFZIq42fKQzrEqVuNqOBrvc0aG1DCPqUlQHBzgRiOolaE3lLbMYg== X-Lms-Return-Path: To: Date: Tue, 11 Apr 2023 16:12:50 +0800 X-Mailer: git-send-email 2.30.2 X-Original-From: "Ying Huang" Reply-To: ying.huang@oss.cipunited.com Subject: [PATCH 5/5] backends: Fix run-native-test.sh and run-funcretval++11.sh run fail on mips Message-Id: <20230411081141.1762395-6-ying.huang@oss.cipunited.com> From: "Ying Huang" References: <20230411081141.1762395-1-ying.huang@oss.cipunited.com> Content-Transfer-Encoding: 8bit In-Reply-To: <20230411081141.1762395-1-ying.huang@oss.cipunited.com> Cc: "Ying Huang" Content-Type: multipart/alternative; boundary=46b1a002d42801e44a50b574de84c91c44662332471c77157ed65563d211 Mime-Version: 1.0 X-Spam-Status: No, score=-12.1 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,GIT_PATCH_0,HTML_MESSAGE,KAM_SHORT,SPF_HELO_NONE,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: --46b1a002d42801e44a50b574de84c91c44662332471c77157ed65563d211 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset=UTF-8 From: Ying Huang add register_info, return_value_location function on mips --- backends/Makefile.am | 2 +- backends/mips_init.c | 2 + backends/mips_regs.c | 109 +++++++++++++++++ backends/mips_retval.c | 261 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 373 insertions(+), 1 deletion(-) create mode 100644 backends/mips_regs.c create mode 100644 backends/mips_retval.c diff --git a/backends/Makefile.am b/backends/Makefile.am index ddc31c9d..5453f787 100644 --- a/backends/Makefile.am +++ b/backends/Makefile.am @@ -101,7 +101,7 @@ loongarch_SRCS =3D loongarch_init.c loongarch_symbol.c arc_SRCS =3D arc_init.c arc_symbol.c =20 mips_SRCS =3D mips_init.c mips_symbol.c mips_attrs.c mips_initreg.c \ - mips_cfi.c mips_unwind.c + mips_cfi.c mips_unwind.c mips_regs.c mips_retval.c =20 libebl_backends_a_SOURCES =3D $(i386_SRCS) $(sh_SRCS) $(x86_64_SRCS) \ $(ia64_SRCS) $(alpha_SRCS) $(arm_SRCS) \ diff --git a/backends/mips_init.c b/backends/mips_init.c index 3caa9fee..7ca93314 100644 --- a/backends/mips_init.c +++ b/backends/mips_init.c @@ -58,6 +58,8 @@ mips_init (Elf *elf __attribute__ ((unused)), HOOK (eh, set_initial_registers_tid); HOOK (eh, abi_cfi); HOOK (eh, unwind); + HOOK (eh, register_info); + HOOK (eh, return_value_location); eh->frame_nregs =3D 32; return eh; } diff --git a/backends/mips_regs.c b/backends/mips_regs.c new file mode 100644 index 00000000..733caeee --- /dev/null +++ b/backends/mips_regs.c @@ -0,0 +1,109 @@ +/* Register names and numbers for mips DWARF. + Copyright (C) 2006 Red Hat, Inc. + Copyright (C) 2023 CIP United Inc. + This file is part of elfutils. + + This file is free software; you can redistribute it and/or modify + it under the terms of either + + * the GNU Lesser General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at + your option) any later version + + or + + * the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at + your option) any later version + + or both in parallel, as here. + + elfutils is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received copies of the GNU General Public License and + the GNU Lesser General Public License along with this program. If + not, see . */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include + +#define BACKEND mips_ +#include "libebl_CPU.h" + +ssize_t +mips_register_info (Ebl *ebl __attribute__ ((unused)), + int regno, char *name, size_t namelen, + const char **prefix, const char **setname, + int *bits, int *type) +{ + if (name =3D=3D NULL) + return 66; + + if (regno < 0 || regno > 65 || namelen < 4) + return -1; + + *prefix =3D "$"; +=20=20 + if (regno < 32) + { + *setname =3D "integer"; + *type =3D DW_ATE_signed; + *bits =3D 32; + if (regno < 32 + 10) + { + name[0] =3D regno + '0'; + namelen =3D 1; + } + else + { + name[0] =3D (regno / 10) + '0'; + name[1] =3D (regno % 10) + '0'; + namelen =3D 2; + } + } + else if (regno < 64) + { + *setname =3D "FPU"; + *type =3D DW_ATE_float; + *bits =3D 32; + name[0] =3D 'f'; + if (regno < 32 + 10) + { + name[1] =3D (regno - 32) + '0'; + namelen =3D 2; + } + else + { + name[1] =3D (regno - 32) / 10 + '0'; + name[2] =3D (regno - 32) % 10 + '0'; + namelen =3D 3; + } + } + else if (regno =3D=3D 64) + { + *type =3D DW_ATE_signed; + *bits =3D 32; + name[0] =3D 'h'; + name[1] =3D 'i'; + namelen =3D 2; + } + else + { + *type =3D DW_ATE_signed; + *bits =3D 32; + name[0] =3D 'l'; + name[1] =3D 'o'; + namelen =3D 2; + } + + name[namelen++] =3D '\0'; + return namelen; +} diff --git a/backends/mips_retval.c b/backends/mips_retval.c new file mode 100644 index 00000000..fd9aaefa --- /dev/null +++ b/backends/mips_retval.c @@ -0,0 +1,261 @@ +/* Function return value location for Linux/mips ABI. + Copyright (C) 2005 Red Hat, Inc. + Copyright (C) 2023 CIP United Inc. + This file is part of elfutils. + + This file is free software; you can redistribute it and/or modify + it under the terms of either + + * the GNU Lesser General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at + your option) any later version + + or + + * the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at + your option) any later version + + or both in parallel, as here. + + elfutils is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received copies of the GNU General Public License and + the GNU Lesser General Public License along with this program. If + not, see . */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include +#include + +#define BACKEND mips_ +#include "libebl_CPU.h" +#include "libdwP.h" + +/* All the possible MIPS ARCHs. */ +enum mips_arch + { + MIPS_ARCH_UNKNOWN =3D 0, + MIPS_ARCH_32, + MIPS_ARCH_64, + MIPS_ARCH_LAST + }; + +/* Find the mips ARCH of the current file */ +enum mips_arch find_mips_arch(Elf *elf) +{ + GElf_Ehdr ehdr_mem; + GElf_Ehdr *ehdr =3D gelf_getehdr (elf, &ehdr_mem); + + if (ehdr =3D=3D NULL) + return MIPS_ARCH_LAST; + + GElf_Word elf_flags =3D ehdr->e_flags; + + /* Check elf_flags to see if it specifies the ARCH being used. */ + switch ((elf_flags & EF_MIPS_ARCH)) + { + case E_MIPS_ARCH_32: + case EF_MIPS_ARCH_32R2: + case E_MIPS_ARCH_32R6: + return MIPS_ARCH_32; + case E_MIPS_ARCH_64: + case EF_MIPS_ARCH_64R2: + case E_MIPS_ARCH_64R6: + return MIPS_ARCH_64; + default: + return MIPS_ARCH_32; + } + + return MIPS_ARCH_UNKNOWN; +} + +unsigned int +mips_arch_regsize (enum mips_arch arch) +{ + switch (arch) + { + case MIPS_ARCH_32: + return 4; + case MIPS_ARCH_64: + return 8; + case MIPS_ARCH_UNKNOWN: + case MIPS_ARCH_LAST: + default: + return 0; + } +} + +/* $v0 or pair $v0, $v1 */ +static const Dwarf_Op loc_intreg_o32[] =3D + { + { .atom =3D DW_OP_reg2 }, { .atom =3D DW_OP_piece, .number =3D 4 }, + { .atom =3D DW_OP_reg3 }, { .atom =3D DW_OP_piece, .number =3D 4 }, + }; + +static const Dwarf_Op loc_intreg[] =3D + { + { .atom =3D DW_OP_reg2 }, { .atom =3D DW_OP_piece, .number =3D 8 }, + { .atom =3D DW_OP_reg3 }, { .atom =3D DW_OP_piece, .number =3D 8 }, + }; +#define nloc_intreg 1 +#define nloc_intregpair 4 + +/* $f0 (float), or pair $f0, $f1 (double). + * f2/f3 are used for COMPLEX (=3D 2 doubles) returns in Fortran */ +static const Dwarf_Op loc_fpreg_o32[] =3D + { + { .atom =3D DW_OP_regx, .number =3D 32 }, { .atom =3D DW_OP_piece, .nu= mber =3D 4 }, + { .atom =3D DW_OP_regx, .number =3D 33 }, { .atom =3D DW_OP_piece, .nu= mber =3D 4 }, + { .atom =3D DW_OP_regx, .number =3D 34 }, { .atom =3D DW_OP_piece, .nu= mber =3D 4 }, + { .atom =3D DW_OP_regx, .number =3D 35 }, { .atom =3D DW_OP_piece, .nu= mber =3D 4 }, + }; + +/* $f0, or pair $f0, $f2. */ +static const Dwarf_Op loc_fpreg[] =3D + { + { .atom =3D DW_OP_regx, .number =3D 32 }, { .atom =3D DW_OP_piece, .nu= mber =3D 8 }, + { .atom =3D DW_OP_regx, .number =3D 34 }, { .atom =3D DW_OP_piece, .nu= mber =3D 8 }, + }; +#define nloc_fpreg 1 +#define nloc_fpregpair 4 +#define nloc_fpregquad 8 + +/* The return value is a structure and is actually stored in stack space + passed in a hidden argument by the caller. But, the compiler + helpfully returns the address of that space in $v0. */ +static const Dwarf_Op loc_aggregate[] =3D + { + { .atom =3D DW_OP_breg2, .number =3D 0 } + }; +#define nloc_aggregate 1 + +int +mips_return_value_location (Dwarf_Die *functypedie, const Dwarf_Op **locp) +{ + /* First find the ARCH used by the elf object */ + enum mips_arch arch =3D find_mips_arch(functypedie->cu->dbg->elf); + /* Something went seriously wrong while trying to figure out the ARCH */ + if (arch =3D=3D MIPS_ARCH_LAST) + return -1; + + /* We couldn't identify the ARCH, but the file seems valid */ + if (arch =3D=3D MIPS_ARCH_UNKNOWN) + return -3; + + unsigned int regsize =3D mips_arch_regsize (arch); + if (!regsize) + return -2; + + /* Start with the function's type, and get the DW_AT_type attribute, + which is the type of the return value. */ +=20=20 + Dwarf_Attribute attr_mem; + Dwarf_Attribute *attr =3D dwarf_attr_integrate (functypedie, DW_AT_type,= &attr_mem); + if (attr =3D=3D NULL) + /* The function has no return value, like a `void' function in C. */ + return 0; + + Dwarf_Die die_mem; + Dwarf_Die *typedie =3D dwarf_formref_die (attr, &die_mem); + int tag =3D dwarf_tag (typedie); + + /* Follow typedefs and qualifiers to get to the actual type. */ + while (tag =3D=3D DW_TAG_typedef + || tag =3D=3D DW_TAG_const_type || tag =3D=3D DW_TAG_volatile_type + || tag =3D=3D DW_TAG_restrict_type) + { + attr =3D dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem); + typedie =3D dwarf_formref_die (attr, &die_mem); + tag =3D dwarf_tag (typedie); + } + + switch (tag) + { + case -1: + return -1; + + case DW_TAG_subrange_type: + if (! dwarf_hasattr_integrate (typedie, DW_AT_byte_size)) + { + attr =3D dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem); + typedie =3D dwarf_formref_die (attr, &die_mem); + tag =3D dwarf_tag (typedie); + } + /* Fall through. */ + FALLTHROUGH; + + case DW_TAG_base_type: + case DW_TAG_enumeration_type: + CASE_POINTER: + { + Dwarf_Word size; + if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_byte_size, + &attr_mem), &size) !=3D 0) + { + if (dwarf_is_pointer (tag)) + size =3D regsize; + else + return -1; + } + if (tag =3D=3D DW_TAG_base_type) + { + Dwarf_Word encoding; + if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_encoding, + &attr_mem), &encoding) !=3D 0) + return -1; + +#define ARCH_LOC(loc, regsize) ((regsize) =3D=3D 4 ? (loc ## _o32) : (loc)) + + if (encoding =3D=3D DW_ATE_float) + { + *locp =3D ARCH_LOC(loc_fpreg, regsize); + if (size <=3D regsize) + return nloc_fpreg; + + if (size <=3D 2*regsize) + return nloc_fpregpair; + + if (size <=3D 4*regsize && arch =3D=3D MIPS_ARCH_32) + return nloc_fpregquad; + + goto aggregate; + } + } + *locp =3D ARCH_LOC(loc_intreg, regsize); + if (size <=3D regsize) + return nloc_intreg; + if (size <=3D 2*regsize) + return nloc_intregpair; + + /* Else fall through. Shouldn't happen though (at least with gcc) */ + } + FALLTHROUGH; + + case DW_TAG_structure_type: + case DW_TAG_class_type: + case DW_TAG_union_type: + case DW_TAG_array_type: + aggregate: + /* XXX TODO: Can't handle structure return with other ABI's yet :-/ = */ + if ((arch !=3D MIPS_ARCH_32) && (arch !=3D MIPS_ARCH_64)) + return -2; + + *locp =3D loc_aggregate; + return nloc_aggregate; + } + + /* XXX We don't have a good way to return specific errors from ebl calls. + This value means we do not understand the type, but it is well-formed + DWARF and might be valid. */ + return -2; +} --=20 2.30.2= --46b1a002d42801e44a50b574de84c91c44662332471c77157ed65563d211--