From a9522a2168c8233e8f15c42a32e7376c2a40ac12 Mon Sep 17 00:00:00 2001 From: Andrew Burgess Date: Tue, 15 Mar 2016 21:38:30 +0000 Subject: arc: Remove EF_ARC_CPU_GENERIC constant. The constant EF_ARC_CPU_GENERIC is defined in the include/elf/arc.h file, and is used in a few places in binutils, however, this constant should never make it into the elf header flags; we always set a valid cpu type in the assembler, which should then be copied over during linking. There are some non-gnu arc compilers that don't write an architecture type into the e_flags field, instead leaving the field as 0, which is the EF_ARC_CPU_GENERIC value. This non-gnu compiler uses the machine type to distinguish between the old and newer arc architectures, setting the machine type to EM_ARC_COMPACT for old arc600, arc601, and arc700 architectures, while using EM_ARC_COMPACT2 for newer arcem and archs architectures. Previously when displaying the machine flags for an older EM_ARC_COMPACT machine, if the e_flags had not been filled in, then we relied on the default case statement to display the message "Generic ARCompact", while in the EM_ARC_COMPACT2 case we specifically handled EF_ARC_CPU_GENERIC to print "ARC Generic", leaving the default case to print a message about unrecognised cpu flag. After this commit EF_ARC_CPU_GENERIC has been removed, for both machine types EM_ARC_COMPACT and EM_ARC_COMPACT2 we now rely on the default case statement to handle the situation where the e_flags has not been filled in. The message displayed is now "Unknown ARCompact" (for older arc architectures) and "Unknown ARC" (for the newer architectures). The switch from "Generic" to "Unknown" in the message string is for clarity, calling the file "Generic" can give the impression that the file is compiled for a common sub-set of the architectures, and would therefore run on any type of machine (or at least any type of new or old machine depending on if the machine type is ARC or ARCv2). However, this was not what "Generic" meant, it really meant "Unknown", so that's what we now say. As part of the merging of the readelf flag reading code, I have unified the strings used in displaying the ELF ABI. This means that for older arc machines (arc600, arc601, and arc700) the string used for the original ABI, and ABIv2 have changed, the current ABIv3 remains the same. For the newer architectures (arcem and archs) the abi strings remain unchanged in all cases. bfd/ChangeLog: * elf32-arc.c (arc_elf_print_private_bfd_data): Remove use of EF_ARC_CPU_GENERIC. (arc_elf_final_write_processing): Don't bother setting cpu field in e_flags, this will have been set elsewhere. binutils/ChangeLog: * readelf.c (get_machine_flags): Move arc processing into... (decode_ARC_machine_flags): ... new function. Remove use of EF_ARC_CPU_GENERIC, change default case from "generic arc" to "unknown arc". Merged ABI printing between two machine types. gas/ChangeLog: * config/tc-arc.c (arc_select_cpu): Remove use of EF_ARC_CPU_GENERIC. include/ChangeLog: * elf/arc.h (EF_ARC_CPU_GENERIC): Delete. Update related comment. --- binutils/ChangeLog | 7 +++ binutils/readelf.c | 143 ++++++++++++++++++++++++++--------------------------- 2 files changed, 76 insertions(+), 74 deletions(-) (limited to 'binutils') diff --git a/binutils/ChangeLog b/binutils/ChangeLog index 7ba4560..c71ba3f 100644 --- a/binutils/ChangeLog +++ b/binutils/ChangeLog @@ -1,5 +1,12 @@ 2016-03-21 Andrew Burgess + * readelf.c (get_machine_flags): Move arc processing into... + (decode_ARC_machine_flags): ... new function. Remove use of + EF_ARC_CPU_GENERIC, change default case from "generic arc" to + "unknown arc". Merged ABI printing between two machine types. + +2016-03-21 Andrew Burgess + * testsuite/binutils-all/objdump.exp (cpus_expected): Add ARC700 to the architecture list. diff --git a/binutils/readelf.c b/binutils/readelf.c index 7deac04..fe23d45 100644 --- a/binutils/readelf.c +++ b/binutils/readelf.c @@ -2271,6 +2271,73 @@ get_machine_name (unsigned e_machine) } static void +decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[]) +{ + /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some + other compilers don't a specific architecture type in the e_flags, and + instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700 + architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS + architectures. + + Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2, + but also sets a specific architecture type in the e_flags field. + + However, when decoding the flags we don't worry if we see an + unexpected pairing, for example EM_ARC_COMPACT machine type, with + ARCEM architecture type. */ + + switch (e_flags & EF_ARC_MACH_MSK) + { + /* We only expect these to occur for EM_ARC_COMPACT2. */ + case EF_ARC_CPU_ARCV2EM: + strcat (buf, ", ARC EM"); + break; + case EF_ARC_CPU_ARCV2HS: + strcat (buf, ", ARC HS"); + break; + + /* We only expect these to occur for EM_ARC_COMPACT. */ + case E_ARC_MACH_ARC600: + strcat (buf, ", ARC600"); + break; + case E_ARC_MACH_ARC601: + strcat (buf, ", ARC601"); + break; + case E_ARC_MACH_ARC700: + strcat (buf, ", ARC700"); + break; + + /* The only times we should end up here are (a) A corrupt ELF, (b) A + new ELF with new architecture being read by an old version of + readelf, or (c) An ELF built with non-GNU compiler that does not + set the architecture in the e_flags. */ + default: + if (e_machine == EM_ARC_COMPACT) + strcat (buf, ", Unknown ARCompact"); + else + strcat (buf, ", Unknown ARC"); + break; + } + + switch (e_flags & EF_ARC_OSABI_MSK) + { + case E_ARC_OSABI_ORIG: + strcat (buf, ", (ABI:legacy)"); + break; + case E_ARC_OSABI_V2: + strcat (buf, ", (ABI:v2)"); + break; + /* Only upstream 3.9+ kernels will support ARCv2 ISA. */ + case E_ARC_OSABI_V3: + strcat (buf, ", v3 no-legacy-syscalls ABI"); + break; + default: + strcat (buf, ", unrecognised ARC OSABI flag"); + break; + } +} + +static void decode_ARM_machine_flags (unsigned e_flags, char buf[]) { unsigned eabi; @@ -2768,81 +2835,9 @@ get_machine_flags (unsigned e_flags, unsigned e_machine) break; case EM_ARC_COMPACT2: - switch (e_flags & EF_ARC_MACH_MSK) - { - case EF_ARC_CPU_ARCV2EM: - strcat (buf, ", ARC EM"); - break; - case EF_ARC_CPU_ARCV2HS: - strcat (buf, ", ARC HS"); - break; - case EF_ARC_CPU_GENERIC: - strcat (buf, ", ARC generic"); - break; - case E_ARC_MACH_ARC600: - strcat (buf, ", ARC600"); - break; - case E_ARC_MACH_ARC601: - strcat (buf, ", ARC601"); - break; - case E_ARC_MACH_ARC700: - strcat (buf, ", ARC700"); - break; - default: - strcat (buf, ", unrecognized cpu flag for ARCv2"); - break; - } - switch (e_flags & EF_ARC_OSABI_MSK) - { - case E_ARC_OSABI_ORIG: - strcat (buf, ", (ABI:legacy)"); - break; - case E_ARC_OSABI_V2: - strcat (buf, ", (ABI:v2)"); - break; - /* Only upstream 3.9+ kernels will support ARCv2 ISA. */ - case E_ARC_OSABI_V3: - strcat (buf, ", v3 no-legacy-syscalls ABI"); - break; - default: - strcat (buf, ", unrecognised ARC OSABI flag"); - break; - } - break; - case EM_ARC_COMPACT: - switch (e_flags & EF_ARC_MACH_MSK) - { - case E_ARC_MACH_ARC600: - strcat (buf, ", ARC 600"); - break; - case E_ARC_MACH_ARC601: - strcat (buf, ", ARC 601"); - break; - case E_ARC_MACH_ARC700: - strcat (buf, ", ARC 700"); - break; - default: - strcat (buf, ", Generic ARCompact"); - break; - } - switch (e_flags & EF_ARC_OSABI_MSK) - { - case E_ARC_OSABI_ORIG: - strcat (buf, ", legacy syscall ABI"); - break; - case E_ARC_OSABI_V2: - /* For 3.2+ Linux kernels which use asm-generic - hdrs. */ - strcat (buf, ", v2 syscall ABI"); - break; - case E_ARC_OSABI_V3: - /* Upstream 3.9+ kernels which don't use any legacy - syscalls. */ - strcat (buf, ", v3 no-legacy-syscalls ABI"); - break; - } - break; + decode_ARC_machine_flags (e_flags, e_machine, buf); + break; case EM_ARM: decode_ARM_machine_flags (e_flags, buf); -- cgit v1.1