Steve Furber: ARM System-on-Chip Architecture.
2nd Edition. Addison Wesley, 2001, ISBN-10: 0-201-67519-6
Rysunek 1.6
MU0
memory
Prosty Procesor
licznik rozkazów (PC  Program
MEMrq RnW
Counter) przechowujący adres
MU0
IRce
kolejnej wykonywanej instrukcji
Podstawy techniki
akumulator (ACC  ACCumulator) IR
rejestr zawierający jeden z
opcode
mikroprocesorowej
argumentów przed operacją ALU
PC
i wynik pracy ALU
ETEW006
ACCoe
jednostka arytmetyczno- PCce
Asel
logiczna (ALU  Arithmetic-Logic
ALU
ALUfs
Unit) wykonująca operacje na
B A
Grupy rozkazów
binarnych argumentach, np. &, |,
Tryby adresowania ^, not, +,  , ........ ACCce
ACC[15]
rejestr instrukcji (IR  Instruction
ACC
ACCz
Register) zawierający aktualnie
wykonywaną instrukcję
mux
Bsel
0 1
Andrzej Stępień
układ dekodowania instrukcji
(decode) i sterowania (control logic)
Katedra Metrologii Elektronicznej i Fotonicznej
które koordynują pracę procesora
Steve Furber: ARM System-on-Chip Architecture. Steve Furber: ARM System-on-Chip Architecture.
2nd Edition. Addison Wesley, 2001, ISBN-10: 0-201-67519-6 2nd Edition. Addison Wesley, 2001, ISBN-10: 0-201-67519-6
Instrukcja Opcode Efekt wykonania
MU0 MU0
LDA S 0000 ACC := mem16[S]
STO S 0001 mem16[S] := ACC
Struktura [1#2] Struktura [2#2]
ADD S 0010 ACC := ACC + mem16[S]
SUB S 0011 ACC := ACC  mem16[S]
JMP S 0100 PC := S
kod operacyjny adres pamięci
S
(opcode) (memory address) JGE S 0101 if ACC e" 0 PC := S
JNE S 0110 if ACC `" 0 PC := S
4 bity 12 bitów
STP 0111 stop
kod operacyjny adres pamięci
MU0 jest 16-bitowym procesorem
S
(opcode) (memory address)
4 bity 12 bitów
16-bitowe instrukcje zawierają:
 4-bitowy kod operacyjny (operation code or opcode); procesor
Mnemonik rozkazu ADD S oznacza wykonanie ACC: = ACC + mem16 [S]:
realizuje jedynie 16 instrukcji
dodanie zawartość akumulatora ACC i zawartości 16-bitowej komórki
 12-bitowy adres pamięci (address field S); procesor może
pamięci o adresie S (12-bitowy adres)
zaadresować 8 Kbajtów pamięci złożonej z 4.096 16-bitowych
przesłanie wyniku dodawania do akumulatora ACC
komórek pamięci
Steve Furber: ARM System-on-Chip Architecture. Steve Furber: ARM System-on-Chip Architecture.
2nd Edition. Addison Wesley, 2001, ISBN-10: 0-201-67519-6 2nd Edition. Addison Wesley, 2001, ISBN-10: 0-201-67519-6
MU0 MU0
Formaty instrukcji Instrukcje 4 adresowe (argumentowe)
wynik (result) jest efektem wykonania przez procesor MU0 podstawowych
operacji, np. dodawania dwóch argumentów
format 4-argumentowej (adresowej) instrukcji:
format instrukcji:
ADD d, s1, s2, next_i ; d := s1 + s2
 kod operacyjny instrukcji określa jej sposób działania, np. dodawanie
; instrukcja liczy (4n + f) bitów
 niektóre bity kodu operacyjnego określają typ operandu, np. rejestr
(register) lub pamięć (memory)
f bitów n bitów n bitów n bitów n bitów
function s1 addr s2 addr d addr next_i addr
 inne bity określają miejsce składowania wyniku (result destination)
adresy dwóch adres adres następnej do
typ funkcji
 niektóre bity mogą określać adres następnej do wykonania instrukcji
operandów wyniku wykonania instrukcji
(address of the next instruction to be executed)
instrukcje mogą zawierać 4-, 3-, 2-, 1- lub 0-argumentów (adresów
argumentów) oraz wyniku (result)
1
mux
0
1
Steve Furber: ARM System-on-Chip Architecture. Steve Furber: ARM System-on-Chip Architecture.
2nd Edition. Addison Wesley, 2001, ISBN-10: 0-201-67519-6 2nd Edition. Addison Wesley, 2001, ISBN-10: 0-201-67519-6
MU0 MU0
Instrukcje 3 adresowe (argumentowe) Instrukcje 2 adresowe (argumentowe)
format 4-argumentowej (adresowej) instrukcji:
format 4-argumentowej (adresowej) instrukcji:
ADD d, s1, s2, next_i ; d := s1 + s2; instrukcja liczy (f + 4n) bitów
ADD d, s1, s2, next_i ; d := s1 + s2
; instrukcja liczy (f + 4n) bitów
f bitów n bitów n bitów n bitów n bitów
f bitów n bitów n bitów n bitów n bitów function s1 addr s2 addr d addr next_i addr
function s1 addr s2 addr d addr next_i addr adresy dwóch adres adres następnej do
typ funkcji
operandów wyniku wykonania instrukcji
adresy dwóch adres adres następnej do
typ funkcji
operandów wyniku wykonania instrukcji
format 3-argumentowej (adresowej) instrukcji:
ADD d, s1, s2 ; d := s1 + s2; instrukcja liczy (f + 3n) bitów
f bitów n bitów n bitów n bitów
format 3-argumentowej (adresowej) instrukcji  adres następnej instrukcji
function s1 addr s2 addr d addr
obliczany przez dodanie rozmiaru bieżącej (wykonywanej) instrukcji do jej
adresu i wpisanie nowej wartości do licznika rozkazów PC (redukcja liczby
format 2-argumentowej (adresowej) instrukcji  zmniejszenie
bitów w każdej instrukcji); obliczanie adresu jak poprzednio:
długości instrukcji, jeśli wynik nadpisuje jeden z argumentów:
ADD d, s1, s2 ; d := s1 + s2
ADD d, s1 ; d := d + s1; instrukcja liczy (f + 2n) bitów
; instrukcja liczy (f + 3n) bitów
f bitów n bitów n bitów n bitów
f bitów n bitów n bitów
function s1 addr s2 addr d addr function s1 addr d addr
Steve Furber: ARM System-on-Chip Architecture. Steve Furber: ARM System-on-Chip Architecture.
2nd Edition. Addison Wesley, 2001, ISBN-10: 0-201-67519-6 2nd Edition. Addison Wesley, 2001, ISBN-10: 0-201-67519-6
MU0: Instrukcje 1 adresowe (argumentowe) MU0: Instrukcje 0 adresowe (argumentowe)
format 4-argumentowej (adresowej) instrukcji: format 4-argumentowej (adresowej) instrukcji:
ADD d, s1, s2, next_i ; d := s1 + s2; instrukcja liczy (f + 4n) bitów ADD d, s1, s2, next_i ; d := s1 + s2; instrukcja liczy (f + 4n) bitów
f bitów n bitów n bitów n bitów n bitów
f bitów n bitów n bitów n bitów n bitów
function s1 addr s2 addr d addr next_i addr
function s1 addr s2 addr d addr next_i addr
adresy dwóch adres adres następnej do
adresy dwóch adres adres następnej do
typ funkcji
typ funkcji
operandów wyniku wykonania instrukcji
operandów wyniku wykonania instrukcji
format 3-argumentowej (adresowej) instrukcji:
format 3-argumentowej (adresowej) instrukcji:
ADD d, s1, s2 ; d := s1 + s2, instrukcja liczy (f + 3n) bitów
ADD d, s1, s2 ; d := s1 + s2, instrukcja liczy (f + 3n) bitów
function s1 addr s2 addr d addr
function s1 addr s2 addr d addr
format 2-argumentowej (adresowej) instrukcji:
ADD d, s1 ; d := d + s1 instrukcja liczy (f + 2n) bitów
format 2-argumentowej (adresowej) instrukcji:
ADD d, s1 ; d := d + s1 instrukcja liczy (f + 2n) bitów function s1 addr d addr
function s1 addr d addr
format 1-argumentowej (adresowej) instrukcji:
ADD s1 ; acc := acc + s1 instrukcja liczy (f + n) bitów
function
function s1 addr
format 1-argumentowej (adresowej) instrukcji  jeśli rejestrem wyniku
jest domyślny rejestr zwany akumulatorem:
format 0-argumentowej (adresowej) instrukcji:
ADD s1 ; acc := acc + s1 instrukcja liczy (f + n) bitów
ADD ; szczyt_stosu := szczyt_stosu + następna_wartość_na_stosie
f bitów n bitów
; (top_of_stack := top_of_stack + next_on_stack)
function
function
function s1 addr
; instrukcja liczy (f ) bitów
http://pl.wikipedia.org/wiki/Model_programowy_procesora
http://pl.wikipedia.org/wiki/Instrukcja_(informatyka)
http://en.wikipedia.org/wiki/Instruction_set
Model programowy procesora Instrukcje
instrukcja (w programowaniu) to najmniejszy samodzielny element
model programowy procesora (ISA - Instruction Set Architecture)
imperatywnego języka programowania; instrukcja może być:
ogólne określenie dotyczące organizacji, funkcjonalności i zasad
działania procesora, widoczne z punktu widzenia programisty jako
 niskiego poziomu napisana w asemblerze (np. mov r1, r2), która po
dostępne mechanizmy programowania (nie jest architekturą procesora)
przetłumaczeniu na kod binarny nadaje się do uruchomienia przez
procesor
model programowy procesora tworzą m.in.:
 instrukcja wysokiego poziomu napisana np. w języku C (int a = 5;),
 lista rozkazów procesora (instruction set)
która zostanie przetłumaczona na kilka instrukcji niskiego poziomu (na
 typy danych (data types)
poziomie asemblera).
 dostępne tryby adresowania (addressing modes)
 zestaw rejestrów dostępnych dla programisty (register file)
program jest tworzony jako zbiór różnych instrukcji; instrukcja może
 zasady obsługi wyjątków i przerwań (exceptions and interrupts)
zawierać wewnętrzne komponenty (np. wyrażenia).
procesory posiadające ten sam model programowy są ze sobą
instrukcje mogą być proste (NOP, a = a + 1, return 5, goto 13,
kompatybilne  mogą wykonywać te same programy w taki sam
ClearScreen) lub złożone (if a>3 then .. else .., switch c & & .)
(funkcjonalny) sposób, np. Cortex-M0/M0+ Cortex-M3 Cortex-M4
2
ARM Developer Suite. Assembler Guide.
etykieta
PRESERVE8
ARM DUI0068B, v.1.2, November 2001
dyrektywa
THUMB
mnemonik instrukcji
; Vector Table Mapped to Address 0 at Reset
operand
Cortex-M0
AREA RESET, DATA, READONLY
; komentarz
EXPORT __Vectors
Linia kodu programu
StartUp_LPC11xx.s
__Vectors DCD __initial_sp ; Top of Stack
DCD Reset_Handler ; Reset Handler
DCD NMI_Handler ; NMI Handler
instrukcja ..........................................................................
; External Interrupts
mnemonik instrukcji [operand1], [operand2], .. DCD WAKEUP_IRQHandler ; 16+ 0: Wakeup PIO0.0
DCD WAKEUP_IRQHandler ; 16+ 1: Wakeup PIO0.1
..........................................................................
[etykieta:] [; komentarz]
Reset_Handler PROC ; Reset Handler
EXPORT Reset_Handler [WEAK]
dyrektywa
IMPORT SystemInit
IMPORT __main
dyrektywa DCD (Define Constant Data)
etykieta - symboliczny adres,
LDR R0, =SystemInit
deklaruje kilka 32-bitowych słów
BLX R0
będących adresami procedur, które
instrukcja - rozkaz wykonywany przez procesor, LDR R0, =__main
tworzą tabelę skoków
BX R0
ENDP
mnemonik - symboliczna nazwa instrukcji,
; Dummy Exception Handlers (infinite loops which can be modified)
NMI_Handler PROC ; NMI Handler
operand - argumenty instrukcji,
EXPORT NMI_Handler [WEAK]
B .
ENDP
dyrektywa - polecenie dla asemblera,
HardFault_Handler PROC ; HardFault_Handler
EXPORT HardFault_Handler [WEAK]
komentarz - tekst pomijany przez asembler, od  ; do CR LF ...........................................................................
http://pl.wikipedia.org/wiki/Makroinstrukcja
Dekoder instrukcji
Makroinstrukcje
dekoder rozkazów (Instruction decoder)  układ określający typ rozkazu,
sposób jego wykonania, sposób generowania sygnałów sterujących, np.
pamięcią
makroinstrukcja (macro instruction) to ciąg instrukcji wywoływanych
za pomocą jednej dodatkowo zdefiniowanej instrukcji: sposób dekodowania rozkazu zależny od typu procesora, projektantów
procesora
MACRO
prostszy i szybszy dekoder procesorów RISC (mniejsza liczba rozkazów)
{$label} macroname { $cond } { $parameter { ,$parameter } ... }
w porównaniu z architekturą CISC
; code
MEND ARM Compiler toolchain. Version 4.1. Assembler Reference.
każda instrukcja zawiera informację o:
ARM DUI 0489C, p.6-30
% kodzie operacyjnym (opcode), typie wykonywanej operacji,
przekształcenie (rozszerzenie) makroinstrukcji w ciąg słów języka % operandach  z
ródle argumentów wejściowych (sources), np. numery
programowania (poddawanych dalszej translacji) jest realizowane przez rejestrów, adresy pamięci itp.
wstępny element translatora (preprocesor)
% operandach  przeznaczeniu argumentów wyjściowych (destination), np.
numery rejestrów, adresy pamięci itp.
% sposobie ich adresowania (addressing mode)
ARM�v7-M Architecture Reference Manual. Errata markup.
ARM7TDMI Data Sheet. ARM DDI 0029E, p. 5-7
ARM DDI 0403Derrata 2010_Q3, p. A7-223
Dekodowanie instrukcji
Dekodowanie instrukcji
Format 2: Thumb ADD/SUB
ADD (register)
15 11 9 5 3
10 8 6 2 0
Source register /
Immediate flag: 0  Register operand
T1: ADDS , ,
Immediate value
1  Immediate operand 00011 0 0 Rm Rn Rd
Thumb, Outside IT block
15 11 8 6 2 0
9 5 3
Rm/
00011 I OpOffset3 Rn Rd
9 8 6 3
7 2 0
15 10
T2: ADD ,
Destination
Opcode: 0  ADD
010001 00 DN Rm Rdn
register Thumb
1  SUB
Source
DN:Rdn
register
(4 bits)
Op I Instruction Action
T3: ADD{S}.W , , {,} 00  LSL
01  LSR
0 0 ADD Rd, Rn, Rm Rd �! Rm + Rn
Thumb-2
10  ASR
11  ROR
0 1 ADD Rd, Rn, #Offset3 Rd �! Rn + Offset3 (3-bit immediate value)
5 4
10 9 4 15 11 8
15 11 8 5 3 0 14 12 7 6 3 0
1 0 SUB Rd, Rn, Rm Rd �! Rn  Rm
shift
11101 01 1000 S Rn 0 imm3 Rd imm2 Rm
type
1 1 SUB Rd, Rn, #Offset3 Rd �! Rn  Offset3 (3-bit immediate value)
3
http://en.wikipedia.org/wiki/Instruction_set
Przetwarzanie danych, obsługa pamięci
PREFIX w kodach rozkazów MCS51
(Data handling and Memory operations)
x0 x1 x2 x3 x5
AJMP LJMP RR INC
0x NOP
addr11 addr16 A addr
OPCODE
JBC ACALL LCALL RRC DEC
PREFIX = 0A5h
1x wpis wartości do rejestru
bit, rel addr11 addr16 A addr
dodatkowe
(set a register to a fixed constant value)
JB AJMP RL ADD
instrukcje np.
2x RET
bit, rel addr11 A A, addr
odczyt danych z pamięci do rejestrów lub zapis danych z rejestrów
80C51MX (Philips)
do pamięci
C251 (Intel/Atmel)
ORL AJMP MOV INC OPCODE
Ax (move data from a memory location to a register, or vice versa),
C, /bit addr11 C, bit DPTR PREFIX
odczyt danych z urządzeń peryferyjnych do rejestrów lub zapis
POP ACALL LJMP RR DJNZ
Dx danych z rejestrów do urządzeń peryferyjnych
addr addr11 addr16 A addr, rel
(read/write data from/into hardware devices),
MOVX AJMP MOVX MOV
Ex
A,@DPTR addr11 A, @Ri A, addr
MOVX ACALL MOVX MOV
Fx
@DPTR,A addr11 @Ri, A addr, A
http://en.wikipedia.org/wiki/Instruction_set http://en.wikipedia.org/wiki/Instruction_set
Instrukcje arytmetyczne i logiczne Kontrola przepływu
(Arithmetic and logic operations) (Control flow operations)
dodawanie, odejmowanie, mnożenie, dzielenie wartości w dwóch
rejestrach, wynik również w rejestrze ze zmianą znacznika lub znaczników w
rejestrze statusowym
(add, subtract, multiply, or divide the values of two registers, placing the
bezwarunkowe rozgałęzienie programu  skoki bezwarunkowe
result in a register, possibly setting one or more condition codes in a status
(branch to another location in the program and execute instructions
register)
there)
operacje bitowe z koniunkcją i alternatywą bitów w parze rejestrów lub
warunkowe rozgałęzienie programu  skoki warunkowe
negacją każdego bitu w rejestrze
(conditionally branch to another location if a certain condition holds)
(perform bitwise operations, taking the conjunction and disjunction of
wywołania podprogramów, przerwań z pamiętaniem adresu
corresponding bits in a pair of registers, or the negation of each bit in a
powrotu z podprogramu, przerwania
register)
(indirectly branch to another location, while saving the location of the
porównanie dwóch wartości w rejestrach, np. test czy mniejszy lub test
next instruction as a point to return to (a call))
równości itp.
(compare two values in registers, for example, to see if one is less, or if they
are equal)
http://en.wikipedia.org/wiki/Instruction_set
Instructions Types
Typy instrukcji
Data Transfer [2#2]
wymiana danych (Data Transfer) [1#2]
P89LPC952/954 User Manual. NXP Semiconductors, UM10147, Rev. 02 - 28 April 2008
Load and Transfer MOV, MOVC, MOVX, XCH, XCHD, SWAP
MCS51
Stack operation PUSH, POP
Load and Transfer MOV, MOVW, LDI, LD, LDD, LDS, CLR, SET,
wpis zadanej wartości do rejestru (set a register to a fixed constant
AVR
ST, STD, STS, LPM, SPM,
value; a temporary "scratchpad" location in the CPU itself)
IN, OUT
8-bit AVR Instruction Set.
Atmel Corporation, Rev. 0856G AVR 07/08
Stack operation PUSH, POP
przenoszenia danych z pamięci do rejestru lub na odwrót (move data
Load and Transfer MOV
MSP430x4xx Family User s Guide.
from a memory location to a register, or vice versa); w celu uzyskania
MSP430 Texas Instruments, SLAU056J, January 2010
Stack operation PUSH
danych do wykonywania dalszych obliczeń lub zapisania wyniku
obliczeń
Load and Transfer MOV, MOVN, LDR, STR, LDM, STM, SWP
ARM
Stack operation LDM, STM, PUSH (Thumb STM), POP (Thumb LDM)
odczyt/zapis z/do układów peryferyjnych (read and write data from RealView� Developer Kit. Assembler Guide. ARM DUI 0283B, Version 2.2 - April 2005
hardware devices)
Load and Transfer MOV, XCHG, CMPXCHG, CMPXCHG8B,
IA-32
BSWAP, XADD, CWD/Q/W/E
Architectures
Intel� 64 and IA-32 Architectures. Software Developer s
IN, OUT
Manual. Volume 1: Basic Architecture. Intel Corporation,
Stack operation PUSH, POP Order Number: 253665-037US, January 2011
4
ARM Architecture Reference Manual. Thumb-2 Supplement. ARM Architecture Reference Manual. Thumb-2 Supplement.
ARM DDI 0308D, p. 4-96/4-98 ARM DDI 0308D, p. 4-96/4-98
ARM Cortex
Cortex
Multiple Data Transfer
Multiple Data Transfer
SIMD (Single Instruction, Multiple Data)
LDM | STM {} Rn {!},
SIMD (Single Instruction, Multiple Data)
określa jeden z trybów adresowania:
LDM | STM Rn {!},
IA, IB (instrukcja ARM), DA (instrukcja ARM), DB
określa jeden z trybów adresowania: IA, DB
Increment or Decrement, After (przed) lub Before (po)
Increment or Decrement, , After (przed) lub Before (po)
LDMxx R10, {R0, R1, R4}
lista rejestrów
STMxx R10, {R0, R1, R4}
I lub D korekta LDMDB / LDMEA Load Multiple Decrement Before (Load Multiple Empty
rejestru Rn Ascending Stacks)p.4-96 wielokrotny odczyt kolejnych komórek pamięci
xx: IA IB DA DB
(R10) o liczbę adresowanej rejestrem bazowym Rn (liczba odczytów zależy od listy
R4
transferowa- rejestrów ); rejestr bazowy Rn dekrementowany (%4)
R4 R1
nych bajtów przed odczytem danych
R1 R0
kierunek LDMIA / LDMFD Load Multiple Increment After (Load Multiple Full
R10
R0 R4
narastania
rejestr Descending Stacks)p.4-98 wielokrotny odczyt kolejnych komórek
! aktualizacja rejestru
adresów
R1 R4
bazowy
pamięci adresowanej rejestrem bazowym Rn (liczba odczytów zależy
Rn (R10) po
R0 R1
od listy rejestrów ); rejestr bazowy Rn inkrementowany
zakończeniu
R0
transferu danych (+4) po odczycie danych
8-bit AVR Instruction Set.
Atmel, Rev. 0856G AVR 07/08, doc0856, p.15
Znaczniki
Arithmetic Instructions
C, H, V, S, N, Z (AVR - 1/2)
ADD Integer add (DADD(.B) Add src and C decimally to dst MSP430)
Rd Rr bez znaku
ADC Add with carry (DADC(.B) Add C decimally to destination MSP430)
C H V N S Z
INC Increment
0xFF + 1 = 1111 1111b 255 + 1 = 256 !
DAA Decimal adjust after addition
0000 0001b  1 + 1 = 0
C=1 0000 0000b 1 1 0 0 0 1
SUB Subtract (RSB Reverse Subtract ARM)
ze znakiem
SBB Subtract with borrow (RSC Reverse Subtract with Carry ARM)
H
V R
DEC Decrement
CMP Compare (CMN Compare Negative ARM)
C = 1, Rd7=1, Rr7=0, R7=0 C = Rd7 " Rr7 +Rr7 " R7 +R7 " Rd7
(CPC Compare with Carry AVR)
H = 1, Rd3=1, Rr3=0, R3=0
(CPSE Compare Skip if Equal AVR) H = Rd3 " Rr3 +Rr3 " R3 +R3 " Rd3
V = 0, Rd7=1, Rr7=0, R7=0
(DJNZ Decrement and Jump if Not Equal C51)
N = 0, R7=0
V = Rd7 " Rr7 " R7 + Rd7 " Rr7 " R7
DAS Decimal adjust after subtraction
S = 0
N = R7
Z = 1, all Rn=0
NEG Arithmetic negate
S = N�" V
MUL Unsigned multiply
C51: OV = C xor A7 | 6
Z = R7 " R6 " R5 " R4 " R3 " R2 " R1 " R0
P = parzysta liczba 1 w Acc i P
DIV Unsigned divide
Intel 64 and IA-32 Architectures. Software Developer s Manual.
Volume 1: Basic Architecture. Intel Corporation, Order Number
253665-037US, January 2011, p.5-5
Znaczniki
Instrukcje logiczne
C, H, V, S, N, Z (AVR - 2/2)
przesunięcia i obroty
Rd Rr bez znaku
C H V N S Z
Instrukcje logiczne AND, OR, (XOR) i NOT wykonują podstawowe
0x7F + 1 = 0111 1111b 127 + 1 = 128
operacje logiczne dla bajtu, słowa i podwójnego słowa.
0000 0001b +127 + 1 =  128 !
C=0 1000 0000b 0 1 1 1 0 0
A xor B = [A and (not B)] or [(NOT A) and B]
ze znakiem
H
V R
C = 0, Rd7=0, Rr7=0, R7=1
C = Rd7 " Rr7 +Rr7 " R7 +R7 " Rd7
Instrukcje przesunięć (shift) i obrotów (rotate) przesuwają i obracają
H = 1, Rd3=1, Rr3=0, R3=0
bity w słowie i podwójnym słowie (arytmetyczne lub logiczne).
H = Rd3 " Rr3 +Rr3 " R3 +R3 " Rd3
V = 1, Rd7=0, Rr7=0, R7=1
N = 1, R7=1
V = Rd7 " Rr7 " R7 + Rd7 " Rr7 " R7
scrN scr0
S = 0 scrN scr0 0
C
N = R7
Z = 0, all Rn=0
obrót (rotate)
przesunięcie (shift)
S = N�" V
C51: OV = C xor A7 | 6
Z = R7 " R6 " R5 " R4 " R3 " R2 " R1 " R0
P = parzysta liczba 1 w Acc i P
5
Intel� 64 and IA-32 Architectures.
Software Developer s Manual.
Volume 1: Basic Architecture.
Intel Corporation, Order Number
Shift and Rotate Instructions [1#2]
253665-037US, January 2011, p.7-18
Logical Instructions
LEFT
scrN scr0 RIGHT
scrN scr0
rotate
RRX (Rotate right scrN scr0 C
scrN scr0
C
Z = not X Z = X and Y Z = X or Y Z = X xor Y
with extend moves)
Z X Z X Y Z X Y Z X Y
scrN scr0 C
1 0 0 0 0 0 0 0 0 0 0
0 1 0 1 0 1 1 0 1 1 0
logical shift
scrN scr0 C
scrN scr0
C 0 0
0 0 1 1 0 1 1 0 1
1 1 1 1 1 1 0 1 1
arithmetic shift scrN scr0 C
Z = X xor Y = (X and (not Y)) or ((not X) and Y)
dstN dst0 dstN dst0 CF
CF
MCS51 AVR MSP430 ARM IA 32
dstN dst0 dstN dst0
NOT CPL COM *INV(.B) NOT
(only Acc) (One s Complement) BIC(.B) CMN(ot), MVN(ot)
 instruction shifts the bits in the destination operand to the left (right) and fills the
empty bit positions (in the destination operand) with bits shifted out of the source
AND ANL AND, ANDI(mmediate) AND(.B) AND AND
operand
BIT(.B)
 shift count can range from 0 to 31 bits
OR ORL OR, ORI(mmediate) BIS(.B) ORR, ORN(ot) OR
 source operand is not modified
XOR XRL EOR XOR(.B) EOR XOR  CF flag is loaded with the last bit shifted out of the destination operand.
A[31:0] control
Address register
ARM
Shift and Rotate Steve Furber:
P P ARM System-
przesunięcia 32-bitowej zmiennej incrementer
Barrel shifter [1#3]
on-Chip
C C
Instructions [2#2]
zawartej w jednym rejestrów, w lewo
Architecture.
2nd Edition.
lub w prawo o zadaną liczbę bitów,
Register Addison
Wesley, 2001,
przed wpisem do ALU
bank
p.92
A
N
K K-1 0
L
przesunięcia zwiększają wydajność
Instruction
Before: U
wielu operacji przetwarzania danych
decode
A
SWAP
mult
b
N &
K K-1 0
5 różnych operacji przesunięcia:
u
b
After: control
s B
u
% logiczne przesunięcie w lewo
s
Barrel
(logical shift left) LSL
b
shifter u
% logiczne przesunięcie w prawo
s
(logical shift right) LSR
ALU
% arytmetyczne przesunięcie w prawo
N
K K-1 0
(arithmetic shift right) ASR
Before:
Sign (or Zero)
% obrót w prawo
extension (IA 32)
N
(rotate right) ROR
K K-1 0
After:
Data out register Data in register
% rozszerzony obrót w prawo
(rotate right extended) RRX
Steve Furber: ARM System-on-Chip Architecture. Steve Furber: ARM System-on-Chip Architecture.
2nd Edition. Addison Wesley, 2001, p.92 2nd Edition. Addison Wesley, 2001, p.92
ARM
ARM
Barrel shifter [2#2]
Barrel Shifter [1#2] Barrel
shifter
przy przesunięciu w lewo in[3..0] = 1100
ALU
lub w prawo włączana jest
no shift
right 3 right 2 right 1
właściwa przekątna
ilustracja zasady działania
in[3] = 1
przesuwnika w oparciu o
no shift
right 3 right 2 right 1
matrycę 4 x 4 (cross-bar switch w ARM przesuwnik działa w
left 1
in[2] = 1
in[3]
4 x 4 matrix)  ARM używa
logice ujemnej (stan "1" jest
left 1
matrycy 32 x 32 left 2
reprezentowany jako in[1] = 0
in[2]
left 2
potencjał masy GND, a
left 3
każde wejście jest połączone in[0] = 0
stan '0  jako potencjał
in[1]
left 3
z wyjściem przez matrycę
bliski zasilaniu VCC)
przełaczników - tranzystorów
in[0]
NMOS
wyjścia niepodłączone do
out[0] out[1] out[2] out[3]
wejść są w stanie
przesunięcie realizowane
shift left 1 "! out[3..0] = 1000
"!
"!
"!
naładowania, co jest
out[0] out[1] out[2] out[3]
przez włączenie odpowiedniej
"!
"!
"!
traktowane jako stan  0 shift right 1 "! out[3..0] = 0110
przekątnej matrycy
6
http://en.wikipedia.org/wiki/Bitwise_operation
Operacje bitowe Operacje bitowe
(Bitwise operation) [1#2] (Bitwise operation) [2#2]]
Clear/Set/Toggle wybranych bitów w R2: R26, R25, R22 i R20.
rejestr R2: 7 6 5 4 3 2 1 0
operacje wykonywane na jednym lub kilku bitach
Mask EQU 0110 0101b ; bity maski
szybkie operacje realizowane najczęściej bezpośrednio przez
jednostkę ALU; stosowane do porównań i obliczeń
;maska: 0 1 1 0 0 1 0 1
wskazania bitów zgodne z zapisem binarnym; od lewej do prawej
Clear_bits: AND R2, #NOT Mask ; R2 �! R2 AND NOT Mask
Set_bits: OR R2, #Mask ; R2 �! R2 OR Mask
Toggle_bits: XOR R2, #Mask ; R2 �! R2 XOR Mask
MSP430x4xx Family User s Guide. MSP430x4xx Family User s Guide.
Texas Instruments, SLAU056J, January 2010, p.3-17 Texas Instruments, SLAU056J, January 2010, p.3-17
Instrukcje emulowane MSP430
(Emulated Instructions) Emulated Instructions
Instr. emulowane Instr. procesora
INC dst ADD #1, dst ; Increment
nie istnieją w kodzie maszynowym procesora (brak instrukcji)
INCD dst ADD #2, dst ; Double increment
DEC dst SUB #1, dst ; Decrement
automatycznie zastępowane instrukcji emulowanych przez
INV dst XOR # 1, dst ; Invert
równoważne podstawienie właściwych instrukcji w trakcie asemblacji
(1 do 1) TST dst CMP #0, dst ; Test destination
BR dst MOV dst, PC ; Branch to destination
łatwiejsza praca w asemblerze
RLA dst ADD dst, dst ; Rotate left arithmetic
; (shift left 1 bit)
RLC dst ADDC dst, dst ; Rotate left through carry
Intel 64 and IA-32 Architectures. Software Developer s Manual.
Volume 1: Basic Architecture. Intel Corporation, Order Number:
253665-037US, January 2011
Conditional Data Transfer Instructions
Conditional Data Transfer Instructions
IA-32 Architectures [2#2]
IA-32 Architectures [1#2]
CMOVNS Conditional move if not sign (non-negative)
MOV Move data between general-purpose registers; move data
CMOVP/CMOVPE Conditional move if parity/Conditional move if parity even
between memory and general-purpose or segment registers;
CMOVNP/CMOVPO Conditional move if not parity/Conditional move if parity odd
move immediates to general-purpose registers
XCHG Exchange
CMOVE/CMOVZ Conditional move if equal/Conditional move if zero
BSWAP Byte swap
CMOVNE/CMOVNZ Conditional move if not equal/Conditional move if not zero
XADD Exchange and add
CMOVA/CMOVNBE Conditional move if above/Conditional move if not below or equal
CMPXCHG Compare and exchange
CMOVAE/CMOVNB Conditional move if above or equal/Conditional move if not below
CMPXCHG8B Compare and exchange 8 bytes
CMOVB/CMOVNAE Conditional move if below/Conditional move if not above or equal
PUSH Push onto stack
CMOVBE/CMOVNA Conditional move if below or equal/Conditional move if not above
POP Pop off of stack
CMOVG/CMOVNLE Conditional move if greater/Conditional move if not less or equal
PUSHA/PUSHAD Push general-purpose registers onto stack
CMOVGE/CMOVNL Conditional move if greater or equal/Conditional move if not less
POPA/POPAD Pop general-purpose registers from stack
CMOVL/CMOVNGE Conditional move if less/Conditional move if not greater or equal
CWD/CDQ Convert word to doubleword/Convert doubleword to quadword
CMOVLE/CMOVNG Conditional move if less or equal/Conditional move if not greater
CBW/CWDE Convert byte to word/Convert word to doubleword in EAX
CMOVC Conditional move if carry
register
CMOVNC Conditional move if not carry
MOVSX Move and sign extend
CMOVO Conditional move if overflow
MOVZX Move and zero extend
7
N Z C V " " "
Cortex-M0: xPSR
0
31 30 29 28
Efektywność instrukcji ARM
ARM
ARM Architecture Reference Manual.
Instruction Set ARM DDI 0100E. ARM DDI 0027D, June 2000, p.A3-6
C instruction:
if (Z == 1) R1 = R2 + ( R3 " 4) ;
unsigned
HI higher
C set and Z clear Compiled ARM instruction:
EQADDS R1, R2, R3, LSL #2
unsigned lower signed greater
AL always
LS or same than
C clear or Z set Z clear, and either
equal negative EQADDS R1, R2, R3, LSL #2
EQ MI
GT N set and V set,
Z set N set
signed greater
or
than or equal
N clear & V clear
positive or
ADD {cond} {S} Rd, Rn,
not equal N set and V set,
GE (Z == 0,N == V)
NE PL zero
Z clear or
R1 = R2 + R3 SHL 2
N clear
N clear and
signed less
V clear (N == V)
unsigned
than or equal Z=1 "! (Equal) EQ
CS
higher or overflow
signed less Z set,
/ VS
V set
same or sets condition flags after instruction "! S
than
HS LE
C set N set and V clear,
N set and V clear,
LT
or Rm LSL #5bit_Imm "!
or
CC unsigned no
N clear and V set
/ lower overflow
VC N clear and V set
Logical Shift Left
(Z == 1 or N != V)
(N != V)
LO C clear V clear
Adresowanie natychmiastowe
Tryby Adresowania
(Immediate Addressing)
Natychmiastowy (immediate / literal: immediate, pre-indexed immediate
operacje z wartością stałej zapisanej w pamięci programu jako część
offset, post-indexed immediate offset, ..)
wykonywanej instrukcji:
Rejestrowy (register or pre-indexed register offset, post-indexed register
ANL P1, #01110011B ; MCS51: P1 �! P1 and 01110011b
offset, ..)
; zerowanie bitów: 7, 3 i 2 portu P1
add A, #$15 ; ST7: A �! A + $15
Bezpośredni / absolutny (direct / absolute: short, long, ..)
ldi r17, 0xFF ; AVR: R17 �! 0FFh
Pośredni / rejestrowo pośredni (Indirect / Register indirect: register
DADD.W #0x9876, R5 ; MSP430: 9876h + R5 + C R5
autoincrement indirect, autodecrement register indirect, memory indirect, ..)
; (dziesiętnie)
Relatywny / symboliczny / indeksowy (Relative / Symbolic / Indexed: PC-
LDR R0, [R1, {#imm}] ; Cortex-M0: wpisz do rejestru R0
relative, PC-relative with index and offset, displacement, relative, base
; zawartość pamięci RAM
register, base plus index, base plus index plus offset addressing, ..)
; o adresie [R1 + imm]
; { } wartość opcjonalna (do wyboru)
Stos (Stack: register indirect, ..)
Adresowanie rejstrowe Adresowanie bezpośrednie
(Register Addressing) (Direct Addressing)
operacje z wykorzystaniem adresów komórek pamięci lub adresów
rejestrów:
operacje na rejestrach:
ANL P1, #01110011B ; C51: (P1) �! (P1) and 01110011b
ANL B, #01110011B ; C51: B �! B and 01110011b
ld A, $4B ; ST7: A �! ($4B)
add A, #$15 ; ST7: A �! A + $15
lds r12, 0x00FF ; AVR: R12 �! (00FFh)
ldi r17, 0xFF ; AVR: R17 �! 0FFh
MOV &EDE, &TONI ; MSP430: (EDE) (TONI)
DADD.W #0x9876, R5 ; MSP430: 9876h + R5 + C R5
; (dziesiętnie)
LDR PC, Reset_Addr ; ARM: PC �! (Reset_Addr)
; nie można wpisać 32-bitowej zmiennej do rejestru w jednym
MOV R2, R0, LSL #2 ; Cortex-M0: przesuń R0
; 32-bitowym słowie, ponieważ instrukcja ma również długość
2-krotnie w
; 32 bitów
; lewo i wynik wpisz do R2
; (R2 �! R0 " 4)
8
Adresowanie pośrednie Adresowanie indeksowe
(Indirect Addressing) (Indexed Addressing)
MOVC A, @A+DPTR ; C51: A �! (A + DPTR)CODE
adres komórki pamięci RAM lub rejestru jest zawarty w rejestrze lub
wskaz
niku:
LD A, ([ptr.w], X) ; ST7: A �! ([ptr.word], X)
ADD A, @R1 ; C51: A �! A + (R1), tylko R0, R1
LD Rd, X ; AVR: Load Indirect from Data Space
cp A, [ptr] ; ST7: Reg CC: {N, Z, C} �! A  ((ptr))
LD Rd, X+ ; to Register using Index X
LD Rd,  X
ld r10, X ; AVR: R10 �! (X),
; odczytaj komórkę pamięci o adresie w X
MOV 2(R5), 6(R6) ; MSP430: (2 + (R5)) (6 + (R6))
; lub Y lub Z i wpisz do r10
LDRcc R0, [R1, #12] ! ; ARM: if cc = true, then R1 = R1 + 12
cmp @r6, r7 ; MSP430: r7  (r6) Reg SR: {N, Z, C, V}
; R0 �! (R1 + 12), pre-indexed
LDRcc R0, [R1], #12 ; ARM: R0 �! (R1), post-indexed
STR R3, [R2] ; ARM: [R2] �! R3,
; if cc = true, then R1 = R1 + 12
; wpisz R3 do pamięci RAM o adresie w R2
RealView� Developer Kit. Assembler Guide.
ARM DUI 0283B, Version 2.2 - April 2005
Adresowanie pamięci  tryb 2
Adresowanie względne
Load and Store Word or Unsigned Byte
(Relative Addressing)
LDR|STR{}{B}{T} ,
DJNZ Rn, rel ; C51: Rn �! Rn  1
; if Rn = 0 then PC �! PC + rel
where is one of the nine options for Word or Unsigned
JRcc label ; ST7: if (cc == 1) then
Byte:
; PC = PC + oft
; or PC = PC + (oft) [, #+/-] Immediate offset
; else PC = PC
[, +/-] Register offset
RJMP k ; AVR: PC �! PC + k + 1 [, +/-, #] Scaled register offset
;  2K d" k < 2K
[, #+/-]! Immediate pre-indexed
MOV EDE, TONI ; MSP430: MOV X(PC), Y(PC)
[, +/-]! Register pre-indexed
; X = EDE - PC
; Y = TONI - PC [, +/-, #]! Scaled register pre-indexed
[], #+/- Immediate post-indexed
LDR Rd,=const ; ARM7: LDR Rn, [PC, #offset to literal pool]
[], +/- Register post-indexed
; load Rn register with one word
; from the address [PC + offset] [], +/-, # Scaled register post-indexed
Problemy i pytania
1. Czym jest instrukcja procesora ?
2. Jakie składniki tworzą instrukcje procesora ?
3. Jakie typy instrukcji są dostępne w procesorach ?
4. Na czym polegają instrukcje SIMD ?
5. Jakie jest przeznaczenie znaczników: N, Z, C, V ?
6. Czym się różnią operacje  shift od  rotate ?
7. Na czym polega maskowanie bitów ?
8. Czym są instrukcje emulowane ?
9. Czym się różnią instrukcje warunkowe od bezwarunkowych ?
10. Podać stosowane w procesorach tryby adresowania.
11. Na czym polega adresowanie natychmiastowe ?
12. Na czym polega adresowanie bezpośrednie ?
13. Na czym polega adresowanie pośrednie ?
14. Na czym polega adresowanie rejestrowe ?
15. Na czym polega adresowanie indeksowe ?
16. Czym jest etykieta ?
9