Questions ASM

15 sujets de 1 à 15 (sur un total de 50)

bombseb
22 juin 2014 à 13h03 #213443
Bonjour,

Je suis en train de me mettre à l’ASM 68k avec ASMOne sur un émulateur…
J’aurais une petite question :

Qu’elle est la différence entre ces deux instructions :

move.w toto,a0
move.w (toto),a1

quand je lance mon prog les registres a0 et a1 ont la même valeur…. (j’ai mi toto dc.b $44 un peu plus bas)

autre question :
move.l 4.w,a6 ; Get base of exec lib

A quoi sert le « .w » sur cette ligne svp ?

Encore une autre question, quand j’assemble mon prog avec « a » et que je le lance avec « j », si je veux le relancer une deuxième fois je suis obligé de le réassembler sinon il ne se lance pas (il m’affiche juste le contenu des registres)… comment ca se fait ?

Et une dernière question pour la route et je vous laisse tranquille :o)
Je ne comprend pas trop comment utiliser le debugger, est-ce que quelqu’un pourrais m’expliquer vite fait svp ? Comment mettre un point d’arrêt et faire du pas à pas… La doc n’est pas très explicite je trouve

Merci d’avance pour votre aide
Foul
22 juin 2014 à 14h00 #213446
pleins d’exemples ici :

http://obligement.free.fr/programmation.php
http://www.gurumed.net/index.php/Initiation_%C3%A0_l%27Assembleur_680X0

et surtout les supers tuto/vidéos de Photon/Scoopex :

🙂
bombseb
22 juin 2014 à 14h19 #213447
Salut,

Oui je connais c’est trois liens qui sont vachement bien d’ailleurs mais je n’ai pas trouvé de réponse à mes questions dans ces sites justement…
Anonyme
22 juin 2014 à 14h27 #213448
move.w a0,d0 -> copie le contenu de a0 dans d0
move.w (a0),d0 -> copie le contenu situé à l’adresse mémoire a0 dans d0

ça ne devrait pas, théoriquement, te donner le même résultat (sauf coïncidence).

Attention, en principe, les registre a0-a7 dont utilisés pour stocker des adresses mémoires. Les registres d0-d7 servent eux à stocker des données.
L’architecture du 68000 est tolérante, mais en fonction des instructions tu as des spécificités qu’il faut étudier. Un bon manuel de 68000 (papier ou online) te seras sans doute utile.

—-

Pour ton autre question :
move.l 4.w,a6

Le .w signifie qu’on ne prends que les 16 premiers bits de la valeur « 4 » pour les copier en 32 bits dans le registre a6.

—-

Je suppose qu’on doit réassembler avant chaque execution afin de remettre à zéro toutes les data utilisateurs de ton programme (variables & autres).

—-

Pour le debugger, je passe … pas une grande expérience du debugger d’Asmone.
Mais en gros, si tu sais ce qu’est un breakpoint et du step by step, tu as déjà fait 80% du chemin :p

Bon courage!!!
bombseb
22 juin 2014 à 14h36 #213450
move.w a0,d0 -> copie le contenu de a0 dans d0
move.w (a0),d0 -> copie le contenu situé à l’adresse mémoire a0 dans d0

Oui pour ca je sais bien mais dans mon exemple c’était un label que j’utilisais :

move.w toto,a0
move.w (toto),a1
toto dc.b $44
-> ici, a0 et a1 ont la même valeur, comment ca se fait ? (j’aurais du utiliser plutôt d0 et d1 mais bon)

Pour ton autre question :
move.l 4.w,a6

Le .w signifie qu’on ne prends que les 16 premiers bits de la valeur « 4? pour les copier en 32 bits dans le registre a6.

bizarre, pourquoi on n’utilise pas plutôt move.w 4,a6 alors ? ca reviendrais à la même chose non ? Je ne comprend pas l’interêt de la chose…
lexomil
22 juin 2014 à 14h45 #213453
Bonjour,

dans ton cas c’est normal, les deux instructions sont semblables, tu demande a copier le mot (.w) contenu à l’adresse toto dans les registre a0 et a1.
ça ne serait pas le cas si tu faisais

lea toto,a2
move.w a2,a0
move.w (a2),a0

là tu tomberais dans le cas décrit par astrofra

remarque en passant, tu défini ta variable par un dc.b donc un byte et tu transfert un mot vers les registres, tu va donc te récupérer ton $44 et autre chose derrière (chose non définie).

j’ai pas plus d’idée pour asm one, j’utilise Devpac de mon coté.

Bonne journée
bombseb
22 juin 2014 à 14h54 #213454
Ok merci alors j’ai compris… donc c’est bien la même chose…

remarque en passant, tu défini ta variable par un dc.b donc un byte et tu transfert un mot vers les registres, tu va donc te récupérer ton $44 et autre chose derrière (chose non définie).

Oui c’est vrai, mais bon c’était juste un test vite fait…

Une autre question au passage, l’instruction lea (load effective adress) permet ici (lea toto,a2) de mettre l’adresse de toto dans a2.
qu’elle est la différence avec un move.l #toto, a2 ?
Apparement ca me ramènne la même chose…
modulo
22 juin 2014 à 15h49 #213460
oui lea toto et move.l #toto, c’est la même chose.

le # avant le symbole sert à préciser qu’on veut l’adresse et non pas le contenu.

Je pense qu’il vaut mieux utiliser lea car c’est plus explicite et plus spécialisé (donc plus rapide) qu’un move. À confirmer avec une table d’opcode qui donne les cycles d’horloge par instruction (j’avoue que j’ai pas ça sous la main).

Pour l’anecdote, sur 386/486, on faisait certaines multiplications avec lea, car on pouvait passer un index et une puissance qui couvraient pas mal de multiplicateurs. Le tout en un seul cycle (une mul, ça coûtait cher à l’époque).

Mon Dieu, je suis tout rouillé en assembleur… je ne fais plus que du C, du C++ et du Lua.
bombseb
22 juin 2014 à 15h54 #213461
ah okok merci pour la précision ca ne m’étonne qu’a moitié…
Anonyme
22 juin 2014 à 15h55 #213462
Du Lua ?
Dans quel contexte, modulo ? ça m’intéresse 🙂
modulo
22 juin 2014 à 16h44 #213466
Ah Lua, je pourrais en parler des heures 🙂

Je l’utilise dans beaucoup de situations, mais notamment:

– pour faire des interfaces avec des bibliothèques en C, que j’appelle ensuite depuis un script Lua. Quand le wrapper est direct, on peut même utiliser la lib FFI du projet LuaJIT (le compilo just-in-time qui fait rougir javascript V8).

Interfacer avec les bibliothèques me permet de faire du prototypage, des tests unitaires de mes libs, voire même d’écrire une appli complète.

– pour lire des fichiers à utiliser avec du C. Parser des tokens en C, c’est très pénible et sujet à erreurs. Note que depuis que je fais davantage de C++, l’intérêt de lire un fichier en Lua s’estompe un peu devant les streams et les regex intégrés à la libstdc++. Même si c’est plus pratique et plus lisible en Lua, il y a quand même des inconvénients: notamment le fait d’être obligé de maintenir une table d’index parallèle, pour ordonner les clés (chaque ligne du fichier part dans une table, mais à part utiliser des index, pas moyen de garder l’ordre si on veut utiliser les clés).

– pour faire de l’administration système. Là, c’est un Lua uniquement avec LFS (Lua File System) et LuaSocket. Par exemple, je surveille des fichiers et je reçois des rapports par mail. Ou encore, de la génération à la demande de rêgles iptables, selon des séquences reçues sur les interfaces. De façon générale, et avec un module luaposix (en plus des modules cités auparavant), Lua remplace fort avantageusement le shell, sans tout ses inconvénients (notamment les séquences d’échappement pour les chaines, Lua traitant tous les caractères de façon égalitaire avec la paire délimitante [[ … ]] )

– j’ai aussi un serveur web écrit en Lua, pour traiter les données utilisateurs et servir des pages web. J’ai un serveur web en frontal qui ne fait que transmettre les requêtes. Ici également, tout est 100% Lua (de mon côté, car j’utilise LuaFCGI qui est une lib partiellement en C, pour implémenter le FCGI).

Mes champs d’application sont l’administration système, la gestion commerciale et … le jeu video 🙂

J’aime beaucoup la simplicité biblique du langage qui n’exclue pas une belle conception (coroutines, fonctions lambda, interfaçage C aisé et puissant avec les userdata et la gestion par pile, closures ! …). En plus c’est extrèmement rapide (et pour ceux qui en veulent plus, il y a LuaJIT).

Pour être honnête dans ce concert de louange, je dirais qu’il manque deux choses à Lua:

Une séparation index/hash dans les tables (partiellement résolu avec les metatables, mais c’est pas ça quand même).

De vrais thread (les coroutines, c’est du multitache coopératif). Bon là, c’est un problème de conception insoluble, et avec des threads, Lua ne serait plus Lua. J’ai déjà fait des tests d’intégrations de thread avec Lua, en bidouillant, mais ça ne marche pas très fort et si ça peut passer «en test», ça n’ira pas dans un vrai environnement où le temps de réaction est critique. Je me souviens que j’avais dû d’ailleurs un peu modifier la lib lua pour faire ça, donc pas très conseillé !

Voila 🙂
Anonyme
22 juin 2014 à 17h16 #213469
Ah, pas mal.
Le Lua te sert de c-shell, en fait.
Pour ton binding C/Lua, tu fais comment ? bindé à la pogne, ou avec un outil ?

L’été dernier j’ai présenté une démo à la Evoke, qui est intégralement scriptée en Squirrel sur un moteur 3D C++ fait par un pote :
http://www.pouet.net/prod.php?which=61730

Tu fais du Lua sur quelle plateforme ?

(désolé bombseb pour le hijack de topic :))
bombseb
22 juin 2014 à 17h24 #213470
Pas de soucis :o)
bombseb
22 juin 2014 à 20h54 #213481
Me voilà de retour…
Je suis en train d’éssayer de comprendre la programmation du copper…
J’ai à peut près compris le principe des instructions WAIT, MOVE et SKIP, mais je ne trouve pas de site qui explique clairement les lignes du label cop: (voir ci dessous)

Apparement cette ligne :
[code]dc.w $008e,$1a64,$0090,$ffc4 ; Setting up [/code]

Sert à affecter une position et une taille à l’écran graphique, mais je ne comprend pas comment sont formées ces valeurs, est-ce que quelqu’un pourrait m’expliquer svp ?

[code]cop: dc.w $0106,$0000,$01fc,$0000 ; AGA compatible
dc.w $008e,$1a64,$0090,$ffc4 ; Setting up display,
dc.w $0092,$0038,$0094,$00d0 ; modulo and so on
dc.w $0102,$0000,$0104,$0000
dc.w $0106,$0000,$0108,$0000
dc.w $0120,$0000,$0122,$0000 ; Clear spriteptrs
dc.w $0124,$0000,$0126,$0000
dc.w $0128,$0000,$012a,$0000
dc.w $012c,$0000,$012e,$0000
dc.w $0130,$0000,$0132,$0000
dc.w $0134,$0000,$0136,$0000
dc.w $0138,$0000,$013a,$0000
dc.w $013c,$0000,$013e,$0000
dc.w $0100,$1200 ; 1 Bitplane
bplptr: dc.w $00e0,$0000 ; Adress of bpl
dc.w $00e2,$0000
dc.w $0180,$0000 ; Color00 = black
dc.w $0182,$0fff ; Color01 = white
dc.w $ffff,$fffe[/code]
bombseb
22 juin 2014 à 20h56 #213484
A partir de bplptr j’ai compris…Mais c’est qu’il y a au dessus que je ne comprend pas…