addition ...



  • Hi !!

    Wie kann man 2 int zahlen mit inline assembler (vc++ 2003 toolkit) addieren..

    theoretisch:

    variable 1 in akku schieben
    variable 2 in register...
    beides addieren...
    akkuinhalt ausgeben....

    Wie übergebe ich denn die variablen von C an den assembler?

    int addieren(int a, int b)
    {
     _asm
     {
      mov a,[kein plan]
      mov d,[keinplan]
      add a,d
    
      und jetzt?
     }
    }
    

    danke

    Aliendrummer


  • Mod

    addition mit inline assembler ist in vc++ ziemlich sinnlos, eben weil es nur wenige möglichkeiten gibt, die art der paramterübergabe zu regeln - und keine davon ist sehr effizient.
    z.b.

    inline int addieren(int a, int b)
    {
     __asm
     {
      mov eax, a
      add eax, b
     }
    }
    

    das ist die standard methode - aber nicht sonderlich effizient, da die parameter über den stack übergeben werden.

    oder

    inline int __fastcall addieren(int a, int b)
    {
     __asm
     {
      mov eax, ecx
      add eax, edx
     }
    }
    

    hier werden die ersten beiden parameter in ecx und edx übergeben (sofern möglich), das ist also deutlich schneller, da nun auch kein stackrahmen benötigt wird. allerdings wird auch (gerade) hier keine inline expansion stattfinden, obwohl sie sehr lohnenswert wäre.
    .. mit g++ wär das nicht passiert 😉

    inline int addieren(int a, int b)
    {
        int result;
        asm( "addl %1, %2" : "=r" ( result ) : "0,rim" ( a ), "rim,0" ( b ) );
        return result;
    }
    

    hier werden je nach situation tatsächlich nur eine oder zwei assembler instruktionen generiert - der inline assembler ist bei g++ daher sehr gut geeignet, neue intrinsics zu generieren.



  • inline const int addieren (int a, int b) 
    { 
        static int result = 0; 
        asm( "addl %1, %2" : "=r" ( result ) : "0,rim" ( a ), "rim,0" ( b ) ); 
        return result; 
    }
    

    static and const are your friends 😉



  • ''' schrieb:

    inline const int addieren (int a, int b) 
    { 
        static int result = 0; 
        asm( "addl %1, %2" : "=r" ( result ) : "0,rim" ( a ), "rim,0" ( b ) ); 
        return result; 
    }
    

    static and const are your friends 😉

    Blödsinn 😉


  • Mod

    ''' schrieb:

    inline const int addieren (int a, int b) 
    { 
        static int result = 0; 
        asm( "addl %1, %2" : "=r" ( result ) : "0,rim" ( a ), "rim,0" ( b ) ); 
        return result; 
    }
    

    static and const are your friends 😉

    lies den standard - es ist völlig egal ob du int oder const int zurückgibst, so wie es egal ist, ob du const int oder nur int als parameter benutzt . und static... darüber brauchen wir gar nicht erst zu reden.


  • Mod

    war nat. ein fehler in den constraints drin (%1 darf ja keine konstante sein)

    inline int addieren(int a, int b)
    {
        int result;
        asm( "addl %1, %2" : "=r" ( result ) : "%0" ( a ), "%rim" ( b ) );
        return result;
    }
    

    so müsste es stimmen. bzgl. static: um es deutlich zu sagen - das würde a) nicht thread-safe sein, und b) zwei völlig überflüssige zusätzliche mov befehle einfügen



  • camper schrieb:

    ''' schrieb:

    inline const int addieren (int a, int b) 
    { 
        static int result = 0; 
        asm( "addl %1, %2" : "=r" ( result ) : "0,rim" ( a ), "rim,0" ( b ) ); 
        return result; 
    }
    

    static and const are your friends 😉

    lies den standard - es ist völlig egal ob du int oder const int zurückgibst, so wie es egal ist, ob du const int oder nur int als parameter benutzt . und static... darüber brauchen wir gar nicht erst zu reden.

    Doch wir reden mal drüber: Was ist an Static falsch, hmn? na? naa?

    Ja ich weiß jetzt gleich kommt wieder diese Wunderbare idee "Der Compiler machts schon", aber das das nicht jeder Compiler tut interessiert wieder kein Schwein.

    Das mit const int zurückgeben, darüber hat Hume mal was feines gesagt im C++ forum! Kannst dafür ja mal diese Tolle neue (beschissene) Suchfunktion benutzen!



  • Lies mal den Post über dir. Letzte Zeile: Na? Naa?


  • Mod

    ''' schrieb:

    camper schrieb:

    ''' schrieb:

    inline const int addieren (int a, int b) 
    { 
        static int result = 0; 
        asm( "addl %1, %2" : "=r" ( result ) : "0,rim" ( a ), "rim,0" ( b ) ); 
        return result; 
    }
    

    static and const are your friends 😉

    lies den standard - es ist völlig egal ob du int oder const int zurückgibst, so wie es egal ist, ob du const int oder nur int als parameter benutzt . und static... darüber brauchen wir gar nicht erst zu reden.

    Doch wir reden mal drüber: Was ist an Static falsch, hmn? na? naa?

    Ja ich weiß jetzt gleich kommt wieder diese Wunderbare idee "Der Compiler machts schon", aber das das nicht jeder Compiler tut interessiert wieder kein Schwein.

    Das mit const int zurückgeben, darüber hat Hume mal was feines gesagt im C++ forum! Kannst dafür ja mal diese Tolle neue (beschissene) Suchfunktion benutzen!

    wenn du nichts eigenes beizutragen hast, lass es doch einfach. wie bereits erwähnt, ist mir die argumentation, const T zurückzugeben, durchaus bekannt (wenn ich dem auch nicht zustimmen kann; man schreibt nicht eben mal a() += b() - wenn man es tut, hat man einen guten grund; ausserdem kann zuviel const an dieser stelle mitunter unnötige temporaries verursachen - und const Ts sind für move konstruktoren unverdaulich). was dir dabei entgeht, ist schlicht, dass es bei builtins keinen unterschied macht - das funktionsergebnis ist sowieso ein rvalue.


Log in to reply