Início / server / Perguntas / 163487
Accepted
Jake Wilson
Asked: 2010-07-24 08:58:22 +0800 CST

Como saber se um sistema Linux é big endian ou little endian?

  • 772

Eu sei que certos processadores são Big Endian e outros são Little Endian. Mas existe um comando, script bash, script python ou uma série de comandos que podem ser usados ​​na linha de comando para determinar se um sistema é Big Endian ou Little Endian? Algo como:

if <some code> then
    echo Big Endian
else
    echo Little Endian
fi

Ou é mais simples apenas determinar qual processador o sistema está usando e seguir com isso para determinar sua Endianess?

central-processing-unit

12 respostas

  1. Best Answer

    Em um sistema Big Endian (Solaris em SPARC)

    $ echo -n I | od -to2 | head -n1 | cut -f2 -d" " | cut -c6

    0

    Em um sistema pouco endian (Linux em x86)

    $ echo -n I | od -to2 | head -n1 | cut -f2 -d" " | cut -c6

    1

    A solução acima é inteligente e funciona muito bem para Linux *86 e Solaris Sparc.

    Eu precisava de uma solução somente shell (sem Perl) que também funcionasse em AIX/Power e HPUX/Itanium. Infelizmente, os dois últimos não funcionam bem: o AIX relata "6" e o HPUX fornece uma linha vazia.

    Usando sua solução, consegui criar algo que funcionou em todos esses sistemas Unix:

    $ echo I | tr -d [:space:] | od -to2 | head -n1 | awk '{print $2}' | cut -c6

    Em relação à solução Python que alguém postou, ela não funciona no Jython porque a JVM trata tudo como Big. Se alguém conseguir fazê-lo funcionar em Jython, por favor poste!

    Além disso, encontrei isso, o que explica o endianness de várias plataformas. Alguns hardwares podem operar em qualquer modo, dependendo do que o SO seleciona: http://labs.hoffmanlabs.com/node/544

    Se você for usar o awk, esta linha pode ser simplificada para:

    echo -n I | od -to2 | awk '{ print substr($2,6,1); exit}'

    Para pequenas caixas Linux que não possuem 'od' (digamos OpenWrt), tente 'hexdump':

    echo -n I | hexdump -o | awk '{ print substr($2,6,1); exit}'
    • 139

  2. Se você estiver em uma máquina Linux bastante recente (quase tudo depois de 2012) , lscpuagora contém esta informação:

    $ lscpu | grep Endian
Byte Order:            Little Endian

    Isso foi adicionado lscpuna versão 2.19, que é encontrada no Fedora >= 17, CentOS >= 6.0, Ubuntu >= 12.04.

    Observe que encontrei esta resposta nesta excelente resposta no Unix.SE. Essa resposta tem muitas informações relevantes, este post é apenas um resumo dela.

    • 60

  3. Aqui está um script de uma linha python mais elegante

    python -c "import sys;sys.exit(0 if sys.byteorder=='big' else 1)"

    código de saída 0significa big endian e 1significa little endian

    ou apenas mude sys.exitpara printuma saída imprimível

    • 34

  4. Você pode tirar proveito do formato de arquivo ELF para determinar a endianness do seu sistema. Por exemplo, imprima os primeiros seis bytes de um arquivo ELF arbitrário em hexadecimal:

    xxd -c 1 -l 6 /bin/ls

0000000: 7f  .
0000001: 45  E
0000002: 4c  L
0000003: 46  F
0000004: 02  .
0000005: 01  .

    Se a última linha (o sexto byte) for 01, de acordo com o formato ELF , 01 é little endian e 02 é big endian.

    Se você não tiver um xxdna sua caixa (e tiver o busybox), tente isto:

    hexdump -s 5 -n 1 -C /bin/busybox
    • 14

  5. A resposta principal pode ser simplificada um pouco usando awk:

    Em um sistema Big Endian (Solaris, SPARC)

    $ echo -n I | od -to2 | awk 'FNR==1{ print substr($2,6,1)}'
0

    Em um sistema Little Endian (Linux, Intel)

    $ echo -n I | od -to2 | awk 'FNR==1{ print substr($2,6,1)}'
1

    Kernels Linux mais recentes

    A partir da versão 2.19 do pacote util-linux o comando lscpupassou a incluir um campo relacionado a Endianness. Então agora você pode simplesmente usar este comando para descobrir isso:

    $ lscpu | grep -i byte
Byte Order:            Little Endian

    Isso foi confirmado no Ubuntu 12.10 e CentOS 6. Então, eu estaria disposto a assumir que a maioria dos Kernels Linux 3.0+ estão oferecendo isso agora.

    Em sistemas Debian/Ubuntu você também pode usar este comando, não tenho certeza de quando ele se tornou disponível:

    $ dpkg-architecture | grep -i end
DEB_BUILD_ARCH_ENDIAN=little
DEB_HOST_ARCH_ENDIAN=little

    Referências

    • 10

  6. Este script Python deve funcionar para você:

    #!/usr/bin/env python
from struct import pack
if pack('@h', 1) == pack('<h', 1):
    print "Little Endian"
else:
    print "Big Endian"
    • 9 
  7. python -c "import sys; print(sys.byteorder)"

    Seria imprimir a endianess do sistema.

    • 9

  8. Eu encontrei uma maneira de fazer isso em Jython. Como o Jython (Python na JVM) é executado em uma VM, ele sempre relata big endian, independentemente do hardware.

    Esta solução funciona para Linux, Solaris, AIX e HPUX. Não testei no Windows:

        from java.lang import System
    for property, value in dict(System.getProperties()).items():
        if property.endswith('cpu.endian'):
            return value
    • 3

  9. Um comando de linha única baseado no formato ELF:
    hexdump -s 5 -n 1 /bin/sh

    • 1

  10. Requisito um pouco diferente: eu preciso de um teste como este em um script de configuração de compilação de programa para determinar se a máquina de destino de compilação é bit ou little endian, sem executar código . O script deve depositar #define HAVE_LITTLE_ENDIAN 1em um config.hcabeçalho, ou então #define HAVE_LITTLE_ENDIAN 0.

    A máquina de destino da compilação pode ser diferente da máquina de compilação, pois podemos estar fazendo compilação cruzada, o que também explica por que o teste não deve tentar executar nenhum código compilado. Está fora de questão ter um pequeno programa em C com uma printfdeclaração que cuspa a resposta.

    Uma possível solução é esta. Geramos um arquivo chamado conftest.cque contém isso:

    #define USPELL(C0, C1, C2, C3) \                                             
  ((unsigned) C0 << 24 | \                                              
   (unsigned) C1 << 16 | \                                              
   (unsigned) C2 << 8 | (unsigned) C3)                                       

unsigned x[6] = {                                                       
  0,                                                                         
  USPELL('L', 'I', 'S', 'P'),                                                
  USPELL('U', 'N', 'I', 'X'),                                                
  USPELL('C', 'O', 'R', 'E'),                                                
  USPELL('D', 'W', 'I', 'M'),                                                
  0                                                                          
};

    Agora, compilamos isso conftest.ousando:

    $ /path/to/cross-compiling/cc conftest.c -c

    Então executamos:

    $ strings conftest.o
PSILXINUEROCMIWD

    Se a string PSILXINUEROCMIWDocorrer, o destino será little-endian. Se a string LISPUNIXCOREDWIMocorrer, é big-endian. Se nenhuma das seqüências ocorrer ou, ainda mais surpreendentemente, ambas ocorrerem, então o teste falhou.

    Essa abordagem funciona porque as constantes "fourcc" calculadas no programa têm valores independentes da máquina, denotando os mesmos inteiros independentemente da endianness. Sua representação de armazenamento no arquivo de objeto segue o endianness do sistema de destino, e isso é visível por meio da exibição baseada em caracteres em strings.

    As duas palavras de guarda zero garantem que a string seja isolada. Isso não é estritamente necessário, mas garante que a string que estamos procurando não esteja embutida em alguma outra string, o que significa que stringsa produzirá em uma linha sozinha.

    PS, a USPELLmacro não coloca entre parênteses as inserções de argumento porque é criada para esse propósito específico, não para reutilização.

    • 0

relate perguntas