M7: numbers and representation in assembly

course/en/19-numbers-in-assembly.md

@@ -0,0 +1,47 @@
+# Numbers in assembly
+
+Assembly exposes the distinction among **value**, **syntax**, **bit width** and **machine meaning**. A number may be an immediate constant, address, mask, offset or part of an instruction encoding.
+
+## PREDICT
+
+Do `$10`, `#10`, `0x10` and `10h` always mean the same thing?
+
+## STEP — literals and syntax
+
+Assembler dialects use different literal conventions. Common forms include decimal `42`, hexadecimal `0x2A`, `$2A` in many classic assemblers, `2Ah` in some Intel-style contexts, and forms such as `%101010` for binary.
+
+Always interpret syntax in the context of the actual assembler.
+
+## Immediate versus address
+
+A numeric operand can be the value itself or identify a location from which a value is read.
+
+On 6502-style syntax, `LDA #$2A` commonly loads immediate value `0x2A`, while `LDA $2A` accesses memory according to the instruction's addressing mode.
+
+On Motorola 68000, `MOVE.B #$2A,D0` uses an immediate value, while `MOVE.B $002A,D0` refers to memory. Size suffixes such as `.B`, `.W` and `.L` make operand width visible in many 68k dialects.
+
+## AVR
+
+AVR uses its own register and instruction constraints. For example, `LDI R16, 0x2A` loads a constant into a permitted register. A source literal still has to fit the operand range and instruction encoding.
+
+## x86
+
+x86 has multiple major assembler dialects. Intel and AT&T syntax can express the same machine operation differently, so no single textual convention should be mistaken for universal assembly syntax.
+
+## Registers, masks and disassembly
+
+Registers and instruction fields have finite widths. Bit masks such as `0x0F` are commonly used to select fields.
+
+A disassembler interprets raw bytes as instructions for a chosen ISA and address. Bytes that are actually data can look like plausible instructions when context is wrong.
+
+## OBSERVE
+
+Assembly source contains human-readable symbols and numeric notation. The CPU receives encoded instruction bit fields.
+
+## EXPLAIN
+
+Number representation is fundamental to assembly because operands, addresses, registers, masks, offsets and encodings are all finite bit fields.
+
+## Check yourself
+
+Why are `#$2A` and `$2A` different in many classic assembler dialects? Why must you know the dialect before interpreting `10h`?

course/no/19-tall-i-assembly.md

@@ -0,0 +1,79 @@
+# Tall i assembly
+
+Assembly gjør skillet mellom **verdi**, **syntaks**, **bitbredde** og **maskinbetydning** svært synlig. Samme tall kan være en immediate konstant, adresse, maske, offset eller del av en maskininstruksjon.
+
+## PREDICT
+
+Betyr `$10`, `#10`, `0x10` og `10h` alltid det samme?
+
+## STEP — literals og syntaks
+
+Assemblerdialekter bruker forskjellige notasjoner. Vanlige eksempler er:
+
+- `42` — ofte desimal
+- `0x2A` — vanlig hexnotasjon
+- `$2A` — hex i mange 6502- og 68k-assemblere
+- `2Ah` — hex i enkelte Intel-lignende syntakser
+- `%101010` — binær i enkelte assemblere
+
+Syntaksen må alltid leses i kontekst av den aktuelle assembleren.
+
+## Immediate eller adresse?
+
+Et tall i en instruksjon kan beskrive selve verdien eller stedet verdien skal hentes fra.
+
+### 6502-lignende eksempel
+
+`LDA #$2A` betyr typisk last den umiddelbare verdien `0x2A`.
+
+`LDA $2A` betyr derimot les fra en minneadresse etter assemblerens og instruksjonens adresseringsregler.
+
+### Motorola 68000
+
+`MOVE.B #$2A,D0` bruker `#$2A` som immediate verdi.
+
+`MOVE.B $002A,D0` refererer til minne.
+
+Suffix som `.B`, `.W` og `.L` gjør også datastørrelsen eksplisitt i mange 68k-assemblerdialekter.
+
+## AVR
+
+AVR har egne registre og instruksjonsbegrensninger. En konstant kan for eksempel lastes med:
+
+`LDI R16, 0x2A`
+
+Tallene i kildekoden må fortsatt passe operandens tillatte range og instruksjonsencoding.
+
+## x86
+
+x86 har flere assemblerdialekter. Intel- og AT&T-syntaks kan uttrykke samme maskininstruksjon forskjellig. Derfor er det farlig å lære én tekstlig form som om den var «assembly-syntaksen».
+
+## Registre og bredde
+
+Et register har en definert bredde. Skriver du et større tall enn feltet eller instruksjonen kan representere, må assembleren enten avvise det, redusere det etter definerte regler eller velge en annen encoding.
+
+Bitbredde bestemmer også hvordan samme bitmønster kan tolkes signed eller unsigned.
+
+## Masker
+
+Assembly bruker ofte tall som bitmasker:
+
+`AND #$0F`
+
+kan brukes til å beholde de fire laveste bitene i en byte, avhengig av ISA og syntaks.
+
+## Disassembly
+
+En disassembler starter med rå byte og forsøker å tolke dem som instruksjoner for en bestemt ISA og startadresse. En byte som er data i ett område kan derfor bli vist som en tilsynelatende instruksjon dersom verktøyet får feil kontekst.
+
+## OBSERVE
+
+Assemblerkilden inneholder menneskevennlige symboler og tallnotasjoner. CPU-en ser den ferdig kodede instruksjonens bitfelt.
+
+## EXPLAIN
+
+Tallforståelse er grunnleggende for assembly fordi operander, adresser, registre, masks, offsets og instruksjonsencoding alle er begrensede bitfelt.
+
+## Sjekk deg selv
+
+Hvorfor er `#$2A` og `$2A` forskjellige i mange klassiske assemblere? Hvorfor må du vite assemblerdialekten før du tolker `10h`?

exercises/no/08-assembly.md

@@ -0,0 +1,10 @@
+# Øvelser: tall i assembly
+
+1. Forklar forskjellen mellom en immediate verdi og en minneadresse.
+2. I en 6502-lignende syntaks, hva signaliserer `#` normalt i `LDA #$7F`?
+3. Hva er desimalverdien av hexliteralet `0x2A`?
+4. Hvorfor er `$100` problematisk som verdi i et rent 8-bit felt?
+5. Hva gjør masken `0x0F` når den AND-es med en byte?
+6. Hvorfor kan Intel- og AT&T-x86-assembly se forskjellige ut selv når maskinkoden uttrykker samme operasjon?
+7. Hva kan gå galt hvis en disassembler tolker en datatabell som kode?
+8. Finn signed og unsigned tolkning av 8-bitmønsteret `11111110₂`.

solutions/no/08-assembly.md

@@ -0,0 +1,10 @@
+# Løsninger: tall i assembly
+
+1. Immediate betyr at operanden inneholder selve verdien; en adresse identifiserer et sted der data eller kode finnes.
+2. `#` markerer normalt immediate addressing i denne syntaksfamilien.
+3. (2×16+10=42).
+4. `0x100 = 256` krever ni bit og passer ikke som en ordinær unsigned 8-bit verdi.
+5. Den nuller de fire øverste bitene og beholder de fire nederste.
+6. De er forskjellige tekstlige assemblerdialekter med blant annet ulike operand- og literalregler.
+7. Rå databyte kan dekodes som tilsynelatende gyldige, men meningsløse instruksjoner og føre analysen feil.
+8. Unsigned: 254. Signed toerkomplement: −2.