Assembleur

[om38100]

Bonjour,
j'ai un problème avec mon programme assembleur en ARM
je dois réalisé cette fonction:
Si (R0>R1) retourner la valeur R0*2+R1
Si (R0=R1) retourner la valeur R0+R1
Si (R0<R1) retourner la valeur R0+R1*2

j'ai réalisé le programme suivant mais toujours des erreurs pouvez vous m'aider svp

P_compara MOV R0,#1
MOV R1,#2

CMP R0,R1
BHI CMP
MOV R0,R0*2
ADD R2,R0,R1
B P_comparb

P_comparb CMP R0,R1
BEQ CMP
ADD R2,R0,R1*2
B P_comparc

P_comparc CMP R0,R1
BLS CMP
ADD R2,R0,R1

Cordialement Julien Delavigne
-----

[ftorama]

Pourquoi faire ça en assembleur en 2013?

C'est un devoir à rendre?

[om38100]

Non c'est un Tp que je n'arrive pas à terminer avec les erreurs

[om38100]

Personne pour m'aider ?

[A voir en vidéo sur Futura]

[PIXEL]

pas impossible , mais....

1) un soft en ASM se doit d'être COMMENTÈ , pour aider à la correction

2) quel µ ? car il y a des variantes de l'un à l'autre, et peu de contributeurs les maitrisent TOUS.

[Seb.26]

...en assembleur, je ferais un truc du style :

si R0 > R1
alors R0 = R0 * 2

si R0 < R1
alors R1 = R1 * 2

retourner R0 + R1

NB: en ASM, on fait *2 en décalant d'un bit à gauche ...

en gros, il te reste à pondre 6 lignes de code

[freepicbasic]

Le # est réservé pour le chargement immédiat,
mettre 1 et 2 dans les registre n'aboutis à rien ...

Je ne connais pas trop cet assembleur, voir si CMP fait bien la comparaison ;
c est à dire une soustraction qui modifie les flags mais pas les registres

Vérifier aussi si l'addition avec son propre registre est possible(ADD R0,R0) , sinon il faudra faire appel à un registre de plus.
comme
MOV R2,R0
ADD RO,R2

ou utiliser le décalage comme cité ci dessus.

le Equal fait parti de la procédure sup puisque la seconde partie est identique comme "R0 + R1"

je pense que BRA est l'instruction de saut sur ce processeur , à vérifier...

CMP R0,R1
BHI Sup
BEQ Eqal

ADD R0,R0
ADD R0,R1
BRA fin

sup
ADD R1,R1
equal
ADD R0,R1

fin

[Murayama]

Bonjour!

Pourquoi faire ça en assembleur en 2013?

Il y a toujours une poignée d'irréductibles qui prétendent que c'est plus
rapide, et j'en ai même vu qui disent que c'est portable.

Si (R0>R1) retourner la valeur R0*2+R1
Si (R0=R1) retourner la valeur R0+R1
Si (R0<R1) retourner la valeur R0+R1*2

Voici une méthode sûre:

- Vous faites un programme en C dans lequel il y a une fonction my_func définie
comme ça:

int my_func(int r0, int r1) {
if(r0 > r1) {
return 2*r0+r1;
}
else if(r1 == r0) {
return 2*r0;
}
else {
return r0 + 2*r1;
}
}

- ensuite, vous le compilez et vous le faites fonctionner avec un point
d'arrêt avant la fonction.
- Vous ouvrez une fenêtre désassembleur, et vous avez ce que vous cherchez
sans effort, ce qui pour un étudiant est un plus.

Pascal

[terriblement]

Il y a toujours une poignée d'irréductibles qui prétendent que c'est plusrapide

C'est le cas, si codé proprement...

Voici une méthode sûre

C'est surtout une méthode pour avori un code non optimisé, avec des étapes difficile à justifier devant un professeur

[Murayama]

Bonjour!

C'est le cas, si codé proprement...

Les compilateurs sont devenus tellement bons qu'il est généralement
difficile d'optimiser davantage. Quelqu'un disait qu'en assembleur, on multiplie par 2
en shiftant à gauche. Je viens d'essayer. Dans mon code C, j'ai fait une multiplication par
2, puis par 3, puis par 69 (un compte rond). Dans le cas d'une multiplication par 2, il
fait simplement un shift gauche. Dans le cas d'une multiplication par 3, il me fait une
copie dans un autre registre, il shifte l'un des registres, puis les additionne.
Et c'est seulement dans la multiplication par 69 qu'il utilise le multiplicateur hardware.
Le compilateur tient donc compte des spécificités du processeur que j'utilise, il se sert
du multiplieur hardware alors qu'il aurait pu faire la multiplication "à la main".

C'est surtout une méthode pour avori un code non optimisé, avec des étapes difficile à justifier devant un professeur

Mais c'est avant tout une façon d'avoir sans effort une base de code qui fonctionne.
Rien n'interdit de le modifier par la suite.

Pascal

[terriblement]

Fais voir une loop avec une for, et la meme chsoe avec un while et une variable que tu incrementes dans ce while.
Le while se fera plus rapidement (chez moi en totu cas, XC8 pour PIC18F). Donc en assembleur on peut j'en suis sur largement optimiser la chose.

C'est toujours bon d'avoir quelques notions en asm. Quand tu as des applis qui demandent des temps de réponse très rapide, tu es parfois obligé de passer par là.

[ftorama]

Fais voir une loop avec une for, et la meme chsoe avec un while et une variable que tu incrementes dans ce while.
Le while se fera plus rapidement (chez moi en totu cas, XC8 pour PIC18F). Donc en assembleur on peut j'en suis sur largement optimiser la chose.

C'est toujours bon d'avoir quelques notions en asm. Quand tu as des applis qui demandent des temps de réponse très rapide, tu es parfois obligé de passer par là.

C'est que le compilateur est mauvais. N'oublie pas non plus que les versions gratuites de XC8 n'ont qu'un niveau d'optimisation basique. De plus, les 16F et 18F n'ont pas été conçus à la base pour le C (stack fixe et limitée entre autres).

[terriblement]

C'est que le compilateur est mauvais. N'oublie pas non plus que les versions gratuites de XC8 n'ont qu'un niveau d'optimisation basique.

J'avais zappé ce point.

De plus, les 16F et 18F n'ont pas été conçus à la base pour le C (stack fixe et limitée entre autres).

Donc fonctionne plus rapidement en assembleur, CQFD.

PS: Je ne code presque jamais en assembleur.

[Murayama]

Bonjour!

C'est toujours bon d'avoir quelques notions en asm. Quand tu as des applis qui demandent
des temps de réponse très rapide, tu es parfois obligé de passer par là.
[...]
PS: Je ne code presque jamais en assembleur.

Bon, je vois que nous disons peut-être la même chose. Pour ma part, il m'arrive de coder
en assembleur. Je l'ai fait pour une FFT, parce que le compilateur "rangeait" des variables
qui sont réutilisées quelques lignes plus loin. Et comme un papillon de FFT est appelé des
milliers de fois, c'est utile de gagner quelques cycles.

Pascal