unsigned int is_array:1;
unsigned int is_ptr:1;
unsigned int is_struct:1; // split for args
+ unsigned int is_retreg:1; // register to return
};
struct parsed_proto_arg {
unsigned int is_func:1;
unsigned int is_stdcall:1;
unsigned int is_fastcall:1;
- unsigned int is_vararg:1;
+ unsigned int is_vararg:1; // vararg func
unsigned int is_fptr:1;
unsigned int is_noreturn:1;
unsigned int is_unresolved:1;
+ unsigned int is_userstack:1;
+ unsigned int is_arg:1; // decl in func arg
unsigned int has_structarg:1;
+ unsigned int has_retreg:1;
};
static const char *hdrfn;
return -1;
}
-static int get_regparm(char *dst, size_t dlen, char *p)
+static int get_regparm(char *dst, size_t dlen, char *p, int *retreg)
{
- int i, o;
+ int i = 0, o;
+
+ *retreg = 0;
if (*p != '<')
return 0;
- for (o = 0, i = 1; o < dlen; i++) {
+ i++;
+ if (p[i] == '*') {
+ *retreg = 1;
+ i++;
+ }
+
+ for (o = 0; o < dlen; i++) {
if (p[i] == 0)
return 0;
if (p[i] == '>')
"struct",
"enum",
"CONST",
+ "volatile",
};
static const char *known_ptr_types[] = {
"FARPROC",
+ "WNDPROC",
"HACCEL",
"HANDLE",
"HBITMAP",
"HRSRC",
"HKEY",
"HMENU",
+ "HWAVEOUT",
"HWND",
+ "PBYTE",
"PCRITICAL_SECTION",
"PDWORD",
+ "PFILETIME",
"PHKEY",
"PLONG",
"PMEMORY_BASIC_INFORMATION",
"PUINT",
"PVOID",
"PCVOID",
+ "PWORD",
"DLGPROC",
"TIMERPROC",
"WNDENUMPROC",
char regparm[16];
char buf[256];
char cconv[32];
+ int is_retreg;
int xarg = 0;
char *p, *p1;
int i, l;
pp->is_stdcall = 1; // IDA
else if (IS(cconv, "__usercall"))
pp->is_stdcall = 0; // IDA
+ else if (IS(cconv, "__userstack")) {
+ pp->is_stdcall = 0; // custom
+ pp->is_userstack = 1;
+ }
else if (IS(cconv, "WINAPI"))
pp->is_stdcall = 1;
else {
}
strcpy(pp->name, buf);
- ret = get_regparm(regparm, sizeof(regparm), p);
+ ret = get_regparm(regparm, sizeof(regparm), p, &is_retreg);
if (ret > 0) {
if (!IS(regparm, "eax") && !IS(regparm, "ax")
&& !IS(regparm, "al") && !IS(regparm, "edx:eax"))
hdrfn, hdrfline, p1 - protostr);
return -1;
}
+ arg->fptr->is_arg = 1;
+ // we don't use actual names right now..
+ snprintf(arg->fptr->name,
+ sizeof(arg->fptr->name), "a%d", xarg);
// we'll treat it as void * for non-calls
arg->type.name = strdup("void *");
arg->type.is_ptr = 1;
#endif
arg->reg = NULL;
- ret = get_regparm(regparm, sizeof(regparm), p);
+ ret = get_regparm(regparm, sizeof(regparm), p, &is_retreg);
if (ret > 0) {
p += ret;
p = sskip(p);
arg->reg = strdup(map_reg(regparm));
+ arg->type.is_retreg = is_retreg;
+ pp->has_retreg |= is_retreg;
+ }
+
+ if (strstr(arg->type.name, "int64")
+ || IS(arg->type.name, "double"))
+ {
+ // hack..
+ free(arg->type.name);
+ arg->type.name = strdup("int");
+ pp_copy_arg(&pp->arg[xarg], arg);
+ xarg++;
}
ret = check_struct_arg(arg);
{
const struct parsed_proto *pp_ret;
struct parsed_proto pp_search;
+ char *p;
if (pp_cache == NULL)
build_pp_cache(fhdr);
sym++;
strcpy(pp_search.name, sym);
+ p = strchr(pp_search.name, '@');
+ if (p != NULL)
+ *p = 0;
+
pp_ret = bsearch(&pp_search, pp_cache, pp_cache_size,
sizeof(pp_cache[0]), pp_name_cmp);
if (pp_ret == NULL && !quiet)
return pp;
}
+static inline void pp_print(char *buf, size_t buf_size,
+ const struct parsed_proto *pp)
+{
+ size_t l;
+ int i;
+
+ snprintf(buf, buf_size, "%s %s(", pp->ret_type.name, pp->name);
+ l = strlen(buf);
+
+ for (i = 0; i < pp->argc_reg; i++) {
+ snprintf(buf + l, buf_size - l, "%s%s",
+ i == 0 ? "" : ", ", pp->arg[i].reg);
+ l = strlen(buf);
+ }
+ if (pp->argc_stack > 0) {
+ snprintf(buf + l, buf_size - l, "%s{%d stack}",
+ i == 0 ? "" : ", ", pp->argc_stack);
+ l = strlen(buf);
+ }
+ snprintf(buf + l, buf_size - l, ")");
+}
+
static inline void proto_release(struct parsed_proto *pp)
{
int i;