Logicielsmoto.com

Bonjour,

Connaissez vous une syntaxe plus simple que celle-ci pour le ldd :



le but étant de pouvoir utiliser deux equates d'un octet sur un LDD
afin d'éviter d'avoir un lda #constant1 et un ldb #constant2

peut on s'affranchir du *256 en utilisant une autre syntaxe (plus simple) qui serait adaptée à cette situation ?

tu peux utiliser "<+8" (décalage à gauche (+) de 8 bits) au lieu de "*256", mais je pense pas que ca simplifie.

_________________
Good morning, that's a nice Tnetennba

Je me demande d'ailleurs comment l'ASM va assembler ce LDD #contant1*256+constant2

La solution la plus simple c'est de stocker le résultat de A et B dans une adresse tampon 16 bits nommée 'constant' par exemple et de récupérer l'ensemble par LDD constant. Il ne faut pas oublier que contant1 et constant2 n'existe pas en LM et sont forcément réservées quelque part en mémoire.

j'ai évité de mettre des calculs compliqués genre LDD #mon calcul compliqué

comme ça c'est pas pareil ?

_________________

Pourquoi faire simple quand on peut faire compliqué ?

Note aussi que
C'est juste pareil que LDA #nn + CLRB (pour rappel D=A:B). Ici il y a nettement plus simple.

Ensuite tu fais un ADDD #nn, avec nn sur 8 bit et B=0, donc un LDB #nn fait pareil en plus simple.

Mais au final deux LD 8bits sont plus lents et occupent plus de place qu'un LD 16bits.

Le calcul compliqué est parfaitement valide et utilisé très souvent. C'est une constante: le compilo calcule la valeur exacte de son coté (c'est son boulot à la base), il n'y a aucun problème avec ca. Que des avantages. Pourquoi s'en priver ?

_________________
Good morning, that's a nice Tnetennba

Je disais qui si contant1 est en $9000 et constant2 en $9001 qui forme le binôme constant

Un simple LDD $contant suffit ou LDD $9000

Les constante sont des EQUATES (EQU). Effectivement elles n'ont pas d'adresses mémoire. Elles n'existent que le temps de la compilation et sont évaluées par l'assembleur quand il en a besoin. Du coup on peut tout charger dans D même si elle est utilisée dans une expression complexe sans passer par une zone mémoire dans le programme: le compilo va évaluer l'expression, obtenir une valeur et la mettre en argument immédiat à l'opcode du LDD par exemple.

_________________
Good morning, that's a nice Tnetennba

J'ai remarqué que beaucoup de débutants mélangent les instructions du macro-assembleur et les instructions du processeur cible.
La bonne compréhension de la différence entre les deux est essentielle. Il ne faut pas commencer à écrire du code sans avoir bien assimilé cette notion.
En général c'est bien expliqué dans la documentation de l'assembleur utilisé. Il faut la lire et la comprendre.

Il y a un truc simple pour s'assurer que le code fait bien ce que l'on a voulu : étudier le listing généré par l'assemblage.
On voit en particulier le code opération généré, et les paramètres. Si on a confondu, par exemple, une valeur et un pointeur, on s'en aperçoit facilement à la vue du langage machine résultant.

Euh à priori tu n'a PAS besoin de ça vu que le registre D est DEJA Ax256+B dans le 6809.
Tout ce que tu as à faire est
LDA constant1
LDB constant2

Et c'est TOUT, ton D contiendra 256xA+B

Il n'a même,pas besoin de faire ça!!

le D su 6809 est déjà du Ax256+B

Salut Sam

Sauf erreur de ma part, c'est pas ce qui est demandé

Sa demande est exactement ce que fait le 6809 à savoir que D estAx256+B .

Et je ne comprend pas sa demande, pourquoi il cherche à refaire l'existant ?

Je pige pas ce que tu ne comprends pas. En gros il se demandait si l'écriture LDD #machin-compliqué-mais-constant marchait ou pas. Ma réponse est: bien sur que ca marche. Le compilo va évaluer la constante de son coté et ne va pas générer du code contenant MUL / ADD. Il a une constante compliquée, mais constante avant tout et l'utilise comme telle.

Note: la génération de MUL / ADD à partir d'un truc de haut niveau comme D := X+D*5 est ce que fait un compilateur (c/pascal/fortran), or ici on a un assembleur. En assembleur on reste au même niveau d'abstraction (instructions machine). Il ne génère pas d'autres instructions machine que celles qui figurent explicitement dans le source.

_________________
Good morning, that's a nice Tnetennba

Désolé, je n'ai pas suivi le forum (honte à moi) et je réponds donc un peu tardivement.

Sam a bien compris ma question de départ et sa réponse est OK.
C'est uniquement une problématique de syntaxe assembleur (C8609).

Je voulais simplement savoir s'il existait une syntaxe reconnue par l'assembleur C8609 qui concatène deux equates 8bits.
En l'absence de cette syntaxe on utilise des opérations arithmétiques pour faire cette concaténation, c'est juste moins lisible.

L'objectif étant de faire un LDD avec deux equates 8 bits au lieu d'un LDA et un LDB, ce qui fait gagner un cycle et un octet.
On conserve la possibilité de faire cette petite optim tout en ayant un code un peu plus maintenable par l'utilisation d'equates au lieu de valeurs en dur.
Seul bémol, c'est un peu moins lisible ;-)