概述
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <memory>
#include <string>
#include <cstdarg>
#include <map>
#include <vector>
#include <windows.h>
using namespace std;
#define CCT_AALIGN 0x4
#define CCT_SALIGN 0x8
#define CCT_E_SUCCESS 0xF0000000
#define CCT_E_UNKNOWNTYPE 0xF0000001
#define CCT_E_WRONGNATYPE 0xF0000002
#define CCT_E_MULTRETUAN 0xF0000004
#define CCT_RT 0x10000000
#define CCT_UNK 0x1000
#define CCT_INT 0x1001
#define CCT_32 0x1002
#define CCT_DOUBLE 0x1004
#define CCT_64 0x1008
#define CCT_NA 0x1010
//----------------------------------------------------------------------------
struct cct {
unsigned t;
unsigned rn;
unsigned bc;
unsigned mc;
char* b;
cct* n;
cct():t(CCT_UNK), rn(0), bc(0), mc(0), b(0), n(0){};
void newbuf(unsigned size) { if (b) free(b); b=(char*)malloc(size); }
virtual ~cct() { if (b) free(b); }
}; // end of cct
#define cct_astype(a,t) (t&)(*(t*)a.b)
//----------------------------------------------------------------------------
#define ASM_RET_SPACE(rtc,rta)
_asm mov eax, dword ptr[rtc]
_asm cmp eax, 4
_asm jle rsD
_asm sub esp, eax
_asm mov dword ptr[rta], esp
_asm rsD:
#define ASM_RET_ADDR(rta)
_asm push dword ptr[rta]
#define ASM_SAVERETURN(v_buf, rtc)
_asm mov edx, dword ptr[v_buf]
_asm mov ecx, dword ptr[rtc]
_asm cmp ecx, 4
_asm jg rtL
_asm mov dword ptr[edx], eax
_asm jmp srD
_asm rtL: cmp ecx, 0
_asm jz srD
_asm mov esi, dword ptr[eax]
_asm mov dword ptr[edx], esi
_asm add eax, 4
_asm add edx, 4
_asm sub ecx, 4
_asm jmp rtL
_asm srD:
#define ASM_MOVE_32P(v_buf)
_asm sub esp, 4
_asm mov edx, dword ptr[v_buf]
_asm mov eax, dword ptr[edx]
_asm mov dword ptr[esp], eax
#define ASM_MOVE_64P(v_buf)
_asm sub esp, 8
_asm mov ecx, esp
_asm mov edx, dword ptr[v_buf]
_asm mov eax, dword ptr[edx]
_asm mov dword ptr[ecx], eax
_asm add ecx, 4
_asm mov edx, dword ptr[v_buf]
_asm mov eax, dword ptr[edx+04h]
_asm mov dword ptr[ecx], eax
#define ASM_MOVE_naP(v_buf, v_bc, v_mc)
_asm mov ecx, dword ptr[v_bc]
_asm inc ecx
_asm mov eax, 4
_asm mul ecx
_asm mov edx, dword ptr[v_buf]
_asm sub esp, eax
_asm mov esi, esp
_asm dec ecx
_asm napL: cmp ecx, 0
_asm jz TAIL
_asm mov eax, dword ptr[edx]
_asm mov dword ptr[esi], eax
_asm add edx, 04h
_asm add esi, 04h
_asm dec ecx
_asm jmp napL
_asm TAIL: mov ecx, dword ptr[v_mc]
_asm cmp ecx, 3
_asm jnz M2
_asm mov al, byte ptr[edx]
_asm mov byte ptr[esi],al
_asm inc edx
_asm inc esi
_asm mov ax, word ptr[edx]
_asm mov word ptr[esi],ax
_asm jmp naPD
_asm M2: cmp ecx, 2
_asm jnz M1
_asm mov ax, word ptr[edx]
_asm mov word ptr[esi],ax
_asm jmp naPD
_asm M1: cmp ecx, 1
_asm jnz naPD
_asm mov al, byte ptr[edx]
_asm mov byte ptr[esi],al
_asm naPD:
#define ASM_STDCALL_CALL(v_pfunc)
_asm call v_pfunc
void cc_call(cct* a, void* p) {
int err=0;
int rtc=0;
int rta=0;
cct *r=0;
int v_eax=0;
char* v_rb=0;
while (a&&!err) {
char* b=a->b;
int v_bc=a->bc; int v_mc=a->mc;
if (a->t&CCT_RT) {
if (rtc) { err=CCT_E_MULTRETUAN; }
else {
switch(a->t&~CCT_RT) {
case CCT_INT:
case CCT_32: rtc=sizeof(int); break;
case CCT_DOUBLE:
case CCT_64: rtc=sizeof(double); break;
case CCT_NA: {
if (a->bc+a->mc) {rtc=(a->bc+1); rtc<<=2; }
else { err=CCT_E_WRONGNATYPE; }
} break;
default: err=CCT_E_UNKNOWNTYPE;
}
if (rtc) {
r=a;
r->newbuf(rtc);
r->t=CCT_RT;
v_rb=r->b;
ASM_RET_SPACE(rtc, rta);
}
}
} else {
switch(a->t) {
case CCT_INT:
case CCT_32: {
ASM_MOVE_32P(b);
} break;
case CCT_DOUBLE:
case CCT_64: {
ASM_MOVE_64P(b);
} break;
case CCT_NA: {
ASM_MOVE_naP(b, v_bc, v_mc);
} break;
default: err=CCT_E_UNKNOWNTYPE;
}
}
a=a->n;
}
if (!err) {
if (rtc) {
ASM_RET_ADDR(rta);
}
ASM_STDCALL_CALL(p);
if (rtc) {
ASM_SAVERETURN(v_rb, rtc);
}
} else { printf("err:t%dn", err); }
}
//----------------------------------------------------------------------------
struct Large1{ char c; short s; int i; };
struct Large2{ char c; double d; };
struct Large3{ char b[5]; };
struct Large4{ char b[4]; };
struct Large5{ char b[6]; };
struct Large6{ char b[13]; };
int aa(int a, Large1 l) { unsigned mass=0x10000000; return a+l.c+l.s+l.i; }
double bb(double a, char b) { return a+b; }
void __cdecl cc(double a) { printf("cc:t%fn", a); }
void __stdcall dd(Large2 a) { printf("dd:t%fn", a.d); }
void __stdcall ee(Large3 a) { printf("ee:t%dn", sizeof(Large3)); }
void __stdcall ff(short s, char c) { printf("ff:t%d,%cn", s, c); }
void __stdcall gg(const char* s) { printf("gg:t%sn", s); }
void __stdcall hh(void (__stdcall*p)(const char* s)) { printf("hh:t0x%xn", p); }
void __stdcall ii(int i) { printf("ii:t%dn", i); }
void __stdcall jj(double d) { printf("jj:t%fn", d); }
void __stdcall kk(Large4 l) { printf("kk:t%sn", l.b); }
void __stdcall ll(Large4 l) { printf("ll:t%sn", l.b); }
Large6 __stdcall mm(Large6 l) {
return l;
/*
mov eax,dword ptr [ebp+8]
mov ecx,dword ptr [l]
mov dword ptr [eax],ecx
mov edx,dword ptr [ebp+10h]
mov dword ptr [eax+4],edx
mov ecx,dword ptr [ebp+14h]
mov dword ptr [eax+8],ecx
mov dl,byte ptr [ebp+18h]
mov byte ptr [eax+0Ch],dl
mov eax,dword ptr [ebp+8]
*/
}
Large6 __stdcall nn(Large6 l) {
int len=strlen(l.b);
for(int i=0;i<len;++i) { l.b[i]+=1; }
printf("nn:t%sn", l.b);
return l;
}
int __stdcall oo() { printf("oo:t99n"); return 99; }
//----------------------------------------------------------------------------
int main() {
{/* int gap=0x2468;
Large1 l; l.c=0x40; l.s=0x24; l.i=0x68;
unsigned mass=0x00000;
gap=aa(0x123, l);
double a=1.0;
char b=0x20;
a=bb(a,b);
*/}
{ double d=12.34;
_asm {
fld qword ptr[d]
sub esp, 8
fstp qword ptr[esp]
call [cc]
add esp, 8 // __cdecl
}
}
{
Large2 l2; l2.c=0x68; l2.d=56.78;
/*
sub esp,10h
mov eax,esp
mov ecx,dword ptr [l]
mov dword ptr [eax],ecx
mov edx,dword ptr [ebp-24h]
mov dword ptr [eax+4],edx
mov ecx,dword ptr [ebp-20h]
mov dword ptr [eax+8],ecx
mov edx,dword ptr [ebp-1Ch]
mov dword ptr [eax+0Ch],edx
call dd
*/ dd(l2);
}
{
Large3 l3;
/*
sub esp,8
mov eax,esp
mov ecx,dword ptr [l3]
mov dword ptr [eax],ecx
mov dl,byte ptr [ebp-34h]
mov byte ptr [eax+4],dl
call ee
*/ ee(l3);
}
{
short s=0x45; char c='A';
/*
movzx eax,byte ptr [c]
push eax
movzx ecx,word ptr [s]
push ecx
call ff
*/ ff(s, c);
}
{
const char* s="abc";
/*
mov eax,dword ptr [ebp-5Ch]
push eax
call gg
*/ gg(s);
}
{
/*
push offset gg
call hh
*/ hh(&gg);
}
/*
_asm {
push 999
call dword ptr[Sleep]
} */
{
cct p;
p.newbuf(sizeof(int));
p.t=CCT_INT;
cct_astype(p, int)=13579;
cc_call(&p, &ii);
}
{
cct p;
p.newbuf(sizeof(double));
p.t=CCT_DOUBLE;
cct_astype(p,double)=5678.9;
cc_call(&p, &jj);
}
{
cct p;
p.newbuf(sizeof(Large4));
p.t=CCT_32;
strcpy(p.b, "abc");
cc_call(&p, &kk);
}
{
cct p;
p.newbuf(sizeof(Large5));
p.t=CCT_NA;
p.bc=1;
p.mc=2;
strcpy(p.b, "abcde");
//cc_call(&p, &ll);
}
{
Large6 l;
strcpy(l.b, "god");
Large6 r=mm(l);
printf("mm:t%sn", r.b);
}
{
cct pr; pr.t=CCT_NA+CCT_RT;
pr.bc=3; pr.mc=1;
cct p;
p.newbuf(sizeof(Large6));
p.t=CCT_NA; p.bc=3; p.mc=1;
strcpy(p.b, "abcdefg");
pr.n=&p;
cc_call(&pr, &nn);
printf("nn:t%sn", pr.b);
}
{
cct pr2; pr2.t=CCT_INT+CCT_RT;
cc_call(&pr2, &oo);
printf("oo:t%dn", *pr2.b+12);
}
printf("END!n");
return 0;
}
//----------------------------------------------------------------------------
//
#define CCT_ROUND(s,round) ((s)+(round)-1)&~((round)-1)
int cct_align(int PackAlign, const vector<int>& List) {
int result=0;
/*
int count=List.size();
if (count > 0) {
int i=1;
int max_size=0;
int min_size=0;
for (auto n : List) {
max_size=max(max_size,n);
min_size=min(PackAlign,n);
if (i) { i=0; result=n; printf("-%dn", result); }
else {
result=CCT_ROUND(result+n, min_size);
printf("*%dn", result);
}
}
min_size=min(PackAlign,max_size);
result=CCT_ROUND(result, min_size);
printf("+%dn", result);
}
*/
return result;
}
最后
以上就是超级乌龟为你收集整理的n7:C内嵌ASM动态调用函数(stdcall)的全部内容，希望文章能够帮你解决n7:C内嵌ASM动态调用函数(stdcall)所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复