How to check whether a system is big endian or little endian?

Question

How to check whether a system is big endian or little endian?

Answer 1

In Java:

import java.nio.ByteOrder;

public class EndiannessCheck {
    public static void main(String[] args) {
        ByteOrder byteOrder = ByteOrder.nativeOrder();
        if (byteOrder.equals(ByteOrder.LITTLE_ENDIAN)) {
            System.out.println("Little Endian");
        } else {
            System.out.println("Big Endian");
        }
    }
}

Answer 2

In case if you want to check it on a linux machine you can use below mentioned cmd

lscpu | grep "Byte Order"

After running this cmd you will get the output like mentioned below

Byte Order:            Little Endian

Hope it helps

Answer 3

in C with GCC 9.4:

#include <endian.h>

#if __BYTE_ORDER == __LITTLE_ENDIAN
...
#endif

N.B. trap for the unwary : DON'T do this:

#ifdef __LITTLE_ENDIAN 

because both __LITTLE_ENDIAN and __BIG_ENDIAN are defined in endian.h! Also LITTLE_ENDIAN / BIG_ENDIAN (no leading underscores are defined)

Answer 4

C logic to check whether your processor follows little endian or big endian

unsigned int i =12345; 
char *c = (char *)&i; // typecast int to char* so that it points to first bit of int
if(*c != 0){          // If *c points to 0 then it is Big endian else Little endian
printf("Little endian");
}
else{
printf("Big endian");
}

Hope this helps. Was one of the question asked in my interview for the role of embedded software engineer role

Answer 5

In bash (from How to tell if a Linux system is big endian or little endian?):

endian=`echo -n "I" | od -to2 | head -n1 | cut -f2 -d" " | cut -c6`

if [ "$endian" == "1" ]; then
  echo "little-endian"
else
  echo "big-endian"
fi

Answer 6

In Rust (no crates or use statements required)

In a function body:

if cfg!(target_endian = "big") {
    println!("Big endian");
} else {
    println!("Little endian");
}

Outside a function body:

#[cfg(target_endian = "big")]
fn print_endian() {
    println!("Big endian")
}

#[cfg(target_endian = "little")]
fn print_endian() {
    println!("Little endian")
}

This is what the byteorder crate does internally: https://docs.rs/byteorder/1.3.2/src/byteorder/lib.rs.html#1877

Answer 7

In Powershell

[System.BitConverter]::IsLittleEndian

Answer 8

A compilable version of the top answer for n00bs:

#include <stdio.h>

int main() {
    int n = 1;

    // little endian if true
    if(*(char *)&n == 1) {
        printf("Little endian\n");
    } else {
        printf("Big endian\n");
    }   
}

Stick that in check-endianness.c and compile and run:

$ gcc -o check-endianness check-endianness.c
$ ./check-endianness

This whole command is a copy/pasteable bash script you can paste into your terminal:

cat << EOF > check-endianness.c
#include <stdio.h>
int main() {
    int n = 1;
    // little endian if true
    if(*(char *)&n == 1) {
        printf("Little endian\n");
    } else {
        printf("Big endian\n");
    }   
}
EOF

gcc -o check-endianness check-endianness.c \
 && ./check-endianness \
 && rm check-endianness check-endianness.c

The code is in a gist here if you prefer. There is also a bash command that you can run that will generate, compile, and clean up after itself.

Answer 9

In Nim,

echo cpuEndian

---

It is exported from the system module.

Answer 10

In Rust (byteorder crate required):

use std::any::TypeId;

let is_little_endian = TypeId::of::<byteorder::NativeEndian>() == TypeId::of::<byteorder::LittleEndian>();

Answer 11

In C++20 use std::endian:

#include <bit>
#include <iostream>

int main() {
    if constexpr (std::endian::native == std::endian::little)
        std::cout << "little-endian";
    else if constexpr (std::endian::native == std::endian::big)
        std::cout << "big-endian";
    else
        std::cout << "mixed-endian";
}

Answer 12

In C

#include <stdio.h> 

/* function to show bytes in memory, from location start to start+n*/
void show_mem_rep(char *start, int n) 
 { 
      int i; 
      for (i = 0; i < n; i++) 
      printf("%2x ", start[i]); 
      printf("\n"); 
 } 

/*Main function to call above function for 0x01234567*/
int main() 
{ 
   int i = 0x01234567; 
   show_mem_rep((char *)&i, sizeof(i));  
   return 0; 
} 

When above program is run on little endian machine, gives “67 45 23 01” as output , while if it is run on big endian machine, gives “01 23 45 67” as output.

Answer 13

Using Macro,

const int isBigEnd=1;
#define is_bigendian() ((*(char*)&isBigEnd) == 0)

Answer 14

In Python:

from sys import byteorder
print(byteorder)
# will print 'little' if little endian

Answer 15

Another C code using union

union {
    int i;
    char c[sizeof(int)];
} x;
x.i = 1;
if(x.c[0] == 1)
    printf("little-endian\n");
else    printf("big-endian\n");

It is same logic that belwood used.

Answer 16

In Linux,

static union { char c[4]; unsigned long mylong; } endian_test = { { 'l', '?', '?', 'b' } };
#define ENDIANNESS ((char)endian_test.mylong)

if (ENDIANNESS == 'l') /* little endian */
if (ENDIANNESS == 'b') /* big endian */

Answer 17

In C, C++

int n = 1;
// little endian if true
if(*(char *)&n == 1) {...}

See also: Perl version

Answer 18

A C++ solution:

namespace sys {

const unsigned one = 1U;

inline bool little_endian()
{
    return reinterpret_cast<const char*>(&one) + sizeof(unsigned) - 1;
}

inline bool big_endian()
{
    return !little_endian();
}

} // sys

int main()
{
    if(sys::little_endian())
        std::cout << "little";
}

Answer 19

A one-liner with Perl (which should be installed by default on almost all systems):

perl -e 'use Config; print $Config{byteorder}'

If the output starts with a 1 (least-significant byte), it's a little-endian system. If the output starts with a higher digit (most-significant byte), it's a big-endian system. See documentation of the Config module.

Answer 20

If you are using .NET: Check the value of BitConverter.IsLittleEndian.