From patchwork Sat Feb 8 16:26:14 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Terekhov, Mikhail via Gdb-patches" X-Patchwork-Id: 37771 Received: (qmail 100060 invoked by alias); 8 Feb 2020 16:26:58 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 99849 invoked by uid 89); 8 Feb 2020 16:26:56 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-21.6 required=5.0 tests=AWL, BAYES_00, FREEMAIL_FROM, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.1 spammy= X-HELO: sonic309-25.consmr.mail.ir2.yahoo.com Received: from sonic309-25.consmr.mail.ir2.yahoo.com (HELO sonic309-25.consmr.mail.ir2.yahoo.com) (77.238.179.83) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 08 Feb 2020 16:26:54 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yahoo.de; s=s2048; t=1581179210; bh=MX4GzmHFwVNJSI+egk2ZLbTyJhRw3Z2FjSDN86l8170=; h=From:To:Subject:Date:In-Reply-To:References:From:Subject; b=NEQCUIt1064Qy6WvRm4FikYLLlKErUKAuzMO+g4p5j9sCctKvGdcl0s5rXm5DnTA1DDJNt8DvhWOSOCYa8wCworTPFI2wqtVYRNHcLQGIe6r0uhLsr3AXL0z/rmc8wVNyoivQQpC00bAJBM4m+CHZ0o38k6eeaLi3FPxcbIRqKD2UwGs3ITOj7Pgc0YhZTjOyEXG6CKz+y3j8AqMdR4uwVTd30tAEpH/Ra57252bAK9D3Kg5xloEOLIjjW2kIrrWJzA0GVoVv1NVGRbjsWEkE8aHHkx2T/Vk9s5ncU1yyUKwBKMwglwDhwjJbpcgZzdbfQ9RuvydA+RQdyxEAGm2XQ== Received: from sonic.gate.mail.ne1.yahoo.com by sonic309.consmr.mail.ir2.yahoo.com with HTTP; Sat, 8 Feb 2020 16:26:50 +0000 Received: by smtp422.mail.ir2.yahoo.com (Oath Hermes SMTP Server) with ESMTPA ID 0733abcbb6ba962e7b0d5cf63f3ad1a7; Sat, 08 Feb 2020 16:26:46 +0000 (UTC) X-Patchwork-Original-From: "Hannes Domani via gdb-patches" From: "Terekhov, Mikhail via Gdb-patches" Reply-To: Hannes Domani To: gdb-patches@sourceware.org Subject: [PATCH v2 2/2] Use enums for human-readable exception information. Date: Sat, 8 Feb 2020 17:26:14 +0100 Message-Id: <20200208162614.4918-2-ssbssa@yahoo.de> In-Reply-To: <20200208162614.4918-1-ssbssa@yahoo.de> References: <20200208162614.4918-1-ssbssa@yahoo.de> MIME-Version: 1.0 Content-Length: 7405 X-IsSubscribed: yes Changes to $_siginfo type to this: (gdb) pt $_siginfo type = struct EXCEPTION_RECORD { enum ExceptionCode ExceptionCode; DWORD ExceptionFlags; struct EXCEPTION_RECORD *ExceptionRecord; PVOID ExceptionAddress; DWORD NumberParameters; union { ULONG_PTR ExceptionInformation[15]; struct {...} AccessViolationInformation; }; } (gdb) pt $_siginfo.ExceptionCode type = enum ExceptionCode {FATAL_APP_EXIT = 1073741845, DBG_CONTROL_C = 1073807365, DBG_CONTROL_BREAK = 1073807368, DATATYPE_MISALIGNMENT = 2147483650, BREAKPOINT, SINGLE_STEP, ACCESS_VIOLATION = 3221225477, IN_PAGE_ERROR, ILLEGAL_INSTRUCTION = 3221225501, NONCONTINUABLE_EXCEPTION = 3221225509, INVALID_DISPOSITION, ARRAY_BOUNDS_EXCEEDED = 3221225612, FLOAT_DENORMAL_OPERAND, FLOAT_DIVIDE_BY_ZERO, FLOAT_INEXACT_RESULT, FLOAT_INVALID_OPERATION, FLOAT_OVERFLOW, FLOAT_STACK_CHECK, FLOAT_UNDERFLOW, INTEGER_DIVIDE_BY_ZERO, INTEGER_OVERFLOW, PRIV_INSTRUCTION, STACK_OVERFLOW = 3221225725, FAST_FAIL = 3221226505} (gdb) pt $_siginfo.AccessViolationInformation type = struct { enum ViolationType Type; PVOID Address; } (gdb) pt $_siginfo.AccessViolationInformation.Type type = enum ViolationType {READ_ACCESS_VIOLATION, WRITE_ACCESS_VIOLATION, DATA_EXECUTION_PREVENTION_VIOLATION = 8} Which makes it easier to understand the reason of the exception: (gdb) p $_siginfo $1 = { ExceptionCode = ACCESS_VIOLATION, ExceptionFlags = 0, ExceptionRecord = 0x0, ExceptionAddress = 0x401632 , NumberParameters = 2, { ExceptionInformation = {1, 291, 0 }, AccessViolationInformation = { Type = WRITE_ACCESS_VIOLATION, Address = 0x123 } } } gdb/ChangeLog: 2020-02-08 Hannes Domani * windows-tdep.c (struct enum_value_name): New struct. (create_enum): New function. (windows_get_siginfo_type): Create and use enum types. --- v2: - more comments --- gdb/windows-tdep.c | 102 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 96 insertions(+), 6 deletions(-) diff --git a/gdb/windows-tdep.c b/gdb/windows-tdep.c index ad65b1b403..e9787887a4 100644 --- a/gdb/windows-tdep.c +++ b/gdb/windows-tdep.c @@ -680,6 +680,71 @@ windows_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal) return -1; } +struct enum_value_name +{ + uint32_t value; + const char *name; +}; + +/* Allocate a TYPE_CODE_ENUM type structure with its named values. */ + +static struct type * +create_enum (struct gdbarch *gdbarch, int bit, const char *name, + const struct enum_value_name *values, int count) +{ + struct type *type; + int i; + + type = arch_type (gdbarch, TYPE_CODE_ENUM, bit, name); + TYPE_NFIELDS (type) = count; + TYPE_FIELDS (type) = (struct field *) + TYPE_ZALLOC (type, sizeof (struct field) * count); + TYPE_UNSIGNED (type) = 1; + + for (i = 0; i < count; i++) + { + TYPE_FIELD_NAME (type, i) = values[i].name; + SET_FIELD_ENUMVAL (TYPE_FIELD (type, i), values[i].value); + } + + return type; +} + +static const struct enum_value_name exception_values[] = +{ + { 0x40000015, "FATAL_APP_EXIT" }, + { 0x40010005, "DBG_CONTROL_C" }, + { 0x40010008, "DBG_CONTROL_BREAK" }, + { 0x80000002, "DATATYPE_MISALIGNMENT" }, + { 0x80000003, "BREAKPOINT" }, + { 0x80000004, "SINGLE_STEP" }, + { 0xC0000005, "ACCESS_VIOLATION" }, + { 0xC0000006, "IN_PAGE_ERROR" }, + { 0xC000001D, "ILLEGAL_INSTRUCTION" }, + { 0xC0000025, "NONCONTINUABLE_EXCEPTION" }, + { 0xC0000026, "INVALID_DISPOSITION" }, + { 0xC000008C, "ARRAY_BOUNDS_EXCEEDED" }, + { 0xC000008D, "FLOAT_DENORMAL_OPERAND" }, + { 0xC000008E, "FLOAT_DIVIDE_BY_ZERO" }, + { 0xC000008F, "FLOAT_INEXACT_RESULT" }, + { 0xC0000090, "FLOAT_INVALID_OPERATION" }, + { 0xC0000091, "FLOAT_OVERFLOW" }, + { 0xC0000092, "FLOAT_STACK_CHECK" }, + { 0xC0000093, "FLOAT_UNDERFLOW" }, + { 0xC0000094, "INTEGER_DIVIDE_BY_ZERO" }, + { 0xC0000095, "INTEGER_OVERFLOW" }, + { 0xC0000096, "PRIV_INSTRUCTION" }, + { 0xC00000FD, "STACK_OVERFLOW" }, + { 0xC0000409, "FAST_FAIL" }, +}; + +static const struct enum_value_name violation_values[] = +{ + { 0, "READ_ACCESS_VIOLATION" }, + { 1, "WRITE_ACCESS_VIOLATION" }, + { 8, "DATA_EXECUTION_PREVENTION_VIOLATION" }, +}; + /* Implement the "get_siginfo_type" gdbarch method. */ static struct type * @@ -687,7 +752,8 @@ windows_get_siginfo_type (struct gdbarch *gdbarch) { struct windows_gdbarch_data *windows_gdbarch_data; struct type *dword_type, *pvoid_type, *ulongptr_type; - struct type *siginfo_ptr_type, *siginfo_type; + struct type *code_enum, *violation_enum; + struct type *violation_type, *para_type, *siginfo_ptr_type, *siginfo_type; windows_gdbarch_data = get_windows_gdbarch_data (gdbarch); if (windows_gdbarch_data->siginfo_type != NULL) @@ -700,12 +766,38 @@ windows_get_siginfo_type (struct gdbarch *gdbarch) ulongptr_type = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "ULONG_PTR"); + /* ExceptionCode value names */ + code_enum = create_enum (gdbarch, gdbarch_int_bit (gdbarch), + "ExceptionCode", exception_values, + ARRAY_SIZE (exception_values)); + + /* ACCESS_VIOLATION type names */ + violation_enum = create_enum (gdbarch, gdbarch_ptr_bit (gdbarch), + "ViolationType", violation_values, + ARRAY_SIZE (violation_values)); + + /* ACCESS_VIOLATION information */ + violation_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); + append_composite_type_field (violation_type, "Type", violation_enum); + append_composite_type_field (violation_type, "Address", pvoid_type); + + /* Unnamed union of the documented field ExceptionInformation, + and the alternative AccessViolationInformation (which displays + human-readable values for ExceptionCode ACCESS_VIOLATION). */ + para_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION); + append_composite_type_field (para_type, "ExceptionInformation", + lookup_array_range_type (ulongptr_type, 0, 14)); + append_composite_type_field (para_type, "AccessViolationInformation", + violation_type); + siginfo_type = arch_composite_type (gdbarch, "EXCEPTION_RECORD", TYPE_CODE_STRUCT); siginfo_ptr_type = arch_pointer_type (gdbarch, gdbarch_ptr_bit (gdbarch), NULL, siginfo_type); - append_composite_type_field (siginfo_type, "ExceptionCode", dword_type); + /* ExceptionCode is documented as type DWORD, but here a helper + enum type is used instead to display a human-readable value. */ + append_composite_type_field (siginfo_type, "ExceptionCode", code_enum); append_composite_type_field (siginfo_type, "ExceptionFlags", dword_type); append_composite_type_field (siginfo_type, "ExceptionRecord", siginfo_ptr_type); @@ -713,10 +805,8 @@ windows_get_siginfo_type (struct gdbarch *gdbarch) pvoid_type); append_composite_type_field (siginfo_type, "NumberParameters", dword_type); /* The 64-bit variant needs some padding. */ - append_composite_type_field_aligned (siginfo_type, "ExceptionInformation", - lookup_array_range_type (ulongptr_type, - 0, 14), - TYPE_LENGTH (ulongptr_type)); + append_composite_type_field_aligned (siginfo_type, "", + para_type, TYPE_LENGTH (ulongptr_type)); windows_gdbarch_data->siginfo_type = siginfo_type;