Ir para o conteúdo
  • Revista PROGRAMAR: Já está disponível a edição #60 da revista programar. Faz já o download aqui!

pessantiago

Ajuda assembly

Mensagens Recomendadas

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?

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros 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

.

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros 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

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros 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 ]);
    }


}

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros 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

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros 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.

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros 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

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros 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


Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros 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

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros 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

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!

Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.

Entrar Agora

×

Aviso Sobre Cookies

Ao usar este site você aceita os nossos Termos de Uso e Política de Privacidade. Este site usa cookies para disponibilizar funcionalidades personalizadas. Para mais informações visite esta página.