运行时动态函数调用(Runtime Dynamic Invoke)

egmkang

__asm
...
你还真不怕麻烦...
为啥不用函数指针直接来呢

drangon

函数指针的问题主要是参数固定，不能可变。

但其实很多时候简化一下设计，用函数指针就够用了，非要实现强大的功能或者灵活性，很多时候没太大必要，反而是自找麻烦，维护不过来还沾沾自喜说曲高和寡。。。。

OwnWaterloo

原帖由 syncpk99 于 2009-9-8 09:39 发表
找到这个库N久了，就是一眼也没看过啊

因为以前做过类似的工作， 所以对它的代码感到很亲切

OwnWaterloo

原帖由 nicolas.shen 于 2009-9-8 11:01 发表
嗯的确有不少体力活，真是佩服啊

嗯， 敢直接写汇编那真是体力活了……
即使在x86， 还要为不同编译器写不同的代码 ……
dyncall_call_x86_nasm.asm
dyncall_call_x86_gas.S
dyncall_call_x86_nasm.asm
dyncall_call_x86_apple.s

好像不是程序生成， 4个文件都是手写的。  相当的麻烦……


我以前是直接写x86的machine code。 就不用考虑不同编译器的问题了。
但又遇到了DEP的问题。 也是体力活……  稍微轻松一些。

OwnWaterloo

期待

OwnWaterloo

原帖由 egmkang 于 2009-9-8 12:48 发表
__asm
...
你还真不怕麻烦...
为啥不用函数指针直接来呢

你在仔细想想需求， 就知道函数指针也是帮不上忙的。
使用函数指针进行调用时， 参数个数在运行前就固定了。

OwnWaterloo

原帖由 drangon 于 2009-9-8 13:07 发表
但其实很多时候简化一下设计，用函数指针就够用了，非要实现强大的功能或者灵活性，很多时候没太大必要，反而是自找麻烦，维护不过来还沾沾自喜说曲高和寡。。。。

嗯， 很多时候。 但不是所有情况下。
在极少的情况下， 有需求就是真正的需要 —— 绕弯去实现比设计一种方法直接支持要更麻烦， 甚至不可能。

nicolas.shen

其实想这样做，就是想在脚本里调用api，实在是还没有想到别的办法，期待 群雄逐鹿 兄弟的 C++实现

群雄逐鹿

实现的还是很不爽，
抛砖引玉，这个代码可以可以动态的调用printf，目前只支持%s和%d两种参数。

主要就是用detect_stack_pos检测stack位置，
然后手动填写stack.
特别要满足 detect_stack_pos 和 被调用的函数（这里是printf）处在一摸一样的stack位置，
这个可以通过 数组 any_fn funcs[ 3 ]; 保证。

VC2008和cygwin下测试通过，cygwin 结果

$ ./a.exe '---%s---%d--%d---%s' ffeww 333 22 abcd
---ffeww---333--22---abcd

$ ./a.exe '---bbs%d.chinaunix.%s--' 3 net
---bbs3.chinaunix.net--

但是不足:
1. 需要用动态数组预留stack空间，VC只能用静态的代替。
2. 需要一个全局变量记录 stack检测结果，开始认为c++可以用类成员代替全局变量，但实际上代替不了（this指针怎么都必须有）
    如果全局变量的问题能解决，就比较好包装一个通用的库了。

还有返回值可以不可以用，还没验证。

1. 
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. 
   
5. typedef void (*any_fn)( );
   
6. typedef struct
   
7. {
   
8.         void *stack_pos0;
   
9.         void *stack_pos1;
   
10.         int argc;
    
11.         char **argv;
    
12. } stack_t;
    
13. 
    
14. stack_t g_stack;
    
15. 
    
16. void detect_stack_pos( void *arg0, void *arg1 )
    
17. {
    
18.         stack_t *stack = &g_stack;
    
19.         stack->stack_pos0 = (void *)&arg0;
    
20.         stack->stack_pos1 = (void *)&arg1;
    
21.         //printf( "stack pos = %p %p\n", &arg0, &arg1 );
    
22. }
    
23.        
    
24. void set_stack( )
    
25. {
    
26.         stack_t *stack = &g_stack;
    
27.        
    
28.         int direction = ( stack->stack_pos0 < stack->stack_pos1 ? 1 : -1 );
    
29. 
    
30.         int i;               
    
31.         void *stack_pos = stack->stack_pos0;
    
32.         const char *p;
    
33.         const char *fmt = stack->argv[ 1 ];
    
34.                
    
35.         *(const char **)stack_pos = fmt;
    
36.         stack_pos = (void *)( (const char **)stack_pos + direction );
    
37.                
    
38.         i = 2;
    
39.         for( p = fmt; *p != '\0'; ++p )
    
40.         {
    
41.                 if( *p != '%' )
    
42.                         continue;
    
43.                 ++p;
    
44.                 if( *p == '\0' )
    
45.                         break;
    
46.                        
    
47.                 switch( *p )
    
48.                 {
    
49.                 case 'd':
    
50.                         *(int *)stack_pos = atoi( stack->argv[ i++ ] );
    
51.                         stack_pos = (void *)( (int *)stack_pos + direction );
    
52.                         break;
    
53.                 case 's':
    
54.                         *(const char **)stack_pos = stack->argv[ i++ ];
    
55.                         printf( "%s\n", *(const char **)stack_pos);
    
56.                         stack_pos = (void *)( (const char **)stack_pos + direction );
    
57.                         break;
    
58.                 }
    
59.         }
    
60. }
    
61. 
    
62. 
    
63. size_t get_min_stack_size( const char *fmt )
    
64. {
    
65.         size_t param_num = 1;
    
66.         while( *fmt != '\0' )
    
67.         {
    
68.                 if( *fmt == '%' )
    
69.                         ++param_num;
    
70.                 ++fmt;
    
71.         }
    
72.        
    
73.         /* Only support %d %s now, so just use sizeof(void *) instead */
    
74.         return param_num * sizeof(void *);
    
75. }
    
76. 
    
77.        
    
78. void call_func( int argc, char **argv )
    
79. {
    
80.         int i;
    
81.         size_t min_stack_size;
    
82.         any_fn funcs[ 3 ];
    
83.        
    
84.         funcs[ 0 ] = (any_fn)&detect_stack_pos;
    
85.         funcs[ 1 ] = (any_fn)&set_stack;
    
86.         funcs[ 2 ] = (any_fn)&printf;
    
87.        
    
88.         g_stack.argc = argc;
    
89.         g_stack.argv = argv;
    
90.        
    
91.        
    
92.         min_stack_size = get_min_stack_size( argv[ 1 ] );
    
93.        
    
94.         for( i = 0; i < sizeof( funcs ) / sizeof( funcs[ 0 ] ); ++i )
    
95.         {
    
96.                 volatile any_fn func = funcs[ i ];
    
97.                 {
    
98.                         /* Allocate stack size */
    
99. #ifdef __GNUC__
    
100.                         volatile char buffer[ min_stack_size ];
     
101. #else
     
102.                         volatile char buffer[ 400 ];
     
103. #endif
     
104.                         /* Prevent optimization by assigning a value */
     
105.                         if( i <= 1 )
     
106.                         {
     
107.                                 buffer[ 0 ] = 0;
     
108.                                 buffer[ sizeof( buffer ) / sizeof( buffer[ 0 ] ) - 1 ] = 0;
     
109.                         }
     
110.                        
     
111.                         (*func)( );
     
112.                 }
     
113.         }
     
114. };
     
115. 
     
116. int main( int argc, char **argv )
     
117. {
     
118.         call_func( argc, argv );
     
119.         return 0;
     
120. }
     
121. 
     
122. 
     

复制代码

[ 本帖最后由 群雄逐鹿 于 2009-9-8 14:50 编辑 ]

OwnWaterloo

确实是纯C/C++的，也实现得很巧妙。

但不是可移植的， 因为代码中已经假设机器具有栈结构， 参数通过栈传递， 所有函数指针都有相同表示。
这些都是C/C++没有规定的。