Is there a standard way to determine at compile-time if system is 32 or 64 bit?

Question

I need to set #ifdef - checks for conditional compile. I want to automate the process but cannot specify the target OS/machine. Is there some way that the pre-compiler can resolve whether it it is running on 32-bit or 64-bit?

(Explanation) I need to define a type that is 64 bits in size. On 64bit OS it is a long, on most others it is a long long.

I found this answer - is this the correct way to go?

[edit] a handy reference for compiler macros

What exactly is your definition of a 64-bit system? (This is a serious question) — NPE, Jul 15 '11 at 11:06
So do you want the code to compile the code as 32-bit if the compiler is running on a 32-bit machine or 64-bit if the compiler is running on a 64-bit machine? I don't quite understand your question. Also I find it rather difficult to believe that you cannot specify the target OS/machine, especially if you're the one compiling the source. — In silico, Jul 15 '11 at 11:08
There is no standard define for the 'bitness' of the target system in the pre-compiler. You either have to pass your own, or rely on those defined by the compiler itself. E.g. _WIN64 — Christopher, Jul 15 '11 at 11:14

Puppy · Accepted Answer · 2011-07-15T11:57:40.280

10

The only compile check you can do reliably would be sizeof(void*) == 8, true for x64 and false for x86. This is a constexpr and you can pass it to templates but you can forget using ifdef with it. There is no platform-independent way to know the address size of the target architecture (at pre-process time), you will need to ask your IDE for one. The Standard doesn't even have the concept of the address size.

edited Jul 15 '11 at 11:57

answered Jul 15 '11 at 11:11

Puppy

144,682
38
256
465

good suggestion re templates, I think that will be the way to go, safest anyway. – slashmais Jul 15 '11 at 11:29

score 4 · Answer 2 · answered Jul 15 '11 at 11:11

4

No there is no standard language support for macro to determine if the machine is a 64-bit or 32-bit at preprocessor stage.

answered Jul 15 '11 at 11:11

iammilind

68,093
33
169
336

In silico · Answer 3 · 2011-07-15T11:30:57.347

4

In response to your edit, there is a "macro-less for you" way to get a type that is 64 bits.

if you need a type that can hold 64 bits, then #include <cstdint> and use either int64_t or uint64_t. You can also use the Standard Integer Types provided by Boost.

Another option is to use long long. It's technically not part of the C++ standard (it will be in C++0x) but is supported on just about every compiler.

edited Jul 15 '11 at 11:30

answered Jul 15 '11 at 11:24

In silico

51,091
10
150
143

rubenvb · Answer 4 · 2019-04-02T07:06:55.800

2

Boost has absorbed the old Predef project. You'll want the architecture macros, more specifically BOOST_ARCH_X86_32/BOOST_ARCH_X86_64, assuming you only care about x86.

If you need a wider detection (e.g. ARM64), either add the relevant macro's to your check, or check what you actually want to check, e.g.

sizeof(void*) == 8

edited Apr 02 '19 at 07:06

answered Jul 15 '11 at 11:22

rubenvb

74,642
33
187
332

This is the problem with link-only answers: the link is dead, and I have no idea how to solve my problem using this "answer". – Violet Giraffe Mar 31 '19 at 15:55

score 2 · Answer 5 · answered Jul 15 '11 at 12:35

I would look at source code for a cross-platform library. It is a quite large part. Every pair of OS and compiler has own set of definitions. Few libraries You may look at:
http://www.libsdl.org/ \include\SDL_config*.h (few files)
http://qt.nokia.com/ \src\corelib\global\qglobal.h

score 1 · Answer 6 · answered Jul 15 '11 at 11:10

1

Well, the answer is clearly going to be OS-specific, so you need to narrow down your requirements.

For example, on Unix uname -a typically gives enough info to distinguish a 32-bit build of the OS from a 64-bit build.

The command can be invoked by your pre-compiler. Depending on its output, compiler flags can be set appropriately.

answered Jul 15 '11 at 11:10

NPE

486,780
108
951
1,012

that's not a compile time check either – Karoly Horvath Jul 15 '11 at 11:10
Or use a symbol from `gcc -dM -E - < /dev/null`. – lhf Jul 15 '11 at 11:14

score 0 · Answer 7 · answered Jul 15 '11 at 11:30

I would be tempted to hoist the detection out of the code and put that into the Makefile. Then, you can leverage system tools to detect and set the appropriate macro upon which you are switching in your code.

In your Makefile ...

<do stuff to detect and set SUPPORT_XX_BIT to the appropriate value>
gcc myFile.c -D$(SUPPORT_XX_BIT) -o myFile

In your code ...

#if defined(SUPPORT_32_BIT)
...
#elif defined(SUPPORT_64_BIT)
...
#else
    #error "Select either 32 or 64 bit option\n"
#endif

AlefSin · Answer 8 · 2011-07-15T11:41:11.003

-2

Probably the easiest way might be comparing the size of int and long long. You cannot do it in the pre-processor though but you can use it in static_assert.

Edit: WoW all the negative votes. I made my point a bit more clear. Also it appears I should have mentioned 'long long' rather than 'long' because of the way MSVC works.

edited Jul 15 '11 at 11:41

answered Jul 15 '11 at 11:06

AlefSin

1,086
9
20

Perhaps you mean INT_MAX and LONG_MAX? – lhf Jul 15 '11 at 11:09
On MSVC both int and long are 32bits on a 64bit target. – Puppy Jul 15 '11 at 11:10
@Oli: yep, I know you cannot use sizeof with preprocessor. I was thinking more about `static_assert`. – AlefSin Jul 15 '11 at 11:39
@AlefSin: My complaint was based more on the fact that `int` and `long` are often the same size as each other. – Oliver Charlesworth Jul 15 '11 at 11:41

Is there a standard way to determine at compile-time if system is 32 or 64 bit?

8 Answers8

Linked