New answer (C++20) c++20 has introduced a new standard library header <bit>. Among other things it provides a clean, portable way to check the endianness. Since my old method relies on some questionable techniques, I suggest anyone who uses it to switch to the check provided by the standard library. Here’s an adapter which allows … Read more
One method is to use the struct module: def swap32(i): return struct.unpack(“<I”, struct.pack(“>I”, i))[0] First you pack your integer into a binary format using one endianness, then you unpack it using the other (it doesn’t even matter which combination you use, since all you want to do is swap endianness).
As stated earlier, the only “real” way to detect Big Endian is to use runtime tests. However, sometimes, a macro might be preferred. Unfortunately, I’ve not found a single “test” to detect this situation, rather a collection of them. For example, GCC recommends : __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ . However, this only works with latest versions, … Read more
If you’re using autoconf, you can use the AC_C_BIGENDIAN macro, which is fairly guaranteed to work (setting the WORDS_BIGENDIAN define by default) alternately, you could try something like the following (taken from autoconf) to get a test that will probably be optimized away (GCC, at least, removes the other branch) int is_big_endian() { union { … Read more
If you have access to an x86-based Mac then you can take advantage of the fact that Mac OS X has PowerPC emulation built in as well as developer tool support for both x86 (little endian) and PowerPC (big endian). This enables you to compile and run a big and little endian executable on the … Read more
A bit late to the party but with current GCC (tested on 6.2.1 where it works and 4.9.2 where it’s not implemented) there is finally a way to declare that a struct should be kept in X-endian byte order. The following test program: #include <stdio.h> #include <stdint.h> struct __attribute__((packed, scalar_storage_order(“big-endian”))) mystruct { uint16_t a; uint32_t … Read more
Multibyte data in the class files are stored big-endian. From The Java Virtual Machine Specification, Java SE 7 Edition, Chapter 4: The class File Format: A class file consists of a stream of 8-bit bytes. All 16-bit, 32-bit, and 64-bit quantities are constructed by reading in two, four, and eight consecutive 8-bit bytes, respectively. Multibyte … Read more
All x86 and x86-64 machines (which is just an extension to x86) are little-endian. You can confirm it with something like this: #include <stdio.h> int main() { int a = 0x12345678; unsigned char *c = (unsigned char*)(&a); if (*c == 0x78) { printf(“little-endian\n”); } else { printf(“big-endian\n”); } return 0; }
The only time you have to care about endianness is when you’re transferring endian-sensitive binary data (that is, not text) between systems that might not have the same endianness. The normal solution is to use “network byte order” (AKA big-endian) to transfer data, and then swizzle the bytes if necessary on the other end. To … Read more
You could use a memcpy (Result) float f; uchar b[] = {b3, b2, b1, b0}; memcpy(&f, &b, sizeof(f)); return f; or a union* (Result) union { float f; uchar b[4]; } u; u.b[3] = b0; u.b[2] = b1; u.b[1] = b2; u.b[0] = b3; return u.f; But this is no more portable than your code, … Read more