Self Modifiyng Code - Page 1

Bon sa m'enerve, je comprend tres bien le principe du SMC, mais j'arrive pas a trouver comment l'appliquer...

Si quelqu'un a un (ou plusieurs) exemple (simple?) a donner sa serait sympa...

Ba la source de tigcclib par exemple (dans gray.s).

trop complexe


Je prefererait un exemple qui tienne sur quelques lignes (20/30 Max) Gray.s est trop "complexe"

Je vais te découper les parties qui t'intéressent comme ça tu comprendras .

merci

Un exemple bête, mais qui te permettra peut-être de comprendre :

; Affiche un pixel en mode OR ou XOR
; d0.w=x d1.w=y d2.w=mode a0.l=dest
PutPix:
 lea.l \Instr(pc),a1
 tst.w d2
 beq.s \ModeXOR
  move.w #%0000000111110000,(a1) ; bset d0,(a0,d1.w)
  bra.s \ModeOK:
\ModeXOR:
  move.w #%0000000101110000,(a1) ; bchg d0,(a0,d1.w)
\ModeOK:
 add.w d1,d1
 move.w d1,d2
 lsl.w #4,d1
 sub.w d2,d1
 move.w d0,d2
 lsr.w #3,d2
 add.w d2,d1
 not.w d0
\Instr:
 dc.w 0
 dc.w %0001000000000000 ; pour le mode d'adressage indirect indexé avec déplacement
 rts

Je n'ai pas testé, donc je ne garantis pas le fonctionnement

Bon, si on prends la fonction __gray_int1_handler_hw2:

__gray_int1_handler_hw2:
	move.w   %sr,-(%a7)                | save content of status register on stack
	move.w   #0x2700,%sr               | disable ALL interrupts (no one should
	                                   | interrupt us ...)
	movem.l  %d0-%d7/%a0-%a6,-(%a7)

---- traîtement de l'interruption ---

__gray_to_oldint:
	movem.l  (%a7)+,%d0-%d7/%a0-%a6
	move.w   (%a7)+,%sr                 | restore content of status register
    |--------------------------------------------------------------------------
    |  JUMP to previous installed interrupt handler
    |--------------------------------------------------------------------------
	.word    0x4ef9                     | opcode of "JMP address" instruction
__gray_old_int1_hw2:
	.long    0x00000000

et dans __gray_int_handler on peut voir ça:
move.l 0x64,(__gray_old_int1_hw2 - __gray_int1_handler_hw2,%a0)
ça initialise __gray_old_int1_hw2 pour que la routine de l'interruption fasse un saut direct à l'ancienne routine d'interruption.

Oui mais tu n'a pas au final le meme nombre de cycle que si tu fait :
(j'ai changé d3 pour pas détruire d2. sa utilise un registre de plus certe...

; Affiche un pixel en mode OR ou XOR
; d0.w=x d1.w=y d2.w=mode a0.l=dest
PutPix:
 lea.l \Instr(pc),a1
 add.w d1,d1
 move.w d1,d3
 lsl.w #4,d1
 sub.w d3,d1
 move.w d0,d3
 lsr.w #3,d3
 add.w d3,d1
 not.w d0

 tst.w d2
 beq.s \ModeXOR
  bset d0,(a1,d1.w)
  bra.s \ModeOK:
\ModeXOR:
 bchg d0,(a1,d1.w)
\ModeOK:

 rts

Le SMC permet souvent de gagner de la place plutôt que de la vitesse.

[edit] au fait, j'avais fait une erreur dans mon code.

.word    0x4ef9                     | opcode of "JMP address" instruction
__gray_old_int1_hw2:
	.long    0x00000000

Perso se genre de chose j'ai deja utilisé, mais si tu a par ex

move.l (a0), __gray_old_int1_hw2

je prefere utilise directement

jmp (a0)

JE pense pas que sa soit bien plus lent non ?

./9>Heuh, mais dans les niveaux de gris ça gagne de la vitesse (très peu) et de la place, je crois.

Oui ok c'est surtout pour gagner de la place donc

Pas du tout (même si effectivement mieux vaudrait stocker toutes les combinaisons dans le code, mais ça croît de manière exponentielle).

Par exemple, tu peux très bien faire :

Remplir_mémoire_avec_symétrique_par_rapport_à_valeur_divisée_par_shift:
  move.b d0,\patch_moveq+1
  subq.w #1,d1
  bcs \fin
\loop
\patch_moveq
  moveq #0,d0
  sub.b (a0),d0
  lsr.b d2,d0
  move.b d0,(a0)+
  dbf d1,\loop
\fin
  rts

et là tu gagnes un registre sans perdre un cycle dans ta boucle...

heu pkoi mettre sub.b? il me semble pas que l'on ait un gain de vitesse non?

J'ai bien le droit d'utiliser des 'char' non? Parce que sinon à l'entrée d0 pourrait ne pas être un char => pas cool... Euh d'ailleurs j'avais oublié de stocker la valeur calculée => EDIT

move.b (a0),d0 c'est plus parlant pour moi

Alors ré-écrit ce qu'il y a au-dessus avec ta méthode, j'attends de voir

boulette

je préfère ça

Un autre exemple plutôt simple à comprendre:

clr_buffer
	moveq.l	#0,d0
	move.l	d0,d1
	move.l	d1,d2
	move.l	d2,d3
	move.l	d3,d4
	move.l	d4,d5
	move.l	d5,d6
	move.l	d6,d7
	move.l	d7,a1
	move.l	a1,a2
	move.l	a2,a3
	move.l	a3,a4
	move.l	a4,a5
	move.l	a5,a6
	movem.l	d0-d7/a1-a6,(a0)		;56 bytes
	movem.l	d0-d7/a1-a6,56(a0)
	movem.l	d0-d7/a1-a6,112(a0)
	movem.l	d0-d7/a1-a6,168(a0)
	movem.l	d0-d7/a1-a6,224(a0)
	movem.l	d0-d7/a1-a6,280(a0)
	movem.l	d0-d7/a1-a6,336(a0)
	movem.l	d0-d7/a1-a6,392(a0)
	movem.l	d0-d7/a1-a6,448(a0)
	movem.l	d0-d7/a1-a6,504(a0)
	movem.l	d0-d7/a1-a6,560(a0)
	movem.l	d0-d7/a1-a6,616(a0)
	movem.l	d0-d7/a1-a6,672(a0)
	movem.l	d0-d7/a1-a6,728(a0)
	movem.l	d0-d7/a1-a6,784(a0)
	movem.l	d0-d7/a1-a6,840(a0)
	movem.l	d0-d7/a1-a6,896(a0)
	movem.l	d0-d7/a1-a6,952(a0)
	movem.l	d0-d7/a1-a6,1008(a0)
	movem.l	d0-d7/a1-a6,1064(a0)
	movem.l	d0-d7/a1-a6,1120(a0)
                [...]

A la base, c'est une routine d'effacement de buffer, mais en faisant move.b #val,clr_buffer+1 avant l'appel à la routine, tu peux remplir le buffer avec le pattern que tu veux.
En fait, l'instruction moveq.l fait 2 octets, le premier indiquant quel registre de donnée sera la destination, et le deuxième la donnée immédiate à placer.

mouais
Sauf qu'on peut très bien enlever le moveq #0,d0 et utiliser le pattern comme entrée pour la fonction donc ça ne montre pas l'intérêt du SMC mais juste un exemple.

#19 tu est hors sujet je croit

Il n' s'agit pas de SMC...

Pollux> intéressante, ton idée ./13 je n'y avais jamais pensé.

ce serait trop compliquer d'expliquer le fonctionnement du smc rapidement ("flemme" de faire une recherche pour trouver un tuto en anglais que je comprendrait pas) ??

Tout simplement tu changes le code avec du code

Un autre exemple plus facile à visualiser :

; Patche la fonction
; in : d0.w=mode
Patch:
 add.w d0,d0 ; d0=d0*2 (parce qu'une instruction prend 2 octets)
 lea.l TabModes(pc),a0
 adda.w d0,a0
 move.w (a0),d0 ; d0 contient l'instruction (oui, les 3 dernières lignes se résument
;                 à un move.w TabModes(pc,d0.w),d0 mais je détaille)
 
 move.w d0,ApplyPatch ; on écrit l'instruction à l'adresse ApplyPatch
 rts
 
TabModes:
 bclr.b d0,(a0)
 bset.b d0,(a0)
 bchg.b d0,(a0)

mais ca consiste juste à modifier les constantes des instructions ou remplacer une instructiopn par une autre peu differente (or/xor) ou ya des utilisation bien plus complexes ?

On peut faire tout ce qu'on veut avec! On peut même compiler du code sur demande de l'utilisateur et l'exécuter immédiatement.

on peu aussi gagner de la place etc.. mais bon c'est quand meme pas tres utiliser comme methode
(j'aime les chiens et vous ?)

En fait, il s'agit juste de modifier un programme au lieu d'une variable ???


yAro>t'aurais quand même put éviter de rajouter "(j'aime les chiens et vous ?)" à TOUS les dernier posts de JS