3

I have rootfs and klibc file systems. I am creating make rules and some developers have an older compiler without inter-networking.note1 I am trying to verify that all the files get built with arm only when a certain version of the compiler is detected. I have re-built the tree's several times. I was using readelf -A and looking for Tag_THUMB_ISA_use: Thumb-1, but this seem to be in arm only code (but was built with the interworking compiler) as well as thumb code. I can manually run objdump -S and examine the assembler to determine what instruction set is in use.

However, it would be much easier if I had a script/tool predicate so that find, etc can be used to search through the shadow file systems to look for binaries that may have been missed. I thought that some of this information would be in the ELF header and accessible via objdump or readelf, but I haven't found anything reliable.

Specifically I am looking for,

  1. Compiled 'C' that wouldn't run without a CONFIG_ARM_THUMB Linux system.
  2. make rules that use 'C' compiler flags that choke a non-thumb compilers.

note1: Interworking allow easy switching between thumb and arm modes, and the compiler will automatically generate code to support calling from either mode.

artless noise
  • 21,212
  • 6
  • 68
  • 105

2 Answers2

5

The readelf -A output doesn't describe the elf contents. It just describes the capabilities of the processor and or system that is expected or fed to the compiler. As I have an ARM926 CPU which is an ARMV5TEJ processor, gcc/ld will always set Tag_THUMB_ISA_use: Thumb-1 as it just means that ARMV5TEJ is recognized as being Thumb-1 capable. It says nothing about the code itself.

Examining the Linux arch/arm/kernel/elf.c routine elf_check_arch() shows a check for x->e_entry & 1. This leads to the following script,

readelf -h $1 | grep -q Entry.*[13579bdf]$

Ie, just look at the initial ELF entry value and see if the low bit is set. This is a fast check that fits the spirit of what I am looking for. unixsmurf has a good point that the code inside any ELF can mix and match ARM and Thumb. This maybe ok, if the program dynamically ids the CPU and selects an appropriate routine. Ie, just the presence of a Thumb instruction doesn't mean that code will execute.

Just looking at the entry value does determine which gcc compiler flags were used, at least for gcc versions 4.6 to 4.7.

artless noise
  • 21,212
  • 6
  • 68
  • 105
  • This answer tells you if `gcc -mthumb` or the like was used. We can always mix instructions sets (that is what inter-networking is about), but the *entry* will be the primary mode used by the compiler. A compiler could theoretically generate both types of instructions, but generally they don't. – artless noise Jan 03 '14 at 17:29
4

Since thumb and arm sequences can be freely interchanged within an object file, even within the same section, plain ELF header inspection is not going to help you whether a file includes Thumb instructions or not.

A slightly roundabout and still not 100% foolproof way would be to use readelf -r and check if the output contains "R_ARM_THM", indicating a relocation for thumb.

unixsmurf
  • 5,852
  • 1
  • 33
  • 40
  • This is useful, I thought about the "ARM or Thumb" issue. I guess I want to know if it was compiled for **Thumb**; I wasn't anticipating hand-coded assembler. `for i in *; do readelf -r $i | grep -q 'no relocations' || echo $i; done` returns nothing with **klibc**. I guess they don't have any relocation, which will make loading faster. – artless noise Apr 10 '13 at 16:32