From patchwork Thu Aug 3 11:48:17 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alan Modra X-Patchwork-Id: 130521 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:9f41:0:b0:3e4:2afc:c1 with SMTP id v1csp1090386vqx; Thu, 3 Aug 2023 04:50:52 -0700 (PDT) X-Google-Smtp-Source: APBJJlE5scl6KzEwLwG0s//QBlHwkLfGSp41xT8waancyhkMUhjtwsT+NLHPRi66Lz2wipd0BDfS X-Received: by 2002:a17:907:6e04:b0:99c:10b5:7650 with SMTP id sd4-20020a1709076e0400b0099c10b57650mr11038680ejc.1.1691063451893; Thu, 03 Aug 2023 04:50:51 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1691063451; cv=none; d=google.com; s=arc-20160816; b=xRokS8K0IYMHyC6yjA41B86Y5sj9oFfIuwOaVJXeA2OKMg5IIqw8lhuGhV/VBZJqjE Dsa5tYHbXZDMiuKEeDj8NMHALa18VPSEqhJLTdJXsD9f5LJmNCjBiHcNxYbh+7jtj+S9 fR3hyznC72JgANBU/GqY4r87s6AcvbYm9xsmC0raQdBxZkfS4YH47tycPXEnqRnL18hW 2lYxM836JRFwdjTZ/2g9VQFkEzBbxePyg3EPZOIfn3BNiNnWduFce3Tc5C2h2wUp65Oc ArHhGKluXhiBCI/b+SuW4i/XSuAK8yWSozEwq+m+2kYtYmKmU5u0GedyIC0tfCVEE44u 4QMA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-disposition:mime-version:message-id:subject:to:date :dmarc-filter:delivered-to:dkim-signature:dkim-filter; bh=v1s3wmK33YtxwHd+mO79VbBPzAEO6tiz+tFLvh4zl4I=; fh=HNIqzTA9Dp00ovCAyCdXfuEvWDT00OlFxFRPLybXRis=; b=Fnr4j5bCIbusCBeb4DqdsR1Y4djZLoux2DdTwpBKy46v9qBdXH/E7haVUqjB+Yrig+ oWeY2fSs55u2NzEGvMnAPgVe7TnxOLjKiR47ftsd1VOPoDImf+3/s8gDKU6w9E82Pv3d MYa5gZY+exiG7cVHqIlwtuqxNB7mR6cfO5ms7hooV6IjNjeK+Ec37NCVOSgyszuVbUDK hCu8tVLRsbL5xWZmLOZmozijiQ7FPr8YBTDSdAq8xaKeVw9jAmqotN2YmUKRU8CgIckG QGGCVyUQGu1cY3grsprpuvSeivW1ajXqZFOw8C5cbLydj0bM8ePDnGa0X1tXS4CbImYR IGTQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=nasdPoV6; spf=pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="binutils-bounces+ouuuleilei=gmail.com@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=sourceware.org Received: from server2.sourceware.org (ip-8-43-85-97.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id kk20-20020a170907767400b00987dc76f82fsi7408001ejc.285.2023.08.03.04.50.51 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 03 Aug 2023 04:50:51 -0700 (PDT) Received-SPF: pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 8.43.85.97 as permitted sender) client-ip=8.43.85.97; Authentication-Results: mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=nasdPoV6; spf=pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="binutils-bounces+ouuuleilei=gmail.com@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 4CB483854831 for ; Thu, 3 Aug 2023 11:48:36 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 4CB483854831 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1691063316; bh=v1s3wmK33YtxwHd+mO79VbBPzAEO6tiz+tFLvh4zl4I=; h=Date:To:Subject:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=nasdPoV6B7MvP3JtYdK6eaBArgEoQofPYxcIC6OXmTHh6JH5a4trQvpkxKOtgojCi af0GhCMCxHmKoH8l7n62gSSslDG1X0/glsgIWjHb3oCU+rz60ZBnUvy0sjX+XGyc+G K3rEtS0yVDOHIP1PUyP4ga3hirkBY77ioNq/KlJk= X-Original-To: binutils@sourceware.org Delivered-To: binutils@sourceware.org Received: from mail-pf1-x431.google.com (mail-pf1-x431.google.com [IPv6:2607:f8b0:4864:20::431]) by sourceware.org (Postfix) with ESMTPS id A421B385C8B0 for ; Thu, 3 Aug 2023 11:48:22 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org A421B385C8B0 Received: by mail-pf1-x431.google.com with SMTP id d2e1a72fcca58-686c06b806cso552168b3a.2 for ; Thu, 03 Aug 2023 04:48:22 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1691063301; x=1691668101; h=content-disposition:mime-version:message-id:subject:to:from:date :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=v1s3wmK33YtxwHd+mO79VbBPzAEO6tiz+tFLvh4zl4I=; b=jFRD4bfUkQNzexvb0O6jSILGUdeQxietcztQmVIWCCR2WZ9j7bjeipEalSvwq+5ZnN pwBS3RbO3J2GmFI5Y4AhmbeVGDdX73SYBoplRnYzlZatHs5OIsb/3qYRWuDAZeVZmzDq OZc2FP4DWhWAkX6Ks8PjOHCxHZxCqxGAVsQKxImZOLlYbyJgEz9aiZvKRsbf3+qIwNpv SmfTvQs3338VgBQq1/q8CjpK+9zhv6Kpp5IhRl0fOnzeKyjm8fSaJfTOR+s7h8m3jJUa 8Me7TSTZkvoFeksQlOEyrZGMtS2LzSxZKD+LyJQ1e9MhQPhBS+wOfJ8CGwxPWYpvHSHk /xUA== X-Gm-Message-State: ABy/qLbcwTp8/5l3T4UYwkLa8M3c/I0KdVgrtHBOOFTlvofSiCn9uNIF F5wZ1TXpVApyrA9af/0cDkleFqOXTT8= X-Received: by 2002:a05:6a00:134c:b0:686:2b60:3348 with SMTP id k12-20020a056a00134c00b006862b603348mr21320534pfu.21.1691063300131; Thu, 03 Aug 2023 04:48:20 -0700 (PDT) Received: from squeak.grove.modra.org (158.106.96.58.static.exetel.com.au. [58.96.106.158]) by smtp.gmail.com with ESMTPSA id g26-20020a62e31a000000b00666b3706be6sm12540163pfh.107.2023.08.03.04.48.18 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 03 Aug 2023 04:48:19 -0700 (PDT) Received: by squeak.grove.modra.org (Postfix, from userid 1000) id 2762811415EF; Thu, 3 Aug 2023 21:18:17 +0930 (ACST) Date: Thu, 3 Aug 2023 21:18:17 +0930 To: binutils@sourceware.org Subject: readelf sprintf optimisation Message-ID: MIME-Version: 1.0 Content-Disposition: inline X-Spam-Status: No, score=-3034.4 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, 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 X-BeenThere: binutils@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Binutils mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Alan Modra via Binutils From: Alan Modra Reply-To: Alan Modra Errors-To: binutils-bounces+ouuuleilei=gmail.com@sourceware.org Sender: "Binutils" X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1773208550099555071 X-GMAIL-MSGID: 1773208550099555071 This replaces sprintf and strcat calls with stpcpy, and makes use of sprintf return value rather than using strlen, for get_machine_flags. decode_NDS32_machine_flags made use of snprintf, which is arguably the "correct" way to do things if there can be a buffer overflow. In this case I don't think there can be, the buffer is 1k in size which is at least 5 times more than needed. What's more, snprintf returns the count of chars that would be output given no buffer limit, which means code like r += snprintf (buf + r, size - r, ...); r += snprintf (buf + r, size - r, ...); is just wrong. There needs to be a check on the return value in order to prevent buf + r being out of bounds for the second snprintf call. BTW, if you look closely you'll see the return value of the decode functions is unused. I admit to getting a little carried away with writing "out = stpcpy (out, ...):" in each of the decode functions and didn't notice that until get_machine_flags was trimmed down to a much smaller size. When I did notice, I decided it's not such a bad thing. * readelf.c (decode_ARC_machine_flags, decode_ARM_machine_flags), (decode_AVR_machine_flags, decode_NDS32_machine_flags), (decode_AMDGPU_machine_flags): Use stpcpy and sprintf return value. Return end of string. (decode_BLACKFIN_machine_flags, decode_FRV_machine_flags), (decode_IA64_machine_flags, decode_LOONGARCH_machine_flags), (decode_M68K_machine_flags, decode_MeP_machine_flags), (decode_MIPS_machine_flags, decode_MSP430_machine_flags), (decode_PARISC_machine_flags, decode_RISCV_machine_flags), (decode_RL78_machine_flags, decode_RX_machine_flags), (decode_SH_machine_flags, decode_SPARC_machine_flags), (decode_V800_machine_flags, decode_V850_machine_flags), (decode_Z80_machine_flags): New functions, split out from.. (get_machine_flags): ..here. Similarly use stpcpy. diff --git a/binutils/readelf.c b/binutils/readelf.c index 4ecff4c3933..bd112ff53a6 100644 --- a/binutils/readelf.c +++ b/binutils/readelf.c @@ -3001,8 +3001,8 @@ get_machine_name (unsigned e_machine) } } -static void -decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[]) +static char * +decode_ARC_machine_flags (char *out, unsigned e_flags, unsigned e_machine) { /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some other compilers don't specify an architecture type in the e_flags, and @@ -3021,21 +3021,21 @@ decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[]) { /* We only expect these to occur for EM_ARC_COMPACT2. */ case EF_ARC_CPU_ARCV2EM: - strcat (buf, ", ARC EM"); + out = stpcpy (out, ", ARC EM"); break; case EF_ARC_CPU_ARCV2HS: - strcat (buf, ", ARC HS"); + out = stpcpy (out, ", ARC HS"); break; /* We only expect these to occur for EM_ARC_COMPACT. */ case E_ARC_MACH_ARC600: - strcat (buf, ", ARC600"); + out = stpcpy (out, ", ARC600"); break; case E_ARC_MACH_ARC601: - strcat (buf, ", ARC601"); + out = stpcpy (out, ", ARC601"); break; case E_ARC_MACH_ARC700: - strcat (buf, ", ARC700"); + out = stpcpy (out, ", ARC700"); break; /* The only times we should end up here are (a) A corrupt ELF, (b) A @@ -3044,35 +3044,36 @@ decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[]) set the architecture in the e_flags. */ default: if (e_machine == EM_ARC_COMPACT) - strcat (buf, ", Unknown ARCompact"); + out = stpcpy (out, ", Unknown ARCompact"); else - strcat (buf, ", Unknown ARC"); + out = stpcpy (out, ", Unknown ARC"); break; } switch (e_flags & EF_ARC_OSABI_MSK) { case E_ARC_OSABI_ORIG: - strcat (buf, ", (ABI:legacy)"); + out = stpcpy (out, ", (ABI:legacy)"); break; case E_ARC_OSABI_V2: - strcat (buf, ", (ABI:v2)"); + out = stpcpy (out, ", (ABI:v2)"); break; /* Only upstream 3.9+ kernels will support ARCv2 ISA. */ case E_ARC_OSABI_V3: - strcat (buf, ", v3 no-legacy-syscalls ABI"); + out = stpcpy (out, ", v3 no-legacy-syscalls ABI"); break; case E_ARC_OSABI_V4: - strcat (buf, ", v4 ABI"); + out = stpcpy (out, ", v4 ABI"); break; default: - strcat (buf, ", unrecognised ARC OSABI flag"); + out = stpcpy (out, ", unrecognised ARC OSABI flag"); break; } + return out; } -static void -decode_ARM_machine_flags (unsigned e_flags, char buf[]) +static char * +decode_ARM_machine_flags (char *out, unsigned e_flags) { unsigned eabi; bool unknown = false; @@ -3083,13 +3084,13 @@ decode_ARM_machine_flags (unsigned e_flags, char buf[]) /* Handle "generic" ARM flags. */ if (e_flags & EF_ARM_RELEXEC) { - strcat (buf, ", relocatable executable"); + out = stpcpy (out, ", relocatable executable"); e_flags &= ~ EF_ARM_RELEXEC; } if (e_flags & EF_ARM_PIC) { - strcat (buf, ", position independent"); + out = stpcpy (out, ", position independent"); e_flags &= ~ EF_ARM_PIC; } @@ -3097,13 +3098,13 @@ decode_ARM_machine_flags (unsigned e_flags, char buf[]) switch (eabi) { default: - strcat (buf, ", "); + out = stpcpy (out, ", "); if (e_flags) unknown = true; break; case EF_ARM_EABI_VER1: - strcat (buf, ", Version1 EABI"); + out = stpcpy (out, ", Version1 EABI"); while (e_flags) { unsigned flag; @@ -3115,7 +3116,7 @@ decode_ARM_machine_flags (unsigned e_flags, char buf[]) switch (flag) { case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */ - strcat (buf, ", sorted symbol tables"); + out = stpcpy (out, ", sorted symbol tables"); break; default: @@ -3126,7 +3127,7 @@ decode_ARM_machine_flags (unsigned e_flags, char buf[]) break; case EF_ARM_EABI_VER2: - strcat (buf, ", Version2 EABI"); + out = stpcpy (out, ", Version2 EABI"); while (e_flags) { unsigned flag; @@ -3138,15 +3139,15 @@ decode_ARM_machine_flags (unsigned e_flags, char buf[]) switch (flag) { case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */ - strcat (buf, ", sorted symbol tables"); + out = stpcpy (out, ", sorted symbol tables"); break; case EF_ARM_DYNSYMSUSESEGIDX: - strcat (buf, ", dynamic symbols use segment index"); + out = stpcpy (out, ", dynamic symbols use segment index"); break; case EF_ARM_MAPSYMSFIRST: - strcat (buf, ", mapping symbols precede others"); + out = stpcpy (out, ", mapping symbols precede others"); break; default: @@ -3157,11 +3158,11 @@ decode_ARM_machine_flags (unsigned e_flags, char buf[]) break; case EF_ARM_EABI_VER3: - strcat (buf, ", Version3 EABI"); + out = stpcpy (out, ", Version3 EABI"); break; case EF_ARM_EABI_VER4: - strcat (buf, ", Version4 EABI"); + out = stpcpy (out, ", Version4 EABI"); while (e_flags) { unsigned flag; @@ -3173,11 +3174,11 @@ decode_ARM_machine_flags (unsigned e_flags, char buf[]) switch (flag) { case EF_ARM_BE8: - strcat (buf, ", BE8"); + out = stpcpy (out, ", BE8"); break; case EF_ARM_LE8: - strcat (buf, ", LE8"); + out = stpcpy (out, ", LE8"); break; default: @@ -3188,7 +3189,7 @@ decode_ARM_machine_flags (unsigned e_flags, char buf[]) break; case EF_ARM_EABI_VER5: - strcat (buf, ", Version5 EABI"); + out = stpcpy (out, ", Version5 EABI"); while (e_flags) { unsigned flag; @@ -3200,19 +3201,19 @@ decode_ARM_machine_flags (unsigned e_flags, char buf[]) switch (flag) { case EF_ARM_BE8: - strcat (buf, ", BE8"); + out = stpcpy (out, ", BE8"); break; case EF_ARM_LE8: - strcat (buf, ", LE8"); + out = stpcpy (out, ", LE8"); break; case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */ - strcat (buf, ", soft-float ABI"); + out = stpcpy (out, ", soft-float ABI"); break; case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */ - strcat (buf, ", hard-float ABI"); + out = stpcpy (out, ", hard-float ABI"); break; default: @@ -3223,7 +3224,7 @@ decode_ARM_machine_flags (unsigned e_flags, char buf[]) break; case EF_ARM_EABI_UNKNOWN: - strcat (buf, ", GNU EABI"); + out = stpcpy (out, ", GNU EABI"); while (e_flags) { unsigned flag; @@ -3235,43 +3236,43 @@ decode_ARM_machine_flags (unsigned e_flags, char buf[]) switch (flag) { case EF_ARM_INTERWORK: - strcat (buf, ", interworking enabled"); + out = stpcpy (out, ", interworking enabled"); break; case EF_ARM_APCS_26: - strcat (buf, ", uses APCS/26"); + out = stpcpy (out, ", uses APCS/26"); break; case EF_ARM_APCS_FLOAT: - strcat (buf, ", uses APCS/float"); + out = stpcpy (out, ", uses APCS/float"); break; case EF_ARM_PIC: - strcat (buf, ", position independent"); + out = stpcpy (out, ", position independent"); break; case EF_ARM_ALIGN8: - strcat (buf, ", 8 bit structure alignment"); + out = stpcpy (out, ", 8 bit structure alignment"); break; case EF_ARM_NEW_ABI: - strcat (buf, ", uses new ABI"); + out = stpcpy (out, ", uses new ABI"); break; case EF_ARM_OLD_ABI: - strcat (buf, ", uses old ABI"); + out = stpcpy (out, ", uses old ABI"); break; case EF_ARM_SOFT_FLOAT: - strcat (buf, ", software FP"); + out = stpcpy (out, ", software FP"); break; case EF_ARM_VFP_FLOAT: - strcat (buf, ", VFP"); + out = stpcpy (out, ", VFP"); break; case EF_ARM_MAVERICK_FLOAT: - strcat (buf, ", Maverick FP"); + out = stpcpy (out, ", Maverick FP"); break; default: @@ -3282,89 +3283,585 @@ decode_ARM_machine_flags (unsigned e_flags, char buf[]) } if (unknown) - strcat (buf,_(", ")); + out = stpcpy (out,_(", ")); + return out; } -static void -decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size) +static char * +decode_AVR_machine_flags (char *out, unsigned e_flags) { - --size; /* Leave space for null terminator. */ - switch (e_flags & EF_AVR_MACH) { case E_AVR_MACH_AVR1: - strncat (buf, ", avr:1", size); + out = stpcpy (out, ", avr:1"); break; case E_AVR_MACH_AVR2: - strncat (buf, ", avr:2", size); + out = stpcpy (out, ", avr:2"); break; case E_AVR_MACH_AVR25: - strncat (buf, ", avr:25", size); + out = stpcpy (out, ", avr:25"); break; case E_AVR_MACH_AVR3: - strncat (buf, ", avr:3", size); + out = stpcpy (out, ", avr:3"); break; case E_AVR_MACH_AVR31: - strncat (buf, ", avr:31", size); + out = stpcpy (out, ", avr:31"); break; case E_AVR_MACH_AVR35: - strncat (buf, ", avr:35", size); + out = stpcpy (out, ", avr:35"); break; case E_AVR_MACH_AVR4: - strncat (buf, ", avr:4", size); + out = stpcpy (out, ", avr:4"); break; case E_AVR_MACH_AVR5: - strncat (buf, ", avr:5", size); + out = stpcpy (out, ", avr:5"); break; case E_AVR_MACH_AVR51: - strncat (buf, ", avr:51", size); + out = stpcpy (out, ", avr:51"); break; case E_AVR_MACH_AVR6: - strncat (buf, ", avr:6", size); + out = stpcpy (out, ", avr:6"); break; case E_AVR_MACH_AVRTINY: - strncat (buf, ", avr:100", size); + out = stpcpy (out, ", avr:100"); break; case E_AVR_MACH_XMEGA1: - strncat (buf, ", avr:101", size); + out = stpcpy (out, ", avr:101"); break; case E_AVR_MACH_XMEGA2: - strncat (buf, ", avr:102", size); + out = stpcpy (out, ", avr:102"); break; case E_AVR_MACH_XMEGA3: - strncat (buf, ", avr:103", size); + out = stpcpy (out, ", avr:103"); break; case E_AVR_MACH_XMEGA4: - strncat (buf, ", avr:104", size); + out = stpcpy (out, ", avr:104"); break; case E_AVR_MACH_XMEGA5: - strncat (buf, ", avr:105", size); + out = stpcpy (out, ", avr:105"); break; case E_AVR_MACH_XMEGA6: - strncat (buf, ", avr:106", size); + out = stpcpy (out, ", avr:106"); break; case E_AVR_MACH_XMEGA7: - strncat (buf, ", avr:107", size); + out = stpcpy (out, ", avr:107"); break; default: - strncat (buf, ", avr:", size); + out = stpcpy (out, ", avr:"); break; } - size -= strlen (buf); if (e_flags & EF_AVR_LINKRELAX_PREPARED) - strncat (buf, ", link-relax", size); + out = stpcpy (out, ", link-relax"); + return out; } -static void -decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size) +static char * +decode_BLACKFIN_machine_flags (char *out, unsigned e_flags) +{ + if (e_flags & EF_BFIN_PIC) + out = stpcpy (out, ", PIC"); + + if (e_flags & EF_BFIN_FDPIC) + out = stpcpy (out, ", FDPIC"); + + if (e_flags & EF_BFIN_CODE_IN_L1) + out = stpcpy (out, ", code in L1"); + + if (e_flags & EF_BFIN_DATA_IN_L1) + out = stpcpy (out, ", data in L1"); + return out; +} + +static char * +decode_FRV_machine_flags (char *out, unsigned e_flags) +{ + switch (e_flags & EF_FRV_CPU_MASK) + { + case EF_FRV_CPU_GENERIC: + break; + + default: + out = stpcpy (out, ", fr???"); + break; + + case EF_FRV_CPU_FR300: + out = stpcpy (out, ", fr300"); + break; + + case EF_FRV_CPU_FR400: + out = stpcpy (out, ", fr400"); + break; + case EF_FRV_CPU_FR405: + out = stpcpy (out, ", fr405"); + break; + + case EF_FRV_CPU_FR450: + out = stpcpy (out, ", fr450"); + break; + + case EF_FRV_CPU_FR500: + out = stpcpy (out, ", fr500"); + break; + case EF_FRV_CPU_FR550: + out = stpcpy (out, ", fr550"); + break; + + case EF_FRV_CPU_SIMPLE: + out = stpcpy (out, ", simple"); + break; + case EF_FRV_CPU_TOMCAT: + out = stpcpy (out, ", tomcat"); + break; + } + return out; +} + +static char * +decode_IA64_machine_flags (char *out, unsigned e_flags, Filedata *filedata) +{ + if ((e_flags & EF_IA_64_ABI64)) + out = stpcpy (out, ", 64-bit"); + else + out = stpcpy (out, ", 32-bit"); + if ((e_flags & EF_IA_64_REDUCEDFP)) + out = stpcpy (out, ", reduced fp model"); + if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP)) + out = stpcpy (out, ", no function descriptors, constant gp"); + else if ((e_flags & EF_IA_64_CONS_GP)) + out = stpcpy (out, ", constant gp"); + if ((e_flags & EF_IA_64_ABSOLUTE)) + out = stpcpy (out, ", absolute"); + if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS) + { + if ((e_flags & EF_IA_64_VMS_LINKAGES)) + out = stpcpy (out, ", vms_linkages"); + switch ((e_flags & EF_IA_64_VMS_COMCOD)) + { + case EF_IA_64_VMS_COMCOD_SUCCESS: + break; + case EF_IA_64_VMS_COMCOD_WARNING: + out = stpcpy (out, ", warning"); + break; + case EF_IA_64_VMS_COMCOD_ERROR: + out = stpcpy (out, ", error"); + break; + case EF_IA_64_VMS_COMCOD_ABORT: + out = stpcpy (out, ", abort"); + break; + default: + warn (_("Unrecognised IA64 VMS Command Code: %x\n"), + e_flags & EF_IA_64_VMS_COMCOD); + out = stpcpy (out, ", "); + } + } + return out; +} + +static char * +decode_LOONGARCH_machine_flags (char *out, unsigned int e_flags) +{ + if (EF_LOONGARCH_IS_SOFT_FLOAT (e_flags)) + out = stpcpy (out, ", SOFT-FLOAT"); + else if (EF_LOONGARCH_IS_SINGLE_FLOAT (e_flags)) + out = stpcpy (out, ", SINGLE-FLOAT"); + else if (EF_LOONGARCH_IS_DOUBLE_FLOAT (e_flags)) + out = stpcpy (out, ", DOUBLE-FLOAT"); + + if (EF_LOONGARCH_IS_OBJ_V0 (e_flags)) + out = stpcpy (out, ", OBJ-v0"); + else if (EF_LOONGARCH_IS_OBJ_V1 (e_flags)) + out = stpcpy (out, ", OBJ-v1"); + return out; +} + +static char * +decode_M68K_machine_flags (char *out, unsigned int e_flags) +{ + if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000) + out = stpcpy (out, ", m68000"); + else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32) + out = stpcpy (out, ", cpu32"); + else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO) + out = stpcpy (out, ", fido_a"); + else + { + char const *isa = _("unknown"); + char const *mac = _("unknown mac"); + char const *additional = NULL; + + switch (e_flags & EF_M68K_CF_ISA_MASK) + { + case EF_M68K_CF_ISA_A_NODIV: + isa = "A"; + additional = ", nodiv"; + break; + case EF_M68K_CF_ISA_A: + isa = "A"; + break; + case EF_M68K_CF_ISA_A_PLUS: + isa = "A+"; + break; + case EF_M68K_CF_ISA_B_NOUSP: + isa = "B"; + additional = ", nousp"; + break; + case EF_M68K_CF_ISA_B: + isa = "B"; + break; + case EF_M68K_CF_ISA_C: + isa = "C"; + break; + case EF_M68K_CF_ISA_C_NODIV: + isa = "C"; + additional = ", nodiv"; + break; + } + out = stpcpy (out, ", cf, isa "); + out = stpcpy (out, isa); + if (additional) + out = stpcpy (out, additional); + if (e_flags & EF_M68K_CF_FLOAT) + out = stpcpy (out, ", float"); + switch (e_flags & EF_M68K_CF_MAC_MASK) + { + case 0: + mac = NULL; + break; + case EF_M68K_CF_MAC: + mac = "mac"; + break; + case EF_M68K_CF_EMAC: + mac = "emac"; + break; + case EF_M68K_CF_EMAC_B: + mac = "emac_b"; + break; + } + if (mac) + { + out = stpcpy (out, ", "); + out = stpcpy (out, mac); + } + } + return out; +} + +static char * +decode_MeP_machine_flags (char *out, unsigned int e_flags) +{ + switch (e_flags & EF_MEP_CPU_MASK) + { + case EF_MEP_CPU_MEP: + out = stpcpy (out, ", generic MeP"); + break; + case EF_MEP_CPU_C2: + out = stpcpy (out, ", MeP C2"); + break; + case EF_MEP_CPU_C3: + out = stpcpy (out, ", MeP C3"); + break; + case EF_MEP_CPU_C4: + out = stpcpy (out, ", MeP C4"); + break; + case EF_MEP_CPU_C5: + out = stpcpy (out, ", MeP C5"); + break; + case EF_MEP_CPU_H1: + out = stpcpy (out, ", MeP H1"); + break; + default: + out = stpcpy (out, _(", ")); + break; + } + + switch (e_flags & EF_MEP_COP_MASK) + { + case EF_MEP_COP_NONE: + break; + case EF_MEP_COP_AVC: + out = stpcpy (out, ", AVC coprocessor"); + break; + case EF_MEP_COP_AVC2: + out = stpcpy (out, ", AVC2 coprocessor"); + break; + case EF_MEP_COP_FMAX: + out = stpcpy (out, ", FMAX coprocessor"); + break; + case EF_MEP_COP_IVC2: + out = stpcpy (out, ", IVC2 coprocessor"); + break; + default: + out = stpcpy (out, _("")); + break; + } + + if (e_flags & EF_MEP_LIBRARY) + out = stpcpy (out, ", Built for Library"); + + if (e_flags & EF_MEP_INDEX_MASK) + out += sprintf (out, ", Configuration Index: %#x", + e_flags & EF_MEP_INDEX_MASK); + + if (e_flags & ~ EF_MEP_ALL_FLAGS) + out += sprintf (out, _(", unknown flags bits: %#x"), + e_flags & ~ EF_MEP_ALL_FLAGS); + return out; +} + +static char * +decode_MIPS_machine_flags (char *out, unsigned int e_flags) +{ + if (e_flags & EF_MIPS_NOREORDER) + out = stpcpy (out, ", noreorder"); + + if (e_flags & EF_MIPS_PIC) + out = stpcpy (out, ", pic"); + + if (e_flags & EF_MIPS_CPIC) + out = stpcpy (out, ", cpic"); + + if (e_flags & EF_MIPS_UCODE) + out = stpcpy (out, ", ugen_reserved"); + + if (e_flags & EF_MIPS_ABI2) + out = stpcpy (out, ", abi2"); + + if (e_flags & EF_MIPS_OPTIONS_FIRST) + out = stpcpy (out, ", odk first"); + + if (e_flags & EF_MIPS_32BITMODE) + out = stpcpy (out, ", 32bitmode"); + + if (e_flags & EF_MIPS_NAN2008) + out = stpcpy (out, ", nan2008"); + + if (e_flags & EF_MIPS_FP64) + out = stpcpy (out, ", fp64"); + + switch ((e_flags & EF_MIPS_MACH)) + { + case E_MIPS_MACH_3900: + out = stpcpy (out, ", 3900"); + break; + case E_MIPS_MACH_4010: + out = stpcpy (out, ", 4010"); + break; + case E_MIPS_MACH_4100: + out = stpcpy (out, ", 4100"); + break; + case E_MIPS_MACH_4111: + out = stpcpy (out, ", 4111"); + break; + case E_MIPS_MACH_4120: + out = stpcpy (out, ", 4120"); + break; + case E_MIPS_MACH_4650: + out = stpcpy (out, ", 4650"); + break; + case E_MIPS_MACH_5400: + out = stpcpy (out, ", 5400"); + break; + case E_MIPS_MACH_5500: + out = stpcpy (out, ", 5500"); + break; + case E_MIPS_MACH_5900: + out = stpcpy (out, ", 5900"); + break; + case E_MIPS_MACH_SB1: + out = stpcpy (out, ", sb1"); + break; + case E_MIPS_MACH_9000: + out = stpcpy (out, ", 9000"); + break; + case E_MIPS_MACH_LS2E: + out = stpcpy (out, ", loongson-2e"); + break; + case E_MIPS_MACH_LS2F: + out = stpcpy (out, ", loongson-2f"); + break; + case E_MIPS_MACH_GS464: + out = stpcpy (out, ", gs464"); + break; + case E_MIPS_MACH_GS464E: + out = stpcpy (out, ", gs464e"); + break; + case E_MIPS_MACH_GS264E: + out = stpcpy (out, ", gs264e"); + break; + case E_MIPS_MACH_OCTEON: + out = stpcpy (out, ", octeon"); + break; + case E_MIPS_MACH_OCTEON2: + out = stpcpy (out, ", octeon2"); + break; + case E_MIPS_MACH_OCTEON3: + out = stpcpy (out, ", octeon3"); + break; + case E_MIPS_MACH_XLR: + out = stpcpy (out, ", xlr"); + break; + case E_MIPS_MACH_IAMR2: + out = stpcpy (out, ", interaptiv-mr2"); + break; + case E_MIPS_MACH_ALLEGREX: + out = stpcpy (out, ", allegrex"); + break; + case 0: + /* We simply ignore the field in this case to avoid confusion: + MIPS ELF does not specify EF_MIPS_MACH, it is a GNU + extension. */ + break; + default: + out = stpcpy (out, _(", unknown CPU")); + break; + } + + switch ((e_flags & EF_MIPS_ABI)) + { + case E_MIPS_ABI_O32: + out = stpcpy (out, ", o32"); + break; + case E_MIPS_ABI_O64: + out = stpcpy (out, ", o64"); + break; + case E_MIPS_ABI_EABI32: + out = stpcpy (out, ", eabi32"); + break; + case E_MIPS_ABI_EABI64: + out = stpcpy (out, ", eabi64"); + 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: + out = stpcpy (out, _(", unknown ABI")); + break; + } + + if (e_flags & EF_MIPS_ARCH_ASE_MDMX) + out = stpcpy (out, ", mdmx"); + + if (e_flags & EF_MIPS_ARCH_ASE_M16) + out = stpcpy (out, ", mips16"); + + if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) + out = stpcpy (out, ", micromips"); + + switch ((e_flags & EF_MIPS_ARCH)) + { + case E_MIPS_ARCH_1: + out = stpcpy (out, ", mips1"); + break; + case E_MIPS_ARCH_2: + out = stpcpy (out, ", mips2"); + break; + case E_MIPS_ARCH_3: + out = stpcpy (out, ", mips3"); + break; + case E_MIPS_ARCH_4: + out = stpcpy (out, ", mips4"); + break; + case E_MIPS_ARCH_5: + out = stpcpy (out, ", mips5"); + break; + case E_MIPS_ARCH_32: + out = stpcpy (out, ", mips32"); + break; + case E_MIPS_ARCH_32R2: + out = stpcpy (out, ", mips32r2"); + break; + case E_MIPS_ARCH_32R6: + out = stpcpy (out, ", mips32r6"); + break; + case E_MIPS_ARCH_64: + out = stpcpy (out, ", mips64"); + break; + case E_MIPS_ARCH_64R2: + out = stpcpy (out, ", mips64r2"); + break; + case E_MIPS_ARCH_64R6: + out = stpcpy (out, ", mips64r6"); + break; + default: + out = stpcpy (out, _(", unknown ISA")); + break; + } + return out; +} + +static char * +decode_MSP430_machine_flags (char *out, unsigned e_flags) +{ + out = stpcpy (out, _(": architecture variant: ")); + switch (e_flags & EF_MSP430_MACH) + { + case E_MSP430_MACH_MSP430x11: + out = stpcpy (out, "MSP430x11"); + break; + case E_MSP430_MACH_MSP430x11x1: + out = stpcpy (out, "MSP430x11x1 "); + break; + case E_MSP430_MACH_MSP430x12: + out = stpcpy (out, "MSP430x12"); + break; + case E_MSP430_MACH_MSP430x13: + out = stpcpy (out, "MSP430x13"); + break; + case E_MSP430_MACH_MSP430x14: + out = stpcpy (out, "MSP430x14"); + break; + case E_MSP430_MACH_MSP430x15: + out = stpcpy (out, "MSP430x15"); + break; + case E_MSP430_MACH_MSP430x16: + out = stpcpy (out, "MSP430x16"); + break; + case E_MSP430_MACH_MSP430x31: + out = stpcpy (out, "MSP430x31"); + break; + case E_MSP430_MACH_MSP430x32: + out = stpcpy (out, "MSP430x32"); + break; + case E_MSP430_MACH_MSP430x33: + out = stpcpy (out, "MSP430x33"); + break; + case E_MSP430_MACH_MSP430x41: + out = stpcpy (out, "MSP430x41"); + break; + case E_MSP430_MACH_MSP430x42: + out = stpcpy (out, "MSP430x42"); + break; + case E_MSP430_MACH_MSP430x43: + out = stpcpy (out, "MSP430x43"); + break; + case E_MSP430_MACH_MSP430x44: + out = stpcpy (out, "MSP430x44"); + break; + case E_MSP430_MACH_MSP430X : + out = stpcpy (out, "MSP430X"); + break; + default: + out = stpcpy (out, _(": unknown")); + break; + } + + if (e_flags & ~ EF_MSP430_MACH) + out = stpcpy (out, _(": unknown extra flag bits also present")); + return out; +} + +static char * +decode_NDS32_machine_flags (char *out, unsigned e_flags) { unsigned abi; unsigned arch; unsigned config; unsigned version; bool has_fpu = false; - unsigned int r = 0; static const char *ABI_STRINGS[] = { @@ -3395,8 +3892,6 @@ decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size) config = EF_NDS_INST & e_flags; version = EF_NDS32_ELF_VERSION & e_flags; - memset (buf, 0, size); - switch (abi) { case E_NDS_ABI_V0: @@ -3406,11 +3901,11 @@ decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size) case E_NDS_ABI_AABI: case E_NDS_ABI_V2FP_PLUS: /* In case there are holes in the array. */ - r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]); + out += sprintf (out, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]); break; default: - r += snprintf (buf + r, size - r, ", "); + out = stpcpy (out, ", "); break; } @@ -3419,21 +3914,21 @@ decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size) case E_NDS32_ELF_VER_1_2: case E_NDS32_ELF_VER_1_3: case E_NDS32_ELF_VER_1_4: - r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]); + out += sprintf (out, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]); break; default: - r += snprintf (buf + r, size - r, ", "); + out = stpcpy (out, ", "); break; } if (E_NDS_ABI_V0 == abi) { /* OLD ABI; only used in N1213HC, has performance extension 1. */ - r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1"); + out = stpcpy (out, ", Andes Star v1.0, N1213HC, MAC, PERF1"); if (arch == E_NDS_ARCH_STAR_V1_0) - r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */ - return; + out = stpcpy (out, ", 16b"); /* has 16-bit instructions */ + return out; } switch (arch) @@ -3442,78 +3937,78 @@ decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size) case E_NDS_ARCH_STAR_V2_0: case E_NDS_ARCH_STAR_V3_0: case E_NDS_ARCH_STAR_V3_M: - r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]); + out += sprintf (out, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]); break; default: - r += snprintf (buf + r, size - r, ", "); + out = stpcpy (out, ", "); /* ARCH version determines how the e_flags are interpreted. If it is unknown, we cannot proceed. */ - return; + return out; } /* Newer ABI; Now handle architecture specific flags. */ if (arch == E_NDS_ARCH_STAR_V1_0) { if (config & E_NDS32_HAS_MFUSR_PC_INST) - r += snprintf (buf + r, size -r, ", MFUSR_PC"); + out = stpcpy (out, ", MFUSR_PC"); if (!(config & E_NDS32_HAS_NO_MAC_INST)) - r += snprintf (buf + r, size -r, ", MAC"); + out = stpcpy (out, ", MAC"); if (config & E_NDS32_HAS_DIV_INST) - r += snprintf (buf + r, size -r, ", DIV"); + out = stpcpy (out, ", DIV"); if (config & E_NDS32_HAS_16BIT_INST) - r += snprintf (buf + r, size -r, ", 16b"); + out = stpcpy (out, ", 16b"); } else { if (config & E_NDS32_HAS_MFUSR_PC_INST) { if (version <= E_NDS32_ELF_VER_1_3) - r += snprintf (buf + r, size -r, ", [B8]"); + out = stpcpy (out, ", [B8]"); else - r += snprintf (buf + r, size -r, ", EX9"); + out = stpcpy (out, ", EX9"); } if (config & E_NDS32_HAS_MAC_DX_INST) - r += snprintf (buf + r, size -r, ", MAC_DX"); + out = stpcpy (out, ", MAC_DX"); if (config & E_NDS32_HAS_DIV_DX_INST) - r += snprintf (buf + r, size -r, ", DIV_DX"); + out = stpcpy (out, ", DIV_DX"); if (config & E_NDS32_HAS_16BIT_INST) { if (version <= E_NDS32_ELF_VER_1_3) - r += snprintf (buf + r, size -r, ", 16b"); + out = stpcpy (out, ", 16b"); else - r += snprintf (buf + r, size -r, ", IFC"); + out = stpcpy (out, ", IFC"); } } if (config & E_NDS32_HAS_EXT_INST) - r += snprintf (buf + r, size -r, ", PERF1"); + out = stpcpy (out, ", PERF1"); if (config & E_NDS32_HAS_EXT2_INST) - r += snprintf (buf + r, size -r, ", PERF2"); + out = stpcpy (out, ", PERF2"); if (config & E_NDS32_HAS_FPU_INST) { has_fpu = true; - r += snprintf (buf + r, size -r, ", FPU_SP"); + out = stpcpy (out, ", FPU_SP"); } if (config & E_NDS32_HAS_FPU_DP_INST) { has_fpu = true; - r += snprintf (buf + r, size -r, ", FPU_DP"); + out = stpcpy (out, ", FPU_DP"); } if (config & E_NDS32_HAS_FPU_MAC_INST) { has_fpu = true; - r += snprintf (buf + r, size -r, ", FPU_MAC"); + out = stpcpy (out, ", FPU_MAC"); } if (has_fpu) @@ -3521,47 +4016,404 @@ decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size) switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT) { case E_NDS32_FPU_REG_8SP_4DP: - r += snprintf (buf + r, size -r, ", FPU_REG:8/4"); + out = stpcpy (out, ", FPU_REG:8/4"); break; case E_NDS32_FPU_REG_16SP_8DP: - r += snprintf (buf + r, size -r, ", FPU_REG:16/8"); + out = stpcpy (out, ", FPU_REG:16/8"); break; case E_NDS32_FPU_REG_32SP_16DP: - r += snprintf (buf + r, size -r, ", FPU_REG:32/16"); + out = stpcpy (out, ", FPU_REG:32/16"); break; case E_NDS32_FPU_REG_32SP_32DP: - r += snprintf (buf + r, size -r, ", FPU_REG:32/32"); + out = stpcpy (out, ", FPU_REG:32/32"); break; } } if (config & E_NDS32_HAS_AUDIO_INST) - r += snprintf (buf + r, size -r, ", AUDIO"); + out = stpcpy (out, ", AUDIO"); if (config & E_NDS32_HAS_STRING_INST) - r += snprintf (buf + r, size -r, ", STR"); + out = stpcpy (out, ", STR"); if (config & E_NDS32_HAS_REDUCED_REGS) - r += snprintf (buf + r, size -r, ", 16REG"); + out = stpcpy (out, ", 16REG"); if (config & E_NDS32_HAS_VIDEO_INST) { if (version <= E_NDS32_ELF_VER_1_3) - r += snprintf (buf + r, size -r, ", VIDEO"); + out = stpcpy (out, ", VIDEO"); else - r += snprintf (buf + r, size -r, ", SATURATION"); + out = stpcpy (out, ", SATURATION"); } if (config & E_NDS32_HAS_ENCRIPT_INST) - r += snprintf (buf + r, size -r, ", ENCRP"); + out = stpcpy (out, ", ENCRP"); if (config & E_NDS32_HAS_L2C_INST) - r += snprintf (buf + r, size -r, ", L2C"); + out = stpcpy (out, ", L2C"); + + return out; } -static void -decode_AMDGPU_machine_flags (Filedata *filedata, unsigned int e_flags, - char *buf) +static char * +decode_PARISC_machine_flags (char *out, unsigned e_flags) +{ + switch (e_flags & EF_PARISC_ARCH) + { + case EFA_PARISC_1_0: + out = stpcpy (out, ", PA-RISC 1.0"); + break; + case EFA_PARISC_1_1: + out = stpcpy (out, ", PA-RISC 1.1"); + break; + case EFA_PARISC_2_0: + out = stpcpy (out, ", PA-RISC 2.0"); + break; + default: + break; + } + if (e_flags & EF_PARISC_TRAPNIL) + out = stpcpy (out, ", trapnil"); + if (e_flags & EF_PARISC_EXT) + out = stpcpy (out, ", ext"); + if (e_flags & EF_PARISC_LSB) + out = stpcpy (out, ", lsb"); + if (e_flags & EF_PARISC_WIDE) + out = stpcpy (out, ", wide"); + if (e_flags & EF_PARISC_NO_KABP) + out = stpcpy (out, ", no kabp"); + if (e_flags & EF_PARISC_LAZYSWAP) + out = stpcpy (out, ", lazyswap"); + return out; +} + +static char * +decode_RISCV_machine_flags (char *out, unsigned e_flags) +{ + if (e_flags & EF_RISCV_RVC) + out = stpcpy (out, ", RVC"); + + if (e_flags & EF_RISCV_RVE) + out = stpcpy (out, ", RVE"); + + if (e_flags & EF_RISCV_TSO) + out = stpcpy (out, ", TSO"); + + switch (e_flags & EF_RISCV_FLOAT_ABI) + { + case EF_RISCV_FLOAT_ABI_SOFT: + out = stpcpy (out, ", soft-float ABI"); + break; + + case EF_RISCV_FLOAT_ABI_SINGLE: + out = stpcpy (out, ", single-float ABI"); + break; + + case EF_RISCV_FLOAT_ABI_DOUBLE: + out = stpcpy (out, ", double-float ABI"); + break; + + case EF_RISCV_FLOAT_ABI_QUAD: + out = stpcpy (out, ", quad-float ABI"); + break; + } + return out; +} + +static char * +decode_RL78_machine_flags (char *out, unsigned e_flags) +{ + switch (e_flags & E_FLAG_RL78_CPU_MASK) + { + case E_FLAG_RL78_ANY_CPU: + break; + case E_FLAG_RL78_G10: + out = stpcpy (out, ", G10"); + break; + case E_FLAG_RL78_G13: + out = stpcpy (out, ", G13"); + break; + case E_FLAG_RL78_G14: + out = stpcpy (out, ", G14"); + break; + } + if (e_flags & E_FLAG_RL78_64BIT_DOUBLES) + out = stpcpy (out, ", 64-bit doubles"); + return out; +} + +static char * +decode_RX_machine_flags (char *out, unsigned e_flags) +{ + if (e_flags & E_FLAG_RX_64BIT_DOUBLES) + out = stpcpy (out, ", 64-bit doubles"); + if (e_flags & E_FLAG_RX_DSP) + out = stpcpy (out, ", dsp"); + if (e_flags & E_FLAG_RX_PID) + out = stpcpy (out, ", pid"); + if (e_flags & E_FLAG_RX_ABI) + out = stpcpy (out, ", RX ABI"); + if (e_flags & E_FLAG_RX_SINSNS_SET) + out = stpcpy (out, (e_flags & E_FLAG_RX_SINSNS_YES + ? ", uses String instructions" + : ", bans String instructions")); + if (e_flags & E_FLAG_RX_V2) + out = stpcpy (out, ", V2"); + if (e_flags & E_FLAG_RX_V3) + out = stpcpy (out, ", V3"); + return out; +} + +static char * +decode_SH_machine_flags (char *out, unsigned e_flags) +{ + switch ((e_flags & EF_SH_MACH_MASK)) + { + case EF_SH1: + out = stpcpy (out, ", sh1"); + break; + case EF_SH2: + out = stpcpy (out, ", sh2"); + break; + case EF_SH3: + out = stpcpy (out, ", sh3"); + break; + case EF_SH_DSP: + out = stpcpy (out, ", sh-dsp"); + break; + case EF_SH3_DSP: + out = stpcpy (out, ", sh3-dsp"); + break; + case EF_SH4AL_DSP: + out = stpcpy (out, ", sh4al-dsp"); + break; + case EF_SH3E: + out = stpcpy (out, ", sh3e"); + break; + case EF_SH4: + out = stpcpy (out, ", sh4"); + break; + case EF_SH5: + out = stpcpy (out, ", sh5"); + break; + case EF_SH2E: + out = stpcpy (out, ", sh2e"); + break; + case EF_SH4A: + out = stpcpy (out, ", sh4a"); + break; + case EF_SH2A: + out = stpcpy (out, ", sh2a"); + break; + case EF_SH4_NOFPU: + out = stpcpy (out, ", sh4-nofpu"); + break; + case EF_SH4A_NOFPU: + out = stpcpy (out, ", sh4a-nofpu"); + break; + case EF_SH2A_NOFPU: + out = stpcpy (out, ", sh2a-nofpu"); + break; + case EF_SH3_NOMMU: + out = stpcpy (out, ", sh3-nommu"); + break; + case EF_SH4_NOMMU_NOFPU: + out = stpcpy (out, ", sh4-nommu-nofpu"); + break; + case EF_SH2A_SH4_NOFPU: + out = stpcpy (out, ", sh2a-nofpu-or-sh4-nommu-nofpu"); + break; + case EF_SH2A_SH3_NOFPU: + out = stpcpy (out, ", sh2a-nofpu-or-sh3-nommu"); + break; + case EF_SH2A_SH4: + out = stpcpy (out, ", sh2a-or-sh4"); + break; + case EF_SH2A_SH3E: + out = stpcpy (out, ", sh2a-or-sh3e"); + break; + default: + out = stpcpy (out, _(", unknown ISA")); + break; + } + + if (e_flags & EF_SH_PIC) + out = stpcpy (out, ", pic"); + + if (e_flags & EF_SH_FDPIC) + out = stpcpy (out, ", fdpic"); + return out; +} + +static char * +decode_SPARC_machine_flags (char *out, unsigned e_flags) +{ + if (e_flags & EF_SPARC_32PLUS) + out = stpcpy (out, ", v8+"); + + if (e_flags & EF_SPARC_SUN_US1) + out = stpcpy (out, ", ultrasparcI"); + + if (e_flags & EF_SPARC_SUN_US3) + out = stpcpy (out, ", ultrasparcIII"); + + if (e_flags & EF_SPARC_HAL_R1) + out = stpcpy (out, ", halr1"); + + if (e_flags & EF_SPARC_LEDATA) + out = stpcpy (out, ", ledata"); + + if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO) + out = stpcpy (out, ", tso"); + + if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO) + out = stpcpy (out, ", pso"); + + if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO) + out = stpcpy (out, ", rmo"); + return out; +} + +static char * +decode_V800_machine_flags (char *out, unsigned int e_flags) +{ + if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI) + out = stpcpy (out, ", RH850 ABI"); + + if (e_flags & EF_V800_850E3) + out = stpcpy (out, ", V3 architecture"); + + if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0) + out = stpcpy (out, ", FPU not used"); + + if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0) + out = stpcpy (out, ", regmode: COMMON"); + + if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0) + out = stpcpy (out, ", r4 not used"); + + if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0) + out = stpcpy (out, ", r30 not used"); + + if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0) + out = stpcpy (out, ", r5 not used"); + + if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0) + out = stpcpy (out, ", r2 not used"); + + for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags)) + { + switch (e_flags & - e_flags) + { + case EF_RH850_FPU_DOUBLE: + out = stpcpy (out, ", double precision FPU"); + break; + case EF_RH850_FPU_SINGLE: + out = stpcpy (out, ", single precision FPU"); + break; + case EF_RH850_REGMODE22: + out = stpcpy (out, ", regmode:22"); + break; + case EF_RH850_REGMODE32: + out = stpcpy (out, ", regmode:23"); + break; + case EF_RH850_GP_FIX: + out = stpcpy (out, ", r4 fixed"); + break; + case EF_RH850_GP_NOFIX: + out = stpcpy (out, ", r4 free"); + break; + case EF_RH850_EP_FIX: + out = stpcpy (out, ", r30 fixed"); + break; + case EF_RH850_EP_NOFIX: + out = stpcpy (out, ", r30 free"); + break; + case EF_RH850_TP_FIX: + out = stpcpy (out, ", r5 fixed"); + break; + case EF_RH850_TP_NOFIX: + out = stpcpy (out, ", r5 free"); + break; + case EF_RH850_REG2_RESERVE: + out = stpcpy (out, ", r2 fixed"); + break; + case EF_RH850_REG2_NORESERVE: + out = stpcpy (out, ", r2 free"); + break; + default: + break; + } + } + return out; +} + +static char * +decode_V850_machine_flags (char *out, unsigned int e_flags) +{ + switch (e_flags & EF_V850_ARCH) + { + case E_V850E3V5_ARCH: + out = stpcpy (out, ", v850e3v5"); + break; + case E_V850E2V3_ARCH: + out = stpcpy (out, ", v850e2v3"); + break; + case E_V850E2_ARCH: + out = stpcpy (out, ", v850e2"); + break; + case E_V850E1_ARCH: + out = stpcpy (out, ", v850e1"); + break; + case E_V850E_ARCH: + out = stpcpy (out, ", v850e"); + break; + case E_V850_ARCH: + out = stpcpy (out, ", v850"); + break; + default: + out = stpcpy (out, _(", unknown v850 architecture variant")); + break; + } + return out; +} + +static char * +decode_Z80_machine_flags (char *out, unsigned int e_flags) +{ + switch (e_flags & EF_Z80_MACH_MSK) + { + case EF_Z80_MACH_Z80: + out = stpcpy (out, ", Z80"); + break; + case EF_Z80_MACH_Z180: + out = stpcpy (out, ", Z180"); + break; + case EF_Z80_MACH_R800: + out = stpcpy (out, ", R800"); + break; + case EF_Z80_MACH_EZ80_Z80: + out = stpcpy (out, ", EZ80"); + break; + case EF_Z80_MACH_EZ80_ADL: + out = stpcpy (out, ", EZ80, ADL"); + break; + case EF_Z80_MACH_GBZ80: + out = stpcpy (out, ", GBZ80"); + break; + case EF_Z80_MACH_Z80N: + out = stpcpy (out, ", Z80N"); + break; + default: + out = stpcpy (out, _(", unknown")); + break; + } + return out; +} + +static char * +decode_AMDGPU_machine_flags (char *out, unsigned int e_flags, Filedata *filedata) { unsigned char *e_ident = filedata->file_header.e_ident; unsigned char osabi = e_ident[EI_OSABI]; @@ -3575,13 +4427,13 @@ decode_AMDGPU_machine_flags (Filedata *filedata, unsigned int e_flags, of writing, they use the same flags as HSA v3, so the code below uses that assumption. */ if (osabi == ELFOSABI_AMDGPU_HSA && abiversion < ELFABIVERSION_AMDGPU_HSA_V3) - return; + return out; mach = e_flags & EF_AMDGPU_MACH; switch (mach) { #define AMDGPU_CASE(code, string) \ - case code: strcat (buf, ", " string); break; + case code: out = stpcpy (out, ", " string); break; AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX600, "gfx600") AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX601, "gfx601") AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX700, "gfx700") @@ -3617,12 +4469,11 @@ decode_AMDGPU_machine_flags (Filedata *filedata, unsigned int e_flags, AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1013, "gfx1013") AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1036, "gfx1036") default: - sprintf (buf, _(", "), mach); + out += sprintf (out, _(", "), mach); break; #undef AMDGPU_CASE } - buf += strlen (buf); e_flags &= ~EF_AMDGPU_MACH; if ((osabi == ELFOSABI_AMDGPU_HSA @@ -3632,15 +4483,13 @@ decode_AMDGPU_machine_flags (Filedata *filedata, unsigned int e_flags, /* For HSA v3 and other OS ABIs. */ if (e_flags & EF_AMDGPU_FEATURE_XNACK_V3) { - strcat (buf, ", xnack on"); - buf += strlen (buf); + out = stpcpy (out, ", xnack on"); e_flags &= ~EF_AMDGPU_FEATURE_XNACK_V3; } if (e_flags & EF_AMDGPU_FEATURE_SRAMECC_V3) { - strcat (buf, ", sramecc on"); - buf += strlen (buf); + out = stpcpy (out, ", sramecc on"); e_flags &= ~EF_AMDGPU_FEATURE_SRAMECC_V3; } } @@ -3656,23 +4505,22 @@ decode_AMDGPU_machine_flags (Filedata *filedata, unsigned int e_flags, break; case EF_AMDGPU_FEATURE_XNACK_ANY_V4: - strcat (buf, ", xnack any"); + out = stpcpy (out, ", xnack any"); break; case EF_AMDGPU_FEATURE_XNACK_OFF_V4: - strcat (buf, ", xnack off"); + out = stpcpy (out, ", xnack off"); break; case EF_AMDGPU_FEATURE_XNACK_ON_V4: - strcat (buf, ", xnack on"); + out = stpcpy (out, ", xnack on"); break; default: - sprintf (buf, _(", "), xnack); + out += sprintf (out, _(", "), xnack); break; } - buf += strlen (buf); e_flags &= ~EF_AMDGPU_FEATURE_XNACK_V4; sramecc = e_flags & EF_AMDGPU_FEATURE_SRAMECC_V4; @@ -3682,34 +4530,35 @@ decode_AMDGPU_machine_flags (Filedata *filedata, unsigned int e_flags, break; case EF_AMDGPU_FEATURE_SRAMECC_ANY_V4: - strcat (buf, ", sramecc any"); + out = stpcpy (out, ", sramecc any"); break; case EF_AMDGPU_FEATURE_SRAMECC_OFF_V4: - strcat (buf, ", sramecc off"); + out = stpcpy (out, ", sramecc off"); break; case EF_AMDGPU_FEATURE_SRAMECC_ON_V4: - strcat (buf, ", sramecc on"); + out = stpcpy (out, ", sramecc on"); break; default: - sprintf (buf, _(", "), sramecc); + out += sprintf (out, _(", "), sramecc); break; } - buf += strlen (buf); e_flags &= ~EF_AMDGPU_FEATURE_SRAMECC_V4; } if (e_flags != 0) - sprintf (buf, _(", unknown flags bits: %#x"), e_flags); + out += sprintf (out, _(", unknown flags bits: %#x"), e_flags); + return out; } static char * get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine) { static char buf[1024]; + char *out = buf; buf[0] = '\0'; @@ -3721,696 +4570,182 @@ get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine) break; case EM_ARC_COMPACT3: - strcat (buf, ", HS5x"); + out = stpcpy (out, ", HS5x"); break; case EM_ARC_COMPACT3_64: - strcat (buf, ", HS6x"); + out = stpcpy (out, ", HS6x"); break; case EM_ARC_COMPACT2: case EM_ARC_COMPACT: - decode_ARC_machine_flags (e_flags, e_machine, buf); - break; + out = decode_ARC_machine_flags (out, e_flags, e_machine); + break; case EM_ARM: - decode_ARM_machine_flags (e_flags, buf); + out = decode_ARM_machine_flags (out, e_flags); break; - case EM_AVR: - decode_AVR_machine_flags (e_flags, buf, sizeof buf); - break; + case EM_AVR: + out = decode_AVR_machine_flags (out, e_flags); + break; case EM_BLACKFIN: - if (e_flags & EF_BFIN_PIC) - strcat (buf, ", PIC"); - - if (e_flags & EF_BFIN_FDPIC) - strcat (buf, ", FDPIC"); - - if (e_flags & EF_BFIN_CODE_IN_L1) - strcat (buf, ", code in L1"); - - if (e_flags & EF_BFIN_DATA_IN_L1) - strcat (buf, ", data in L1"); - + out = decode_BLACKFIN_machine_flags (out, e_flags); break; case EM_CYGNUS_FRV: - switch (e_flags & EF_FRV_CPU_MASK) - { - case EF_FRV_CPU_GENERIC: - break; - - default: - strcat (buf, ", fr???"); - break; - - case EF_FRV_CPU_FR300: - strcat (buf, ", fr300"); - break; - - case EF_FRV_CPU_FR400: - strcat (buf, ", fr400"); - break; - case EF_FRV_CPU_FR405: - strcat (buf, ", fr405"); - break; - - case EF_FRV_CPU_FR450: - strcat (buf, ", fr450"); - break; - - case EF_FRV_CPU_FR500: - strcat (buf, ", fr500"); - break; - case EF_FRV_CPU_FR550: - strcat (buf, ", fr550"); - break; - - case EF_FRV_CPU_SIMPLE: - strcat (buf, ", simple"); - break; - case EF_FRV_CPU_TOMCAT: - strcat (buf, ", tomcat"); - break; - } + out = decode_FRV_machine_flags (out, e_flags); break; case EM_68K: - if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000) - strcat (buf, ", m68000"); - else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32) - strcat (buf, ", cpu32"); - else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO) - strcat (buf, ", fido_a"); - else - { - char const * isa = _("unknown"); - char const * mac = _("unknown mac"); - char const * additional = NULL; - - switch (e_flags & EF_M68K_CF_ISA_MASK) - { - case EF_M68K_CF_ISA_A_NODIV: - isa = "A"; - additional = ", nodiv"; - break; - case EF_M68K_CF_ISA_A: - isa = "A"; - break; - case EF_M68K_CF_ISA_A_PLUS: - isa = "A+"; - break; - case EF_M68K_CF_ISA_B_NOUSP: - isa = "B"; - additional = ", nousp"; - break; - case EF_M68K_CF_ISA_B: - isa = "B"; - break; - case EF_M68K_CF_ISA_C: - isa = "C"; - break; - case EF_M68K_CF_ISA_C_NODIV: - isa = "C"; - additional = ", nodiv"; - break; - } - strcat (buf, ", cf, isa "); - strcat (buf, isa); - if (additional) - strcat (buf, additional); - if (e_flags & EF_M68K_CF_FLOAT) - strcat (buf, ", float"); - switch (e_flags & EF_M68K_CF_MAC_MASK) - { - case 0: - mac = NULL; - break; - case EF_M68K_CF_MAC: - mac = "mac"; - break; - case EF_M68K_CF_EMAC: - mac = "emac"; - break; - case EF_M68K_CF_EMAC_B: - mac = "emac_b"; - break; - } - if (mac) - { - strcat (buf, ", "); - strcat (buf, mac); - } - } + out = decode_M68K_machine_flags (out, e_flags); break; case EM_AMDGPU: - decode_AMDGPU_machine_flags (filedata, e_flags, buf); + out = decode_AMDGPU_machine_flags (out, e_flags, filedata); break; case EM_CYGNUS_MEP: - switch (e_flags & EF_MEP_CPU_MASK) - { - case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break; - case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break; - case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break; - case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break; - case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break; - case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break; - default: strcat (buf, _(", ")); break; - } - - switch (e_flags & EF_MEP_COP_MASK) - { - case EF_MEP_COP_NONE: break; - case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break; - case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break; - case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break; - case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break; - default: strcat (buf, _("")); break; - } - - if (e_flags & EF_MEP_LIBRARY) - strcat (buf, ", Built for Library"); - - if (e_flags & EF_MEP_INDEX_MASK) - sprintf (buf + strlen (buf), ", Configuration Index: %#x", - e_flags & EF_MEP_INDEX_MASK); - - if (e_flags & ~ EF_MEP_ALL_FLAGS) - sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"), - e_flags & ~ EF_MEP_ALL_FLAGS); + out = decode_MeP_machine_flags (out, e_flags); break; case EM_PPC: if (e_flags & EF_PPC_EMB) - strcat (buf, ", emb"); + out = stpcpy (out, ", emb"); if (e_flags & EF_PPC_RELOCATABLE) - strcat (buf, _(", relocatable")); + out = stpcpy (out, _(", relocatable")); if (e_flags & EF_PPC_RELOCATABLE_LIB) - strcat (buf, _(", relocatable-lib")); + out = stpcpy (out, _(", relocatable-lib")); break; case EM_PPC64: if (e_flags & EF_PPC64_ABI) - { - char abi[] = ", abiv0"; - - abi[6] += e_flags & EF_PPC64_ABI; - strcat (buf, abi); - } + out += sprintf (out, ", abiv%d", e_flags & EF_PPC64_ABI); break; case EM_V800: - if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI) - strcat (buf, ", RH850 ABI"); - - if (e_flags & EF_V800_850E3) - strcat (buf, ", V3 architecture"); - - if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0) - strcat (buf, ", FPU not used"); - - if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0) - strcat (buf, ", regmode: COMMON"); - - if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0) - strcat (buf, ", r4 not used"); - - if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0) - strcat (buf, ", r30 not used"); - - if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0) - strcat (buf, ", r5 not used"); - - if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0) - strcat (buf, ", r2 not used"); - - for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags)) - { - switch (e_flags & - e_flags) - { - case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break; - case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break; - case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break; - case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break; - case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break; - case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break; - case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break; - case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break; - case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break; - case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break; - case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break; - case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break; - default: break; - } - } + out = decode_V800_machine_flags (out, e_flags); break; case EM_V850: case EM_CYGNUS_V850: - switch (e_flags & EF_V850_ARCH) - { - case E_V850E3V5_ARCH: - strcat (buf, ", v850e3v5"); - break; - case E_V850E2V3_ARCH: - strcat (buf, ", v850e2v3"); - break; - case E_V850E2_ARCH: - strcat (buf, ", v850e2"); - break; - case E_V850E1_ARCH: - strcat (buf, ", v850e1"); - break; - case E_V850E_ARCH: - strcat (buf, ", v850e"); - break; - case E_V850_ARCH: - strcat (buf, ", v850"); - break; - default: - strcat (buf, _(", unknown v850 architecture variant")); - break; - } + out = decode_V850_machine_flags (out, e_flags); break; case EM_M32R: case EM_CYGNUS_M32R: if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH) - strcat (buf, ", m32r"); + out = stpcpy (out, ", m32r"); break; case EM_MIPS: case EM_MIPS_RS3_LE: - if (e_flags & EF_MIPS_NOREORDER) - strcat (buf, ", noreorder"); - - if (e_flags & EF_MIPS_PIC) - strcat (buf, ", pic"); - - if (e_flags & EF_MIPS_CPIC) - strcat (buf, ", cpic"); - - if (e_flags & EF_MIPS_UCODE) - strcat (buf, ", ugen_reserved"); - - if (e_flags & EF_MIPS_ABI2) - strcat (buf, ", abi2"); - - if (e_flags & EF_MIPS_OPTIONS_FIRST) - strcat (buf, ", odk first"); - - if (e_flags & EF_MIPS_32BITMODE) - strcat (buf, ", 32bitmode"); - - if (e_flags & EF_MIPS_NAN2008) - strcat (buf, ", nan2008"); - - if (e_flags & EF_MIPS_FP64) - strcat (buf, ", fp64"); - - switch ((e_flags & EF_MIPS_MACH)) - { - case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break; - case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break; - case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break; - case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break; - case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break; - case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break; - case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break; - case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break; - case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break; - case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break; - case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break; - case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break; - case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break; - case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break; - case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break; - case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break; - case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break; - case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break; - case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break; - case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break; - case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break; - case E_MIPS_MACH_ALLEGREX: strcat(buf, ", allegrex"); break; - case 0: - /* We simply ignore the field in this case to avoid confusion: - MIPS ELF does not specify EF_MIPS_MACH, it is a GNU - extension. */ - break; - default: strcat (buf, _(", unknown CPU")); break; - } - - switch ((e_flags & EF_MIPS_ABI)) - { - case E_MIPS_ABI_O32: strcat (buf, ", o32"); break; - case E_MIPS_ABI_O64: strcat (buf, ", o64"); break; - case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break; - case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); 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; - } - - if (e_flags & EF_MIPS_ARCH_ASE_MDMX) - strcat (buf, ", mdmx"); - - if (e_flags & EF_MIPS_ARCH_ASE_M16) - strcat (buf, ", mips16"); - - if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) - strcat (buf, ", micromips"); - - switch ((e_flags & EF_MIPS_ARCH)) - { - case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break; - case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break; - case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break; - case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break; - case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break; - case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break; - case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break; - case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break; - case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break; - case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break; - case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break; - default: strcat (buf, _(", unknown ISA")); break; - } + out = decode_MIPS_machine_flags (out, e_flags); break; case EM_NDS32: - decode_NDS32_machine_flags (e_flags, buf, sizeof buf); + out = decode_NDS32_machine_flags (out, e_flags); break; case EM_NFP: switch (EF_NFP_MACH (e_flags)) { case E_NFP_MACH_3200: - strcat (buf, ", NFP-32xx"); + out = stpcpy (out, ", NFP-32xx"); break; case E_NFP_MACH_6000: - strcat (buf, ", NFP-6xxx"); + out = stpcpy (out, ", NFP-6xxx"); break; } break; case EM_RISCV: - if (e_flags & EF_RISCV_RVC) - strcat (buf, ", RVC"); - - if (e_flags & EF_RISCV_RVE) - strcat (buf, ", RVE"); - - if (e_flags & EF_RISCV_TSO) - strcat (buf, ", TSO"); - - switch (e_flags & EF_RISCV_FLOAT_ABI) - { - case EF_RISCV_FLOAT_ABI_SOFT: - strcat (buf, ", soft-float ABI"); - break; - - case EF_RISCV_FLOAT_ABI_SINGLE: - strcat (buf, ", single-float ABI"); - break; - - case EF_RISCV_FLOAT_ABI_DOUBLE: - strcat (buf, ", double-float ABI"); - break; - - case EF_RISCV_FLOAT_ABI_QUAD: - strcat (buf, ", quad-float ABI"); - break; - } + out = decode_RISCV_machine_flags (out, e_flags); break; case EM_SH: - switch ((e_flags & EF_SH_MACH_MASK)) - { - case EF_SH1: strcat (buf, ", sh1"); break; - case EF_SH2: strcat (buf, ", sh2"); break; - case EF_SH3: strcat (buf, ", sh3"); break; - case EF_SH_DSP: strcat (buf, ", sh-dsp"); break; - case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break; - case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break; - case EF_SH3E: strcat (buf, ", sh3e"); break; - case EF_SH4: strcat (buf, ", sh4"); break; - case EF_SH5: strcat (buf, ", sh5"); break; - case EF_SH2E: strcat (buf, ", sh2e"); break; - case EF_SH4A: strcat (buf, ", sh4a"); break; - case EF_SH2A: strcat (buf, ", sh2a"); break; - case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break; - case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break; - case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break; - case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break; - case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break; - case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break; - case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break; - case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break; - case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break; - default: strcat (buf, _(", unknown ISA")); break; - } - - if (e_flags & EF_SH_PIC) - strcat (buf, ", pic"); - - if (e_flags & EF_SH_FDPIC) - strcat (buf, ", fdpic"); + out = decode_SH_machine_flags (out, e_flags); break; - case EM_OR1K: - if (e_flags & EF_OR1K_NODELAY) - strcat (buf, ", no delay"); - break; + case EM_OR1K: + if (e_flags & EF_OR1K_NODELAY) + out = stpcpy (out, ", no delay"); + break; - case EM_BPF: - sprintf (buf + strlen (buf), ", CPU Version: %u", - e_flags & EF_BPF_CPUVER); - break; + case EM_BPF: + out += sprintf (out, ", CPU Version: %u", e_flags & EF_BPF_CPUVER); + break; case EM_SPARCV9: - if (e_flags & EF_SPARC_32PLUS) - strcat (buf, ", v8+"); - - if (e_flags & EF_SPARC_SUN_US1) - strcat (buf, ", ultrasparcI"); - - if (e_flags & EF_SPARC_SUN_US3) - strcat (buf, ", ultrasparcIII"); - - if (e_flags & EF_SPARC_HAL_R1) - strcat (buf, ", halr1"); - - if (e_flags & EF_SPARC_LEDATA) - strcat (buf, ", ledata"); - - if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO) - strcat (buf, ", tso"); - - if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO) - strcat (buf, ", pso"); - - if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO) - strcat (buf, ", rmo"); + out = decode_SPARC_machine_flags (out, e_flags); break; case EM_PARISC: - switch (e_flags & EF_PARISC_ARCH) - { - case EFA_PARISC_1_0: - strcpy (buf, ", PA-RISC 1.0"); - break; - case EFA_PARISC_1_1: - strcpy (buf, ", PA-RISC 1.1"); - break; - case EFA_PARISC_2_0: - strcpy (buf, ", PA-RISC 2.0"); - break; - default: - break; - } - if (e_flags & EF_PARISC_TRAPNIL) - strcat (buf, ", trapnil"); - if (e_flags & EF_PARISC_EXT) - strcat (buf, ", ext"); - if (e_flags & EF_PARISC_LSB) - strcat (buf, ", lsb"); - if (e_flags & EF_PARISC_WIDE) - strcat (buf, ", wide"); - if (e_flags & EF_PARISC_NO_KABP) - strcat (buf, ", no kabp"); - if (e_flags & EF_PARISC_LAZYSWAP) - strcat (buf, ", lazyswap"); + out = decode_PARISC_machine_flags (out, e_flags); break; case EM_PJ: case EM_PJ_OLD: if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS) - strcat (buf, ", new calling convention"); + out = stpcpy (out, ", new calling convention"); if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS) - strcat (buf, ", gnu calling convention"); + out = stpcpy (out, ", gnu calling convention"); break; case EM_IA_64: - if ((e_flags & EF_IA_64_ABI64)) - strcat (buf, ", 64-bit"); - else - strcat (buf, ", 32-bit"); - if ((e_flags & EF_IA_64_REDUCEDFP)) - strcat (buf, ", reduced fp model"); - if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP)) - strcat (buf, ", no function descriptors, constant gp"); - else if ((e_flags & EF_IA_64_CONS_GP)) - strcat (buf, ", constant gp"); - if ((e_flags & EF_IA_64_ABSOLUTE)) - strcat (buf, ", absolute"); - if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS) - { - if ((e_flags & EF_IA_64_VMS_LINKAGES)) - strcat (buf, ", vms_linkages"); - switch ((e_flags & EF_IA_64_VMS_COMCOD)) - { - case EF_IA_64_VMS_COMCOD_SUCCESS: - break; - case EF_IA_64_VMS_COMCOD_WARNING: - strcat (buf, ", warning"); - break; - case EF_IA_64_VMS_COMCOD_ERROR: - strcat (buf, ", error"); - break; - case EF_IA_64_VMS_COMCOD_ABORT: - strcat (buf, ", abort"); - break; - default: - warn (_("Unrecognised IA64 VMS Command Code: %x\n"), - e_flags & EF_IA_64_VMS_COMCOD); - strcat (buf, ", "); - } - } + out = decode_IA64_machine_flags (out, e_flags, filedata); break; case EM_VAX: if ((e_flags & EF_VAX_NONPIC)) - strcat (buf, ", non-PIC"); + out = stpcpy (out, ", non-PIC"); if ((e_flags & EF_VAX_DFLOAT)) - strcat (buf, ", D-Float"); + out = stpcpy (out, ", D-Float"); if ((e_flags & EF_VAX_GFLOAT)) - strcat (buf, ", G-Float"); + out = stpcpy (out, ", G-Float"); break; - case EM_VISIUM: + case EM_VISIUM: if (e_flags & EF_VISIUM_ARCH_MCM) - strcat (buf, ", mcm"); + out = stpcpy (out, ", mcm"); else if (e_flags & EF_VISIUM_ARCH_MCM24) - strcat (buf, ", mcm24"); + out = stpcpy (out, ", mcm24"); if (e_flags & EF_VISIUM_ARCH_GR6) - strcat (buf, ", gr6"); + out = stpcpy (out, ", gr6"); break; case EM_RL78: - switch (e_flags & E_FLAG_RL78_CPU_MASK) - { - case E_FLAG_RL78_ANY_CPU: break; - case E_FLAG_RL78_G10: strcat (buf, ", G10"); break; - case E_FLAG_RL78_G13: strcat (buf, ", G13"); break; - case E_FLAG_RL78_G14: strcat (buf, ", G14"); break; - } - if (e_flags & E_FLAG_RL78_64BIT_DOUBLES) - strcat (buf, ", 64-bit doubles"); + out = decode_RL78_machine_flags (out, e_flags); break; case EM_RX: - if (e_flags & E_FLAG_RX_64BIT_DOUBLES) - strcat (buf, ", 64-bit doubles"); - if (e_flags & E_FLAG_RX_DSP) - strcat (buf, ", dsp"); - if (e_flags & E_FLAG_RX_PID) - strcat (buf, ", pid"); - if (e_flags & E_FLAG_RX_ABI) - strcat (buf, ", RX ABI"); - if (e_flags & E_FLAG_RX_SINSNS_SET) - strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES - ? ", uses String instructions" : ", bans String instructions"); - if (e_flags & E_FLAG_RX_V2) - strcat (buf, ", V2"); - if (e_flags & E_FLAG_RX_V3) - strcat (buf, ", V3"); + out = decode_RX_machine_flags (out, e_flags); break; case EM_S390: if (e_flags & EF_S390_HIGH_GPRS) - strcat (buf, ", highgprs"); + out = stpcpy (out, ", highgprs"); break; case EM_TI_C6000: if ((e_flags & EF_C6000_REL)) - strcat (buf, ", relocatable module"); + out = stpcpy (out, ", relocatable module"); break; case EM_MSP430: - strcat (buf, _(": architecture variant: ")); - switch (e_flags & EF_MSP430_MACH) - { - case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break; - case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break; - case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break; - case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break; - case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break; - case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break; - case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break; - case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break; - case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break; - case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break; - case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break; - case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break; - case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break; - case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break; - case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break; - default: - strcat (buf, _(": unknown")); break; - } - - if (e_flags & ~ EF_MSP430_MACH) - strcat (buf, _(": unknown extra flag bits also present")); + out = decode_MSP430_machine_flags (out, e_flags); break; case EM_Z80: - switch (e_flags & EF_Z80_MACH_MSK) - { - case EF_Z80_MACH_Z80: strcat (buf, ", Z80"); break; - case EF_Z80_MACH_Z180: strcat (buf, ", Z180"); break; - case EF_Z80_MACH_R800: strcat (buf, ", R800"); break; - case EF_Z80_MACH_EZ80_Z80: strcat (buf, ", EZ80"); break; - case EF_Z80_MACH_EZ80_ADL: strcat (buf, ", EZ80, ADL"); break; - case EF_Z80_MACH_GBZ80: strcat (buf, ", GBZ80"); break; - case EF_Z80_MACH_Z80N: strcat (buf, ", Z80N"); break; - default: - strcat (buf, _(", unknown")); break; - } + out = decode_Z80_machine_flags (out, e_flags); break; - case EM_LOONGARCH: - if (EF_LOONGARCH_IS_SOFT_FLOAT (e_flags)) - strcat (buf, ", SOFT-FLOAT"); - else if (EF_LOONGARCH_IS_SINGLE_FLOAT (e_flags)) - strcat (buf, ", SINGLE-FLOAT"); - else if (EF_LOONGARCH_IS_DOUBLE_FLOAT (e_flags)) - strcat (buf, ", DOUBLE-FLOAT"); - - if (EF_LOONGARCH_IS_OBJ_V0 (e_flags)) - strcat (buf, ", OBJ-v0"); - else if (EF_LOONGARCH_IS_OBJ_V1 (e_flags)) - strcat (buf, ", OBJ-v1"); + case EM_LOONGARCH: + out = decode_LOONGARCH_machine_flags (out, e_flags); break; } } @@ -6885,11 +7220,8 @@ get_elf_section_flags (Filedata * filedata, uint64_t sh_flags) }; if (do_section_details) - { - sprintf (buff, "[%*.*lx]: ", - field_size, field_size, (unsigned long) sh_flags); - p += field_size + 4; - } + p += sprintf (p, "[%*.*lx]: ", + field_size, field_size, (unsigned long) sh_flags); while (sh_flags) { @@ -7085,10 +7417,9 @@ get_elf_section_flags (Filedata * filedata, uint64_t sh_flags) { if (os_flags) { - size -= 5 + field_size; if (p != buff + field_size + 4) { - if (size < (2 + 1)) + if (size < 2 + 5 + field_size + 1) { warn (_("Internal error: not enough buffer room for section flag info")); return _(""); @@ -7097,16 +7428,15 @@ get_elf_section_flags (Filedata * filedata, uint64_t sh_flags) *p++ = ','; *p++ = ' '; } - sprintf (p, "OS (%*.*lx)", field_size, field_size, - (unsigned long) os_flags); - p += 5 + field_size; + size -= 5 + field_size; + p += sprintf (p, "OS (%*.*lx)", field_size, field_size, + (unsigned long) os_flags); } if (proc_flags) { - size -= 7 + field_size; if (p != buff + field_size + 4) { - if (size < (2 + 1)) + if (size < 2 + 7 + field_size + 1) { warn (_("Internal error: not enough buffer room for section flag info")); return _(""); @@ -7115,16 +7445,15 @@ get_elf_section_flags (Filedata * filedata, uint64_t sh_flags) *p++ = ','; *p++ = ' '; } - sprintf (p, "PROC (%*.*lx)", field_size, field_size, - (unsigned long) proc_flags); - p += 7 + field_size; + size -= 7 + field_size; + p += sprintf (p, "PROC (%*.*lx)", field_size, field_size, + (unsigned long) proc_flags); } if (unknown_flags) { - size -= 10 + field_size; if (p != buff + field_size + 4) { - if (size < (2 + 1)) + if (size < 2 + 10 + field_size + 1) { warn (_("Internal error: not enough buffer room for section flag info")); return _(""); @@ -7133,9 +7462,9 @@ get_elf_section_flags (Filedata * filedata, uint64_t sh_flags) *p++ = ','; *p++ = ' '; } - sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size, - (unsigned long) unknown_flags); - p += 10 + field_size; + size -= 10 + field_size; + p += sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size, + (unsigned long) unknown_flags); } }