From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR05-VI1-obe.outbound.protection.outlook.com (mail-vi1eur05on2101.outbound.protection.outlook.com [40.107.21.101]) by sourceware.org (Postfix) with ESMTPS id 2F62A3856DED for ; Wed, 10 May 2023 14:18:52 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 2F62A3856DED 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=bLNPuIre2p/8wrsqVnDPXUoo1bcxBPbWKN6sKzKQ5S2FXFlbPjopEaDvAW308S3FiKW5pe8SCJsDPiyl8VwaqbstdsbVlTOo9pB4OE6B34J602PyW1Qh0D4GiGeWo0L9yHej3oB6tUAK31PENjuX+Tl1yQnOThq6/Y8MzKqHds2HKGTOKDKabeTBjbFu4325fRRS8Oeu5QmTXHmsQyFIebxGUg9QMbTF2SNqB2n8Rb1dWIcJ2492+FRtnAfnLMB8GOTbIxI0sPQWbKLvujql9o7R+Tv9WK5oHaDI06qZ/zPP+7HYL3880YTaIoVH+aWSFMXBood47h8I8GAaEcnhAw== 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=0qN8a1uhqKrggQEh4+bNKhi+T6fC4L/nv8rzd+BwNh0=; b=khh/7x8D3VUxg2NTXOLCw9KvVY34x1HsvkuuWLtVuD70kZPjT1/Pbz1QaIcU5liEZJoxsnI3Atk6RRLJEutMFbufrZ6rguRSEMjQyOrc5zkRNJv/DqtTdTLoyJYECbFfLUDcXDyP/NM5LEk9wy1NDqFSsLUHE6hmVojbzvB3ZrjnScNZBBKK+sID9xEXkLEBz7N4/oIfpsWWPrSKDdylodjkjzvmKN9P1Btu52w6O48SzfwuP3Mg7/fOw0WVFWJ0Em1QUKgXIb4vMCCNg1BiAIzwaq0NTLtzaWJN08jmIld3EhluslyzqDVwN4yqG9r012zU4IJxcXgV0NcOlXYbyg== 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=0qN8a1uhqKrggQEh4+bNKhi+T6fC4L/nv8rzd+BwNh0=; b=u491obUYRBTe9WeXNMuhQySJq9jiRYexMfmbRdtdKuBBbltp8QtyY217VFZTPw715WXYdEvrd9HCL0Iq/y8RIs3IQRPW3Ni0hPRs1hnsyDu4JhI/aHGOvuBPE1t2vONmfBzCHCi7M0VjkuaO82jpCSXiDFOJkfjbkAaHNUJbKz8= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=syrmia.com; Received: from VI1PR0302MB3486.eurprd03.prod.outlook.com (2603:10a6:803:1e::32) by DB9PR03MB9784.eurprd03.prod.outlook.com (2603:10a6:10:456::15) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6363.31; Wed, 10 May 2023 14:18:48 +0000 Received: from VI1PR0302MB3486.eurprd03.prod.outlook.com ([fe80::82b5:25de:e5b:9914]) by VI1PR0302MB3486.eurprd03.prod.outlook.com ([fe80::82b5:25de:e5b:9914%4]) with mapi id 15.20.6387.018; Wed, 10 May 2023 14:18:48 +0000 From: Aleksandar Rikalo To: binutils@sourceware.org Cc: nickc@redhat.com, macro@orcam.me.uk, dragan.mladjenovic@syrmia.com, lei.wang@oss.cipunited.com Subject: [PATCH v6 3/3] Readelf for nanoMIPS Date: Wed, 10 May 2023 16:18:29 +0200 Message-Id: <20230510141829.2748105-4-aleksandar.rikalo@syrmia.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230510141829.2748105-1-aleksandar.rikalo@syrmia.com> References: <20230510141829.2748105-1-aleksandar.rikalo@syrmia.com> Content-Transfer-Encoding: 8bit Content-Type: text/plain X-ClientProxiedBy: VI1PR0501CA0030.eurprd05.prod.outlook.com (2603:10a6:800:60::16) To VI1PR0302MB3486.eurprd03.prod.outlook.com (2603:10a6:803:1e::32) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: VI1PR0302MB3486:EE_|DB9PR03MB9784:EE_ X-MS-Office365-Filtering-Correlation-Id: a492249c-961a-4fdd-10a6-08db51617866 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: iJiu3Fa7zh7W4J1z3cz/w8RLlm6Xer1sFkB8lqBXy7wRo7Ekd7C8c4C3zUDgzoZLdVcDRe+KLMCg7ZNGMyZEBfTVd6h+zPF/tf4VAqgPQ3yH5CC83pUk/btTKz7SyajaKm2ZQWLAUDo/dzclZNX6rF+rRTSk6ClMw7ygyronEBuSjoNPEt+W7ncYgCq+RLWn8vaUl1HlswzcqW5AK6uyFCg30pUhgklSxeiwBNZgQHpfppXpxc0JCZlIglTUYvTUkxF5Wirbn7BuDYqIIVM5/opHPryJLpiESTOqJYsESyrrco98cG9bq8tQ4HavZh8dYFH4Fh1RByB6Ev15gHBhQ8PwtSkkwpt60eLQdFVQhyfO/cNLeLSuXGSQC+JxOtWXbOLrhmVByAs+y4XBzqM4I1Ick1QLfuKfUIx3vicUdnHbz84PqxrFJIKjgUxK885eIav9Cg1P0N9Kq0gWYr3vjc9yod6W8nhakKanzC/ZbaWPGf+UO/oW5DdlF7PkzE2BlAjuxJ/IqZl8dTGsnmrNeuGolpZr3uhI2z7IhkoGu30EX87jKk3qOm4RxxCq4ArlP0gIaVMKv5y37UHC4VzmcRo7sTeEl/agyqTEOYU/yapVuUOoTREyIXs0vSV1MfSHnGvFvA+GEgRDbm6pCjUEfA== X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:VI1PR0302MB3486.eurprd03.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230028)(39840400004)(396003)(366004)(346002)(376002)(136003)(451199021)(8676002)(36756003)(66556008)(83380400001)(38350700002)(44832011)(2906002)(38100700002)(30864003)(316002)(86362001)(66946007)(6916009)(66476007)(41300700001)(4326008)(5660300002)(8936002)(52116002)(6506007)(26005)(186003)(6512007)(1076003)(2616005)(6666004)(478600001)(19627235002)(6486002)(21314003);DIR:OUT;SFP:1102; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?us-ascii?Q?8uTv8T96X1JRVJyR1IgdXlmeV/lHX2f11y5svObG5ZwGKSC+kvlMXgjvet4h?= =?us-ascii?Q?sVN/XzIsuqHifuSM46B/mdz0Rh9mHKvHx+o2C7+yANI6m0QU4mh5pFys0flx?= =?us-ascii?Q?Iwthv32tbFCcoY7MMHBIx4nBWEeXtyScRUPp1nGD54haFCHHFCTy2mKOIvUx?= =?us-ascii?Q?MYQjEXB2DfffOvCPC5AU8Iw5mBHBWDHksDoeb/wZkyRx2PaQ/rZcBFqY7a25?= =?us-ascii?Q?28VUAbXyfVxyfzE99gi+B15rt7Sl2dlDeOjladK1QGiUg+3dofs3/LMhgcWh?= =?us-ascii?Q?imWNLCxvz9XDgootbM90GSCREgfg2zAV9c1EttMh37Vh3Dr3ztnYyK2raZWt?= =?us-ascii?Q?ZJygCrPuZfnSBladvtyPfoAr7xlnDT91NjPexVUDM0zDpGnBB3AwfJPoMFfs?= =?us-ascii?Q?knLGQ02/IxbA/1yFlJKcqpwaiy0ynblaHUxTtnjg7wdrwxgwpKVZQux6K4DW?= =?us-ascii?Q?4dDqNx/R0SB5SW+DiQZU+xWjIabKnmCveFpK9Prl3uXPXLJ20/6h8xWovZTQ?= =?us-ascii?Q?yDEN1VQI98jyaEIarkB/fYtYev31EWVaSzZF2yoAuKD3DWgpyZgPBy4gSu99?= =?us-ascii?Q?wWzy7TOXoBZjH0hqij0F6nF1sWcfemTiG+tVyHV1v0WXFSBluFkRIh3GhtOM?= =?us-ascii?Q?1xanpHoQ7RdMbk3/HhDAMGyAe/Icl5cyvTOORM6yi6gPcpLjQPBREX5Gz0r0?= =?us-ascii?Q?cXCpfLLcmAIaBDn1UNkM8bmYqRZ26W5AqlpTp7sdVHiokboUq8fEljNFY40l?= =?us-ascii?Q?kjgkNEZB5+NHuDUFVP9ZlGw44T7UQxbNfZU5VUmUAwGdbVmwaFCiH7VNcHN6?= =?us-ascii?Q?NXnLkiGqRj6hlKKXGepj3Qvj3nNmV/pfGWypOdJIeN5GeNXBWLAzFHkQ1ctt?= =?us-ascii?Q?c46ArglhjK6ksRThhhTQ5xARfKeYNFWUPDDHDr+4Mn8eWUXXpGRyqUFzzog6?= =?us-ascii?Q?KC86NJYN6f+YlDyj1nJRkgQCl4ltgYNMboftAeGqpPSaLBQYu0h77DZmOlav?= =?us-ascii?Q?rg7XQfu+UqaKNOX0QB0I72DCPnvnEVIcJi9ghqfKvopYSxP7l+7V4LTJV8sI?= =?us-ascii?Q?EI+O0Kgszt1iFOZ40EaFAlJrUucpjExnnseMuH6oks+hhPDWEMLVKld2bIHv?= =?us-ascii?Q?gbuCGlVQ/ea8asoA7002muBsCvakmKVF00F3cmk7YopV8rzlTQXzSM+kFiEa?= =?us-ascii?Q?Lk8zJ00TsGj6R+25geULihZT03LBJXeDrdhEyKno+xbUHGzAzL7KPbGX+t4e?= =?us-ascii?Q?j5N3Vdozkcnge2c0zhu7AKaA+kNFhjTinSpF+onwYJL8l4L72BOgeo6a1KIh?= =?us-ascii?Q?Ja73doF26Jq+SkIAA/10p82kEBtVPjUFOVpVlFWbtOjlnd3OauEfx0NXFXrb?= =?us-ascii?Q?tJZrm3rMYn+IxU/wL4hdiR71XyBFiRKDfkm6xuoRm8ebrnZj9Ig58aFCn9ly?= =?us-ascii?Q?6K4owCQUGbqYl04HHa8xtYJ/VsMuQzRLcdK17078x8rDSGW8vn7uGz8GoOYl?= =?us-ascii?Q?tPf74c71kamqmhwpF/k+3Sp+BdMxNJ6CiNSYEC9AgYEnmUioAs0b5zLqsmVr?= =?us-ascii?Q?W3YjAHpzEYcp9XkiTf/8v+jhuluESd8Voh12vPHS8flMuKpXkf6smcKD6xPs?= =?us-ascii?Q?gQ=3D=3D?= X-OriginatorOrg: syrmia.com X-MS-Exchange-CrossTenant-Network-Message-Id: a492249c-961a-4fdd-10a6-08db51617866 X-MS-Exchange-CrossTenant-AuthSource: VI1PR0302MB3486.eurprd03.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 10 May 2023 14:18:47.8015 (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: fEMQC8BZhlrNsAQUuMg8j2TK126rLOEMLek4tZuj8o1fj70TqzLrG0V2RJ+uUItQsevg9dtpK+A71xKoOeWuWLtUZFUCSo3wPwhICH1meM4= X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB9PR03MB9784 X-Spam-Status: No, score=-12.3 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,T_SCC_BODY_TEXT_LINE 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: Co-Authored-By: Jaydeep Patil Co-Authored-By: Matthew Fortune Co-Authored-By: Maciej W. Rozycki Co-Authored-By: Stefan Markovic Co-Authored-By: Sara Graovac Co-Authored-By: Dragan Mladjenovic --- binutils/readelf.c | 500 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 500 insertions(+) diff --git a/binutils/readelf.c b/binutils/readelf.c index 140337d7bec..20ecbb67b35 100644 --- a/binutils/readelf.c +++ b/binutils/readelf.c @@ -139,6 +139,7 @@ #include "elf/moxie.h" #include "elf/mt.h" #include "elf/msp430.h" +#include "elf/nanomips.h" #include "elf/nds32.h" #include "elf/nfp.h" #include "elf/nios2.h" @@ -1097,6 +1098,7 @@ guess_is_rela (unsigned int e_machine) case EM_MSP430: case EM_MSP430_OLD: case EM_MT: + case EM_NANOMIPS: case EM_NDS32: case EM_NIOS32: case EM_OR1K: @@ -1894,6 +1896,10 @@ dump_relocations (Filedata *filedata, rtype = elf_nios2_reloc_type (type); break; + case EM_NANOMIPS: + rtype = elf_nanomips_reloc_type (type); + break; + case EM_TI_PRU: rtype = elf_pru_reloc_type (type); break; @@ -2205,6 +2211,16 @@ get_mips_dynamic_type (unsigned long type) } } +static const char * +get_nanomips_dynamic_type (unsigned long type) +{ + switch (type) + { + default: + return NULL; + } +} + static const char * get_sparc64_dynamic_type (unsigned long type) { @@ -2571,6 +2587,9 @@ get_dynamic_type (Filedata * filedata, unsigned long type) case EM_RISCV: result = get_riscv_dynamic_type (type); break; + case EM_NANOMIPS: + result = get_nanomips_dynamic_type (type); + break; default: if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS) result = get_solaris_dynamic_type (type); @@ -4393,6 +4412,38 @@ get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine) strcat (buf, ", OBJ-v1"); break; + case EM_NANOMIPS: + if (e_flags & EF_NANOMIPS_PIC) + strcat (buf, ", pic"); + + if (e_flags & EF_NANOMIPS_32BITMODE) + strcat (buf, ", 32bitmode"); + + switch ((e_flags & EF_NANOMIPS_MACH)) + { + default: strcat (buf, _(", unknown CPU")); break; + } + + switch ((e_flags & EF_NANOMIPS_ABI)) + { + case E_NANOMIPS_ABI_P32: strcat (buf, ", p32"); break; + case E_NANOMIPS_ABI_P64: strcat (buf, ", p64"); break; + case 0: + /* We simply ignore the field in this case to avoid confusion: + MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension. + This means it is likely to be an o32 file, but not for + sure. */ + break; + default: strcat (buf, _(", unknown ABI")); break; + } + + switch ((e_flags & EF_NANOMIPS_ARCH)) + { + case E_NANOMIPS_ARCH_32R6: strcat (buf, ", nanomips32r6"); break; + case E_NANOMIPS_ARCH_64R6: strcat (buf, ", nanomips64r6"); break; + default: strcat (buf, _(", unknown ISA")); break; + } + break; } } @@ -4521,6 +4572,20 @@ get_mips_segment_type (unsigned long type) } } +static const char * +get_nanomips_segment_type (unsigned long type) +{ + switch (type) + { + case PT_NANOMIPS_ABIFLAGS: + return "ABIFLAGS"; + default: + break; + } + + return NULL; +} + static const char * get_parisc_segment_type (unsigned long type) { @@ -4675,6 +4740,9 @@ get_segment_type (Filedata * filedata, unsigned long p_type) case EM_S390_OLD: result = get_s390_segment_type (p_type); break; + case EM_NANOMIPS: + result = get_nanomips_segment_type (p_type); + break; case EM_RISCV: result = get_riscv_segment_type (p_type); break; @@ -10725,6 +10793,17 @@ dynamic_section_mips_val (Filedata * filedata, Elf_Internal_Dyn * entry) putchar ('\n'); } +static void +dynamic_section_nanomips_val (Elf_Internal_Dyn * entry) +{ + switch (entry->d_tag) + { + default: + print_vma (entry->d_un.d_ptr, PREFIX_HEX); + } + putchar ('\n'); +} + static void dynamic_section_parisc_val (Elf_Internal_Dyn * entry) { @@ -12065,6 +12144,9 @@ the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n")); case EM_IA_64: dynamic_section_ia64_val (entry); break; + case EM_NANOMIPS: + dynamic_section_nanomips_val (entry); + break; default: print_vma (entry->d_un.d_val, PREFIX_HEX); putchar ('\n'); @@ -14357,6 +14439,8 @@ is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type) return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */ case EM_MT: return reloc_type == 2; /* R_MT_32. */ + case EM_NANOMIPS: + return reloc_type == 1; /* R_NANOMIPS_32. */ case EM_NDS32: return reloc_type == 20; /* R_NDS32_32_RELA. */ case EM_ALTERA_NIOS2: @@ -14561,6 +14645,8 @@ is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type) return reloc_type == 1; /* R_TILEGX_64. */ case EM_MIPS: return reloc_type == 18; /* R_MIPS_64. */ + case EM_NANOMIPS: + return reloc_type == 2; /* R_NANOMIPS_64. */ default: return false; } @@ -14668,6 +14754,8 @@ is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type) /* Fall through. */ case EM_MSP430_OLD: return reloc_type == 5; /* R_MSP430_16_BYTE. */ + case EM_NANOMIPS: + return reloc_type == 7; /* R_NANOMIPS_UNSIGNED_16 */ case EM_NDS32: return reloc_type == 19; /* R_NDS32_16_RELA. */ case EM_ALTERA_NIOS2: @@ -14896,6 +14984,7 @@ is_none_reloc (Filedata * filedata, unsigned int reloc_type) case EM_MOXIE: /* R_MOXIE_NONE. */ case EM_NIOS32: /* R_NIOS_NONE. */ case EM_OR1K: /* R_OR1K_NONE. */ + case EM_NANOMIPS: /* R_NANOMIPS_NONE. */ case EM_PARISC: /* R_PARISC_NONE. */ case EM_PPC64: /* R_PPC64_NONE. */ case EM_PPC: /* R_PPC_NONE. */ @@ -17480,6 +17569,71 @@ display_mips_gnu_attribute (unsigned char * p, return display_tag_value (tag & 1, p, end); } +static void +print_nanomips_fp_abi_value (int val) +{ + switch (val) + { + case Val_GNU_NANOMIPS_ABI_FP_ANY: + printf (_("Hard or soft float\n")); + break; + case Val_GNU_NANOMIPS_ABI_FP_DOUBLE: + printf (_("Hard float (double precision)\n")); + break; + case Val_GNU_NANOMIPS_ABI_FP_SINGLE: + printf (_("Hard float (single precision)\n")); + break; + case Val_GNU_NANOMIPS_ABI_FP_SOFT: + printf (_("Soft float\n")); + break; + default: + printf ("??? (%d)\n", val); + break; + } +} + +static unsigned char * +display_nanomips_gnu_attribute (unsigned char * p, + unsigned int tag, + const unsigned char * const end) +{ + if (tag == Tag_GNU_NANOMIPS_ABI_FP) + { + uint64_t val; + + READ_ULEB (val, p, end); + printf (" Tag_GNU_NANOMIPS_ABI_FP: "); + + print_nanomips_fp_abi_value (val); + + return p; + } + + if (tag == Tag_GNU_NANOMIPS_ABI_MSA) + { + uint64_t val; + + READ_ULEB (val, p, end); + printf (" Tag_GNU_NANOMIPS_ABI_MSA: "); + + switch (val) + { + case Val_GNU_NANOMIPS_ABI_MSA_ANY: + printf (_("Any MSA or not\n")); + break; + case Val_GNU_NANOMIPS_ABI_MSA_128: + printf (_("128-bit MSA\n")); + break; + default: + printf ("??? (%lu)\n", val); + break; + } + return p; + } + + return display_tag_value (tag & 1, p, end); +} + static unsigned char * display_tic6x_attribute (unsigned char * p, const unsigned char * const end) @@ -19317,6 +19471,350 @@ process_mips_specific (Filedata * filedata) return res; } +static void +print_nanomips_ases (unsigned int mask) +{ + if (mask & NANOMIPS_ASE_DSPR3) + fputs ("\n\tDSP R3 ASE", stdout); + if (mask & NANOMIPS_ASE_EVA) + fputs ("\n\tEnhanced VA Scheme", stdout); + if (mask & NANOMIPS_ASE_MCU) + fputs ("\n\tMCU (MicroController) ASE", stdout); + if (mask & NANOMIPS_ASE_MT) + fputs ("\n\tMT ASE", stdout); + if (mask & NANOMIPS_ASE_VIRT) + fputs ("\n\tVZ ASE", stdout); + if (mask & NANOMIPS_ASE_MSA) + fputs ("\n\tMSA ASE", stdout); + if (mask & NANOMIPS_ASE_TLB) + fputs ("\n\tTLB ASE", stdout); + if (mask & NANOMIPS_ASE_GINV) + fputs ("\n\tGINV ASE", stdout); + if ((mask & NANOMIPS_ASE_xNMS) == 0) + fputs ("\n\tnanoMIPS subset", stdout); + else if (mask == 0) + fprintf (stdout, "\n\t%s", _("None")); + else if ((mask & ~NANOMIPS_ASE_MASK) != 0) + fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~NANOMIPS_ASE_MASK); +} + +static void +print_nanomips_isa_ext (unsigned int isa_ext) +{ + switch (isa_ext) + { + case 0: + fputs (_("None"), stdout); + break; + default: + fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext); + } +} + +static int +get_nanomips_reg_size (int reg_size) +{ + return (get_mips_reg_size (reg_size)); +} + +static bool +process_nanomips_specific (Filedata * filedata) +{ + Elf_Internal_Dyn * entry; + Elf_Internal_Shdr *sect = NULL; + size_t options_offset = 0; + bfd_vma pltgot = 0; + bfd_vma gotsym = 0; + bfd_vma symtabno = 0; + + process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL, + display_nanomips_gnu_attribute); + + sect = find_section (filedata, ".nanoMIPS.abiflags"); + + if (sect != NULL) + { + Elf_External_ABIFlags_v0 *abiflags_ext; + Elf_Internal_ABIFlags_v0 abiflags_in; + + if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size) + fputs ("\nCorrupt ABI Flags section.\n", stdout); + else + { + abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1, + sect->sh_size, _("nanoMIPS ABI Flags section")); + if (abiflags_ext) + { + abiflags_in.version = BYTE_GET (abiflags_ext->version); + abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level); + abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev); + abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size); + abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size); + abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size); + abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi); + abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext); + abiflags_in.ases = BYTE_GET (abiflags_ext->ases); + abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1); + abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2); + + printf ("\nnanoMIPS ABI Flags Version: %d\n", abiflags_in.version); + printf ("\nISA: nanoMIPS%d", abiflags_in.isa_level); + if (abiflags_in.isa_rev > 1) + printf ("r%d", abiflags_in.isa_rev); + printf ("\nGPR size: %d", + get_nanomips_reg_size (abiflags_in.gpr_size)); + printf ("\nCPR1 size: %d", + get_nanomips_reg_size (abiflags_in.cpr1_size)); + printf ("\nCPR2 size: %d", + get_nanomips_reg_size (abiflags_in.cpr2_size)); + fputs ("\nFP ABI: ", stdout); + print_nanomips_fp_abi_value (abiflags_in.fp_abi); + fputs ("ISA Extension: ", stdout); + print_nanomips_isa_ext (abiflags_in.isa_ext); + fputs ("\nASEs:", stdout); + print_nanomips_ases (abiflags_in.ases); + printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1); + printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2); + fputc ('\n', stdout); + free (abiflags_ext); + } + } + } + + if (!get_dynamic_section (filedata)) + return false; + + for (entry = filedata->dynamic_section; + entry < filedata->dynamic_section + filedata->dynamic_nent && entry->d_tag != DT_NULL; + ++entry) + switch (entry->d_tag) + { + case DT_PLTGOT: + pltgot = entry->d_un.d_ptr; + break; + default: + break; + } + + if (options_offset != 0) + { + Elf_External_Options * eopt; + Elf_Internal_Options * iopt; + Elf_Internal_Options * option; + size_t offset; + int cnt; + sect = filedata->section_headers; + + /* Find the section header so that we get the size. */ + sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS); + if (sect == NULL) + { + error (_("No MIPS_OPTIONS header found\n")); + return 0; + } + + eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1, + sect->sh_size, _("options")); + if (eopt) + { + iopt = (Elf_Internal_Options *) + cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt)); + if (iopt == NULL) + { + error (_("Out of memory allocatinf space for MIPS options\n")); + return 0; + } + + offset = cnt = 0; + option = iopt; + + while (offset < sect->sh_size) + { + Elf_External_Options * eoption; + eoption = (Elf_External_Options *) ((char *) eopt + offset); + + option->kind = BYTE_GET (eoption->kind); + option->size = BYTE_GET (eoption->size); + option->section = BYTE_GET (eoption->section); + option->info = BYTE_GET (eoption->info); + + offset += option->size; + + ++option; + ++cnt; + } + + printf (_("\nSection '%s' contains %d entries:\n"), + printable_section_name (filedata, sect), cnt); + + option = iopt; + + while (cnt-- > 0) + { + size_t len; + + switch (option->kind) + { + case ODK_NULL: + /* This shouldn't happen. */ + printf (" NULL %d %x", option->section, option->info); + break; + case ODK_EXCEPTIONS: + fputs (" EXCEPTIONS fpe_min(", stdout); + process_mips_fpe_exception (option->info & OEX_FPU_MIN); + fputs (") fpe_max(", stdout); + process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8); + fputs (")", stdout); + + if (option->info & OEX_PAGE0) + fputs (" PAGE0", stdout); + if (option->info & OEX_SMM) + fputs (" SMM", stdout); + if (option->info & OEX_FPDBUG) + fputs (" FPDBUG", stdout); + if (option->info & OEX_DISMISS) + fputs (" DISMISS", stdout); + break; + case ODK_PAD: + fputs (" PAD ", stdout); + if (option->info & OPAD_PREFIX) + fputs (" PREFIX", stdout); + if (option->info & OPAD_POSTFIX) + fputs (" POSTFIX", stdout); + if (option->info & OPAD_SYMBOL) + fputs (" SYMBOL", stdout); + break; + case ODK_HWPATCH: + fputs (" HWPATCH ", stdout); + if (option->info & OHW_R4KEOP) + fputs (" R4KEOP", stdout); + if (option->info & OHW_R8KPFETCH) + fputs (" R8KPFETCH", stdout); + if (option->info & OHW_R5KEOP) + fputs (" R5KEOP", stdout); + if (option->info & OHW_R5KCVTL) + fputs (" R5KCVTL", stdout); + break; + case ODK_FILL: + fputs (" FILL ", stdout); + /* XXX Print content of info word? */ + break; + case ODK_TAGS: + fputs (" TAGS ", stdout); + /* XXX Print content of info word? */ + break; + case ODK_HWAND: + fputs (" HWAND ", stdout); + if (option->info & OHWA0_R4KEOP_CHECKED) + fputs (" R4KEOP_CHECKED", stdout); + if (option->info & OHWA0_R4KEOP_CLEAN) + fputs (" R4KEOP_CLEAN", stdout); + break; + case ODK_HWOR: + fputs (" HWOR ", stdout); + if (option->info & OHWA0_R4KEOP_CHECKED) + fputs (" R4KEOP_CHECKED", stdout); + if (option->info & OHWA0_R4KEOP_CLEAN) + fputs (" R4KEOP_CLEAN", stdout); + break; + case ODK_GP_GROUP: + printf (" GP_GROUP %#06x self-contained %#06x", + option->info & OGP_GROUP, + (option->info & OGP_SELF) >> 16); + break; + case ODK_IDENT: + printf (" IDENT %#06x self-contained %#06x", + option->info & OGP_GROUP, + (option->info & OGP_SELF) >> 16); + break; + default: + /* This shouldn't happen. */ + printf (" %3d ??? %d %x", + option->kind, option->section, option->info); + break; + } + len = sizeof (* eopt); + while (len < option->size) + if (((char *) option)[len] >= ' ' + && ((char *) option)[len] < 0x7f) + printf ("%c", ((char *) option)[len++]); + else + printf ("\\%03o", ((char *) option)[len++]); + + fputs ("\n", stdout); + ++option; + } + free (eopt); + } + } + + if (pltgot != 0) + { + bfd_vma ent, end; + size_t i, offset; + unsigned char * data; + int addr_size; + + ent = pltgot; + addr_size = (is_32bit_elf ? 4 : 8); + + if (symtabno < gotsym) + { + error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"), + (long) gotsym, (long) symtabno); + return 0; + } + + end = pltgot + (symtabno - gotsym) * addr_size; + offset = offset_from_vma (filedata, pltgot, end - pltgot); + data = (unsigned char *) get_data (NULL, filedata, offset, + end - pltgot, 1, + _("Global Offset Table data")); + if (data == NULL) + return 0; + + printf (_(" Canonical gp value: ")); + print_vma (pltgot + 0x7ff0, LONG_HEX); + printf ("\n\n"); + + printf (_(" Reserved entries:\n")); + printf (_(" %*s %10s %*s Purpose\n"), + addr_size * 2, _("Address"), _("Access"), + addr_size * 2, _("Initial")); + ent = print_mips_got_entry (data, pltgot, ent, data + (end - pltgot)); + printf (_(" Lazy resolver\n")); + if (data + && (byte_get (data + ent - pltgot, addr_size) + >> (addr_size * 8 - 1)) != 0) + { + ent = print_mips_got_entry (data, pltgot, ent, data + (end - pltgot)); + printf (_(" Module pointer (GNU extension)\n")); + } + printf ("\n\n"); + printf (_(" Entries:\n")); + printf (" %*s %10s %*s %*s %-7s %3s %s\n", + addr_size * 2, _("Address"), + _("Access"), + addr_size * 2, _("Initial"), + addr_size * 2, _("Sym.Val."), + _("Type"), + /* Note for translators: "Ndx" = abbreviated form of "Index". */ + _("Ndx"), _("Name")); + + for (i = gotsym; i < symtabno; i++) + { + ent = print_mips_got_entry (data, pltgot, ent, data + (end - pltgot)); + printf (" "); + printf ("\n"); + } + + if (data) + free (data); + } + + return 1; +} + static bool process_nds32_specific (Filedata * filedata) { @@ -22264,6 +22762,8 @@ process_arch_specific (Filedata * filedata) return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES, display_tic6x_attribute, display_generic_attribute); + case EM_NANOMIPS: + return process_nanomips_specific (filedata); case EM_CSKY: return process_attributes (filedata, "csky", SHT_CSKY_ATTRIBUTES, -- 2.25.1