Classes d’assemblage et de gabarit

Je travaille sur un petit projet et j’essaie d’obtenir des valeurs codées en dur dans l’assemblage en ligne. Pour ce faire, j’utilise des modèles. J’ai créé un code pour montrer ce que je vois

#include  template  struct MyClass { size_t myValue = T; void doSomething() { size_t value = T; __asm { mov eax, [T] mov [value], eax } std::cout << value << std::endl; } }; int main() { auto o = new MyClass(); o->doSomething(); return 0; } 

Il s’avère que pour le code de l’assembly, il essaie d’utiliser le segment de données à la place “en collant le numéro directement”

  ; 25 : { push ebp mov ebp, esp push ecx ; 26 : auto o = new MyClass(); push 4 call ??2@YAPAXI@Z ; operator new add esp, 4 ; 14 : size_t value = T; mov DWORD PTR _value$2[ebp], 999 ; 000003e7H ; 26 : auto o = new MyClass(); mov DWORD PTR [eax], 0 mov DWORD PTR [eax], 999 ; 000003e7H ; 15 : __asm ; 16 : { ; 17 : mov eax, [T] mov eax, DWORD PTR ds:0 ; 18 : mov [value], eax mov DWORD PTR _value$2[ebp], eax ; 19 : } ; 20 : std::cout << value << std::endl; 

J’utilise Visual Studio 2015. Existe-t-il un autre moyen d’y parvenir?

Merci d’avance

Tritron.

Ahh, quelle belle question tordue!

J’ai essayé une variable constexpr initialisée avec T. Le résultat était la même valeur – chargée de la mémoire. Les macros peuvent être utilisées pour passer des littéraux à un assemblage en ligne, mais elles ne se mélangent pas bien avec les modèles.

Initialiser une énumération dans la classe à l’aide de T devrait théoriquement fonctionner ( https://msdn.microsoft.com/en-us/library/ydwz5zc6.aspx mentionne que des énumérations peuvent être utilisées dans un assemblage en ligne), le compilateur de visual studio 2015 :-).

Ce qui semble fonctionner est un modèle de fonction qui déclare une énumération à l’aide du paramètre template, puis utilise cette énumération dans l’assembly inline. Si vous devez l’avoir dans une classe basée sur des modèles, vous pouvez instancier la fonction template à l’intérieur de la classe comme ceci:

  #include  template  void dosomething() { enum { LOCALENUM = T }; size_t value = 0; __asm { mov eax, LOCALENUM mov[value], eax } std::cout << value << std::endl; } template  struct MyClass { size_t myValue = T; void doSomething() { ::dosomething(); } }; int main() { //dosomething<999>(); auto o = new MyClass<999>(); o->doSomething(); return 0; } 

Cela se traduit par le code d’assemblage suivant:

  auto o = new MyClass<999>(); 001B1015 mov dword ptr [eax],0 001B101B mov dword ptr [eax],3E7h o->doSomething(); 001B1021 mov eax,3E7h <--- Victory! 001B1026 mov dword ptr [ebp-4],eax 001B1029 mov ecx,dword ptr [_imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A (01B2048h)] 001B102F push offset std::endl > (01B1050h) 001B1034 push dword ptr [ebp-4] 001B1037 call dword ptr [__imp_std::basic_ostream >::operator<< (01B2044h)]