* FabioOlive (~olive@oesc-livre/founder/fabioolive) entrou em #OeSC-Livre

* ChanServ coloca o modo de operador a FabioOlive

<AlissonB> FabioOlive, as arquiteturas tem um valor fixo de registradores pra realizar as operações?

<FabioOlive> AlissonB: sim, quando uma família de processadores é criada, a arquitetura indica quantos registradores tem, pra que servem, etc, e aí isso geralmente não muda (ou no máximo aumenta) nas novas versões da arquitetura

<AlissonB> e quantos registradores são, normalmente?

<FabioOlive> varia muito de arq pra arq

<FabioOlive> x86 em 16 e 32 bits tem o AX, BX, CX, DX, SI, DI pra uso genérico, mais BP e SP com uso um pouco mais especial

<FabioOlive> e o IP que aponta as instruções, então não é usado em operações normais (a não ser jumps :)

<FabioOlive> e alguns registradors de “segmento de memória” tipo CS, DS, ES, SS e tal

<FabioOlive> em 32bits os regs são os mesmos, só se inclui um E (de Extended) na frente, EAX, EBX, ECX, …

<FabioOlive> quando em modo 64bits, aparecem mais 8 regs, R8, R9, R10, …, R15

<FabioOlive> arquiteturas RISC geralmente possuem 32 registradores ou mais

<FabioOlive> e geralmente são chamados r0, r1, r2, r3, … até r31

<_edEr> AlissonB depois manda os logs.. ;)

<FabioOlive> RISC é uma característica de projeto que limita as operações diretas em memória, então ela provê mais registradores pra poder ter mais informação útil na CPU pra operar em cima

<FabioOlive> a x86 é uma arquitetura CISC, então característicamente tem menos registradores e usa mais a memória

<FabioOlive> então em x86 tu podes fazer algo como

<FabioOlive> carrega o conteúdo do endereço foobar no registrador AX

<FabioOlive> multiplica pelo conteúdo do endereço baz

<FabioOlive> enquanto em RISC (ARM, SPARC, MIPS, etc) teria que ser:

<FabioOlive> carrega o conteúdo de foobar em r2, carrega o conteúdo de baz em r3, multiplica r2 por r3

<FabioOlive> AlissonB: pensa assim: sabe uma calculadora de 4 operações, aquela calculadorinha básica? :)

<AlissonB> sim FabioOlive

<FabioOlive> então, uma calculadora dessas é como uma CPU sem RAM ligada nela

<FabioOlive> tu controlas a CPU e o registrador único dela diretamente no teclado

<FabioOlive> tu digita um número, tipo 42

<FabioOlive> quando tu apertas + pra indicar a operação de soma,

<FabioOlive> ela percebe que tu terminou de digitar o número e guarda ele no registrador

<FabioOlive> e guarda que a instrução a ser executada (em outro registrador) é soma, pois tu apertou +

<FabioOlive> quando tu digitares outro número e apertar =, ela executa a operação entre o conteúdo do registrador e o segundo número, coloca o resultado no registrador de novo e mostra no display

<FabioOlive> o resultado já fica no registrador, pois se tu apertares outra operação e outro número, ele segue acumulando o resultado no registrador

<FabioOlive> por isso geralmente se chama esse tipo de registrador de Acumulador :) ou A, pra abreviar, e quando a gente evolui a arquitetura de 8 bits pra 16 bits, a gente chama o A de AX, porque agora ele é o A eXtendido pra 16 bits

<FabioOlive> viu que divertido? :)

<FabioOlive> no caso da calculadora de 4 operações, o usuário faz o papel da RAM, pois é ele quem fornece os dados e as instruções :)

<FabioOlive> ou a folha de papel é a RAM, hehehe

<AlissonB> tudo tem lógica, basta sabê-la, hehe

<FabioOlive> a calculadora não armazena programa, ela é só a CPU, só armazena os registradores para as operações mais imediatas e fundamentais

<AlissonB> bem interessante, hehe

<AlissonB> saquei isso da calculadora

<AlissonB> é tudo pra uso imediato

<FabioOlive> no caso de um computador, a gente pluga a CPU na RAM, e coloca na RAM números que vão indicar operações (instruções) e operandos (dados), e a CPU sai executando sozinha :)

<FabioOlive> AlissonB: exato!