00:00:11
[Música]
00:00:20
Olá hoje nós temos a aula de número seis
00:00:23
da disciplina de organização de
00:00:25
computadores então nós já conversamos
00:00:27
sobre as características gerais do
00:00:29
computador sobre a organização interna
00:00:31
sobre a arquitetura do conjunto de
00:00:33
instruções E hoje nós vamos conversar
00:00:36
sobre o conjunto de instruções do mips
00:00:39
Então nós vamos exemplificar os
00:00:40
conceitos que nós vimos de arquitetura
00:00:42
de conjunto de instruções para um
00:00:45
computador para um processador
00:00:46
específico bom que processador é esse é
00:00:49
o mips o mips é um exemplo didático né
00:00:53
ele aparece em diversos livros textos
00:00:55
aparec aí nos livros textos que a gente
00:00:57
um dos livros textos que a gente
00:00:58
considera do rnc do pato
00:01:00
ah justamente porque um dos autores eh
00:01:04
do livro é autor do mips né Ah ele é um
00:01:07
processador Ah que está à venda ele tem
00:01:10
uma fatia de mercado no de ambientes
00:01:12
embarcados é usado em roteadores em
00:01:16
equipamentos de rede de armazenamento
00:01:18
impressoras né é um equipamento é um
00:01:20
dispositivo que tá em produção e que é
00:01:22
utilizado por que que a gente escolheu
00:01:24
seguir além de ser porque ele tá no
00:01:26
livro texto o mips tem características
00:01:28
de uma arquitetura Risk né então ele tem
00:01:31
a características de formatos de
00:01:33
instrução que facilitam o processo de
00:01:36
aprendizado eles conseguem cobrir todos
00:01:38
os elementos que a gente quer cobrir de
00:01:40
Arquitetura do conjunto de instruções e
00:01:43
os típicos os valores as características
00:01:46
desse conjunto de instruções é típico
00:01:48
dos conjuntos de instruções modernos
00:01:50
então a gente consegue cobrir as
00:01:52
características e discutir essas
00:01:54
características todas utilizando mips
00:01:56
como
00:01:57
referência bom o mips ele segue quatro
00:02:01
princípios de projeto que vão ser ah
00:02:04
relacionados às decisões que foram
00:02:06
tomados e as características dessa
00:02:08
arquitetura desse conjunto de instruções
00:02:10
primeiro princípio de projeto diz que a
00:02:13
simplicidade favorece a
00:02:15
regularidade ou seja quanto mais simples
00:02:18
as minhas instruções quanto mais regular
00:02:21
essas instruções forem né mais fácil é a
00:02:24
decodificação mais simples vai ser o
00:02:26
hardware que vai implementar essa
00:02:28
decodificação e Ass ent ação das
00:02:30
instruções então a simplicidade das
00:02:33
instruções das que a gente defini vai
00:02:36
favorecer a simplicidade do hardware e
00:02:38
vai levar a um melhor desempenho desse
00:02:40
processador bom o que que isso quer
00:02:43
dizer nesse primeiro momento que todas
00:02:45
as operações aritméticas tem a mesma
00:02:47
forma eu vou ter três operandos um
00:02:50
destino e dois operandos origem da onde
00:02:53
eu vou pegar os dados então todas as
00:02:55
instruções são do tipo Ed a b c onde a a
00:03:00
recebe os valores de b + c se eu quiser
00:03:03
fazer a soma de fazer a receber o valor
00:03:07
de a + b eu vou ter que explicitamente
00:03:09
escrever é a a e b né Então Eu repito na
00:03:14
instrução Eu ainda posso utilizar um
00:03:17
mesmo valor Mas a questão aqui é com
00:03:19
relação ao formato da instrução eu
00:03:22
preciso Obrigatoriamente incluir três
00:03:25
operandos e isso simplifica o processo a
00:03:28
decodificação dessa instru
00:03:30
e isso favorece a o desempenho a
00:03:33
implementação desse
00:03:35
processador segundo princípio de projeto
00:03:38
menor é mais rápido e aqui a gente tá
00:03:41
pensando em dois aspectos primeiro
00:03:44
acessar o registrador que tipicamente
00:03:47
são muito menor em termos de a
00:03:49
capacidade de armazenamento é muito
00:03:51
menor do que a memória principal né
00:03:54
acessar um registrador vai ter um menor
00:03:56
tempo de acesso ele é muito mais rápido
00:03:58
né quanto menor o meu conjunto de
00:04:01
registradores se eu tiver 32 ou 16 ao
00:04:04
invés de ter 128 256 o gerenciamento
00:04:07
desses registradores o acesso a esses
00:04:09
registradores também vai ter um tempo de
00:04:11
acesso mais rápido tá então Esse
00:04:14
princípio ele trata do de usar
00:04:16
registradores como operandos dessa
00:04:18
característica que a gente tem no mips
00:04:20
de manipular os registradores para as
00:04:22
operações Lógico aritméticas né então
00:04:26
ele tem 32 registradores de 32 bits
00:04:29
então mips que a gente tá vendo aqui
00:04:30
como exemplo é o mips de 32 bits cuja
00:04:33
palavra tem 32 bits o formato de
00:04:35
instrução tem 32 bits e nós temos 32
00:04:39
registradores também que vão ser
00:04:41
numerados de 0 a
00:04:45
31 bom esses registradores eles têm do
00:04:49
ponto de vista de linguagem assemble do
00:04:51
mips alguns nomes especiais para
00:04:53
facilitar a nossa manipulação primeiros
00:04:56
deles a gente vai ter os registradores
00:04:58
de dólar T zer é dólar T9 são
00:05:01
registradores que a gente pode utilizar
00:05:02
para armazenar valores no nosso código
00:05:05
na nossa implementação no assemble do
00:05:08
mips além de dólar t0 a dólar T9 a gente
00:05:11
tem o dólar s0 a dólar s7 então nós
00:05:14
temos um total aqui de 18 registradores
00:05:17
que a gente pode manipular nos Nossos
00:05:20
programas em assemble do mips tá Ah
00:05:23
esses registradores têm esses nomes t e
00:05:26
s né porque eles estão Associados a
00:05:28
valores temp horários e valores que T
00:05:32
que ser salvas o que que isso quer dizer
00:05:34
nós vamos discutir mais paraa frente o
00:05:36
que que acontece com uma chamada de
00:05:38
função ou uma chamada de procedimento
00:05:40
para tratar uma interrupção então Caso
00:05:42
haja uma mudança nesse fluxo de quem tá
00:05:45
executando né O que tá nos variáveis nos
00:05:48
valores temporários ninguém tem
00:05:50
obrigação de salvar e o programa tem que
00:05:52
saber que ele corre o risco de perder
00:05:54
por outro lado o que tá num valor e num
00:05:56
registrador do tipo S requer que quem
00:06:00
for utilizar esse registrador do tipo S
00:06:02
salve o valor desse registrador e após o
00:06:05
uso restaure o valor original Então isso
00:06:08
é uma característica da arquitetura do
00:06:10
conjunto de instruções que os programas
00:06:12
têm que seguir bom mas aqui a gente tem
00:06:15
18 registradores e eu falei que tinha 32
00:06:18
e esses outros registradores esses
00:06:21
outros registradores eles têm alguns
00:06:22
propósitos específicos pro mips a gente
00:06:25
vai tratar de vários deles ao longo das
00:06:27
várias instruções que a gente for
00:06:29
explorando e o primeiro que eu quero
00:06:30
destacar aqui é o registrador zero que é
00:06:33
chamado de dólar zero bom quando a gente
00:06:36
pensa nas nossas programas em C ou em
00:06:38
Java a gente faz muitas vezes atribuição
00:06:41
de zero vou fazer um loop primeiro lá
00:06:44
meu primeiro valor tipicamente e ig zer
00:06:46
vou incrementar esse valor muitas vezes
00:06:49
vou checar uma condição tô comparando
00:06:50
ser igual a zero maior que zero menor
00:06:52
que zero então nós utilizamos muito o
00:06:54
valor zero nas nossas na nossa linguagem
00:06:57
nos Nossos programas Então como esse é
00:07:00
um valor muito utilizado foi decidido
00:07:02
que esse registrador zero vai ter a
00:07:05
constante zero né que esse é um
00:07:07
registrador que eu não pode ser
00:07:08
sobrescrito então eu já tenho num
00:07:10
registrador esse valor que eu quero
00:07:12
utilizar Por que que isso é importante
00:07:14
porque isso evita que eu precise toda
00:07:17
vez que eu vou fazer um programa que eu
00:07:18
vou usar zero e a gente eu desafio vocês
00:07:21
aí a verificarem os códigos de vocês que
00:07:24
vocês escreveram nas várias disciplinas
00:07:26
e nos vários programas que vocês tiveram
00:07:28
que escrever se se vocês quantas vezes
00:07:30
vocês usaram esse valor zero essa
00:07:32
constante zero então o fato de eu não
00:07:34
precisar acessar uma posição de memória
00:07:37
para buscar esse valor zero já faz com
00:07:39
que eu tenha um ganho de desempenho
00:07:40
então justamente por causa desse uso é
00:07:43
que a gente tem aqui essa decisão de
00:07:45
projeto de que eu tenho um registrador
00:07:46
com esse valor um outro uso interessante
00:07:50
também é para fazer movimentação do
00:07:51
conteúdo de registradores se por algum
00:07:54
motivo eu quero movimentar né Eu quero
00:07:57
deslocar o que tá em S1 para T2
00:08:00
basta eu somar o valor de S1 com zero
00:08:02
que eu já tenho esse deslocamento
00:08:03
garantido então o mips não tem uma
00:08:06
instrução de movimentação mas o fato de
00:08:08
eu ter esse registrador zero permite que
00:08:10
eu crie ess que eu use essa instrução de
00:08:13
movimentação através da instrução de
00:08:16
audição bom outro aspecto importante é
00:08:18
falar de memória né Onde estão os nossos
00:08:21
dados principais como é que funciona a
00:08:23
memória no caso do mips Bom primeiro
00:08:25
aspecto importante a memória endereçada
00:08:27
por byte né apesar da minha palavra ter
00:08:30
32 bits quer dizer que eu tenho 4 bytes
00:08:33
por palavra eu vou fazer o endereçamento
00:08:35
por byte isso é importante porque eu
00:08:37
posso acessar byte na memória eu posso
00:08:39
acessar meia palavra 16 bits ou eu posso
00:08:42
acessar minha palavra toda os 32 bits
00:08:44
então é importante ter essa
00:08:45
flexibilidade no modo de
00:08:47
endereçamento só que as palavras tê que
00:08:50
estar escritas na memória de maneira
00:08:52
alinhada ou seja sempre do bit zero até
00:08:56
o bit 31 sempre alinhado ocupando uma
00:08:59
lha linha toda se eu tiver um valor
00:09:01
menor eu vou por exemplo um byte eu eu
00:09:04
não posso colocar esse byte entre duas
00:09:06
linhas ele precisa tá el precisa tá
00:09:08
colocado na posição correta se for o
00:09:10
caso eu tenho que complementar isso com
00:09:12
zeros fazer essa extensão tá isso quer
00:09:15
dizer o quê se a memória é alinhada
00:09:17
endereçada por byte que quando eu for
00:09:19
buscar minha instrução na memória e a
00:09:21
instrução sempre tem uma palavra toda
00:09:23
que eu vou ter que fazer com que os meus
00:09:25
endereços sejam múltiplos de quatro a
00:09:27
minha primeira instrução por exemplo vai
00:09:29
tá no endereço x a instrução seguinte
00:09:32
vai estar em x + 4 porque eu quero
00:09:34
deslocar uma linha toda tá então é
00:09:37
importante lembrar dessa questão que os
00:09:39
endereços têm que ser múltiplos de
00:09:40
quatro na hora de fazer busca de
00:09:42
instruções na hora de fazer busca de
00:09:44
palavras para poder gerar o código em
00:09:45
assemble correto e uma observação
00:09:49
interessante aqui a gente tem a duas
00:09:52
maneiras de organizar as memóri os dados
00:09:55
na memória né que é o que a gente chama
00:09:57
de ess em inglês o caso do mips ele é
00:09:59
big endian o que isso quer dizer que o
00:10:01
byte mais
00:10:03
significativo está no endereço menos
00:10:05
significativo da palavra Então o bte que
00:10:08
tá no endereço zero é o bte TR tá isso
00:10:11
aqui é importante Principalmente quando
00:10:12
a gente vai escrevendo código em
00:10:14
assembly for fazer a manipulação de
00:10:17
endereços de memória Mas se por outro
00:10:19
lado a gente tiver o compilador o
00:10:21
montador trabalhando PR a gente isso não
00:10:24
vai ser tão relevante mas é importante
00:10:26
lembrar dessas diferenças com relação
00:10:28
aos vários
00:10:30
sistemas bom então vamos ver aqui um
00:10:33
exemplo de acessar a memória então se eu
00:10:35
tiver esse código em c g = h + a de8 né
00:10:40
eu posso mapear G por exemplo no
00:10:42
registrador S1 h no registrador S2 e o
00:10:46
endereço base de A ou seja zero vai tá
00:10:49
em S3 como é que eu faço para
00:10:52
implementar essa operação Primeira coisa
00:10:54
eu preciso buscar esse valor na memória
00:10:56
eu preciso buscar a de8 na posição de
00:10:58
memória
00:10:59
Ou seja eu vou precisar considerar o meu
00:11:02
endereço base S3 e deslocar essas oito
00:11:06
posições Lembrando que na verdade como o
00:11:09
endereço é em byte eu vou ter que
00:11:11
multiplicar isso por quatro né então por
00:11:13
isso que a instrução de load ela coloca
00:11:16
aqui o meu endereço base S3 e aqui o
00:11:19
deslocamento ou seja esse 32 é o número
00:11:22
de iterações que eu vou ter que deslocar
00:11:25
com relação a multiplicar por quatro
00:11:28
porque é o número de de bytes que eu
00:11:29
tenho na minha palavra e t0 é o meu
00:11:32
destino para essa informação uma vez que
00:11:34
eu tenho o valor de a de 8 em t0 eu
00:11:37
posso fazer a soma com o valor que eu
00:11:39
tinha em S2 que equivale a h e armazenar
00:11:43
em G tá então aqui é o exemplo que a
00:11:46
gente tem do acesso à
00:11:50
memória Desculpa bom terceiro princípio
00:11:53
de projeto fazer o caso comum mais
00:11:56
rápido ele decorre justamente da lei de
00:11:58
andal que a gente discutiu lá no começo
00:12:00
do curso né eu tenho que procurar
00:12:02
otimizar aquilo que a gente usa mais bom
00:12:05
além do zero que a gente usa bastante
00:12:06
nos nossos códigos a gente também
00:12:09
costuma fazer bastante incremento de um
00:12:11
em um por exemplo nos casos dos Loops a
00:12:14
gente usa bastante informação ah somas
00:12:18
ou subtrações de valores pequenos né e
00:12:21
valores pequenos aqui são valores por
00:12:23
exemplo que eu poderia armazenar em 8
00:12:24
bits em 16 bits né ah e justamente
00:12:27
pensando nessas caracter
00:12:29
nesse caso comum que é o uso de
00:12:31
constantes pequenas né é que a gente tem
00:12:34
as um outro tipo de instrução que
00:12:37
permite que eu tenha uma um operando que
00:12:40
não está armazenado no registrador mas
00:12:42
que tá escrito na própria instrução tá
00:12:45
Ah e como essas constantes são pequenas
00:12:48
eu posso pegar então e colocar essas
00:12:50
constantes em 16 bits tá então por
00:12:53
exemplo nessa instrução de soma com uma
00:12:56
constante é a instrução do tipo e de i e
00:12:58
de imediato eu estou somando o conteúdo
00:13:01
do registrador S3 com o valor 4 com a
00:13:04
constante 4 e armazenando em S3 tá isso
00:13:08
também é útil para fazer as instruções
00:13:12
para evitar com que eu faça um load de
00:13:14
uma constante da mesma forma que eu não
00:13:16
gostaria de fazer o load do valor zero
00:13:18
eu também não gostaria de ter que fazer
00:13:19
load de valores pequenos por exemplo
00:13:21
daquele um que toda hora eu tô somando
00:13:23
lá no meu loop no meu for Ah não existe
00:13:26
constante negativa desculpa não existe
00:13:29
subtração de constantes as instruções
00:13:32
com imediato são só as instruções de
00:13:34
adição Então eu preciso fazer aqui se eu
00:13:37
quiser uma subtração colocar um valor
00:13:39
negativo
00:13:42
Tá bom então a gente falou de dois tipos
00:13:46
de instrução até agora instruções como
00:13:48
as instruções aritméticas que tem três
00:13:50
registradores e essa instrução i isso
00:13:52
traz a gente para discutir os formatos
00:13:54
de instruções que a gente tem no mips tá
00:13:57
então a gente já falou das instru com
00:13:59
registrador que aparece aqui os
00:14:01
registradores e dessa instrução que
00:14:03
aparece a constante aqui que é essa
00:14:05
instrução com o imediato Então vamos
00:14:07
conversar um pouquinho sobre esses tipos
00:14:09
de instrução primeiro instrução do tipo
00:14:11
R que são as instruções com
00:14:13
registradores como operamos eu tenho o
00:14:15
meu opcode se bits que vão Identificar
00:14:18
qual que é a operação Qual que é a
00:14:20
instrução que tá sendo executada aí eu
00:14:23
vou ter dois registradores com operandos
00:14:25
rs e RT como eu tenho 32 Ades no mips eu
00:14:30
preciso de 5 bits para contar esses 32
00:14:32
registradores exatamente o que eu tenho
00:14:34
aqui 5 bits para RS 5 bits para RT E aí
00:14:37
eu vou ter RD que é o meu registrador
00:14:39
destino mais 5 bits para RD bom isso
00:14:42
ainda me sobra 11 bits nessa minha
00:14:44
instrução de 32 bits ah Existem algumas
00:14:47
instruções de shift de deslocamento que
00:14:51
eu vou usar esse campo aqui Shift amount
00:14:54
para justamente passar esse valor de
00:14:56
deslocamento né se eu tenho 32 bit é
00:14:59
razoável que eu só vai fazer
00:15:00
deslocamento de até 32 posições né não
00:15:03
não preciso mais do que 5 bits para
00:15:05
representar esse valor e finalmente meus
00:15:08
últimos se bits aqui na instrução do
00:15:10
tipo R é função se eu só tenho 6 bits de
00:15:14
opcode eu teri 2 à se 64 valores
00:15:17
possíveis de instrução para poder
00:15:19
executar e nesse meu conjunto de
00:15:22
instruções bom não é um valor tão grande
00:15:25
né eu tenho soma
00:15:26
subtração os as unidades as operações
00:15:29
lógicas load tort são uma série de
00:15:31
instruções a maneira de estender esse
00:15:33
número de instruções é usar esse campo
00:15:36
de função vamos ver um exemplo aqui por
00:15:39
exemplo nessa instrução de soma onde eu
00:15:41
quero somar t0 S1 e S2 eu vou usar um
00:15:44
valor especial para representar que é
00:15:46
uma instrução aritmética aqui no opcode
00:15:49
por exemplo o valor
00:15:51
00 e eu vou usar o campo de função para
00:15:55
especificar que a minha instrução
00:15:57
aritmética que tá dentro de 00 equivale
00:16:01
ao valor 32 ou em decimal ou um 00 aqui
00:16:05
em binário tá então essa combinação do
00:16:09
campo de upcode com função é que vai
00:16:11
permitir que eu reconheça a minha função
00:16:13
de adição bom dois registradores
00:16:16
operandos S1 e S2 olhando na tabela de
00:16:20
referência do mips né que a gente tem
00:16:23
disponível que a gente tem acesso a
00:16:24
gente vai ver que isso equivale aos
00:16:26
registradores 17 e 18 o meu destino t0
00:16:30
equivale ao registrador de número o
00:16:32
então com isso eu sou capaz de construir
00:16:35
a minha instrução bom Como é que o
00:16:38
processador vai entender isso para poder
00:16:39
executar eu preciso transformar o que tá
00:16:41
em decimal que é conveniente para nós
00:16:43
humanos entendermos em binário uma vez
00:16:47
que eu tenho instrução em binário eu
00:16:48
empaco os meus 32 bits aqui em base do E
00:16:51
é isso que o processador vai usar para
00:16:54
ler da memória e para poder saber como
00:16:56
executar essa instrução
00:16:59
bom observando agora a instrução do tipo
00:17:01
I ela continua com os mesmos seis bits
00:17:04
up code a gente tem aqui regularidade no
00:17:06
formato de instrução e eu vou ter dois
00:17:09
registradores aqui RS RT cada um 5 bits
00:17:12
e depois eu tenho 16 bits do campo de
00:17:15
imediato Tá então vamos conversar um
00:17:18
pouquinho sobre esses campos bom a gente
00:17:20
tem dois tipos aqui iniciais que a gente
00:17:23
vai falar de instruções do tipo I
00:17:25
Primeiro as instruções aritméticas se eu
00:17:27
tenho uma instrução aritmética esse meu
00:17:29
campo de imediato é uma constante aquela
00:17:31
constante que pode ser positiva ou
00:17:33
negativa né se a gente lembrar lá das
00:17:35
aulas de lógica digital de aritmética
00:17:37
binária se eu tenho 16 bits essa
00:17:40
constante pode ir de -2 até elevado a 15
00:17:44
até + 2 elevado 15 - 1 que é uma um é
00:17:48
uma constante pequena mas ainda assim é
00:17:50
um espaço razoável de valores pra gente
00:17:52
considerar como constante tá bom se for
00:17:55
uma instrução de load que eu quero
00:17:57
buscar um dado na memó memória eu vou
00:17:59
usar esse valor para ajudar a compor o
00:18:02
meu endereço tá então por isso que esses
00:18:05
esse imediato também pode ser entendido
00:18:07
como endereço esses 16 bits de endereço
00:18:10
ele vai ser somado ao meu endereço base
00:18:13
que está em RS ou seja nesse registrador
00:18:16
Então nesse registrador RS eu vou ter um
00:18:17
endereço de 32 bits eu vou pegar esses
00:18:20
16 bits aqui de endereço vou precisar
00:18:22
fazer a extensão de sinal ou seja a se
00:18:25
ele é um
00:18:26
endereço ele é um endereço ou seja não
00:18:28
tem um conceito de positivo e negativo
00:18:29
vou precisar adicionar bit zero a esses
00:18:32
16 bits para que ele tenha 32 bits vou
00:18:34
somar com o meu endereço base e com isso
00:18:36
eu vou poder acessar uma determinada
00:18:38
posição de memória no caso de uma
00:18:40
instrução de load onde eu tô pegando um
00:18:42
dado da memória para trazer pro
00:18:44
processador eu vou armazenar essa
00:18:46
informação em
00:18:48
RT então justamente o que a gente tem
00:18:51
aqui é o quarto princípio de projeto que
00:18:54
ele vai falar que um bom projeto né de
00:18:57
um computador implica em compr
00:18:59
eu gostaria de ter uma faixa de endereço
00:19:01
Grande para acessar memória muito mais
00:19:04
do que só somar 16 bits eu gostaria de
00:19:06
ter uma possibilidade muito grande de
00:19:07
constante mas por outro lado é
00:19:09
importante que eu tenha regularidade no
00:19:12
meu formato de instrução que eu respeite
00:19:13
os meus 32 bits e que eu ten uma
00:19:15
estrutura muito próxima então por isso
00:19:18
eu não mexi os projetistas não mexeram
00:19:20
nessa parte da instrução então o
00:19:22
compromisso aqui foi ter só 16 bits de
00:19:25
constante ou endereço
00:19:30
o outro tipo de instrução que também usa
00:19:32
o tipo I são as instruções de desvio né
00:19:35
Essas instruções de desvio comparam dois
00:19:37
registradores rs e RT se for se a
00:19:41
condição for verdade eu vou desviar pro
00:19:45
endereço que tá implicado no naqueles 16
00:19:48
bits naquele valor tá então Aqueles 16
00:19:51
bits que eu tenho no campo de imediato
00:19:53
vão ser transformados num endereço de
00:19:55
instrução eles vão ser somados ao meu
00:19:57
endereço base da instrução e vão dar um
00:19:59
novo fluxo pra minha execução a gente
00:20:02
tem dois tipos de instrução de desvio
00:20:04
aqui o bran equal e o Branch not equal
00:20:08
ou seja desvio se for igual desvio se
00:20:11
for diferente então a gente simplifica
00:20:14
no caso do projeto do mips Ele eles
00:20:17
optaram por ter simplesmente dois tipos
00:20:20
de codificação dois tipos de desvio e
00:20:23
fazer com que a gente faça as
00:20:24
comparações separadas para chegar nesse
00:20:27
tipo de
00:20:30
e finalmente o nosso último tipo de
00:20:32
instrução é o tipo J terceiro e último
00:20:34
tipo mantém os mesmos 32 bits e mantém 6
00:20:38
bits de opcode O que que a gente tem na
00:20:40
instrução de tipo J são os saltos ou os
00:20:44
desvios incondicionais são instruções
00:20:46
que vão desviar de qualquer forma a
00:20:48
gente tem aqui as instruções de jump ou
00:20:51
Jump and link tá o que que essas
00:20:53
instruções fazem elas vão mudar para um
00:20:55
outro endereço de qualquer forma bom meu
00:20:58
endereço tem 32 bits mas aqui eu só
00:21:00
tenho 26 bits então a decisão do projeto
00:21:03
aqui dos projetistas Foi criar um outro
00:21:05
modulo de endereçamento onde eu vou
00:21:08
combinar os bits mais significativos do
00:21:10
meu registrador contador de instrução
00:21:13
para concatenar com o endereço que tá
00:21:15
nesses 26 bits Lembrando que o endereço
00:21:19
é por byte tá então aqui eu tô apontando
00:21:22
o endereço por byte eu preciso
00:21:24
multiplicar por quatro para alinhar com
00:21:26
a forma de endereçamento que a gente tem
00:21:27
no mips
00:21:30
então com isso a gente viu as
00:21:32
características principais do conjunto
00:21:34
de instruções do mips que estão
00:21:36
descritas aí no Capítulo do do livro do
00:21:38
renes do Patterson
00:21:55
[Música]
00:21:58
C
00:22:09
[Música]
