ecrire une routine assembleur dans un code source C

ecrire une routine assembleur dans un code source C - Programmation

Marsh Posté le 19-10-2001 à 16:02:11    

la routine assembleur doit pouvoir gerer des variable avec les fonctions DB,DW.., les E/S, les interruptions du style
asm
{
int10 equ 10h
mov ax,13h
int int10
}

Reply

Marsh Posté le 19-10-2001 à 16:02:11   

Reply

Marsh Posté le 19-10-2001 à 16:45:53    

heu, qu'est tu veux exactement ????
 
l'assembleur en ligne est différent dans chaque compilateur (borland/watcom/microsoft......)

Reply

Marsh Posté le 19-10-2001 à 16:58:33    

heu, qu'est tu veux exactement ????  
 
l'assembleur en ligne est différent dans chaque compilateur (borland/watcom/microsoft......)  
 
c vrai, j'utilise  à l'école BORLAND C++ 5.02 et g voudrais créer des routines graphique en assmbleur mais g ne connais pas la syntaxe k'il faut employer.
 
merci de me repondre....

Reply

Marsh Posté le 19-10-2001 à 17:05:36    

un truc du style:
 
int yop(int zorg, int zirg)
{
 int r;
 __asm {
  mov eax,zorg
  xor eax,zirg
  cmp eax,-1
  jne yop
  mov r,eax
  jmp zlick
 }
yop:
 __asm {
  dec eax
  mov r,eax
 }
 
zlick:
 return r;
}
 
sous borland, c'est "asm" tout court, mais tu devais le savoir :D
 
qu'est ce tu veux, savoir interfaçer l'assembleur, ou connaitre les services du bios pour pouvoir faire mumuse ? tu parles du C++ sous DOS, ou du C++ builder sous windows ?

Reply

Marsh Posté le 19-10-2001 à 17:16:49    

en fait g debute en c++, et g l'utilise sous windows mais le compilateur crée une fenetre DOS pour excuter le prog. je connais sinon bien l'assembleur et ses possibilités et j'aimerais tout simplement inclure du code.
 
la syntaxe du c me dit ke c
 
asm
{  
...
}
 
mais ca marche pas quand je fais
asm
{
a db 10h
}
 
il me met unknow assembler instruction ?????
 
merci..

Reply

Marsh Posté le 19-10-2001 à 17:43:14    

le db, tu n'as pas droit, les allocations de variables se font C, seul du code asm peut être déclaré...
 
 
char a=0x010;
asm {
 mov al,a
}
 
idem, tout doit être en synthaxe C, donc:
asm mov al,0x0ff;
et pas  
asm mov al,ffh;
 
attention aussi, toujours :
 
asm {
...
}
 
pas :
 
asm
{
...
}
 
les EQU passent pas, idem, fo #define, car même le code asm va passer par le préprocesseur........

Reply

Marsh Posté le 19-10-2001 à 17:59:08    

GRAND MERCI MAITRE - TU M'EVITES QUELQUES HEURES PASSEES DEVANT L'ORDI...
 
aurais tu du code source comme exemple à m'envoyer stp ..
et pour les E/S command ca marche ?
et pour charger l'offset d'une variable ca doit etre
 
char a=0x010;
asm {
mov ax,[a]
}
 
non ?

Reply

Marsh Posté le 19-10-2001 à 18:25:48    

sais plus !!!!!!!!!
 
je viens de faire des essais:
 
#include<stdio.h>
 
main()
{
  int a=0x0AB;
  int *b=&a;
  int c,d;
 
  __asm {
        mov eax,[a]
        mov ebx,b
        mov c,eax
        mov d,ebx
  }
  printf("%x, %x\n",c,d);
}
 
et là il ça me sort  
ab, 12ff7c
 
donc non, le mov (e)ax,[a] ne te donne pos l'offset (logique même en asm pure), mais le compilateur (celui de visual studio), ne veut pas d'un:
 
mov eax, offset a
 
ou  
 
mov eax,&a
 
là, je sais po, je me souviens que je contournais généralement le pb via un pointeur en amont en C, et je fesais surtout carrément des fonctions en ASM (dans .ASM), pis je liais le tout avec le C (pas d'asm en ligne pour mes routines critiques, tu perds du temps si le passage des paramètres et le retour créent des intructions à la con).......

Reply

Marsh Posté le 19-10-2001 à 19:13:02    

slt,
 
j'ai rapidement récupé un vieux truc franchment je n'ai pas vérifié s'il marchait  
 
void Rabit_Modulo_un(fft_code *val,tip x)
//-------------------------------------
//  retourne le reste de (a*b)/modulo
//  le signe est pris en compte
//------------------------------------
{
    _EDX = *(val+x);
    _EAX = *val;
    asm push      eax;
   asm sub     eax,edx;
    asm sbb       ecx,ecx;
    asm and       ecx,dword ptr [_MODUL];
    asm add       eax,ecx;
 
    *(val+x) = _EAX;
// asm mov       dword ptr [ebx+4*edi],eax;
    asm pop       eax;
    asm mov       ecx,dword ptr [_MODUL];
    asm sub       ecx,edx;
    asm sub       eax,ecx;
    asm sbb       ecx,ecx;
    asm and       ecx,dword ptr [_MODUL];
    asm add       eax,ecx;
 
    *val= _EAX;
}
 
ecrit sous builder 3.0, parceque je crois que la version 5.02 a des problèmes avec les _EAX, ... (enfin registre 32 bits). Je sais plus, c'est loin ... pffff ;)
 
 
c'est cencé correspondre au code ci-dessous mais la verison ASM est lourdement optimisé. les codes de test ont été judicieusement remplacés.
 
    unsigned long   a,
                    b;
    a = *(val+x);
    b = MODUL - a;
 
//--------  Cas : c = a - ret
    if(a > *val)
        *(val+x) = b + *val;
    else
        *(val+x) = *val - a;
 
 
//--------  Cas : c = a + ret
    if(*val >= b)
        *val -= b;
    else
        *val += a;

 

[edtdd]--Message édité par Barbarella--[/edtdd]

Reply

Marsh Posté le 20-10-2001 à 12:14:36    

tien voila aussi du code que j'avais fait avec C++ Builder
 

Code :
  1. //---------------------------------------------------------------------------
  2. // multiplication de matrices : matrices de taille 4x4 exclusivement
  3. // Code assembleur optimisé : dépendances entre les operations
  4. void Asm_Multiplication_de_matrice(/*double* matrice,double* matrice_,double* resultat_*/) {
  5. // [ A B C D ]   [ Q ]                [ U ]
  6. // [ E F G H ]   [ R ]                [ V ]
  7. // [ I J K L ] * [ S ], quatre fois = [ W ]
  8. // [ M N O P ]   [ T ]                [ X ]
  9. // matrice * chaque colonne de la matrice matrice_ = resultat_
  10.   asm {
  11.    // colonne 1 de la matrice résultat
  12.     fld     [matrice_ +   0] // Q
  13.     fmul    [matrice  +   0] // A
  14.     fld     [matrice_ +   0] // Q
  15.     fmul    [matrice  +  32] // E
  16.     fld     [matrice_ +   0] // Q
  17.     fmul    [matrice  +  64] // I
  18.     fld     [matrice_ +   0] // Q
  19.     fmul    [matrice  +  96] // M
  20.     fld     [matrice_ +  32] // R
  21.     fmul    [matrice  +   8] // B
  22.     fld     [matrice_ +  32] // R
  23.     fmul    [matrice  +  40] // F
  24.     fld     [matrice_ +  32] // R
  25.     fmul    [matrice  +  72] // J
  26.     fld     [matrice_ +  32] // R
  27.     fmul    [matrice  + 104] // N
  28.     fxch    st(3)            // 4° <->  1°
  29.     faddp   st(7),st(0)
  30.     faddp   st(4),st(0)
  31.     faddp   st(4),st(0)
  32.     faddp   st(1),st(0)
  33.     fld     [matrice_ +  64] // S
  34.     fmul    [matrice  +  16] // C
  35.     fld     [matrice_ +  64] // S
  36.     fmul    [matrice  +  48] // G
  37.     fld     [matrice_ +  64] // S
  38.     fmul    [matrice  +  80] // K
  39.     fld     [matrice_ +  64] // S
  40.     fmul    [matrice  + 112] // O
  41.     fxch    st(3)            // 4° <->  1°
  42.     faddp   st(7),st(0)
  43.     faddp   st(4),st(0)
  44.     faddp   st(4),st(0)
  45.     faddp   st(1),st(0)
  46.     fld     [matrice_ +  96] // T
  47.     fmul    [matrice  +  24] // D
  48.     fld     [matrice_ +  96] // T
  49.     fmul    [matrice  +  56] // H
  50.     fld     [matrice_ +  96] // T
  51.     fmul    [matrice  +  88] // L
  52.     fld     [matrice_ +  96] // T
  53.     fmul    [matrice  + 120] // P
  54.     fxch    st(3)            // 4° <->  1°
  55.     faddp   st(7),st(0)
  56.     faddp   st(4),st(0)
  57.     faddp   st(4),st(0)
  58.     faddp   st(1),st(0)
  59.     fxch    st(3)            // 4° <->  1°
  60.     fstp    [resultat_ +   0]
  61.     fstp    [resultat_ +  64]
  62.     fstp    [resultat_ +  32]
  63.     fstp    [resultat_ +  96]
  64.    // colonne 2 de la matrice résultat
  65.     fld     [matrice_ +   8] // Q
  66.     fmul    [matrice  +   0] // A
  67.     fld     [matrice_ +   8] // Q
  68.     fmul    [matrice  +  32] // E
  69.     fld     [matrice_ +   8] // Q
  70.     fmul    [matrice  +  64] // I
  71.     fld     [matrice_ +   8] // Q
  72.     fmul    [matrice  +  96] // M
  73.     fld     [matrice_ +  40] // R
  74.     fmul    [matrice  +   8] // B
  75.     fld     [matrice_ +  40] // R
  76.     fmul    [matrice  +  40] // F
  77.     fld     [matrice_ +  40] // R
  78.     fmul    [matrice  +  72] // J
  79.     fld     [matrice_ +  40] // R
  80.     fmul    [matrice  + 104] // N
  81.     fxch    st(3)            // 4° <->  1°
  82.     faddp   st(7),st(0)
  83.     faddp   st(4),st(0)
  84.     faddp   st(4),st(0)
  85.     faddp   st(1),st(0)
  86.     fld     [matrice_ +  72] // S
  87.     fmul    [matrice  +  16] // C
  88.     fld     [matrice_ +  72] // S
  89.     fmul    [matrice  +  48] // G
  90.     fld     [matrice_ +  72] // S
  91.     fmul    [matrice  +  80] // K
  92.     fld     [matrice_ +  72] // S
  93.     fmul    [matrice  + 112] // O
  94.     fxch    st(3)            // 4° <->  1°
  95.     faddp   st(7),st(0)
  96.     faddp   st(4),st(0)
  97.     faddp   st(4),st(0)
  98.     faddp   st(1),st(0)
  99.     fld     [matrice_ + 104] // T
  100.     fmul    [matrice  +  24] // D
  101.     fld     [matrice_ + 104] // T
  102.     fmul    [matrice  +  56] // H
  103.     fld     [matrice_ + 104] // T
  104.     fmul    [matrice  +  88] // L
  105.     fld     [matrice_ + 104] // T
  106.     fmul    [matrice  + 120] // P
  107.     fxch    st(3)            // 4° <->  1°
  108.     faddp   st(7),st(0)
  109.     faddp   st(4),st(0)
  110.     faddp   st(4),st(0)
  111.     faddp   st(1),st(0)
  112.     fxch    st(3)            // 4° <->  1°
  113.     fstp    [resultat_ +   8]
  114.     fstp    [resultat_ +  72]
  115.     fstp    [resultat_ +  40]
  116.     fstp    [resultat_ + 104]
  117.    // colonne 3 de la matrice résultat
  118.     fld     [matrice_ +  16] // Q
  119.     fmul    [matrice  +   0] // A
  120.     fld     [matrice_ +  16] // Q
  121.     fmul    [matrice  +  32] // E
  122.     fld     [matrice_ +  16] // Q
  123.     fmul    [matrice  +  64] // I
  124.     fld     [matrice_ +  16] // Q
  125.     fmul    [matrice  +  96] // M
  126.     fld     [matrice_ +  48] // R
  127.     fmul    [matrice  +   8] // B
  128.     fld     [matrice_ +  48] // R
  129.     fmul    [matrice  +  40] // F
  130.     fld     [matrice_ +  48] // R
  131.     fmul    [matrice  +  72] // J
  132.     fld     [matrice_ +  48] // R
  133.     fmul    [matrice  + 104] // N
  134.     fxch    st(3)            // 4° <->  1°
  135.     faddp   st(7),st(0)
  136.     faddp   st(4),st(0)
  137.     faddp   st(4),st(0)
  138.     faddp   st(1),st(0)
  139.     fld     [matrice_ +  80] // S
  140.     fmul    [matrice  +  16] // C
  141.     fld     [matrice_ +  80] // S
  142.     fmul    [matrice  +  48] // G
  143.     fld     [matrice_ +  80] // S
  144.     fmul    [matrice  +  80] // K
  145.     fld     [matrice_ +  80] // S
  146.     fmul    [matrice  + 112] // O
  147.     fxch    st(3)            // 4° <->  1°
  148.     faddp   st(7),st(0)
  149.     faddp   st(4),st(0)
  150.     faddp   st(4),st(0)
  151.     faddp   st(1),st(0)
  152.     fld     [matrice_ + 112] // T
  153.     fmul    [matrice  +  24] // D
  154.     fld     [matrice_ + 112] // T
  155.     fmul    [matrice  +  56] // H
  156.     fld     [matrice_ + 112] // T
  157.     fmul    [matrice  +  88] // L
  158.     fld     [matrice_ + 112] // T
  159.     fmul    [matrice  + 120] // P
  160.     fxch    st(3)            // 4° <->  1°
  161.     faddp   st(7),st(0)
  162.     faddp   st(4),st(0)
  163.     faddp   st(4),st(0)
  164.     faddp   st(1),st(0)
  165.     fxch    st(3)            // 4° <->  1°
  166.     fstp    [resultat_ +  16]
  167.     fstp    [resultat_ +  80]
  168.     fstp    [resultat_ +  48]
  169.     fstp    [resultat_ + 112]
  170.    // colonne 4 de la matrice résultat
  171.     fld     [matrice_ +  24] // Q
  172.     fmul    [matrice  +   0] // A
  173.     fld     [matrice_ +  24] // Q
  174.     fmul    [matrice  +  32] // E
  175.     fld     [matrice_ +  24] // Q
  176.     fmul    [matrice  +  64] // I
  177.     fld     [matrice_ +  24] // Q
  178.     fmul    [matrice  +  96] // M
  179.     fld     [matrice_ +  56] // R
  180.     fmul    [matrice  +   8] // B
  181.     fld     [matrice_ +  56] // R
  182.     fmul    [matrice  +  40] // F
  183.     fld     [matrice_ +  56] // R
  184.     fmul    [matrice  +  72] // J
  185.     fld     [matrice_ +  56] // R
  186.     fmul    [matrice  + 104] // N
  187.     fxch    st(3)            // 4° <->  1°
  188.     faddp   st(7),st(0)
  189.     faddp   st(4),st(0)
  190.     faddp   st(4),st(0)
  191.     faddp   st(1),st(0)
  192.     fld     [matrice_ +  88] // S
  193.     fmul    [matrice  +  16] // C
  194.     fld     [matrice_ +  88] // S
  195.     fmul    [matrice  +  48] // G
  196.     fld     [matrice_ +  88] // S
  197.     fmul    [matrice  +  80] // K
  198.     fld     [matrice_ +  88] // S
  199.     fmul    [matrice  + 112] // O
  200.     fxch    st(3)            // 4° <->  1°
  201.     faddp   st(7),st(0)
  202.     faddp   st(4),st(0)
  203.     faddp   st(4),st(0)
  204.     faddp   st(1),st(0)
  205.     fld     [matrice_ + 120] // T
  206.     fmul    [matrice  +  24] // D
  207.     fld     [matrice_ + 120] // T
  208.     fmul    [matrice  +  56] // H
  209.     fld     [matrice_ + 120] // T
  210.     fmul    [matrice  +  88] // L
  211.     fld     [matrice_ + 120] // T
  212.     fmul    [matrice  + 120] // P
  213.     fxch    st(3)            // 4° <->  1°
  214.     faddp   st(7),st(0)
  215.     faddp   st(4),st(0)
  216.     faddp   st(4),st(0)
  217.     faddp   st(1),st(0)
  218.     fxch    st(3)            // 4° <->  1°
  219.     fstp    [resultat_ +  24]
  220.     fstp    [resultat_ +  88]
  221.     fstp    [resultat_ +  56]
  222.     fstp    [resultat_ + 120]
  223.     }
  224. }
  225. //---------------------------------------------------------------------------

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed