Edição atual tal como às 14h50min de 25 de maio de 2021

Lista de Exercícios para (AT1)

Nota: Nossa primeira avaliação será dia 29/06/2021 conforme previsto. Esta lista de exercícios servirá de guia de estudos para vocês, não vou corrigi-la e também vocês não precisarão entregá-la mas vou tirar todas as dúvidas de vocês via grupo do Whatsapp.

Questões

Parte1

Por que estudar microprocessadores?
O que é um microprocessador?
Disserte sobre o que significa, quando começou e quando terminou a chamada "lei de Moore".
Explique o que significa single-core e multi-core em se tratando arquitetura de microprocessadores.
O que você entende por um computador?
Quais os principais tipos de computador?
O que é um Cluster e como funciona?
O que são e para que servem os Mainframes?
O que difere um computador Desktop para um Supercomputador?
No que se difere os "ditos" sistemas embarcados microcontrolados dos outros tipos de computadores?
Cite 5 dispositivos eletrônico que você conheça que possuam Sistemas Embarcados?
O que é RFID?
Complete o desenho abaixo no que se refere a arquitetura e organização de um computador.
O que é memória cache?
O que é Hardware?
Fale sobre as três operações básicas realizados por um computador e o que cada uma delas faz.
Complete a figura abaixo com as seis camadas de abstrações propostas por Tenenbaum, 1999.
O que um Firmware?
O que é um Software?
Quais as principais etapas de um algoritmo para a obtenção de uma solução computacional?
O que é linguagem de máquina?
O modelo computacional idealizado por Von Neumann é baseado quais componentes principais?
Qual aspecto mais importante do modelo de Von Neumann?
Qual a principal diferença entre a arquitetura de Von Neumann e de Havard?
Fale sobre o modelo de barramento de sistema.
O que é um sinal de clock?
Como é composto um sistema de computador típico?

Parte 2

A que é a CPU e pelo que é responsável?
O que é uma instrução?
Qual é um formato típico de uma instrução de 8 bits?
O que é mnemónico?
Por que a maioria dos programas são escritas em linguagens de alto nível ao contrário de linguagem de máquina?
Como fica um programa depois de compilado?
Quais são as etapas básicas de funcionamento de um microprocessador?
Quais são os elementos de uma estrutura generalizada de um microprocessador?
Para que serve a ULA?
Para que serve a FPU?
Para que servem os registradores e como são divididos?
Para que serve o Acumulador?
Para que serve o Registrador de flags?
O que são PC e IR?
O que são MBR e MAR?
Para que serve o Stack Pointer (SP)?
O significa LIFO? Explique.
Como estão divididos os registrador do processador ARM7?
Quantos registradores possuem o ATMega328P?
Como funciona a UC?
O que é ciclo de instrução?
O que é "uma busca de dados"?
Para que serve as interrupções?
Sobre o desempenho de microprocessadores é correto dizer que depende somente do clock?
Qual a causa da CPU trabalhar com "rajadas longas" ou "rajadas curtas"?
Suponha que queiramos executar uma instrução de máquina que soma três números que estão na memória e salve o resultado em outro endereço de memória
```
int a=10, b=20, c=30, t; \\sendo a no endereço 100, b no 101, c no 102 e t no 104
```
Coloque todas as etapas (PC, IR, MAR e MBR) para fazer t=a+b e depois t=t+c no mesmo programa.
O que é um barramento?
Como funciona o barramento de dados?
Como funciona o barramento de endereços?
Como funciona o barramento de controle?
Cite os sinais típicos de controle?
Qual a diferença entre um microcontrolador e um microcomputador?

Respostas

[26]

;int a=10, b=20, c=30, t; \\sendo a no endereço 100, b no ;101, c no 102 e t no 104

200: M[104] = M[100] + M[101]
201: M[104] = M[104] + M[103]

PC = 200;
IR <- (M[104] = M[100] + M[101])
PC = PC + 1
MAR = 100
MBR <- 10
R1 = MBR
MAR = 101
MBR <- 20
R2 = MBR
R3 = R1 + R2
MAR = 104
MBR = R3
IR <- (M[104] = M[102] + M[104])
PC = PC + 1
MAR = 102
MBR <- 30
R1 = MBR
MAR = 104
MBR <- 30
R2 = MBR
R3 = R1 + R2
MAR = 104
MBR = R3
M[104] <- 60

Código que faz isso na prática em ASM

		;		Comecamos armazenando 4 valores na memoria
		;		int a=10, b=20, c=30, t; \\sendo a no endereço 100, b no ;104, c no 108 e t no 10C
		
		
		mov		R0, #10
		mov		R1, #0
		mov		R2, #16 ; 4 valores (4 bytes cada valor 4x4=16)
		mov		R3, #0x100  	; endereço base
loop		str		R0, [R3,R1]
		add		R1, R1, #4 	; endereços têm que ser múltiplos de 4
		add		R0, R0, #10
		cmp		R1, R2
		blt		loop
		;principal
		
		ldr		R4, [R3,#0] ; primeiro endereço a=10 em  0x100
		ldr		R5, [R3,#4] ; b=20 em 0x104
		add		R6, R4,R5	  ; t=a+b
		ldr		R4, [R3,#8] ; c=30 em  0x108
		add		R6, R6,R4   ; t=t+c
		str		R6, [R3,#12] ; t em 0x10C
		
fim

Parte 3

Converta o número 1488d:
1. base 2
2. base 8
3. base 16
Converta os números abaixo para base decimal:
1. A3BDh
2. 110100101.101b
3. 1683o
Converta os números abaixo para binário com sinal e amplitude de 8bits:
1. -70d
2. 70d
3. 53h
4. 232o
Converta o número decimal (positivo) em negativo utilizando complemento de 1:
1. 17d
2. 34d
3. 89d
4. 112d
Por que 0d=00000000b=11111111b em complemento de 1?
Converta o número decimal (positivo) em negativo utilizando complemento de 2:
1. 17d
2. 34d
3. 89d
4. 127d
Quais os números representados pelo complemento de 2 abaixo:
1. 001101101b
2. 111001010b
3. 001111100b
4. 101010101b
Se os números abaixo fossem representados por notação de Excesso 128, quais seriam?
1. 00110110b
2. 11100101b
3. 00111110b
4. 10101010b
O que é overflow? Exemplifique.
O que é carry? Exemplifique.
Explique como são representados os números reais em computadores?
Explique o que acontece quando se rotaciona um número binário para esquerda ou para direita?
Como é feita a notação de ponto flutuante?
Seja o byte 11111101b determinar:
1. O bit de sinal
2. O expoente
3. A mantissa
4. Valor decimal (considerando notação de excesso para expoente e ponto fixo para mantissa)
Seja o decimal 1,25d represente ele com notação de ponto flutuante de 8bits.
Para que serve a normalização do ponto flutuante?
O que é o bit escondido?
Explique o cuidado de se definir o intervalo e precisão de valores representáveis.
Qual o cuidado que o projetista de hardware' tem que ter com Overflow e Underflow?
Converta os valores decimais abaixo para a notação IEEE 754, precisão simples:
1. 2019.8125d
2. 570.5625d
Converta os valores ponto flutuante abaixo, notação IEEE 754 precisão simples, para base decimal:
1. 1110 0001 1110 0001 0000 0000 0000 0000
2. 0010 1010 1001 0101 1000 0000 0000 0000

Parte 4

Escreva um programa em ARM que implementa um loop com 20 iterações, incrementando uma variável do valor 0 a 19 e somando o valor 17, a cada iteração, ao valor inicial (=7) armazenado em R1.
Escreva o programa em ARM que implementa as operações lógicas (AND, OR, XOR, NXOR, NAND E NOR) entre dois valores, armazenados em R4 e R5.
Implemente um programa ARM que resolve a equação: Y = (A - B) / (C + D x E). Dica: armazene A em R0, B, em R1, C, em R2, D, em R3 e E, em R4.
Implemente um programa em ARM que lê e compara os valores armazenados em R1, R2 e R3 e devolve o maior dentre eles em R4, e o menor, em R5.
Implemente um programa em ARM que coloque em ordem crescente 10 valores da memória.

Respostas

* Algumas respostas!

Solução [1]

;PROGRAMA	QUE IMPLEMENTA R1 = R1 + 5, 40 VEZES
		;		i.e., R1 = R1 x 200
		;*******
		mov		r1, #7      ;valor inicial de R1
		mov		r2, #17      ;incremento de R1
		mov		r3, #20     ;numero de loops
		mov		r4, #0      ;valor inicial do contador
		;***INICIA	LOOP ***
loop		add		r1, r1, r2  ;r1 = r1 + r2 (7+17)
		add		r4,r4, #1   ;r4 = r4 + 1
		cmp		r4,r3	   ;r4 < r3?
		blt		loop        ; se for menor pula pro loop
fim

Mudanças entre as edições de "MI1022806 2021 1 AULA05"

Edição atual tal como às 14h50min de 25 de maio de 2021

Índice

Lista de Exercícios para (AT1)

Questões

Parte1

Parte 2

Respostas

Parte 3

Parte 4

Respostas

Menu de navegação

Pesquisa

@@ Linha 1: / Linha 1: @@
-=Conjuntos de Instruções=
+=Lista de Exercícios para (AT1)=
-Um programador de linguagem de alto nível normalmente conhece muito pouco acerca da arquitetura da máquina que está usando.
+;Nota: Nossa primeira avaliação será dia 29/06/2021 conforme previsto. Esta lista de exercícios servirá de guia de estudos para vocês, não vou corrigi-la  e também vocês não precisarão entregá-la mas vou tirar todas as dúvidas de vocês via grupo do Whatsapp.
-O conjunto de instruções da máquina é o limite em que o projetista de CPU e o programador de baixo nível enxergam, da mesma máquina.
+==Questões==
-Implementar uma CPU é uma tarefa que envolve, em grande parte, implementar um conjunto de instruções de máquina.
+===Parte1===
-Já programar em ''linguagem de máquina'' (na verdade, em '''linguagem de montagem''', ''Assembly'') exige um conhecimento acerca do conjunto de registradores da CPU, a estrutura de memória, os tipos de dados disponíveis na máquina e o funcionamento da ULA.
+#Por que estudar microprocessadores?
+#O que é um microprocessador?
+#Disserte sobre o que significa, quando começou e quando terminou a chamada "lei de Moore".
+#Explique o que significa ''single-core'' e ''multi-core'' em se tratando arquitetura de microprocessadores.
+#O que você entende por ''um computador''?
+#Quais os principais tipos de computador?
+#O que é um ''Cluster'' e como funciona?
+#O que são e para que servem os ''Mainframes''?
+#O que difere um computador ''Desktop'' para um Supercomputador?
+#No que se difere os "ditos" sistemas embarcados microcontrolados dos outros tipos de computadores?
+#Cite 5 dispositivos eletrônico que você conheça que possuam Sistemas Embarcados?
+#O que é RFID?
+#Complete o desenho abaixo no que se refere a arquitetura e organização de um computador.[[imagem: fig067_MI1022806.png|400px|center]]
+#O que é memória cache?
+#O que é ''Hardware''?
+#Fale sobre as três operações básicas realizados por um computador e o que cada uma delas faz.
+#Complete a figura abaixo com as seis camadas de abstrações propostas por Tenenbaum, 1999.[[imagem: fig068_MI1022806.png|400px|center]]
+#O que um ''Firmware''?
+#O que é um ''Software''?
+#Quais as principais etapas de um algoritmo para a obtenção de uma solução computacional?
+#O que é linguagem de máquina?
+#O modelo computacional idealizado por Von Neumann é baseado quais componentes principais?
+#Qual aspecto mais importante do modelo de Von Neumann?
+#Qual a principal diferença entre a arquitetura de Von Neumann e de Havard?
+#Fale sobre o modelo de barramento de sistema.
+#O que é um sinal de ''clock''?
+#Como é composto um sistema de computador típico?
-Porém, da descrição do conjunto de instruções à uma compreensão sobre o funcionamento da CPU, há um longo caminho.
+===Parte 2===
-==Características de Instruções de Máquinas==
+#A que é a CPU e pelo que é responsável?
+#O que é uma instrução?
+#Qual é um formato típico de uma instrução de 8 bits?
+#O que é mnemónico?
+#Por que a maioria dos programas são escritas em linguagens de alto nível ao contrário de linguagem de máquina?
+#Como fica um programa depois de compilado?
+#Quais são as etapas básicas de funcionamento de um microprocessador?
+#Quais são os elementos de uma estrutura generalizada de um microprocessador?
+#Para que serve a ULA?
+#Para que serve a FPU?
+#Para que servem os registradores e como são divididos?
+#Para que serve o Acumulador?
+#Para que serve o Registrador de flags?
+#O que são PC e IR?
+#O que são MBR e MAR?
+#Para que serve o Stack Pointer (SP)?
+#O significa LIFO? Explique.
+#Como estão divididos os registrador do processador ARM7?
+#Quantos registradores possuem o ATMega328P?
+#Como funciona a UC?
+#O que é ciclo de instrução?
+#O que é "uma busca de dados"?
+#Para que serve as interrupções?
+#Sobre o desempenho de microprocessadores é correto dizer que depende somente do ''clock''?
+#Qual a causa da CPU trabalhar com "rajadas longas" ou "rajadas curtas"?
+#Suponha que queiramos executar uma instrução de máquina que soma três números que estão na memória e salve o resultado em outro endereço de memória<pre>int a=10, b=20, c=30, t; \\sendo a no endereço 100, b no 101, c no 102 e t no 104</pre>Coloque todas as etapas (PC, IR, MAR e MBR) para fazer t=a+b e depois t=t+c no mesmo programa.
+#O que é um barramento?
+#Como funciona o barramento de dados?
+#Como funciona o barramento de endereços?
+#Como funciona o barramento de controle?
+#Cite os sinais típicos de controle?
+#Qual a diferença entre um microcontrolador e um microcomputador?
-A operação de uma CPU é determinada pelas instruções que ela executa, conhecidas como '''instruções de máquina'''.
+====Respostas====
-A coleção de instruções que uma determinada CPU é capaz de executar é conhecida como '''conjunto de instruções da CPU'''.
+{{collapse top|[26]}}
+<pre>
+;int a=10, b=20, c=30, t; \\sendo a no endereço 100, b no ;101, c no 102 e t no 104
-===Elementos de Instrução de Máquina===
+: M[104] = M[100] + M[101]
+: M[104] = M[104] + M[103]
-Cada instrução deve conter toda a informação necessária para que a CPU possa executá-la.
+PC = 200;
+IR <- (M[104] = M[100] + M[101])
-[[imagem: fig104_MI1022806.png|center]]
+PC = PC + 1
+MAR = 100
-A figura acima ajuda a definir os elementos da instrução:
+MBR <- 10
+R1 = MBR
-* Código de operação (''OPCODE'') - Especifica a operação a ser efetuada (por exemplo, ADD, ou E/S, etc). A operação é especificada por um código binário.
+MAR = 101
-Ex: [https://wiki.ifsc.edu.br/mediawiki/index.php/AULA_13_-_Eletr%C3%B4nica_Digital_1_-_Gradua%C3%A7%C3%A3o#Unidade_L.C3.B3gico-Aritm.C3.A9tica_.28ULA.29 Palavra de seleção (SMCn) em uma ULA de 4 bits]
+MBR <- 20
+R2 = MBR
-* Referência a operando fonte - a operação pode envolver um ou mais operandos fonte, ou seja, que constituem dados de entrada para a operação. '''Exemplos:'''
+R3 = R1 + R2
-** operação com um único operando: INV(A)
+MAR = 104
-** operação com dois operandos: ADD(A,B)
+MBR = R3
-** operação com três ou mais operandos: DEV(GE(A,B),C,D)
+IR <- (M[104] = M[102] + M[104])
+PC = PC + 1
-* Referência a um operando de destino - a operação pode eventualmente produzir um resultado, que deverá ser enviado a um endereço de memória, ou registrador
+MAR = 102
+MBR <- 30
-* Endereço da próxima instrução - indica aonde a CPU deve buscar a próxima instrução (memória principal ou virtual), depois que a instrução corrente for completada, quando for o caso.
+R1 = MBR
+MAR = 104
-Os operandos fonte e destino podem estar localizados em:
+MBR <- 30
+R2 = MBR
-* Memória principal ou virtual - implica em busca na memória RAM, ou no HD (quando virtual)
+R3 = R1 + R2
-* Registrador da CPU - se houver apenas um registrador, a referência a ele poderá ser implícita. Quando há acumulador, a referência a ele é ''default''. Caso hajam vários registradores, normalmente a referência a cada um, individualmente, é feita por um número inteiro correspondente.
+MAR = 104
-* Dispositivo de E/S - indicado diretamente na instrução. Se for usada a E/S mapeada na memória, esta informação se resumirá a um endereço de memória, como os demais. Pode ser também um registrador específico (Ex: porta serial).
+MBR = R3
+M[104] <- 60
-==Representação de Instruções==
-Internamente, cada instrução é representada por uma sequência de bits.
-É dividida em '''campos''', correspondentes aos elementos da instrução.
-'''Exemplos:'''
-<center><b>
-{| class="wikitable"
-|-
-! style="width: 150px;"|4 bits
-! style="width: 150px;"|6 bits
-! style="width: 150px;"|6 bits
-|-
-! style="background:#6A5ACD; color:white;"|Código da operação
-! style="background:#6A5ACD; color:white;"|Referência a operando
-! style="background:#6A5ACD; color:white;"|Referência a operando
-|-
-!style="text-align:center; colspan=3";| 16 btis
-|}
-</center></b>
-<br><br>
-<center><b>
-{| class="wikitable"
-|+Instrução na memória
-|-
-|0 &emsp; &emsp; &emsp; &emsp; &emsp; 7
-|8 &emsp; &emsp; &emsp; &emsp; &emsp; 19
-|20 &emsp; &emsp; &emsp; &emsp; &emsp; 27
-|28 &emsp; &emsp; &emsp; &emsp; &emsp; 39
-|-
-! style="background:#6A5ACD; color:white;"|OP<sub>1</sub>
-! style="background:#6A5ACD; color:white;"|END<sub>1</sub>
-! style="background:#6A5ACD; color:white;"|OP<sub>2</sub>
-! style="background:#6A5ACD; color:white;"|END<sub>2</sub>
-|}
-</center></b>
-[[imagem: fig106_MI1022806.png|center]]
-A maioria das CPUs têm mais de um formato de instrução.
-Durante a execução, uma instrução é lida em um registrador de instruções (IR) da CPU. A CPU extrai os dados dos vários campos da instrução e efetua a operação correspondente.
-Os códigos de operação normalmente são representados por abreviações, chamadas ''mnemônicos'', que evitam que os programadores tenham que trabalhar diretamente com valores binários.
-Alguns exemplos mais comuns são:
- ADD  -------------  Adição
- SUB  -------------  Subtração
- MPY  -------------  Multiplição
- DIV  -------------  Divisão
- GT   -------------  Operação >
- LT   -------------  Operação <
- GE   -------------  Operação &ge;
- LE   -------------  Operação &le;
-Os operandos também são representados por símbolos.
-Por exemplo:
-   ADD R, Y
-pode significar adicionar o valor contido na posição Y, com o valor contido no registrador R.
-Neste caso, Y é um endereço de memória e R, um registrador da própria CPU.
-;Exercício:
-Em uma [https://wiki.ifsc.edu.br/mediawiki/index.php/AULA_13_-_Eletr%C3%B4nica_Digital_1_-_Gradua%C3%A7%C3%A3o#Unidade_L.C3.B3gico-Aritm.C3.A9tica_.28ULA.29 ULA de inteiros de 4 bits], com formato de instrução '''''[OPCODE(5) A(4) B(4)]''''', qual seria a instrução correspondente, se a intenção fosse executar a operação lógica ''Y = OR(A', B) '', com ''A = 0001b'' e ''B = 1010''?
-==Número de Endereços==
-Uma das maneiras tradicionais de se descrever uma arquitetura é em termos do número de endereços contidos em cada instrução.
-Obviamente, instruções aritméticas e lógicas requerem um número maior de operandos (e de endereços, por conseguinte). Normalmente, precisam de dois operandos que serão submetidos a um cálculo ou comparação, e de um terceiro, pra armazenar o resultado.
-O endereço da próxima instrução normalmente é implícito, armazenado no registrador PC.
-A figura abaixo (a,b e c) compara o que seriam instruções típicas de um, dois ou três endereços, para computar a mesma linha de programação:
- Y = (A - B) / (C + D x E)
-[[imagem: fig107_MI1022806.png|400px|center]]
-Note que as instruções com 3 endereços implementaram o comando com apenas 4 instruções de máquina. Porém, instruções de 3 endereços não são muito comuns, porque implicam em instruções grandes.
-No caso das instruções de 2 endereços, foram necessárias 6 linhas de código, duas a mais, portanto. Nestas instruções é típico que um dos endereços referencie tanto o operando, quanto o resultado.
-Gera opcodes menores, porém gera códigos maiores e exige maior habilidade do programador.
-As instruções de 1 único endereço exigem que um segundo endereço seja sempre implícito (normalmente, o Acumulador - AC). Neste caso, foram necessárias 8 instruções para resolver o problema.
-É possível também usar-se em expressões aritméticas uma instrução com ZERO endereço. Neste caso, é necessária uma organização de memória especial, chamada '''''pilha'''''. As instruções com zero endereço sempre referenciam os valores nas duas posições no topo da pilha.
-<center><b>
-{| class="wikitable"
-|-
-! style="background:#6A5ACD; color:white; width: 150px;text-align:center;"|Número de Endereços
-! style="background:#6A5ACD; color:white; width: 150px;text-align:center;"|Representação simbólica
-! style="background:#6A5ACD; color:white; width: 150px;text-align:center;"|Interpretação
-|-
-! style="text-align:center;"|3
-|OP A, B, C
-|A &larr;  B OP C
-|-
-! style="text-align:center;!|2
-|OP A, B
-|A &larr; A OP B
-|-
-! style="text-align:center;!|1
-|OP A
-|AC &larr; AC OP A
-|-
-! style="text-align:center;!|0
-|OP
-|T &larr; (T-1) OP T
-|}
-</b></center>
-Além de tudo que foi citado, as instruções podem variar muito de tamanho porque o endereço em questão de cada operando pode se referir à memória física ou a um dos registradores da CPU. Como as memórias são muito maiores que o número de registradores, vão utilizar endereços muito mais longos.
-Assim, existem máquinas que, quando vão endereçar um valor NA MEMÓRIA externa (RAM) utilizam '''mais de uma instrução''' para acessar o dado.
-Tudo sempre vai depender da arquitetura da máquina.
-==Tipo de Instrução==
-Como já vimos, uma única instrução escrita em linguagem de alto nível pode requerer várias instruções de máquina.
-Os tipos de instrução de máquina que existem são:
-* Processamento de dados - instruções aritméticas e lógicas
-* Armazenamento/transferência de dados - instruções de memória
-* Movimentação de dados - instruções de E/S
-* Controle - instruções de teste e de desvio
-[[imagem: fig108_MI1022806.png|600px|center]]
-[[imagem: fig109_MI1022806.png|600px|center]]
-Na maioria das vezes, as instruções são autoexplicativas.
-As instruções do tipo transferência de controle, no entanto, podem ser muito complexas. Em todos os casos, exceto com elas a próxima instrução a ser executada é aquele que segue imediatamente a atual, na memória.
-Nas instruções de transferência de controle, a CPU atualiza o PC com o endereço de alguma outra instrução, armazenada na memória de programa.
-As instruções de transferência de controle são aquelas utilizadas quando há ''loops'' no código, ou comandos de decisão ou ainda quando o código teve que ser segmentado em vários arquivos, normalmente porque estava muito extenso.
-===Instruções de desvio===
-Nestas, um dos operandos é o endereço da próxima instrução a ser executada.
-Com frequência, essa instrução é do tipo '''desvio condicional''', isto é, o desvio só ocorrerá se uma determinada condição for satisfeita.
-Caso contrário, o programa segue com a próxima instrução adjacente, sem alterações no PC além do incremento normal.
-Estas instruções normalmente têm o nome de ''BRANCH'' ou ''JUMP'' e podem depender de uma condição, ou ser incondicionais.
-'''Exemplo:'''
-[[imagem: fig110_MI1022806.png|border|center]]
-===Instruções de chamada de procedimento===
-Um procedimento, ou função, ou ainda subrotina é um trecho de código independente que modulariza um programa.
-O mecanismo de controle de procedimentos envolve duas instruções básicas: uma instrução de '''chamada''', que desvia a instrução corrente para o início do procedimento, e uma instrução de '''retorno''', que provoca o retorno da execução para o endereço onde ocorreu a chamada. Ambas são condições de desvio.
-A figura abaixo ilustra o uso de procedimentos na execução de um programa.
-[[imagem: fig111_MI1022806.png|border|center]]
-==Instruções do Pentium II e do PowerPC==
-Para exemplificar, apresentamos o caso especial de conjunto de instruções de um processador de propósito geral que foi muito utilizado até o início da década de (20)00.
-[[imagem: fig112_MI1022806.png|600px|center]]
-[[imagem: fig113_MI1022806.png|600px|center]]
-[[imagem: fig114_MI1022806.png|600px|center]]
-=Conjunto de Instruções do ARM=
-O conjunto de instruções também é chamado de [https://en.wikipedia.org/wiki/Instruction_set_architecture '''"ISA - Instruction Set Architecture"'''].
-[[imagem: fig115_MI1022806.png|center]]
-A arquitetura ARM trabalha com três tipos de instruções: o ARM, THUMB e o THUMB-2.
-O conjunto THUMB de instruções de 16 bits trabalha com registradores de 32 bits.
-O código THUMB é capaz de reduzir em até 65% o tamanho de um código ARM (maior densidade de código), e aumentar em até 160% o desempenho, em relação a um processador ARM equivalente, conectado a um sistema de 16 bits, apenas.
-[[imagem: fig116_MI1022806.png|border|550px|center]]
-==Características do ISA ARM==
-* 13 registradores de propósito geral:
-** R0 a R7 (low registers)
-** R8 a R12 (high registers)
-* 3 registradores de uso/significado especial
-** r13: stack pointer (SP)
-** r14: link (LR)
-** r15: (PC)
-* 1 registrador de propósito especial
-** xPSR = Program Status Register
-* Registradores xPSR, PC, LR, R12, R3, R2, R1 e R0 são armazenados automaticamente na pilha quando uma interrupção ocorre.
-[[image: fig117_MI1022806.png|border|center]]
-[[image: fig118_MI1022806.png|border|center]]
-* Arquitetura load-store: as instruções somente lidam com valores que estejam nos registradores (ou imediatos) e sempre armazenam resultados em algum registrador. O acesso à memória é feito apenas através das instruções '''load''' (para carregar o valor da memória em um registrador) e '''store''' (para armazenar o valor de um registrador na memória).
-* Permite a execução condicional de várias instruções.
-* Máquina de 3 endereços – dois registradores operandos e um registrador de resultado são especificados.
-** 1º operando: especifica o local onde será armazenado o resultado da operação.
-** Outros: valores imediatos ou locais onde se encontram os dados.
-  Exemplo: ADD R1, R2, #4
-   R1 ← (R2) + 4
-* Uniformidade e tamanhos fixos dos campos das instruções para facilitar a decodificação.
-* I/O mapeado em memória: a comunicação com dispositivos periféricos é feita no próprio espaço de endereçamento de memória (via load e store).
-* Endereços de memória se referem a bytes individuais.
-==Formato de Instruções==
-Apesar das diferenças entre as instruções, os projetistas mantiveram certa regularidade no formato delas, facilitando a decodificação. O formato geral é do bit menos significativo ao mais significativo, o seguinte:
-* 4 bits para condição de execução;
-* 3 bits para o tipo de instrução;
-* 5 bits para o ''opcode'';
-* 20 bits, cujo uso e repartição varia para acomodar endereços, referências a registradores,
-deslocamentos e rotações.
-'''Operandos:'''
-Registradores:
- ADD r1, r2, r3
- MOV r1, r2
-Imediatos: identificados pelo símbolo #
- ADD r1, r2, #10
- MOV r1, #0
-Maiores detalhes sobre o formato das instruções podem ser vistos na figura.
-[[imagem: fig119_MI1022806.png|border|center]]
-Estas condições são ativadas através de sufixos que são colocados junto com os minemônicos das instruções.
-Por exemplo, um salto (B) pode ser acompanhado de um NE (not equal), o que gera uma expressão BNE.
-Essa instrução só será executada caso a condição seja verdadeira.
-==Conjunto de Instruções ARM==
-Quanto ao número de bits, as instruções podem ser dos seguintes tipos:
-'''ARM'''
-[[imagem: fig120_MI1022806.png|center]]
-'''THUMB'''
-* Operações de 32 bits, em instruções de 16 bits
-* Introduzido no processador [https://wiki.ifsc.edu.br/mediawiki/images/0/0c/Arm7ds.pdf ARM7TDMI (Datasheet)]
-* Suportado por todos os processadores ARM, desde então
-'''THUMB-2'''
-* Permite uma mistura com performance otimizada de instruções de 16/32 bits
-* Todas as operações do processador podem ser realizadas no estado "Thumb"
-* Suportado por todos os processadores da linha Cortex-M, desde então.
-[[imagem: fig121_MI1022806.png|border|center]]
-Quanto ao tipo de operação, tipos de instruções oferecidos são:
-* Load/Store: Instruções de carregamento e escrita de dados na memória. Podem ler/escrever
-palavras inteiras(32 bits), meias-palavras(16 bits), bytes sem sinal, e podem ler e estender o
-sinal de meias-palavras.
-A sintaxe é:
-===Instruções de acesso à memória===
-  '' <LDR|STR> {cond} {B} {T} Rd,<Address>''
-onde:
-* ''LDR'' carrega um valor da memória para um registrador
-* ''STR'' armazena um valor de registrador para a memória
-* ''{cond}'' mnemônico condicional de 2 caracteres
-*''{B}'' se B estiver presente, transfere um byte, senão, transfere uma palavra
-*''{T}'' se T estiver presente, the bit ''W'' será setado em um instrução pós-indexada, forçando um modo não-privilegiado para o ciclo de transferência. Não permitido para modo pré-indexado.
-*''Rd'' é o nome do registrador
-*''<Address>'' pode ser:
-**Uma expressão que gere um endereço:
- <expression>
-**Uma especificação de endereço pré-fixada:
- ''[Rn]'' endereço base
- ''[Rn,<#expression>]{!}'' offset de ''<expression>'' bytes
- ''[Rn,{+/-}Rm{,<shift>}]{!}'' offset de +/- conteúdos do registrador de índice, deslocado de ''<shift>''
-**Uma especificação de endereçamento pós-fixada:
-  ''[Rn],<#expression>'' offset de ''<expression>'' bytes
-  ''[Rn],{+/-}Rm{,<shift>}'' offset de +/- conteúdos do registrador de índice, deslocado de ''<shift>''
-;Exemplos
- STR R1,[R2,R4]   ; Armazena R1 em R2+R4 (ambos os quais são
-                   ; registradores)
- STR R1,[R2],R4    ; Armazena R1 em R2 e escreve de volta
-                   ; R2+R4 em R2.
- LDR R1,[R2,#16]   ; Carrega R1 do endereço R2+16, mas
-                   ; não escreve de volta.
- LDR R1,[R2,R3,LSL#2] ; Carrega R1 do endereço R2+R3*4.
- LDREQBR1,[R6,#5]  ; Carrega condicionalmente o byte de R6+5 em
-                   ; R1 bits 0 a 7, preenchendo os bits 8 a 31
-                   ; com zeros.
- STR R1,PLACE      ; Gera um offset em PC relativo ao
-                   ; endereço PLACE.
-A arquitetura ARM suporta dois tipos de instruções de load e store que transferem o conteúdo de um registrador para a memória ou ao contrário.
-O primeiro tipo pode carregar ou escrever uma parava de 32 bits ou um byte sem sinal.
-O segundo tipo pode ler ou escrever meia palavra de 16 bit sem sinal, e pode carregar e sinalizar meia palavra de 16 bit ou um byte. Este tipo de instrução está disponível apenas para a arquitetura ARM versão 4 ou posterior.
-[[image: fig122_MI1022806.png|600px|center]]
-* Load/Store em blocos: são instruções que permitem definir a leitura/escrita de blocos de até 16 registradores em uma única instrução. Isso é feito com uma máscara de 16 bits na instrução
-que define quais registradores serão usados, e permite atingir uma banda de comunicação
-quatro vezes maior do que uma instrução que usa um único registrador.
-Essas instruções podem ser usadas para início e retorno de chamadas, assim como para ler blocos de memória.
-* Desvio: Todos os processadores ARM suportam instruções de branch com saltos condicionais para frente ou para trás de até 32M. A condição é dada por um campo de 4 bits.  Saltos mais longos podem ser feitos através de chamadas de subrotinas como por exemplo o ''Branch whith Link (BL)'', que mantem o endereço de retorno no LR (R14).
-* Processamento de Dados: são operações de adição e subtração, operações lógicas AND, OR e XOR, e instruções de comparação e teste;
-** Multiplicação de inteiros: as multiplicações de inteiros podem ser feitas com operandos de 32 ou 16 bits, e o resultado pode ocupar 32 ou 64 bits;
-** Adição/Subtração paralelas: essas instruções permitem aplicar a operação em partes dos operandos, de forma paralela.
-Um exemplo é a instrução ADD16, que adiciona as primeiras meias-palavras dos operandos para formar a meia palavra superior do resultado, enquanto faz o mesmo com as meias-palavras inferiores para formar a parte inferior do resultado. Essas instruções são úteis para processamento de imagens
-[[image: fig123_MI1022806.png|600px|center]]
-[[image: fig124_MI1022806.png|600px|center]]
-* Extensão: são instruções para reagrupar dados;
-* Acesso a registrador de estado: é permitido ler e escrever em partes do registrador de estados. Existem duas instruções para mover os conteúdos de um registrador de propósito geral e de um registrador de estado, que são as seguintes:
-** MRS – move o conteúdo do registrador de estado para um registrador de propósito geral.
-** MSR – move o conteúdo do registrador de propósito para um registrador de estado.
-* Interface para coprocessadores: há um grupo de instruções para trocas de dados com coprocessadores, assim como para controle destes. Elas permitem ao processador ARM iniciar uma operação de processamento de um coprocessador. Permite fazer transferências entre os registradores do processador e dos coprocessadores. Permitem também o processador criar endereços para o coprocessador carregar e escrever instruções. Todo o tratamento de ponto flutuante é feito por um coprocessador, cuja presença nos chips é opcional.
-* Intercâmbio com Thumb: são instruções para indicar se serão executadas instruções de 32 ou 16 bits. A instrução BX permite a troca entre o estado ARM e o estado THUMB. Esta instrução copia o conteúdo de um registrador de propósito geral para o PC. Caso o bit[0] do valor transferido para o PC seja 1, o processador troca para o estado THUMB.
-* instruções geradoras de exceções. Existe duas instruções deste tipo:
-**  a SWI que causa uma interrupção de software. É o mecanismo principal utilizado pelo ARM para poder executar códigos do Sistema Operacional no modo de usuário (User Mode).
-** E existe o BKPT. Esta instrução é usada para breakpoints na arquitetura ARM da versão 5 em diante.
-=Programas em Instruções ARM=
-;Exemplo 1: Programa calculadora simples 4 operações:
-<syntaxhighlight lang=asm>
- ;PROGRAMA CALCULADORA DE 4 OPERAÇÕES
- ;		R4 = 1 -> R3 = R2 + R1
- ;		R4 = 2 -> R3 = R2 - R1
- ;		R4 = 3 -> R3 = R2 X R1
- ;		R4 = 4 -> R3 = R2 / R1
- mov		r4,#4 ; valor de R4 define operação
- mov		r2,#60
- mov		r1,#12
- mov		r3,#0
- cmp		r4,#1
- blt		fim
- beq		soma
- ;******
- cmp		r4,#2
- beq		subt  ; se r4=2 pula para subtração
- ;******
- cmp		r4,#3
- beq		mult
- ;******
- cmp		r4,#4
- bgt		fim
- beq		divisao
- ;******
- ;******; ALGORITMO DE SOMA:
- soma	add		r3,r2,r1
-     b	fim
- ;******; ALGORITMO DE SUBTRAÇÃO:
- subt	sub		r3,r2,r1
-     b	fim
- ;******; ALGORITMO DE MULTIPLICAÇÃO:
- mult	add		r3, r3, r2
-        sub		r1, r1, #1
-        cmp		r1, #1
-        bge		mult
-        b		fim
- ;******; ALGORITMO DE DIVISÃO:
- divisao	mov		r4,r2
- div2		subge	r4,r4, r1
-                add		r3, r3,#1
-                cmp		r4,r1
-                bge		div2
-                b		fim
- fim
-</syntaxhighlight>
-;Exemplo 2: Programa em instruções ARM que implementa uma calculadora de 4 operações inteiras e grava os resultados em arquivo de saída (ARMSIM):
-<syntaxhighlight lang=asm>
- ;************************
- ; programa CALCULADORA
- ; R3 = R2 op R1
- ;
- ;onde 'op':
- ; R4 = 1 - SOMA
- ; R4 = 2 - SUBTRACAO
- ; R4 = 3 - MULTIPLICACAO
- ; R4 = 4 - DIVISAO
- ;*************************
- OutFileHandle: .word 0
- InFileHandle: .word 0
- InFileName:  .asciz "arqentrada.txt"
- OutFileName: .asciz "ArqSaida.txt"
- Saidasoma: .asciz "Soma = "
- Saidasub:  .asciz "Subtracao = "
- Saidamult: .asciz "Multiplicacao = "
- Saidadiv1: .asciz "Divisao = "
- Saidadiv2: .asciz "\n Resto = "
- Saidafim:  .asciz "\n Fim do processamento! "
-      ldr r0,=InFileName
-      mov r1,#0
-      swi 0x66
-      swi 0x6c
- ;******
-      mov r4,r0
-      mov r2,#6
-      mov r1,#2
-      mov r3,#0
-     cmp r4,#1
-      blt fim
-      beq soma
- ;******
-      cmp r4,#2
-      beq subt
- ;******
-      cmp r4,#3
-      beq mult
- ;******
-      cmp r4,#4
-      bgt fim
-      beq divisao
- ;******
- soma: add r3,r2,r1
-      ldr r0,=Saidasoma
-      swi 0x02
-      add r0,r3,#'0
-      swi 0x00
-      b fim
- subt: sub r3,r2,r1
-      ldr r0,=Saidasub
-      swi 0x02
-      add r0,r3,#'0
-      swi 0x00
-      b fim
- mult: mul r3,r2,r1
-      ldr r0,=Saidasoma
-      swi 0x02
-      add r0,r3,#'0
-      swi 0x00
-      b fim
- divisao:  mov r4,r2
- div2:    subge r4,r4, r1
-         add r3, r3,#1
-         cmp r4,r1
-         bge div2
-         ldr r0,=Saidadiv1
-         swi 0x02
-         add r0,r3,#'0
-         swi 0x00
-         mov r0,#'\0
-         swi 0x00
-         ldr r0,=Saidadiv2
-         swi 0x02
-         add r0,r4,#'0
-         swi 0x00
-         b fim
- fim: ldr r0, =Saidafim
-     swi 0x02
-</syntaxhighlight>
-;Exemplo 3: Programa que executa operações aritméticas e lógicas nos operandos:
-<syntaxhighlight lang=asm>
-  mov		r1,#4
-  mov		r2,#30
-  mov		r3,#1
-  mov		r4, #5
-  ORR		R1, R2, #0x20		;R1 = R2 | 0x20
-  ADD		R3, R2, R4, LSL #3	; R3 = R2 + (R4 << 3)
-  RSB		R5, R4, #0		; R4 = 0 - R5
-  SUB		R1, R3, R2, LSR R4	;R1 = R2 - (R3 >> R4)
-</syntaxhighlight>
-;Exemplo 4: Programa que executa multiplicação sem uso da instrução MUL e checando se os operandos são negativos:
-<syntaxhighlight lang=asm>
- ;		EXERCÍCIO 2 DISCIPLINA MICROPROCESSADORES
- ;		PROFA. FERNANDA
- ;		AULA 26/03/2019
-  mov		r0,#8
-  mov		r1,#-5
-  mov		r4,#0   ; registrador  de SAÍDA
- inicio
-  cmp		r1,#0
-  beq		fim ;r1 = 0 -> r4 = 0
-  bgt		set ;r1 >0
-  ; r1 negativo:
-  rsb		r3, r1, #0
-  rsb		r2,r0, #0
-  b		loop
- set
-  mov		r3,r1
-  mov		r2,r0
- loop
-  add		r4,r4,r2
-  sub		r3, r3, #1
-  cmp		r3,#0
-  ble		fim
-  b		loop
- fim
-</syntaxhighlight>
-;Exemplo 5: Programa que armazena um valor NA MEMÓRIA:
-<syntaxhighlight lang=asm>
-  mov R0, #255
-  mov R3, #2000
-  mov R1, #0
-  str R0, [R3, R1]
-</syntaxhighlight>
-;Exemplo 6: Programa que armazena valores em espaços seguidos da memória:
-<syntaxhighlight lang=asm>
-  mov R0, #255
-  mov R1, #0
-  mov R2, #100  //100 endereços depois do endereço-base
-  mov R3, #2000  //endereço base
- loop
-  str R0, [R3,R1]
-  add R1, R1, #4 //endereços têm que ser múltiplos de 4
-  add R0, R0, #1
-  cmp R1, R2
-  blt loop
-  ldr R5,[R3,#20]
-</syntaxhighlight>
-Ao final da execução, R3 continua contendo o valor 0X7D0 (endereço base = 2.000d)
-;Exemplo 7: Programa que armazena valores em espaços seguidos da memória e atualiza variável:
-<syntaxhighlight lang=asm>
-  mov R0, #255
-  mov R1, #0
-  mov R2, #100  //100 endereços depois do endereço-base
-  mov R3, #2000  //endereço base
- loop
-  str R0, [R3,R1]!
-  add R1, R1, #4 //endereços têm que ser múltiplos de 4
-  add R0, R0, #1
-  cmp R1, R2
-  blt loop
-  ldr R5,[R3,#-200]
-</syntaxhighlight>
-Ao final da execução, R3 contém o valor 0X908 (endereço base = 2.312d)
-;Exemplo 8: Programa que salva dois vetores de 8 valores na memória (A, no endereço 2000 e B, no endereço 2032) e executa a operação:
- c =  &sum; Ai.Bi, com i variando de 0 a 7.
-O produto final C será armazenado no endereço 1000 da memória
-<syntaxhighlight lang=asm>
-  mov		R0, #4 ; passo de memória
-  mov		R10, #2000 ;endereço de A
-  mov		R11, #2032 ;endereço de B
-  mov		R12, #1000 ;endereço de C
-  ;valores	do vetor A
-  mov		R2, #30
-  mov		R3, #27
-  mov		R4, #21
-  mov		R5, #17
-  mov		R6, #10
-  mov		R7, #3
-  mov		R8, #-1
-  mov		R9, #-2
-  ;grava	valores de A na memória
-  mov		R1, R10
-  str		R2, [R1],R0
-  str		R3, [R1],R0
-  str		R4, [R1],R0
-  str		R5, [R1],R0
-  str		R6, [R1],R0
-  str		R7, [R1],R0
-  str		R8, [R1],R0
-  str		R9, [R1]
-  ;valores	do vetor B
-  mov		R2, #-3
-  mov		R3, #1
-  mov		R4, #7
-  mov		R5, #11
-  mov		R6, #13
-  mov		R7, #23
-  mov		R8, #4
-  mov		R9, #5
-  ;grava	valores de B na memória
-  mov		R1, R11
-  str		R2, [R1],R0
-  str		R3, [R1],R0
-  str		R4, [R1],R0
-  str		R5, [R1],R0
-  str		R6, [R1],R0
-  str		R7, [R1],R0
-  str		R8, [R1],R0
-  str		R9, [R1]
-  ;rotina	para multiplicação dos valores
-  mov		R1, R10
-  mov		R2, R11
-  mov		R3, #0
-  mov		R4, #7
-  mov		R8, #0 ;registrador de saída
-  somatorio	mov		R5, #0
-  ldr		R6, [R1],R0
-  ldr		R7, [R2],R0
-  cmp		R7, #0
-  bge		multpos ;se 2o op >0 => mult positiva
-  beq		final  ;se 2o op = 0 => não acumula
-  ;se		2o. op < 0 :
-  multneg	sub		R5, R5, R6
-  add		R7, R7, #1
-  cmp		R7, #0
-  bne		multneg
-  b		final
-  multpos	add		R5, R5, R6
-  sub		R7, R7, #1
-  cmp		R7, #0
-  bne		multpos
-  final	add		R8, R8, R5
-  add		R3, R3, #1
-  cmp		R3, R4
-  ble		somatorio
-  str		R8, [R12]
-</syntaxhighlight>
-=Exercícios=
-:1. Escreva o programa que implementa um loop com 40 iterações, incrementando uma variável do valor 0 a 39 e somando o valor 3, a cada iteração, ao valor inicial (=3) armazenado em R1.
-{{collapse top|Exemplo de solução 1}}
-Loop com 40 iterações e soma 3 a R1, em cada iteração
-   ;PROGRAMA	QUE IMPLEMENTA R1 = R1 + 5, 40 VEZES
-   ;		i.e., R1 = R1 x 200
-   ;*******
-   mov		r1, #5      ;valor inicial de R1
-   mov		r2, #3      ;incremento de R1
-   mov		r3, #40     ;numero de loops
-   mov          r4, #0      ;valor inicial
- ;***INICIA LOOP ***
- loop   add r1, r1, r2  ;r1 = r1 + 3
-        add r4,r4, #1
-        cmp r3,r4
-        blt loop
- fim
-{{collapse bottom}}
-:2. Escreva o programa que implementa as operações lógicas (AND, OR, XOR, NXOR, NAND E NOR) entre dois valores, armazenados em R4 e R5. {{collapse top|Exemplo de solução 2}}
-Todas as operações são '''bit-a-bit''', e não lógicas:
- mov		r4, #13
- mov		r5, #6
- and		r0, r4,r5  ;r0 = r4 & r5
- orr		r1, r4, r5 ;r1 = r4 | r5
- eor		r2, r4, r5 ;r2 = r4 ^ r5
- mvn		r3, r2     ;r3 = nxor(r4, r5)
- mvn		r6, r0     ;r6 = nand(r4, r5)
- mvn		r7, r1     ;r7 = nor(r4, r5)
-{{collapse bottom}}
-:3. Implemente, no ARMSIM, o programa Arm que resolve a equação: Y = (A - B) / (C + D x E). Dica: armazene A em R0, B, em R1, C, em R2, D, em R3 e E, em R4.
-{{collapse top|Exemplo de solução 3}}
-Programa que resolve a equação Y = (A - B)/(C + DxE), com o resultado em R8
- ;PROGRAMA	QUE IMPLEMENTA Y = (A - B) / (C + D x E)
- ;COM:
-    ;		A = 10, B = 4, C = 2, D = 3, E = 9
-    ;		e Y -> R8
-    ;******************
-    mov		r0, #100   ;A
-    mov		r1, #4    ;B
-    mov		r2, #2    ;C
-    mov		r3, #3    ;D
-    mov		r4, #9    ;E
-    sub		r5, r0, r1 ; R5 = A - B
-    ;***		ROTINA PARA D X E ***
-    mov		r6,r3
-    mov		r7,r4
- loop		add		r6, r6, r3  ; R6 = R6 + D
-    sub		r7,r7, #1   ; REPETE R7 = R4 VEZES
-    cmp		r7,#1
-    bgt		loop
-    add		r6,r6,r2 ; R6 = (DxE) + C
-   ;***		ROTINA PARA R8 = R5/R6 , ie, (A - B)/(C + D x E)
-    mov		r8,#0
- div		subge	r5,r5, r6
-    add		r8, r8,#1
-    cmp		r5,r6
-    bge		div
- fim
-{{collapse bottom}}
-:4. Implemente, no ARMSIM, o programa que lê compara os valores armazenados em R1, R2 e R3 e devolve o maior dentre eles em R4, e o menor, em R5.
-{{collapse top|Exemplo de solução 4}}
-Compara R1, R2 e R3 e armazena o maior valor, dentre os 3, em R4 e o menor valor, em R5
-   ;PROGRAMA	QUE COMPARA 3 VALORES EM R1, R2 E R3
-   ;		E ARMAZENA O MAIOR EM R4
-   ;		E O MENOR, EM R5
-   mov		r1, #50
-   mov		r2, #20
-   mov		r3, #6
-   cmp		r1,r2
-   blt		r2maior
-   cmp		r1, r3
-   blt		r3maior
-   mov		r4,r1  ; R1 eh o maior
-   cmp		r2,r3
-   movge	r5,r3
-   movlt	r5,r2
-   b		fim
- r2maior	cmp		r2,r3
-   blt		r3maior
-   mov		r4, r2  ; R2 eh o maior
-   cmp		r1,r3
-   movge	r5,r3
-   movlt	r5,r1
-   b		fim
- r3maior	mov		r4, r3  ; R3 eh o maior
-   cmp		r1,r2
-   movge	r5,r2
-   movlt	r5,r1
-   b		fim
- fim
-{{collapse bottom}}
-:5. Escreva o programa com menu para resolver operações '''lógicas''' E, OU e NÃO entre dois valores armazenados em R4 e R5, assumindo que a variável é ''false'' quando tiver valor igual a 0 (=0).
-:6. Implemente o programa que calcula (X * 2^N), apenas pelos deslocamentos à esquerda ou direita, de um valor X armazenado em R0 e com N armazenado em R1.
-=Conjunto de Instruções THUMB=
-O THUMB possui instruções com as mesmas finalidades das instruções ARM, porém são codificadas com 16 bits.
-Estas instruções THUMB geram códigos menores porém muitas vezes ocorre de aumentar o número de instruções que o processador deve executar.
-Uma solução para isso são aplicações que utilizam ambos tipos de instruções (ARM e THUMB).
-Aplicações deste tipo conseguem reduzir o tamanho do seu código significativamente e conseguem manter o consumo de energia baixo.
-Algumas instruções THUMB são:
-==Instruções de deslocamento: ASR, LSL, LSR, ROR e RRX==
-As instruções a seguir são, na verdade, sinônimos para a instrução
- ''MOV Rd, Rm, XXX #n ''
-onde XXX é um dentre LSR, LSL, ASR, ROR e n é uma constante variando de 0-31.
-'''Obs''': se o sufixo S for acrecentado a XXX então o último bit deslocado de Rd entra no bit C (Carry) da palavra de estado.
-'''Obs''': os bits de uma palavra são numerados de 0 a 31, do menos significativo ao mais significativo
-===Sintaxe:===
- ''op{S}{cond} Rd, Rm, Rs''
- ''op{S}{cond} Rd, Rm, #n''
- ''RRX{S}{cond} Rd, Rm''
-onde:
-*''op'' is one of:
-** ASR: Deslocamento à direita aritmético
-** LSL: Deslocamento à esquerda lógico
-** LSR: Deslocamento à direita lógico
-** ROR: Rotaciona à direita
-*''S'' é um sufixo opcional. Se S for especificado, as flags condicionais são atualizadas no resultado da operação.
-*''Rd'' é o registrador destino
-*''Rm'' é o registrador contendo o valor a ser deslocado
-*''Rs'' é o registrador contendo o comprimento de deslocamento a ser aplicado ao valor em Rm. Apenas o byte menos significativo é usado e deve variar entre [0,255].
-*''n'' é o comprimento de deslocamento. Depende da instrução:
-** ASR: comprimento de deslocamento de 1 a 32
-** LSL: comprimento de deslocamento de 0 a 31
-** LSR:  comprimento de deslocamento de 1 a 32
-** ROR:  comprimento de deslocamento de 1 a 31
- LSR Rd, #n  - desloca Rd n bits para a direita inserindo n 0s à esquerda (divide Rd por 2**n)
- LSL Rd, #n  - desloca Rd n bits para a esquerda inserindo n 0s à direita (multiplica Rd por 2**n)
- ASR Rd, #n  - desloca Rd n bits para a direita, replicando o bit 31 (preserva o bit de sinal)
-                    - divide um inteiro com sinal por 2**n
- ROR Rd, #n  - rotaciona para a direita n bits de Rd (o bit 0, - significativo, entra no lugar do bit 31)
- XXX Rd, Rm,#n - variante permitida das instruções acima; Rm não muda
- RRX Rd, Rm  - rotaciona um bit do par (Rm,C) como se fosse uma palavra de 33 bits:  Rd0->C, C->Rd31, etc
-                    - resultado vai para Rd, Rm não é alterado, exceto se Rd=Rm.
-===Operação===
-ASR, LSL, LSR e ROR movem os bits no registrador Rm para a esquerda ou para a direita, pelo número de lugares especificado pela constante n, ou registrador Rs.
-RRX move os bits no registrador Rm para a direita 1 vez.
-Em todas estas instruções, o resultado é escrito para Rd, mas o valor em Rm continua inalterado.
-===Restrições===
-Não use com SP ou PC.
-===Flags de condição===
-Se S for especificado:
-* estas instruções atualizam as flags N e Z de acordo com o resultado
-* a flag C é atualizada com o último bit deslocado, exceto quando o comprimento do deslocamento é 0.
-;Exemplos:
- ASR R7, R8, #9; arithmetic shift right by 9 bits
- LSLS R1, R2, #3; logical shift left by 3 bits with flag update
- LSR R4, R5, #6; logical shift right by 6 bits
- ROR R4, R5, R6; rotate right by the value in the bottom byte of R6
- RRX R4, R5; rotate right with extend
-   mov		r1, #-200
-   mov		r2, #200
-   mov		r3, #5
-   asr		r9, r1, #3
-   lsls		r5, r2, #4
-   lsl		r4, r3, #6
-   ror		r6, r1, #6
-   rrx		r7, r3
-==BFC - Bit field clear e BFI - Bit field insert==
-===Sintaxe===
- ''BFC{cond} Rd, #lsb, #width''
- ''BFI{cond} Rd, Rn, #lsb, #width''
-onde:
-* ''cond'' é o código condicional, cc.
-* ''Rd'' é o registrador destino.
-* ''Rn'' é o registrador fonte.
-* ''lsb'' é a posição do bit menos significativo no campo de bits [0-31].
-* ''width'' é a largura do campo de bits [1-32].
-===Operação===
-BFC zera um campo de bits em um registrador. Limpa ''width'' bits em ''Rd'', iniciando da posição inferior ''lsb''.
-Os demais bits permanecem inalterados.
-BFI copia um campo de bits de um registrador para outro. Substitui ''width'' bits em ''Rd'', iniciando da posição inferior ''lsb'', pelos ''width'' bits em ''Rn'', iniciando da posição bit[0]. Os demais bits permanecem inalterados.
-===Restrições===
-Não é permitido utilizar os registradores SP e PC com estas instruções.
-Estas instruções não afetam as flags.
-;Exemplos:
- BFC R4, #8, #12 ; Limpa o bit 8 até bit 19 (12 bits) de R4
- BFI R9, R2, #8, #12 ; Substitui bits 8 a 19 (12 bits) de R9 com bits 0 a 11 de R2
-==AND, ORR, EOR, BIC, and ORN==
-E, OU, OU EXCLUSIVO, Zera bit, E NÃO-OU lógicos.
-===Sintaxe===
- ''op{S}{cond} {Rd,} Rn, Operand2''
-onde:
-* ''op'' é uma das operações:
-** AND: E lógico
-** ORR: OU lógico ou seta-bit
-** EOR: OU exclusivo lógico
-** BIC: NÃO-E lógico ou zera bit
-** ORN: NÃO-OU lógico
-*''S'' é o sufixo opcional. Se S for especificado, as flags de código condicional serão atualizadas como resultado da operação.
-*''cond'' é o código de condição opcional
-*''Rd'' é o registrador destino
-*''Rn'' é o registrador que contém o primeiro operando
-*''Operand2'' é o segundo operando
-===Operação===
-As instruções AND, EOR, e ORR realizam operações E, OU-EXC e OR bit-a-bit nos valores de Rn e operand2.
-A instrução BIC realiza uma operação E nos bits de Rn com o complemento dos correspondentes bits no valor de operand2.
-A instrução ORN realiza uma operação OU nos bits de Rn com o complemento dos bits correspondentes no valor de operand2.
-===Restrições===
-Não usar em SP e PC.
-===Flags de condição===
-Se S for especificado, estas instruções:
-* Atualizam as flags N e Z de acordo com o resultado.
-* Podem atualizar a flag C durante o cálculo de operand2
-* Não afetam a flag V
-;Exemplo
- AND R9, R2,#0xFF00
- ORREQ R2, R0, R5
- ANDS R9, R8, #0x19
- EORS R7, R11, #0x18181818
- BIC R0, R1, #0xab
- ORN R7, R11, R14, ROR #4
- ORNS R7, R11, R14, ASR #32
-==ADD, ADC, SUB, SBC, and RSB==
-Soma, soma com carry, subtrai, subtrai com carry e subtrai reverso.
-===Sintaxe===
- ''op{S}{cond} {Rd,} Rn, Operand2''
- ''op{cond} {Rd,} Rn, #imm12; ADD and SUB only''
-onde:
-*''op'' é:
-** ADD: Soma
-** ADC: Soma com carry
-** SUB: Subtração
-** SBC: Subtração com carry
-** RSB: Subtração reversa
-*''S'' é o sufixo opcional. Se S for especificado, as flags serão atualizadas no final da operação.
-*''cond'' é o cc
-*''Rd'' é o registrador destino. Se for omitido, o destino é o próprio '''Rn'''.
-*''Rn'' é o registrador contendo o primeiro operando
-*''Operand2'' é o segundo operando flexível
-*''imm12'' é qualquer valor na faixa de 0-4095
-===Operação===
-A instrução ADD adiciona o valor do operand2, ou imm12, ao valor de Rn.
-A instrução ADC adiciona o valor do Rn e operand2, junto com a flag de carry.
-A instrução SUB subtrai o valor de operand2 do valor em Rn. Se a flag de carry estiver zerada, o resultado é diminuído de um.
-A instrução SBC subtrai o valor em Rn de operand2. Esta instrução é útil porque operand2 permite uma faixa maior de valores.
-A instrução RSB subtrai o valor do operand2, ou imm12, ao valor de Rn.
-A instrução ADDW é equivalente à instrução ADD, que usa o operando imm12. SUBW é equivalente à instrução SUB, que usa o operando imm12.
-==CBZ and CBNZ==
-Compara e desviam se zero; compara e desvia se não-zero.
-===Sintaxe:===
- ''CBZ Rn, label''
- ''CBNZ Rn, label''
-onde:
-*''Rn'' é o registrador contendo o operando.
-*''label'' é o destino do desvio.
-===Operação===
-Use as instruções CBZ e CBNZ para evitar mudar as flags de cc e reduzir o número de instruções
-A instrução ''CBZ Rn, label'' não altera as flags de condição, mas, ao contrário, é equivalente a:
- CMP Rn, #0
- BEQ label
-A instrução ''CBNZ Rn, label'' não altera as flags de condição, mas, ao contrário, é equivalente a:
- CMP Rn, #0
- BNE label
-===Restrições===
-* Rn deve ser R0 a R7
-* O destino do desvio deve estar entre 4 e até 130 bytes após a instrução
-* Estas instruções não podem ser usadas dentro de um bloco IT.
-===Flags de condição===
-Não alteram as flags
-;Exemplos
- CBZ R5, target ; Forward branch if R5 is zero
- CBNZ R0, target ; Forward branch if R0 is not zero
-==CMP and CMN==
-Compara e compara negativo.
-===Sintaxe:===
- ''CMP{cond} Rn, Operand2''
- ''CMN{cond} Rn, Operand2''
-onde:
-* ''cond'' é um código de condição opcional (c.c.)
-* ''Rn'' é o registrador do primeiro operando
-* ''Operand2'' é o segundo operando
-===Operação===
-As instruções comparam o valor do registrador com operand2.
-Elas atualizam a condição da flag no resultado, mas não escrevem o resultado em um registrador.
-A instrução CMP subtrai o valor de operand2 do valor em Rn. Faz o mesmo que a instrução SUBS, exceto que o resultado é descartado.
-A instrução CMN adiciona o valor de operand2 ao valor em Rn. Faz o mesmo que a instrução ADDS, exceto que o resultado é descartado.
-===Restrições===
-Não é permitido usar PC e operand2 não pode ser SP.
-===Flags de condição===
-As instruções atualizam as flags N, Z, C e V, de acordo com o resultado.
-;Exemplos:
- CMP R2, R9
- CMN R0, #6400
- CMPGTSP, R7, LSL #2
-==CLZ - Count leading zeros==
-===Sintaxe:===
- '''CLZ{cond} Rd, Rm'''
-onde:
-* ''cond'' é o cc opcional.
-* ''Rd'' é o registrador destino
-* ''Rm'' é registrador operando
-===Operação===
-A instrução CLZ conta o número de zeros no valor em Rm e retorna o resultado em Rd.
-O valor resultante é 32 se nenhum bit está setado no registrador fonte, e zero, se bit[31] é setado.
-===Restrições===
-Não use com SP e PC.
-===Flags de condição===
-Esta instrução não altera as flags.
-;Exemplos
- CLZ R4,R9
- CLZNE R2,R3
-== IT - If-Then condition instruction==
-;Sintaxe:
- ''IT{x{y{z}}} cond''
-onde:
-*''x'' especifica a condição chave para a segunda instrução no bloco IT.
-*''y'' especifica a condição chave para a terceira instrução no bloco IT.
-*''z'' especifica a condição chave para a quarta instrução no bloco IT.
-*''cond'' especifica a condição chave para a primeira instrução no bloco IT.
-As condições chave para segunda, terceira e quarta instruções do bloco podem ser:
-*T: Then - Então. Aplica a condição ''cond'' à instrução.
-* E: Else - Senão. aplica a condição inversa de ''cond'' à instrução.
-Exemplo:
-[[image: fig125_MI1022806.png|border|center]]
-[[image: fig126_MI1022806.png|center]]
-===Operação===
-A instrução IT realiza um das quatro instruções condicionais seguintes.
-As condições podem ser as mesmas, ou algumas podem ser o inverso lógico das outras. As instruções que seguem a instrução IT formam o "bloco IT".
-As instruções no bloco IT, incluindo os branches, devem especificar a condição {cond} como parte de suas sintaxes.
-Podem ser geradas exceções nos blocos IT.
-===Restrições===
-As seguintes instruções não são permitidas num bloco IT:
-* IT
-* CBZ e CBNZ
-* CPSID e CPSIE.
-Um branch ou qualquer outra instrução que modifique o PC deve estar fora de um bloco IT, ou deve ser a última instrução dentro do bloco IT. São:
-* ADD PC, PC, Rm
-* MOV PC, Rm
-* B, BL, BX, BLX
-* qualquer instrução LDM, LDR, ou POP que escreva no PC
-* TBB e TBH
-Não desvie para qualquer instrução INTERNA a um bloco IT, exceto quando retornando de um Exception Handler.
-Para restrições adicionais, consulte o manual do seu Arm Assembler.
-===Flags de condição===
-Esta instrução não altera as flags.
-;Exemplos:
- ITTE NE ; Proximas 3 instruções são condicionais
- ANDNE R0, R0, R1 ; ANDNE não atualiza as flags de condicao
- ADDSNE R2, R2, #1 ; ADDSNE atualiza as flags de condicao
- MOVEQ R2, R3 ; Move Conditional
- CMP R0, #9 ; Converte valor hexa R0 (0 a 15) para ASCII
- ; ('0'-'9', 'A'-'F')
- ITE GT ; Proximas 2 instrucoes sao condicionais
- ADDGT R1, R0, #55 ; Converte 0xA -> 'A'
- ADDLE R1, R0, #48 ; Converte 0x0 -> '0'
- IT GT ; bloco IT com apenas uma instrucao condicional
- ADDGT R1, R1, #1 ; Incrementa R1 condicionalmente
- ITTEE EQ ; Proximas 4 instrucoes são condicionais
- MOVEQ R0, R1 ; move Condicional
- ADDEQ R2, R2, #10 ; add Condicional
- ANDNE R3, R3, #1 ; AND Condicional
- BNE.W dloop ; Instrucao Branch instruction apenas pode ser usada no final
- ; de um bloco IT
- IT NE ; proxima instrucao é condicional
- ADD R0, R0, R1 ; erro de sintaxe: nenhum codigo condicional
-==Execução condicional de instruções==
-As instruções lógico-aritméticas podem ser condicionalmente executadas dependendo dos flags da palavra de estado que foram atualizados numa instrução anterior (usualmente imediatamente anterior).
-Existem 15 condições que podem ser usadas como sufixo da instrução, e que são as mesmas usadas nas instruções de salto condicional:
- eq, ne, cs ou hs, cc ou lo, mi, pl, vs, vc, hi, ls, ge, lt, gt, le, al.
-Para que a execução condicional seja possível até 4 instruções devem ser precedidas pela instrução especial "If-Then condition instruction":
-   it cond,
-onde cond é uma das 15 siglas de 2 letrasi citadas anteriormente (existem outros 3 possíveis parâmetros).
-Exemplos:
-(1) suponha que r1 contem um inteiro com sinal: colocar em r0 o valor absoluto desse inteiro:
- movs r0, r1	@ atualiza flags
- it mi		@ queremos tomar o negativo caso r0 <0
- rsbmi r0, #0    @ faça r0 := 0 - r0 caso o bit N estivesse ligado
-Obs: o mesmo código em instruções ARM seria:
- mov r0, #12
- mov r1, #8
- mov r2, #4
- loop:   cmp  r1, r2         @ cmp sempre atualiza flags
- @ queremos testar se r1 > r2
- subgt  r1, r1 ,r2     @ se r1 > r2, faça r1:=r1-r2
- sublt  r2, r2 ,r1     @ se r1 < r2 faça  r2:= r2-r1
- bne  loop             @ se r1 # r2 volte ao laço
-(2) algoritmo para calcular o máximo divisor comum de dois inteiros em r1 e r2, devolvendo o resultado em r1 e r2:
- loop:   cmp  r1, r2         @ cmp sempre atualiza flags
-  it gt               @ queremos testar se r1 > r2
-  subgt r1, r2        @ se r1 > r2, faça r1:=r1-r2
-  it lt               @ senão teste por <
-  sublt  r2, r1       @ se r1 < r2 faça  r2:= r2 -r1
-  bne  loop           @ se r1 # r2 volte ao laço
-			    @ senão mdc=r1=r2
--------------------
-Outras instruções THUMB:
-* RBIT - Reverse bits - p-81
-* REV - Reverse byte order in a word - p-81 (passa uma palavre de "little endian" para "big endian" e vice-versa)
-* SXTB - Sign extend a byte - p-90
-* TBB - Table branch byte - p-96
-* UDIV - Unsigned divide - p-86
-* UMULL - Unsigned multiply (32x32), 64 bit result
-* UXTB - Zero extend a byte - p-90
-* CPSID/CPSIE - Interrupts Disable/Enable - p-98
-Maiores informações: [[media: MIPciCM3.pdf| The Cortex-M3 instruction set]]
-=Conjunto de instruções THUMB2=
-Tradicionalmente todas as instru&ccedil;&otilde;es da arquitetura
-ARM tem tamanho regular de 32 bits (4 bytes)
-Na gera&ccedil;&atilde;o 4 de processadores ARM (Tipo ARM7-TDMI) foi incuido o conjunto
-de instru&ccedil;&otilde;es alternativo THUMB em que a maioria das instru&ccedil;&otilde;es tem 2 bytes.
-Nos processadores ARM7-TDMI os conjuntos de instru&ccedil;&otilde;es ARM e THUMB s&atilde;o implementados
-como dois modos de opera&ccedil;&atilde;o diferentes, necessitando de uma instru&ccedil;&atilde;o especial para
-trocar de modo.
-Na gera&ccedil;&atilde;o 7 (Cortex) foi introduzido o conjunto de instru&ccedil;&otilde;es THUMB2 com
-instu&ccedil;&otilde;es de 2 e 4 bytes que podem acessar todos os recursos do processador.
-Desta forma podem-se usar instru&ccedil;&otilde;es de 16 bits ou de 32 bits arbitrariamente
-sem que seja necess&aacute;rio trocar o modo de opera&ccedil;&atilde;o.
-Nos processadores Cortex M0, M1, M2 e M3 existem apenas as instru&ccedil;&otilde;es THUMB2.
-O suporte ao conjunto ARM &eacute; desabilitado.
-Na fam&iacute;lia Cortex o processador de interrup&ccedil;&otilde;es NVIC foi incorporado
-ao core do processador, de modo a tornar o uso de interrup&ccedil;&otilde;es mais simples
-e mais eficiente que nos chips anteriores da fam&iacute;lia ARM.
-==Mapa de Memória==
-Sistemas baseados no Cortex-M3 devem ter um mapa de mem&oacute;ria definido:
-<center>
-{| class="wikitable"
-|-
-|0xFFFFFFFF<br>0xE0000000
-|Perif&eacute;ricos do sistema: NVIC, debug
-|-
-|0xDFFFFFFF<br>0xA0000000
-|Livre para Perif&eacute;ricos Externos
-|-
-|0x9FFFFFFF<br>0x60000000</td>
-|Livre para RAM Externa
-|-
-|0x5FFFFFFF<br>0x40000000</td>
-|Perif&eacute;ricos definidos pelo fabricante do CHIP
-|-
-|0x3FFFFFFF<br>0x20000000</td>
-|SRAM (Mem&oacute;ria integrada no CHIP)
-|-
-|0x1FFFFFFF<br>0x00000000
-|Mem&oacute;ria FLASH integrada para firmware
-|}
-</center>
-==O arquivo de registradores==
-A arquitetura Cortex-M3, assim como o ARM7,  tem 16 registradores (R0 a R15) de 32bits com acesso direto &agrave; ULA.
-Algumas instru&ccedil;&otilde;es THUMB s&oacute; podem acessar os registradores de R0 a R7.
-Tres registradores tem prop&oacute;sito especial:
-<dl>
-<dt>R0 a R7 <dd> Registradores do usu&aacute;rio baixos: Todas as instru&ccedil;&otilde;es tem acesso.
-<dt>R8 a R12 <dd> Registradores do usu&aacute;rio altos: Algumas instru&ccedil;&otilde;es THUMB n&atilde;o tem acesso.
-<dt>R13 ou SP <dd>Stack Pointer. Apontador de pilha. Existem dois apontadores de pilha, ambos acess&iacute;veis como R3:
-<ul><li><b>MSP</b> Main Stack Pointer: Este &eacute; o apontador de pilha principal, usado no n&uacute;cleo do sistema operacional
-e no tratamento de exce&ccedil;&otilde;es.</li>
-<li><b>PSP</b> Process Stack Pointer: Usada em programas aplicativos (modo usu&aacute;rio).
-</ul>
-As intru&ccedil;&otilde;es PUSH e POP armazenam ou restauram dados da pilha.
-<pre class="code">
-PUSH	{R0}	; R13 = R13-4,  Memoria[R3] = R0
-POP	{R0}	; R0 = Memoria[R3], R13 = R13+4;
 </pre>
-As intru&ccedil;&otilde;es PUSH e POP podem usar uma lista de registradores:
+;Código que faz isso na prática em ASM
-<pre class="code">
+<pre>
-PUSH	{R0, R1, R2, R5}
+		;		Comecamos armazenando 4 valores na memoria
-POP	{R0-R2, R5}	; Restaura R0, R1, R2 e R5
+		;		int a=10, b=20, c=30, t; \\sendo a no endereço 100, b no ;104, c no 108 e t no 10C
-</pre>
+		mov		R0, #10
+		mov		R1, #0
+		mov		R2, #16 ; 4 valores (4 bytes cada valor 4x4=16)
+		mov		R3, #0x100  	; endereço base
+loop		str		R0, [R3,R1]
+		add		R1, R1, #4 	; endereços têm que ser múltiplos de 4
+		add		R0, R0, #10
+		cmp		R1, R2
+		blt		loop
+		;principal
+		ldr		R4, [R3,#0] ; primeiro endereço a=10 em  0x100
+		ldr		R5, [R3,#4] ; b=20 em 0x104
+		add		R6, R4,R5	  ; t=a+b
+		ldr		R4, [R3,#8] ; c=30 em  0x108
+		add		R6, R6,R4   ; t=t+c
+		str		R6, [R3,#12] ; t em 0x10C
+fim
-</dd>
-<dt>R14 ou LR <dd>Link Register. Cont&eacute;m o endere&ccedil;o de retorno para chamadas de subrotina.
-A instru&ccedil;&atilde;o BL <i>&lt;endere&ccedil;o &gt;</i> funciona como uma chamada de subrotina.
-Ela salva automaticamete o endere&ccedil;o da
-intru&ccedil;&atilde;o seuinte no LR e salta para o local indicado pelo operando.
-Se for necess&aacute;rio aninhar chamadas de subrotina, o LR deve ser salvo na pilha.</dd>
-<dt>R15 ou PC <dd>Program Counter. Este registrador tem o endere&ccedil;o da pr&oacute;xima instru&ccedil;&atilde;o
-que ser&aacute; executada.</dd>
-</dl>
-===Registradores Especiais===
-Fora do banco de registradores R0 a R15 existem alguns registradores que controlam ou indicam
-aspectos especiais do processador.
-Eles podem ser classificados em tres grupos:
-<ul>
-<li> '''xPSR''' -  APSR, IPSR, EPSR: ''Program Status Registers'': Tem os bits de estado da ULA: '''NZCVQ'''</li>
-<li> PRIMASK, FAULTMASK e BASEPRI: Prioridade e mascaramento de interrup&ccedil;&otilde;es</li>
-<li> CONTROL: Indica o modo de opera&ccedil;&atilde;o: Privilegiado, Usu&aacute;rio ou executando uma excess&atilde;o</li>
-</ul>
-Os bits NZCV do xPSR s&atilde;o chamados <i>"Condition Code"</i> abreviado como <i>cc</i>.
-Em geral, os códigos cc refletem o resultado da &uacute;ltima instru&ccedil;&atilde;o da unidade aritm&eacute;tica.
-<b>N</b> <i>Negative:</i> &Eacute; uma c&oacute;pia do bit mais significativo do resultado, que indica o
-sinal. Resultado com bit mais significativo 1 &eacute; considerado como negativo. Setado, quando o resultado da operação for negativo, ou zerado, caso contrário
-<b>Z</b> <i>Zero:</i> Indica que deu resultado ZERO na &uacute;ltima opera&ccedil;&atilde;o. Setado, quando o resultado da operação for zero, ou zerado, caso contrário
-<b>C</b> <i>Carry:</i> Bit de transporte na soma ou empr&eacute;stimo na subtra&ccedil;&atilde;o. Setado, quando o resultado da operação resultar em um carry, ou zerado, caso contrário
-<b>V</b> <i>oVerflow:</i> Indica overflow em uma opera&ccedil;&atilde;o com sinal. Ocorre quando mudou o sinal
-sem a ativa&ccedil;&atilde;o do carry. Setado, quando o resultado da operação resultar em overflow, ou zerado, caso contrário
-Um carry ocorre quando:
-* o resultado de uma adição for maior ou igual a 2^32
-* se o resultado de uma subtração for positivo ou zero
-* como resultado de um deslocamento para a direita ou esquerda.
-O overflow ocorre quando o resultado de uma soma, subtração, ou comparação for maior ou igual a 2^31, ou menor que -2^31.
-Muitas instruções de processamento de dados podem atualizar as flags de condição do APSR, de acordo com o resultado da operação.
-Algumas instruções vão atualizar todas as flags, e algumas, apenas um subconjunto.
-Se a flag não for atualizada, o valor original é preservado.
-Você pode executar uma instrução condicionalmente, baseado em um ou mais flags atualizadas por meio de outra instrução:
-* imediatamente após a instrução que atualizou as flags;
-* Após um determinado intervalo de instruções que não tenham atualizado as flags.
-A execução condicional está disponível pelo uso condicional de branches, ou adicionando os sufixos ''cc'' às instruções.
-<center>
-{| class="wikitable"
-|+Tabela de Sufixos de Condição de Código
-|-
-! style="background:#6A5ACD; color:white; width: 150px;text-align:center;"|Sufixo
-! style="background:#6A5ACD; color:white; width: 150px;text-align:center;"|Flags
-! style="background:#6A5ACD; color:white; width: 250px;text-align:center;"|Significado
-|-
-! style="text-align:center;"|EQ
-|Z=1
-|Equal
-|-
-! style="text-align:center;!|NE
-|Z=0
-|Not equal
-|-
-! style="text-align:center;!|CS or HS
-|C=1
-|Higher or same, unsigned >=
-|-
-! style="text-align:center;!|CC or LO
-|C=0
-|Lower, unsigned <
-|-
-! style="text-align:center;"|MI
-|N=1
-|Negative
-|-
-! style="text-align:center;!|PL
-|N=0
-|Positive or zero
-|-
-! style="text-align:center;!|VS
-|V=1
-|Overflow
-|-
-! style="text-align:center;!|VC
-|V=0
-|No overflow
-|-
-! style="text-align:center;"|HI
-|C=1 and Z=0
-|Higher, unsigned >
-|-
-! style="text-align:center;!|LS
-|C=0 or Z=1
-|Lower or same, unsigned <=
-|-
-! style="text-align:center;!|GE
-|N=V
-|Greater than or equal, signed >=
-|-
-! style="text-align:center;!|LT
-|N!=V
-|Less than, signed <
-|-
-! style="text-align:center;!|GT
-|Z=0 and N=V
-|Greater than, signed >
-|-
-! style="text-align:center;!|LE
-|Z=1 an N!=V
-|Less than or equal, signed <=
-|-
-! style="text-align:center;!|Al
-|Can have any value
-|Always. This is the default when no suffix is specified.
-|}
-</center>
-Os sufixos de condição de código (cc) permitem ao processador testar uma condição baseado nas flags dos registradores. Se a condição falhar, a instrução:
-* Não executa
-* Não escreve nenhum valor no registrador de destino
-* Não afeta nenhuma flag
-* Não gera nenhuma exceção
-Use as instruções CBZ e CBNZ para comparar o valor de um registrador com zero e desviar, dependendo do resultado.
-Todas as instru&ccedil;&otilde;es tem um campo que permite a sua execu&ccedil;&atilde;o condicional de acordo
-com o estado dos bits NZCV do xPSR. Na linguagem assembly esta execu&ccedil;&atilde;o condicional &eacute;
-indicada por um sufixo de duas letras no mnemonico da instru&ccedil;&atilde;o de acordo com a tabela a seguir:
-<center>
-{| class="wikitable"
-|+Tabela de Sufixos de Condição de Código
-|-
-! style="background:#6A5ACD; color:white; width: 50px;text-align:center;"|CC
-! style="background:#6A5ACD; color:white; width: 250px;text-align:center;"|Condição
-! style="background:#6A5ACD; color:white; width: 50px;text-align:center;"|CC
-! style="background:#6A5ACD; color:white; width: 250px;text-align:center;"|Condição
-|-
-|CS
-|C=1 Carry Set
-|CC
-|C=0 Carry Clear
-|-
-|EQ
-|Z=1 Equal (zero)
-|NE
-|Z=0 Not Equal (não zero)
-|-
-|VS
-|V=1 Overflow Set
-|VC
-|V=0 Overflow Clear
-|-
-|GT
-|Greater Then (com sinal)
-|LT
-|Less Then (com sinal)
-|-
-|GE
-|Greater or Equal (com sinal)
-|LE
-|Less or Equal (com sinal)
-|-
-|PL
-|N=0 PLus (Positivo) (com sinal)
-|MI
-|N=1 Minus (negativo)
-|-
-|HI
-|HIgher (maior que) (sem sinal)
-|LO
-|Lower (menor que) (sem sinal)
-|-
-|HS
-|Higher or Same (sem sinal) (mesmo que CS)
-|LS
-|Lower or Same (sem sinal)
-|}
-</center>
-<p>A maioria das instru&ccedil;&otilde;es pode afetar ou n&atilde;o os indicadores de estado no CPSR.
-Na linguagem assembly coloca-se um sufixo com a letra <b>s</b> no mnemonico da instru&ccedil;&atilde;o
-para indicar que os flags devem ser modificados.
-Por exemplo:
-<pre class="code">
-	subs	R1, R2, R3	/* Calcula R1=R2-R3 e ajusta flags */
-	addge	R4, R4, #1	/* Soma 1 no R4 se o resultado da subs for >= 0 */
-	AND	R5, #7		/* R5 = R5 &amp; 7  Quado tem 2 operandos o destino=primeiro op */
 </pre>
-As instru&ccedil;&otilde;es de processamento de dados geralmente tem 3 argumentos:
+{{collapse bottom}}
-<ul><li>op1: O primeiro argumento &eacute; um registrador onde o resultado &eacute; armazenado</li>
+===Parte 3===
-<li>op2: O segundo argumento &eacute; um registrador usado como primeiro operando da opera&ccedil;&atilde;o</li>
-<li>op3: O terceiro argumento &eacute; o segundo operando da opera&ccedil;&atilde;o, que pode ser um valor imediato de 8 bits,
-um registrador ou um registrador com deslocamento.</li>
-</ul>
+#Converta o número 1488d:
+##base 2
+##base 8
+##base 16
+#Converta os números abaixo para base decimal:
+##A3BDh
+##110100101.101b
+##1683o
+#Converta os números abaixo para binário com sinal e amplitude de 8bits:
+##-70d
+##70d
+##53h
+##232o
+#Converta o número decimal (positivo) em negativo utilizando complemento de 1:
+##17d
+##34d
+##89d
+##112d
+#Por que 0d=00000000b=11111111b em complemento de 1?
+#Converta o número decimal (positivo) em negativo utilizando complemento de 2:
+##17d
+##34d
+##89d
+##127d
+#Quais os números representados pelo complemento de 2 abaixo:
+##001101101b
+##111001010b
+##001111100b
+##101010101b
+#Se os números abaixo fossem representados por notação de Excesso 128, quais seriam?
+##00110110b
+##11100101b
+##00111110b
+##10101010b
+#O que é ''overflow''? Exemplifique.
+#O que é ''carry''? Exemplifique.
+#Explique como são representados os números reais em computadores?
+#Explique o que acontece quando se rotaciona um número binário para esquerda ou para direita?
+#Como é feita a notação de ponto flutuante?
+#Seja o byte 11111101b determinar:
+##O bit de sinal
+##O expoente
+##A mantissa
+##Valor decimal (considerando notação de excesso para expoente e ponto fixo para mantissa)
+#Seja o decimal 1,25d represente ele com notação de ponto flutuante de 8bits.
+#Para que serve a normalização do ponto flutuante?
+#O que é o bit escondido?
+#Explique o cuidado de se definir o intervalo e precisão de valores representáveis.
+#Qual o cuidado que o projetista de ''hardware''' tem que ter com ''Overflow'' e ''Underflow''?
+#Converta os valores decimais abaixo para a notação IEEE 754, precisão simples:
+##2019.8125d
+##570.5625d
+#Converta os valores ponto flutuante abaixo, notação IEEE 754 precisão simples, para base decimal:
+##1110 0001 1110 0001 0000 0000 0000 0000
+##0010 1010 1001 0101 1000 0000 0000 0000
-As instru&ccedil;&otilde;es de 3 argumentos s&atilde;o as seguintes:
+===Parte 4===
-{| class="wikitable"
+#Escreva um programa em ARM que implementa um loop com 20 iterações, incrementando uma variável do valor 0 a 19 e somando o valor 17, a cada iteração, ao valor inicial (=7) armazenado em R1.
-|+Instru&ccedil;&otilde;es de 3 argumentos
+#Escreva o programa em ARM que implementa as operações lógicas (AND, OR, XOR, NXOR, NAND E NOR) entre dois valores, armazenados em R4 e R5.
-|-
+#Implemente um programa ARM que resolve a equação: Y = (A - B) / (C + D x E). Dica: armazene A em R0, B, em R1, C, em R2, D, em R3 e E, em R4.
-|AND	op1,op2,op3
+#Implemente um programa em ARM que lê e compara os valores armazenados em R1, R2 e R3 e devolve o maior dentre eles em R4, e o menor, em R5.
-| op1 = op2 &amp; op3
+#Implemente um programa em ARM que coloque em ordem crescente 10 valores da memória.
-| E bit a bit
-|-
-|EOR	op1,op2,op3
-| op1 = op2 ^ op3
-| Ou exclusivo
-|-
-|ADD	op1,op2,op3
-| op1 = op2 + op3
-| Soma
-|-
-|SUB	op1,op2,op3
-| op1 = op2 - op3
-| Subtra&ccedil;&atilde;o
-|-
-|RSB	op1,op2,op3
-| op1 = op3 - op2
-| Subtra&ccedil;&atilde;o reversa
-|-
-|ADC	op1,op2,op3
-| op1 = op2 + op3
-| Soma com carry
-|-
-|SBC	op1,op2,op3
-| op1 = op2 - op3
-| Subtra&ccedil;&atilde;o com carry
-|-
-|RSC	op1,op2,op3
-| op1 = op3 - op2
-| Subtra&ccedil;&atilde;o reversa com carry
-|-
-|ORR	op1,op2,op3
-| op1 = op2 | op3
-| Ou bit a bit
-|-
-|BIC	op1,op2,op3
-| op1 = op2 &amp; ~op3
-| Bit clear (zera bits)
-|}
-Nas instru&ccedil;&otilde;es com 2 operandos o primeiro deve ser um registrador e o segundo
-pode ser um valor imediato de 8 bits, um registrador ou um registrador com deslocamento.
-;Exemplos de intru&ccedil;&otilde;es de 3 operandos:
-<pre class=code>
+====Respostas====
-	ORR	R1, R2, #0x20		@ R1 = R2 | 0x20
-	ADD	R2, R3, R4, LSL #3	@ R2 = R3 + (R4 &lt;&lt; 3)
-	RSB	R4, R5, #0		@ R5 = 0 - R5
-	SUB	R1, R2, R3, LSR R4	@ R1 = R2 - (R3 &gt;&gt; R4)
-</pre>
-{| class="wikitable"
+''* Algumas respostas!
-|+Instru&ccedil;&otilde;es de 2 argumentos
-|-
-|MOV op1, op2
-|op1 = op2
-|Copia op2 em op1
-|-
-|MVN op1, op2
-|op1 = ~op2
-|Copia op2 negado em op1
-|-
-|CMP op1, op2
-|op1 - op2
-|Compara: Subtrai ajustando CPSR sem armazenar o resultado
-|-
-|CMN op1, op2
-|op1 - ~op2
-|Compara com o segundo operando negado
-|-
-|TST op1, op2
-|op1 &amp; op2
-|Testa bits: Faz E ajustando CPSR sem armazenar o resultado
-|-
-|TEQ op1, op2
-|op1 ^ op2
-|Testa bits: Faz XOR ajustando CPSR sem armazenar o resultado
-|}
-===Instru&ccedil;&otilde;es de leitura da mem&oacute;ria===
+{{collapse top|Solução [1]}}
-Nesta listagem Rd e Re podem ser registradores R0 a R15.
+<pre>
+;PROGRAMA	QUE IMPLEMENTA R1 = R1 + 5, 40 VEZES
-Rd &eacute; o registrador que recebe o valor lido da mem&oacute;ria; Re &eacute; o reg que cont&eacute;m o endere&ccedil;o de
+		;		i.e., R1 = R1 x 200
-mem&oacute;ria que ser&aacute; lido. <tt>offset</tt> &eacute; uma constante positiva ou negaiva de 12 bits usada
+		;*******
-para modificar o endere&ccedil;o.
+		mov		r1, #7      ;valor inicial de R1
+		mov		r2, #17      ;incremento de R1
+		mov		r3, #20     ;numero de loops
-{| class="wikitable"
+		mov		r4, #0      ;valor inicial do contador
-|+Instru&ccedil;&otilde;es de leitura da Mem&oacute;ria para Registrador
+		;***INICIA	LOOP ***
-|-
+loop		add		r1, r1, r2  ;r1 = r1 + r2 (7+17)
-|LDR	Rd,[Re, #offset]
+		add		r4,r4, #1   ;r4 = r4 + 1
-|  Rd := mem&oacute;ria[Re + offset];
+		cmp		r4,r3	   ;r4 < r3?
-| Le 32 bits
+		blt		loop        ; se for menor pula pro loop
-|-
+fim
-|LDRH	Rd,[Re, #offset]
-|  Rd := mem&oacute;ria[Re + offset];
-| Le 16 bits (Half word)
-|-
-|LDRB	Rd,[Re, #offset]
-|  Rd := mem&oacute;ria[Re + offset];
-| Le 8 bits (Byte)
-|-
-|LDR	Rd,[Re, #offset]!
-|  Rd := mem&oacute;ria[Re + offset];<br>Re := Re + offset;
-| Le 32 bits  e modifica Re
-|-
-|LDR	Rd,[Re, Ri]
-| Rd := mem&oacute;ria[Re + Ri]
-| Le mem&oacute;ria com endere&ccedil;o formado pela soma de 2 registradores
-|-
-|LDR	Rd,[Re], #offset
-|  Rd := mem&oacute;ria[Re];<br>Re := Re + offset;
-| Le 32 bits  e modifica Re com p&oacute;s incremento
-|}
-===Instru&ccedil;&otilde;es de escrita na mem&oacute;ria===
-Nesta listagem Rf e Re podem ser registradores R0 a R15.
-Rf &eacute; o registrador que ser&aacute; armazenado na mem&oacute;ria; Re &eacute; o reg que cont&eacute;m o endere&ccedil;o na
-mem&oacute;ria. <tt>offset</tt> &eacute; uma constante positiva ou negaiva de 12 bits usada
-para modificar o endere&ccedil;o.
-{| class="wikitable"
-|+Instru&ccedil;&otilde;es escrita de Registrador na Mem&oacute;ria
-|STR	Rf,[Re, #offset]
-|  mem&oacute;ria[Re + offset]:= Rf;
-| Escreve 32 bits
-|-
-|STRH	Rf,[Re, #offset]
-|  mem&oacute;ria[Re + offset]:= Rf;
-| Escreve 16 bits (Half word)
-|-
-|STRB	Rf,[Re, #offset]
-|  mem&oacute;ria[Re + offset]:= Rf;
-| Escreve 8 bits (Byte)
-|-
-|STR	Rf,[Re, #offset]!
-|  mem&oacute;ria[Re + offset]:= Rf;<br>Re := Re + offset;
-| Le 32 bits  e modifica Re
-|-
-|STR	Rd,[Re], #offset
-|  mem&oacute;ria[Re]:= Rf;<br>Re := Re + offset;
-| Escreve 32 bits  e modifica Re com p&oacute;s incremento
-|}
-===Instru&ccedil;&otilde;es de salto===
-Salto relativo ao PC:
- <pre class=code>
-	B	enderco_destino		@ Salto incondicional
-	BEQ	iguais			@ Salta se Z=1 (Iguais)
-	BCS	carry_set
 </pre>
+{{collapse bottom}}
-===Chamada de subrotina:===
-<pre class=code>
-	BL	subrotina1
-</pre>
-A instru&ccedil;&atilde;o <tt>BL</tt> salva o endere&ccedil;o de retorno no R14 (que &eacute; o LR Link-Rgister) e
-salta para a subrotina. Para reornar, da subrotina pode-se copiar o LR no PC com
-<pre class=code>
-subrotina1:
-	@ Opera&ccedil;&otilde;es da subrotina
-	MOV	PC,LR	@ Retorna da subrotina
-</pre>
-O m&eacute;todo acima n&atilde;o &eacute; aninh&aacute;vel. N&atilde;o se poderia chamar outra subrotina de dentro desta subrotina
-porque o valor do LR seria alterado.
-<br>Subrotinas que chamam subrotinas, devem salvar o LR na pilha:
-<pre class=code>
-subrotina2:
-	PUSH	{R1, R2, LR}	@ Salva na pilha R1, R2, LR
-	@ Opera&ccedil;&otilde;es da subrotina
-	POP	{R1, R2, PC}	@ Restaura R1 e R2 e retorna da subrotina
-</pre>
------------
-=Aplicativos=
-==VISUAL (Arm)==
-:Disponível para download em: [https://salmanarif.bitbucket.io/visual/downloads.html  Visual - IDE para programação ARM]
-:Lista de instruções suportadas: [https://salmanarif.bitbucket.io/visual/supported_instructions.html INSTRUÇÕES ARM para Visual]
-;Exemplo: Mostrar como é compilado um programa, como são acessados os registradores, os comandos mov, add, sub e str.
-<syntaxhighlight lang=asm>
-;--------------------------------------------------------------------
-;	Exercicio adaptado para ARM de Patterson pags. 54/55/56
-;
-;	Mostra a compilacao de um comando de atribuicao em C
-;
-;--------------------------------------------------------------------
-;	Trecho em C:
-;
-;	f = (g + h) - (i + j)
-	mov		r1, #1		; g=1
-	mov		r2, #2		; h=2
-	mov		r3, #10		; i=10
-	mov		r4, #20		; j=20
-	add		r10, r1, r2      ; r10 = g + h
-	add		r11, r3, r4      ; r11 = i + j
-	sub		r0, r10, r11     ; f = r10 - r11
-	mov		r1, #0x10000
-	str		r0, [r1,#4]
-fim
-</syntaxhighlight>
-== ArmSim==
-:Disponível para download em: [https://webhome.cs.uvic.ca/~nigelh/ARMSim-V2.1/Windows/index.html ARMSim - IDE para programação ARM]
-=Referências=
-:Maiores informações sobre programação em ARM:
- [https://wiki.ifsc.edu.br/mediawiki/images/2/29/MIPM3TUG.pdf The Definitive Guide to the ARM CORTEX-M3 2nd ed]
-:Processador ARM:
- https://www.youtube.com/watch?v=7LqPJGnBPMM
-:Curso completo de programação para sistemas embarcados:
- https://www.youtube.com/playlist?list=PLPW8O6W-1chwyTzI3BHwBLbGQoPFxPAPM
 -----