From patchwork Thu Feb 13 20:30:32 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Simon Marchi X-Patchwork-Id: 38053 Received: (qmail 29299 invoked by alias); 13 Feb 2020 20:30:51 -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 29123 invoked by uid 89); 13 Feb 2020 20:30:47 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-23.6 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, SPF_PASS autolearn=ham version=3.3.1 spammy=QUIT, quit X-HELO: mail.efficios.com Received: from mail.efficios.com (HELO mail.efficios.com) (167.114.26.124) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 13 Feb 2020 20:30:45 +0000 Received: from localhost (localhost [127.0.0.1]) by mail.efficios.com (Postfix) with ESMTP id 10142261072 for ; Thu, 13 Feb 2020 15:30:44 -0500 (EST) Received: from mail.efficios.com ([127.0.0.1]) by localhost (mail03.efficios.com [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id X2whCp-_46so; Thu, 13 Feb 2020 15:30:43 -0500 (EST) Received: from localhost (localhost [127.0.0.1]) by mail.efficios.com (Postfix) with ESMTP id 96416261614; Thu, 13 Feb 2020 15:30:42 -0500 (EST) DKIM-Filter: OpenDKIM Filter v2.10.3 mail.efficios.com 96416261614 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=efficios.com; s=default; t=1581625842; bh=/7Rl94paat9qJdFuWKjPCveFKmYNdVVyNBUBUwN8JHE=; h=From:To:Date:Message-Id:MIME-Version; b=AfFkb0hA6a7GPJ5HY0gYwMQPmga6hz70rK+OasJ97CsEmuh2QHjcMhtz93OnXO3FI S55Fb7mAwOWp0IYuUejRPeYb6cmSQ1bmZ3g5aNnKfGpqaQCwrtpTpYYwaMbwNz07hb L9rD8z+AOaTI5+TR6Ppj4Y9NwhJ7eIyv8SLOx4sxZ04jklfi+EeX379YZSA9zGjyci uCtD0HrZ7XPpqwSGiE1uyFdfRTg2FC+IWDysQo3sV+eedEcwTaFYTGwy8ktdVf+Zq1 HlxJdy3lLspmoqT15dRCtQLj7+ieWX+cyGuyLE/nkeAgUgZfoVu9+/9jOQvtNED6qE czyxDsJr386+A== Received: from mail.efficios.com ([127.0.0.1]) by localhost (mail03.efficios.com [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id Bfueb62qRL6F; Thu, 13 Feb 2020 15:30:42 -0500 (EST) Received: from smarchi-efficios.internal.efficios.com (192-222-181-218.qc.cable.ebox.net [192.222.181.218]) by mail.efficios.com (Postfix) with ESMTPSA id 6D812261683; Thu, 13 Feb 2020 15:30:42 -0500 (EST) From: Simon Marchi To: gdb-patches@sourceware.org Cc: Simon Marchi Subject: [PATCH 2/5] gdb: fix printing of flag enums with multi-bit enumerators Date: Thu, 13 Feb 2020 15:30:32 -0500 Message-Id: <20200213203035.30157-2-simon.marchi@efficios.com> In-Reply-To: <20200213203035.30157-1-simon.marchi@efficios.com> References: <20200213203035.30157-1-simon.marchi@efficios.com> MIME-Version: 1.0 GDB has this feature where if an enum looks like it is meant to represent binary flags, it will present the values of that type as a bitwise OR of the flags that are set in the value. The original motivation for this patch is to fix this behavior: enum hello { AAA = 0x1, BBB = 0xf0 }; (gdb) p (enum hello) 0x11 $1 = (AAA | BBB) This is wrong because the bits set in BBB (0xf0) are not all set in the value 0x11, but GDB presents it as if they all were. I think that enumerations with enumerators that have more than one bit set should simply not qualify as "flag enum", as far as this heuristic is concerned. I'm not sure what it means to have flags of more than one bit. So this is what this patch implements. I have added an assert in generic_val_print_enum_1 to make sure the flag enum types respect that, in case they are used by other debug info readers, in the future. I've enhanced the gdb.base/printcmds.exp test to cover this case. I've also added tests for printing flag enums with value 0, both when the enumeration has and doesn't have an enumerator for value 0. gdb/ChangeLog: * dwarf2/read.c: Include "count-one-bits.h". (update_enumeration_type_from_children): If an enumerator has multiple bits set, don't treat the enumeration as a "flag enum". * valprint.c (generic_val_print_enum_1): Assert that enumerators of flag enums have 0 or 1 bit set. gdb/testsuite/ChangeLog: * gdb.base/printcmds.c (enum flag_enum): Prefix enumerators with FE_, add FE_NONE. (three): Update. (enum flag_enum_without_zero): New enum. (flag_enum_without_zero): New variable. (enum not_flag_enum): New enum. (three_not_flag): New variable. * gdb.base/printcmds.exp (test_artificial_arrays): Update. (test_print_enums): Add more tests for printing flag enums. --- gdb/dwarf2/read.c | 14 ++++++++++--- gdb/testsuite/gdb.base/printcmds.c | 30 ++++++++++++++++++++++++++-- gdb/testsuite/gdb.base/printcmds.exp | 20 ++++++++++++++++--- gdb/valprint.c | 8 +++++++- 4 files changed, 63 insertions(+), 9 deletions(-) diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c index 7edbd9d7dfa4..b866cc2d5747 100644 --- a/gdb/dwarf2/read.c +++ b/gdb/dwarf2/read.c @@ -82,6 +82,7 @@ #include "gdbsupport/selftest.h" #include "rust-lang.h" #include "gdbsupport/pathstuff.h" +#include "count-one-bits.h" /* When == 1, print basic high level tracing messages. When > 1, be more verbose. @@ -15526,10 +15527,17 @@ update_enumeration_type_from_children (struct die_info *die, unsigned_enum = 0; flag_enum = 0; } - else if ((mask & value) != 0) - flag_enum = 0; else - mask |= value; + { + int nbits = count_one_bits_ll (value); + + if (nbits != 0 && nbits && nbits != 1) + flag_enum = 0; + else if ((mask & value) != 0) + flag_enum = 0; + else + mask |= value; + } /* If we already know that the enum type is neither unsigned, nor a flag type, no need to look at the rest of the enumerates. */ diff --git a/gdb/testsuite/gdb.base/printcmds.c b/gdb/testsuite/gdb.base/printcmds.c index 57e04e6c01f3..f0b4fa4b86b1 100644 --- a/gdb/testsuite/gdb.base/printcmds.c +++ b/gdb/testsuite/gdb.base/printcmds.c @@ -96,9 +96,35 @@ enum some_volatile_enum { enumvolval1, enumvolval2 }; name. See PR11827. */ volatile enum some_volatile_enum some_volatile_enum = enumvolval1; -enum flag_enum { ONE = 1, TWO = 2 }; +/* An enum considered as a "flag enum". */ +enum flag_enum +{ + FE_NONE = 0x00, + FE_ONE = 0x01, + FE_TWO = 0x02, +}; + +enum flag_enum three = FE_ONE | FE_TWO; + +/* Another enum considered as a "flag enum", but with enumerator with value + 0. */ +enum flag_enum_without_zero +{ + FEWZ_ONE = 0x01, + FEWZ_TWO = 0x02, +}; + +enum flag_enum_without_zero flag_enum_without_zero = 0; + +/* Not a flag enum, an enumerator value has multiple bits sets. */ +enum not_flag_enum +{ + NFE_ONE = 0x01, + NFE_TWO = 0x02, + NFE_F0 = 0xf0, +}; -enum flag_enum three = ONE | TWO; +enum not_flag_enum three_not_flag = NFE_ONE | NFE_TWO; /* A structure with an embedded array at an offset > 0. The array has all elements with the same repeating value, which must not be the diff --git a/gdb/testsuite/gdb.base/printcmds.exp b/gdb/testsuite/gdb.base/printcmds.exp index 6e98b7943ba3..6afb965af066 100644 --- a/gdb/testsuite/gdb.base/printcmds.exp +++ b/gdb/testsuite/gdb.base/printcmds.exp @@ -653,9 +653,9 @@ proc test_artificial_arrays {} { gdb_test_escape_braces "p int1dim\[0\]${ctrlv}@2${ctrlv}@3" \ "({{0, 1}, {2, 3}, {4, 5}}|\[Cc\]annot.*)" \ {p int1dim[0]@2@3} - gdb_test_escape_braces "p int1dim\[0\]${ctrlv}@TWO" " = {0, 1}" \ + gdb_test_escape_braces "p int1dim\[0\]${ctrlv}@FE_TWO" " = {0, 1}" \ {p int1dim[0]@TWO} - gdb_test_escape_braces "p int1dim\[0\]${ctrlv}@TWO${ctrlv}@three" \ + gdb_test_escape_braces "p int1dim\[0\]${ctrlv}@FE_TWO${ctrlv}@three" \ "({{0, 1}, {2, 3}, {4, 5}}|\[Cc\]annot.*)" \ {p int1dim[0]@TWO@three} gdb_test_escape_braces {p/x (short [])0x12345678} \ @@ -736,7 +736,21 @@ proc test_print_enums {} { # Regression test for PR11827. gdb_test "print some_volatile_enum" "enumvolval1" - gdb_test "print three" " = \\\(ONE \\| TWO\\\)" + # Print a flag enum. + gdb_test "print three" [string_to_regexp " = (FE_ONE | FE_TWO)"] + + # Print a flag enum with value 0, where an enumerator has value 0. + gdb_test "print (enum flag_enum) 0x0" [string_to_regexp " = FE_NONE"] + + # Print a flag enum with value 0, where no enumerator has value 0. + gdb_test "print flag_enum_without_zero" [string_to_regexp " = (unknown: 0)"] + + # Print a flag enum with unknown bits set. + gdb_test "print (enum flag_enum) 0xf1" [string_to_regexp " = (FE_ONE | unknown: 240)"] + + # Test printing an enum not considered a "flag enum" (because one of its + # enumerators has multiple bits set). + gdb_test "print three_not_flag" [string_to_regexp " = 3"] } proc test_printf {} { diff --git a/gdb/valprint.c b/gdb/valprint.c index f26a87da3bd4..77b9a4993d79 100644 --- a/gdb/valprint.c +++ b/gdb/valprint.c @@ -39,6 +39,7 @@ #include "cli/cli-option.h" #include "gdbarch.h" #include "cli/cli-style.h" +#include "count-one-bits.h" /* Maximum number of wchars returned from wchar_iterate. */ #define MAX_WCHARS 4 @@ -638,7 +639,12 @@ generic_val_print_enum_1 (struct type *type, LONGEST val, { QUIT; - if ((val & TYPE_FIELD_ENUMVAL (type, i)) != 0) + ULONGEST enumval = TYPE_FIELD_ENUMVAL (type, i); + int nbits = count_one_bits_ll (enumval); + + gdb_assert (nbits == 0 || nbits == 1); + + if ((val & enumval) != 0) { if (!first) fputs_filtered (" | ", stream);