M4: memory addressing and endianness

course/en/13-memory-addresses.md

@@ -0,0 +1,31 @@
+# Memory, addresses and offsets
+
+Memory can be modeled as a sequence of addressable bytes. An address identifies a location; a value may occupy one or several consecutive bytes.
+
+## PREDICT
+
+If a 32-bit value starts at address `0x1000`, which byte addresses does it occupy?
+
+## STEP
+
+In byte-addressable memory the address normally increases by one per byte: `0x1000`, `0x1001`, `0x1002`, `0x1003`. A 32-bit value occupies four bytes.
+
+An **offset** is a displacement relative to a base address. Base `0x2000` plus offset `0x34` gives `0x2034`.
+
+With (n) address bits, (2^n) address patterns exist. On a byte-addressed system, 16 address bits can identify 65,536 byte locations.
+
+## Alignment
+
+Architectures may prefer or require multi-byte values to begin at particular address boundaries. A 32-bit value may be naturally aligned at an address divisible by four.
+
+## OBSERVE
+
+Hexadecimal maps cleanly to address bits: a 16-bit address is four hex digits from `0000` through `FFFF`.
+
+## EXPLAIN
+
+Debugger and hex-editor displays require you to distinguish the address of data from the value stored there.
+
+## Check yourself
+
+Which addresses are occupied by a 16-byte block beginning at `0x3FF0`? Compute base `0x8000` plus offset `0x2A`.

course/en/14-endianness.md

@@ -0,0 +1,33 @@
+# Endianness
+
+Endianness describes the byte order used to store a multi-byte value. It does not change the numerical value itself.
+
+## PREDICT
+
+How can `0x12345678` occupy four bytes beginning at `0x1000`?
+
+## STEP
+
+Big-endian stores the most significant byte first: `12 34 56 78` at increasing addresses.
+
+Little-endian stores the least significant byte first: `78 56 34 12`.
+
+The bit notation inside each normally written byte is not reversed. Here, endianness is about ordering bytes of a multi-byte value.
+
+The Motorola 68000 family is associated with big-endian storage, while x86 uses little-endian. Protocols and file formats can define byte order independently of the host CPU.
+
+## Memory dumps
+
+A dump showing `78 56 34 12` can encode the 32-bit number `0x12345678` when the format specifies little-endian. Raw bytes need width, type and byte-order context.
+
+## OBSERVE
+
+A hex dump normally displays bytes in increasing memory-address order, which need not match the written digit order of a multi-byte number.
+
+## EXPLAIN
+
+Endianness matters when exchanging data among CPUs, networks, binary files, emulators and debugging tools.
+
+## Check yourself
+
+Write `0xA1B2C3D4` as four bytes in both big- and little-endian order.

course/no/13-minne-adresser.md

@@ -0,0 +1,39 @@
+# Minne, adresser og offsets
+
+Et minne kan modelleres som en lang rekke adresserbare byte. En adresse identifiserer en posisjon; en verdi kan bruke én eller flere påfølgende byte.
+
+## PREDICT
+
+Hvis en 32-bit verdi starter på adresse `0x1000`, hvilke byteadresser opptar den?
+
+## STEP
+
+En bytebredde på åtte bit gir 256 mulige rå bitmønstre. I byte-adresserbart minne øker adressen normalt med én for hver byte:
+
+`0x1000, 0x1001, 0x1002, 0x1003`.
+
+En 32-bit verdi bruker fire byte og dekker derfor disse fire adressene når den starter på `0x1000`.
+
+En **offset** er en forskyvning relativt til en basisadresse. Hvis base er `0x2000` og offset er `0x34`, er adressen `0x2034`.
+
+## Adresserom
+
+Med (n) adressebit kan (2^n) forskjellige adresser kodes. Hvor mye minne dette beskriver avhenger av hva hver adresse peker på. På vanlige byte-adresserte systemer betyr 16 adressebit opptil 65 536 byteadresser.
+
+## Alignment
+
+Mange arkitekturer foretrekker eller krever at flerbyteverdier starter på bestemte adressegrenser. En 32-bit verdi kan for eksempel være naturlig aligned på en adresse delelig med 4.
+
+Alignment er en maskinregel eller ytelsesegenskap, ikke en egenskap ved selve tallet.
+
+## OBSERVE
+
+Hex passer svært godt til adresser fordi hvert hexsiffer er fire bit. En 16-bit adresse kan skrives med fire hexsifre fra `0000` til `FFFF`.
+
+## EXPLAIN
+
+Når du leser debugger- eller hex-editorvisninger, må du skille mellom adressen til data og verdien som ligger på adressen.
+
+## Sjekk deg selv
+
+Hvilket adresseområde opptar en 16-byte blokk som starter på `0x3FF0`? Hva er adressen base `0x8000` + offset `0x2A`?

course/no/14-endianness.md

@@ -0,0 +1,49 @@
+# Endianness
+
+Endianness beskriver rekkefølgen byte fra en flerbyteverdi lagres i minnet. Det endrer ikke selve tallets verdi.
+
+## PREDICT
+
+Hvordan kan verdien `0x12345678` ligge i fire byte fra adresse `0x1000`?
+
+## STEP
+
+I **big-endian** lagres mest signifikante byte først:
+
+| Adresse | Byte |
+|---|---|
+| 0x1000 | 12 |
+| 0x1001 | 34 |
+| 0x1002 | 56 |
+| 0x1003 | 78 |
+
+I **little-endian** lagres minst signifikante byte først:
+
+| Adresse | Byte |
+|---|---|
+| 0x1000 | 78 |
+| 0x1001 | 56 |
+| 0x1002 | 34 |
+| 0x1003 | 12 |
+
+## Viktig skille
+
+Bitrekkefølgen inne i den vanlige skriftlige byteverdien snus ikke. Endianness handler her om rekkefølgen på byte i en flerbyteverdi.
+
+Motorola 68000-familien forbindes med big-endian, mens x86 bruker little-endian. Protokoller kan definere sin egen byteorden uavhengig av CPU-en.
+
+## Memory dump
+
+Ser du bytefølgen `78 56 34 12`, kan den være 32-bitverdien `0x12345678` dersom formatet sier little-endian. Uten type, bredde og byteorden er rå byte tvetydige.
+
+## OBSERVE
+
+En hex dump viser byte i stigende minneadresse, ikke nødvendigvis sifrene i den rekkefølgen vi skriver den numeriske verdien.
+
+## EXPLAIN
+
+Endianness blir viktig når data flyttes mellom CPU-er, nettverk, binærfiler, emulatorer og debuggerverktøy.
+
+## Sjekk deg selv
+
+Skriv `0xA1B2C3D4` som fire byte i big- og little-endian.

exercises/no/05-minne-endianness.md

@@ -0,0 +1,10 @@
+# Øvelser: minne og endianness
+
+1. En 64-bit verdi starter på `0x2008`. Hvilke byteadresser bruker den?
+2. Beregn `0x4000 + 0x01A7`.
+3. Hvor mange byteadresser finnes i et 20-bit byte-adressert adresserom?
+4. Skriv `0xCAFEBABE` som fire byte i big-endian.
+5. Skriv samme verdi i little-endian.
+6. En dump inneholder `34 12`. Tolk den som én unsigned 16-bit verdi i både little- og big-endian.
+7. Hvorfor kan du ikke avgjøre betydningen av fire rå byte bare ved å se på bitmønstrene?
+8. Forklar forskjellen mellom alignment og endianness.

solutions/no/05-minne-endianness.md

@@ -0,0 +1,10 @@
+# Løsninger: minne og endianness
+
+1. Åtte byte: `0x2008` til og med `0x200F`.
+2. `0x41A7`.
+3. (2^{20}=1,048,576) byteadresser, altså 1 MiB adresserbart byteområde.
+4. `CA FE BA BE`.
+5. `BE BA FE CA`.
+6. Little-endian: `0x1234 = 4660`. Big-endian: `0x3412 = 13330`.
+7. Du mangler blant annet type, bredde, signedness, byteorden og eventuell formatstruktur.
+8. Alignment beskriver hvor en verdi ligger i forhold til adressegrenser; endianness beskriver rekkefølgen på byte som utgjør flerbyteverdien.