Pesquisar na Comunidade

Olá, tenho de resolver dois exercícios de assembly, mas não percebo nada. Ainda só tive uma aula e foi teórica. Se alguém me pudesse ajudar: escreva um programa em ASM P3 (ou altere o programa anterior) que tenha numa variável em memória o lado de um quadrado e calcule o respetivo perímetro e área, colocando o resultado em R1 e R2, respetivamente. escreva um programa em ASM P3 que calcule: x = 20 – m + (n + 40). Onde x, m e n são registos do processador P3 (por exemplo, R1, R2, e R3).

Bom dia, estou a fazer um projeto para a cadeira de arquitetura de computadores, que consiste em guardar uma letra especifica que apareça na string e caso ela não apareça devolver null. Não tenho ideia de como faço para que o programa saiba que é aquela letra que tem que guardar. Alguém me pode ajudar sff. Obrigada

Atualmente qual é o valor do maior salário de programador Assembly em Portugal e no mundo? Qual é o local que paga o valor do maior salário de programador Assembly em Portugal e no mundo? Qual é a porcentagem atual da demanda de Assembly no mundo?

Qual é a quantidade provável de programadores que atualmente programam em linguagem de máquina? Qual é a provável porcentagem dos programadores que programam atualmente em linguagem de máquina? Qual é a quantidade provável de programadores que atualmente programam em linguagem de Assembly? Qual é a provável porcentagem dos programadores que programam atualmente em Assembly?

gostaria se alguem pode me dar uma ajuda de como criar o jogo da velha em assembly no mips .data cabecalho: .asciiz "Jogo da Velha " espaco: .asciiz " " bl: .asciiz "n" um: .asciiz "1" dois: .asciiz "2" tres: .asciiz "3" barra: .asciiz "|" jog1: .asciiz "JOGADOR 1:n" jog2: .asciiz "JOGADOR 2:n" posicao: .asciiz "Digite linha e coluna (xy): " erro: .asciiz "Posicao Invalida.n" victory1: .asciiz "Parabens JOGADOR 1, voce ganhou." victory2: .asciiz "Parabens JOGADOR 2, voce ganhou." empat: .asciiz "Empatou, chora." .text .globl main main: addi $t0 $zero 45 #Inicializa os registradores em ‘-’ addi $t1 $zero 45 addi $t2 $zero 45 addi $t3 $zero 45 addi $t4 $zero 45 addi $t5 $zero 45 addi $t6 $zero 45 addi $t7 $zero 45 addi $t8 $zero 45 la $a0 cabecalho #Imprime o cabeçalho li $v0 4 syscall #comeca a diversao j print1 j fim print1: #Imprime a grade do jogo. la $a0 bl #linha branco li $v0 4 syscall la $a0 espaco syscall la $a0 espaco syscall la $a0 espaco syscall la $a0 um syscall la $a0 espaco syscall la $a0 dois syscall la $a0 espaco syscall la $a0 tres syscall la $a0 bl #linha branco syscall la $a0 espaco #comeco primeira linha syscall la $a0 um syscall la $a0 barra syscall move $a0 $t0 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t1 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t2 li $v0 11 syscall la $a0 barra li $v0 4 syscall la $a0 bl #fim primeira linha li $v0 4 syscall la $a0 espaco #comeco segunda linha syscall la $a0 dois syscall la $a0 barra syscall move $a0 $t3 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t4 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t5 li $v0 11 syscall la $a0 barra li $v0 4 syscall la $a0 bl #fim segunda linha li $v0 4 syscall la $a0 espaco #comeco terceira linha syscall la $a0 tres syscall la $a0 barra syscall move $a0 $t6 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t7 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t8 li $v0 11 syscall la $a0 barra li $v0 4 syscall la $a0 bl #fim terceira linha li $v0 4 syscall j testejog2 #Chama teste para jogador 2 print2: la $a0 bl #linha branco li $v0 4 syscall la $a0 espaco syscall la $a0 espaco syscall la $a0 espaco syscall la $a0 um syscall la $a0 espaco syscall la $a0 dois syscall la $a0 espaco syscall la $a0 tres syscall la $a0 bl #linha branco syscall la $a0 espaco #comeco primeira linha syscall la $a0 um syscall la $a0 barra syscall move $a0 $t0 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t1 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t2 li $v0 11 syscall la $a0 barra li $v0 4 syscall la $a0 bl #fim primeira linha li $v0 4 syscall la $a0 espaco #comeco segunda linha syscall la $a0 dois syscall la $a0 barra syscall move $a0 $t3 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t4 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t5 li $v0 11 syscall la $a0 barra li $v0 4 syscall la $a0 bl #fim segunda linha li $v0 4 syscall la $a0 espaco #comeco terceira linha syscall la $a0 tres syscall la $a0 barra syscall move $a0 $t6 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t7 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t8 li $v0 11 syscall la $a0 barra li $v0 4 syscall la $a0 bl #fim terceira linha li $v0 4 syscall j testejog1 #Chama teste para jogador 1 jogador1: la $a0 jog1 #Imprime chamada para jogador 1 li $v0 4 syscall la $a0 posicao #Le a posição syscall li $v0 5 syscall move $16 $v0 beq $16 11 umum beq $16 12 umdois #switch para por X na posicao digitada beq $16 13 umtres beq $16 21 doisum beq $16 22 doisdois beq $16 23 doistres beq $16 31 tresum beq $16 32 tresdois beq $16 33 trestres la $a0 erro #Teste para posição invalida li $v0 4 syscall j jogador1 umum: bgt $t0 45 jogador1 #se ja estiver valor nesta posicao chama de novo addi $t0 $zero 88 #senao poe valor na posicao j print2 #…os demais casos são testados da mesma maneira… umdois: bgt $t1 45 jogador1 addi $t1 $zero 88 j print2 umtres: bgt $t2 45 jogador1 addi $t2 $zero 88 j print2 doisum: bgt $t3 45 jogador1 addi $t3 $zero 88 j print2 doisdois: bgt $t4 45 jogador1 addi $t4 $zero 88 j print2 doistres: bgt $t5 45 jogador1 addi $t5 $zero 88 j print2 tresum: bgt $t6 45 jogador1 addi $t6 $zero 88 j print2 tresdois: bgt $t7 45 jogador1 addi $t7 $zero 88 j print2 trestres: bgt $t8 45 jogador1 addi $t8 $zero 88 j print2 jogador2: la $a0 jog2 #Chamada para jogador 2 li $v0 4 syscall la $a0 posicao #Lê a posição syscall li $v0 5 syscall move $16 $v0 beq $16 11 umum2 beq $16 12 umdois2 beq $16 13 umtres2 beq $16 21 doisum2 #switch para por O na posicao digitada beq $16 22 doisdois2 beq $16 23 doistres2 beq $16 31 tresum2 beq $16 32 tresdois2 beq $16 33 trestres2 la $a0 erro #Teste de posição inválida li $v0 4 syscall j jogador2 umum2: bgt $t0 45 jogador2 #se ja estiver valor nesta posicao chama de novo addi $t0 $zero 79 #senao poe valor na posicao j print1 #…os demais casos de teste são iguais… umdois2: bgt $t1 45 jogador2 addi $t1 $zero 79 j print1 umtres2: bgt $t2 45 jogador2 addi $t2 $zero 79 j print1 doisum2: bgt $t3 45 jogador2 addi $t3 $zero 79 j print1 doisdois2: bgt $t4 45 jogador2 addi $t4 $zero 79 j print1 doistres2: bgt $t5 45 jogador2 addi $t5 $zero 79 j print1 tresum2: bgt $t6 45 jogador2 addi $t6 $zero 79 j print1 tresdois2: bgt $t7 45 jogador2 addi $t7 $zero 79 j print1 trestres2: bgt $t8 45 jogador2 addi $t8 $zero 79 j print1 fim: jr $ra testejog2: #Testa se jogador 2 ganhou add $a0 $t0 $t1 #Testa se o jogo termina empatado add $a0 $a0 $t2 add $a0 $a0 $t3 add $a0 $a0 $t4 add $a0 $a0 $t5 add $a0 $a0 $t6 add $a0 $a0 $t7 add $a0 $a0 $t8 beq $a0 756 empate add $a0 $t0 $t1 add $a0 $a0 $t2 #linha 1 beq $a0 237 jog2ganhou add $a0 $t3 $t4 add $a0 $a0 $t5 #linha 2 beq $a0 237 jog2ganhou add $a0 $t6 $t7 add $a0 $a0 $t8 #linha 3 beq $a0 237 jog2ganhou add $a0 $t0 $t3 add $a0 $a0 $t6 #coluna 1 beq $a0 237 jog2ganhou add $a0 $t1 $t4 add $a0 $a0 $t7 #coluna 2 beq $a0 237 jog2ganhou add $a0 $t2 $t5 add $a0 $a0 $t8 #coluna 3 beq $a0 237 jog2ganhou add $a0 $t0 $t4 add $a0 $a0 $t8 #diagonal 1 beq $a0 237 jog2ganhou add $a0 $t2 $t4 add $a0 $a0 $t6 #diagonal 2 beq $a0 237 jog2ganhou j jogador1 #Chama jogador 1 jog2ganhou: #Imprime que jogador dois ganhou e sai la $a0 victory2 li $v0 4 syscall j fim testejog1: #Testa se jogador 1 ganhou add $a0 $t0 $t1 #Testa se o jogo terminou empatado add $a0 $a0 $t2 add $a0 $a0 $t3 add $a0 $a0 $t4 add $a0 $a0 $t5 add $a0 $a0 $t6 add $a0 $a0 $t7 add $a0 $a0 $t8 beq $a0 756 empate add $a0 $t0 $t1 add $a0 $a0 $t2 #linha 1 beq $a0 264 jog1ganhou add $a0 $t3 $t4 add $a0 $a0 $t5 #linha 2 beq $a0 264 jog1ganhou add $a0 $t6 $t7 add $a0 $a0 $t8 #linha 3 beq $a0 264 jog1ganhou add $a0 $t0 $t3 add $a0 $a0 $t6 #coluna 1 beq $a0 264 jog1ganhou add $a0 $t1 $t4 add $a0 $a0 $t7 #coluna 2 beq $a0 264 jog1ganhou add $a0 $t2 $t5 add $a0 $a0 $t8 #coluna 3 beq $a0 264 jog1ganhou add $a0 $t0 $t4 add $a0 $a0 $t8 #diagonal 1 beq $a0 264 jog1ganhou add $a0 $t2 $t4 add $a0 $a0 $t6 #diagonal 2 beq $a0 264 jog1ganhou j jogador2 #Chama jogador 2 jog1ganhou: #Imprime que jogador 1 ganhou e sai la $a0 victory1 li $v0 4 syscall j fim empate: #Imprime EMPATE e sai la $a0 empat li $v0 4 syscall j fim

Boa noite a todos. Nao sei se esse é o sitio certo. Sera que algum colega tem o disquete que acompanha o livro -- assembly puro e simples de vasco correia veloso. Qual o conteudo desse disco ?? Eu tenho o livro, mais o software em disquete foi pro saco. Gostava de praticar assembly e seguir as instruções do livro e disco. Se algum colega puder me dar essa ajuda. Agradecia. Julio praiaclube@msn.com

resolvido

Boas tardes, estou a ter algumas dúvidas para converter meu código C para Assembly. Aqui esta o meu código C #include<stdio.h> int pares(int numeros[], int x) { int y=0; int i; for(i = 0; i < x; i++) if(numeros[i]%2 == 0) y++; return y; } int main(){ int numeros[30]; int i, z, w; for(i = 0; i < 30; i++) numeros[i] = i + 1; printf("Insira X: "); scanf("%d", &z); w = pares(numeros, z); printf("pares: %d\n", w); } Ja tentei varias horas a tentar converter o programa e por enquanto tenho isto: Input Store array load tr subt array skipcond 800 halt LoopXpositive, Load array Subt Y Skipcond 800 / ac>0 Jump Finish Store array ElseIf, Load Z Add One Store Z Jump LoopXpositive Finish, load Z output Halt dec 1 / a[1] dec 4 / a[2] dec 7 / a[3] dec 10 / a[4] dec 13 / a[5] dec 16 / a[6] dec 19 / a[7] dec 22 / a[8] dec 25 / a[9] dec 28 / a[10] dec 31 / a[11] dec 34 / a[12] dec 37 / a[13] dec 40 / a[14] dec 43 / a[15] dec 46 / a[16] dec 49 / a[17] dec 52 / a[18] dec 55 / a[19] dec 58 / a[20] dec 61 / a[21] dec 64 / a[22] dec 67 / a[23] dec 70 / a[24] dec 73 / a[25] dec 76 / a[26] dec 79 / a[27] dec 82 / a[28] dec 85 / a[29] dec 88 / a[30] tr, dec 31 array, dec 0 X, Dec 0 Y, Dec 2 Z, Dec 0 One, Dec 1 Zero, Dec 0 i, dec 1 Preciso de ajuda. Obrigado =)

Bom dia, foi-me proposto um trabalho em assembly, o qual tem que percorrer um texto e no fim apresentar o número total de caracteres que compõem esse texto; número de letras minúsculas (sem acentos, ASCII puro); e por fim, número total de caracteres ASCII não representáveis. Agradeço desde já quem puder ajudar.

Boa tarde, quero guardar carateres do ecrã num ficheiro. O tamanho é 20 linhas e 40 colunas. Desenvolvi código, mas ele só está a guardar 14 linhas. Alguém me consegue ajudar? Mov bx,0 mov si,0 mov ax,0 mov di,si mov cx, 80 lab_ciclo: mov al, es:[bx] mov buffer[si], al inc si add bx,2 loop lab_ciclo add di,82 mov si,di mov cx,82 cmp si, 2050 jne lab_ciclo

Olá pessoal eu estou a tentar fazer um jogo do labirinto em codigo assembly no dosbox (é um trabalho da minha faculdade) e o professor disponibilizou-nos codigos para nos ajudar mas estou a ver-me á rasca para por exemplo guardar o labirinto que fiz, fazer a interface (NOVO JOGO, FAZER UM LABIRINTO, SAIR), por o avatar no labirinto... alguem me pode ajudar qualquer ajuda é otima

Boa Tarde...... Como faço um programa em Mips que faz o seguinte........ Adicionar as seguintes letras no Alfabeto após cada uma das vogais (exemplo: após cada a, adicionar um b)

Boas pessoal. Sou completamente novo nesta linguagem, ando a aprender na fac, mas não me ando a dar muito bem com ela. Preciso de criar um programa de codificação de mensagens, onde o utilizar mete a mensagem, e sempre que aparecer uma vogal, adiciona a consoante próxima à vogal. Por exemplo: A > B E > F I > J O > P U > V Então, se a minha mensagem fosse: "Hello World", depois da encriptação seria: "Hefllop Woprld". Já tenho o código do input da mensagem aqui: .data #let processor know we will be submitting data to program now insert: .word 4 #make a 4 byte (32 bit) space in memory for a word with address insert_into input: .asciiz "\Please Enter a String to Print\n" #in unused memory store this string with address Ask_Input output: .asciiz "\You typed in: " #in unused memory store this string with address Tell_Output .text #enables text input / output, kind of like String.h in C++ main: #main function is always called in any mips program, so the program will start here with actual assembly code la $a0, input #load address input from memory and store it into arguement register 0 li $v0, 4 #loads the value 4 into register $v0 which is the op code for print string syscall #reads register $v0 for op code, sees 4 and prints the string located in $a0 la $a0, insert #sets $a0 to point to the space allocated for writing a word la $a1, insert #gets the length of the space in $a1 so we can't go over the memory limit li $v0, 8 #load op code for getting a string from the user into register $v0 syscall #reads register $v0 for op code, sees 8 and asks user to input a string, places string in reference to $a0 la $a0, output #load address output from memory and store it into arguement register 0 li $v0, 4 #loads the value 4 into register $v0 which is the op code for print string syscall #reads register $v0 for op code, sees 4 and prints the string located in $a0 la $a0, insert #load address insert_into from memory and store it into arguement register 0 li $v0, 4 #loads the value 4 into register $v0 which is the op code for print string syscall #reads register $v0 for op code, sees 4 and prints the string located in $a0 li $v0, 10 #loads op code into $v0 to exit program syscall #reads $v0 and exits program Porém, já não sei como/o que fazer a partir daqui.

Boa tarde, Eu estou com dificuldades em criar um trabalho em assembly na arquitetura mips que codifique um texto. O programa tem de ''andar'' 5 vezes para a frente em cada letra do texto escrito. Exemplo: Ontem fui a Lisboa ter com a minha mae e aproveitei para comprar um gelado ->Tsyjr kzn f Qnxgtf yjw htr f rnsmf rfj j fuwtajnyjn ufwf htruwfw zr ljqfit Será que alguém consegue dar uma ajuda? Peço desculpa pelo incomodo e obrigado desde ja pela disponibilidade. Cumprimentos

Olá, gente!!! É o seguinte, tenho um programa de Assembly para entregar, eu utilizo este assembler www.cs.missouristate.edu/MARS e, apesar de saber algumas coisas, este já é um bocado demais. Contudo, consegui perceber o problema, o que torna tudo muito mais fácil. É o seguinte: "Num prédio, com 50 moradores, há três elevadores denominados A, B e C. Para otimizar o sistema de controlo dos elevadores foi realizado um levantamento no qual cada utilizador responde: • O elevador que utiliza com mais frequência; • O período que utiliza o elevador, entre: o “M” = matutino; o “V” = vespertino; o “N” = noturno. Construa um programa em assembly do MIPS que calcule e imprima: • Qual é o elevador mais frequentado e em que período se concentra o maior fluxo; • Qual o período mais usado de todos, e a que elevador pertence; • Qual a diferença percentual entre o mais usado dos horários e o menos usado; • Qual a percentagem sobre o total de serviços prestados do elevador de media utilização. Teste o seu funcionamento no MARS. Para o armazenamento das variáveis do programa utilize registos $tn." Ou seja, tenho que ler e validar as variáveis, contadores para o período em que o elevador é utilizado e para qual o elevador mais frequentado. Depois, tenho que fazer um ciclo (porque são 50 pessoas a responder) e dentro desse ciclo tenho que fazer subciclos com as opções todas, depois a parte dos cálculos e a impressão desses cálculos (também vou ter de pôr strings). Agora o meu problema é fazer em Assembly kkkk. Pensei em fazer com vetores (ia precisar de menos linhas), mas também não percebo muito bem....Sugestões aceitam-se!!!! Obrigada!!!!

Boas malta, Alguém me pode dizer como faço um delay em assembly no PIC16F627? A idea é no pressionar um botão executar o código, e ao fim de x segundos voltar tudo ao inicio thanks!! Cumpz!

Ola, Estou a realizar um projecto em que recebe dois numeros passado pelo cliente e realiza diversas operações no entanto no factorial e na Potencia os resultados não estão correctos. Na Potencia o primeiro numero é a base e o segundo expoente no factorial apenas é feito o factorial do primeiro numero. Podem ajudar-me ? Obrigado desde já pela possibilidade. ;Factorial FAT: cmp al,'F' jne potencia lodsb cmp al,'A' jne ERROR ;Factorial do 1 numero mov bx, [num1] call proc_fact add ax, 30h mov [result], ax jmp fim_operacao proc_fact: cmp bl, 1 jg do_calculation mov ax, 1 ret do_calculation: dec bl call proc_fact inc bl mul bl ;ax = al * bl jo fim_operacao ret ;Potencia potencia: cmp al,'P' jne funcao_S lodsb cmp al, 'O' jne ERROR call proc_fact mov eax, [num1] mov ebx, [num2] add edx, eax call potenc potenc: mul jo fim_operacao sub ebx,1 cmp ebx,0 jnz potenc mov [result], al jmp fim_operacao

Bem, tenho um projecto pra terminar e no entanto enquanto o fazia deparei-me com certas situações limitantes no qual impediram a perfeição total do trabalho. O objectivo é criar uma calculadora que faça operações aritméticas (+, -, *, /), lógicas (XOR, AND, OR) e também SL, SR, RL e RR. Consegui fazer a calculadora com as operações aritmeticas e mais o SL e SR. Falta XOR, AND, OR; RL, RL. Para facilitar a vossa compreensão, vou enumerar as dúvidas: 1- Adicionar as operações XOR, AND, OR; RL, RL. 2- Fazer com que o programa detecte e indique no ecrã as situações de overflow. 3- O programa produz resultado em Hexa, como faço para po-lo em inteiro? Se alguém pudesse ajudar agradecia imenso. Caso prefiram, aqui têm o programa feito até agora: section .data MAX_PALAVRA equ 40 s1 db 0xa,"Introduza num: " ts1 equ $ - s1 s3 db 0xa,"Resultado: " ts3 equ $ - s3 s4 db 0xa,"Introduza o operador (+,-,*,/,&,SL,SR): " ts4 equ $ - s4 s5 db 0xa,"Operador inválido",0xA ts5 equ $ - s5 linha db 0xa,0xa tlinha equ $ - linha num1 dd 0 num2 dd 0 result dd 0 tamstr dd 0 section .bss strnum resb MAX_PALAVRA section .text global _start _start: ; Pede num1 call pedeNumero mov [num1], ebx ; Pede num2 call pedeNumero mov [num2], ebx ; Pede operador mov edx,ts4 mov ecx,s4 mov ebx,1 mov eax,4 int 0x80 mov edx,MAX_PALAVRA mov ecx,strnum mov ebx,0 mov eax,3 int 0x80 mov esi, strnum cld lodsb cmp al, '+' jne subtrai call fsoma jmp escreve subtrai: cmp al, '-' jne multiplica call fsubtrai jmp escreve multiplica: cmp al, '*' jne divide call fmultiplica jmp escreve divide: cmp al, '/' jne op_and call fdivide jmp escreve op_and: cmp al, '&' jne op_SL call fop_and jmp escreve op_SL: cmp al, 'S' jne erro_operador lodsb ; Carrega 2º byte do operador no al cmp al, 'L' jne op_SR call fop_SL jmp escreve op_SR: cmp al, 'R' jne erro_operador ;call fop_SR jmp escreve erro_operador: ; Mensagem operador inválido mov edx,ts5 mov ecx,s5 mov ebx,1 mov eax,4 int 0x80 jmp acabou escreve: ; Transforma resultado em string mov ecx, 8 mov edi, strnum mov ebx, [result] cld xor eax, eax cicloresult: rol ebx, 4 mov eax, ebx and eax, 0x0000000F cmp eax, 10 jl algarismo add al, 'A'-10 jmp fim3 algarismo: add al, '0' fim3: stosb loop cicloresult ; Imprime resultado mov edx,ts3 mov ecx,s3 mov ebx,1 mov eax,4 int 0x80 mov edx,8 mov ecx,strnum mov ebx,1 mov eax,4 int 0x80 mov edx,tlinha mov ecx,linha mov ebx,1 mov eax,4 int 0x80 acabou: ; Sair do programa passando o controlo ao sistema operativo mov ebx,0 mov eax,1 int 0x80 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;Funções fsoma: mov ebx, [num1] add ebx, [num2] mov [result], ebx ret fsubtrai: mov ebx, [num1] sub ebx, [num2] mov [result], ebx ret fmultiplica: mov eax, [num1] mov ebx, [num2] mul ebx mov [result], eax ret fdivide: xor edx, edx mov eax, [num1] mov ebx, [num2] div ebx mov [result], eax ret fop_and: mov ebx, [num1] and ebx, [num2] mov [result], ebx ret ; É necessário melhorar, pois o 'num2' pode ser maior que 'cl' fop_SL: mov ebx, [num1] mov ecx, [num2] shl ebx, cl mov [result], ebx ret pedeNumero: mov edx,ts1 mov ecx,s1 mov ebx,1 mov eax,4 int 0x80 mov edx,MAX_PALAVRA mov ecx,strnum mov ebx,0 mov eax,3 int 0x80 sub eax, 1 mov [tamstr],eax xor eax, eax xor ebx, ebx mov esi, strnum cld mov ecx, [tamstr] ciclonum1: lodsb cmp al, '9' jg letra1 and al, 0xF jmp fim1 letra1: and al, 0xF add al, 9 fim1: shl ebx,4 add ebx, eax loop ciclonum1 ret

Boas , estou a tentar fazer um programa em assembly onde é pedido para fazer uma rotina que tendo como parâmetro de entrada oendereço de uma stringC, devolva o somatório BCD (dois dígitos por byte) dos elementosque constituem a string, também assumidos como BCD. Comecei por fazer o seguinte: .data message1 : .asciiz "Introduza a string pretendida: \n" message2 : .asciiz "O somatorio da sua string é" userinput : .space 100 .text main: li $v0,4 la $a0, message1 syscall #Getting user's input as text li $v0,8 la $a0,userinput li $a1,100 syscall #Display string li $v0,4 la $a0,userinput syscall # jal somatorioelementos #Tell the system this is the end of main li $v0,10 syscall somatorioelementos: #Display somatorio li $v0,4 la $a0,message2 syscall #Tell the system this is the end of main li $v0,10 syscall Alguem me pode ajudar ? Estou no caminho certo ? Nao faço a minima como é que vou fazer a parte do somatorio .

Estou numa fase inicial em assembly, e não percebo muito ainda. Tenho o seguinte exercício mas estou a conseguir resolver, alguém pode dar uma ajuda? Exercício: Elaborar uma rotina em assembly para escrever os valores sequenciais de 0 a 255 num array se bytes com 10.000 elementos. Aguardo resposta. Cumps;

Viva, não percebo nada de assembly mas preciso de passar este codigo super simples para assembly. Alguém de ideias? (Sim, aprender asembly era o ideal, mas precisava disto para ontem) #include #include int main(void) { int soma=0; int resultado=0; int loopx=1; while(loopx==1) { printf("Insere um numero para somar\n"); scanf("%d",&soma); resultado = resultado + soma; printf("\nContinuar?\nSim-1\nNao-2\n"); scanf("%d",&loopx); } printf("\nO Resultado e: %d\n",resultado); system("pause"); return 0; }

Boas malta, alguém me consegue explicar como resolver este exercício?