Logicielsmoto.com

Nous sommes le 01 Mar 2021, 04:15

Heures au format UTC + 1 heure




Poster un nouveau sujet Répondre au sujet  [ 13 messages ] 
Auteur Message
MessagePosté: 29 Nov 2020, 12:26 
Hors ligne

Inscription: 21 Avr 2019, 21:48
Messages: 40
Localisation: Var
Bonjour,

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

Code:
(main)TEST
   org $0000
   
constant1 equ $1A
constant2 equ $E9

        ldd   #(constant1*256)+constant2
        sta   $A000
        stb   $B000


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 ?


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 29 Nov 2020, 14:22 
Hors ligne

Inscription: 21 Aoû 2006, 09:06
Messages: 1385
Localisation: Brest
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


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 06 Déc 2020, 10:55 
Hors ligne

Inscription: 13 Juin 2005, 21:50
Messages: 265
Localisation: Planete Zorg (31)
Je me demande d'ailleurs comment l'ASM va assembler ce LDD #contant1*256+constant2 :voyons:

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.


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 06 Déc 2020, 12:56 
Hors ligne

Inscription: 06 Avr 2010, 01:59
Messages: 313
j'ai évité de mettre des calculs compliqués genre LDD #mon calcul compliqué

comme ça c'est pas pareil ?

Code:
(main)TEST
   org $0000
   
constant1 equ $1A
constant2 equ $E9

        lda #constant1
        ldb #256
        MUL
        ADDD #constant2
                                            ; ldd   #(constant1*256)+constant2
        sta   $A000
        stb   $B000

_________________
Image


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 06 Déc 2020, 13:53 
Hors ligne

Inscription: 21 Aoû 2006, 09:06
Messages: 1385
Localisation: Brest
Pourquoi faire simple quand on peut faire compliqué ?

Note aussi que
Code:
LDA #nn
LDB 256
MUL

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


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 07 Déc 2020, 00:27 
Hors ligne

Inscription: 13 Juin 2005, 21:50
Messages: 265
Localisation: Planete Zorg (31)
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


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 07 Déc 2020, 01:40 
Hors ligne

Inscription: 21 Aoû 2006, 09:06
Messages: 1385
Localisation: Brest
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


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 07 Déc 2020, 09:57 
Hors ligne
M. DCMOTO

Inscription: 06 Juin 2004, 08:23
Messages: 630
Localisation: Provence (France)
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.


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 26 Déc 2020, 21:58 
Hors ligne

Inscription: 21 Fév 2020, 11:38
Messages: 185
Bentoc a écrit:
Bonjour,

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

Code:
(main)TEST
   org $0000
   
constant1 equ $1A
constant2 equ $E9

        ldd   #(constant1*256)+constant2
        sta   $A000
        stb   $B000


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 ?


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


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 26 Déc 2020, 22:00 
Hors ligne

Inscription: 21 Fév 2020, 11:38
Messages: 185
Samuel Devulder a écrit:
tu peux utiliser "<+8" (décalage à gauche (+) de 8 bits) au lieu de "*256", mais je pense pas que ca simplifie.


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

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


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 26 Déc 2020, 22:07 
Hors ligne

Inscription: 21 Fév 2020, 11:38
Messages: 185
Samuel Devulder a écrit:
Pourquoi faire simple quand on peut faire compliqué ?

Note aussi que
Code:
LDA #nn
LDB 256
MUL

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 ?


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 ?


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 27 Déc 2020, 12:19 
Hors ligne

Inscription: 21 Aoû 2006, 09:06
Messages: 1385
Localisation: Brest
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


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 08 Jan 2021, 12:02 
Hors ligne

Inscription: 21 Avr 2019, 21:48
Messages: 40
Localisation: Var
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 ;-)


Haut
 Profil  
Répondre en citant le message  
Afficher les messages postés depuis:  Trier par  
Poster un nouveau sujet Répondre au sujet  [ 13 messages ] 

Heures au format UTC + 1 heure


Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 4 invités


Vous ne pouvez pas poster de nouveaux sujets
Vous ne pouvez pas répondre aux sujets
Vous ne pouvez pas éditer vos messages
Vous ne pouvez pas supprimer vos messages
Vous ne pouvez pas joindre des fichiers

Rechercher:
Aller à:  
cron
Développé par phpBB® Forum Software © phpBB Group
Traduction par phpBB-fr.com