From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id 6C+FNWnLEWDLTwAAWB0awg (envelope-from ) for ; Wed, 27 Jan 2021 15:22:01 -0500 Received: by simark.ca (Postfix, from userid 112) id 712C21EFC1; Wed, 27 Jan 2021 15:22:00 -0500 (EST) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on simark.ca X-Spam-Level: X-Spam-Status: No, score=0.2 required=5.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,MAILING_LIST_MULTI,RDNS_NONE,URIBL_BLOCKED autolearn=no autolearn_force=no version=3.4.2 Received: from sourceware.org (unknown [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by simark.ca (Postfix) with ESMTPS id 1DBE81EF84 for ; Wed, 27 Jan 2021 15:21:57 -0500 (EST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id CD0FD398B877; Wed, 27 Jan 2021 20:21:56 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org CD0FD398B877 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1611778916; bh=nDhP6ir3pQUnwgPDxq+ZVdFP2pMj6fmsmK2HD0LlYMg=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=bvLM1hYzcuNdPx1TnX9oqUm24TEIBFmdc1D62CmMDATdNmccecFxFlHDNlUYn7fV3 r4+CqM56a2clp2dYWAReBR+fVaVq5Ei+z9BD6SvO0Zl6V86WKgx7N+2PEln78fCRuI UjlvxJtfued8BtvfPv98bkjKfqEuo2uDbXGturzc= Received: from mail-qt1-x834.google.com (mail-qt1-x834.google.com [IPv6:2607:f8b0:4864:20::834]) by sourceware.org (Postfix) with ESMTPS id A4606398B868 for ; Wed, 27 Jan 2021 20:21:53 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org A4606398B868 Received: by mail-qt1-x834.google.com with SMTP id d15so2405293qtw.12 for ; Wed, 27 Jan 2021 12:21:53 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=nDhP6ir3pQUnwgPDxq+ZVdFP2pMj6fmsmK2HD0LlYMg=; b=JUekR4kcFJo6x5RMr9HueMQwy977KPJOvZd/nNtnJQ0gaHuSHaR5luU8Xlh9QoBSk7 wPI5eYvlIVj5/spjnyXc2CDU70yBSxSTnBzBRIJ3c16mKH8rTgK4w4wyguTcd/CdBkFR 10S9DFxTYcpSWDW6k2k/JqB1LaqstXcA5TTVFc6rWnk8FTbXBV2tRB6iXxFIM9aF0bRK br1djJXue90rfOyf04gdQA05QZWV0kVDAIukSuv4Pa7DZFcFnvv1M9PkF4skQBPq/4K9 6YKIBe37b0jZrX5BQ3hLBhrrfQuLTJgbmzBOVfarJxle+zzWdptT2AiaWQWn+LBSSe2Q b/0w== X-Gm-Message-State: AOAM532TZX48OH1D6ME2jqCsMnC30XicBF/NbnnPBi/0lGq+GYmc5f5V riEp/UqSfL2hoouiRM9CihFNKP62bF1xfA== X-Google-Smtp-Source: ABdhPJz++UQfiMME7hBzzGPLIgZ4d8V7ocDRdZCXhjJoCNPGkIP/evVVbqpqTVucgJ66wuLPjETSgg== X-Received: by 2002:a05:622a:18d:: with SMTP id s13mr11103802qtw.52.1611778913056; Wed, 27 Jan 2021 12:21:53 -0800 (PST) Received: from localhost.localdomain ([2804:7f0:8284:874d:b82c:87fc:4324:adab]) by smtp.gmail.com with ESMTPSA id b194sm1854531qkc.102.2021.01.27.12.21.51 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 27 Jan 2021 12:21:52 -0800 (PST) To: gdb-patches@sourceware.org Subject: [PATCH v5 22/25] Extend "x" and "print" commands to support memory tagging Date: Wed, 27 Jan 2021 17:21:09 -0300 Message-Id: <20210127202112.2485702-23-luis.machado@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210127202112.2485702-1-luis.machado@linaro.org> References: <20210127202112.2485702-1-luis.machado@linaro.org> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , From: Luis Machado via Gdb-patches Reply-To: Luis Machado Errors-To: gdb-patches-bounces@sourceware.org Sender: "Gdb-patches" Updates on v5: - Add -memory-tag-violations print option to control whether GDB should print a warning when a logical tag from a pointer doesn't match the allocation tag contained in memory. - Remove checks for a removed memory_tagging global variable. - Update tests listing print options. Updates on v4: - Updated function names. - Removed useless include of infrun.h -- Extend the "x" and "print" commands to make use of memory tagging functionality, if supported by the architecture. The "print" command will point out any possible tag mismatches it finds when dealing with pointers, in case such a pointer is tagged. No additional modifiers are needed. Suppose we have a pointer "p" with value 0x1234 (logical tag 0x0) and that we have an allocation tag of 0x1 for that particular area of memory. This is the expected output: (gdb) p/x p Logical tag (0x0) does not match the allocation tag (0x1). $1 = 0x1234 The "x" command has a new 'm' modifier that will enable displaying of allocation tags alongside the data dump. It will display one allocation tag per line. AArch64 has a tag granule of 16 bytes, which means we can have one tag for every 16 bytes of memory. In this case, this is what the "x" command will display with the new 'm' modifier: (gdb) x/32bxm p 0x1234: 0x01 0x02 0x00 0x00 0x00 0x00 0x00 0x00 0x123c: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x1244: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x124c: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 (gdb) x/4gxm a 0x1234: 0x0000000000000201 0x0000000000000000 0x1244: 0x0000000000000000 0x0000000000000000 gdb/ChangeLog: YYYY-MM-DD Luis Machado * printcmd.c (decode_format): Handle the 'm' modifier. (do_examine): Display allocation tags when required/supported. (should_validate_memtags): New function. (print_command_1): Display memory tag mismatches. * valprint.c (show_memory_tag_violations): New function. (value_print_option_defs): Add new option "memory-tag-violations". (user_print_options) : Initialize to 1. * valprint.h (struct format_data) : New field. (value_print_options) : New field. gdb/testsuite/ChangeLog: YYYY-MM-DD Luis Machado * gdb.base/options.exp: Adjust for new print options. * gdb.base/with.exp: Likewise. --- gdb/printcmd.c | 82 +++++++++++++++++++++++++++++- gdb/testsuite/gdb.base/options.exp | 1 + gdb/testsuite/gdb.base/with.exp | 2 +- gdb/valprint.c | 22 ++++++++ gdb/valprint.h | 4 ++ 5 files changed, 109 insertions(+), 2 deletions(-) diff --git a/gdb/printcmd.c b/gdb/printcmd.c index 78acda4e37..322ad16eed 100644 --- a/gdb/printcmd.c +++ b/gdb/printcmd.c @@ -193,6 +193,7 @@ decode_format (const char **string_ptr, int oformat, int osize) val.size = '?'; val.count = 1; val.raw = 0; + val.print_tags = false; if (*p == '-') { @@ -215,6 +216,11 @@ decode_format (const char **string_ptr, int oformat, int osize) val.raw = 1; p++; } + else if (*p == 'm') + { + val.print_tags = true; + p++; + } else if (*p >= 'a' && *p <= 'z') val.format = *p++; else @@ -1100,12 +1106,47 @@ do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr) need_to_update_next_address = 1; } + /* Whether we need to print the memory tag information for the current + address range. */ + bool print_range_tag = true; + uint32_t gsize = gdbarch_memtag_granule_size (gdbarch); + /* Print as many objects as specified in COUNT, at most maxelts per line, with the address of the next one at the start of each line. */ while (count > 0) { QUIT; + + CORE_ADDR tag_laddr = 0, tag_haddr = 0; + + /* Print the memory tag information if requested. */ + if (fmt.print_tags && print_range_tag + && target_supports_memory_tagging ()) + { + tag_laddr = align_down (next_address, gsize); + tag_haddr = align_down (next_address + gsize, gsize); + + struct value *v_addr + = value_from_ulongest (builtin_type (gdbarch)->builtin_data_ptr, + tag_laddr); + + if (gdbarch_tagged_address_p (target_gdbarch (), v_addr)) + { + std::string atag = gdbarch_memtag_to_string (gdbarch, v_addr, + tag_allocation); + + if (!atag.empty ()) + { + printf_filtered (_("\n"), + atag.c_str (), + paddress (gdbarch, tag_laddr), + paddress (gdbarch, tag_haddr)); + } + } + print_range_tag = false; + } + if (format == 'i') fputs_filtered (pc_prefix (next_address), gdb_stdout); print_address (next_gdbarch, next_address, gdb_stdout); @@ -1136,6 +1177,11 @@ do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr) /* Display any branch delay slots following the final insn. */ if (format == 'i' && count == 1) count += branch_delay_insns; + + /* Update the tag range based on the current address being + processed. */ + if (tag_haddr <= next_address) + print_range_tag = true; } printf_filtered ("\n"); } @@ -1208,6 +1254,26 @@ print_value (value *val, const value_print_options &opts) annotate_value_history_end (); } +/* Returns true if memory tags should be validated. False otherwise. */ + +static bool +should_validate_memtags (struct value *value) +{ + if (target_supports_memory_tagging () + && gdbarch_tagged_address_p (target_gdbarch (), value)) + { + gdb_assert (value && value_type (value)); + + enum type_code code = value_type (value)->code (); + + return (code == TYPE_CODE_PTR + || code == TYPE_CODE_REF + || code == TYPE_CODE_METHODPTR + || code == TYPE_CODE_MEMBERPTR); + } + return false; +} + /* Helper for parsing arguments for print_command_1. */ static struct value * @@ -1246,7 +1312,21 @@ print_command_1 (const char *args, int voidprint) if (voidprint || (val && value_type (val) && value_type (val)->code () != TYPE_CODE_VOID)) - print_value (val, print_opts); + { + /* If memory tagging validation is on, check if the tag is valid. */ + if (print_opts.memory_tag_violations && should_validate_memtags (val) + && !gdbarch_memtag_matches_p (target_gdbarch (), val)) + { + std::string ltag = gdbarch_memtag_to_string (target_gdbarch (), + val, tag_logical); + std::string atag = gdbarch_memtag_to_string (target_gdbarch (), + val, tag_allocation); + printf_filtered (_("Logical tag (%s) does not match the " + "allocation tag (%s).\n"), + ltag.c_str (), atag.c_str ()); + } + print_value (val, print_opts); + } } /* Called from command completion function to skip over /FMT diff --git a/gdb/testsuite/gdb.base/options.exp b/gdb/testsuite/gdb.base/options.exp index 44c773c3fa..78ec54502c 100644 --- a/gdb/testsuite/gdb.base/options.exp +++ b/gdb/testsuite/gdb.base/options.exp @@ -165,6 +165,7 @@ proc_with_prefix test-print {{prefix ""}} { "-array-indexes" "-elements" "-max-depth" + "-memory-tag-violations" "-null-stop" "-object" "-pretty" diff --git a/gdb/testsuite/gdb.base/with.exp b/gdb/testsuite/gdb.base/with.exp index 0e83ad4898..0d53dbebba 100644 --- a/gdb/testsuite/gdb.base/with.exp +++ b/gdb/testsuite/gdb.base/with.exp @@ -238,7 +238,7 @@ with_test_prefix "errors" { gdb_test "with w" \ "Ambiguous set command \"w\": watchdog, width, write\\." gdb_test "with print m" \ - "Ambiguous set print command \"m\": max-depth, max-symbolic-offset\\." + "Ambiguous set print command \"m\": max-depth, max-symbolic-offset, memory-tag-violations\\." gdb_test "with variable xxx=1" \ "Cannot use this setting with the \"with\" command" diff --git a/gdb/valprint.c b/gdb/valprint.c index 2c3541e668..95f2930adf 100644 --- a/gdb/valprint.c +++ b/gdb/valprint.c @@ -110,6 +110,7 @@ struct value_print_options user_print_options = 10, /* repeat_count_threshold */ 0, /* output_format */ 0, /* format */ + 1, /* memory_tag_violations */ 0, /* stop_print_at_null */ 0, /* print_array_indexes */ 0, /* deref_ref */ @@ -203,6 +204,17 @@ show_repeat_count_threshold (struct ui_file *file, int from_tty, value); } +/* If nonzero, prints memory tag violations for pointers. */ + +static void +show_memory_tag_violations (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + fprintf_filtered (file, + _("Printing of memory tag violations is %s.\n"), + value); +} + /* If nonzero, stops printing of char arrays at first null. */ static void @@ -3023,6 +3035,16 @@ will be replaced with either '{...}' or '(...)' depending on the language.\n\ Use \"unlimited\" to print the complete structure.") }, + boolean_option_def { + "memory-tag-violations", + [] (value_print_options *opt) { return &opt->memory_tag_violations; }, + show_memory_tag_violations, /* show_cmd_cb */ + N_("Set printing of memory tag violations for pointers."), + N_("Show printing of memory tag violations for pointers."), + N_("When logical tags in pointers do not match the allocation tags in\n\ +memory, issue a warning."), + }, + boolean_option_def { "null-stop", [] (value_print_options *opt) { return &opt->stop_print_at_null; }, diff --git a/gdb/valprint.h b/gdb/valprint.h index ca8ad6aa71..e1dae2cc8f 100644 --- a/gdb/valprint.h +++ b/gdb/valprint.h @@ -65,6 +65,9 @@ struct value_print_options e.g. when the user passes a format to "print". */ int format; + /* Print memory tag violations for pointers. */ + bool memory_tag_violations; + /* Stop printing at null character? */ bool stop_print_at_null; @@ -252,6 +255,7 @@ struct format_data int count; char format; char size; + bool print_tags; /* True if the value should be printed raw -- that is, bypassing python-based formatters. */ -- 2.25.1