Datorteknik
Tomas Nordström
Föreläsning 3
För utveckling av verksamhet, produkter och livskvalitet.
Föreläsning 3 (+4?)
• Assembler
• ARM
• Instruktioner
2
Assembler
• Vi har sett hur man kan skriva in kod genom att
skriva direkt i 1:or och 0:or. Ganska omständligt.
Lätt att göra fel. Ingen "intuitiv" koll på vad koden
gör. Bättre: Översätt varje rad till något vi själva
förstår.
• En översättning från 1:or och 0:or till ord som ger
en bättre känsla för vad instruktionen gör,
mnemonics. Ett datorprogram översätter dessa
ord till 1:or och 0:or. "Språket" man då skriver i
kallas assembler.
3
Assembler forts.
• Programmering mha instruktioner som är CPUberoende.
• Rader i koden kan ges olika namn – labels/
programlägen
• Assembler är ett programmeringsspråk för
programmering på lägsta, hårdvaranära nivån.
Programmering sker med sk. instruktioner. De
instruktioner som finns beror på hårdvaran.
Assembler är alltså ett maskinberoende språk.
Språket klassas som lågnivåspråk.
• Alla grundkonstruktioner från högnivåspråk t ex
while, for, if måste skapas utifrån existerande
instruktioner.
4
ARM - Programmers model
• Direktiv/instruktioner
• Speciell "kod", assemblerdirektiv, finns för att hjälpa till vid
översättningen (assembleringen) till maskinkod (1:or och
0:or)
• Assemblerdirektiven är inte processorspecifika, utan
assemblerspecifika.
• Typiska sådana direktiv (uppmaningar) till assemblatorn är:
• Säga var koden börjar resp. slutar. ORG resp. END
• Definiera upp logiska namn på konstanter som används ofta EQU
• Sätta logiska etiketter, labels, på vissa rader (programlägen som då
blir minnesplatser dit man kan referera)
• Säga var koden skall hamna fysiskt i minnet
5
Assembler - exempelkod
; Memory Postions ------------------------------!
START
EQU
0x20000000 ; Start av SRAM!
PIOA_PER EQU
0x400E0C00 ; PIO Enable Register!
PIOA_PDSR EQU
0x400E0C3C ; Pin Data Status Register!
; Initiation code ------------------------------!
THUMB!
ORG
START
!
; Initiate PortA input ------------------------!
MAIN
LDR
R0,=PIOA_PER!
LDR
R1,=0XC0000!
STR
R1,[R0]
; enable PIOA!
LDR
R0,=DATA1
; Let R0 point to data!
; Read and manipulate data from portA (buttons)!
LDRb R1,[R0]
; load data into R1!
SUB
R1,R1,#1
; adjust data!
MOV
R5,#1
; set bit 0 to 1!
MOV
R6,R5, LSL R1
; shift the one R1 number of times!
AND
R6,R6,#0x0F
; mask out bit 0-4 in R6!
LDR
R2,=PIOA_PDSR!
LDR
R3,[R2]
; read portA/buttons !
LSR
R3,R3,#18
; move buttonflags to bit 1-0!
AND
R3,R3,#0x3
; mask buttons!
ORR
R3,R3,R6
; merge data!
SLUT
STRb R3,[R0]
; save data!
STOP
B
STOP!
DATA1
DCB
4!
DATA2
DC8
1!
END!
6
ARM assembler
Vanligaste direktiv för ARM
• Namn EQU tal
; Ersätter namnet Namn med talet tal.
; OBS! Tar ingen minnesplats
• Namn DCB tal
; Deklarerar en byte i minnet på den adress
; där Namn hamnar
• Namn DS8 X
; Reserverar plats för X antal 8-bitars resp
• Namn DS32 X
; 32-bitars tal på den adress där Namn hamnar
• ORG X
; Låter koden efteråt börja på adressen X
• END
; Avslutar assemblerkoden
7
Assemblering
• Översättningen från assembler till maskinkod sker
med en teknik som heter 2-stegs assemblering.
• Pass l -Första genomgång:
Hela koden gås igenom en gång och bestämmer vilka
adresser alla labels ska ha. Dessa lagras i det som kallas en
symboltabell. Går att räkna ut mha ORG-direktiven
• Pass2 - Andra genomgång:
Översätter koden till maskinkod samt ersätter "lablama"
med resp. adress från symboltabellen. Färdig!
8
Assembler vs Maskinkod
•
•
•
•
•
Assemblerkod – Program som
mha mnemonics beskriver ett
vilka maskininstruktioner som
ska utföras, använder
adressoberoende labels.
Utvecklas oftast inte på
målsystemet.
•
•
Maskinkod - De 1:or och 0:or
som laddas ner i datorns minne
Maskinkod laddas ner från PC
till målprocessorns minne, i
vårt fall via en liten låda som
pratar USB med datorn och
JTAG med målsystemet.
Assemblerkod översätts med en assemblator till maskinkod.
Måste använda processorspecifikt utvecklingsverktyg för
assemblering och kunna ladda ner till maskinkoden till målsystem.
Vi använder IAR Embedded Workbench.
Assembler är det språk eller "verktyg" som vi kommer att använda
för att programmera med i den här kursen.
9
Flödesschema - assemblering
Assemblerkod
1-Pass
symboltabell
LDR R1,R1,R2!
LABEL=0x2000F02
!
2-Pass
Översättning
till maskinkod
Maskinkod laddas till målsystemet
110010101011011
!
111100100011101
!
10
Pseudoinstruktioner
Syntetiska instruktioner
•
•
Mellan direktiv och instruktioner
Assemblatorn kan översätta en inskriven instruktion till flera instruktioner
som processorn kan tolka. En sådan instruktion, som inte är någon riktig,
kallas ibland en pseudoinstruktion.
•
Ex: Instr. MOV har begränsade tal som inargument. T ex MOV R1, #255
Större tal än 255 kan inte läggas in.
Lösning: Pseudoinstr. LDR R3,=49500 Här kan vi ha ett 32-bitars tal som
inargument trots att instruktionslängden bara är 32 bitar. Om talet är stort
blir översättningen LDR R3, [PC, #offset] Själva talet (här 49500)
placeras efter själva koden (efter END) och assemblatorn räknar ut avstånd
från instr. till var talet placeras (offset).
Är talet mindre än 9 bitar översätts instr. till MOV.
•
•
11
Sammanfattning Assembler
• Programmeringsspråk på lägsta nivån för processorer.
• Processorspecifik. Måste känna till processorn väl. Viktigt för
att känna till begränsningar.
• Möjlighet att använda labels. Behöver inte koda med
absolutadresser.
• Använder logiska namn för instruktioner, mnemonics.
• Pseudoinstruktioner-mellanting mellan direktiv och
instruktioner.
• Översätts med en assemblator till maskinkod. Maskinkod
läggs ner i processoms minne.
12
ARM
• RISC-processor
• 32-bitars arkitektur (ALU, interna register och
databuss)
• Tre-operands instruktioner (eller två+ett immed.)
• Load-Store struktur. Allt flyttas till register och
arbetas med där, sen tillbaka till minnet.
• 16 generella register - får användas till vad man
vill
• Flexibel kompakt instruktionsuppsättning. Alla
instruktioner kan utföras villkorligt (unikt för ARM)
13
ARM orginal
• Alla instruktioner är 32 bitar långa
• Ett flexibelt instruktionsset där instruktioner kan
utföras villkorligt (bit 31-28) samt sätta PSR på
begäran (S)
• Inbyggd skiftning av operand2 i alla instruktioner.
• Instruktioner för blockförflyttning av data, dvs
minnesblock kan flyttas till grupper av register och
tvärtom.
14
ARM Architecture roadmap
15
Vilken arkitektur är min ARM?
•
16
ARM Cortex M3
•
•
•
Key features of the Cortex-M3 core are:
ARMv7-M architecture
Instruction Sets
•
•
•
•
•
•
•
•
•
Thumb (entire)
Thumb-2 (entire)
1-cycle 32-bit hardware multiply, 2-12 cycle 32-bit hardware divide, saturated
math support
3-stage pipeline with branch speculation
1 to 240 physical interrupts, plus NMI
12 cycle interrupt latency; no shadow registers, state saved on
stack
Integrated sleep modes
1.25 DMIPS/MHz
90 nm implementation: 32 µW/MHz; 0.12 mm2
17
Thumb
• Thumb instructions are a sequence of half-word-aligned
half-words
• Each Thumb instruction is either
• a 16-bit half-word in that stream
• A 32-bit instruction consisting of two half-words in that stream
• If bits [15:11] of the half-word being decoded take on
any of the following values
•
•
•
•
•
0b11101
0b11110
0b11111
then half-word is the first half-word of a 32-bit instruction
otherwise the half-word is a 16-bit instruction
• See ARM ARM A5.1, A5.5, A5-13
18
19
20
Thumb-2
•
21
16bit Thumb-2
•
22
Thumb-2 Implementation
•
23
32bit Instruction Encoding
•
24
ARM and 16-bit Instruction Encoding
•
25
Thumb-2
•
[ARM Cortex-M3 Instruction Set & Architecture]
26
Instruction Encoding
ADD immediate
28
Nyckeldokument
•
180 sidor sammanfattning
Av Cortex M3
ARMs manual, på 410 sidor för Cortex M3
31
ATMEL SAM3U manual,
1187 sidor
ARM Cortex M3
Register
•
[ARM Cortex-M3 Devices, Generic User Guide, 2010]
32
ARM Cortex M3
Specialregister
[ARM Cortex-M3 Devices,
Generic User Guide, 2010]
• The Program Status Register (PSR) combines:
• Application Program Status Register (APSR)
• Interrupt Program Status Register (IPSR)
• Execution Program Status Register (EPSR).
• These registers are mutually exclusive bitfields in
the 32-bit PSR. The bit assignments are:
33
Flags
•
34
Memory Model
35
ARM Cortex M3
Instruktioner
Totalt 4 sidor!
•
[ARM Cortex-M3 Devices, Generic User Guide, 2010]
37
•
[ARM Cortex-M3 Devices, Generic User Guide, 2010]
39
ARM Cortex M3
Instruktionsklasser
• Ladda/Skriv till minnet
• Databehandling
•
•
•
•
Skiftoperationer
Logiska operationer
Aritmetiska och test instruktioner
Flytta mellan register och ladda in små konstanter till
register
• Hopp
• Övriga instruktioner
40
ARM Cortex M3
Vilkorsstyrning
•
Alla instruktioner kan
utföras på villkor. Lägg till
villkorsflaggorna efter
instruktionen.!
41
Conditional Execution and Flags
•
42
ARM Cortex M3
Instruktioner – Load/Store
43
•
44
•
45
•
46
•
47
Ladda/Spara
Exempel:
ADR R1, TextMessage
!; Write address value of a location
!
!
!
!
!; labelled as TextMessage to R1!
LDR R8, [R10] !
!; Loads R8 from the address in R10.!
LDRNE R2, [R5, #960]! !; Loads (conditionally) R2 from a word 960 bytes
!
!
!; above the address in R5, and increments R5 by 960!
STR R2, [R9,#const-struc] ; const-struc is an expression evaluating to a!
!
!
!; constant in the range 0-4095.!
STRH R3, [R4], #4
!; Store R3 as halfword data into address in R4,
!
!
!; then increment R4 by 4!
LDRD R8, R9, [R3, #0x20] ; Load R8 from a word 8 bytes above the address in
!
!
!; R3, and load R9 from a word 9 bytes !
!
!
!
!; above the address in R3!
STRD R0, R1, [R8], #-16 ; Store R0 to address in R8, and store R1 to a word
!
!
!; 4 bytes above the address in R8, and then
!
!
!
!; decrement R8 by 16.!
49
ARM Cortex M3
Instruktioner –
Databehandling
•
50
ARM Cortex M3
Instruktioner – Databehandling
• Skiftoperationer
• ASR, LSR, LSL, ROR, RRX!
• Logiska operationer
• AND, ORR, EOR, BIC, ORN!
• Aritmetiska och test instruktioner
•
•
•
•
•
ADD, ADC, SUB, SUBC, RSB, !
CMP, CMN, TST, TEQ, CLZ!
MUL, MLA, MLS, SDIV, SMLAL, SMULL, UMLAL, UMULL!
SSAT, USAT!
BFC, BFI, SBFX, SXTB, SXTH, UBFX, UXTB, UXTH!
51
ARM Cortex M3
Instruktioner – Databehandling
• Flytta mellan register och ladda in små konstanter
till register
• MOV, MVN, MOVW
• MOVT
• REV, REV16, REVSH, RBIT
52
ARM Cortex M3
Instruktioner – Skiftoperationer
• ASR #3
• LSR #3
• LSL #3
53
ARM Cortex M3
Instruktioner – Skiftoperationer
•
ROR #3
• RRX
54
ARM Cortex M3
Instruktioner – Logiska operationer
AND, ORR, EOR, BIC, and ORN
• Logical AND, OR, Exclusive OR, Bit Clear, and OR
NOT. !
Examples:!
AND
ORREQ
ANDS
EORS
BIC
ORN
ORNS
R9,
R2,
R9,
R7,
R0,
R7,
R7,
R2, #0xFF00!
R0, R5!
R8, #0x19!
R11, #0x18181818!
R1, #0xab!
R11, R14, ROR #4!
R11, R14, ASR #32!
55
ARM Cortex M3
Instruktioner – Aritmetiska operationer
ADD, ADC, SUB, SBC, and RSB!
• Add, Add with carry, Subtract, Subtract with carry,
and Reverse Subtract.
Exempel:!
•
•
•
•
ADD R2, R1, R3!
SUBS R8, R6, #240 ;
RSB R4, R4, #1280 ;
ADCHI R11, R0, R3 ;
!
!
!;
Sets the flags on the result!
Subtracts contents of R4 from 1280!
Only executed if C flag set and Z
flag clear.!
56
ARM Cortex M3
Instruktioner – Flytta mellan register
MOV and MVN!
• Move and Move NOT.
Exempel!
•
•
•
•
•
•
MOVS R11, #0x000B
MOV R1, #0xFA05
MOVS R10, R12
MOV R3, #23 !
MOV R8, SP !
MVNS R2, #0xF
!
!
!;
!;
!;
!;
!;
!;
Write value
Write value
Write value
Write value
Write value
Write value
0xF) to the
of
of
in
of
of
of
R2
0x000B to R11, flags get updated!
0xFA05 to R1, flags are not updated!
R12 to R10, flags get updated!
23 to R3!
stack pointer to R8!
0xFFFFFFF0 (bitwise inverse of
!
and update flags.!
57
ARM Cortex M3
Instruktioner - Hopp
•
•
•
•
B, BL, BX, BLX
CBZ, CBNZ
IT
TBB, TBH
58
• B, BL, BX, and BLX
• Branch instructions. L with linking, X based on
register
59
• Exempel
B loopA
BLE ng !
B.W target
BEQ target
BEQ.W target
BL funC
!
BX LR !
BXNE R0
BLX R0 !
!
!;
!;
!;
!;
!;
!;
!;
!;
!;
!;
!;
Branch to loopA!
Conditionally branch to label ng!
Branch to target within 16MB range!
Conditionally branch to target!
Conditionally branch to target within 1MB!
Branch with link (Call) to function funC,
!
return address stored in LR!
Return from function call!
Conditionally branch to address stored in R0!
Branch with link and exchange (Call) !
!
to a address stored in R0.!
!
!
60
ARM Cortex M3
Instruktioner - Övrigt
•
61
Enkelt villkor
if (tal==23){!
!<kod l> }!
<kod2>!
!
!
!
if (tal!=23){!
!<kod l> }!
<kod2>!
!
!CMP Rl, #23 ; (R1)- 23!
!BNE KOD2 ; om inte lika hoppa förbi!
!<kod l> ; annars utför!
KOD2 <kod2>!
!
!
!CMP Rl, #23 ; (R1)- 23!
!BEQ EXIT
; om lika, hoppa förbi!
!<kod l>!
EXIT ---!
!
62
if-else sats
!CMP Rl, R2!
if (tal==tal2){!
!BEQ KOD1 ; om
!<kod l> }!
KOD2 !<kod2>!
Else {!
!B SLUT!
!<kod2>}!
KOD1 !<kodl>!
!
SLUT ---!
!
!
lika hoppa till kod1!
63
Användning av villkorade instruktioner
•
64
for-loop
!LDR R0,#0!
for (i=0; i<25; i++)
!
LOOP !CMP R0,#25!
{!
!BGE EXIT!
<vad som skall utföras>!
!<vad som skall utföras>!
}!
!ADD R0,R0,#1!
<fortsättning på koden>!
!B LOOP!
EXIT <fortsättning på koden>!
!
!
!
65
while-sats
While(tal!=25)!
LOOP !CMP R0,#25!
{!
!BEQ EXIT!
<tal förändras på något sätt>
!
!<R0 förändras…>!
}!
!B LOOP!
<fortsättning på koden>! EXIT <fortsättning på koden>!
!
!
!
66
