[1]
# include <stdio.h>
# include <Windows.h>
int main(void) {
//________________________________________________
BYTE number_byte[] = { 10, 20, 30, 40, 50, 60 };
DWORD TotalSum = 0x0;
BYTE* str_value = "%#x\n";
BYTE* total_sum_str = "summation => [%d]\n";
//________________________________________________
__asm LEA edi, dword ptr[number_byte]; // edi = &number_byte
__asm {
MOV ecx, 0x6;
MOV edx, 0x0;
L:
PUSH edx;
PUSH ecx;
MOVZX eax, BYTE ptr[edi + edx]; // eax =
ADD TotalSum, eax;
PUSH eax;
PUSH str_value;
CALL dword ptr[printf];
POP ebx;
POP ebx;
POP ecx;
POP edx;
INC edx;
LOOP L;
PUSH TotalSum;
PUSH total_sum_str;
CALL dword ptr[printf];
POP ebx;
POP ebx;
}
return 0;
}
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
[3]
# include <stdio.h>
# include <Windows.h>
# define SIZE 6
//____________________________________
typedef struct Rev_arry{
DWORD Before_arry[6];
DWORD After_arry[6];
}Rev_arry, *ptr_arry;
//____________________________________
// [function prototype]
void _Init_(PVOID param);
void _Do_Rev_(PVOID param);
void _Data_printf(PVOID param);
//____________________________________
//____________________________________
int main(void) {
Rev_arry s = { 0, };
__asm {
LEA EDI, dword ptr[s]; // EDI = &s
//________________________________
PUSH EDI;
CALL dword ptr[_Init_];
POP EDI;
//________________________________
PUSH EDI;
CALL dword ptr[_Do_Rev_];
POP EDI;
//________________________________
PUSH EDI;
CALL dword ptr[_Data_printf];
POP EDI;
//________________________________
}
return 0;
} // end of main function
//____________________________________
void _Init_(PVOID param) {
__asm {
MOV EAX, dword ptr ss : [ebp + 0x8];
MOV EBX, 0xa;
MOV ECX, 0x6;
MOV EDX, 0x0;
L: // Loop Label
// [ PUSH ]_________________________________
PUSH EDX;
PUSH EBX;
PUSH ECX;
MOV DWORD PTR[EAX + EDX], EBX;
// [ POP ]_________________________________
POP ECX; // => POP_1
POP EBX; // => POP_2
INC EBX;
POP EDX; // => POP_3
ADD EDX, 0x4;
LOOP L;
}
} //
//____________________________________
void _Do_Rev_(PVOID param) {
__asm {
MOV EAX, dword ptr ss : [ebp + 0x8]; // EAX = param
MOV EDX, 0x14;
MOV EBX, 0x18;
// loop
MOV ECX, 0x6;
L:
PUSH EBX;
PUSH EDX;
PUSH EAX; // EAX 값 보존
PUSH ECX; // ECX 값 보존
PUSH dword ptr[EAX + EDX];
//POP EDX;
//SUB EDX, 0x4;
pop dword ptr[EAX + EBX];
POP ECX;
POP EAX;
POP EDX;
SUB EDX, 0x4;
POP EBX;
ADD EBX, 0X4;
LOOP L;
}
} // end of _Do_Rev_ function
void _Data_printf(PVOID param) {
char* sprompt = "%#x ";
__asm {
MOV EAX, dword ptr ss : [ebp + 0x8];
MOV ECX, 0x6; // ecx = 0x6
MOV EDX, 0x18; // index
L:
PUSH EAX;
PUSH EDX;
PUSH ECX;
PUSH dword ptr[EAX + EDX];
PUSH dword ptr[sprompt];
CALL dword ptr[printf];
POP EBX;
POP EBX;
POP ECX;
POP EDX;
ADD EDX, 0x4;
POP EAX;
LOOP L;
}
} // end of _Data_printf function
# include <stdio.h>
int main(void) {
int Arry[3] = { 10, 20, 30 };
int value = 0;
__asm LEA edi, dword ptr[Arry];
__asm MOV eax, dword ptr[edi];
__asm MOV value, eax;
printf("value => %d\n", value);
return 0;
}
stack 구조 엑셀
http://codeup.kr/JudgeOnline/problem.php?id=1052
# include <stdio.h>
# include <Windows.h>
int main(void) {
__int32 v1 = 0;
__int32 v2 = 0;
__int32 flag = 0;
char* prompt = "%d %d";
__asm {
// scanf("%d %d", &v1, &v2)
LEA edi, dword ptr[v2]; //
PUSH edi; // (&v2);
LEA edi, dword ptr[v1];
PUSH edi; // ( , &v1, &v2);
PUSH prompt; // ("%d %d", &v1, &v2);
CALL dword ptr[scanf]; // scanf("%d %d", &v1, &v2);
POP ebx;
pop ebx;
pop ebx;
MOV eax, v1; // eax = v1
MOV ebx, v2; // ebx = v2
XOR eax, ebx;
CMP eax, 0x0;
JZ jumpZero; // zf = 0 [1]
JNZ jumpNotZero; // zf = [0]
jumpZero:
MOV eax, 0x1;
MOV flag, eax;
jmp _End;
jumpNotZero:
MOV eax, 0x0;
MOV flag, eax;
_End:
}
return 0;
}
http://codeup.kr/JudgeOnline/problem.php?id=1051
http://codeup.kr/JudgeOnline/problem.php?id=1359
http://codeup.kr/JudgeOnline/problem.php?id=1360
http://codeup.kr/JudgeOnline/problem.php?id=1064
# include <stdio.h>
# include <Windows.h>
int main(void) {
__int32 height = 0;
char* prompt = "%d";
char* LF = "\n";
//char* s = "%d";
__asm {
// scanf("%d", &height)
LEA edi, dword ptr[height];
PUSH edi;
PUSH prompt;
CALL dword ptr[scanf];
POP ebx;
POP ebx;
MOV ecx, height;
L1:
PUSH ecx;
MOV EAX, ECX;
L2:
PUSH eax;
PUSH ecx;
// 55555
// 4444
PUSH EAX;
PUSH prompt;
CALL dword ptr[printf];
POP EBX;
POP EBX;
POP ecx;
POP eax;
Loop L2;
PUSH LF;
CALL dword ptr[printf];
POP ebx;
POP ecx;
Loop L1;
}
return 0;
}
'어셈블리' 카테고리의 다른 글
포인터 접근 방식 (0) | 2017.11.14 |
---|---|
stack 구조 엑셀 (0) | 2017.11.14 |
별찍기 어셈블리 (0) | 2017.10.30 |
별찍기 어셈블 코드 (0) | 2017.10.30 |
소수 판별 코드 인라인 어셈블리 (0) | 2017.10.26 |
# include <stdio.h>
int main(void) {
int num = 0;
char* sprompt = "%d";
char* star = "*";
char* s = "\n";
__asm {
lea edi, dword ptr[num]; // edi = &num
push edi;
push sprompt; // "%d"
call dword ptr[scanf]; // scanf("%d", &num);
/////////////////////////////////////
mov ecx, num;
mov eax, 1;
L: // stair
push ecx;
mov ecx, eax;
push eax;
L1: // '*'
push ecx;
push star;
call dword ptr[printf];
pop ebx;
pop ecx;
loop L1;
push s;
call dword ptr[printf];
pop ebx;
pop eax;
add eax, 1;
pop ecx;
loop L;
}
}
'어셈블리' 카테고리의 다른 글
stack 구조 엑셀 (0) | 2017.11.14 |
---|---|
임시 (0) | 2017.11.08 |
별찍기 어셈블 코드 (0) | 2017.10.30 |
소수 판별 코드 인라인 어셈블리 (0) | 2017.10.26 |
최대값 임시 수정해야될 코드 (0) | 2017.10.24 |
별찍기 어셈블 코드
# include <stdio.h>
int main(void) {
int num = 0;
char* prompt = "%d";
char* star = "*";
char* s = "\n";
__asm {
// scanf("%d", &num)
lea edi, num; // edi = &num
push edi;
push prompt;
call dword ptr[scanf];
pop ebx;
pop ebx;
/////////////////////////////////
mov ecx, num;
L1:
push ecx;
L2:
mov edx, ecx;
push edx;
push star;
call dword ptr[printf];
pop ebx;
pop ecx;
loop L2;
/////////////////////////////////
push s;
call dword ptr[printf];
pop ebx;
/////////////////////////////////
pop ecx;
loop L1;
}
return 0;
}
'어셈블리' 카테고리의 다른 글
임시 (0) | 2017.11.08 |
---|---|
별찍기 어셈블리 (0) | 2017.10.30 |
소수 판별 코드 인라인 어셈블리 (0) | 2017.10.26 |
최대값 임시 수정해야될 코드 (0) | 2017.10.24 |
인라인 어셈블리 3개 값 받고 대소 비교 (0) | 2017.10.23 |
소수 판별 코드 인라인 어셈블리
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
typedef struct _primeNumber
{
int number; // 4byte
char* ptrString; // 4byte
char* ptrScanf; // 4byte
}primeNumber;
void __init__(primeNumber** param)
{
char* strValue = "Integer input : ";
char* strValue2 = "%d";
if ((*param) == NULL)
{
__asm PUSH 0;
__asm CALL dword ptr[exit];
}
else
{ // (*param) != NULL
__asm LEA edi, param;
__asm MOV edi, dword ptr[edi];
__asm MOV dword ptr[edi + 0], 0;
__asm LEA esi, dword ptr[strValue]; // esi = address(strValue)
__asm MOV esi, [esi];
__asm MOV dword ptr[edi + 4], esi;
__asm LEA esi, dword ptr[strValue2]; // esi = address(strValue)
__asm MOV esi, [esi];
__asm MOV dword ptr[edi + 8], esi;
}
} // end of __init__ function
void __integerWrite__(primeNumber** param)
{
__asm lea edi, param;
__asm mov edi, [edi];
__asm mov eax, dword ptr[edi + 4]; // eax = "Integer input : "
__asm push eax;
__asm call dword ptr[printf];
__asm pop ebx;
/////////////////////////////////////////////////////
__asm lea edi, param;
__asm mov edi, [edi];
__asm lea eax, dword ptr[edi + 0];
__asm push eax; // ( ,&number);
/////////////////////////////////////////////////////
__asm push dword ptr[edi + 8]
__asm call dword ptr[scanf];
__asm pop ebx;
__asm pop ebx;
} // end of __integerWrite__ function
void __primeResult__(primeNumber** param)
{
DWORD count = 0;
char* pYES = "%d is prime number \n";
char* pNO = "%d is not prime number \n";
__asm
{
lea edi, param;
mov edi, [edi];
mov ecx, dword ptr[edi + 0];
L:
mov eax, dword ptr[edi + 0];
xor edx, edx; // edx = 0
div ecx;
cmp edx, 0;
je jumpEqual;
jne jumpNotEqual;
jumpEqual:
inc count;
jmp TheEnd;
jumpNotEqual:
jmp TheEnd;
TheEnd:
loop L;
cmp count, 2;
je sameJump;
jne sameNotJump;
sameJump:
push dword ptr[edi + 0];
push pYES;
call dword ptr[printf];
pop ebx;
pop ebx;
jmp theEnd1;
sameNotJump:
push dword ptr[edi + 0];
push pNO;
call dword ptr[printf];
pop ebx;
pop ebx;
jmp theEnd1;
theEnd1:
}
} // end of __primeResult__ function
int main(void)
{
primeNumber pNum;
printf("address(pNum) => %p \n", &pNum);
printf("address(pNum->ptrString) => %p \n", &(pNum.ptrString));
printf("address(pNum->ptrScanf) => %p \n", &(pNum.ptrScanf));
__asm LEA edi, pNum;
__asm PUSH edi;
__asm CALL dword ptr[__init__];
__asm POP ebx;
printf("pNum->number => %d\n", pNum.number);
printf("pNum->ptrString => %s\n", pNum.ptrString);
printf("pNum->ptrScanf => %s\n", pNum.ptrScanf);
__asm LEA edi, pNum;
__asm PUSH edi;
__asm CALL dword ptr[__integerWrite__];
__asm POP ebx;
__asm LEA edi, pNum;
__asm PUSH edi;
__asm CALL dword ptr[__primeResult__];
__asm POP ebx;
/*
char* t_string = "integer input : ";
__asm lea edi, [pNum]; // edi = &pNum
__asm mov dword ptr[edi], 10;
__asm mov dword ptr[edi + 3], [t_string];
printf("%d \n", pNum.number);
*/
return 0;
}
'어셈블리' 카테고리의 다른 글
별찍기 어셈블리 (0) | 2017.10.30 |
---|---|
별찍기 어셈블 코드 (0) | 2017.10.30 |
최대값 임시 수정해야될 코드 (0) | 2017.10.24 |
인라인 어셈블리 3개 값 받고 대소 비교 (0) | 2017.10.23 |
이중 포인터 어셈블리 접근 방식 (0) | 2017.10.22 |
최대값 임시 수정해야될 코드
#include <stdio.h>
#include <Windows.h>
#include <time.h>
#include <stdlib.h>
#define L 10
typedef struct _arry
{
DWORD Mat[10]; // DWORD == INT
DWORD MinValue;
DWORD MaxValue;
}arry, *ptrArry;
ptrArry createNode();
void __init__(arry** param);
void __dataPrintf__(arry** param);
void __maxValue__(arry** param);
int main(void)
{
ptrArry mNode = NULL;
__asm CALL dword ptr[createNode];
__asm MOV mNode, eax; // mNode = eax
__asm LEA eax, dword ptr[mNode];
__asm PUSH eax; // &mNode;
__asm CALL dword ptr[__init__];
__asm POP ebx;
// << srand((unsigned)time(NULL)); >>
__asm PUSH 0; // ( 0)
__asm CALL dword ptr[time]; // time(0)
__asm POP ebx;
__asm PUSH eax;
__asm CALL dword ptr[srand];
__asm POP ebx;
for (int i = 0; i < L; i++)
{
mNode->Mat[i] = rand() % 10;
}
/*
__asm MOV ecx, 10;
__asm L:
__asm Loop L;
*/
// << __dataPrintf__ (&mNode) >>
__asm LEA edi, mNode;
__asm PUSH edi;
__asm CALL dword ptr[__dataPrintf__];
__asm POP ebx;
// << __maxValue__ (&mNode) >>
__asm LEA edi, mNode;
__asm PUSH edi;
__asm CALL dword ptr[__maxValue__];
__asm POP ebx;
//
return 0;
} // end of main function
ptrArry createNode()
{
ptrArry node = (ptrArry)malloc(sizeof(arry));
return node;
} // end of creatNode function
void __init__(arry** param)
{
if ((*param) == NULL) { exit(1); }
else
{ // (* param) != NULL
__asm MOV eax, 0;
__asm MOV edi, param; //
__asm MOV edi, [edi]; //
__asm MOV ecx, 12;
__asm REP stosd;
}
for (int i = 0; i < L; i++)
{
printf("%d ", (** param).Mat[i]);
}
printf("\n");
} // end of __init__ function
void __dataPrintf__(arry** param)
{
for (int i = 0; i < L; i++)
{
printf("%d ", (** param).Mat[i]);
}
printf("\n");
} // end of __dataPrintf__ function
void __maxValue__(arry** param)
{
int v1 = 0;
__asm{
MOV edi, param;
MOV edi, [edi];
MOV eax, [edi];
MOV ecx, 10;
L1:
CMP eax, [edi];
JL JumpLess;
JGE JumpGreatEqual;
JumpLess:
MOV eax, [edi];
JMP JumpEnd;
JumpGreatEqual:
JMP JumpEnd;
JumpEnd:
ADD edi, 4h;
LOOP L1;
MOV [edi], ebx;
//MOV v1, eax
}
printf("max => %d\n", v1);
} // end of __maxValue__ function
'어셈블리' 카테고리의 다른 글
별찍기 어셈블 코드 (0) | 2017.10.30 |
---|---|
소수 판별 코드 인라인 어셈블리 (0) | 2017.10.26 |
인라인 어셈블리 3개 값 받고 대소 비교 (0) | 2017.10.23 |
이중 포인터 어셈블리 접근 방식 (0) | 2017.10.22 |
인라이 어셈블리 (0) | 2017.10.15 |
인라인 어셈블리 3개 값 받고 대소 비교
#include <stdio.h>
int main(void)
{
int v1 = 0;
int v2 = 0;
int v3 = 0;
int largeValue = 0;
char* strValue = "value input : ";
char* WriteValue = "%d";
__asm
{
// [ v1 ]
push strValue; // ("value input : ");
call dword ptr[printf]; // printf ("value input : ");
pop ebx;
lea edi, v1; // edi = &v1
push edi; // ( ,%v1);
push WriteValue; // ("%d", %v1);
call dword ptr[scanf]; // scanf("%d", %v1);
pop ebx;
pop ebx;
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// [ v2 ]
push strValue; // ("value input : ");
call dword ptr[printf]; // printf ("value input : ");
pop ebx;
lea edi, v2; // edi = &v2
push edi; // ( ,%v1);
push WriteValue; // ("%d", %v2);
call dword ptr[scanf]; // scanf("%d", %v2);
pop ebx;
pop ebx;
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// [ v3 ]
push strValue; // ("value input : ");
call dword ptr[printf]; // printf ("value input : ");
pop ebx;
lea edi, v3; // edi = &v3
push edi; // ( ,%v1);
push WriteValue; // ("%d", %v3);
call dword ptr[scanf]; // scanf("%d", %v3);
pop ebx;
pop ebx;
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
mov eax, v1; // eax = v1
cmp eax, v2;
jl JumpEaxLess;
jge End;
JumpEaxLess:
mov eax, v2;
jmp End;
End:
cmp eax, v3;
jl JumpEaxLess1;
jge End1;
JumpEaxLess1:
mov eax, v3;
jmp End1;
End1:
mov largeValue, eax;
}
printf("large => %d\n", largeValue);
return 0;
}
'어셈블리' 카테고리의 다른 글
소수 판별 코드 인라인 어셈블리 (0) | 2017.10.26 |
---|---|
최대값 임시 수정해야될 코드 (0) | 2017.10.24 |
이중 포인터 어셈블리 접근 방식 (0) | 2017.10.22 |
인라이 어셈블리 (0) | 2017.10.15 |
인라인 어셈블리 (0) | 2017.10.15 |
이중 포인터 어셈블리 접근 방식
#include <stdio.h>
int main(void)
{
int s = 10;
int* ps = &s;
int** pps = &ps;
int k = 0;
printf("&pps => 0x%x \n", &pps);
printf("&ps => 0x%x \n", &ps);
printf("&s => 0x%x \n", &s);
__asm
{
lea esi, pps; // esi : 0077F980, &pps : 0077F980
mov eax, [pps]; // eax : 0077F98C, &ps : 0077F98C
mov ebx, [eax]; // ebx : 0077F998, &s: 0077F998
mov edx, [ebx];
mov k, edx;
}
printf(" k => %d \n", k);
return 0;
}
'어셈블리' 카테고리의 다른 글
최대값 임시 수정해야될 코드 (0) | 2017.10.24 |
---|---|
인라인 어셈블리 3개 값 받고 대소 비교 (0) | 2017.10.23 |
인라이 어셈블리 (0) | 2017.10.15 |
인라인 어셈블리 (0) | 2017.10.15 |
제곱 어셈블리 (0) | 2017.10.13 |