ADD é um microprograma ou microinstrução ? [RESOLVIDO]

ednux
(usa Arch Linux)

Enviado em 22/02/2016 - 13:29h

Estou estudando Organização e Arquitetura de Computadores e fiquei com essa dúvida. Onde é a barreira entre microintruções e microprogramas ?
Gostaria de um exemplo de uma microinstrução e da mesma dentro de um microprograma.

To aprendendo pelo livro do Tenenbaum (Organização estruturada de computadores, 5 edição).

mulatinho
(usa Slackware)

Enviado em 22/02/2016 - 14:29h

caro colega,

acho que esse não é o fórum correto pra essa pergunta.

ADD no sentido em que você deve estar falando é uma instrução da linguagem Assembly, que pode somar dois números, dois registros ou dois endereços.

todo o binário tem uma série (muitos) de mnemônicos em BITS e podem ser traduzidos também em hexadecimal; no fim eles são nada mais do que instruções assembly em linguagem de máquina; e que como uma grande quantidade e uma lógica entre si finalmente formam um programa. o estudo de mnemônicos também é uma das bases para engenharia reversa.

ednux
(usa Arch Linux)

Enviado em 22/02/2016 - 14:48h

É, eu sei que essa comunidade é de C/C++ porém aqui é melhor visualizado e se tiver alguém no vol que saiba com certeza está aqui.

O ADD que me refiro é da linguagem de Máquina (nível ISA), abaixo do assembly. Assembler pelo que entendi. Porém eu notei que podem existir 2 tipos, um ADD que representa a soma e outro como se fosse uma mini função que carrega dados A, carrega dados B, soma e coloca em C.
Na minha visão isso funcionaria como microinstruções formam microprogramas e estes formas as instruções. É isso que eu quero saber, se esse é o raciocínio correto.

EnzoFerber
(usa FreeBSD)

Enviado em 22/02/2016 - 19:23h

Olá.

É difícil dizer quais instruções são parte do hardware e quais do software. Em um nível tão baixo é escolha do fabricante como implementar. Mas para a função ADD, provavelmente ela é no nível de hardware, já a instrução de multiplicação provavelmente é em nível de microprograma (já que podemos multiplicar n*m em log(m) clocks ;) Dá uma olhada nos Adders: https://en.wikipedia.org/wiki/Adder_(electronics)

Primeiro, sua pergunta: Onde é a barreira entre microintruções e microprogramas?

Os microprogramas são compostos por microinstruções. https://en.wikipedia.org/wiki/Microcode

É complicado te dar um código de microprograma, já que estão dentro dos processadores. Você pode tentar procurar por isso na internet. Mas já as instruções que ele executa, são os números que você consegue em um dumper.

$ gcc -c main.c

$ objdump -d main.o

...

 

Vai ver as instruções em números.

*

Algumas coisas a ter em mente:
1. Assembly é a linguagem composta por mneumônicos que representam instruções de máquina.
2. Assembler é o programa que traduz os mneumônicos inteligíveis para códigos de máquina (instruções).
3. Os processadores normalmente tem um "interpretador" chamado de micro-programa, que interpreta as micro-instruções (os números traduzidos pelo assembler).

*

No Organização Estruturada de Computadores:

Página 3, figura 1.1. Máquina Multinível.

Aqui, o nível 0 é o hardware em si (portas lógicas executando pulsos elétricos).
O nível 1 é o micro-programa que executa a ISA - a ISA é a forma na qual estão organizadas as portas lógicas, os multiplexadores, etc. Não vá fundo nessa parte até ter uma boa base conceitual de como a pilha funciona, senão vai pirar e sua curva de aprendizado será muito ruim.

Aconselho a ler o livro do Tanenbaum de forma sequencial. Ele tem uma ótima forma de explicar e exemplificar as coisas, tem um humor bem interessante e te passa as abstrações conceituais necessárias para você entender o próximo nível. Tenta não ir com muita pressa, o assunto é complexo.

Dito isto, você poderá ler mais sobre o L1 (microcódigo ou microprograma) na página 190, início do capítulo 4 - O nível de microarquitetura.

Entender os computadores em nível tão baixo pode ser uma tarefa árdua e LONGA, portando, recomendo "pular" entre os diversos níveis de abstrações para tentar entender como as coisas são. O que quero dizer é para sempre procurar entender a abstração CONCEITUAL de um nível acima ao nível o qual você esta estudando a IMPLEMENTAÇÃO.

(Pra cima diminui a complexidade, pra baixo aumenta)

Existe um tópico extremamente interessante que serve como "linhas gerais", e vai ajudar bastante:
http://programmers.stackexchange.com/questions/81624/how-do-computers-work/81715#81715

Leia. Leia duas vezes. Vale a pena.

*

Eu gostei bastante de tentar implementar uma máquina de nível zero em C. Desenvolvi um pequeno conjunto de instruções (umas 40) que conseguiam realizar loads/stores, add, sub, double, half, etc. Desenvolvi então, em cima disso, um pequeno microprograma.

É bem interessante. O código final nunca é bom o suficiente e estou sempre brincando com ele, refazendo algumas partes ou completamente. O que vale a pena nesse processo é escrever o código - não procure códigos feitos, implemente o SEU. Os insights que terá serão impagáveis.

Depois de um tempo, você terá uma máquina com umas 100 instruções e poderá VER programas sendo carregados na memória e sendo executados. É muito legal. Muito. Sério.

*
Structure and Interpretation of Computer Programs

Sobre a multiplicação em log(m), vale a pena ser lido: https://mitpress.mit.edu/sicp/

Ah, sobre o SICP (o livro acima): Se você for ler só um livro sobre programação, leia este. De quebra, vai aprender Scheme (um dialeto de LISP). E vai ficar fera em recursividade.

*

Além disso, dá uma olhada no processo de fazer bootstrap para um compilador, vai te dar uns insights legais também. Esse aqui é bem legal: http://homepage.ntlworld.com/edmund.grimley-evans/bcompiler.html

O primeiro arquivo que ele utiliza é totalmente escrito em instruções de máquina (em números hexadecimais) - isso significa que você pode carregar o programa diretamente na memória e ele será executado pelo processador ;)

Coisa bacana!

*

Acho que exagerei um pouco, mas costumo me empolgar com baixo-nível.
Qualquer dúvida posta denovo, será um prazer ajudar.

[]'s
Enzo Ferber

$ indent -kr -i8 src.c



"(...)all right-thinking people know that (a) K&R are _right_ and (b) K&R are right." - linux/Documentation/CodingStyle - TORVALDS, Linus. 

 

removido
(usa Nenhuma)

Enviado em 22/02/2016 - 20:04h

Existem códigos numéricos representados geralmente em hexadecimal que fazem determinadas ações no microprocessador.
Estes códigos podem relacionar registradores da máquina ou endereços de memória ou ambos.
Para não ter que ficar se lembrando toda hora qual código é para tal coisa nos registradores usam-se mnemônicos.


Existe documentação no site dos fabricantes de microprocessadores que lista quais são esses códigos hexadecimais e quais os mnemônicos correspondentes.


Mnemônicos são palavras como ADD, SUB, MOV, MUL, DIV, JMP, JL ... que servem para lembrança de instruções ao invés de se usar os números nos locais.
Os nũmeros são escritos em hexadecimais na tabela mas poderiam ser em octais, decimais, tanto faz.


São apenas códigos numéricos que dariam nó na cabeça de quem tentar se lembrar.
Cada processador tem seus códigos. Alguns podem seguir um padrão e ter códigos semelhantes a de outros.
Por exemplo, instalar a mesma distribuição em uma máquina com processador AMD e em outra com processador Intel.


Esses mnemônicos representam as instruções dos programas em Assembly.
Assembly é a linguagem. Assembler é o programa que faz a montagem. É o montador.
Não se diz que Assembly é compilada, mas sim montada.


Com a documentação do fabricante de processadores pode-se criar um programa montador, isto é, um assembler para linguagem Assembly.


Ainda vale lembrar que além de diferenças estruturais de processador, existem diferenças entre Assembly de sistemas operacionais diferentes.


As interrupções 21h e 13h do MSDOS© não funcionam se o programa tentar ser compilado para Linux.
Programas em Assembly para Linux 32 bits e 64 bits também são diferentes, pois usam registradores diferentes para se chamar as interrupções.

----------------------------------------------------------------------------------------------------------------
http://24.media.tumblr.com/tumblr_m62bwpSi291qdlh1io1_250.gif

ednux
(usa Arch Linux)

Enviado em 23/02/2016 - 02:14h

Muito obrigado a todos! Foi bem esclarecedor. Esses conceitos são difíceis de se encontrar e quanto mais eu lia, mas confuso ficava. Eu realmente estou com um pouco de pressa e precisei correr com o conteúdo.

Essa era a conexão que estava faltando nos meus estudos.

Vou seguir seus conselhos, Enzo, nessa longa jornada ;)
E listeiro_037 muito obrigado por escrever de uma forma tão simples e intuitiva o conceito de mnemônicos.

Só mais uma dúvida, quando um programa em C é compilado ele é traduzido para Assembler ou para micro-instruções ?
E em Assembly é montado para assembler e depois micro-instruções correto ?

Se entendi bem, os níveis poderiam ser de cima para baixo: Linguagem C, Assembly, Assembler, micro-instruções e finalmente interpretados pelo micro-programa.

removido
(usa Nenhuma)

Enviado em 23/02/2016 - 05:26h

Assembly é a linguagem em si com os mnemônicos. Assembler é o programa que transforma os mnemônicos naqueles hexadecimais malucos falados lá atrás. Vulgarmente os números são conhecidos como linguagem de máquina.

Eu tenho alguns programas em Assembly para Linux em minha conta do VOL. Dê uma passada por lá. Alguns para 32 bits e outros para 64 bits. Você pode até testar e ver se funcionam no seu Linux. :-)

Primeiro vem os mnemônicos (Assembly). Depois o montador (Assembler) transforma o Assembly (mnemônicos) em um monte de códigos numéricos conhecidos como linguagem de máquina. E o processador não entende números, mas sinais elétricos ritmados por pulsos de clock e chaveados por circuitos digitais lógicos e outras coisas mais.

Se você souber os números de cor e escrever um arquivo binário com eles dentro possivelmente ele rodará. Tinha até um projeto de montador em shell script. O nome dele é que não era muito legal: shasm.

Sobre o compilador C e o montador; no caso depende de como os programas compiladores e montadores foram estruturados.

Por exemplo, não tenho certeza se o compilador C do Projeto GNU chamado de GCC é um front-end para o programa assembler do projeto GNU chamado de as (antigamente GNU Assembler era chamado GAS mas devem ter mudado para AS porque pegou mal ou vai saber).

Se o GCC for front-end no processo de criação do programa e o AS for backend, então o programa em C (no caso deste software) é transformado em um tipo de Assembly (para o tipo do GNU Assembly) e em um segundo passo este virará os códigos. Esses programas montadores podem funcionar em mais de um passo para criar a linguagem de máquina.

Veja o exemplo de um código em C:

#include <stdio.h>

#include <stdlib.h>



// teste-1030.c

// testado com gcc -S teste-1030.c



int main (){



	int  x = 10;



	printf("\n\n%d\n\n", &x);



	return 0;

} 

Quando usado com o GCC usando a opção -S (conforme comentado no exemplo), ele dá uma saída de instruções Assembly:

	.file	"teste-1030.c"

	.section	.rodata

.LC0:

	.string	"\n\n%d\n\n"

	.text

	.globl	main

	.type	main, @function

main:

.LFB2:

	.cfi_startproc

	pushq	%rbp

	.cfi_def_cfa_offset 16

	.cfi_offset 6, -16

	movq	%rsp, %rbp

	.cfi_def_cfa_register 6

	subq	$16, %rsp

	movl	$10, -4(%rbp)

	leaq	-4(%rbp), %rax

	movq	%rax, %rsi

	movl	$.LC0, %edi

	movl	$0, %eax

	call	printf

	movl	$0, %eax

	leave

	.cfi_def_cfa 7, 8

	ret

	.cfi_endproc

.LFE2:

	.size	main, .-main

	.ident	"GCC: (Debian 4.9.2-10) 4.9.2"

	.section	.note.GNU-stack,"",@progbits 

Há uma teoria sobre montadores num livro antigo chamado Assemblers, Compilers, and Program Translation, de Peter Calingaert. E tem um professor brasileiro que escreveu um livro muito legal sobre teoria de montadores. Ele é do sul do Brasil, de uma faculdade pública. Não me lembro do nome dele agora.

Dê uma olhada cuidadosa neste livro: http://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-... e tem muito mais de onde este veio.

Nele você encontra sobre opcodes e mnemônicos.

Há um tempo atrás a Intel mandava prá casa da pessoa que solicitasse a documentação do processador com todos os opcodes.
Eles deixam disponíveis no site, mas sabe como é... Eles mandam e chega possivelmente em cerca de uma semana.
Para tal você precisa localizar a página de cadastro se ainda houver.

Não sei se a AMD oferece o mesmo serviço.

Estudando linguagem de máquina você começa a tomar noção de certas cosas como shellcodes e como podem ser usados em exploits. Daí para o Metasploit é um pulo. A maioria dos hackeros de Kali de primeira viagem desconhecem estas coisas. Entendeu até onde dá prá ir? :-)

Adicional para leitura:

* https://pt.wikipedia.org/wiki/Assembly
* https://pt.wikipedia.org/wiki/C%C3%B3digo_de_opera%C3%A7%C3%A3o
* https://pt.wikipedia.org/wiki/Bytecode
* https://pt.wikipedia.org/wiki/Bytecode_Java
* http://www.mathemainzel.info/files/x86asmref.html
* http://ref.x86asm.net/


Mnemônicos também são chamados de opcodes.
Linguagem de máquina também é chamada de bytecodes.

----------------------------------------------------------------------------------------------------------------
http://24.media.tumblr.com/tumblr_m62bwpSi291qdlh1io1_250.gif