Is the program 32 or 64 bits?

Question

Assignment is simple to explain: write the shortest code you need to determine whether an executable binary program supplied as parameter is 32 or 64 bits.

If there is a different kind of bitness, you can also do for it, but is not mandatory.

What I really don't want is telling me you support other bitnesses and after I get 32 or 64 as a result.

Valid outputs for 32:

32
32bit
32bits
32 bit
32 bits

The same pattern for 64.

No accepted answer.

Answer 1

Jelly on Linux, 6 bytes

5ịO×32

Try it online!

Usage note: the question says "write the shortest code you need to determine whether an executable binary program supplied as parameter", and that's exactly what you need to do here; supply the entire executable binary program as the parameter. Not its filename, the program itself. (I hope you have a fairly understanding shell!) The TIO link uses the shortest known ELF program Linux will run, by Brian Raiter as the example program.

Linux uses ELF as its executable format. It turns out that the fifth byte of an ELF program specifies the processor bitwidth it's designed for: 0x01 for a 32-bit program, or 0x02 for a 64-bit program. So all we have to do is extract the byte in question (5ị), convert it from a character to a number (O), and multiply by 32 (×32).

There's probably a language that can use this exact algorithm more succinctly, but I wanted to post this answer to demonstrate the algorithm.

Answer 2

Bash + common Linux utils, 18

• 2 byte saved thanks to @Dennis.

file -|cut -c17-18

The input program piped in.

Try it online!

Answer 3

MATL (Linux), 5 bytes

5)32*

Implicitly input entire program. Get fifth byte, multiply by 32.

Try it online!

---

As a bonus, here's an answer that works on most (but not all) Windows executables, for 20 bytes:

t'PE'Xf1)4+)100=Q32*

Try it online!

Find the PE signature (which would fail if there's an unusual DOS stub containing PE) and see if it is followed by d (100) two bytes later (which corresponds to x64, and thus would fail for other 64 bit architectures)

Answer 4

GolfScript for ELF (5 bytes)

4=32*

CJam for ELF (6 bytes)

q4=32*

or

q4=5m<

---

This is why I commented in the sandbox that "challenge" was not an appropriate description of this task.

Answer 5

Windows Bash (with core util?), test PE32 vs PE32+; 37 bytes

file $1|grep -q 2+&&echo 64||echo 32

This is a bash script works on Windows Bash (bash in Ubuntu Linux Subsystem on Windows 10), which tell given *.exe file 32 bit or 64 bit.

Not yet tested on other platform, maybe it work.

Answer 6

Jelly (Windows), 24 bytes

ƈO
Ç64СUḣ4%⁹ḅ⁹_38ǹ¡×32

Hexdump:

00000000: 9c4f 7f0e 3634 0f00 55ed 3425 89d4 895f  .O..64..U.4%..._
00000010: 3338 0e81 0011 3332                      38....32

I have no idea why %⁹ is necessary, but it is.

Takes the whole executable from STDIN. Take from command line argument would definitely shorter but there is a (small) upper bound on the size.

Yes, Windows PE executable format is hard to parse. Also Jelly hates non-constant nilad.

---

ƈO

Link 1: Return the next byte value from stdin.

Ç64СUḣ4%⁹ḅ⁹

Read the 4-byte e_lfanew at offset 60 and convert it to an integer.

_38ǹ¡

Take the byte at (e_lfanew - 38) positions later which is the higher byte of the signature in the PE optional header, described here at the "optional header magic number" part.

×32

Multiply by 32. Get 32 for 32-bit executables (PE32) and 64 for PE32+.

Answer 7

Haskell, 36 35 bytes

fmap((32*).fromEnum.(!!4)).readFile

For the ELF format

Try it online!

Answer 8

Ruby -n, 23 bytes

p IO.read($_)[4].ord*32

Try it online!

Linux ELF version. TIO link tests the interpreter on itself.

Answer 9

Bash, 36 bytes

cp $1 x
file x|egrep -o '32|64'|uniq

Try 64 bits online!

Try 32 bits online!