A mudança de bits depende do endianness?

Suponha que eu tenha o número 'numb'=1025 [00000000 00000000 00000100 00000001] representado:

Na Little-Endian Machine:

 00000001 00000100 00000000 00000000 

Na máquina big-endian:

 00000000 00000000 00000100 00000001 

Agora, se eu aplicar Left Shift em 10 bits (ie: numb << = 10), eu deveria ter:

[A] Na Máquina Little-Endian:

Como eu notei no GDB, Little Endian faz o Left Shift em 3 passos: [Eu mostrei ‘3’ passos para entender melhor o processamento]

  1. Trate o não. na Convenção Big-Endian:

     00000000 00000000 00000100 00000001 
  2. Aplique o Shift Esquerdo:

     00000000 00010000 00000100 00000000 
  3. Represente o resultado novamente em Little-Endian:

     00000000 00000100 00010000 00000000 

[B] Na máquina big-endian:

 00000000 00010000 00000100 00000000 

Minha pergunta é:

Se eu aplicar diretamente uma Mudança da Esquerda na Convenção Little Endian, ela deve dar:

numb :

 00000001 00000100 00000000 00000000 

numb << 10 :

 00010000 00000000 00000000 00000000 

Mas na verdade, isso dá:

 00000000 00000100 00010000 00000000 

Para alcançar o segundo resultado apenas, mostrei três etapas hipotéticas acima.

Por favor, explique-me porque os dois resultados acima são diferentes: O resultado real do numb << 10 é diferente do resultado esperado.

Endianness é o modo como os valores são armazenados na memory. Quando carregada no processador, independentemente do endianness, a instrução de mudança de bit está operando no valor do registrador do processador. Portanto, o carregamento da memory para o processador é o equivalente à conversão para big endian, a operação de mudança vem em seguida e, em seguida, o novo valor é armazenado novamente na memory, que é onde a ordem de byte little endian entra em vigor novamente.

Atualize, graças ao @jww: No PowerPC o vetor muda e gira são sensíveis ao endian. Você pode ter um valor em um registrador vetorial e um turno produzirá resultados diferentes em little-endian e big-endian .

Não, o bitshift, como qualquer outra parte de C, é definido em termos de valores , não de representações. Deslocamento à esquerda por 1 é multiplicação por 2, deslocamento à direita é divisão. (Como sempre, ao usar operações bit a bit, cuidado com a sinalização. Tudo está mais bem definido para tipos integrais não assinados.)

Qualquer que seja a instrução de deslocamento, os bits de ordem mais alta primeiro são considerados o deslocamento à esquerda. Qualquer que seja a instrução de deslocamento, os bits de ordem inferior primeiro são considerados o deslocamento à direita. Nesse sentido, o comportamento de >> e < < para números não unsigned não dependerá do endianness.

Computadores não escrevem números do jeito que fazemos. O valor simplesmente muda. Se você insistir em olhar para isso byte-by-byte (mesmo que não seja assim que o computador faz), você poderia dizer que em uma máquina little-endian, o primeiro byte muda para a esquerda, os bits excedentes vão para o segundo byte, e assim por diante.

(By the way, little-endian faz mais sentido se você escrever os bytes verticalmente, em vez de horizontalmente, com endereços mais elevados no topo. O que acontece a ser como diagramas de mapas de memory são geralmente desenhados.)