Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
6901 connectés 

  FORUM HardWare.fr
  Programmation

  ecrire une routine assembleur dans un code source C

 
 


Dernière réponse
Sujet : ecrire une routine assembleur dans un code source C
darkoli 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. //---------------------------------------------------------------------------

Votre réponse
Nom d'utilisateur    Pour poster, vous devez être inscrit sur ce forum .... si ce n'est pas le cas, cliquez ici !
Le ton de votre message                        
                       
Votre réponse
[b][i][u][strike][spoiler][fixed][cpp][url][email][img][*]   
 
   [quote]
 
Options

 
Vous avez perdu votre mot de passe ?


Vue Rapide de la discussion
darkoli 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. //---------------------------------------------------------------------------
barbarella 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]
bjone 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).......
hurricanne 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 ?
bjone 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........
hurricanne 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..
bjone 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 ?
hurricanne 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....
bjone heu, qu'est tu veux exactement ????
 
l'assembleur en ligne est différent dans chaque compilateur (borland/watcom/microsoft......)
hurricanne 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
}

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo

Copyright © 1997-2025 Groupe LDLC (Signaler un contenu illicite / Données personnelles)