Predefined macros in C/C++ that tell you what the target processor is.

These are the predefined macros that C/C++ compilers define to tell you what type of processor the target processor, for which code is being generated, is. There are also predefined macros in C/C++ that tell you the compiler, predefined macros in C/C++ that tell you the target platform and predefined macros in C/C++ that tell you what language features are available.

Non-model-specific macros that describe the processor in terms of its features

The point of the order macros is that they enable feature tests of the form:

#if __BYTE_ORDER__ && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)

	// ... little-endian code

#endif

The fact that they are non-zero when defined means that you can employ the zero value case to determine whether the feature test is available in the first place. The C++ language standard mandates that the value of an identifier that isn't a macro, in a controlling expression for conditional compilation, is zero, remember.

Macros that are specific to Intel Architecture processor targets

Intel Architecture conditional compilation

A consistent, robust, and portable way to differentiate amongst the different Intel Architecture targets is tricky.

OpenWatcom provides a simple differentiation. Its compiler for 16-bit targets defines __I86__ and _M_I86, and its compiler for 32-bit targets defines __386__ and _M_I386. Both compilers define __X86__ and _M_IX86, with the latter indicating what instruction set is being used. (Remember that the new instructions specific to the 80486 and Pentium are available in both 16-bit and 32-bit code.) This would be a fairly straightforward scheme:

// This is OpenWatcom's scheme.
#if __X86_64__

	// It's the x86-64/IA32e architecture.

#elif __X86__
	// It's an x86 architecture of some kind:
#  if __386__ || _M_I386

	// Using the compiler for 32-bit targets, wpp386 or wcc386, so must be x86-32.
#    if _M_IX86 >= 600
		// Pentium Pro instructions and instruction scheduling
#    elif _M_IX86 >= 500
		// Pentium instructions and instruction scheduling
#    elif _M_IX86 >= 400
		// 80486 instructions and instruction scheduling
#    elif _M_IX86 >= 300
		// 80386 instructions and instruction scheduling
#    else
		// This is not possible with the 32-bit compiler.
#    endif

#  elif __I86__ || _M_I86

	// Using the compiler for 16-bit targets, wpp or wcc, so must be x86-16.
#    if _M_IX86 >= 600
		// Pentium Pro instructions and instruction scheduling
#    elif _M_IX86 >= 500
		// Pentium instructions and instruction scheduling
#    elif _M_IX86 >= 400
		// 80486 instructions and instruction scheduling
#    elif _M_IX86 >= 300
		// 80386 instructions and instruction scheduling
#    elif _M_IX86 >= 200
		// 80286 instructions and instruction scheduling
#    elif _M_IX86 >= 100
		// 80186 instructions and instruction scheduling
#    else
		// 8086 instructions and instruction scheduling
#    endif

#  endif
#endif

That is, it would be simple, if everyone else followed the same scheme. But they don't. DigitalMars always defines the _M_I86 macro, even for 32-bit targets, and doesn't define __386__ or _M_I386 at all. DigitalMars doesn't support anything other than 16-bit and 32-bit targets:

// This is DigitalMars' scheme.
#if defined(_M_IX86)

	// It must be the x86-32 architecture.
#    if _M_IX86 >= 600
		// Pentium Pro instructions and instruction scheduling
#    elif _M_IX86 >= 500
		// Pentium instructions and instruction scheduling
#    elif _M_IX86 >= 400
		// 80486 instructions and instruction scheduling
#    elif _M_IX86 >= 300
		// 80386 instructions and instruction scheduling
#    else
		// This is not possible with the 32-bit compiler.
#    endif

#else

	// It must be the x86-16 architecture.
#    if _M_I286
		// 80286 instructions and instruction scheduling
#    elif _M_I8086
		// 8086 instructions and instruction scheduling
#    else
		// This is not possible with the 16-bit compiler.
#    endif

#endif

Microsoft's C++ compiler, similarly, doesn't define __I86__, _M_I86, __386__, or _M_I386 at all, and only defines _M_IX86. Since Microsoft's C++ compiler doesn't even allow for the possibility of 16-bit targets, is scheme is somewhat different:

// This is Microsoft's scheme.
#if _M_IA64

	// It's the Itanium/IA64 architecture.

#elif _M_X64 /*Modern macro*/ \
   || _M_AMD64 /*Older macro with a vendor-specific name*/

	// It's the x86-64 architecture.

#elif _M_IX86

	// It's the x86-32 architecture.
#    if _M_IX86 >= 600
		// Pentium Pro instructions and instruction scheduling
#    elif _M_IX86 >= 500
		// Pentium instructions and instruction scheduling
#    elif _M_IX86 >= 400
		// 80486 instructions and instruction scheduling
#    elif _M_IX86 >= 300
		// 80386 instructions and instruction scheduling
#    else
		// This is not possible with the 32-bit compiler.
#    endif

#else

	// … _M_PPC, _M_RX000, and _M_ALPHA indicate non-Intel
	// architectures that are no longer available as targets.

#endif

Worse, GCC, Clang, and Intel's C++ compiler don't define any of these nine macros. Instead, they have an alternative scheme of their own, using a completely disjoint set of macros (note the lowercase spellings instead of uppercase) that are — just to make the incompatibility symmetrical — not defined at all by OpenWatcom, Microsoft's C++ compiler, or DigitalMars:

// This is the scheme for GCC, Clang, and Intel's compiler.
#if defined(__ia64__)

        // ... Itanium/IA64

#if defined(__x86_64__)

	// ... x86-64/IA32e

#elif defined(__i386__)

	// ... x86-32

#endif

Combining these into a single, portable, conditional compilation that works on all of the compilers makes quite a mess:

#if defined(__IA64__) \
 || _M_IA64 /*MSVC++*/ \
 || defined(__ia64__) /*GCC,Clang,Intel*/

        // ... Itanium/Intel Architecture 64

#elif __X86_64__ /*OpenWatcom*/ \
   || _M_X64 /*MSVC++*/ \
   || _M_AMD64 /*MSVC++ compatibility with older compilers*/ \
   || defined(__x86_64__) /*GCC,Clang,Intel*/

	// ... x86-64/IA32e

#elif __386__ || _M_I386 /*OpenWatcom*/ \
   || (defined(__DMC__) && defined(_M_IX86)) /*DigitalMars*/ \
   || (defined(_MSC_VER) && _M_IX86) /*MSVC++*/ \
   || defined(__i386__) /*GCC,Clang,Intel*/

	// ... x86-32
#    if _M_IX86 >= 600
		// Pentium Pro instructions and instruction scheduling
#    elif _M_IX86 >= 500
		// Pentium instructions and instruction scheduling
#    elif _M_IX86 >= 400
		// 80486 instructions and instruction scheduling
#    elif _M_IX86 >= 300
		// 80386 instructions and instruction scheduling
#    else
		// This must be GCC or Clang.
#    endif

#  elif __I86__ || _M_I86 /*OpenWatcom*/ \
   || (defined(__DMC__) && !defined(_M_IX86)) /*DigitalMars*/

	// ... x86-16
#    if _M_IX86 >= 600
		// Pentium Pro instructions and instruction scheduling
#    elif _M_IX86 >= 500
		// Pentium instructions and instruction scheduling
#    elif _M_IX86 >= 400
		// 80486 instructions and instruction scheduling
#    elif _M_IX86 >= 300
		// 80386 instructions and instruction scheduling
#    elif _M_IX86 >= 200 || _M_I286
		// 80286 instructions and instruction scheduling
#    elif _M_IX86 >= 100
		// 80186 instructions and instruction scheduling
#    else
		// 8086 instructions and instruction scheduling
#    endif

#endif

Macros for other than Intel Architecture processor targets