Jump to content
  • Revista PROGRAMAR: Já está disponível a edição #60 da revista programar. Faz já o download aqui!

pessantiago

Ajuda assembly

Recommended Posts

pessantiago

.data
vector: .int 5,9,3,7,6,1,8,2,4,10,12,13,18,19,20,16,14,11,17,15
.text


.global main
main:
	movl $0, %ecx
	movl $0, %eax
	movl $20, %ebx
	movl $0, %edx
	ciclo:
		addl vector(,%ecx,4), %eax
		incl %ecx
		cmpl $20, %ecx
	jne ciclo
	call imprime_eax			
	divl %ebx
	call imprime_ecx
	call imprime_edx		
	call imprime_ebx		
ret

Tenho este código que ja faz a media os que agora a ordenação de vectores nao sei como fazer alguem me pode ajudar?

Share this post


Link to post
Share on other sites
Rui Carlos

Podes sempre implementar um algoritmo de ordenação simples em C, e depois converter para assembly.

Pelo menos deve te dar algumas dicas para resolveres o problema.

Share this post


Link to post
Share on other sites
Chillz

boas, como faço para compilar de c para assembly ja andei a procura no nosso amigo google mas nao encontrei nada, que pelomenos funcione.

. immout

.

Share this post


Link to post
Share on other sites
Felix_Poison

compilar de C para ASM? nao entendi!!  me expliquem esse esquema ninja porque eu nao conheço e nunca ouvi falar.

voce está se refirindo a debugar um programa em C e assim cria-lo em ASM? :S eu hein..

bem, para o seu problema, pessantiago, encontrei um otimo artigo sobre isso e outras coisas que te serão uteis:

http://www.osdevbrasil.net/blog/juntando-codigo-c-com-assembly/

espero ter ajudado. se nao, fala ae :D

Share this post


Link to post
Share on other sites
pessantiago

tenho isto podes ajudar -me a passar isto para assembly

#include <stdio.h>



int main(){
     int     i,j,q;
     q=5;
     //quantidade de numeros de entrada
    int num[5];
    int temp;

    //Recebe os valores digitados


    for (i=0;i<q;i++){
        printf("Entre com o numero %d :",i+1);
        scanf("%d",&num[ i ]);
    }

    //Ordena valores valores do vetor num em ordem crescente
    for(j=q;j>0;j--){
        for(i=0;i<j;i++){
            if(num[ i ]>num[i+1]){
                temp = num[ i ];
                num[ i ] = num[i+1];
                num[i+1] = temp;
            }
        }
    }

    //Imprime o vetor ja ordenado
    puts("\n");
    for (i=0;i<q;i++){
        printf(" %d",num[ i ]);
    }


}

Share this post


Link to post
Share on other sites
Rui Carlos

Era só fazer gcc -S do ficheiro com esse código...

Se tivesses uma função separada para fazer a ordenação, era capaz de ser mais simples.

	.cstring
LC0:
.ascii "Entre com o numero %d :\0"
LC1:
.ascii "%d\0"
LC2:
.ascii "\12\0"
LC3:
.ascii " %d\0"
.text
.globl _main
_main:
pushl	%ebp
movl	%esp, %ebp
pushl	%ebx
subl	$68, %esp
call	L17
"L00000000001$pb":
L17:
popl	%ebx
movl	$5, -16(%ebp)
movl	$0, -24(%ebp)
jmp	L2
L3:
movl	-24(%ebp), %eax
incl	%eax
movl	%eax, 4(%esp)
leal	LC0-"L00000000001$pb"(%ebx), %eax
movl	%eax, (%esp)
call	L_printf$stub
movl	-24(%ebp), %eax
sall	$2, %eax
movl	%eax, %edx
leal	-44(%ebp), %eax
addl	%edx, %eax
movl	%eax, 4(%esp)
leal	LC1-"L00000000001$pb"(%ebx), %eax
movl	%eax, (%esp)
call	L_scanf$stub
leal	-24(%ebp), %eax
incl	(%eax)
L2:
movl	-24(%ebp), %eax
cmpl	-16(%ebp), %eax
jl	L3
movl	-16(%ebp), %eax
movl	%eax, -20(%ebp)
jmp	L5
L6:
movl	$0, -24(%ebp)
jmp	L7
L8:
movl	-24(%ebp), %eax
movl	-44(%ebp,%eax,4), %edx
movl	-24(%ebp), %eax
incl	%eax
movl	-44(%ebp,%eax,4), %eax
cmpl	%eax, %edx
jle	L9
movl	-24(%ebp), %eax
movl	-44(%ebp,%eax,4), %eax
movl	%eax, -12(%ebp)
movl	-24(%ebp), %edx
movl	-24(%ebp), %eax
incl	%eax
movl	-44(%ebp,%eax,4), %eax
movl	%eax, -44(%ebp,%edx,4)
movl	-24(%ebp), %edx
incl	%edx
movl	-12(%ebp), %eax
movl	%eax, -44(%ebp,%edx,4)
L9:
leal	-24(%ebp), %eax
incl	(%eax)
L7:
movl	-24(%ebp), %eax
cmpl	-20(%ebp), %eax
jl	L8
leal	-20(%ebp), %eax
decl	(%eax)
L5:
cmpl	$0, -20(%ebp)
jg	L6
leal	LC2-"L00000000001$pb"(%ebx), %eax
movl	%eax, (%esp)
call	L_puts$stub
movl	$0, -24(%ebp)
jmp	L13
L14:
movl	-24(%ebp), %eax
movl	-44(%ebp,%eax,4), %eax
movl	%eax, 4(%esp)
leal	LC3-"L00000000001$pb"(%ebx), %eax
movl	%eax, (%esp)
call	L_printf$stub
leal	-24(%ebp), %eax
incl	(%eax)
L13:
movl	-24(%ebp), %eax
cmpl	-16(%ebp), %eax
jl	L14
addl	$68, %esp
popl	%ebx
leave
ret
.section __IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5
L_scanf$stub:
.indirect_symbol _scanf
hlt ; hlt ; hlt ; hlt ; hlt
L_printf$stub:
.indirect_symbol _printf
hlt ; hlt ; hlt ; hlt ; hlt
L_puts$stub:
.indirect_symbol _puts
hlt ; hlt ; hlt ; hlt ; hlt
.subsections_via_symbols

Share this post


Link to post
Share on other sites
Lophes

Boas, desculpem vir para aqui entrometer-me mas será que me podem converter este programa para assembly? Se fosse possivel era bom que fosse compativel com o intel 8051.

#include <stdio.h>

main()

{

      int p=0,i,n;

      printf("Introduza um Numero: ");

      scanf("%d",&n);

      i=1;

      while (i<=n)

      {

            if ((n%i)==0)

              p=p+1;

              i=i+1;

              }

           

              if (p==2)

              printf("O numero e primo.");

           

              else

              printf("O numero nao e primo.\n");

              system ("pause");

      }

Cumprimentos, e muito obrigado pela ajuda.

Share this post


Link to post
Share on other sites
vasco16

Boas, desculpem vir para aqui entrometer-me mas será que me podem converter este programa para assembly? Se fosse possivel era bom que fosse compativel com o intel 8051.

#include <stdio.h>

main()

{

      int p=0,i,n;

      printf("Introduza um Numero: ");

      scanf("%d",&n);

      i=1;

      while (i<=n)

      {

            if ((n%i)==0)

              p=p+1;

              i=i+1;

              }

           

              if (p==2)

              printf("O numero e primo.");

           

              else

              printf("O numero nao e primo.\n");

              system ("pause");

      }

Cumprimentos, e muito obrigado pela ajuda.

Pelo que percebi tens de compilar esse código com o seguinte código:

gcc -S nomedoficheiro.extensao nomedoprograma

Share this post


Link to post
Share on other sites
Chillz

Boa tarde,

Eu andei a testar aqui o código gentilmente fornecido pelo Rui mas acho que o modifiquei mal.

Acho que os comentários estão mais ou menos. Se me puderem ajudar a configurar isso melhoriznho . agracedia. O codigo apresentado tem a mesma função que os anteriores.  Por favor dêm uma maozinha ao pobre 😳.

.data

VECT: .int 3,35,45,30,6,8,10,9,16,14,32,41,27,14,5,2,17,23,19,14  #declara o vector e atribui-lhe valores

VAR: .int 0 							  #cria uma variavel com o valor inicial 0


.text
.globl main

#funcao da media
MED:
movl $0, %eax                    	#coloca 0 para eac

movl $0, %ecx				#coloca 0 para o contador

A1: 	addl VECT(,%ecx,4), %eax	#adiciona no vector posicao 1 o valor escrito em eax (0)
    	incl %ecx			#incrementa o contador em 1
    	cmpl $19, %ecx			# compara com o vector a posição 19
    	JBE A1				#se o valor for menor que a comparação feita em cimaa do array posicao 19
					#volta a repetir o ciclo


movl $0, %edx                           #move o valor para edx
movl $20, %ebx				#coloca o valor de 20 no ebx
divl %ebx				#divide o que esta no valor ebx por 20
Ret

#funcao da mediana
MEDIANA: 
movl $20, %ebx				# move o valor 20 para ebx	
movl $0, %edx				# move o valor 0 para edx	
movl $2, %ecx				# move o valor 2 para ecx
movl %ebx, %eax				#move o valor dfe ebx para eax
divl %ecx				#divide o que esta no valor eax com ecx
cmpl $0, %edx				#compara se a posicao 0 tem o valor de edx
JE R1					# chama a funçao r1 se o valor anterior for igual		
addl $1, %eax				#
movl VECT(,%eax,4), %eax		#
Ret

R1:	movl $0, %ecx			# move o valor 0 para ecx
	movl VECT+40, %ecx		#
	addl VECT+44, %ecx		#
	movl %ecx, %eax			# move o valor de ecx para eax
	movl $0, %edx			# move o valor 0 para edx
	movl $2, %ecx			# move o valor 2 para ecx
	divl %ecx			# divide o valor anterior

Ret

#funcao de ordenar
ORD:

A2:     movl $0, %ecx			# coloca o valor 0 em ecx
	movl $0, VAR            	# atribui a var o valor 0

A3: 	movl VECT(,%ecx,4), %eax	# coloca o conteudo de ecx para o vector
   	movl VECT+4(,%ecx,4), %ebx	# 

    

    	cmpl %eax, %ebx			# compara eax ebx
    	JAE A4				# chama funcao a4 se for maior ou igual 
	xchg %eax, %ebx			# muda eax com ebx
	movl %eax, VECT+4(,%ecx,4) 	# move eax para o vector com a posiçao +4
	movl %ebx, VECT(,%ecx,4) 	
	movl $1, VAR			# move o valor 1 para a variavel var
	jmp A4				# salta apra a4 



A4: 	incl %ecx			# incrementa o valor em ecx
	cmpl $18, %ecx			# compara a posicao 18 a ecx
	JB A3				# chama a funçao A3 se o valor anterior for menor
	cmpl $1, VAR			# compara a posicao 1 a VAR
	JE A2				# Chama a funçao A2 se o valor anterior for igual


Ret




main:
call MED				#chama a funcao media
call ORD				#chama a funcao de ordenar
movl $0, %ecx				#move 0 para ecx
R2:	movl VECT(,%ecx,4), %eax	#move eax para o vector
	incl %ecx			#incrementa o ecx	
	cmp $19, %ecx			#compara a posiçao 19 com o ecx
	JBE R2 				#chama a funçao r2 se for menor ou igual
call MEDIANA				#chama mediana


Share this post


Link to post
Share on other sites
costricardo
.data # LOCAL ONDE SE DECLARAM VARIÁVEIS       

vector:	.long 17,2,3,4,5,8,7,6,9,14,18,12,10,11,15,16,1,13,19,20  # Declaração do vectore inicializados
med: .long 0  # Declara a variável média #
medi: .long 0 #Declara a variável mediana# 
tam: .long 20 #   
control: .int 0

.section .rodata # Local onde se declaram as strings

strmedia: .string "\nA Media é igual: "     #String media                           
strmediana: .string "\nA Mediana é igual: " #String mediana
strtrabalho: .string "\nTrabalho realizado por:\n" #String Trabalho
strnomes: .string "Gabriel Santos (mec:42186), Ricardo Emanuel(mec:51424), Ricardo Costa(mec:43780)\n\n" #String nomes
strdis: .string "Elementos de Arquitectura de computadores - 2009/2010 - ESTGA\n" #String dis
strordena: .string "\nOrdenação de vectores:\n" #String ordena
strbuble: .string "\nOrdenação de vectores em linguagem assembly IE32 para o processador 8086:\n" #String buble



.text           
.globl main # PARTE ONDE "COMEÇA" O PROGRAMA


##########################FUNÇÃO ORDENA #######################################################################
                          
ordena: 							

# Utilização da stack para manipulação de strings

pushl %ebp 
pushl $strbuble
call printf
addl $4, %esp
pop %ebp


pushl %ebp  
pushl $strordena # Instrução push carrega a stack com o valor da string
call printf      # Imprime a string
addl $4, %esp
pop %ebp         # Retira tudo o que está no registo %ebp ( base pointer )

###Rótulo r2###

r2:
movl $0, control # Instrução mov coloca o valor do operando 1 no operando 2
movl $0, %edx   
movl $1, %ecx  


########## Rótulo Ciclo ##########

ciclo:             


movl vector(,%edx,4), %eax # Passagem de valor vector[i] para o registo %eax   
movl vector(,%ecx,4), %ebx # Passagem de valor vector[i+1] para o registo %ebx 

                     
cmpl %ebx,%eax # Compara valor de registo %ebx com %eax   
JA troca       # Se a condição( %eax>%ebx )for verdadeira salta para o rótulo troca, caso não seja salta para (r1) 
jmp r1 

####### Rótulo Troca ############
troca:

xchgl %eax, %ebx # Intrução xchg efectua troca do valor dos registos
movl %eax, vector(,%edx,4)  
movl %ebx, vector(,%ecx,4)
movl $1, control

###### Rótulo r1 #############
r1:

incl %ecx       # Intrução inc incrementa valor do registo %ecx
incl %edx
movl tam,%eax   # Instrução que garante que o último elemento do vector seja comparado com o penúltimo  
subl $2, %eax   # Posição inicial do vector = 0 e final = 19, quando %edx = 18, %ecx = 19 
cmpl %eax,%edx  # Se ( %edx <= 18 continua o ciclo, caso contrário salta fora ( pois não há mais nada a comparar )   
JBE ciclo       # Se a condição for verdadeira ( %edx<= %eax ) 
cmpl $1, control 
JE  r2          #  Se a condição for verdadeira ( $1 = control ), salta para o rótulo (r2)

ret 
############################################# FUNÇÃO MÉDIA ##################################################


media:

movl tam, %ecx         
movl $0, %edx      
movl $0, %eax    

###### Rótulo Soma ######

soma:           

movl vector(,%edx,4), %ebx    
incl %edx                    
addl %ebx, %eax   # Intrução add adiciona operando 1 com o operando 2           

decl %ecx         # Intrução dec decrementa o registo %ecx                
cmpl $0,%ecx                  
JNE soma          # Se a condição for verdadeira ( $0 != %ecx ), salta para o rótulo (soma)

movl $0,%edx                 
movl tam,%ecx                
divl %ecx         # Instrução div, divide o que está em EDX:EAX pelo valor do registo %ecx            
movl %eax,med               

ret 
######################################### Função Mediana ###################################################


mediana:


movl tam,%eax   
cltd             # Intrução cltd que  converte um registo de dimensão .long num registo EDX:EAX
        xorl %edx,%edx   # Instrução que coloca o registo %edx a 0
movl $2,%ecx    

divl %ecx

        cmpl $0,%edx #

jne impar
jmp par          # Salto 
        
######## Rótulo Par #############

        par:

movl vector(,%eax,4), %ebx
decl %eax
movl vector(,%eax,4), %ecx
addl %ecx,%ebx
movl %ebx,%eax
movl $2,%ecx    

divl %ecx
movl %eax,medi 

ret
        
###### Rótulo Impar #############
        impar: 

movl vector(,%eax,4), %ebx
	movl %ebx,medi


ret

################################### Função Imprime ############################################
imprime:

movl $0, %ecx 

####### Rótulo Imprimevector ###########

imprimevector:


movl vector(, %ecx,4), %eax  

incl %ecx        
call imprime_eax
cmpl tam, %ecx   
JNE imprimevector



####### Printf da string ( strmedia )#####

pushl %ebp
pushl $strmedia
call printf
addl $4, %esp
pop %ebp
movl med, %ebx 
call imprime_ebx

####### Printf da string ( strmediana )###

pushl %ebp
pushl $strmediana
call printf
addl $4, %esp
pop %ebp
movl medi, %ecx 
call imprime_ecx 

###### Printf da string ( strtabalho )###

pushl %ebp
pushl $strtrabalho
call printf
addl $4, %esp
pop %ebp

###### Printf da string ( strnomes )###

pushl %ebp
pushl $strnomes
call printf
addl $4, %esp
pop %ebp

###### Printf da string ( strdis )####

pushl %ebp
pushl $strdis
call printf
addl $4, %esp
pop %ebp

ret 

################################### Função Principal do Programa ####################################################

main:

call ordena  #Chama a função ordena 
call media   #Chama a função media 
call mediana #Chama a função mediana    
call imprime #Chama a função Imprime  


ret # Fim da função principal do programa



I´m a Geek and you?www.tecnologias.in

Share this post


Link to post
Share on other sites
costricardo

Está ai uma ordenação de vectores e sua media e mediana. Espero ter ajudado  :cheesygrin:


I´m a Geek and you?www.tecnologias.in

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.