* 가로 행, 세로 열
* 3차원 배열
자료형 이름[높이][행][열]
#include <stdio.h>
int main(void)
{
00A91960 push ebp
00A91961 mov ebp,esp
00A91963 sub esp,110h
00A91969 push ebx
00A9196A push esi
00A9196B push edi
00A9196C lea edi,[ebp-50h]
00A9196F mov ecx,14h
00A91974 mov eax,0CCCCCCCCh
00A91979 rep stos dword ptr es:[edi]
00A9197B mov eax,dword ptr [__security_cookie (0A9A000h)]
00A91980 xor eax,ebp
00A91982 mov dword ptr [ebp-4],eax
00A91985 mov ecx,offset _7C51B9D2_PopuResearch@c (0A9C008h)
00A9198A call @__CheckForDebuggerJustMyCode@4 (0A91339h)
00A9198F nop
int villa[4][2];
int popu, i, j;
// 가구별 거주 인원 입력 받기
for (i = 0; i < 4; i++)
00A91990 mov dword ptr [i],0
00A91997 jmp __$EncStackInitStart+36h (0A919A2h)
00A91999 mov eax,dword ptr [i]
00A9199C add eax,1
00A9199F mov dword ptr [i],eax
00A919A2 cmp dword ptr [i],4
00A919A6 jge __$EncStackInitStart+8Eh (0A919FAh)
{
for (j = 0; j < 2; j++)
00A919A8 mov dword ptr [j],0
00A919AF jmp __$EncStackInitStart+4Eh (0A919BAh)
00A919B1 mov eax,dword ptr [j]
00A919B4 add eax,1
00A919B7 mov dword ptr [j],eax
00A919BA cmp dword ptr [j],2
00A919BE jge __$EncStackInitStart+8Ch (0A919F8h)
{
printf("%d층 %d호 인구수: ", i + 1, j + 1);
00A919C0 mov eax,dword ptr [j]
00A919C3 add eax,1
00A919C6 push eax
00A919C7 mov ecx,dword ptr [i]
00A919CA add ecx,1
00A919CD push ecx
00A919CE push offset string "%d\xc3\xfe %d\xc8\xa3 \xc0\xce\xb1\xb8\xbc\xf6: " (0A97B30h)
00A919D3 call _printf (0A910DCh)
00A919D8 add esp,0Ch
scanf_s("%d", &villa[i][j]);
00A919DB mov eax,dword ptr [i]
00A919DE lea ecx,villa[eax*8]
00A919E2 mov edx,dword ptr [j]
00A919E5 lea eax,[ecx+edx*4]
00A919E8 push eax
00A919E9 push offset string "%d" (0A97B48h)
00A919EE call _scanf_s (0A91294h)
00A919F3 add esp,8
}
00A919F6 jmp __$EncStackInitStart+45h (0A919B1h)
}
00A919F8 jmp __$EncStackInitStart+2Dh (0A91999h)
// 빌라의 층별 인구수 출력하기
for (i = 0; i < 4; i++)
00A919FA mov dword ptr [i],0
00A91A01 jmp __$EncStackInitStart+0A0h (0A91A0Ch)
00A91A03 mov eax,dword ptr [i]
00A91A06 add eax,1
00A91A09 mov dword ptr [i],eax
00A91A0C cmp dword ptr [i],4
00A91A10 jge __$EncStackInitStart+0F7h (0A91A63h)
{
popu = 0;
00A91A12 mov dword ptr [popu],0
popu += villa[i][0];
00A91A19 mov eax,dword ptr [i]
00A91A1C lea ecx,villa[eax*8]
00A91A20 mov edx,4
00A91A25 imul eax,edx,0
00A91A28 mov edx,dword ptr [popu]
00A91A2B add edx,dword ptr [ecx+eax]
00A91A2E mov dword ptr [popu],edx
popu += villa[i][1];
00A91A31 mov eax,dword ptr [i]
00A91A34 lea ecx,villa[eax*8]
00A91A38 mov edx,4
00A91A3D shl edx,0
00A91A40 mov eax,dword ptr [popu]
00A91A43 add eax,dword ptr [ecx+edx]
00A91A46 mov dword ptr [popu],eax
printf("%d층 인구수 : %d\n", i + 1, popu);
00A91A49 mov eax,dword ptr [popu]
00A91A4C push eax
00A91A4D mov ecx,dword ptr [i]
00A91A50 add ecx,1
00A91A53 push ecx
00A91A54 push offset string "%d\xc3\xfe \xc0\xce\xb1\xb8\xbc\xf6 : %d\n" (0A97B4Ch)
00A91A59 call _printf (0A910DCh)
00A91A5E add esp,0Ch
}
00A91A61 jmp __$EncStackInitStart+97h (0A91A03h)
return 0;
00A91A63 xor eax,eax
}
00A91A65 push edx
00A91A66 mov ecx,ebp
00A91A68 push eax
00A91A69 lea edx,ds:[0A91A94h]
00A91A6F call @_RTC_CheckStackVars@8 (0A911F4h)
00A91A74 pop eax
00A91A75 pop edx
00A91A76 pop edi
00A91A77 pop esi
00A91A78 pop ebx
00A91A79 mov ecx,dword ptr [ebp-4]
00A91A7C xor ecx,ebp
00A91A7E call @__security_check_cookie@4 (0A91159h)
00A91A83 add esp,110h
00A91A89 cmp ebp,esp
00A91A8B call __RTC_CheckEsp (0A91258h)
00A91A90 mov esp,ebp
00A91A92 pop ebp
00A91A93 ret
#include <stdio.h>
int main(void)
{
00007FF6D65B1980 push rbp
00007FF6D65B1982 push rdi
00007FF6D65B1983 sub rsp,188h
00007FF6D65B198A lea rbp,[rsp+20h]
00007FF6D65B198F lea rdi,[rsp+20h]
00007FF6D65B1994 mov ecx,2Ah
00007FF6D65B1999 mov eax,0CCCCCCCCh
00007FF6D65B199E rep stos dword ptr [rdi]
00007FF6D65B19A0 mov rax,qword ptr [__security_cookie (07FF6D65BD000h)]
00007FF6D65B19A7 xor rax,rbp
00007FF6D65B19AA mov qword ptr [rbp+158h],rax
00007FF6D65B19B1 lea rcx,[__7C51B9D2_PopuResearch@c (07FF6D65C2008h)]
00007FF6D65B19B8 call __CheckForDebuggerJustMyCode (07FF6D65B137Ah)
00007FF6D65B19BD nop
int villa[4][2];
int popu, i, j;
// 가구별 거주 인원 입력 받기
for (i = 0; i < 4; i++)
00007FF6D65B19BE mov dword ptr [i],0
00007FF6D65B19C5 jmp __$EncStackInitStart+40h (07FF6D65B19CFh)
00007FF6D65B19C7 mov eax,dword ptr [i]
00007FF6D65B19CA inc eax
00007FF6D65B19CC mov dword ptr [i],eax
00007FF6D65B19CF cmp dword ptr [i],4
00007FF6D65B19D3 jge __$EncStackInitStart+0B0h (07FF6D65B1A3Fh)
{
for (j = 0; j < 2; j++)
00007FF6D65B19D5 mov dword ptr [j],0
00007FF6D65B19DF jmp __$EncStackInitStart+60h (07FF6D65B19EFh)
00007FF6D65B19E1 mov eax,dword ptr [j]
00007FF6D65B19E7 inc eax
00007FF6D65B19E9 mov dword ptr [j],eax
00007FF6D65B19EF cmp dword ptr [j],2
00007FF6D65B19F6 jge __$EncStackInitStart+0AEh (07FF6D65B1A3Dh)
{
printf("%d층 %d호 인구수: ", i + 1, j + 1);
00007FF6D65B19F8 mov eax,dword ptr [j]
00007FF6D65B19FE inc eax
00007FF6D65B1A00 mov ecx,dword ptr [i]
00007FF6D65B1A03 inc ecx
00007FF6D65B1A05 mov r8d,eax
00007FF6D65B1A08 mov edx,ecx
00007FF6D65B1A0A lea rcx,[string "%d\xc3\xfe %d\xc8\xa3 \xc0\xce\xb1\xb8\xbc\xf6: " (07FF6D65BAD28h)]
00007FF6D65B1A11 call printf (07FF6D65B119Ah)
00007FF6D65B1A16 nop
scanf_s("%d", &villa[i][j]);
00007FF6D65B1A17 movsxd rax,dword ptr [i]
00007FF6D65B1A1B lea rax,villa[rax*8]
00007FF6D65B1A20 movsxd rcx,dword ptr [j]
00007FF6D65B1A27 lea rax,[rax+rcx*4]
00007FF6D65B1A2B mov rdx,rax
00007FF6D65B1A2E lea rcx,[string "%d" (07FF6D65BAD40h)]
00007FF6D65B1A35 call scanf_s (07FF6D65B1203h)
00007FF6D65B1A3A nop
}
00007FF6D65B1A3B jmp __$EncStackInitStart+52h (07FF6D65B19E1h)
}
00007FF6D65B1A3D jmp __$EncStackInitStart+38h (07FF6D65B19C7h)
// 빌라의 층별 인구수 출력하기
for (i = 0; i < 4; i++)
00007FF6D65B1A3F mov dword ptr [i],0
00007FF6D65B1A46 jmp __$EncStackInitStart+0C1h (07FF6D65B1A50h)
00007FF6D65B1A48 mov eax,dword ptr [i]
00007FF6D65B1A4B inc eax
00007FF6D65B1A4D mov dword ptr [i],eax
00007FF6D65B1A50 cmp dword ptr [i],4
00007FF6D65B1A54 jge __$EncStackInitStart+126h (07FF6D65B1AB5h)
{
popu = 0;
00007FF6D65B1A56 mov dword ptr [popu],0
popu += villa[i][0];
00007FF6D65B1A5D movsxd rax,dword ptr [i]
00007FF6D65B1A61 lea rax,villa[rax*8]
00007FF6D65B1A66 mov ecx,4
00007FF6D65B1A6B imul rcx,rcx,0
00007FF6D65B1A6F mov eax,dword ptr [rax+rcx]
00007FF6D65B1A72 mov ecx,dword ptr [popu]
00007FF6D65B1A75 add ecx,eax
00007FF6D65B1A77 mov eax,ecx
00007FF6D65B1A79 mov dword ptr [popu],eax
popu += villa[i][1];
00007FF6D65B1A7C movsxd rax,dword ptr [i]
00007FF6D65B1A80 lea rax,villa[rax*8]
00007FF6D65B1A85 mov ecx,4
00007FF6D65B1A8A imul rcx,rcx,1
00007FF6D65B1A8E mov eax,dword ptr [rax+rcx]
00007FF6D65B1A91 mov ecx,dword ptr [popu]
00007FF6D65B1A94 add ecx,eax
00007FF6D65B1A96 mov eax,ecx
00007FF6D65B1A98 mov dword ptr [popu],eax
printf("%d층 인구수 : %d\n", i + 1, popu);
00007FF6D65B1A9B mov eax,dword ptr [i]
00007FF6D65B1A9E inc eax
00007FF6D65B1AA0 mov r8d,dword ptr [popu]
00007FF6D65B1AA4 mov edx,eax
00007FF6D65B1AA6 lea rcx,[string "%d\xc3\xfe \xc0\xce\xb1\xb8\xbc\xf6 : %d\n" (07FF6D65BAD48h)]
00007FF6D65B1AAD call printf (07FF6D65B119Ah)
00007FF6D65B1AB2 nop
}
00007FF6D65B1AB3 jmp __$EncStackInitStart+0B9h (07FF6D65B1A48h)
return 0;
00007FF6D65B1AB5 xor eax,eax
}
00007FF6D65B1AB7 mov edi,eax
00007FF6D65B1AB9 lea rcx,[rbp-20h]
00007FF6D65B1ABD lea rdx,[__xt_z+260h (07FF6D65BAD00h)]
00007FF6D65B1AC4 call _RTC_CheckStackVars (07FF6D65B1316h)
00007FF6D65B1AC9 mov eax,edi
00007FF6D65B1ACB mov rcx,qword ptr [rbp+158h]
00007FF6D65B1AD2 xor rcx,rbp
00007FF6D65B1AD5 call __security_check_cookie (07FF6D65B11B3h)
00007FF6D65B1ADA lea rsp,[rbp+168h]
00007FF6D65B1AE1 pop rdi
00007FF6D65B1AE2 pop rbp
00007FF6D65B1AE3 ret
* movsxd(MOVe with Sign eXtend)
32비트 값을 64비트로 부호를 확장하여 복사
#include <stdio.h>
int main(void)
{
00F01870 push ebp
00F01871 mov ebp,esp
00F01873 sub esp,0FCh
00F01879 push ebx
00F0187A push esi
00F0187B push edi
00F0187C lea edi,[ebp-3Ch]
00F0187F mov ecx,0Fh
00F01884 mov eax,0CCCCCCCCh
00F01889 rep stos dword ptr es:[edi]
00F0188B mov eax,dword ptr [__security_cookie (0F0A000h)]
00F01890 xor eax,ebp
00F01892 mov dword ptr [ebp-4],eax
00F01895 mov ecx,offset _B7888422_TwoDimArrayAddr@c (0F0C008h)
00F0189A call @__CheckForDebuggerJustMyCode@4 (0F0132Ah)
00F0189F nop
int arr[3][2];
int i, j;
for (i = 0; i < 3; i++)
00F018A0 mov dword ptr [i],0
00F018A7 jmp __$EncStackInitStart+36h (0F018B2h)
00F018A9 mov eax,dword ptr [i]
00F018AC add eax,1
00F018AF mov dword ptr [i],eax
00F018B2 cmp dword ptr [i],3
00F018B6 jge __$EncStackInitStart+73h (0F018EFh)
for (j = 0; j < 2; j++)
00F018B8 mov dword ptr [j],0
00F018BF jmp __$EncStackInitStart+4Eh (0F018CAh)
00F018C1 mov eax,dword ptr [j]
00F018C4 add eax,1
00F018C7 mov dword ptr [j],eax
00F018CA cmp dword ptr [j],2
00F018CE jge __$EncStackInitStart+71h (0F018EDh)
printf("%p\n", &arr[i][j]);
00F018D0 mov eax,dword ptr [i]
00F018D3 lea ecx,arr[eax*8]
00F018D7 mov edx,dword ptr [j]
00F018DA lea eax,[ecx+edx*4]
00F018DD push eax
00F018DE push offset string "%p\n" (0F07B30h)
00F018E3 call _printf (0F010D2h)
00F018E8 add esp,8
00F018EB jmp __$EncStackInitStart+45h (0F018C1h)
00F018ED jmp __$EncStackInitStart+2Dh (0F018A9h)
return 0;
00F018EF xor eax,eax
}
00F018F1 push edx
00F018F2 mov ecx,ebp
00F018F4 push eax
00F018F5 lea edx,ds:[0F01920h]
00F018FB call @_RTC_CheckStackVars@8 (0F011EAh)
00F01900 pop eax
00F01901 pop edx
00F01902 pop edi
00F01903 pop esi
00F01904 pop ebx
00F01905 mov ecx,dword ptr [ebp-4]
00F01908 xor ecx,ebp
00F0190A call @__security_check_cookie@4 (0F0114Fh)
00F0190F add esp,0FCh
00F01915 cmp ebp,esp
00F01917 call __RTC_CheckEsp (0F0124Eh)
00F0191C mov esp,ebp
00F0191E pop ebp
00F0191F ret
#include <stdio.h>
int main(void)
{
00007FF6DF621890 push rbp
00007FF6DF621892 push rdi
00007FF6DF621893 sub rsp,158h
00007FF6DF62189A lea rbp,[rsp+20h]
00007FF6DF62189F lea rdi,[rsp+20h]
00007FF6DF6218A4 mov ecx,1Eh
00007FF6DF6218A9 mov eax,0CCCCCCCCh
00007FF6DF6218AE rep stos dword ptr [rdi]
00007FF6DF6218B0 mov rax,qword ptr [__security_cookie (07FF6DF62D000h)]
00007FF6DF6218B7 xor rax,rbp
00007FF6DF6218BA mov qword ptr [rbp+128h],rax
00007FF6DF6218C1 lea rcx,[__B7888422_TwoDimArrayAddr@c (07FF6DF632008h)]
00007FF6DF6218C8 call __CheckForDebuggerJustMyCode (07FF6DF62136Bh)
00007FF6DF6218CD nop
int arr[3][2];
int i, j;
for (i = 0; i < 3; i++)
00007FF6DF6218CE mov dword ptr [i],0
00007FF6DF6218D5 jmp __$EncStackInitStart+40h (07FF6DF6218DFh)
00007FF6DF6218D7 mov eax,dword ptr [i]
00007FF6DF6218DA inc eax
00007FF6DF6218DC mov dword ptr [i],eax
00007FF6DF6218DF cmp dword ptr [i],3
00007FF6DF6218E3 jge __$EncStackInitStart+82h (07FF6DF621921h)
for (j = 0; j < 2; j++)
00007FF6DF6218E5 mov dword ptr [j],0
00007FF6DF6218EC jmp __$EncStackInitStart+57h (07FF6DF6218F6h)
00007FF6DF6218EE mov eax,dword ptr [j]
00007FF6DF6218F1 inc eax
00007FF6DF6218F3 mov dword ptr [j],eax
00007FF6DF6218F6 cmp dword ptr [j],2
00007FF6DF6218FA jge __$EncStackInitStart+80h (07FF6DF62191Fh)
printf("%p\n", &arr[i][j]);
00007FF6DF6218FC movsxd rax,dword ptr [i]
00007FF6DF621900 lea rax,arr[rax*8]
00007FF6DF621905 movsxd rcx,dword ptr [j]
00007FF6DF621909 lea rax,[rax+rcx*4]
00007FF6DF62190D mov rdx,rax
00007FF6DF621910 lea rcx,[string "%p\n" (07FF6DF62ACA4h)]
00007FF6DF621917 call printf (07FF6DF621195h)
00007FF6DF62191C nop
00007FF6DF62191D jmp __$EncStackInitStart+4Fh (07FF6DF6218EEh)
00007FF6DF62191F jmp __$EncStackInitStart+38h (07FF6DF6218D7h)
return 0;
00007FF6DF621921 xor eax,eax
}
00007FF6DF621923 mov edi,eax
00007FF6DF621925 lea rcx,[rbp-20h]
00007FF6DF621929 lea rdx,[__xt_z+1E0h (07FF6DF62AC80h)]
00007FF6DF621930 call _RTC_CheckStackVars (07FF6DF621307h)
00007FF6DF621935 mov eax,edi
00007FF6DF621937 mov rcx,qword ptr [rbp+128h]
00007FF6DF62193E xor rcx,rbp
00007FF6DF621941 call __security_check_cookie (07FF6DF6211AEh)
00007FF6DF621946 lea rsp,[rbp+138h]
00007FF6DF62194D pop rdi
00007FF6DF62194E pop rbp
00007FF6DF62194F ret
* 이중 포인터(= 더블 포인터)
포인터의 포인터
포인터 변수를 가리키는 또 다른 포인터 변수
* *(*dptr) == **dptr
#include <stdio.h>
int main(void)
{
00F855F0 push ebp
00F855F1 mov ebp,esp
00F855F3 sub esp,0F8h
00F855F9 push ebx
00F855FA push esi
00F855FB push edi
00F855FC lea edi,[ebp-38h]
00F855FF mov ecx,0Eh
00F85604 mov eax,0CCCCCCCCh
00F85609 rep stos dword ptr es:[edi]
00F8560B mov eax,dword ptr [__security_cookie (0F8A000h)]
00F85610 xor eax,ebp
00F85612 mov dword ptr [ebp-4],eax
00F85615 mov ecx,offset _E110EADE_DoublePointerAccess@c (0F8C008h)
00F8561A call @__CheckForDebuggerJustMyCode@4 (0F8132Ah)
00F8561F nop
double num = 3.14;
00F85620 movsd xmm0,mmword ptr [__real@40091eb851eb851f (0F87C00h)]
00F85628 movsd mmword ptr [num],xmm0
double* ptr = #
00F8562D lea eax,[num]
00F85630 mov dword ptr [ptr],eax
double** dptr = &ptr;
00F85633 lea eax,[ptr]
00F85636 mov dword ptr [dptr],eax
double* ptr2;
printf("%9p %9p\n", ptr, *dptr);
00F85639 mov eax,dword ptr [dptr]
00F8563C mov ecx,dword ptr [eax]
00F8563E push ecx
00F8563F mov edx,dword ptr [ptr]
00F85642 push edx
00F85643 push offset string "%9p %9p\n" (0F87B30h)
00F85648 call _printf (0F810D2h)
00F8564D add esp,0Ch
printf("%9g %9g\n", num, **dptr);
00F85650 mov eax,dword ptr [dptr]
00F85653 mov ecx,dword ptr [eax]
00F85655 sub esp,8
00F85658 movsd xmm0,mmword ptr [ecx]
00F8565C movsd mmword ptr [esp],xmm0
00F85661 sub esp,8
00F85664 movsd xmm0,mmword ptr [num]
00F85669 movsd mmword ptr [esp],xmm0
00F8566E push offset string "%9g %9g\n" (0F87BE8h)
00F85673 call _printf (0F810D2h)
00F85678 add esp,14h
printf("\nnum의 주소 : %p(%d), ptr의 주소 : %p, ptr2의 주소 %p, dptr의 주소 : %p\n\n",
00F8567B lea eax,[dptr]
00F8567E push eax
00F8567F lea ecx,[ptr2]
00F85682 push ecx
00F85683 lea edx,[ptr]
00F85686 push edx
00F85687 lea eax,[num]
00F8568A push eax
00F8568B lea ecx,[num]
00F8568E push ecx
00F8568F push offset string "\nnum\xc0\xc7 \xc1\xd6\xbc\xd2 : %p(%d), ptr\xc0\xc7 \xc1\xd6@"... (0F88620h)
00F85694 call _printf (0F810D2h)
00F85699 add esp,18h
&num, &num, &ptr, &ptr2, &dptr);
ptr2 = *dptr;
00F8569C mov eax,dword ptr [dptr]
00F8569F mov ecx,dword ptr [eax]
00F856A1 mov dword ptr [ptr2],ecx
*ptr2 = 10.99;
00F856A4 mov eax,dword ptr [ptr2]
00F856A7 movsd xmm0,mmword ptr [__real@4025fae147ae147b (0F87B40h)]
00F856AF movsd mmword ptr [eax],xmm0
printf("%9g %9g %9g\n", num, **dptr, *ptr2);
00F856B3 mov eax,dword ptr [ptr2]
00F856B6 sub esp,8
00F856B9 movsd xmm0,mmword ptr [eax]
00F856BD movsd mmword ptr [esp],xmm0
00F856C2 mov ecx,dword ptr [dptr]
00F856C5 mov edx,dword ptr [ecx]
00F856C7 sub esp,8
00F856CA movsd xmm0,mmword ptr [edx]
00F856CE movsd mmword ptr [esp],xmm0
00F856D3 sub esp,8
00F856D6 movsd xmm0,mmword ptr [num]
00F856DB movsd mmword ptr [esp],xmm0
00F856E0 push offset string "%9g %9g %9g\n" (0F87CE8h)
00F856E5 call _printf (0F810D2h)
00F856EA add esp,1Ch
return 0;
00F856ED xor eax,eax
}
00F856EF push edx
00F856F0 mov ecx,ebp
00F856F2 push eax
00F856F3 lea edx,ds:[0F85720h]
00F856F9 call @_RTC_CheckStackVars@8 (0F811EAh)
00F856FE pop eax
00F856FF pop edx
00F85700 pop edi
00F85701 pop esi
00F85702 pop ebx
00F85703 mov ecx,dword ptr [ebp-4]
00F85706 xor ecx,ebp
00F85708 call @__security_check_cookie@4 (0F8114Fh)
00F8570D add esp,0F8h
00F85713 cmp ebp,esp
00F85715 call __RTC_CheckEsp (0F8124Eh)
00F8571A mov esp,ebp
00F8571C pop ebp
00F8571D ret
* printf("%9p %9p\n", ptr, *dptr);
(1)
00F85639 mov eax,dword ptr [dptr]
00F8563C mov ecx,dword ptr [eax]
00F8563E push ecx
(2)
00F8563F mov edx,dword ptr [ptr]
00F85642 push edx
#include <stdio.h>
int main(void)
{
00007FF6BCFD1890 push rbp
00007FF6BCFD1892 push rdi
00007FF6BCFD1893 sub rsp,178h
00007FF6BCFD189A lea rbp,[rsp+30h]
00007FF6BCFD189F lea rdi,[rsp+30h]
00007FF6BCFD18A4 mov ecx,22h
00007FF6BCFD18A9 mov eax,0CCCCCCCCh
00007FF6BCFD18AE rep stos dword ptr [rdi]
00007FF6BCFD18B0 mov rax,qword ptr [__security_cookie (07FF6BCFDD000h)]
00007FF6BCFD18B7 xor rax,rbp
00007FF6BCFD18BA mov qword ptr [rbp+138h],rax
00007FF6BCFD18C1 lea rcx,[__E110EADE_DoublePointerAccess@c (07FF6BCFE2008h)]
00007FF6BCFD18C8 call __CheckForDebuggerJustMyCode (07FF6BCFD136Bh)
00007FF6BCFD18CD nop
double num = 3.14;
00007FF6BCFD18CE movsd xmm0,mmword ptr [__real@40091eb851eb851f (07FF6BCFDAE30h)]
00007FF6BCFD18D6 movsd mmword ptr [num],xmm0
double* ptr = #
00007FF6BCFD18DB lea rax,[num]
00007FF6BCFD18DF mov qword ptr [ptr],rax
double** dptr = &ptr;
00007FF6BCFD18E3 lea rax,[ptr]
00007FF6BCFD18E7 mov qword ptr [dptr],rax
double* ptr2;
printf("%9p %9p\n", ptr, *dptr);
00007FF6BCFD18EB mov rax,qword ptr [dptr]
00007FF6BCFD18EF mov r8,qword ptr [rax]
00007FF6BCFD18F2 mov rdx,qword ptr [ptr]
00007FF6BCFD18F6 lea rcx,[string "%9p %9p\n" (07FF6BCFDADA0h)]
00007FF6BCFD18FD call printf (07FF6BCFD1195h)
00007FF6BCFD1902 nop
printf("%9g %9g\n", num, **dptr);
00007FF6BCFD1903 mov rax,qword ptr [dptr]
00007FF6BCFD1907 mov rax,qword ptr [rax]
00007FF6BCFD190A movsd xmm2,mmword ptr [rax]
00007FF6BCFD190E movq r8,xmm2
00007FF6BCFD1913 movsd xmm1,mmword ptr [num]
00007FF6BCFD1918 movq rdx,xmm1
00007FF6BCFD191D lea rcx,[string "%9g %9g\n" (07FF6BCFDADB0h)]
00007FF6BCFD1924 call printf (07FF6BCFD1195h)
00007FF6BCFD1929 nop
printf("\nnum의 주소 : %p(%d), ptr의 주소 : %p, ptr2의 주소 %p, dptr의 주소 : %p\n\n",
00007FF6BCFD192A lea rax,[dptr]
00007FF6BCFD192E mov qword ptr [rsp+28h],rax
00007FF6BCFD1933 lea rax,[ptr2]
00007FF6BCFD1937 mov qword ptr [rsp+20h],rax
00007FF6BCFD193C lea r9,[ptr]
00007FF6BCFD1940 lea r8,[num]
00007FF6BCFD1944 lea rdx,[num]
00007FF6BCFD1948 lea rcx,[string "\nnum\xc0\xc7 \xc1\xd6\xbc\xd2 : %p(%d), ptr\xc0\xc7 \xc1\xd6@"... (07FF6BCFDADC0h)]
00007FF6BCFD194F call printf (07FF6BCFD1195h)
00007FF6BCFD1954 nop
&num, &num, &ptr, &ptr2, &dptr);
ptr2 = *dptr;
00007FF6BCFD1955 mov rax,qword ptr [dptr]
00007FF6BCFD1959 mov rax,qword ptr [rax]
00007FF6BCFD195C mov qword ptr [ptr2],rax
*ptr2 = 10.99;
00007FF6BCFD1960 mov rax,qword ptr [ptr2]
00007FF6BCFD1964 movsd xmm0,mmword ptr [__real@4025fae147ae147b (07FF6BCFDAE40h)]
00007FF6BCFD196C movsd mmword ptr [rax],xmm0
printf("%9g %9g %9g\n", num, **dptr, *ptr2);
00007FF6BCFD1970 mov rax,qword ptr [dptr]
00007FF6BCFD1974 mov rax,qword ptr [rax]
00007FF6BCFD1977 mov rcx,qword ptr [ptr2]
00007FF6BCFD197B movsd xmm3,mmword ptr [rcx]
00007FF6BCFD197F movq r9,xmm3
00007FF6BCFD1984 movsd xmm2,mmword ptr [rax]
00007FF6BCFD1988 movq r8,xmm2
00007FF6BCFD198D movsd xmm1,mmword ptr [num]
00007FF6BCFD1992 movq rdx,xmm1
00007FF6BCFD1997 lea rcx,[string "%9g %9g %9g\n" (07FF6BCFDAE20h)]
00007FF6BCFD199E call printf (07FF6BCFD1195h)
00007FF6BCFD19A3 nop
return 0;
00007FF6BCFD19A4 xor eax,eax
}
00007FF6BCFD19A6 mov edi,eax
00007FF6BCFD19A8 lea rcx,[rbp-30h]
00007FF6BCFD19AC lea rdx,[__xt_z+2B0h (07FF6BCFDAD50h)]
00007FF6BCFD19B3 call _RTC_CheckStackVars (07FF6BCFD1307h)
00007FF6BCFD19B8 mov eax,edi
00007FF6BCFD19BA mov rcx,qword ptr [rbp+138h]
00007FF6BCFD19C1 xor rcx,rbp
00007FF6BCFD19C4 call __security_check_cookie (07FF6BCFD11AEh)
00007FF6BCFD19C9 lea rsp,[rbp+148h]
00007FF6BCFD19D0 pop rdi
00007FF6BCFD19D1 pop rbp
00007FF6BCFD19D2 ret
* movq 명령어
64비트 데이터를 복사하거나 이동
#include <stdio.h>
int main(void)
{
003E1870 push ebp
003E1871 mov ebp,esp
003E1873 sub esp,12Ch
003E1879 push ebx
003E187A push esi
003E187B push edi
003E187C lea edi,[ebp-6Ch]
003E187F mov ecx,1Bh
003E1884 mov eax,0CCCCCCCCh
003E1889 rep stos dword ptr es:[edi]
003E188B mov eax,dword ptr [__security_cookie (03EA000h)]
003E1890 xor eax,ebp
003E1892 mov dword ptr [ebp-4],eax
003E1895 mov ecx,offset _B586263E_PointerArrayType@c (03EC008h)
003E189A call @__CheckForDebuggerJustMyCode@4 (03E132Ah)
003E189F nop
int num1 = 10, num2 = 20, num3 = 30;
003E18A0 mov dword ptr [num1],0Ah
003E18A7 mov dword ptr [num2],14h
003E18AE mov dword ptr [num3],1Eh
int* ptr1 = &num1;
003E18B5 lea eax,[num1]
003E18B8 mov dword ptr [ptr1],eax
int* ptr2 = &num2;
003E18BB lea eax,[num2]
003E18BE mov dword ptr [ptr2],eax
int* ptr3 = &num3;
003E18C1 lea eax,[num3]
003E18C4 mov dword ptr [ptr3],eax
int* ptrArr[] = { ptr1, ptr2, ptr3 };
003E18C7 mov eax,dword ptr [ptr1]
003E18CA mov dword ptr [ptrArr],eax
003E18CD mov eax,dword ptr [ptr2]
003E18D0 mov dword ptr [ebp-58h],eax
003E18D3 mov eax,dword ptr [ptr3]
003E18D6 mov dword ptr [ebp-54h],eax
int** dptr = ptrArr;
003E18D9 lea eax,[ptrArr]
003E18DC mov dword ptr [dptr],eax
printf("%d %d %d\n", *(ptrArr[0]), *(ptrArr[1]), *(ptrArr[2]));
003E18DF mov eax,4
003E18E4 shl eax,1
003E18E6 mov ecx,dword ptr ptrArr[eax]
003E18EA mov edx,dword ptr [ecx]
003E18EC push edx
003E18ED mov eax,4
003E18F2 shl eax,0
003E18F5 mov ecx,dword ptr ptrArr[eax]
003E18F9 mov edx,dword ptr [ecx]
003E18FB push edx
003E18FC mov eax,4
003E1901 imul ecx,eax,0
003E1904 mov edx,dword ptr ptrArr[ecx]
003E1908 mov eax,dword ptr [edx]
003E190A push eax
003E190B push offset string "%d %d %d\n" (03E7B30h)
003E1910 call _printf (03E10D2h)
003E1915 add esp,10h
printf("%d %d %d\n", *(dptr[0]), *(dptr[1]), *(dptr[2]));
003E1918 mov eax,4
003E191D shl eax,1
003E191F mov ecx,dword ptr [dptr]
003E1922 mov edx,dword ptr [ecx+eax]
003E1925 mov eax,dword ptr [edx]
003E1927 push eax
003E1928 mov ecx,4
003E192D shl ecx,0
003E1930 mov edx,dword ptr [dptr]
003E1933 mov eax,dword ptr [edx+ecx]
003E1936 mov ecx,dword ptr [eax]
003E1938 push ecx
003E1939 mov edx,4
003E193E imul eax,edx,0
003E1941 mov ecx,dword ptr [dptr]
003E1944 mov edx,dword ptr [ecx+eax]
003E1947 mov eax,dword ptr [edx]
003E1949 push eax
003E194A push offset string "%d %d %d\n" (03E7B30h)
003E194F call _printf (03E10D2h)
003E1954 add esp,10h
return 0;
003E1957 xor eax,eax
}
003E1959 push edx
003E195A mov ecx,ebp
003E195C push eax
003E195D lea edx,ds:[3E1988h]
003E1963 call @_RTC_CheckStackVars@8 (03E11EAh)
003E1968 pop eax
003E1969 pop edx
003E196A pop edi
003E196B pop esi
003E196C pop ebx
003E196D mov ecx,dword ptr [ebp-4]
003E1970 xor ecx,ebp
003E1972 call @__security_check_cookie@4 (03E114Fh)
003E1977 add esp,12Ch
003E197D cmp ebp,esp
003E197F call __RTC_CheckEsp (03E124Eh)
003E1984 mov esp,ebp
003E1986 pop ebp
003E1987 ret
#include <stdio.h>
int main(void)
{
00335600 push ebp
00335601 mov ebp,esp
00335603 sub esp,104h
00335609 push ebx
0033560A push esi
0033560B push edi
0033560C lea edi,[ebp-44h]
0033560F mov ecx,11h
00335614 mov eax,0CCCCCCCCh
00335619 rep stos dword ptr es:[edi]
0033561B mov eax,dword ptr [__security_cookie (033A000h)]
00335620 xor eax,ebp
00335622 mov dword ptr [ebp-4],eax
00335625 mov ecx,offset _E2B4C1F4_2DArrPointer@c (033C008h)
0033562A call @__CheckForDebuggerJustMyCode@4 (033132Ah)
0033562F nop
int arr1[3][2];
int arr2[2][3];
printf("arr1 : %p\n\n", arr1);
00335630 lea eax,[arr1]
00335633 push eax
00335634 push offset string "arr1 : %p\n\n" (0337B30h)
00335639 call _printf (03310D2h)
0033563E add esp,8
printf("arr1 + 1 : %p\n", arr1 + 1);
00335641 lea eax,[ebp-18h]
00335644 push eax
00335645 push offset string "arr1 + 1 : %p\n" (0337B40h)
0033564A call _printf (03310D2h)
0033564F add esp,8
printf("arr1 + 2 : %p\n\n", arr1 + 2);
00335652 lea eax,[ebp-10h]
00335655 push eax
00335656 push offset string "arr1 + 2 : %p\n\n" (0337B54h)
0033565B call _printf (03310D2h)
00335660 add esp,8
printf("arr2 : %p\n", arr2);
00335663 lea eax,[arr2]
00335666 push eax
00335667 push offset string "arr2 : %p\n" (0337D40h)
0033566C call _printf (03310D2h)
00335671 add esp,8
printf("arr2 + 1 : %p\n", arr2 + 1);
00335674 lea eax,[ebp-34h]
00335677 push eax
00335678 push offset string "arr2 + 1 : %p\n" (0337B78h)
0033567D call _printf (03310D2h)
00335682 add esp,8
printf("arr2 + 2 : %p\n\n", arr2 + 2);
00335685 lea eax,[ebp-28h]
00335688 push eax
00335689 push offset string "arr2 + 2 : %p\n\n" (0337B8Ch)
0033568E call _printf (03310D2h)
00335693 add esp,8
printf("(arr1 + 1)[0] : %p\n", (arr1 + 1)[0]);
00335696 mov eax,8
0033569B imul ecx,eax,0
0033569E lea edx,[ebp+ecx-18h]
003356A2 push edx
003356A3 push offset string "(arr1 + 1)[0] : %p\n" (0337B64h)
003356A8 call _printf (03310D2h)
003356AD add esp,8
printf("(arr1 + 1)[1] : %p\n\n", (arr1 + 1)[1]);
003356B0 mov eax,8
003356B5 shl eax,0
003356B8 lea ecx,[ebp+eax-18h]
003356BC push ecx
003356BD push offset string "(arr1 + 1)[1] : %p\n\n" (0337C3Ch)
003356C2 call _printf (03310D2h)
003356C7 add esp,8
printf("(arr1 + 2)[0] : %p\n", (arr1 + 2)[0]);
003356CA mov eax,8
003356CF imul ecx,eax,0
003356D2 lea edx,[ebp+ecx-10h]
003356D6 push edx
003356D7 push offset string "(arr1 + 2)[0] : %p\n" (0337D4Ch)
003356DC call _printf (03310D2h)
003356E1 add esp,8
printf("(arr1 + 2)[1] : %p\n\n", (arr1 + 2)[1]);
003356E4 mov eax,8
003356E9 shl eax,0
003356EC lea ecx,[ebp+eax-10h]
003356F0 push ecx
003356F1 push offset string "(arr1 + 2)[1] : %p\n\n" (0337E90h)
003356F6 call _printf (03310D2h)
003356FB add esp,8
printf("(arr1 + 1)[4] : %p\n", (arr1 + 1)[4]);
003356FE mov eax,8
00335703 shl eax,2
00335706 lea ecx,[ebp+eax-18h]
0033570A push ecx
0033570B push offset string "(arr1 + 1)[4] : %p\n" (0337EA8h)
00335710 call _printf (03310D2h)
00335715 add esp,8
printf("(arr1 + 2)[4] : %p\n\n", (arr1 + 2)[4]);
00335718 mov eax,8
0033571D shl eax,2
00335720 lea ecx,[ebp+eax-10h]
00335724 push ecx
00335725 push offset string "(arr1 + 2)[4] : %p\n\n" (0337FF4h)
0033572A call _printf (03310D2h)
0033572F add esp,8
return 0;
00335732 xor eax,eax
}
00335734 push edx
00335735 mov ecx,ebp
00335737 push eax
00335738 lea edx,ds:[335764h]
0033573E call @_RTC_CheckStackVars@8 (03311EAh)
00335743 pop eax
00335744 pop edx
00335745 pop edi
00335746 pop esi
00335747 pop ebx
00335748 mov ecx,dword ptr [ebp-4]
0033574B xor ecx,ebp
0033574D call @__security_check_cookie@4 (033114Fh)
00335752 add esp,104h
00335758 cmp ebp,esp
0033575A call __RTC_CheckEsp (033124Eh)
0033575F mov esp,ebp
00335761 pop ebp
00335762 ret
#include <stdio.h>
int main(void)
{
00421870 push ebp
00421871 mov ebp,esp
00421873 sub esp,13Ch
00421879 push ebx
0042187A push esi
0042187B push edi
0042187C lea edi,[ebp-7Ch]
0042187F mov ecx,1Fh
00421884 mov eax,0CCCCCCCCh
00421889 rep stos dword ptr es:[edi]
0042188B mov eax,dword ptr [__security_cookie (042A000h)]
00421890 xor eax,ebp
00421892 mov dword ptr [ebp-4],eax
00421895 mov ecx,offset _15A98840_2DArrNameAndArrPtr@c (042C008h)
0042189A call @__CheckForDebuggerJustMyCode@4 (042132Ah)
0042189F nop
int arr1[2][2] = {
004218A0 mov dword ptr [arr1],1
004218A7 mov dword ptr [ebp-14h],2
004218AE mov dword ptr [ebp-10h],3
004218B5 mov dword ptr [ebp-0Ch],4
{1, 2}, {3, 4}
};
int arr2[3][2] = {
004218BC mov dword ptr [arr2],1
004218C3 mov dword ptr [ebp-34h],2
004218CA mov dword ptr [ebp-30h],3
004218D1 mov dword ptr [ebp-2Ch],4
004218D8 mov dword ptr [ebp-28h],3
004218DF mov dword ptr [ebp-24h],6
{1, 2}, {3, 4}, {3, 6}
};
int arr3[4][2] = {
004218E6 mov dword ptr [arr3],1
004218ED mov dword ptr [ebp-5Ch],2
004218F4 mov dword ptr [ebp-58h],3
004218FB mov dword ptr [ebp-54h],4
00421902 mov dword ptr [ebp-50h],3
00421909 mov dword ptr [ebp-4Ch],6
00421910 mov dword ptr [ebp-48h],7
00421917 mov dword ptr [ebp-44h],8
{1, 2}, {3, 4}, {3, 6}, {7, 8}
};
int (*ptr)[2];
int i;
ptr = arr1;
0042191E lea eax,[arr1]
00421921 mov dword ptr [ptr],eax
printf("** Show 2, 2 arr1\n");
00421924 push offset string "** Show 2, 2 arr1\n" (0427B30h)
00421929 call _printf (04210D2h)
0042192E add esp,4
for (i = 0; i < 2; i++)
00421931 mov dword ptr [i],0
00421938 jmp __$EncStackInitStart+0C7h (0421943h)
0042193A mov eax,dword ptr [i]
0042193D add eax,1
00421940 mov dword ptr [i],eax
00421943 cmp dword ptr [i],2
00421947 jge __$EncStackInitStart+106h (0421982h)
printf("%d %d\n", ptr[i][0], ptr[i][1]);
00421949 mov eax,dword ptr [i]
0042194C mov ecx,dword ptr [ptr]
0042194F lea edx,[ecx+eax*8]
00421952 mov eax,4
00421957 shl eax,0
0042195A mov ecx,dword ptr [edx+eax]
0042195D push ecx
0042195E mov edx,dword ptr [i]
00421961 mov eax,dword ptr [ptr]
00421964 lea ecx,[eax+edx*8]
00421967 mov edx,4
0042196C imul eax,edx,0
0042196F mov ecx,dword ptr [ecx+eax]
00421972 push ecx
00421973 push offset string "%d %d\n" (0427B48h)
00421978 call _printf (04210D2h)
0042197D add esp,0Ch
00421980 jmp __$EncStackInitStart+0BEh (042193Ah)
ptr = arr2;
00421982 lea eax,[arr2]
00421985 mov dword ptr [ptr],eax
printf("** Show 3, 2 arr1\n");
00421988 push offset string "** Show 3, 2 arr1\n" (0427B50h)
0042198D call _printf (04210D2h)
00421992 add esp,4
for (i = 0; i < 3; i++)
00421995 mov dword ptr [i],0
0042199C jmp __$EncStackInitStart+12Bh (04219A7h)
0042199E mov eax,dword ptr [i]
004219A1 add eax,1
004219A4 mov dword ptr [i],eax
004219A7 cmp dword ptr [i],3
004219AB jge __$EncStackInitStart+16Ah (04219E6h)
printf("%d %d\n", ptr[i][0], ptr[i][1]);
004219AD mov eax,dword ptr [i]
004219B0 mov ecx,dword ptr [ptr]
004219B3 lea edx,[ecx+eax*8]
004219B6 mov eax,4
004219BB shl eax,0
004219BE mov ecx,dword ptr [edx+eax]
004219C1 push ecx
004219C2 mov edx,dword ptr [i]
004219C5 mov eax,dword ptr [ptr]
004219C8 lea ecx,[eax+edx*8]
004219CB mov edx,4
004219D0 imul eax,edx,0
004219D3 mov ecx,dword ptr [ecx+eax]
004219D6 push ecx
004219D7 push offset string "%d %d\n" (0427B48h)
004219DC call _printf (04210D2h)
004219E1 add esp,0Ch
004219E4 jmp __$EncStackInitStart+122h (042199Eh)
ptr = arr3;
004219E6 lea eax,[arr3]
004219E9 mov dword ptr [ptr],eax
printf("** Show 4, 2 arr1\n");
004219EC push offset string "** Show 4, 2 arr1\n" (0427B68h)
004219F1 call _printf (04210D2h)
004219F6 add esp,4
for (i = 0; i < 4; i++)
004219F9 mov dword ptr [i],0
00421A00 jmp __$EncStackInitStart+18Fh (0421A0Bh)
00421A02 mov eax,dword ptr [i]
00421A05 add eax,1
00421A08 mov dword ptr [i],eax
00421A0B cmp dword ptr [i],4
00421A0F jge __$EncStackInitStart+1CEh (0421A4Ah)
printf("%d %d\n", ptr[i][0], ptr[i][1]);
00421A11 mov eax,dword ptr [i]
00421A14 mov ecx,dword ptr [ptr]
00421A17 lea edx,[ecx+eax*8]
00421A1A mov eax,4
00421A1F shl eax,0
00421A22 mov ecx,dword ptr [edx+eax]
00421A25 push ecx
00421A26 mov edx,dword ptr [i]
00421A29 mov eax,dword ptr [ptr]
00421A2C lea ecx,[eax+edx*8]
00421A2F mov edx,4
00421A34 imul eax,edx,0
00421A37 mov ecx,dword ptr [ecx+eax]
00421A3A push ecx
00421A3B push offset string "%d %d\n" (0427B48h)
00421A40 call _printf (04210D2h)
00421A45 add esp,0Ch
00421A48 jmp __$EncStackInitStart+186h (0421A02h)
return 0;
00421A4A xor eax,eax
}
00421A4C push edx
00421A4D mov ecx,ebp
00421A4F push eax
00421A50 lea edx,ds:[421A7Ch]
00421A56 call @_RTC_CheckStackVars@8 (04211EAh)
00421A5B pop eax
00421A5C pop edx
00421A5D pop edi
00421A5E pop esi
00421A5F pop ebx
00421A60 mov ecx,dword ptr [ebp-4]
00421A63 xor ecx,ebp
00421A65 call @__security_check_cookie@4 (042114Fh)
00421A6A add esp,13Ch
00421A70 cmp ebp,esp
00421A72 call __RTC_CheckEsp (042124Eh)
00421A77 mov esp,ebp
00421A79 pop ebp
00421A7A ret
* 배열 포인터와 포인터 배열
int* whoA[4]; // 포인터 배열
int (*whoA)[4]; // 배열 포인터
#include <stdio.h>
int main(void)
{
003F1870 push ebp
003F1871 mov ebp,esp
003F1873 sub esp,158h
003F1879 push ebx
003F187A push esi
003F187B push edi
003F187C lea edi,[ebp-98h]
003F1882 mov ecx,26h
003F1887 mov eax,0CCCCCCCCh
003F188C rep stos dword ptr es:[edi]
003F188E mov eax,dword ptr [__security_cookie (03FA000h)]
003F1893 xor eax,ebp
003F1895 mov dword ptr [ebp-4],eax
003F1898 mov ecx,offset _F83B8595_ArrPtrAndPtrArr@c (03FC008h)
003F189D call @__CheckForDebuggerJustMyCode@4 (03F132Ah)
003F18A2 nop
int num1 = 10, num2 = 20, num3 = 30, num4 = 40;
003F18A3 mov dword ptr [num1],0Ah
003F18AA mov dword ptr [num2],14h
003F18B1 mov dword ptr [num3],1Eh
003F18B8 mov dword ptr [num4],28h
int arr2d[2][4] = { 1,2,3,4,5,6,7,8 };
003F18BF mov dword ptr [arr2d],1
003F18C6 mov dword ptr [ebp-54h],2
003F18CD mov dword ptr [ebp-50h],3
003F18D4 mov dword ptr [ebp-4Ch],4
003F18DB mov dword ptr [ebp-48h],5
003F18E2 mov dword ptr [ebp-44h],6
003F18E9 mov dword ptr [ebp-40h],7
003F18F0 mov dword ptr [ebp-3Ch],8
int i, j;
int* whoA[4] = { &num1, &num2, &num3, &num4 };
003F18F7 lea eax,[num1]
003F18FA mov dword ptr [whoA],eax
003F1900 lea eax,[num2]
003F1903 mov dword ptr [ebp-84h],eax
003F1909 lea eax,[num3]
003F190C mov dword ptr [ebp-80h],eax
003F190F lea eax,[num4]
003F1912 mov dword ptr [ebp-7Ch],eax
int (*whoB)[4] = arr2d;
003F1915 lea eax,[arr2d]
003F1918 mov dword ptr [whoB],eax
printf("%d %d %d %d\n", *whoA[0], *whoA[1], *whoA[2], *whoA[3]);
003F191E mov eax,4
003F1923 imul ecx,eax,3
003F1926 mov edx,dword ptr whoA[ecx]
003F192D mov eax,dword ptr [edx]
003F192F push eax
003F1930 mov ecx,4
003F1935 shl ecx,1
003F1937 mov edx,dword ptr whoA[ecx]
003F193E mov eax,dword ptr [edx]
003F1940 push eax
003F1941 mov ecx,4
003F1946 shl ecx,0
003F1949 mov edx,dword ptr whoA[ecx]
003F1950 mov eax,dword ptr [edx]
003F1952 push eax
003F1953 mov ecx,4
003F1958 imul edx,ecx,0
003F195B mov eax,dword ptr whoA[edx]
003F1962 mov ecx,dword ptr [eax]
003F1964 push ecx
003F1965 push offset string "%d %d %d %d\n" (03F7B30h)
003F196A call _printf (03F10D2h)
003F196F add esp,14h
for (i = 0; i < 2; i++)
003F1972 mov dword ptr [i],0
003F1979 jmp __$EncStackInitStart+108h (03F1984h)
003F197B mov eax,dword ptr [i]
003F197E add eax,1
003F1981 mov dword ptr [i],eax
003F1984 cmp dword ptr [i],2
003F1988 jge __$EncStackInitStart+157h (03F19D3h)
{
for (j = 0; j < 4; j++)
003F198A mov dword ptr [j],0
003F1991 jmp __$EncStackInitStart+120h (03F199Ch)
003F1993 mov eax,dword ptr [j]
003F1996 add eax,1
003F1999 mov dword ptr [j],eax
003F199C cmp dword ptr [j],4
003F19A0 jge __$EncStackInitStart+148h (03F19C4h)
printf("%d ", whoB[i][j]);
003F19A2 mov eax,dword ptr [i]
003F19A5 shl eax,4
003F19A8 add eax,dword ptr [whoB]
003F19AE mov ecx,dword ptr [j]
003F19B1 mov edx,dword ptr [eax+ecx*4]
003F19B4 push edx
003F19B5 push offset string "%d " (03F7B40h)
003F19BA call _printf (03F10D2h)
003F19BF add esp,8
003F19C2 jmp __$EncStackInitStart+117h (03F1993h)
printf("\n");
003F19C4 push offset string "\n" (03F7B44h)
003F19C9 call _printf (03F10D2h)
003F19CE add esp,4
}
003F19D1 jmp __$EncStackInitStart+0FFh (03F197Bh)
return 0;
003F19D3 xor eax,eax
}
003F19D5 push edx
003F19D6 mov ecx,ebp
003F19D8 push eax
003F19D9 lea edx,ds:[3F1A04h]
003F19DF call @_RTC_CheckStackVars@8 (03F11EAh)
003F19E4 pop eax
003F19E5 pop edx
003F19E6 pop edi
003F19E7 pop esi
003F19E8 pop ebx
003F19E9 mov ecx,dword ptr [ebp-4]
003F19EC xor ecx,ebp
003F19EE call @__security_check_cookie@4 (03F114Fh)
003F19F3 add esp,158h
003F19F9 cmp ebp,esp
003F19FB call __RTC_CheckEsp (03F124Eh)
003F1A00 mov esp,ebp
003F1A02 pop ebp
003F1A03 ret
* 2차원 배열에서도 arr[i] == *(arr + i)는 같다
int main(void)
{
00251950 push ebp
00251951 mov ebp,esp
00251953 sub esp,0FCh
00251959 push ebx
0025195A push esi
0025195B push edi
0025195C lea edi,[ebp-3Ch]
0025195F mov ecx,0Fh
00251964 mov eax,0CCCCCCCCh
00251969 rep stos dword ptr es:[edi]
0025196B mov ecx,offset _A3320C7D_FunctionPointer@c (025C008h)
00251970 call @__CheckForDebuggerJustMyCode@4 (0251334h)
00251975 nop
char* str = "Function Pointer";
00251976 mov dword ptr [str],offset string "Function Pointer" (0257B44h)
int num1 = 10, num2 = 20;
0025197D mov dword ptr [num1],0Ah
00251984 mov dword ptr [num2],14h
void (*fptr1)(int, int) = SimpleAdder;
0025198B mov dword ptr [fptr1],offset _SimpleAdder (0251244h)
void (*fptr2)(char*) = ShowString;
00251992 mov dword ptr [fptr2],offset _ShowString (025122Bh)
// 함수 포인터 변수에 의한 호출
fptr1(num1, num2);
00251999 mov esi,esp
0025199B mov eax,dword ptr [num2]
0025199E push eax
0025199F mov ecx,dword ptr [num1]
002519A2 push ecx
002519A3 call dword ptr [fptr1]
002519A6 add esp,8
002519A9 cmp esi,esp
002519AB call __RTC_CheckEsp (0251258h)
002519B0 nop
fptr2(str);
002519B1 mov esi,esp
002519B3 mov eax,dword ptr [str]
002519B6 push eax
002519B7 call dword ptr [fptr2]
002519BA add esp,4
002519BD cmp esi,esp
002519BF call __RTC_CheckEsp (0251258h)
002519C4 nop
return 0;
002519C5 xor eax,eax
}
002519C7 pop edi
002519C8 pop esi
002519C9 pop ebx
002519CA add esp,0FCh
002519D0 cmp ebp,esp
002519D2 call __RTC_CheckEsp (0251258h)
002519D7 mov esp,ebp
002519D9 pop ebp
002519DA ret
int main(void)
{
00007FF77EA21960 push rbp
00007FF77EA21962 push rdi
00007FF77EA21963 sub rsp,188h
00007FF77EA2196A lea rbp,[rsp+20h]
00007FF77EA2196F lea rcx,[__A3320C7D_FunctionPointer@c (07FF77EA32008h)]
00007FF77EA21976 call __CheckForDebuggerJustMyCode (07FF77EA21375h)
00007FF77EA2197B nop
char* str = "Function Pointer";
00007FF77EA2197C lea rax,[string "Function Pointer" (07FF77EA2AC40h)]
00007FF77EA21983 mov qword ptr [str],rax
int num1 = 10, num2 = 20;
00007FF77EA21987 mov dword ptr [num1],0Ah
00007FF77EA2198E mov dword ptr [num2],14h
void (*fptr1)(int, int) = SimpleAdder;
00007FF77EA21995 lea rax,[SimpleAdder (07FF77EA21253h)]
00007FF77EA2199C mov qword ptr [fptr1],rax
void (*fptr2)(char*) = ShowString;
00007FF77EA219A0 lea rax,[ShowString (07FF77EA2106Eh)]
00007FF77EA219A7 mov qword ptr [fptr2],rax
// 함수 포인터 변수에 의한 호출
fptr1(num1, num2);
00007FF77EA219AE mov edx,dword ptr [num2]
00007FF77EA219B1 mov ecx,dword ptr [num1]
00007FF77EA219B4 call qword ptr [fptr1]
00007FF77EA219B7 nop
fptr2(str);
00007FF77EA219B8 mov rcx,qword ptr [str]
00007FF77EA219BC call qword ptr [fptr2]
00007FF77EA219C2 nop
return 0;
00007FF77EA219C3 xor eax,eax
}
00007FF77EA219C5 lea rsp,[rbp+168h]
00007FF77EA219CC pop rdi
00007FF77EA219CD pop rbp
00007FF77EA219CE ret
int main(void)
{
00ED19D0 push ebp
00ED19D1 mov ebp,esp
00ED19D3 sub esp,0E4h
00ED19D9 push ebx
00ED19DA push esi
00ED19DB push edi
00ED19DC lea edi,[ebp-24h]
00ED19DF mov ecx,9
00ED19E4 mov eax,0CCCCCCCCh
00ED19E9 rep stos dword ptr es:[edi]
00ED19EB mov ecx,offset _EDD9FEEB_UsefulFunctionPointer@c (0EDC008h)
00ED19F0 call @__CheckForDebuggerJustMyCode@4 (0ED1339h)
00ED19F5 nop
int age1 = 20;
00ED19F6 mov dword ptr [age1],14h
int age2 = 30;
00ED19FD mov dword ptr [age2],1Eh
int first;
printf("입장순서1\n");
00ED1A04 push offset string "\xc0\xd4\xc0\xe5\xbc\xf8\xbc\xad1\n" (0ED7B30h)
00ED1A09 call _printf (0ED10DCh)
00ED1A0E add esp,4
first = WhoIsFirst(age1, age2, OlderFirst);
00ED1A11 push offset _OlderFirst (0ED10B9h)
00ED1A16 mov eax,dword ptr [age2]
00ED1A19 push eax
00ED1A1A mov ecx,dword ptr [age1]
00ED1A1D push ecx
00ED1A1E call _WhoIsFirst (0ED1073h)
00ED1A23 add esp,0Ch
00ED1A26 mov dword ptr [first],eax
printf("%d세와 %d세 중 %d세가 먼저 입장!\n\n", age1, age2, first);
00ED1A29 mov eax,dword ptr [first]
00ED1A2C push eax
00ED1A2D mov ecx,dword ptr [age2]
00ED1A30 push ecx
00ED1A31 mov edx,dword ptr [age1]
00ED1A34 push edx
00ED1A35 push offset string "%d\xbc\xbc\xbf\xcd %d\xbc\xbc \xc1\xdf %d\xbc\xbc\xb0\xa1 \xb8\xd5\xc0\xfa \xc0\xd4\xc0\xe5@"... (0ED7B40h)
00ED1A3A call _printf (0ED10DCh)
00ED1A3F add esp,10h
printf("입장순서2\n");
00ED1A42 push offset string "\xc0\xd4\xc0\xe5\xbc\xf8\xbc\xad2\n" (0ED7B6Ch)
00ED1A47 call _printf (0ED10DCh)
00ED1A4C add esp,4
first = WhoIsFirst(age1, age2, YoungFirst);
00ED1A4F push offset _YoungFirst (0ED110Eh)
00ED1A54 mov eax,dword ptr [age2]
00ED1A57 push eax
00ED1A58 mov ecx,dword ptr [age1]
00ED1A5B push ecx
00ED1A5C call _WhoIsFirst (0ED1073h)
00ED1A61 add esp,0Ch
00ED1A64 mov dword ptr [first],eax
printf("%d세와 %d세 중 %d세가 먼저 입장!\n\n", age1, age2, first);
00ED1A67 mov eax,dword ptr [first]
00ED1A6A push eax
00ED1A6B mov ecx,dword ptr [age2]
00ED1A6E push ecx
00ED1A6F mov edx,dword ptr [age1]
00ED1A72 push edx
00ED1A73 push offset string "%d\xbc\xbc\xbf\xcd %d\xbc\xbc \xc1\xdf %d\xbc\xbc\xb0\xa1 \xb8\xd5\xc0\xfa \xc0\xd4\xc0\xe5@"... (0ED7B40h)
00ED1A78 call _printf (0ED10DCh)
00ED1A7D add esp,10h
return 0;
00ED1A80 xor eax,eax
}
00ED1A82 pop edi
00ED1A83 pop esi
00ED1A84 pop ebx
00ED1A85 add esp,0E4h
00ED1A8B cmp ebp,esp
00ED1A8D call __RTC_CheckEsp (0ED125Dh)
00ED1A92 mov esp,ebp
00ED1A94 pop ebp
00ED1A95 ret
int main(void)
{
00007FF6B1F11A10 push rbp
00007FF6B1F11A12 push rdi
00007FF6B1F11A13 sub rsp,148h
00007FF6B1F11A1A lea rbp,[rsp+20h]
00007FF6B1F11A1F lea rcx,[__EDD9FEEB_UsefulFunctionPointer@c (07FF6B1F22008h)]
00007FF6B1F11A26 call __CheckForDebuggerJustMyCode (07FF6B1F1137Ah)
00007FF6B1F11A2B nop
int age1 = 20;
00007FF6B1F11A2C mov dword ptr [age1],14h
int age2 = 30;
00007FF6B1F11A33 mov dword ptr [age2],1Eh
int first;
printf("입장순서1\n");
00007FF6B1F11A3A lea rcx,[string "\xc0\xd4\xc0\xe5\xbc\xf8\xbc\xad1\n" (07FF6B1F1AC28h)]
00007FF6B1F11A41 call printf (07FF6B1F111A4h)
00007FF6B1F11A46 nop
first = WhoIsFirst(age1, age2, OlderFirst);
00007FF6B1F11A47 lea r8,[OlderFirst (07FF6B1F11078h)]
00007FF6B1F11A4E mov edx,dword ptr [age2]
00007FF6B1F11A51 mov ecx,dword ptr [age1]
00007FF6B1F11A54 call WhoIsFirst (07FF6B1F1111Dh)
00007FF6B1F11A59 mov dword ptr [first],eax
printf("%d세와 %d세 중 %d세가 먼저 입장!\n\n", age1, age2, first);
00007FF6B1F11A5C mov r9d,dword ptr [first]
00007FF6B1F11A60 mov r8d,dword ptr [age2]
00007FF6B1F11A64 mov edx,dword ptr [age1]
00007FF6B1F11A67 lea rcx,[string "%d\xbc\xbc\xbf\xcd %d\xbc\xbc \xc1\xdf %d\xbc\xbc\xb0\xa1 \xb8\xd5\xc0\xfa \xc0\xd4\xc0\xe5@"... (07FF6B1F1AC38h)]
00007FF6B1F11A6E call printf (07FF6B1F111A4h)
00007FF6B1F11A73 nop
printf("입장순서2\n");
00007FF6B1F11A74 lea rcx,[string "\xc0\xd4\xc0\xe5\xbc\xf8\xbc\xad2\n" (07FF6B1F1AC68h)]
00007FF6B1F11A7B call printf (07FF6B1F111A4h)
00007FF6B1F11A80 nop
first = WhoIsFirst(age1, age2, YoungFirst);
00007FF6B1F11A81 lea r8,[YoungFirst (07FF6B1F11109h)]
00007FF6B1F11A88 mov edx,dword ptr [age2]
00007FF6B1F11A8B mov ecx,dword ptr [age1]
00007FF6B1F11A8E call WhoIsFirst (07FF6B1F1111Dh)
00007FF6B1F11A93 mov dword ptr [first],eax
printf("%d세와 %d세 중 %d세가 먼저 입장!\n\n", age1, age2, first);
00007FF6B1F11A96 mov r9d,dword ptr [first]
00007FF6B1F11A9A mov r8d,dword ptr [age2]
00007FF6B1F11A9E mov edx,dword ptr [age1]
00007FF6B1F11AA1 lea rcx,[string "%d\xbc\xbc\xbf\xcd %d\xbc\xbc \xc1\xdf %d\xbc\xbc\xb0\xa1 \xb8\xd5\xc0\xfa \xc0\xd4\xc0\xe5@"... (07FF6B1F1AC38h)]
00007FF6B1F11AA8 call printf (07FF6B1F111A4h)
00007FF6B1F11AAD nop
return 0;
00007FF6B1F11AAE xor eax,eax
}
00007FF6B1F11AB0 lea rsp,[rbp+128h]
00007FF6B1F11AB7 pop rdi
00007FF6B1F11AB8 pop rbp
00007FF6B1F11AB9 ret
'IT공부 > IT서적' 카테고리의 다른 글
| [뇌를 자극하는 윈도우즈 시스템 프로그래밍] 10장. 컴퓨터 구조 - 3 (0) | 2025.01.30 |
|---|---|
| [윤성우 열혈 C프로그래밍] Chapter21 (0) | 2025.01.30 |
| [뇌를 자극하는 윈도우즈 시스템 프로그래밍] 9장. 스케줄링 알고리즘과 우선순위 (0) | 2025.01.28 |
| [윤성우 열혈 C프로그래밍] 디버깅 빌드, 어셈블리 코드 - Chapter11, Chapter12, Chapter13, Chapter14 (0) | 2025.01.27 |
| [뇌를 자극하는 윈도우즈 시스템 프로그래밍] 8장. 프로세스간 통신(IPC) - 2 (0) | 2025.01.21 |