mirror of
git://source.winehq.org/git/wine.git
synced 2024-09-30 05:08:30 +00:00
winedbg: Use CRT allocation functions.
Signed-off-by: Eric Pouech <eric.pouech@gmail.com>
This commit is contained in:
parent
674ef559e0
commit
890e3baaba
|
@ -216,8 +216,8 @@ BOOL break_add_break_from_lvalue(const struct dbg_lvalue* lvalue, BOOL swbp)
|
|||
return FALSE;
|
||||
}
|
||||
dbg_printf("Unable to add breakpoint, will check again any time a new DLL is loaded\n");
|
||||
new = dbg_heap_realloc(dbg_curr_process->delayed_bp,
|
||||
sizeof(struct dbg_delayed_bp) * (dbg_curr_process->num_delayed_bp + 1));
|
||||
new = realloc(dbg_curr_process->delayed_bp,
|
||||
sizeof(struct dbg_delayed_bp) * (dbg_curr_process->num_delayed_bp + 1));
|
||||
if (!new) return FALSE;
|
||||
dbg_curr_process->delayed_bp = new;
|
||||
|
||||
|
@ -260,13 +260,13 @@ void break_add_break_from_id(const char *name, int lineno, BOOL swbp)
|
|||
lineno == dbg_curr_process->delayed_bp[i].u.symbol.lineno)
|
||||
return;
|
||||
}
|
||||
new = dbg_heap_realloc(dbg_curr_process->delayed_bp,
|
||||
sizeof(struct dbg_delayed_bp) * (dbg_curr_process->num_delayed_bp + 1));
|
||||
new = realloc(dbg_curr_process->delayed_bp,
|
||||
sizeof(struct dbg_delayed_bp) * (dbg_curr_process->num_delayed_bp + 1));
|
||||
if (!new) return;
|
||||
dbg_curr_process->delayed_bp = new;
|
||||
dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp].is_symbol = TRUE;
|
||||
dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp].software_bp = swbp;
|
||||
dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp].u.symbol.name = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(name) + 1), name);
|
||||
dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp].u.symbol.name = strdup(name);
|
||||
dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp].u.symbol.lineno = lineno;
|
||||
dbg_curr_process->num_delayed_bp++;
|
||||
}
|
||||
|
|
|
@ -64,7 +64,6 @@ static WCHAR *get_program_name(HANDLE hProcess)
|
|||
{
|
||||
WCHAR image_name[MAX_PATH];
|
||||
WCHAR *programname;
|
||||
WCHAR *output;
|
||||
|
||||
/* GetProcessImageFileNameW gives no way to query the correct buffer size,
|
||||
* but programs with a path longer than MAX_PATH can't be started by the
|
||||
|
@ -95,10 +94,7 @@ static WCHAR *get_program_name(HANDLE hProcess)
|
|||
programname[MAX_PROGRAM_NAME_LENGTH - 1] = 0;
|
||||
}
|
||||
|
||||
output = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(lstrlenW(programname) + 1));
|
||||
lstrcpyW(output, programname);
|
||||
|
||||
return output;
|
||||
return wcsdup(programname);
|
||||
}
|
||||
|
||||
static LPWSTR g_ProgramName;
|
||||
|
@ -142,12 +138,12 @@ static void load_crash_log( HANDLE file )
|
|||
{
|
||||
DWORD len, pos = 0, size = 65536;
|
||||
|
||||
crash_log = HeapAlloc( GetProcessHeap(), 0, size );
|
||||
crash_log = malloc( size );
|
||||
SetFilePointer( file, 0, NULL, FILE_BEGIN );
|
||||
while (ReadFile( file, crash_log + pos, size - pos - 1, &len, NULL ) && len)
|
||||
{
|
||||
pos += len;
|
||||
if (pos == size - 1) crash_log = HeapReAlloc( GetProcessHeap(), 0, crash_log, size *= 2 );
|
||||
if (pos == size - 1) crash_log = realloc( crash_log, size *= 2 );
|
||||
}
|
||||
crash_log[pos] = 0;
|
||||
}
|
||||
|
|
|
@ -499,7 +499,7 @@ static int input_fetch_entire_line(const char* pfx, char** line)
|
|||
*/
|
||||
WriteFile(dbg_parser.output, pfx, strlen(pfx), &nread, NULL);
|
||||
|
||||
buffer = HeapAlloc(GetProcessHeap(), 0, alloc = 16);
|
||||
buffer = malloc(alloc = 16);
|
||||
assert(buffer != NULL);
|
||||
|
||||
dbg_parser.line_no++;
|
||||
|
@ -508,7 +508,7 @@ static int input_fetch_entire_line(const char* pfx, char** line)
|
|||
{
|
||||
if (!ReadFile(dbg_parser.input, &ch, 1, &nread, NULL) || nread == 0)
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, buffer);
|
||||
free(buffer);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
@ -516,9 +516,9 @@ static int input_fetch_entire_line(const char* pfx, char** line)
|
|||
{
|
||||
char* new;
|
||||
while (len + 2 > alloc) alloc *= 2;
|
||||
if (!(new = dbg_heap_realloc(buffer, alloc)))
|
||||
if (!(new = realloc(buffer, alloc)))
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, buffer);
|
||||
free(buffer);
|
||||
return -1;
|
||||
}
|
||||
buffer = new;
|
||||
|
@ -557,11 +557,11 @@ size_t input_lex_read_buffer(char* buf, int size)
|
|||
if (dbg_parser.last_line && (len == 0 || (len == 1 && tmp[0] == '\n')) &&
|
||||
dbg_parser.output != INVALID_HANDLE_VALUE)
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, tmp);
|
||||
free(tmp);
|
||||
}
|
||||
else
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, dbg_parser.last_line);
|
||||
free(dbg_parser.last_line);
|
||||
dbg_parser.last_line = tmp;
|
||||
}
|
||||
}
|
||||
|
@ -585,7 +585,7 @@ int input_read_line(const char* pfx, char* buf, int size)
|
|||
len = min(size - 1, len);
|
||||
memcpy(buf, line, len);
|
||||
buf[len] = '\0';
|
||||
HeapFree(GetProcessHeap(), 0, line);
|
||||
free(line);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
|
@ -42,10 +42,10 @@ char* lexeme_alloc_size(int size)
|
|||
if (next_lexeme >= alloc_lexeme)
|
||||
{
|
||||
alloc_lexeme += 32;
|
||||
local_lexemes = dbg_heap_realloc(local_lexemes, alloc_lexeme * sizeof(local_lexemes[0]));
|
||||
local_lexemes = realloc(local_lexemes, alloc_lexeme * sizeof(local_lexemes[0]));
|
||||
assert(local_lexemes);
|
||||
}
|
||||
return local_lexemes[next_lexeme++] = HeapAlloc(GetProcessHeap(), 0, size + 1);
|
||||
return local_lexemes[next_lexeme++] = malloc(size + 1);
|
||||
}
|
||||
|
||||
static char* lexeme_alloc(const char* lexeme)
|
||||
|
@ -68,7 +68,7 @@ static char* lexeme_alloc_if(const char* lexeme, unsigned sz)
|
|||
|
||||
void lexeme_flush(void)
|
||||
{
|
||||
while (--next_lexeme >= 0) HeapFree(GetProcessHeap(), 0, local_lexemes[next_lexeme]);
|
||||
while (--next_lexeme >= 0) free(local_lexemes[next_lexeme]);
|
||||
next_lexeme = 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -537,12 +537,6 @@ static inline BOOL dbg_write_memory(void* addr, const void* buffer, size_t len)
|
|||
return dbg_curr_process->process_io->write(dbg_curr_process->handle, addr, buffer, len, &wlen) && len == wlen;
|
||||
}
|
||||
|
||||
static inline void* dbg_heap_realloc(void* buffer, size_t size)
|
||||
{
|
||||
return (buffer) ? HeapReAlloc(GetProcessHeap(), 0, buffer, size) :
|
||||
HeapAlloc(GetProcessHeap(), 0, size);
|
||||
}
|
||||
|
||||
struct data_model
|
||||
{
|
||||
enum dbg_internal_types itype;
|
||||
|
|
|
@ -65,8 +65,8 @@ BOOL display_add(struct expr *exp, int count, char format)
|
|||
{
|
||||
struct display *new;
|
||||
/* no space left - expand */
|
||||
new = dbg_heap_realloc(displaypoints,
|
||||
(maxdisplays + DISPTAB_DELTA) * sizeof(*displaypoints));
|
||||
new = realloc(displaypoints,
|
||||
(maxdisplays + DISPTAB_DELTA) * sizeof(*displaypoints));
|
||||
if (!new) return FALSE;
|
||||
displaypoints = new;
|
||||
maxdisplays += DISPTAB_DELTA;
|
||||
|
@ -208,8 +208,8 @@ BOOL display_delete(int displaynum)
|
|||
}
|
||||
}
|
||||
maxdisplays = DISPTAB_DELTA;
|
||||
displaypoints = dbg_heap_realloc(displaypoints,
|
||||
(maxdisplays = DISPTAB_DELTA) * sizeof(*displaypoints));
|
||||
displaypoints = realloc(displaypoints,
|
||||
(maxdisplays = DISPTAB_DELTA) * sizeof(*displaypoints));
|
||||
ndisplays = 0;
|
||||
}
|
||||
else if (displaypoints[--displaynum].exp != NULL)
|
||||
|
@ -225,8 +225,8 @@ BOOL display_delete(int displaynum)
|
|||
{
|
||||
/* MARK */
|
||||
maxdisplays = (ndisplays + DISPTAB_DELTA - 1) & ~(DISPTAB_DELTA - 1);
|
||||
displaypoints = dbg_heap_realloc(displaypoints,
|
||||
maxdisplays * sizeof(*displaypoints));
|
||||
displaypoints = realloc(displaypoints,
|
||||
maxdisplays * sizeof(*displaypoints));
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
|
|
|
@ -721,7 +721,7 @@ struct expr* expr_clone(const struct expr* exp, BOOL *local_binding)
|
|||
int i;
|
||||
struct expr* rtn;
|
||||
|
||||
rtn = HeapAlloc(GetProcessHeap(), 0, sizeof(struct expr));
|
||||
rtn = malloc(sizeof(struct expr));
|
||||
|
||||
/*
|
||||
* First copy the contents of the expression itself.
|
||||
|
@ -734,30 +734,30 @@ struct expr* expr_clone(const struct expr* exp, BOOL *local_binding)
|
|||
rtn->un.cast.expr = expr_clone(exp->un.cast.expr, local_binding);
|
||||
break;
|
||||
case EXPR_TYPE_INTVAR:
|
||||
rtn->un.intvar.name = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(exp->un.intvar.name) + 1), exp->un.intvar.name);
|
||||
rtn->un.intvar.name = strdup(exp->un.intvar.name);
|
||||
break;
|
||||
case EXPR_TYPE_U_CONST:
|
||||
case EXPR_TYPE_S_CONST:
|
||||
break;
|
||||
case EXPR_TYPE_STRING:
|
||||
rtn->un.string.str = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(exp->un.string.str) + 1), exp->un.string.str);
|
||||
rtn->un.string.str = strdup(exp->un.string.str);
|
||||
break;
|
||||
case EXPR_TYPE_SYMBOL:
|
||||
rtn->un.symbol.name = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(exp->un.symbol.name) + 1), exp->un.symbol.name);
|
||||
rtn->un.symbol.name = strdup(exp->un.symbol.name);
|
||||
if (local_binding && symbol_is_local(exp->un.symbol.name))
|
||||
*local_binding = TRUE;
|
||||
break;
|
||||
case EXPR_TYPE_PSTRUCT:
|
||||
case EXPR_TYPE_STRUCT:
|
||||
rtn->un.structure.exp1 = expr_clone(exp->un.structure.exp1, local_binding);
|
||||
rtn->un.structure.element_name = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(exp->un.structure.element_name) + 1), exp->un.structure.element_name);
|
||||
rtn->un.structure.element_name = strdup(exp->un.structure.element_name);
|
||||
break;
|
||||
case EXPR_TYPE_CALL:
|
||||
for (i = 0; i < exp->un.call.nargs; i++)
|
||||
{
|
||||
rtn->un.call.arg[i] = expr_clone(exp->un.call.arg[i], local_binding);
|
||||
}
|
||||
rtn->un.call.funcname = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(exp->un.call.funcname) + 1), exp->un.call.funcname);
|
||||
rtn->un.call.funcname = strdup(exp->un.call.funcname);
|
||||
break;
|
||||
case EXPR_TYPE_BINOP:
|
||||
rtn->un.binop.exp1 = expr_clone(exp->un.binop.exp1, local_binding);
|
||||
|
@ -790,28 +790,28 @@ BOOL expr_free(struct expr* exp)
|
|||
expr_free(exp->un.cast.expr);
|
||||
break;
|
||||
case EXPR_TYPE_INTVAR:
|
||||
HeapFree(GetProcessHeap(), 0, (char*)exp->un.intvar.name);
|
||||
free((char*)exp->un.intvar.name);
|
||||
break;
|
||||
case EXPR_TYPE_U_CONST:
|
||||
case EXPR_TYPE_S_CONST:
|
||||
break;
|
||||
case EXPR_TYPE_STRING:
|
||||
HeapFree(GetProcessHeap(), 0, (char*)exp->un.string.str);
|
||||
free((char*)exp->un.string.str);
|
||||
break;
|
||||
case EXPR_TYPE_SYMBOL:
|
||||
HeapFree(GetProcessHeap(), 0, (char*)exp->un.symbol.name);
|
||||
free((char*)exp->un.symbol.name);
|
||||
break;
|
||||
case EXPR_TYPE_PSTRUCT:
|
||||
case EXPR_TYPE_STRUCT:
|
||||
expr_free(exp->un.structure.exp1);
|
||||
HeapFree(GetProcessHeap(), 0, (char*)exp->un.structure.element_name);
|
||||
free((char*)exp->un.structure.element_name);
|
||||
break;
|
||||
case EXPR_TYPE_CALL:
|
||||
for (i = 0; i < exp->un.call.nargs; i++)
|
||||
{
|
||||
expr_free(exp->un.call.arg[i]);
|
||||
}
|
||||
HeapFree(GetProcessHeap(), 0, (char*)exp->un.call.funcname);
|
||||
free((char*)exp->un.call.funcname);
|
||||
break;
|
||||
case EXPR_TYPE_BINOP:
|
||||
expr_free(exp->un.binop.exp1);
|
||||
|
@ -826,6 +826,6 @@ BOOL expr_free(struct expr* exp)
|
|||
break;
|
||||
}
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, exp);
|
||||
free(exp);
|
||||
return TRUE;
|
||||
}
|
||||
|
|
|
@ -129,7 +129,7 @@ static void gdbctx_delete_xpoint(struct gdb_context *gdbctx, struct dbg_thread *
|
|||
ERR("%04lx:%04lx: Couldn't remove breakpoint at:%p/%x type:%d\n", process->pid, thread ? thread->tid : ~0, x->addr, x->size, x->type);
|
||||
|
||||
list_remove(&x->entry);
|
||||
HeapFree(GetProcessHeap(), 0, x);
|
||||
free(x);
|
||||
}
|
||||
|
||||
static void gdbctx_insert_xpoint(struct gdb_context *gdbctx, struct dbg_thread *thread,
|
||||
|
@ -146,7 +146,7 @@ static void gdbctx_insert_xpoint(struct gdb_context *gdbctx, struct dbg_thread *
|
|||
return;
|
||||
}
|
||||
|
||||
if (!(x = HeapAlloc(GetProcessHeap(), 0, sizeof(struct gdb_xpoint))))
|
||||
if (!(x = malloc(sizeof(struct gdb_xpoint))))
|
||||
{
|
||||
ERR("%04lx:%04lx: Couldn't allocate memory for breakpoint at:%p/%x type:%d\n", process->pid, thread->tid, addr, size, type);
|
||||
return;
|
||||
|
|
|
@ -199,7 +199,7 @@ static BOOL CALLBACK info_mod_cb(PCSTR mod_name, DWORD64 base, PVOID ctx)
|
|||
|
||||
if (im->num_used + 1 > im->num_alloc)
|
||||
{
|
||||
struct info_module* new = dbg_heap_realloc(im->modules, (im->num_alloc + 16) * sizeof(*im->modules));
|
||||
struct info_module* new = realloc(im->modules, (im->num_alloc + 16) * sizeof(*im->modules));
|
||||
if (!new) return FALSE; /* stop enumeration in case of OOM */
|
||||
im->num_alloc += 16;
|
||||
im->modules = new;
|
||||
|
@ -283,7 +283,7 @@ void info_win32_module(DWORD64 base)
|
|||
}
|
||||
num_printed++;
|
||||
}
|
||||
HeapFree(GetProcessHeap(), 0, im.modules);
|
||||
free(im.modules);
|
||||
|
||||
if (base && !num_printed)
|
||||
dbg_printf("'0x%0*I64x' is not a valid module address\n", ADDRWIDTH, base);
|
||||
|
@ -317,7 +317,7 @@ static void class_walker(HWND hWnd, struct class_walker* cw)
|
|||
{
|
||||
if (cw->used >= cw->alloc)
|
||||
{
|
||||
ATOM* new = dbg_heap_realloc(cw->table, (cw->alloc + 16) * sizeof(ATOM));
|
||||
ATOM* new = realloc(cw->table, (cw->alloc + 16) * sizeof(ATOM));
|
||||
if (!new) return;
|
||||
cw->alloc += 16;
|
||||
cw->table = new;
|
||||
|
@ -344,7 +344,7 @@ void info_win32_class(HWND hWnd, const char* name)
|
|||
cw.table = NULL;
|
||||
cw.used = cw.alloc = 0;
|
||||
class_walker(GetDesktopWindow(), &cw);
|
||||
HeapFree(GetProcessHeap(), 0, cw.table);
|
||||
free(cw.table);
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -536,7 +536,7 @@ void info_win32_processes(void)
|
|||
|
||||
dp.count = 0;
|
||||
dp.alloc = 16;
|
||||
dp.entries = HeapAlloc(GetProcessHeap(), 0, sizeof(*dp.entries) * dp.alloc);
|
||||
dp.entries = malloc(sizeof(*dp.entries) * dp.alloc);
|
||||
if (!dp.entries)
|
||||
{
|
||||
CloseHandle(snap);
|
||||
|
@ -551,11 +551,11 @@ void info_win32_processes(void)
|
|||
dp.entries[dp.count++].children = -1;
|
||||
if (dp.count >= dp.alloc)
|
||||
{
|
||||
struct dump_proc_entry* new = HeapReAlloc(GetProcessHeap(), 0, dp.entries, sizeof(*dp.entries) * (dp.alloc * 2));
|
||||
struct dump_proc_entry* new = realloc(dp.entries, sizeof(*dp.entries) * (dp.alloc * 2));
|
||||
if (!new)
|
||||
{
|
||||
CloseHandle(snap);
|
||||
HeapFree(GetProcessHeap(), 0, dp.entries);
|
||||
free(dp.entries);
|
||||
return;
|
||||
}
|
||||
dp.alloc *= 2;
|
||||
|
@ -575,7 +575,7 @@ void info_win32_processes(void)
|
|||
}
|
||||
dbg_printf(" %-8.8s %-8.8s %s (all id:s are in hex)\n", "pid", "threads", "executable");
|
||||
dump_proc_info(&dp, first, 0);
|
||||
HeapFree(GetProcessHeap(), 0, dp.entries);
|
||||
free(dp.entries);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -386,11 +386,11 @@ BOOL memory_get_string(struct dbg_process* pcs, void* addr, BOOL in_debuggee,
|
|||
if (!unicode) ret = pcs->process_io->read(pcs->handle, addr, buffer, size, &sz);
|
||||
else
|
||||
{
|
||||
buffW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
|
||||
buffW = malloc(size * sizeof(WCHAR));
|
||||
ret = pcs->process_io->read(pcs->handle, addr, buffW, size * sizeof(WCHAR), &sz);
|
||||
WideCharToMultiByte(CP_ACP, 0, buffW, sz / sizeof(WCHAR), buffer, size,
|
||||
NULL, NULL);
|
||||
HeapFree(GetProcessHeap(), 0, buffW);
|
||||
free(buffW);
|
||||
}
|
||||
if (size) buffer[size-1] = 0;
|
||||
return ret;
|
||||
|
@ -418,11 +418,11 @@ BOOL memory_get_string_indirect(struct dbg_process* pcs, void* addr, BOOL unicod
|
|||
ret = pcs->process_io->read(pcs->handle, ad, buffer, size * sizeof(WCHAR), &sz) && sz != 0;
|
||||
else
|
||||
{
|
||||
if ((buff = HeapAlloc(GetProcessHeap(), 0, size)))
|
||||
if ((buff = malloc(size)))
|
||||
{
|
||||
ret = pcs->process_io->read(pcs->handle, ad, buff, size, &sz) && sz != 0;
|
||||
MultiByteToWideChar(CP_ACP, 0, buff, sz, buffer, size);
|
||||
HeapFree(GetProcessHeap(), 0, buff);
|
||||
free(buff);
|
||||
}
|
||||
else ret = FALSE;
|
||||
}
|
||||
|
|
|
@ -59,14 +59,14 @@ void source_add_path(const char* path)
|
|||
if (dbg_curr_process->search_path)
|
||||
{
|
||||
unsigned pos = strlen(dbg_curr_process->search_path) + 1;
|
||||
new = HeapReAlloc(GetProcessHeap(), 0, dbg_curr_process->search_path, pos + size);
|
||||
new = realloc(dbg_curr_process->search_path, pos + size);
|
||||
if (!new) return;
|
||||
new[pos - 1] = ';';
|
||||
strcpy(&new[pos], path);
|
||||
}
|
||||
else
|
||||
{
|
||||
new = HeapAlloc(GetProcessHeap(), 0, size);
|
||||
new = malloc(size);
|
||||
if (!new) return;
|
||||
strcpy(new, path);
|
||||
}
|
||||
|
@ -75,7 +75,7 @@ void source_add_path(const char* path)
|
|||
|
||||
void source_nuke_path(struct dbg_process* p)
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, p->search_path);
|
||||
free(p->search_path);
|
||||
p->search_path = NULL;
|
||||
}
|
||||
|
||||
|
@ -146,7 +146,7 @@ static struct open_file_list* source_add_file(const char* name, const char* real
|
|||
sz = sizeof(*ol);
|
||||
nlen = strlen(name) + 1;
|
||||
if (realpath) sz += strlen(realpath) + 1;
|
||||
ol = HeapAlloc(GetProcessHeap(), 0, sz + nlen);
|
||||
ol = malloc(sz + nlen);
|
||||
if (!ol) return NULL;
|
||||
strcpy(ol->path = (char*)(ol + 1), name);
|
||||
if (realpath)
|
||||
|
@ -255,7 +255,7 @@ static int source_display(const char* sourcefile, int start, int end)
|
|||
}
|
||||
|
||||
ol->nlines++;
|
||||
ol->linelist = HeapAlloc(GetProcessHeap(), 0, ol->nlines * sizeof(unsigned int));
|
||||
ol->linelist = malloc(ol->nlines * sizeof(unsigned int));
|
||||
|
||||
nlines = 0;
|
||||
pnt = addr;
|
||||
|
@ -379,7 +379,7 @@ void source_free_files(struct dbg_process* p)
|
|||
for (ofile = p->source_ofiles; ofile; ofile = ofile_next)
|
||||
{
|
||||
ofile_next = ofile->next;
|
||||
HeapFree(GetProcessHeap(), 0, ofile->linelist);
|
||||
HeapFree(GetProcessHeap(), 0, ofile);
|
||||
free(ofile->linelist);
|
||||
free(ofile);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -182,7 +182,7 @@ unsigned stack_fetch_frames(const dbg_ctx_t* _ctx)
|
|||
dbg_ctx_t ctx = *_ctx;
|
||||
BOOL ret;
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, dbg_curr_thread->frames);
|
||||
free(dbg_curr_thread->frames);
|
||||
dbg_curr_thread->frames = NULL;
|
||||
|
||||
memset(&sf, 0, sizeof(sf));
|
||||
|
@ -204,8 +204,8 @@ unsigned stack_fetch_frames(const dbg_ctx_t* _ctx)
|
|||
SymFunctionTableAccess64, SymGetModuleBase64, NULL, SYM_STKWALK_DEFAULT)) ||
|
||||
nf == 0) /* we always register first frame information */
|
||||
{
|
||||
struct dbg_frame* new = dbg_heap_realloc(dbg_curr_thread->frames,
|
||||
(nf + 1) * sizeof(dbg_curr_thread->frames[0]));
|
||||
struct dbg_frame* new = realloc(dbg_curr_thread->frames,
|
||||
(nf + 1) * sizeof(dbg_curr_thread->frames[0]));
|
||||
if (!new) break;
|
||||
dbg_curr_thread->frames = new;
|
||||
|
||||
|
|
|
@ -197,10 +197,10 @@ static BOOL dbg_exception_prolog(BOOL is_debug, const EXCEPTION_RECORD* rec)
|
|||
if ((!last_name || strcmp(last_name, si->Name)) ||
|
||||
(!last_file || strcmp(last_file, il.FileName)))
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, last_name);
|
||||
HeapFree(GetProcessHeap(), 0, last_file);
|
||||
last_name = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(si->Name) + 1), si->Name);
|
||||
last_file = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(il.FileName) + 1), il.FileName);
|
||||
free(last_name);
|
||||
free(last_file);
|
||||
last_name = strdup(si->Name);
|
||||
last_file = strdup(il.FileName);
|
||||
dbg_printf("%s () at %s:%lu\n", last_name, last_file, il.LineNumber);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -497,7 +497,7 @@ static void cleanup(struct tgt_process_minidump_data* data)
|
|||
if (data->mapping) UnmapViewOfFile(data->mapping);
|
||||
if (data->hMap) CloseHandle(data->hMap);
|
||||
if (data->hFile != INVALID_HANDLE_VALUE) CloseHandle(data->hFile);
|
||||
HeapFree(GetProcessHeap(), 0, data);
|
||||
free(data);
|
||||
}
|
||||
|
||||
static struct be_process_io be_process_minidump_io;
|
||||
|
@ -512,7 +512,7 @@ enum dbg_start minidump_reload(int argc, char* argv[])
|
|||
|
||||
WINE_TRACE("Processing Minidump file %s\n", argv[0]);
|
||||
|
||||
data = HeapAlloc(GetProcessHeap(), 0, sizeof(struct tgt_process_minidump_data));
|
||||
data = malloc(sizeof(struct tgt_process_minidump_data));
|
||||
if (!data) return start_error_init;
|
||||
data->mapping = NULL;
|
||||
data->hMap = NULL;
|
||||
|
|
|
@ -55,7 +55,7 @@ enum dbg_start tgt_module_load(const char* name, BOOL keep)
|
|||
if (!dbg_init(hDummy, NULL, FALSE))
|
||||
return start_error_init;
|
||||
len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
|
||||
nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
|
||||
nameW = malloc(len * sizeof(WCHAR));
|
||||
if (!nameW)
|
||||
{
|
||||
ret = start_error_init;
|
||||
|
@ -69,7 +69,7 @@ enum dbg_start tgt_module_load(const char* name, BOOL keep)
|
|||
ret = start_error_init;
|
||||
keep = FALSE;
|
||||
}
|
||||
HeapFree(GetProcessHeap(), 0, nameW);
|
||||
free(nameW);
|
||||
}
|
||||
|
||||
if (keep)
|
||||
|
|
|
@ -266,7 +266,7 @@ struct dbg_process* dbg_add_process(const struct be_process_io* pio, DWORD pid,
|
|||
if (!h)
|
||||
h = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
|
||||
|
||||
if (!(p = HeapAlloc(GetProcessHeap(), 0, sizeof(struct dbg_process)))) return NULL;
|
||||
if (!(p = malloc(sizeof(struct dbg_process)))) return NULL;
|
||||
p->handle = h;
|
||||
p->pid = pid;
|
||||
p->process_io = pio;
|
||||
|
@ -307,11 +307,7 @@ struct dbg_process* dbg_add_process(const struct be_process_io* pio, DWORD pid,
|
|||
void dbg_set_process_name(struct dbg_process* p, const WCHAR* imageName)
|
||||
{
|
||||
assert(p->imageName == NULL);
|
||||
if (imageName)
|
||||
{
|
||||
WCHAR* tmp = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(imageName) + 1) * sizeof(WCHAR));
|
||||
if (tmp) p->imageName = lstrcpyW(tmp, imageName);
|
||||
}
|
||||
if (imageName) p->imageName = wcsdup(imageName);
|
||||
}
|
||||
|
||||
void dbg_del_process(struct dbg_process* p)
|
||||
|
@ -325,16 +321,16 @@ void dbg_del_process(struct dbg_process* p)
|
|||
|
||||
for (i = 0; i < p->num_delayed_bp; i++)
|
||||
if (p->delayed_bp[i].is_symbol)
|
||||
HeapFree(GetProcessHeap(), 0, p->delayed_bp[i].u.symbol.name);
|
||||
free(p->delayed_bp[i].u.symbol.name);
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, p->delayed_bp);
|
||||
free(p->delayed_bp);
|
||||
source_nuke_path(p);
|
||||
source_free_files(p);
|
||||
list_remove(&p->entry);
|
||||
if (p == dbg_curr_process) dbg_curr_process = NULL;
|
||||
if (p->event_on_first_exception) CloseHandle(p->event_on_first_exception);
|
||||
HeapFree(GetProcessHeap(), 0, (char*)p->imageName);
|
||||
HeapFree(GetProcessHeap(), 0, p);
|
||||
free((char*)p->imageName);
|
||||
free(p);
|
||||
}
|
||||
|
||||
/******************************************************************
|
||||
|
@ -357,7 +353,7 @@ BOOL dbg_init(HANDLE hProc, const WCHAR* in, BOOL invade)
|
|||
if (*last == '/' || *last == '\\')
|
||||
{
|
||||
WCHAR* tmp;
|
||||
tmp = HeapAlloc(GetProcessHeap(), 0, (1024 + 1 + (last - in) + 1) * sizeof(WCHAR));
|
||||
tmp = malloc((1024 + 1 + (last - in) + 1) * sizeof(WCHAR));
|
||||
if (tmp && SymGetSearchPathW(hProc, tmp, 1024))
|
||||
{
|
||||
WCHAR* x = tmp + lstrlenW(tmp);
|
||||
|
@ -368,7 +364,7 @@ BOOL dbg_init(HANDLE hProc, const WCHAR* in, BOOL invade)
|
|||
ret = SymSetSearchPathW(hProc, tmp);
|
||||
}
|
||||
else ret = FALSE;
|
||||
HeapFree(GetProcessHeap(), 0, tmp);
|
||||
free(tmp);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -402,7 +398,7 @@ struct dbg_thread* dbg_get_thread(struct dbg_process* p, DWORD tid)
|
|||
struct dbg_thread* dbg_add_thread(struct dbg_process* p, DWORD tid,
|
||||
HANDLE h, void* teb)
|
||||
{
|
||||
struct dbg_thread* t = HeapAlloc(GetProcessHeap(), 0, sizeof(struct dbg_thread));
|
||||
struct dbg_thread* t = malloc(sizeof(struct dbg_thread));
|
||||
|
||||
if (!t)
|
||||
return NULL;
|
||||
|
@ -431,10 +427,10 @@ struct dbg_thread* dbg_add_thread(struct dbg_process* p, DWORD tid,
|
|||
|
||||
void dbg_del_thread(struct dbg_thread* t)
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, t->frames);
|
||||
free(t->frames);
|
||||
list_remove(&t->entry);
|
||||
if (t == dbg_curr_thread) dbg_curr_thread = NULL;
|
||||
HeapFree(GetProcessHeap(), 0, t);
|
||||
free(t);
|
||||
}
|
||||
|
||||
void dbg_set_option(const char* option, const char* val)
|
||||
|
|
Loading…
Reference in a new issue