Zugriff des C++ Inline Assemblers auf Klassenelemente

Hallo,

ich habe eine Klasse programmiert und einige der Methoden mit Assembler-Code optimiert. Dabei habe ich folgendes Problem. Ich sehe keine Moeglichkeit, wie ich dem Inline-Assembler klar machen soll, dass er ein Element aus der Klasse laden soll. Folgendes Beispiel:

class C {
  void   methode ();
private
  float  x;
};

void C::methode ()
{
  float local_copy_of_x = x;
  __asm {
             ...
             fld    x                   // funktioniert nicht
             fld    local_copy_of_x     // funktioniert
             ...
  }
}

Im Moment umgehe ich das Problem, wie im Beispiel demonstriert, indem ich eine lokale Kopie des Klassenelements anlege, auf welche der Assembler-Code dann problemlos zugreifen kann. Dies ist jedoch umstaendlich und unnoetig.

Weis jemand, ob das ueberhaupt moeglich ist?

P.S.: ich benutze VC6

camper

class C {
  void   methode ();
private
  float  x;
};

void C::methode ()
{
  __asm {
    ...
    mov ecx, this
    fld C::x[ecx] // oder
    fld [ecx]C.x
    ...
  }
}

P.S. Das ganze hab ich durch Probieren gefunden - jedenfalls finde ich nichts dazu in der offiziellen Dokumentation. Auch noch möglich ist

fld [ecx]+A::a
    fld A::a+[ecx]
    fld [ecx+A::a]
    fld [A::a+ecx]

Allerdings reagiert der Intel C++ Compiler darauf allergisch, die beiden anderen Varianten funktionieren dagegen mit beiden Compilern. Wenn jemand diesbezüglich über andere Compiler wie etwa Borland bescheid weiß, könnte man das evtl. in die FAQ aufnehmen.

Der Zugriff auf Elemente in Klassen/Structs mit dem VC++ Inline Assembler wird in folgendem MSDN Artikel beschrieben:
http://msdn2.microsoft.com/en-us/library/fabdxz08.aspx

Helmut S.

camper schrieb:

class C {
  void   methode ();
private
  float  x;
};

void C::methode ()
{
  __asm {
    ...
    mov ecx, this
    fld C::x[ecx] // oder
    fld [ecx]C.x
    ...
  }
}
P.S. Das ganze hab ich durch Probieren gefunden - jedenfalls finde ich nichts dazu in der offiziellen Dokumentation. Auch noch möglich ist
fld [ecx]+A::a
    fld A::a+[ecx]
    fld [ecx+A::a]
    fld [A::a+ecx]
Allerdings reagiert der Intel C++ Compiler darauf allergisch, die beiden anderen Varianten funktionieren dagegen mit beiden Compilern. Wenn jemand diesbezüglich über andere Compiler wie etwa Borland bescheid weiß, könnte man das evtl. in die FAQ aufnehmen.

fld C::x[ecx]

Diese Schreibweise ist eine mögliche Fehlerquelle, der Inline-Assembler bekommt keine Information ueber die
Operandengroesse vom Compiler(VC 8.0) und der Compiler gibt keine Warnung aus(=Compilerbug).
Obiges Beispiel mit double statt float ergibt einen Fehler, den der Compiler(VC 8.0) nicht meldet - das ist ein Bug.

// processor: x86
// compiler:  VC 8.0

class C 
{ 
public: 
    void   methode (); 
private: 
    double  x; 
}; 

void C::methode () 
{ 
__asm {                 

        mov     ecx, this           // OK
        fld     C::x[ecx]           // Fehler (fld dword ptr C::x[ecx])
        fld     qword ptr C::x[ecx] // OK
        fld     [ecx]C.x            // OK

      } 
}

mfg

cool, danke. da waer ich nicht drauf gekommen.
Hab noch dieses offsetof()-Makro entdeckt, damit waer es zumindest moeglich gewesen, sich das zurueckschreiben der lokalen variable zu ersparen, aber so ist ja noch viel besser.