From: Eric Pouech eric.pouech@gmail.com
Signed-off-by: Eric Pouech eric.pouech@gmail.com --- programs/winedbg/break.c | 34 ++++++++++++++++++++-------------- programs/winedbg/dbg.y | 8 +++++++- programs/winedbg/display.c | 7 +++++-- programs/winedbg/info.c | 19 +++++++++++++++---- programs/winedbg/stack.c | 6 ++++-- 5 files changed, 51 insertions(+), 23 deletions(-)
diff --git a/programs/winedbg/break.c b/programs/winedbg/break.c index 27a11a00d33..90df7d1e8b5 100644 --- a/programs/winedbg/break.c +++ b/programs/winedbg/break.c @@ -202,6 +202,7 @@ BOOL break_add_break(const ADDRESS64* addr, BOOL verbose, BOOL swbp) */ BOOL break_add_break_from_lvalue(const struct dbg_lvalue* lvalue, BOOL swbp) { + struct dbg_delayed_bp* new; ADDRESS64 addr;
types_extract_as_address(lvalue, &addr); @@ -215,13 +216,15 @@ 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"); - dbg_curr_process->delayed_bp = - dbg_heap_realloc(dbg_curr_process->delayed_bp, - sizeof(struct dbg_delayed_bp) * ++dbg_curr_process->num_delayed_bp); - - dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].is_symbol = FALSE; - dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].software_bp = swbp; - dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].u.addr = addr; + new = dbg_heap_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; + + dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp].is_symbol = FALSE; + 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.addr = addr; + dbg_curr_process->num_delayed_bp++; return TRUE; } return FALSE; @@ -234,6 +237,7 @@ BOOL break_add_break_from_lvalue(const struct dbg_lvalue* lvalue, BOOL swbp) */ void break_add_break_from_id(const char *name, int lineno, BOOL swbp) { + struct dbg_delayed_bp* new; struct dbg_lvalue lvalue; int i;
@@ -256,13 +260,15 @@ void break_add_break_from_id(const char *name, int lineno, BOOL swbp) lineno == dbg_curr_process->delayed_bp[i].u.symbol.lineno) return; } - dbg_curr_process->delayed_bp = dbg_heap_realloc(dbg_curr_process->delayed_bp, - sizeof(struct dbg_delayed_bp) * ++dbg_curr_process->num_delayed_bp); - - dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].is_symbol = TRUE; - dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].software_bp = swbp; - dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].u.symbol.name = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(name) + 1), name); - dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].u.symbol.lineno = lineno; + new = dbg_heap_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.lineno = lineno; + dbg_curr_process->num_delayed_bp++; }
struct cb_break_lineno diff --git a/programs/winedbg/dbg.y b/programs/winedbg/dbg.y index 30701a660be..3a5392596de 100644 --- a/programs/winedbg/dbg.y +++ b/programs/winedbg/dbg.y @@ -514,8 +514,14 @@ static int input_fetch_entire_line(const char* pfx, char** line)
if (len + 2 > alloc) { + char* new; while (len + 2 > alloc) alloc *= 2; - buffer = dbg_heap_realloc(buffer, alloc); + if (!(new = dbg_heap_realloc(buffer, alloc))) + { + HeapFree(GetProcessHeap(), 0, buffer); + return -1; + } + buffer = new; } buffer[len++] = ch; } diff --git a/programs/winedbg/display.c b/programs/winedbg/display.c index 11de3c12504..f38b3df206a 100644 --- a/programs/winedbg/display.c +++ b/programs/winedbg/display.c @@ -63,10 +63,13 @@ BOOL display_add(struct expr *exp, int count, char format)
if (i == maxdisplays) { + struct display *new; /* no space left - expand */ + new = dbg_heap_realloc(displaypoints, + (maxdisplays + DISPTAB_DELTA) * sizeof(*displaypoints)); + if (!new) return FALSE; + displaypoints = new; maxdisplays += DISPTAB_DELTA; - displaypoints = dbg_heap_realloc(displaypoints, - maxdisplays * sizeof(*displaypoints)); }
if (i == ndisplays) ndisplays++; diff --git a/programs/winedbg/info.c b/programs/winedbg/info.c index ae0fd90e938..2ba7c5950d0 100644 --- a/programs/winedbg/info.c +++ b/programs/winedbg/info.c @@ -199,8 +199,10 @@ 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)); + if (!new) return FALSE; /* stop enumeration in case of OOM */ im->num_alloc += 16; - im->modules = dbg_heap_realloc(im->modules, im->num_alloc * sizeof(*im->modules)); + im->modules = new; } im->modules[im->num_used].mi.SizeOfStruct = sizeof(im->modules[im->num_used].mi); if (SymGetModuleInfo64(dbg_curr_process->handle, base, &im->modules[im->num_used].mi)) @@ -315,8 +317,10 @@ 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)); + if (!new) return; cw->alloc += 16; - cw->table = dbg_heap_realloc(cw->table, cw->alloc * sizeof(ATOM)); + cw->table = new; } cw->table[cw->used++] = atom; info_win32_class(hWnd, clsName); @@ -547,8 +551,15 @@ void info_win32_processes(void) dp.entries[dp.count++].children = -1; if (dp.count >= dp.alloc) { - dp.entries = HeapReAlloc(GetProcessHeap(), 0, dp.entries, sizeof(*dp.entries) * (dp.alloc *= 2)); - if (!dp.entries) return; + struct dump_proc_entry* new = HeapReAlloc(GetProcessHeap(), 0, dp.entries, sizeof(*dp.entries) * (dp.alloc * 2)); + if (!new) + { + CloseHandle(snap); + HeapFree(GetProcessHeap(), 0, dp.entries); + return; + } + dp.alloc *= 2; + dp.entries = new; } dp.entries[dp.count].proc.dwSize = sizeof(dp.entries[dp.count].proc); ok = Process32Next(snap, &dp.entries[dp.count].proc); diff --git a/programs/winedbg/stack.c b/programs/winedbg/stack.c index 01a86108d6e..25328a867e2 100644 --- a/programs/winedbg/stack.c +++ b/programs/winedbg/stack.c @@ -204,8 +204,10 @@ unsigned stack_fetch_frames(const dbg_ctx_t* _ctx) SymFunctionTableAccess64, SymGetModuleBase64, NULL, SYM_STKWALK_DEFAULT)) || nf == 0) /* we always register first frame information */ { - dbg_curr_thread->frames = dbg_heap_realloc(dbg_curr_thread->frames, - (nf + 1) * sizeof(dbg_curr_thread->frames[0])); + struct dbg_frame* new = dbg_heap_realloc(dbg_curr_thread->frames, + (nf + 1) * sizeof(dbg_curr_thread->frames[0])); + if (!new) break; + dbg_curr_thread->frames = new;
dbg_curr_thread->frames[nf].addr_pc = sf.AddrPC; dbg_curr_thread->frames[nf].linear_pc = (DWORD_PTR)memory_to_linear_addr(&sf.AddrPC);
From: Eric Pouech eric.pouech@gmail.com
Signed-off-by: Eric Pouech eric.pouech@gmail.com --- programs/winedbg/break.c | 10 +++++----- programs/winedbg/crashdlg.c | 10 +++------- programs/winedbg/dbg.y | 14 +++++++------- programs/winedbg/debug.l | 6 +++--- programs/winedbg/debugger.h | 6 ------ programs/winedbg/display.c | 12 ++++++------ programs/winedbg/expr.c | 24 ++++++++++++------------ programs/winedbg/gdbproxy.c | 4 ++-- programs/winedbg/info.c | 16 ++++++++-------- programs/winedbg/memory.c | 8 ++++---- programs/winedbg/source.c | 14 +++++++------- programs/winedbg/stack.c | 6 +++--- programs/winedbg/tgt_active.c | 8 ++++---- programs/winedbg/tgt_minidump.c | 4 ++-- programs/winedbg/tgt_module.c | 4 ++-- programs/winedbg/winedbg.c | 26 +++++++++++--------------- 16 files changed, 79 insertions(+), 93 deletions(-)
diff --git a/programs/winedbg/break.c b/programs/winedbg/break.c index 90df7d1e8b5..6cff37eb886 100644 --- a/programs/winedbg/break.c +++ b/programs/winedbg/break.c @@ -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++; } diff --git a/programs/winedbg/crashdlg.c b/programs/winedbg/crashdlg.c index 7d2c99f513a..f3ea0e7b94d 100644 --- a/programs/winedbg/crashdlg.c +++ b/programs/winedbg/crashdlg.c @@ -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; } diff --git a/programs/winedbg/dbg.y b/programs/winedbg/dbg.y index 3a5392596de..dd2f0401ffc 100644 --- a/programs/winedbg/dbg.y +++ b/programs/winedbg/dbg.y @@ -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; }
diff --git a/programs/winedbg/debug.l b/programs/winedbg/debug.l index 1f8040ff976..be528fed986 100644 --- a/programs/winedbg/debug.l +++ b/programs/winedbg/debug.l @@ -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; }
diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h index d5c5934cceb..17bebf9e886 100644 --- a/programs/winedbg/debugger.h +++ b/programs/winedbg/debugger.h @@ -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; diff --git a/programs/winedbg/display.c b/programs/winedbg/display.c index f38b3df206a..370aa9f6bd7 100644 --- a/programs/winedbg/display.c +++ b/programs/winedbg/display.c @@ -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; diff --git a/programs/winedbg/expr.c b/programs/winedbg/expr.c index 5a3bc496e83..189ca2a0b39 100644 --- a/programs/winedbg/expr.c +++ b/programs/winedbg/expr.c @@ -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; } diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index a63748c6ebe..643860d55ee 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -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; diff --git a/programs/winedbg/info.c b/programs/winedbg/info.c index 2ba7c5950d0..af68ab799da 100644 --- a/programs/winedbg/info.c +++ b/programs/winedbg/info.c @@ -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); } }
diff --git a/programs/winedbg/memory.c b/programs/winedbg/memory.c index aa5c32b42f2..a8318675ff6 100644 --- a/programs/winedbg/memory.c +++ b/programs/winedbg/memory.c @@ -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; } diff --git a/programs/winedbg/source.c b/programs/winedbg/source.c index 363cf2bf654..044eccaab5e 100644 --- a/programs/winedbg/source.c +++ b/programs/winedbg/source.c @@ -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); } } diff --git a/programs/winedbg/stack.c b/programs/winedbg/stack.c index 25328a867e2..5385b048ff0 100644 --- a/programs/winedbg/stack.c +++ b/programs/winedbg/stack.c @@ -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;
diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c index 9e11de69bc9..b3b385ee2b4 100644 --- a/programs/winedbg/tgt_active.c +++ b/programs/winedbg/tgt_active.c @@ -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); } } diff --git a/programs/winedbg/tgt_minidump.c b/programs/winedbg/tgt_minidump.c index af39d4af922..d5f3a10a5e9 100644 --- a/programs/winedbg/tgt_minidump.c +++ b/programs/winedbg/tgt_minidump.c @@ -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; diff --git a/programs/winedbg/tgt_module.c b/programs/winedbg/tgt_module.c index 63fab9a238e..56a59356ffa 100644 --- a/programs/winedbg/tgt_module.c +++ b/programs/winedbg/tgt_module.c @@ -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) diff --git a/programs/winedbg/winedbg.c b/programs/winedbg/winedbg.c index 8a5c9bc69ed..1bf627fd53c 100644 --- a/programs/winedbg/winedbg.c +++ b/programs/winedbg/winedbg.c @@ -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)
FWIW I think it'd be nice if you could format the commit messages in a consistent way with Wine history (leading capital and trailing period). I believe there was some discussion about being able to merge directly from Gitlab, and having to manually edit messages will prevent us from doing that.
This merge request was approved by R��mi Bernon.
-
Eric Pouech -
eric pouech (＠epo)
-
Rémi Bernon (＠rbernon)