Source Code

Source code

Asm in VisualStudio_20xx
Highlighting Assembler language in VisualStudio_20xx
Using asm files with c/c++ projects in VisualStudio_20xx
Using assembler in Visual C++/CLI and the .NET Platform
Using assembler with Java projects
A.I. PROGRAMMING IN PROLOG AND ASSEMBLER
Using assembler with Prolog projects
Using SSE commands
Using SSE3 commands

Asm in VisualStudio_20xx

    В MS_VisualStudio_20xx есть возможность использования собственного 
ml.exe и link.exe, для этого их нужно подключить: 
    // вместо xx версия студии, у меня Microsoft Visual Studio 10.0
    // кстати, в 2010 в регистрах появились понятные для глаз цифры,
    // вместо их представления, (на скринах в закладках SSE, SSE3).
    // Также ml.exe использует все наборы команд для своей версии, в
    // отличии от masm32_v.10, к-ый не использует SSE2,SSE3,SSE4...

->Tools->External Tools...->Add:

  Assemble 32-bit
  C:\Program Files\Microsoft Visual Studio x.0\VC\bin\ml.exe
  -c -coff -Fl -Fo $(ItemFileName).obj $(ItemFileName).asm
  $(ItemDir)
  
link.exe при неправильном подключении «сносит», поэтому:
->Tools->Visual Studio Command Prompt: // путь указываем к *.obj файлу
  link /subsystem:console C:\TEMP\sse.obj

... после того, как проассемблировали и отлинковали программу exe-шник 
      забираем из C:\Program Files\Microsoft Visual Studio x.0\VC\bin\

    Masm32_v.10 прописывается по другому и без проблем подключаеться
linker: // masm32[v.10] don't support SSE2,SSE3,SSE4, only VS_20xx

  masm32
  C:\masm32\bin\ml.exe
  /c /coff /Cp /nologo /Fm /Zi /Zd /Fl $(ItemFileName).asm
  $(ItemDir)
  
  link32
  C:\masm32\bin\link.exe
  /SUBSYSTEM:CONSOLE /DEBUG /VERSION:4.0 $(ItemFileName).obj
  $(ItemDir)

Return to top page

Highlighting Assembler language in VisualStudio_20xx

Here are the required steps to set up Assembler syntax highlighting in 
    MS Visual Studio:

1) Download the Usertype.dat file  given here to a folder in which you 
have read/write permissions.

2) Copy Usertype.dat to the  
               C:\Program Files\Microsoft Visual Studio x.0\Common7\IDE 
folder. If you are using  Windows Vista, it will display a verification 
window before copying the file.

3) Open MS Visual Studio, select Options... from the Tools menu, select 
Text Editor, and select File Extension. On the right side of the dialog 
(shown below), enter asm as the extension,  select Microsoft Visual C++ 
from the Editor list, and click the Add button.  Click the OK button to 
save your changes.

Close MS Visual Studio and restart it. Open your project and display an 
ASM file. You should see syntax highlighting in the editor.

Result:

Return to top page

Using asm files with c/c++ projects in VisualStudio_20xx

    В Visuale, как и в других IDE, есть свои samples 
( C:\Program Files\Microsoft Visual Studio xx.0\Samples\1033 ), а именно 
интересующие нас projects in folders ..\C++\Compiler\MASM, к-ые по каким
-то причинам не хотят собираться (кроме 2005 Visuala), поэтому:

- open project (folder) with *.asm and *.c or *.cpp files
- open in browser(IE) *.vcxproj
- find this text string ( in different VS -> different sting )


нас интересует вот эти строчки 
    VS_2010
ml -c -Zi "-Fl$(IntDir)%(FileName).lst" "-Fo$(IntDir)%(FileName).obj" "%(FullPath)"
$(IntDir)%(FileName).obj;%(Outputs)
    VS_2008
ml -c -Zi "-Fl$(IntDir)\$(InputName).lst" "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
$(IntDir)\$(InputName).obj
    VS_2005 (как и в VS_2008)
ml -c -Zi "-Fl$(IntDir)\$(InputName).lst" "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
$(IntDir)\$(InputName).obj

( в VS_2003 находим таким же способом )

Теперь делаем свой проект:

- File->New->Project...->C++ Empty Project
- Project->Add Existing Item... or Add New Item...
(добавили наши файлы одним из перечисленных способов)
... в Microsoftовском *.asm файле в комментах есть параметры компиляции,
но они слегка различаются:
; Custom Build Step, including a listing file placed in intermediate directory
; but without Source Browser information
; debug:
; ml -c -Zi "-Fl$(IntDir)\$(InputName).lst" "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
; release:
; ml -c "-Fl$(IntDir)\$(InputName).lst" "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
; outputs:
; $(IntDir)\$(InputName).obj
    поэтому если они понадобятся, мы будем знать где их надо подкорректировать.
	
- for each *.asm files write properties:
right_click->Properties->Item Type->Custom Build Tool->Apply
Custom Build Tool->General
Command Line -> 
     ml -c -Zi "-Fl$(IntDir)%(FileName).lst" "-Fo$(IntDir)%(FileName).obj" "%(FullPath)"
Description -> Assembling...
Outputs -> $(IntDir)%(FileName).obj;%(Outputs)
для VS_2008/05/03 соот. свои параметры...


    Для нагдядности протестим функции с использованием основных команд CPU и FPU.
ATTENTION!!! return value already in eax.
    ...напомню для к-го *.asm файла, требуется прописывать параметры компиляции, 
описанные выше.

   ...я оставил Microsoft_comments...и думаю за проделанную разЪяснительную работу->
ClusterED rework. вполне заслуживаю.
   ...еще один момент, если в первый раз не запускается и показывает ошибки - это глюк,
закрываем и перезапускаем заново (у меня на всех трех студиях повторялось, и соответ-
ственно после этого на всех трех работало без проблем VS_2005/08/10).

; asm_f1.asm
; Copyright (c) Microsoft Corporation.  All rights reserved. ClusterED rework.

.686
.model flat, c

; Custom Build Step, including a listing file placed in intermediate directory
; but without Source Browser information
; debug:
; ml -c -Zi "-Fl$(IntDir)\$(InputName).lst" "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
; release:
; ml -c "-Fl$(IntDir)\$(InputName).lst" "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
; outputs:
; $(IntDir)\$(InputName).obj

; Custom Build Step, including a listing file placed in intermediate directory
; and Source Browser information also placed in intermediate directory
; debug:
; ml -c -Zi "-Fl$(IntDir)\$(InputName).lst" "-FR$(IntDir)\$(InputName).sbr"
;                                   "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
; release:
; ml -c "-Fl$(IntDir)\$(InputName).lst" "-FR$(IntDir)\$(InputName).sbr"
;                                   "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
; outputs:
; $(IntDir)\$(InputName).obj
; $(IntDir)\$(InputName).sbr

.code

func1 PROC x:SDWORD, y:SDWORD
	mov eax, x
	mul y
; return value already in eax
	RET
func1 ENDP

intFpu PROC x:SDWORD, y:SDWORD
    xor eax, eax
    fild x
    fiadd y
    fistp x
    mov eax, x
    RET
intFpu ENDP

end



; asm_f2.asm
; Copyright (c) Microsoft Corporation.  All rights reserved. ClusterED rework.

.686
.model flat, c

; Custom Build Step, including a listing file placed in intermediate directory
; but without Source Browser information
; debug:
; ml -c -Zi "-Fl$(IntDir)\$(InputName).lst" "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
; release:
; ml -c "-Fl$(IntDir)\$(InputName).lst" "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
; outputs:
; $(IntDir)\$(InputName).obj

; Custom Build Step, including a listing file placed in intermediate directory
; and Source Browser information also placed in intermediate directory
; debug:
; ml -c -Zi "-Fl$(IntDir)\$(InputName).lst" "-FR$(IntDir)\$(InputName).sbr"
;                               "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
; release:
; ml -c "-Fl$(IntDir)\$(InputName).lst" "-FR$(IntDir)\$(InputName).sbr"
;                               "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
; outputs:
; $(IntDir)\$(InputName).obj
; $(IntDir)\$(InputName).sbr

.code

func2 PROC x:SDWORD, y:SDWORD
  mov eax, x
  mul y

; return value already in eax
  RET
func2 ENDP

end



// main.c
//Copyright (c) Microsoft Corporation.  All rights reserved. ClusterED rework.

#include <stdio.h>
#include <stdlib.h>

int func1(int, int);
int intFpu(int, int);
int func2(int, int);

int main() {
	int i=2, j=5;

// VS_2010
// ml -c -Zi "-Fl$(IntDir)%(FileName).lst" "-Fo$(IntDir)%(FileName).obj" "%(FullPath)"
// $(IntDir)%(FileName).obj;%(Outputs)
// VS_2008/05
// ml -c -Zi "-Fl$(IntDir)\$(InputName).lst" "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"
// $(IntDir)\$(InputName).obj

// call function, in this case an
// assembly language function, and print result
	printf("The simple_func with arg: %d and %d: %d\n", i, j, func1(i, j));
	printf("The using_fpu with arg: %d and %d: %d\n", i, j, intFpu(i, j));
	printf("The using_second_asm_file with arg: %d and %d: %d\n", i, j, func2(i, j));
	getchar();
	return 0;
}

Result:

Return to top page

Using assembler in Visual C++/CLI and the .NET Platform

Пример использования ассемблерного кода в проектах на Visual C++/CLI and the .NET Platform. Пример показывает насколько быстрее могут выполняться стандартные операции на ассемблере, но только в Debug Mode, в Release Mode разницы почти нет, дизассемблерный листинг тоже в разных режимах отличается.

    #include "stdafx.h"

    using namespace System;

    #pragma managed()

    int mul2(int k, int n)
    {
	    __asm {
		    mov ecx,n
		    mov eax,k
    m1:
		    add eax,ecx
		    loop m1

		    mov k,eax
	    }
	    return k;
    }

    #pragma managed()


    int main(array<System::String ^> ^args)
    {
	    int cnt = 1000000, z = 0;

	    DateTime d1 = DateTime::UtcNow;

	    z = mul2(0, cnt);	

	    DateTime d2 = DateTime::UtcNow;
	    Console::WriteLine(d2 - d1);
	    Console::WriteLine("z = " + z.ToString());

	    z = 0;
	    d1 = DateTime::UtcNow;

	    for(int i = cnt; i > 0; i--) {
		    z += i;	
	    }

	    d2 = DateTime::UtcNow;
	    Console::WriteLine(d2 - d1);
	    Console::WriteLine("z = " + z.ToString());

	    Console::ReadLine();
        return 0;
    }

Disassembly:

Return to top page

Using SSE commands

«SSE-команды»  basic_program_coded&&encoded_data_with_sse_comand_xorps

Продемонстрируем работу SSE команд в ассемблерных вставках програм на С++ 
          в среде VisualStudio 2008 ProfessionalEdition.
Для примера продемонстрируем програму шифровки-дешифровки данных с SSE командой XORPS 
    / как мы знаем если два раза применить эту команду с одним и тем же ключом, то мы 
    восстановим данные / , в программе продемонстрирован сам метод, итерфейс 
    использования мы оставляем на дальнейшее расмотрения конкретной задачи.

->  Обнаружилась интересная деталь при всех паралельных командах Visual работает 
    корректно только когда операции производяться с двумя регистрами, хотя в 
    assemblerе предусмотрены для тех же команд операции регистр - память 
		movups XMM0,[esi]  //
		movups XMM1,[edi]  // 		
		xorps XMM0,XMM1    // correct
		
            xorps XMM0,[edi]   // don’t correct, don’t working
->  также SSE registers работают не только с дробными числами, но ис целыми, что 
    продемонстрировано в нашей программе, хотя если надо можно задать и массивы 
    вещественных чисел.

#include <iostream>
using namespace std;

int main() {
	float arr1[]={1, 2, 3, 4, 2, 2, 2, 2}; // 1.0, 2.3, 3.4, 4.3, 2.0, 2.0, 2.0, 2.0
	float arr2[]={2, 2, 2, 2, 1, 2, 3, 4};
	float res1[]={0, 0, 0, 0, 0, 0, 0, 0};
    int cnt=sizeof(arr1)/sizeof(float)/4; // cnt=2
// если не кратно 4 требуется остаток и соот. остаток от 4 чтобы выявить 
//     «затесавшиеся» лишние данные, тоже оставим на дальнейшее расмотрения 
//     конкретной задачи. 	
	__asm {
		lea esi,arr1
		lea edi,arr2
		lea ebx,res1
		mov ecx,cnt // LENGTHOF don’t working in VS2008Prof
m1:   //  xorps XMM0,XMM0      //; using for clear register
      //  xorps XMM1,XMM1      //; using for clear register
		movups XMM0,[esi]  
		    //; 4080000040400000400000003F800000 /first four digit array/ & ...
		movups XMM1,[edi]  
		    //; 40000000400000004000000040000000 / -//- /
		xorps XMM0,XMM1    
		    //; coded data -> 0080000000400000000000007F800000 / -//- /
		xorps XMM0,XMM1    
		    //; encoded data -> 4080000040400000400000003F800000 / -//- /
		movups [ebx],XMM0
		add esi,4*TYPE arr1
		add edi,4*TYPE arr2
		add ebx,4*TYPE res1
        loop m1
	}
	for(register int i=0; i<sizeof(arr1)/sizeof(float); i++)
	    cout << res1[i] << " ";
	cout << endl;
}

Чтобы увидеть registers нужно:
->Ставим breakpoint
->Debug->Start Debugging
->Debug->Windows->Registers->right click mouse in field window registers
   and choice need registers:CPU,…,FPU,MMX,SSE,SSE2,…

в нашем случае до операции xorps:

EAX = CCCCCCCC EBX = 0013FEF4 ECX = 00000002 EDX = 00000001 ESI = 0013FF44 
EDI = 0013FF1C EIP = 00411597 ESP = 0013FE0C EBP = 0013FF68 EFL = 00000206 

CS = 001B DS = 0023 ES = 0023 SS = 0023 FS = 003B GS = 0000 

ST0 = +0.0000000000000000e+0000   ST1 = +0.0000000000000000e+0000   
ST2 = -0.2917997402214941e+4426   ST3 = +6.5502861448102810e-1074   
ST4 = +0.0000000025083383e-2940   ST5 = -0.1879217777276923e+3552   
ST6 = 1#QNAN                      ST7 = +0.0000000000000000e+0000   
CTRL = 027F STAT = 0000 TAGS = FFFF EIP = 0041157B EDO = 0013FF10 

MM0 = 0000000000000000 MM1 = 0000000000000000 MM2 = 086FF970086FF970 
MM3 = 7C91485900000000 MM4 = 000000007C913288 MM5 = 086FF8F40000E38D 
MM6 = 7C9132907C90EE18 MM7 = 0000000000000000 

XMM0 = 4080000040400000400000003F800000 
XMM1 = 40000000400000004000000040000000 
XMM2 = 00000000000000000000000000000000 
XMM3 = 00000000000000000000000000000000 
XMM4 = 00000000000000000000000000000000 
XMM5 = 00000000000000000000000000000000 
XMM6 = 00000000000000000000000000000000 
XMM7 = 00000000000000000000000000000000 XMM00 = +1.00000E+000      
XMM01 = +2.00000E+000      XMM02 = +3.00000E+000      
XMM03 = +4.00000E+000      XMM10 = +2.00000E+000      
XMM11 = +2.00000E+000      XMM12 = +2.00000E+000      
XMM13 = +2.00000E+000      XMM20 = +0.00000E+000      
XMM21 = +0.00000E+000      XMM22 = +0.00000E+000      
XMM23 = +0.00000E+000      XMM30 = +0.00000E+000      
XMM31 = +0.00000E+000      XMM32 = +0.00000E+000      
XMM33 = +0.00000E+000      XMM40 = +0.00000E+000      
XMM41 = +0.00000E+000      XMM42 = +0.00000E+000      
XMM43 = +0.00000E+000      XMM50 = +0.00000E+000      
XMM51 = +0.00000E+000      XMM52 = +0.00000E+000      
XMM53 = +0.00000E+000      XMM60 = +0.00000E+000      
XMM61 = +0.00000E+000      XMM62 = +0.00000E+000      
XMM63 = +0.00000E+000      XMM70 = +0.00000E+000      
XMM71 = +0.00000E+000      XMM72 = +0.00000E+000      
XMM73 = +0.00000E+000      MXCSR = 00001F80 

XMM0DL = +2.00000047311187E+000           
XMM0DH = +5.12000122547150E+002           
XMM1DL = +2.00000047683716E+000           
XMM1DH = +2.00000047683716E+000           
XMM2DL = +0.00000000000000E+000           
XMM2DH = +0.00000000000000E+000           
XMM3DL = +0.00000000000000E+000           
XMM3DH = +0.00000000000000E+000           
XMM4DL = +0.00000000000000E+000           
XMM4DH = +0.00000000000000E+000           
XMM5DL = +0.00000000000000E+000           
XMM5DH = +0.00000000000000E+000           
XMM6DL = +0.00000000000000E+000           
XMM6DH = +0.00000000000000E+000           
XMM7DL = +0.00000000000000E+000           
XMM7DH = +0.00000000000000E+000           

OV = 0 UP = 0 EI = 1 PL = 0 ZR = 0 AC = 0 PE = 1 CY = 0


после первого xorps “coded data”:

XMM0 = 0080000000400000000000007F800000 
XMM1 = 40000000400000004000000040000000


после второго “encoded data”:

XMM0 = 4080000040400000400000003F800000 
XMM1 = 40000000400000004000000040000000 


Чтобы увидеть наш код в disassemblere нужно:
->Ставим breakpoint
->Debug->Start Debugging
->Debug->Windows->Disassembly

--- c:\documents and settings\cole\my documents\visual studio 2008
                              \dz_c++\test\sse\sse\r1.cpp 
     1: #include <iostream>
     2: using namespace std;
     3: 
     4: int main() {
004114B0 55               push        ebp  
004114B1 8B EC            mov         ebp,esp 
004114B3 81 EC 50 01 00 00 sub         esp,150h 
004114B9 53               push        ebx  
004114BA 56               push        esi  
004114BB 57               push        edi  
004114BC 8D BD B0 FE FF FF lea         edi,[ebp-150h] 
004114C2 B9 54 00 00 00   mov         ecx,54h 
004114C7 B8 CC CC CC CC   mov         eax,0CCCCCCCCh 
004114CC F3 AB            rep stos    dword ptr es:[edi] 
     5: float arr1[]={1, 2, 3, 4, 2, 2, 2, 2}; // 1.0, 2.3, 3.4, 4.3, 2.0, 2.0, 2.0, 2.0
004114CE D9 E8            fld1             
004114D0 D9 5D DC         fstp        dword ptr [arr1] 
004114D3 D9 05 10 78 41 00 fld         dword ptr [__real@40000000 (417810h)] 
004114D9 D9 5D E0         fstp        dword ptr [ebp-20h] 
004114DC D9 05 0C 78 41 00 fld         dword ptr [__real@40400000 (41780Ch)] 
004114E2 D9 5D E4         fstp        dword ptr [ebp-1Ch] 
004114E5 D9 05 08 78 41 00 fld         dword ptr [__real@40800000 (417808h)] 
004114EB D9 5D E8         fstp        dword ptr [ebp-18h] 
004114EE D9 05 10 78 41 00 fld         dword ptr [__real@40000000 (417810h)] 
004114F4 D9 5D EC         fstp        dword ptr [ebp-14h] 
004114F7 D9 05 10 78 41 00 fld         dword ptr [__real@40000000 (417810h)] 
004114FD D9 5D F0         fstp        dword ptr [ebp-10h] 
00411500 D9 05 10 78 41 00 fld         dword ptr [__real@40000000 (417810h)] 
00411506 D9 5D F4         fstp        dword ptr [ebp-0Ch] 
00411509 D9 05 10 78 41 00 fld         dword ptr [__real@40000000 (417810h)] 
0041150F D9 5D F8         fstp        dword ptr [ebp-8] 
     6: 	float arr2[]={2, 2, 2, 2, 1, 2, 3, 4};
00411512 D9 05 10 78 41 00 fld         dword ptr [__real@40000000 (417810h)] 
00411518 D9 5D B4         fstp        dword ptr [arr2] 
0041151B D9 05 10 78 41 00 fld         dword ptr [__real@40000000 (417810h)] 
00411521 D9 5D B8         fstp        dword ptr [ebp-48h] 
00411524 D9 05 10 78 41 00 fld         dword ptr [__real@40000000 (417810h)] 
0041152A D9 5D BC         fstp        dword ptr [ebp-44h] 
0041152D D9 05 10 78 41 00 fld         dword ptr [__real@40000000 (417810h)] 
00411533 D9 5D C0         fstp        dword ptr [ebp-40h] 
00411536 D9 E8            fld1             
00411538 D9 5D C4         fstp        dword ptr [ebp-3Ch] 
0041153B D9 05 10 78 41 00 fld         dword ptr [__real@40000000 (417810h)] 
00411541 D9 5D C8         fstp        dword ptr [ebp-38h] 
00411544 D9 05 0C 78 41 00 fld         dword ptr [__real@40400000 (41780Ch)] 
0041154A D9 5D CC         fstp        dword ptr [ebp-34h] 
0041154D D9 05 08 78 41 00 fld         dword ptr [__real@40800000 (417808h)] 
00411553 D9 5D D0         fstp        dword ptr [ebp-30h] 
     7: 	float res1[]={0, 0, 0, 0, 0, 0, 0, 0};
00411556 D9 EE            fldz             
00411558 D9 5D 8C         fstp        dword ptr [res1] 
0041155B D9 EE            fldz             
0041155D D9 5D 90         fstp        dword ptr [ebp-70h] 
00411560 D9 EE            fldz             
00411562 D9 5D 94         fstp        dword ptr [ebp-6Ch] 
00411565 D9 EE            fldz             
00411567 D9 5D 98         fstp        dword ptr [ebp-68h] 
0041156A D9 EE            fldz             
0041156C D9 5D 9C         fstp        dword ptr [ebp-64h] 
0041156F D9 EE            fldz             
00411571 D9 5D A0         fstp        dword ptr [ebp-60h] 
00411574 D9 EE            fldz             
00411576 D9 5D A4         fstp        dword ptr [ebp-5Ch] 
00411579 D9 EE            fldz             
0041157B D9 5D A8         fstp        dword ptr [ebp-58h] 
     8:     int cnt=sizeof(arr1)/sizeof(float)/4; // cnt=2
0041157E C7 45 80 02 00 00 00 mov         dword ptr [cnt],2 
     9: 	
    10: 	__asm {
    11: 		lea esi,arr1
00411585 8D 75 DC         lea         esi,[arr1] 
    12: 		lea edi,arr2
00411588 8D 7D B4         lea         edi,[arr2] 
    13: 		lea ebx,res1
0041158B 8D 5D 8C         lea         ebx,[res1] 
    14: 		mov ecx,cnt // LENGTHOF dont working in VS2008Prof
0041158E 8B 4D 80         mov         ecx,dword ptr [cnt] 
    15: m1:	    
    16:       //  xorps XMM0,XMM0      //; using for clear register
    17:       //  xorps XMM1,XMM1      //; using for clear register
    18: 		movups XMM0,[esi]  
    //; 4080000040400000400000003F800000 /first four digit array/ & ...
00411591 0F 10 06         movups      xmm0,xmmword ptr [esi] 
    19: 		movups XMM1,[edi]  
    //; 40000000400000004000000040000000 / -//- /
00411594 0F 10 0F         movups      xmm1,xmmword ptr [edi] 
    20: 		xorps XMM0,XMM1    
    //; coded data -> 0080000000400000000000007F800000 / -//- /
00411597 0F 57 C1         xorps       xmm0,xmm1 
    21: 		xorps XMM0,XMM1    
    //; encoded data -> 4080000040400000400000003F800000 / -//- /
0041159A 0F 57 C1         xorps       xmm0,xmm1 
    22: 		movups [ebx],XMM0
0041159D 0F 11 03         movups      xmmword ptr [ebx],xmm0 
    23: 		add esi,4*TYPE arr1
004115A0 83 C6 10         add         esi,10h 
    24: 		add edi,4*TYPE arr2
004115A3 83 C7 10         add         edi,10h 
    25: 		add ebx,4*TYPE res1
004115A6 83 C3 10         add         ebx,10h 
    26:         loop m1
004115A9 E2 E6            loop        m1 (411591h) 
    27: 	}
    28: 	for(register int i=0; i<sizeof(arr1)/sizeof(float); i++)
004115AB C7 85 74 FF FF FF 00 00 00 00 mov         dword ptr [i],0 
004115B5 EB 0F            jmp         m1+35h (4115C6h) 
004115B7 8B 85 74 FF FF FF mov         eax,dword ptr [i] 
004115BD 83 C0 01         add         eax,1 
004115C0 89 85 74 FF FF FF mov         dword ptr [i],eax 
004115C6 83 BD 74 FF FF FF 08 cmp         dword ptr [i],8 
004115CD 73 33            jae         m1+71h (411602h) 
    29: 	    cout << res1[i] << " ";
004115CF 68 00 78 41 00   push        offset string " " (417800h) 
004115D4 8B F4            mov         esi,esp 
004115D6 8B 85 74 FF FF FF mov         eax,dword ptr [i] 
004115DC 51               push        ecx  
004115DD D9 44 85 8C      fld         dword ptr res1[eax*4] 
004115E1 D9 1C 24         fstp        dword ptr [esp] 
004115E4 8B 0D 3C A3 41 00 mov         ecx,dword ptr [__imp_std::cout (41A33Ch)] 
004115EA FF 15 40 A3 41 00 call
  dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (41A340h)] 
004115F0 3B F4            cmp         esi,esp 
004115F2 E8 AD FB FF FF   call        @ILT+415(__RTC_CheckEsp) (4111A4h) 
004115F7 50               push        eax  
004115F8 E8 57 FB FF FF   call        std::operator<<<std::char_traits<char> > (411154h) 
004115FD 83 C4 08         add         esp,8 
00411600 EB B5            jmp         m1+26h (4115B7h) 
    30: 	cout << endl;
00411602 8B F4            mov         esi,esp 
00411604 A1 44 A3 41 00   mov         eax,dword ptr [__imp_std::endl (41A344h)] 
00411609 50               push        eax  
0041160A 8B 0D 3C A3 41 00 mov         ecx,dword ptr [__imp_std::cout (41A33Ch)] 
00411610 FF 15 24 A3 41 00 call    
  dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (41A324h)] 
00411616 3B F4            cmp         esi,esp 
00411618 E8 87 FB FF FF   call        @ILT+415(__RTC_CheckEsp) (4111A4h) 
    31: }
0041161D 52               push        edx  
0041161E 8B CD            mov         ecx,ebp 
00411620 50               push        eax  
00411621 8D 15 44 16 41 00 lea         edx,[ (411644h)] 
00411627 E8 7E FA FF FF   call        @ILT+165(@_RTC_CheckStackVars@8) (4110AAh) 
0041162C 58               pop         eax  
0041162D 5A               pop         edx  
0041162E 5F               pop         edi  
0041162F 5E               pop         esi  
00411630 5B               pop         ebx  
00411631 81 C4 50 01 00 00 add         esp,150h 
00411637 3B EC            cmp         ebp,esp 
00411639 E8 66 FB FF FF   call        @ILT+415(__RTC_CheckEsp) (4111A4h) 
0041163E 8B E5            mov         esp,ebp 
00411640 5D               pop         ebp  
00411641 C3               ret              
00411642 8B FF            mov         edi,edi

Result:

Return to top page

Using SSE3 commands

#include <iostream>
using namespace std;

int main() {
	float arr1[]={1.0, 2.3, 3.4, 4.3, 5.6, 6.7, 7.8, 8.9}; 
	float arr2[]={2.0, 2.4, 3.5, 4.4, 5.5, 6.6, 7.7, 8.8};
	float res1[]={0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
	float res2[]={0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
    int cnt=sizeof(arr1)/sizeof(float)/4; // cnt=2
	
	__asm {
		lea esi,arr1
		lea edi,arr2
		lea ebx,res1
		mov ecx,cnt // LENGTHOF dont working in VS2008Prof
m1:	    
      //  xorps XMM0,XMM0      //; using for clear register
      //  xorps XMM1,XMM1      //; using for clear register
		movups XMM0,[esi] 
		movups XMM1,[edi]
		haddps XMM0,XMM1

		movups [ebx],XMM0
		add esi,4*TYPE arr1
		add edi,4*TYPE arr2
		add ebx,4*TYPE res1
        loop m1
	}
	for(register int i=0; i<sizeof(arr1)/sizeof(float); i++)
	    cout << res1[i] << " ";
	cout << endl;
}

Result:

Return to top page

ASM Reverse

The power of assembler

Source code

Contents

Asm in VisualStudio_20xx

Highlighting Assembler language in VisualStudio_20xx

Using asm files with c/c++ projects in VisualStudio_20xx

Using assembler in Visual C++/CLI and the .NET Platform

Using SSE commands

Using SSE3 commands