Little Endian Puns

i recall reading in a few places(which when i try to find now i cannot) that alludes to the power7+ being little endian capable to some degree. i don't remember where exactly, but i recall one source mentioning the 7+'s LE implementation not being perfect, and somewhere else stating it is possible to run LE linux os's in KVM on a 7+ host. Is there any truth to that, or am i mis-remembering/mis-reading something.

EDIT: found the mention of it not being perfect Here

> POWER8 systems are certainly more widely distributed than previous generations which since about POWER5 were almost exclusively IBM, and they were also the first Power ISA CPU with a fully-functioning little-endian mode (the POWER7 implementation had gaps

Question: The number 1234567 is stored as 32bit word starting at address F0439000. Show the address and contents of each byte of 32bit word on a

1. Little endian system
2. Big endian system

My thoughts are

1. 1234567 = 00010010 11010110 10000111 (shows as three bytes in binary)
2. there are three bytes, but it stored as 32bit, there is another byte requires which is simply 00000000
3. Now the binary number is 00000000 00010010 11010110 10000111
4. In big endian the most significant value will be in the smallest address location (am i right?). so the memory looks like this

5. In little endian the most significant number will be in the biggest memory address location. (just reverse of big endian)

If i am wrong you know what is my confusion. Thanks in advance for your kind help.

Im not sure if this is the correct sub reddit for this question since it's not a programming question, but Im having a difficult time understanding how the most significant byte is chosen for a given value. For example if we have a hexadecimal number 0x010203 then for big Endian the most significant byte is 01 and the least significant byte is 03. However if we have a ipv4 address 127.0.0.1 then for big Endian the most significant byte is 1 and the least significant byte is 127 and that really doesn't make any sense to me. Any one out there who can explain this to me?

I tried reading UTF-16 file using csv-reading package both in Emacs (using Geiser) and Dr. Racket IDE. But, though I get the result, it is not readable. The content of the file is attendance data generated by Microsoft Teams.

[Q1] How to change the default character set in Racket?

[Q2] Is there any mechanism to convert a Unicode text to normal ASCII text without using any external applications?

Why is it called BIG ENDian when the sequence of bits ENDs with the most LITTLE bit?

I'm currently, learning how to code the GBA, which is a little endian system, and in one of the tutorials I'm following, they wrote a setColor function like this:

uint16 setColor(uint8 a_red, uint8 a_green, uint8 a_blue) {
return (a_red & 0x1F) | (a_green & 0x1F) << 5 | (a_blue & 0x1F) << 10;
}

This means that the binary color value is represented as bgr, which didn't surprise me as the GBA is little endian. But I was wondering if this is how you would code binary values for other little endian systems, like for the x86 processor, because this is the first time I had to rearrange values like this. Like I don't think I had to write binary values like this before, and I have an Intel processor. So I was wondering why we consider little endian in this situation, but in other ones, like when regular C coding, we don't consider what the endian of the system is?

> This post is originally published on yoursunny.com blog https://yoursunny.com/t/2021/ESP32-endian/

I'm programming network protocols on the Espressif ESP32 microcontroller, and I want to know: is ESP32 big endian or little endian? Unfortunately, search results have only videos and forum posts and PDF; the answer, if present, is buried deep in pages and pages of discussions and irrelevant content. So I quickly wrote a little program to determine the endianness of ESP32.

The Straight Answer: ESP32 is Little Endian

I have determined that: the Tensilica Xtensa LX6 microprocessor in ESP32 is little endian.

ESP32 is little endian. Many other processors are little endian, too:

• Intel and AMD x86 and x86_64 processors are little endian.
• Raspberry Pi and Beaglebone Black are little endian, although the underlying ARM processor may operate as big endian.
• ESP8266 is little endian. It has Tensilica Xtensa L106 microprocessor, similar to the ESP32
• nRF52 series is little endian. This includes the Adafruit Bluefruit nRF52832.

Arduino Sketch to Determine Endianness

I used this Arduino program to determine the endianness of ESP32 CPU:

void setup() {
  Serial.begin(115200);
  Serial.println();

  uint32_t x = 0x12345678;
  const uint8_t* p = reinterpret_cast<const uint8_t*>(&x);
  Serial.printf("%02X%02X%02X%02X\n", p[0], p[1], p[2], p[3]);
}

void loop() {
}

The program should print 12345678 on a big endian machine, or 78563412 on a little endian machine. ESP32 prints:

> 78563412

So ESP32 is little endian.

Hello,

I'm creating a verilog riscv core and might have done something wrong.(sry if this is oftopic for this sub) My design works partially, simple c++ applications work, but bigger ones fail. And I think I might know why.

When designing my core, I assumed little endian meant least significant byte at the end, well I discovered that's not the case. (I'm so stupid jeez) So I am now modifying my design to be little endian.

However I have a question about the is a and its load and store instructions. If I load a word from ram, does it load that little endian as well or are only instructions loaded little endian. Same goes for saving, little endian?

To clarify, lets say I have the value 0x00000001 in register a0. Now I do SW to save it to address 0. Will that value now be saved as [0]:0x01 [1]:0x00 [2]:0x00 [3]:0x00 or the other way around?

And of course the same question for lw: [0]:0x01 [1]:0x00 [2]:0x00 [3]:0x00 becomes 0x00000001 or 0x01000000?

Thanks!

From my CA course text: "... two competing kingdoms, Lilliput and Blefuscu, have different customs for breaking eggs. The inhabitants of Lilliput break their eggs at the little end and hence are known as little endians, while the inhabitants of Blefuscu break their eggs at the big end, and hence are known as big endians.

The novel is a parody reflecting the absurdity of war over meaningless issues. The terminology is fitting, as whether a CPU is big-endian or little-endian is of little fundamental importance."

Also see: this post

Edit: Byte order not bit order, as was pointed out :)

If I wanted to change 9F 86 01 To F4 01

Would it be 00 F4 01 or F4 01 00 ?

Still learning sorry.

Let's say when i do:

printf("%02x", i);

The output is:

00464c45

The output I want is:

45 4c 46 00 (with the space)

How do I do it?

Little-endian

The obvious advantage to little-endianness is what you mentioned already in your question... the fact that a given number can be read as a number of a varying number of bits from the same memory address. As the Wikipedia article on the topic states:

>Although this little-endian property is rarely used directly by high-level programmers, it is often employed by code optimizers as well as by assembly language programmers.

Because of this, mathematical functions involving multiple precisions are easier to write because the byte significance will always correspond to the memory address, whereas with big-endian numbers this is not the case. This seems to be the argument for little-endianness that is quoted over and over again... because of its prevalence I would have to assume that the benefits of this ordering are relatively significant.

Another interesting explanation that I found concerns addition and subtraction. When adding or subtracting multi-byte numbers, the least significant byte must be fetched first to see if there is a carryover to more significant bytes. Because the least-significant byte is read first in little-endian numbers, the system can parallelize and begin calculation on this byte while fetching the following byte(s).

Big-endian

Going back to the Wikipedia article, the stated advantage of big-endian numbers is that the size of the number can be more easily estimated because the most significant digit comes first. Related to this fact is that it is simple to tell whether a number is positive or negative by simply examining the bit at offset 0 in the lowest order byte.

What is also stated when discussing the benefits of big-endianness is that the binary digits are ordered as most people order base-10 digits. This is advantageous performance-wise when converting from binary to decimal.

While all these arguments are interesting (at least I think so), their applicablility to modern processors is another matter. In particular, the addition/subtraction argument was most valid on 8 bit systems...

For my money, little-endianness seems to make the most sense and is by far the most common when looking at all the devices which use it. I think that the reason why big-endianness is still used is more for reasons of legacy than performance. Perhaps at one time the designers of a given architecture decided that big-endianness was preferrable little-endianness, and as the architecture evolved over the years the endianness stayed t

First post here. Sorry if the title wasn't informative; I wasn't sure how to name it.

So when I was trying to solve stack2 I forgot to put the bytes in the correct endian order, but this produced a strange behaviour that I don't understand.

So if I set the GREENIE to this(Notice the inverted byte order):

user@protostar:/opt/protostar/bin$ GREENIE=$(python -c 'print "A"*64 + "\x0d\x0a\x0d\x0a"')

And then run gdb on stack2 and examine the stack with x/24wx $esp after strcpy is called, this is the result:

0xbffff730: 0x41414141 0x41414141 0x41414141 0x41414141

0xbffff740: 0x41414141 0x41414141 0x41414141 0x41414141

0xbffff750: 0x41414141 0x41414141 0x41414141 0x41414141

0xbffff760: 0x41414141 0x41414141 0x000d0a0d 0xbffff9c3

somehow the modified variable is not 0x0a0d0a0d as I would expect, but intead the first byte has been changed to 00. Why would this be?

Hi, i've ported xmr-stak-cpu to powerpc, it's still rough in the edges and requires some optimization. But it works, I can get 1600h/s in a 20 core server. https://github.com/nioroso-x3/xmr-stak-power

Feedback welcome!

What a freak of a system!

Bijective- No Zero, there is a digit for the base though (123456789X, 11)

Balanced- Half positive, half negative digits (1234514̅13̅12̅1T10)

Little Endian- Numbers are left to right instead (123456789, 01, 11, 21, 31, 41, 51, 61, 71, 81, 91, 02, 12, 22, 32, 42, 52)

Bijective Balanced Little Endian: (12345, 4̅1, 3̅1, 2̅1, T1, X, 11, 21, 31, 41, 51, 4̅2, 3̅2, 2̅2, T2, X1, 12

Start at 1, get is at XXT1 (I think 1,000 decimal)

I have a hexadecimal value which is quite big and I want to use some kind of converter online which can convert it into little or big endian for me. I tried searching a lot but there's barely any online but one: https://www.scadacore.com/tools/programming-calculators/online-hex-converter/

But it's kind of hard to copy and paste values from this site

Can someone help me if there is anything like this online out there?

At least VLC player reports the decoded format of meny HEVC files as: Planar 4:2:0 YUV 10-bit LE.

Or, at least it used to (now it shows that on my laptop, not on PC), now I can't see any indication if the file is even 10-bit. I only managed to access that information with MediaInfo's HTML view. BTW, are some encoding tools providing metadata that even VLC player or other players would use?

I've always wondered what "LE" means there but didn't quite find information on that. This question is, however, rather unimportant.

So, I've been working on some public ctf lately, and ran into an issue I hadn't considered before.

I'll spare you the details, but basically the solution to the ctf was to invoke a specific program and pass a crafted string of hex characters as an argument. I threw together a python script for the purpose. Didn't work.

After dicking around for hours, checking to make sure my string was correct, that my python wasn't sending extra characters, etc, I finally hit on the thought that it might take little endian. I reversed the order the bytes were sent, and bam, I was in.

The question still remains, though - how do you know if you should use big or little endian in a specific case? Is it based on the hardware? Is it the programming language? In this case, the program was written in C, so can I say 'Any time I have to pass a string of hex characters to a C program, make sure to use little endian.' Do you just have to sometimes try it the other way if it doesn't work the first time?

Is it a major factor while designing a compression algo, and if yes how the developers deal with it.

Hey folks, I've been experimenting with encryption algorithms however I've run into an issue with endianness. I don't have the best intuition on this subject.

The code works as expected on big endian systems but with a big to little endian it does not.

I've uploaded it to a gist here. The get_byte_offset strangely also returns a different value on the different systems with the same 64bit seed - especially considering that XOR should be commutative.

Any Code Review or tips would be a help.

Hi,
I'm reading metadata from mobi file. I have trouble with choosing which method should I use to read UInt16. Should it be Little Endian or Big Endian? How can i determine which method should be used to convert Buffer?