Défi pour les programmeurs 6809

Cette catégorie traite de développements récents pour nos vieilles machines, applications, jeux ou démos... Amis programmeurs, c'est ici que vous pourrez enfin devenir célèbres!

Modérateurs : Carl, Papy.G, fneck

Répondre
Daniel
Messages : 10827
Enregistré le : 01 mai 2007 18:30
Localisation : Vaucluse
Contact :

Défi pour les programmeurs 6809

Message par Daniel » 09 nov. 2015 10:18

L'EPROM 2732 dont l'emplacement est prévu par Thomson dans la carte mère du MO5 peut servir à une foule de projets utiles.

Image

Pour ma part, je l'utilise déjà pour implanter un contrôleur de carte SD : http://dcmoto.free.fr/bricolage/cs91-280_mo5/index.html
Il occupe les adresses comprises entre $A000 et $A7FF. Il reste encore la plage $A800-$AEFF accessible sans difficulté avec le circuit de décodage d'adresse actuel, soit 1792 octets libres.

J'imagine y mettre un programme permettant de dumper la mémoire, de la désassembler et de la modifier. Cet outil résident serait très utile pour mettre au point des programmes directement sur la "vraie" machine et éviterait l'utilisation d'un émulateur sur PC.
J'ai écrit un tel outil en 1986 : http://dcmoto.free.fr/programmes/desass ... index.html

Image

Je l'ai ensuite un peu amélioré en 2013, voici le programme source :

Code : Tout sélectionner

/**************************************************\
*                 D D P 2 0 1 3                    * 
*           (c) 2013 - Daniel Coulom               *  
*           http://dcmoto.free.fr/                 *
*           http://forum.system-cfg.com/           *
*--------------------------------------------------*
* Ce code est distribue gratuitement dans l'espoir *
* qu'il sera utile, mais sans aucune  garantie  et *
* sans  engager  la  responsabilité  de  l'auteur. *
* Vous  pouvez  l' utiliser,  le  modifier  et  le *
* diffuser librement, en conservant cette  licence *
* et les références de l'auteur dans   toutes  les *
* copies. L'exploitation commerciale est interdite.*
\**************************************************/

* Ce programme permet de desassembler, de dumper
* et de patcher la RAM du MO5. Il est prevu pour
* être charge en memoire non modifiable, par exemple
* une cartouche MEMO5 ou une EPROM. Il est issu de
* la conversion d'un programme ecrit en 1986.

/**************************************************\
*                Version 2013.11.29                *
\**************************************************/
* Historique
* 2013.11.29 dans le dump, espace apres l'adresse 
* 2013.11.15 test BNE apres LEAY (BPL ne marche pas) 
* 2013.11.14 zones de travail en memoire video
* 2013.11.14 nettoyage du code
* 2013.11.14 suppression du code auto-modifiable
* 2013.11.13 adresses directes remplacees par labels
* 2013.11.12 premiere version operationnelle

*-----------------------------------
* Zones de travail en memoire video
*-----------------------------------
LIGNE  EQU $1F40 
ADDR   EQU $1F69
CODOP  EQU $1F6B 
INDIR  EQU $1F6C

*------------------------------
* Debut du programme
*------------------------------
  ORG $9000
  LEAX   ECRAN0,PCR  adresse ecran d'accueil      
  LBSR   PRSTR       affichage ecran d'accueil      
ATTENTE
  SWI
  FCB    $0C         lecture rapide clavier         
  BEQ    ATTENTE     attente d'une touche         

*------------------------------
* Saisie adresse
*------------------------------
GETADDR
  LEAX   ECRAN1,PCR  adresse ecran saisie adresse      
  LBSR   PRSTR       affichage ecran      
  LBSR   GETH2       saisie 2 octets hexa              
  TFR    D,U         adresse dans U       
  CMPD   #$FFFF      adresse fictive pour abandon       
  BNE    ACTION      choix de l'action      
  LEAX   ECRAN6,PCR  initialisation position          
  LBSR   PRSTR       affichage       
  RTS                retour 

*------------------------------
* Choix de l'action
*------------------------------              
ACTION
  LEAX   ECRAN4,PCR  adresse ecran       
  LBSR   PRSTR       affichage ecran       
CHOIX
  LDA    #$6E        touche STOP
  STA    $A7C1       scrutation clavier       
  TST    $A7C1       test touche              
  BPL    GETADDR     retour saisie adresse
  LDA    #$72        touche BASIC
  STA    $A7C1       scrutation clavier       
  TST    $A7C1       test touche              
  LBPL   DESA        desassemblage   
  LDA    #$70        touche SHIFT 
  STA    $A7C1       scrutation clavier       
  TST    $A7C1       test touche              
  LBPL   DUMP        dump
  LDA    #$6A        touche CNT
  STA    $A7C1       scrutation clavier       
  TST    $A7C1       test touche              
  BMI    CHOIX       touche invalide
  LBRA   PATCH       patch  

*------------------------------              
* Desassemblage
*------------------------------              
DESA
  STU    ADDR,PCR          
  LEAY   LIGNE,PCR   pointeur Y en debut de ligne          
  LDD    #$2820                
DESA1           
  STB    ,Y+         remise a blanc            
  DECA                      
  BNE    DESA1       boucle de 40 caracteres           
  LDB    ,U+         octet a desassembler           
  LEAX   MNEMO,PCR   adresse table mnemoniques  
DESA3
  LDY    ,X++        adresse traitement du type (relatif a $9149)     
  CMPY   #$FFFF      test fin de la table
  BNE    DESA4       la table n'est pas finie
  LBSR   DES0        desassemblage instruction inconnue    
  LBRA   PUTL        affichage ligne desassemblee            
DESA4
  LEAY   1,Y         Y=1 pour DES0, Y=2 pour DES1, etc...
  LDA    ,X+         nombre de lignes pour ce type
DESA5             
  CMPB   ,X+         test du code operation
  BEQ    DESA7       identique table
  DECA               decrementation compteur lignes
  BEQ    DESA6       type suivant
  LEAX   $04,X       sauter le libelle
  BRA    DESA5       ligne suivante
DESA6
  LEAX   $04,X       sauter le libelle
  BRA    DESA3       type suivant
DESA7
  TFR    PC,D        adresse courante dans D
  ADDD   #PUTL-*     adresse routine affichage ligne
  PSHS   D           empilage adresse de retour
  TFR    PC,D        adresse courante dans D
  ADDD   #DESAS9-*-3 adresse table des branchements
DESA8
  ADDD   #$03        adresse routine suivante
  LEAY   -1,Y        decrementation du type
  BNE    DESA8       type > 0
  TFR    D,PC        branchement a la routine de traitement
  
DESAS9
  LBRA   DES0
  LBRA   DES1
  LBRA   DES2
  LBRA   DES3
  LBRA   DES4
  LBRA   DES5
  LBRA   DES6
  LBRA   DES7
  LBRA   DES8
  LBRA   DES9
  LBRA   DES10
  LBRA   DES11
  LBRA   DES6
  LBRA   DES1

*------------------------------              
* Dump
*------------------------------              
DUMP
  LEAY   LIGNE,PCR   pointeur Y en debut de ligne          
  TFR    U,D
  LBSR   HEXAD       affichage hexa de l'adresse
  LDA    #$20
  STA    ,Y+         blanc apres l'adresse 
  LDB    #$08        compteur de boucle 
DUMP1
  LDA    ,U+ 
  LBSR   HEXAA       affichage octet hexa
  LDA    #$20 
  STA    ,Y+  
  DECB        
  BNE    DUMP1       boucle sur 8 octets
  LEAU   -$08,U             
  LDB    #$20               
  STB    ,Y+                
  LDB    #$07               
DUMP2
  LDA    ,U+                
  BSR    ASCII       affichage octet ASCII      
  DECB                   
  BPL    DUMP2             
  LBRA   PUTL        affichage de la ligne dumpee             

*------------------------------              
* Patch
*------------------------------              
PATCH
  BSR    PATCH1      affichage ecran patch              
  BSR    GETH1       saisie d'un octet hexa
  STB    ,U                 
  LEAX   ECRAN5,PCR  initialisation position        
  BSR    PRSTR      
  BSR    PATCH1      affichage ecran patch        
  LEAU   $01,U              
  LBRA   ACTION      choix de l'action              

*------------------------------              
* Affichage ecran patch
*------------------------------              
PATCH1
  LEAY   LIGNE,PCR   pointeur Y en debut de ligne          
  TFR    U,D
  LBSR   HEXAD       affichage hexa de l'adresse
  LDA    #$20               
  STA    ,Y+                
  LDA    ,U                 
  LBSR   HEXAA       affichage octet hexa
  LDB    #$20               
  STB    ,Y+                
  BSR    ASCII       affichage octet ASCII
  LDB    #$04               
  STB    ,Y+         fin de chaine
  LEAY   LIGNE,PCR   pointeur Y en debut de ligne          
  TFR    Y,X                
  BSR    PRSTR              
  LEAX   ECRAN3,PCR  ecran de patch
  BSR    PRSTR       affichage      
  RTS                       

*--------------------
* Conversion ASCII
*--------------------
ASCII
  CMPA   #$20               
  BCS    ASCII1              
  CMPA   #$80               
  BCS    ASCII2              
ASCII1
  LDA    #$2E               
ASCII2
  STA    ,Y+                
  RTS                       

*--------------------
* affichage caractere
*--------------------
PRCHAR
  SWI
  FCB    $02     affichage d'un caractere               

*--------------------
* affichage chaine
*--------------------
PRSTR
  LDB    ,X+     lire le caractere          
  CMPB   #$04    detection fin de chaine          
  BNE    PRCHAR             
  RTS                       

*---------------------
* Saisie 2 octets hexa
*---------------------
GETH2
  BSR    GETH1   saisie d'un octet hexa              
  TFR    B,A                

*---------------------
* Saisie 1 octet hexa
*---------------------
GETH1
  PSHS   A                  
  BSR    GETH0     saisie caractere hexa         
  TFR    B,A                
  ASLA                      
  ASLA                      
  ASLA                      
  ASLA                      
  BSR    GETH0     saisie caractere hexa         
  PSHS   B                  
  ADCA   ,S+                
  TFR    A,B                
  PULS   A,PC               

*------------------------------
* Saisie caractere hexadecimal
*------------------------------
GETH0
  NOP                       
  SWI
  FCB    $0A     lecture clavier           
  TSTB                      
  BEQ    GETH0   pas de touche enfoncee            
  CMPB   #$46    'F'           
  BHI    GETH0              
  CMPB   #$30    '0'               
  BCS    GETH0              
  CMPB   #$39    '9'           
  BLS    PUTH0             
  CMPB   #$41    'A'           
  BCS    GETH0           
PUTH0
  NOP                      
  SWI
  FCB    $02               
  CMPB   #$3A    ':'           
  BHI    PUTH1             
  SBCB   #$2F               
  RTS
PUTH1
  SBCB   #$37               
  RTS                       

*-------------------
* Affichage ligne
*-------------------
PUTL
  LDD    #$0D0A      CR-LF en fin de ligne          
  STD    ,Y++               
  LDB    #$04        terminateur de ligne      
  STB    ,Y+                
  LEAY   LIGNE,PCR   pointeur Y en debut de ligne          
  TFR    Y,X                
  BSR    PRSTR
  LBRA   CHOIX              

*---------------------
* Affichage hexa de D
*---------------------
HEXAD
  BSR    HEXAA   affichage octet hexa              

*---------------------
* Affichage hexa de B
*---------------------
HEXAB
  TFR    B,A                

*----------------------
* Affichage hexa de A
*----------------------              
HEXAA
  PSHS   B,A                
  TFR    A,B                
  ANDB   #$0F               
  LSRA                      
  LSRA                      
  LSRA                      
  LSRA                      
  ANDCC  #$FE               
  BSR    HEXA1              
  BSR    HEXA1              
  PULS   A,B,PC             

*--------------------------
* Affichage digit hexa
*--------------------------              
HEXA1
  EXG    A,B                
  CMPB   #$09               
  BHI    HEXA2              
  ADDB   #$30           
  FCB    $B5
HEXA2
  ADDB   #$37            
  STB    ,Y+                
  RTS                       

*------------------------------------
* Transfert debut ligne
* A = nbre d'octets hexa a afficher
*------------------------------------
TLINE              
  PSHS   U,B,A              
* transfert adresse hexadecimale              
  LEAY   LIGNE,PCR   pointeur Y en debut de ligne          
  LDU    ADDR,PCR    adresse a transferer        
  TFR    U,D
  BSR    HEXAD       affichage hexa de l'adresse              
  LEAY   $01,Y       espace         
* transfert dump hexadecimal              
TLIN1
  LDA    ,U+                
  BSR    HEXAA       affichage octet hexa              
  DEC    ,S                 
  BNE    TLIN1       boucle pour 8 octets        
* transfert mnemonique              
  LEAY   LIGNE,PCR   pointeur Y en debut de ligne          
  LEAY   $10,Y       position 16         
  LDA    #$04        4 caracteres a transferer 
TLIN2                 
  LDB    ,X+                
  STB    ,Y+         transfert d'un caractere         
  DECA                      
  BNE    TLIN2       boucle pour 4 caracteres          
  LEAY   $01,Y       espace         
  PULS   A,B,U,PC           

*------------------------------------
* Desassemblage type 00
*------------------------------------              
DES0
  LDA    #$01        1 octet               
  BRA    TLINE              

*------------------------------------
* Desassemblage type 01 et 13
*------------------------------------              
DES1
  LDB    #$23
  FCB    $B5

*------------------------------------
* Desassemblage type 03
*------------------------------------              
DES3
  LDB    #$2F
  LDA    #$02        2 octets       
DES31
  BSR    TLINE              
  STB    ,Y+                
  LDB    #$24   '$'               
  STB    ,Y+                
  LDA    ,U+                
  BRA    HEXAA  affichage hexa de A              

*------------------------------------
* Desassemblage type 02
*------------------------------------              
DES2
  LDB    #$23   '#'            
  FCB    $B5    

*------------------------------------
* Desassemblage type 04
*------------------------------------              
DES4
  LDB    #$00                  
  LDA    #$03         3 octets      
DES41
  BSR    TLINE              
  STB    ,Y+                
  LDB    #$24   '$'            
  STB    ,Y+                
  LDD    ,U++               
  BRA    HEXAD   affichage hexa de D             

*------------------------------------
* Desassemblage type 07 (operations pile)
*------------------------------------              
DES7
  LDA    #$02         2 octets               
  BSR    TLINE              
  LEAX   RPILE,PCR          
  LDA    ,U+                
  LDB    #$09               
  STB    -$01,S             
  BRA    DES72
DES71    
  LDB    #$2C      ','     
  STB    ,Y+   
DES72
  DEC    -$01,S    nbre registres a afficher
  BNE    DES73       
  LEAY   -$01,Y     
  RTS              retour                  
DES73
  LSRA            
  BCS    DES75         
DES74
  LDB    ,X+      
  BPL    DES74     
  BRA    DES72       
DES75
  LDB    ,X+           
  BPL    DES77   
DES76
  ANDB   #$7F  
  STB    ,Y+    
  BRA    DES71   
DES77
  STB    ,Y+              
  LDB    ,X+            
  BRA    DES76 

*------------------------------------
* Desassemblage type 11 (EXG-TFR)
*------------------------------------              
DES11
  LDA    #$02       2 octets               
  LBSR   TLINE              
  LDA    ,U+                
  TFR    A,B                
  ANDB   #$0F               
  LSRA                      
  LSRA                      
  LSRA                      
  LSRA                      
  ANDCC  #$FE               
  BSR    DES111              
  TFR    B,A                
  LDB    #$2C               
  STB    ,Y+                
DES111
  PSHS   B                  
  LEAX   REXG,PCR          
  INCA                      
DES112
  DECA                    
  BEQ    DES114 
DES113               
  LDB    ,X+          
  BPL    DES113            
  BRA    DES112         
DES114
  LDB    ,X+                
  BPL    DES115         
  BRA    DES116          
DES115
  STB    ,Y+               
  LDB    ,X+          
DES116
  ANDB   #$7F             
  STB    ,Y+                
  PULS   B,PC               

*------------------------------------
* Desassemblage type 06 et 12 (branch)
*------------------------------------              
DES6
  LDA    #$02       2 octets               
  LBSR   TLINE              
  LDB    #$24               
  STB    ,Y+                
  LDB    ,U+                
  TFR    U,X                
  LEAX   B,X                
  TFR    X,D
  LBRA   HEXAD          

*---------------------
*
*---------------------            
DES5B
  LDB    #$5B   '['              
  FCB    $B5

*---------------------
*
*---------------------            
DES5C
  LDB    #$5D   ']'            
  TST    INDIR,PCR          
  BEQ    *+4               
  STB    ,Y+              
  RTS                       

*-------------------
*
*-------------------              
DES5A
  LDB    CODOP,PCR          
  CMPB   #$10               
  BNE    *+3              
  INCA            1 octet supplementaire          
  LBRA   TLINE              

*------------------------------------
* Desassemblage type 05 (indexe)
*------------------------------------              
DES5
  STB    CODOP,PCR          
  CLR    INDIR,PCR          
  LDB    ,U+                
  BITB   #$10               
  BEQ    DES51              
  COM    INDIR,PCR          
DES51
  ANDB   #$8F               
  LDA    #$02               
  BITB   #$80               
  LBEQ   DES53
  INCA                      
  CMPB   #$88    8 bits               
  LBEQ   DES54
  INCA                      
  CMPB   #$89    16 bits           
  LBEQ   DES55
  CMPB   #$8D    16 bits PCR           
  LBEQ   DES57
  DECA                      
  CMPB   #$8C    8 bits PCR           
  LBEQ   DES56
  CMPB   #$8F    16 bits indirect           
  BNE    DES52
  INCA                      
  BSR    DES5A
  BSR    DES5B
  LDB    #$24               
  STB    ,Y+                
  LDD    ,U++               
  LBSR   HEXAD              
  BRA    DES5C

*-------------------
*
*-------------------              
DES5D
  PSHS   B                  
  ANDB   #$60               
  LSRB                      
  LSRB                      
  LSRB                      
  LSRB                      
  LSRB                      
  LEAX   RINDX,PCR          
  LDA    B,X                
  PULS   B,PC               

*---------------------
*
*---------------------            
DES52
  DECA                      
  BSR    DES5E
  ANDB   #$0F               
  LEAX   RINDX+4,PCR          
  INCB                      
  PSHS   B                  
DES521
  DEC    ,S                 
  BEQ    DES523              
DES522
  LDB    ,X+                
  BPL    DES522              
  BRA    DES521              
DES523
  LEAS   $01,S              
DES524
  LDB    ,X+                
  BMI    DES525              
  STB    ,Y+                
  BRA    DES524              
DES525
  ANDB   #$7F               
  STB    ,Y+                
  PSHS   Y                  
DES526
  LDB    ,-Y                
  CMPB   #$52               
  BNE    DES526              
  STA    ,Y                 
  PULS   Y                  
  LBRA   DES5C

*---------------------
*
*---------------------            
DES5E
  LBSR   DES5A
  LBSR   DES5B
DES5F
  LDB    -$01,U             
  BRA    DES5D

*---------------------
*
*---------------------            
DES53
  LBSR   DES5A
  BSR    DES5F              
  STA    <$E2               
  BITB   #$10               
  BEQ    DES531              
  LDA    #$2D               
  STA    ,Y+                
  ANDB   #$0F               
  NEGB                      
  BRA    DES532              
  NOP                       
DES531
  LDA    #$2B               
  STA    ,Y+                
DES532
  ANDB   #$0F               

*-------------------
*
*-------------------              
DES5G
  LBSR   HEXAB              
  LDA    <$E2               
  LDB    #$2C               
  EXG    A,B                
  STD    ,Y++               
  RTS                       

*-------------------
*
*-------------------              
DES54
  BSR    DES5E
  STA    <$E2               
  LDB    ,U+                
  BPL    DES541              
  LDA    #$2D               
  STA    ,Y+                
  NEGB                      
  BRA    DES542              
  NOP                       
DES541
  LDA    #$2B               
  STA    ,Y+                
DES542
  BSR    DES5G              
  LBRA   DES5C

*-------------------
*
*-------------------              
DES55
  BSR    DES5E
  STA    <$E2               
  LDD    ,U++               
  BITA   #$80               
  BEQ    DES551              
  PSHS   A                  
  LDA    #$2D               
  STA    ,Y+                
  PULS   A                  
  COMA                      
  COMB                      
  ADDD   #$0001             
  BRA    DES552              
DES551
  PSHS   A                
  LDA    #$2B             
  STA    ,Y+              
  PULS   A                
DES552
  LBSR   HEXAD              
  LDB    #$2C               
  LDA    <$E2               
  EXG    A,B                
  STD    ,Y++               
  LBRA   DES5C

*-------------------
*
*-------------------              
DES56
  BSR    DES5E
  LDB    ,U+                
  TFR    U,X                
  LEAX   B,X                
  LDB    #$24               
  STB    ,Y+    
  TFR    X,D            
  LBSR   HEXAD              
DES561
  BSR    DES58
  LBRA   DES5C

*-------------------
*
*-------------------              
DES57
  LBSR   DES5E
  LDD    ,U++               
  TFR    U,X                
  LEAX   D,X                
  LDB    #$24               
  STB    ,Y+  
  TFR    X,D              
  LBSR   HEXAD              
  BRA    DES561              

*-------------------
*
*-------------------              
DES58
  LDD    #$2C50  ",P"             
  STD    ,Y++               
  LDD    #$4352  "CR"           
DES59
  STD    ,Y++               
  RTS                       

*------------------------------------
* Desassemblage type 09
*------------------------------------              
DES9
  LDB    ,U+                
  CMPB   #$20               
  BCS    DES94              
  CMPB   #$2F               
  BHI    DES94              
  LEAX   BRANCH,PCR          
  LEAY   LIGNE,PCR    pointeur Y en debut de ligne          
DES91
  CMPB   ,X+                
  BEQ    DES92              
  LEAX   $04,X              
  BRA    DES91              
DES92
  LDU    ADDR,PCR          
  TFR    U,D
  LBSR   HEXAD        affichage hexa de l'adresse              
  LEAY   $01,Y              
  LDD    ,U++               
  LBSR   HEXAD              
  LDD    ,U++               
  PSHS   B,A                
  LBSR   HEXAD              
  LEAY   $03,Y              
  LDB    #$4C               
  STB    ,Y+                
  LDD    ,X++               
  STD    ,Y++               
  LDD    ,X++               
  STD    ,Y++               
  LDB    #$24               
  STB    ,Y+                
  PULS   A,B
DES93                  
  TFR    U,X                
  LEAX   D,X
  TFR    X,D                
  LBRA   HEXAD            

*------------------------------------
* Desassemblage type 08
*------------------------------------              
DES8
  LDA    #$03          3 octets     
  LBSR   TLINE              
  LDB    #$24               
  STB    ,Y+                
  LDD    ,U++               
  BRA    DES93              

*------------------------------------
* 
*------------------------------------              
DES94
  CMPB   #$3F               
  BNE    DES941              
  LDA    #$02        2 octets               
  LDX    #$0010             
  LBSR   TLINE              
  LEAY   -$05,Y             
  LDD    #$5357             
  STD    ,Y++               
  LDD    #$4932   "I2"             
  BRA    DES59              
DES940
  LDX    #$0010             
  LDA    #$02               
  LBSR   TLINE       2 octets              
  LEAY   -$05,Y             
  LDD    #$5357   "SW"          
  STD    ,Y++               
  NOP                       
  LDD    #$4933   "I3"          
  LBRA   DES59              
DES941
  LEAX   COD10,PCR          
  CLRA                      
DES942
  CMPB   ,X+                
  BEQ    DES943              
  INCA                      
  CMPA   #$16               
  LBEQ   UNKNOWN              
  BRA    DES942              
DES943
  PSHS   A                  
  LEAX   LIB10,PCR          
  INCA                      
DES944
  DECA                      
  BEQ    DES945              
  LEAX   $04,X              
  BRA    DES944              
DES945
  PULS   A                  
  CMPA   #$04               
  BCS    DES947 
  CMPA   #$0A  
  BCS    DES949 
  CMPA   #$10  
  BCS    DES948 
DES946
  LDB    #$10  
  LBRA   DES5
DES947
  LDB    #$23 
  FCB    $B5
DES948
  LDB    #$00 
  LDA    #$04 
  LBRA   DES41
DES949
  LDD    #$032F
  LBRA   DES31 

*------------------------------------
* Desassemblage type 10
*------------------------------------              
DES10
  LDB    ,U+   
  CMPB   #$3F  
  BEQ    DES940 
  LEAX   LIB11,PCR          
  CMPB   #$83               
  BEQ    DES947              
  CMPB   #$B3               
  BEQ    DES948              
  CMPB   #$A3               
  BEQ    DES946              
  CMPB   #$93               
  BEQ    DES949              
  LEAX   LIB11+4,PCR          
  CMPB   #$8C               
  BEQ    DES947              
  CMPB   #$BC               
  BEQ    DES948              
  CMPB   #$AC               
  BEQ    DES946              
  CMPB   #$9C               
  BEQ    DES949

*------------------------------------
* Instruction inconnue
*------------------------------------              
UNKNOWN                
  LEAX   BADCOD,PCR          
  LDA    #$02          2 octets 
  LBRA   TLINE    

*---------------------------------------
* DONNEES
*---------------------------------------
MNEMO
* desassemblage type 0
  FCB $00,$00,$1e
  FCB $12,'N,'O,'P,' ', $13,'S,'Y,'N,'C'
  FCB $19,'D,'A,'A,' ', $1d,'S,'E,'X,' '
  FCB $39,'R,'T,'S,' ', $3a,'A,'B,'X,' '
  FCB $3b,'R,'T,'I,' ', $3d,'M,'U,'L,' '
  FCB $40,'N,'E,'G,'A', $50,'N,'E,'G,'B'
  FCB $43,'C,'O,'M,'A', $53,'C,'O,'M,'B'
  FCB $44,'L,'S,'R,'A', $54,'L,'S,'R,'B'
  FCB $46,'R,'O,'R,'A', $56,'R,'O,'R,'B'
  FCB $47,'A,'S,'R,'A', $57,'A,'S,'R,'B'
  FCB $48,'A,'S,'L,'A', $58,'A,'S,'L,'B'
  FCB $49,'R,'O,'L,'A', $59,'R,'O,'L,'B'
  FCB $4a,'D,'E,'C,'A', $5a,'D,'E,'C,'B'
  FCB $4c,'I,'N,'C,'A', $5c,'I,'N,'C,'B'
  FCB $4d,'T,'S,'T,'A', $5d,'T,'S,'T,'B'
  FCB $4f,'C,'L,'R,'A', $5f,'C,'L,'R,'B'
* desassemblage type 1
  FCB $00,$01,$17
  FCB $1a,'O,'R,'C,'C', $1c,'A,'N,'D,'C'
  FCB $3c,'C,'W,'A,'I'
  FCB $80,'S,'U,'B,'A', $c0,'S,'U,'B,'B'
  FCB $81,'C,'M,'P,'A', $c1,'C,'M,'P,'B'
  FCB $82,'S,'B,'C,'A', $c2,'S,'B,'C,'B'
  FCB $84,'A,'N,'D,'A', $c4,'A,'N,'D,'B'
  FCB $85,'B,'I,'T,'A', $c5,'B,'I,'T,'B'
  FCB $86,'L,'D,'A,' ', $c6,'L,'D,'B,' '
  FCB $88,'E,'O,'R,'A', $c8,'E,'O,'R,'B'
  FCB $89,'A,'D,'C,'A', $c9,'A,'D,'C,'B'
  FCB $8a,'O,'R,'A,' ', $ca,'O,'R,'B,' '
  FCB $8b,'A,'D,'D,'A', $cb,'A,'D,'D,'B'
* desassemblage type 2
  FCB $00,$02,$06
  FCB $83,'S,'U,'B,'D', $c3,'A,'D,'D,'D'
  FCB $8c,'C,'M,'P,'X', $cc,'L,'D,'D,' '
  FCB $8e,'L,'D,'X,' ', $ce,'L,'D,'U,' '
* desassemblage type 3
  FCB $00,$03,$2c
  FCB $00,'N,'E,'G,' ', $03,'C,'O,'M,' '
  FCB $04,'L,'S,'R,' ', $06,'R,'O,'R,' '
  FCB $07,'A,'S,'R,' ', $08,'A,'S,'L,' '
  FCB $09,'R,'O,'L,' ', $0a,'D,'E,'C,' '
  FCB $0c,'I,'N,'C,' ', $0d,'T,'S,'T,' '
  FCB $0e,'J,'M,'P,' ', $0f,'C,'L,'R,' '
  FCB $90,'S,'U,'B,'A', $d0,'S,'U,'B,'B'
  FCB $91,'C,'M,'P,'A', $d1,'C,'M,'P,'B'
  FCB $92,'S,'B,'C,'A', $d2,'S,'B,'C,'B'
  FCB $93,'S,'U,'B,'D', $d3,'A,'D,'D,'D'
  FCB $94,'A,'N,'D,'A', $d4,'A,'N,'D,'B'
  FCB $95,'B,'I,'T,'A', $d5,'B,'I,'T,'B'
  FCB $96,'L,'D,'A,' ', $d6,'L,'D,'B,' '
  FCB $97,'S,'T,'A,' ', $d7,'S,'T,'B,' '
  FCB $98,'E,'O,'R,'A', $d8,'E,'O,'R,'B'
  FCB $99,'A,'D,'C,'A', $d9,'A,'D,'C,'B'
  FCB $9a,'O,'R,'A,' ', $da,'O,'R,'B,' '
  FCB $9b,'A,'D,'D,'A', $db,'A,'D,'D,'B'
  FCB $9c,'C,'M,'P,'X', $dc,'L,'D,'D,' '
  FCB $9d,'J,'S,'R,' ', $dd,'S,'T,'D,' '
  FCB $9e,'L,'D,'X,' ', $de,'L,'D,'U,' '
  FCB $9f,'S,'T,'X,' ', $df,'S,'T,'U,' '
* desassemblage type 4
  FCB $00,$04,$2c
  FCB $70,'N,'E,'G,' ', $73,'C,'O,'M,' '
  FCB $74,'L,'S,'R,' ', $76,'R,'O,'R,' '
  FCB $77,'A,'S,'R,' ', $78,'A,'S,'L,' '
  FCB $79,'R,'O,'L,' ', $7a,'D,'E,'C,' '
  FCB $7c,'I,'N,'C,' ', $7d,'T,'S,'T,' '
  FCB $7e,'J,'M,'P,' ', $7f,'C,'L,'R,' '
  FCB $b0,'S,'U,'B,'A', $f0,'S,'U,'B,'B'
  FCB $b1,'C,'M,'P,'A', $f1,'C,'M,'P,'B'
  FCB $b2,'S,'B,'C,'A', $f2,'S,'B,'C,'B'
  FCB $b3,'S,'U,'B,'D', $f3,'A,'D,'D,'D'
  FCB $b4,'A,'N,'D,'A', $f4,'A,'N,'D,'B'
  FCB $b5,'B,'I,'T,'A', $f5,'B,'I,'T,'B'
  FCB $b6,'L,'D,'A,' ', $f6,'L,'D,'B,' '
  FCB $b7,'S,'T,'A,' ', $f7,'S,'T,'B,' '
  FCB $b8,'E,'O,'R,'A', $f8,'E,'O,'R,'B'
  FCB $b9,'A,'D,'C,'A', $f9,'A,'D,'C,'B'
  FCB $ba,'O,'R,'A,' ', $fa,'O,'R,'B,' '
  FCB $bb,'A,'D,'D,'A', $fb,'A,'D,'D,'B'
  FCB $bc,'C,'M,'P,'X', $fc,'L,'D,'D,' '
  FCB $bd,'J,'S,'R,' ', $fd,'S,'T,'D,' '
  FCB $be,'L,'D,'X,' ', $fe,'L,'D,'U,' '
  FCB $bf,'S,'T,'X,' ', $ff,'S,'T,'U,' '
* desassemblage type 5
  FCB $00,$05,$30
  FCB $30,'L,'E,'A,'X', $31,'L,'E,'A,'Y'
  FCB $32,'L,'E,'A,'S', $33,'L,'E,'A,'U'
  FCB $60,'N,'E,'G,' ', $63,'C,'O,'M,' '
  FCB $64,'L,'S,'R,' ', $66,'R,'O,'R,' '
  FCB $67,'A,'S,'R,' ', $68,'A,'S,'L,' '
  FCB $69,'R,'O,'L,' ', $6a,'D,'E,'C,' '
  FCB $6c,'I,'N,'C,' ', $6d,'T,'S,'T,' '
  FCB $6e,'J,'M,'P,' ', $6f,'C,'L,'R,' '
  FCB $a0,'S,'U,'B,'A', $e0,'S,'U,'B,'B'
  FCB $a1,'C,'M,'P,'A', $e1,'C,'M,'P,'B'
  FCB $a2,'S,'B,'C,'A', $e2,'S,'B,'C,'B'
  FCB $a3,'S,'U,'B,'D', $e3,'A,'D,'D,'D'
  FCB $a4,'A,'N,'D,'A', $e4,'A,'N,'D,'B'
  FCB $a5,'B,'I,'T,'A', $e5,'B,'I,'T,'B'
  FCB $a6,'L,'D,'A,' ', $e6,'L,'D,'B,' '
  FCB $a7,'S,'T,'A,' ', $e7,'S,'T,'B,' '
  FCB $a8,'E,'O,'R,'A', $e8,'E,'O,'R,'B'
  FCB $a9,'A,'D,'C,'A', $e9,'A,'D,'C,'B'
  FCB $aa,'O,'R,'A,' ', $ea,'O,'R,'B,' '
  FCB $ab,'A,'D,'D,'A', $eb,'A,'D,'D,'B'
  FCB $ac,'C,'M,'P,'X', $ec,'L,'D,'D,' '
  FCB $ad,'J,'S,'R,' ', $ed,'S,'T,'D,' '
  FCB $ae,'L,'D,'X,' ', $ee,'L,'D,'U,' '
  FCB $af,'S,'T,'X,' ', $ef,'S,'T,'U,' '
* desassemblage type 6
  FCB $00,$06,$10
BRANCH
  FCB $20,'B,'R,'A,' ', $21,'B,'R,'N,' '
  FCB $22,'B,'H,'I,' ', $23,'B,'L,'S,' '
  FCB $24,'B,'H,'S,' ', $25,'B,'L,'O,' '
  FCB $26,'B,'N,'E,' ', $27,'B,'E,'Q,' '
  FCB $28,'B,'V,'C,' ', $29,'B,'V,'S,' '
  FCB $2a,'B,'P,'L,' ', $2b,'B,'M,'I,' '
  FCB $2c,'B,'G,'E,' ', $2d,'B,'L,'T,' '
  FCB $2e,'B,'G,'T,' ', $2f,'B,'L,'E,' '
* desassemblage type 7
  FCB $00,$07,$04
  FCB $34,'P,'S,'H,'S', $35,'P,'U,'L,'S'
  FCB $36,'P,'S,'H,'U', $37,'P,'U,'L,'U'
* desassemblage type 8
  FCB $00,$08,$02
  FCB $16,'L,'B,'R,'A', $17,'L,'B,'S,'R'
* desassemblage type 9
  FCB $00,$09,$01
  FCB $10,'P,'A,'G,'1'
* desassemblage type 10
  FCB $00,$0A,$01
  FCB $11,'P,'A,'G,'2'
* desassemblage type 11
  FCB $00,$0B,$02
  FCB $1f,'T,'F,'R,' ', $1e,'E,'X,'G,' '
* desassemblage type 12
  FCB $00,$0C,$01
  FCB $8d,'B,'S,'R,' '
* desassemblage type 13
  FCB $00,$0d,$01
  FCB $3f,'S,'W,'I,'1'
* fin de table
  FCB $ff,$ff
BADCOD
  FCC '??? '
* codes et libelles des instuctions a prefixe
COD10
  FCB $83,$8c,$8e,$ce
  FCB $93,$9c,$9e,$de,$9f,$df
  FCB $b3,$bc,$be,$fe,$bf,$ff
  FCB $a3,$ac,$ae,$ee,$af,$ef
LIB10  
  FCC 'CMPDCMPYLDY LDS '
  FCC 'CMPDCMPYLDY LDS STY STS '
  FCC 'CMPDCMPYLDY LDS STY STS '
  FCC 'CMPDCMPYLDY LDS STY STS '
LIB11
  FCC 'CMPUCMPS'
RPILE
  FCB $43,$c3,$c1,$c2,$44,$d0,$d8,$d9
  FCB $d5,$50,$c3
REXG
  FCB $c4,$d8,$d9,$d5,$d3,$50,$c3,$bf
  FCB $bf,$c1,$c2,$43,$c3,$44,$d0
RINDX  
  FCB $58,$59,$55,$53,$2c,$52,$ab,$2c
  FCB $52,$2b,$ab,$2c,$2d,$d2,$2c,$2d
  FCB $2d,$d2,$2c,$d2,$42,$2c,$d2,$41
  FCB $2c,$d2,$d2,$d2,$d2,$d2,$44,$2c
  FCB $d2,$d2,$d2,$d2,$d2
ECRAN0
  FCB $00,$1b,$42,$1b,$50,$1b,$60,$0c
  FCB $1b,$73,$1f,$46,$48,$44,$16,$42
  FCB $65,$73,$61,$73,$73,$65,$6d,$62
  FCB $6c,$65,$75,$72,$1f,$48,$48,$1b
  FCB $72,$44,$75,$6d,$70,$20,$65,$74
  FCB $20,$50,$61,$74,$63,$68,$1b,$45
  FCB $1f,$4b,$48,$1b,$70,$28,$63,$29
  FCB $20,$44,$61,$6e,$69,$65,$6c,$20
  FCB $43,$6f,$75,$6c,$6f,$6d,$20,$20
  FCB $2d,$20,$20,$31,$39,$38,$36,$1b
  FCB $47,$1f,$50,$4f,$56,$65,$72,$73
  FCB $69,$6f,$6e,$20,$34,$2e,$30,$1f
  FCB $58,$41,$20,$20,$20,$20,$20,$20
  FCB $20,$41,$70,$70,$75,$79,$65,$7a
  FCB $20,$73,$75,$72,$20,$75,$6e,$65
  FCB $20,$74,$6f,$75,$63,$68,$65,$20
  FCB $2e,$2e,$2e,$20,$20,$20,$20,$20
  FCB $20,$14,$04
ECRAN4  
  FCB $0c,$53,$48,$49,$46,$54,$28,$64
  FCB $75,$6d,$70,$29,$20,$42,$41,$53
  FCB $49,$43,$28,$64,$16,$42,$65,$73
  FCB $61,$29,$20,$43,$4e,$54,$28,$70
  FCB $61,$74,$63,$68,$29,$20,$53,$54
  FCB $4f,$50,$14
ECRAN5  
  FCB $1f,$20,$20,$1f,$12,$13,$1f,$57
  FCB $41,$04
ECRAN1
  FCB $1f,$12,$13,$1b,$42,$0c,$1b,$75
  FCB $1f,$22,$24,$1f,$12,$24,$0c,$18
  FCB $41,$64,$72,$65,$73,$73,$65,$3a
  FCB $1f,$58,$5e,$28,$46,$46,$46,$46
  FCB $3d,$46,$69,$6e,$29,$1f,$58,$4a
  FCB $11,$04
ECRAN3
  FCB $0a,$1f,$22,$24,$1f,$12,$24,$0c
  FCB $18,$3d,$3d,$3d,$3e,$1f,$58,$52
  FCB $28,$6e,$6f,$75,$76,$65,$6c,$6c
  FCB $65,$20,$76,$61,$6c,$65,$75,$72
  FCB $20,$68,$65,$78,$61,$29,$1f,$58
  FCB $46,$11,$04
ECRAN6
  FCB $1f,$20,$20,$1f,$12,$14,$1b,$74
  FCB $0c,$04
  
  END
Malheureusement, après assemblage, la taille du code généré est 2901 octets. Beaucoup plus que la place libre (1792 octets).

Le défi est donc de faire entrer ce code (ou un autre à peu près équivalent) dans l'espace imparti. Toutes les suggestions seront les bienvenues.
Daniel
L'obstacle augmente mon ardeur.

Avatar du membre
gilles
Messages : 1632
Enregistré le : 07 août 2008 13:44
Localisation : Nantes
Contact :

Re: Défi pour les programmeurs 6809

Message par gilles » 09 nov. 2015 10:41

En modifications très rapide:

supprime l'écran d'accueil ou limite au strict minimum (choix des couleurs, clear screen, affichage de 2 ou 3 char max).
Recompacte la table des MNEMO, chaque mnemo prend 1+4 octets mais dans la pratique tout est en majuscule donc cela tient dans 1+2 octets au lieu de 4 (4bits par char).

Daniel
Messages : 10827
Enregistré le : 01 mai 2007 18:30
Localisation : Vaucluse
Contact :

Re: Défi pour les programmeurs 6809

Message par Daniel » 09 nov. 2015 13:57

Pour les mnémos l'idée est bonne. On peut même aller plus loin en codant uniquement les caractères @, A, B, ......Y, Z, [, \, °, ^,_ sur 2 bits, ce qui réduit la table d'environ 360 octets. Il faudra seulement une dizaine d'octets de plus pour l'affichage, avec conversion de quelques caractères spéciaux pour obtenir l'espace, le 1 et le 2 (qui ne sont pas dans la plage $40-$5F).

La suppression de l'écran d'accueil permet d'économiser environ 120 octets.

Bilan : 2900 - 360 - 120 = 2420.
Reste à gagner : 628 octets.
Daniel
L'obstacle augmente mon ardeur.

__sam__
Messages : 4174
Enregistré le : 18 sept. 2010 12:08
Localisation : Brest et parfois les Flandres

Re: Défi pour les programmeurs 6809

Message par __sam__ » 09 nov. 2015 14:05

@Daniel tu ne peux pas encoder 26 lettres sur 2 bits. Il faut au minimum 5 bits/lettre.

Pour l'affichage en hexa d'un nombre entre 0 et 15 (dans le registre A) il y a un truc hyper compact:

Code : Tout sélectionner

ADDA   #$90  
DAA
ADCA   #$40
DAA
6 octets au lieu de 11 dans HEXA1. En outre dans HEXAA je ne comprends pas le "ANDCC #$FE" qui est inutile.

Autre truc:

Code : Tout sélectionner

PATCH1
  LEAY   LIGNE,PCR   pointeur Y en debut de ligne          
  TFR    U,D
  LBSR   HEXAD       affichage hexa de l'adresse
  LDA    #$20               
  STA    ,Y+                
  LDA    ,U                 
  LBSR   HEXAA       affichage octet hexa
  LDB    #$20               
  STB    ,Y+                
  BSR    ASCII       affichage octet ASCII
  LDB    #$04               
  STB    ,Y+         fin de chaine
  LEAY   LIGNE,PCR   pointeur Y en debut de ligne          
  TFR    Y,X                
  BSR    PRSTR              
  LEAX   ECRAN3,PCR  ecran de patch
  BSR    PRSTR       affichage      
  RTS       
Il y a un jeu entre X et Y que je trouve bizare. Pourquoi ne pas utiliser X depuis le début ? Par ailleurs le fameux CHR$(4) de fin de chaine me semble superflux. La convention C du chr$(0) en fin de chaine est infiniment mieux: pas de cmpb #4 ni de ldb #4/stb à faire: un simple clr pose la fin de chaine, et le test à chr$(0) se fait de façon implicite et ne necessite aucun opcode.

Mais bon ca ne fait pas gagner beaucoup tout ca. Il faut gagner 30% sur l'ensemble et loà on gagne 10% au pif.

Le gain sur la table des memonique ferait gagner plus, mais c'est pas facile: il ya 4 lettres. il faut 5 bits minimum par lettre, soit 20bits = 2.5octets. Au mieux, deux mnémoniques (10octets) peuvent tenir sur 7 octets. 30% de gain maxi dans la partie mnemonique.

En pratique, comme certains groupes n'ont pas un nombre paire de mnemoniques on ne peut pas gagner autant. Il faut juste utiliser le compactage de 3 lettres (15bits) dans 2 octets. Ainsi une entrée de 5 octets ne fera plus que 4. Gain: 20% exactement sur cette partie. C'est déjà ca.

Ensuite tu peux gagner de la place en retirant l'addressage relatif PCR: le code s'excute à des addresses fixes, non ? C'est plus rapide et compact en adressage absolu, et encore plus si tu peux utiliser DP.
Samuel.
A500 Vampire V2+, A1200(030@50mhz/fpu/64mb/cf 8go),
GVP530 (MMU/FPU) h.s., R-Pi, TO9, TO8D, TO8. New Teo 1.8.4 8)

Daniel
Messages : 10827
Enregistré le : 01 mai 2007 18:30
Localisation : Vaucluse
Contact :

Re: Défi pour les programmeurs 6809

Message par Daniel » 09 nov. 2015 14:45

__sam__ a écrit :@Daniel tu ne peux pas encoder 26 lettres sur 2 bits. Il faut au minimum 5 bits/lettre.
Je devais être mal réveillé. J'ai vu 2 colonnes et j'ai écrit 2 bits, alors que c'est 4 bits par colonne donc 5 bits pour 2 colonnes.
Donc on est loin du compte, le gain n'est pas suffisant. Faut-il continuer à chercher, où est-ce mission impossible ?

Il y a encore d'autres pistes pour optimiser, en particulier appeler des routines déjà existantes en ROM système ou en ROM Basic. Le programme étant destiné uniquement au MO5, on peut tolérer un appel direct.

Ou encore compresser le code. Rien n'interdit de le décompresser en RAM. Encore que c'est un peu embêtant car on risque alors d'écraser le programme que l'on veut analyser. Il faudrait au minimum pouvoir choisir la plage d'adresses utilisées.
Daniel
L'obstacle augmente mon ardeur.

__sam__
Messages : 4174
Enregistré le : 18 sept. 2010 12:08
Localisation : Brest et parfois les Flandres

Re: Défi pour les programmeurs 6809

Message par __sam__ » 09 nov. 2015 16:00

Idée pour la table. Si je comprends bien le code, une table est écrite comme ca:

Code : Tout sélectionner

<type de dessassemblage: 2 octets> <nb elements: 1 octet>
<opcode: 1 octet> <memo: 4 octets> ...
<sentinelle: $FFFFF>
1er truc: pourquoi ne pas mettre le label du type de dessasemblage (DES1 DES2 DES3) plutot que la version numérique 1 2 3 dans les ddeux premiers octets. On gagne toute la partie avec le calcul sur PC pour passer du numéro x à la routine DESx. Là la routine est immédiatement acessible.
2eme truc: utiliser $0000 en sentinelle de fin de table. Du coup on laissse tomber le couteux-en espace cmpy #$FFFF, et le simple LDY ,X++ suffit pour voir Y pointer sur la routine DESx et detecter la fin de tableau.
3eme truc: le meno peut être réduit à 2 octets: les 3 premiers chars du tableau sont encodés sur 5 bits représentnat A-Z. Ca marche parce que les 3 rpemier char des menmo sont A-Z sans blanc.. et le denire char est tel quel.

Avec ca on gagne pas mal de place déjà.
Samuel.
A500 Vampire V2+, A1200(030@50mhz/fpu/64mb/cf 8go),
GVP530 (MMU/FPU) h.s., R-Pi, TO9, TO8D, TO8. New Teo 1.8.4 8)

Avatar du membre
canal
Messages : 67
Enregistré le : 17 juil. 2015 00:15
Localisation : Paris
Contact :

Re: Défi pour les programmeurs 6809

Message par canal » 09 nov. 2015 16:11

Bon, ca va je me sens pas visé ... je ne fais que du 6805 :mrgreen: (pas 6809 donc !)

Il faut prendre le code octet par octet et l'optimiser ... regardes la fonction (en bleue) que j'ai fait la :
http://forum.system-cfg.com/viewtopic.php?t=6737 ... bon c du 6805 ... Le code se réécrit lui même... une prise de tête pour gagner 1 octet je crois.

1/ Dans ton code je vois :

Code : Tout sélectionner

  INCA                      
DES944
  DECA                      
  BEQ    DES945              
  LEAX   $04,X              
  BRA    DES944              
DES945
Le INCA suivi d'un DECA -2 sucres- déjà moi ca me fait tilter (a moins que c t pour éviter le 0 !).

Moi j'écris ça ainsi ... en évitant la boucle et je gagne 3 octets.

Code : Tout sélectionner

DES944
  LEAX   $04,X              ( X = X + 4)
  DECA                      
  BNE    DES944              
DES945
[Edit: J'ai considéré que A n'est jamais égal a zéro (ca a l'air juste...) mais si c pas le cas mon optimisation marchera pas ...]

2/ Au cas où ca marcherait pas :

Code : Tout sélectionner

DES948
  LDB    #$00 
Gagne 1 seul octet en faisant CLRB mais c'est 2 fois dans le code donc ca fait 2 octets :

Code : Tout sélectionner

DES948
  CLRB 
Reste encore : 628-3-2 = 623 bon ok ...

3/ Il y a aussi la table LIB10 qui a l'air bien redondante ... surement des octets a gagner la ...

Code : Tout sélectionner

LIB10  
  FCC 'CMPDCMPYLDY LDS '
  FCC 'CMPDCMPYLDY LDS STY STS '
  FCC 'CMPDCMPYLDY LDS STY STS '
  FCC 'CMPDCMPYLDY LDS STY STS '
Il faudrait arriver a n'avoir que ça :

Code : Tout sélectionner

LIB10  
  FCC 'CMPDCMPYLDY LDS STY STS '
Alex.
Modifié en dernier par canal le 09 nov. 2015 16:50, modifié 3 fois.
CP/M (Z80)

Avatar du membre
gilles
Messages : 1632
Enregistré le : 07 août 2008 13:44
Localisation : Nantes
Contact :

Re: Défi pour les programmeurs 6809

Message par gilles » 09 nov. 2015 16:28

effectivement je voulais mettre un peu trop d'info dans un quartet, toutes les lettres ne sont pas utilisées mais ce n'est pas suffisant pour rentrer il faut bien 5 bits donc on passe de 1+4 à 1+3 octets par mnemo sauf si on considère tous les bits à la suite mais le décodage devient complexe.

__sam__
Messages : 4174
Enregistré le : 18 sept. 2010 12:08
Localisation : Brest et parfois les Flandres

Re: Défi pour les programmeurs 6809

Message par __sam__ » 09 nov. 2015 18:03

Bon je sens qu'il y a moyen de gagner des octets avec toutes ces remarques.. mais est-ce que la frontière des 1.7ko est atteignable? (c'est toujours sur les derniers octets que ca coince)
Samuel.
A500 Vampire V2+, A1200(030@50mhz/fpu/64mb/cf 8go),
GVP530 (MMU/FPU) h.s., R-Pi, TO9, TO8D, TO8. New Teo 1.8.4 8)

Avatar du membre
Papy.G
Modérateur
Messages : 1770
Enregistré le : 10 juin 2014 13:40
Localisation : Haute-Garonne/Gers

Re: Défi pour les programmeurs 6809

Message par Papy.G » 09 nov. 2015 20:18

Toutes les mnémos utilisent-elles toutes les lettres de l'alphabet à toutes les positions, y'a peut-être moyen de gruger un peu avec un alphabet pas complet? :mrgreen:
Soyez exigeants, ne vous contentez pas de ce que l'on vous vend.
Demandez-en plus, ou faites-le vous-même.

Fool-DupleX
Messages : 1031
Enregistré le : 06 avr. 2009 12:07

Re: Défi pour les programmeurs 6809

Message par Fool-DupleX » 09 nov. 2015 21:13

La table des mnémoniques me semble réductible. Pourquoi avoir NEGA, NEGB et NEG par exemple, alors que le nibble de poids faible est toujours le même et que ce sont les bits de poids fort qui indiquent le registre. il serait peut-être plus efficace de tester les bits de poids fort durant le desassemblage et de rajouter espace, A ou B selon le cas.

Pour les strings, on peut gagner quelques misérables octets en supprimant même le $00 à la fin et en le remplacant par un bit 7 à 1 dans le dernier caractère de la chaine (astuce largement utilisée dans le basic de microsoft). Ca permet d'economiser aussi les LDB #$04 STB ,Y+ dans la production de chaines pendant le desassemblage. il suffit de mettre LDD #$0D8A par exemple.

Je me pose aussi des questions sur l'utilité du buffer de ligne à afficher.

Edit: on pourrait aussi avoir une longue string genre "ASLROLNEGCMP..." et remplacer chaque occurrence de NEG etc. dans la table de mneno par un index : 0 pour ASL, 1 pour ROL etc. On passe de 3 a 1 octet pour toutes les occurences dans la table. En utilisant l'astuce du bit 7 à 1 pour indiquer la fin de la mnemo, on peut coller toutes les mnemo quelle que soit leur taille a la suite les unes des autres : ASLROLNEGCMPLDSTSWIANDOR...

Daniel
Messages : 10827
Enregistré le : 01 mai 2007 18:30
Localisation : Vaucluse
Contact :

Re: Défi pour les programmeurs 6809

Message par Daniel » 09 nov. 2015 22:07

J'ai commencé l'optimisation en tenant compte de vos remarques : abandon du code translatable, remplacement des numéros de tables par l'adresse de la routine de traitement, amélioration de détails, suppression d'instructions inutiles... Pour l'instant, sans toucher à la table des mnémoniques et aux écrans, le code est à 2809 octets. Environ 100 octets gagnés, mais il en reste 1027 en trop.

Les mnémoniques font environ 1300 octets, plus environ 330 pour les écrans, mais ne sont probablement pas compressibles à plus de 50%. Ca s'annonce difficile. L'utilisation d'un bit 7 à un pour marquer la fin d'une chaine ou d'un mnémonique est un bon plan, mais j'ai peur que ce soit insuffisant.
Daniel
L'obstacle augmente mon ardeur.

Avatar du membre
jb_jb_fr
Messages : 300
Enregistré le : 29 mars 2010 10:36
Localisation : Essonne (91)
Contact :

Re: Défi pour les programmeurs 6809

Message par jb_jb_fr » 09 nov. 2015 22:31

Quelques autres petites optimisation
remplacer :

Code : Tout sélectionner

      LDA    #$20
      STA    ,Y+         blanc apres l'adresse
      LDB    #$08        compteur de boucle
par

Code : Tout sélectionner

      LDD    #$2008
      STA    ,Y+         blanc apres l'adresse
et

Code : Tout sélectionner

      LDB    #$20               
      STB    ,Y+               
      LDB    #$07               
    DUMP2
par

Code : Tout sélectionner

      LDD    #$2007               
      STA    ,Y+               
    DUMP2
Tout comme:

Code : Tout sélectionner

      LEAY   LIGNE,PCR   pointeur Y en debut de ligne         
      TFR    Y,X               
      BSR    PRSTR             
Je ne comprends pas pourquoi prendre Y?

Code : Tout sélectionner

      LEAX   LIGNE,PCR   pointeur Y en debut de ligne         
      BSR    PRSTR             
est plus simple non?

Y'en a surement pleins d'autre du genre

Jacques

Notator
Messages : 435
Enregistré le : 09 août 2015 20:13
Localisation : Lyon

Re: Défi pour les programmeurs 6809

Message par Notator » 09 nov. 2015 22:54

Je ne pense pas qu'il soit possible de réduire l'encombrement de 30%, surtout un programme de 'traduction' de code, tel qu'un désassembleur.

Une solution, serait d'utiliser un système de mémoire paginée, et doubler ainsi la mémoire dispo.

En mettant à l'emplacement un petit circuit 'en impériale', supportant une 2764, et probablement deux chips de portes logiques, pour réaffecter l'adressage, avec de plus deux fils pour ramener et renvoyer une ligne supplémentaire d'adresse.

Le principe est simple : le 'surplus' de mémoire (32 Ko) nécessaire vient se substituer à une zone mémoire déjà occupée (par exemple, celle contenant le Basic). Un sélecteur (une porte nand, par exemple) vient sélectionner l'adressage de l'une ou l'autre zone selon le besoin.
En usage courant, le sélecteur déjà cité est automatiquement (par le jeu de son alimentation électrique) positionné sur la mémoire native.
Dès qu'on lance le programme de désassemblage (qui démarre dans la zone mémoire accessible en permanence), une de ses premières tâches est de sélectionner une adresse mémoire de zone permanente, dont le décodage (avec des portes) va être mémorisé (par une bascule D, par exemple) et faire basculer le sélecteur pour valider la zone supplémentaire, et gardera cette sélection tant qu'on ne sort pas du programme désassembleur (on rebasculera en natif juste avant de quitter le programme).

Pratiquement, la ligne d'adresse correspondant au bit de poids fort de la 2764 est coupée vers le processeur, avant la distribution de l'adressage mémoire, et ramenée sur la carte, sur le sélecteur, puis, du côté sélection mémoire native, renvoyé sur la distribution mémoire (ce cas de figure rend le fonctionnement identique à celui d'origine). Le côté mémoire additive, lui, sélectionne l'une des deux moitiés de la 2764 (peu importe laquelle, à condition d'en tenir compte dans l'adressage du programme) ; l'autre moitié occupe en permanence la zone mémoire disponible à l'origine.

Daniel
Messages : 10827
Enregistré le : 01 mai 2007 18:30
Localisation : Vaucluse
Contact :

Re: Défi pour les programmeurs 6809

Message par Daniel » 10 nov. 2015 08:35

Oui, cette technique permet d'augmenter la taille mémoire disponible. Elle est d'ailleurs utilisée par Thomson dans le contrôleur CD90-351, les cartouches MEMO5 de Colorpaint, LSEG et Jane, l'extension mémoire 64K. Et elle a été généralisée dans les machines de dernière génération, aussi bien pour la RAM que pour la ROM. Mais le défi, ici, est purement logiciel : faire tenir ce programme ou un programme équivalent dans les 1792 octets impartis.

Je continue à gagner quelques octets en appliquant vos idées d'optimisation. Toutes ne sont pas utilisables : par exemple X est un index sur l'octet en cours et Y un index sur le début de la ligne. Les deux registres doivent être initialisés avec l'adresse du début de ligne, on ne peut pas se passer de Y.

C'est à chaque fois quelques octets gagnés, mais je doute d'arriver à la bonne taille sans une refonte complète du code, voire même du principe de recherche des mnémoniques. Plutôt que de parcourir toute la table pour trouver le code de l'instruction, il vaudrait mieux analyser les bits de ce code et faire un accès direct au libellé d'une part, à la routine de traitement d'autre part. C'est d'ailleurs un peu l'idée suggérée par FoolDupleX lorsqu'il parle des bits de poids faible et de poids fort du code opération.

Une petite précision : dans ce programme je n'ai écrit que l'interface utilisateur. Le désassembleur vient de la revue Microtom. Si je l'avais écrit moi-même il serait beaucoup mieux optimisé :wink:
Daniel
L'obstacle augmente mon ardeur.

Répondre