From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id 4L5pKTrlkV8PSQAAWB0awg (envelope-from ) for ; Thu, 22 Oct 2020 16:02:02 -0400 Received: by simark.ca (Postfix, from userid 112) id A6FAC1EFC9; Thu, 22 Oct 2020 16:02:02 -0400 (EDT) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on simark.ca X-Spam-Level: X-Spam-Status: No, score=-1.1 required=5.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,MAILING_LIST_MULTI,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.2 Received: from sourceware.org (server2.sourceware.org [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 CC89B1E552 for ; Thu, 22 Oct 2020 16:02:00 -0400 (EDT) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id D226F3987838; Thu, 22 Oct 2020 20:01:59 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org D226F3987838 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1603396919; bh=pd8wikdNxLMJTUDn6ZfZHsLZB+lsPsH1PfZ0EZKn6Zw=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=OiT0hW1vBdkJ20YWcHHtvXkjAXXn//4dfy3yNY/5vYirOE6t46lEhBmtpBFoL8rPo VoGs5rQhp/Lj/pNeLLZO+Rc7HiRC0sz8Ts3tYXii7qrrRrqxxZHhUb/ZimoTcUKavf pmcwfLfymeH6M44krkSAVkUihA6n+D9YT+NMxKuA= Received: from mail-qt1-x82e.google.com (mail-qt1-x82e.google.com [IPv6:2607:f8b0:4864:20::82e]) by sourceware.org (Postfix) with ESMTPS id A37703987833 for ; Thu, 22 Oct 2020 20:01:57 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org A37703987833 Received: by mail-qt1-x82e.google.com with SMTP id c5so2260920qtw.3 for ; Thu, 22 Oct 2020 13:01:57 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=pd8wikdNxLMJTUDn6ZfZHsLZB+lsPsH1PfZ0EZKn6Zw=; b=TtHa5tSIq81yyYFuJWRIOmGYDfcyYIFBHSYpDS/3HAIXOQ4HnDDPv+BE5fa8ukiO2z QlQoEyOevkAeymSRlJp4MRAbgNPwo64VCFOcDLQmlNOgBbceRkyC/LKKRz4RHwMV028c i98O2e4azPZmjaXzDrzyM9HtUN54Ns/2Dy1KRxsD28y+MtcbAVYrQXgn7EEj9s0YnVAU ycNJfvYmGzO1z1MCSWa19F9+Eu5VW2ieLin+1//GP4RB6PHkQ2McSM2lp6GPDKBYiUZ8 X+ueiSGvhV1NKVHtXp3Hhmdx7lFMJ1a+dwlzI+UePVw+Qt73DBDreMj7gb9eSpzVGnCb 5T1w== X-Gm-Message-State: AOAM530n6HBVqb9TKqkO/TMazedpRy12jipyG+WwnBW5kWZdoWF7fPE5 Mdp6jb3bfhYzqakvI+oH1gOs8kpMSvI2eg== X-Google-Smtp-Source: ABdhPJyYwiqzsylzZfOLpR3ILWx+WQgrXbodo9qmrCEMwOXGB2TSJubhKILYKvvYvnBqZwvZqHYwpQ== X-Received: by 2002:ac8:5c82:: with SMTP id r2mr3787387qta.195.1603396916891; Thu, 22 Oct 2020 13:01:56 -0700 (PDT) Received: from localhost.localdomain ([2804:7f0:8284:1487:b9b1:f72a:8f1:600]) by smtp.gmail.com with ESMTPSA id a21sm1711208qkk.98.2020.10.22.13.01.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 22 Oct 2020 13:01:56 -0700 (PDT) To: gdb-patches@sourceware.org Subject: [PATCH v2 21/24] Extend "x" and "print" commands to support memory tagging Date: Thu, 22 Oct 2020 17:00:11 -0300 Message-Id: <20201022200014.5189-22-luis.machado@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20201022200014.5189-1-luis.machado@linaro.org> References: <20201022200014.5189-1-luis.machado@linaro.org> 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 Cc: david.spickett@linaro.org Errors-To: gdb-patches-bounces@sourceware.org Sender: "Gdb-patches" 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.h (struct format_data) : New field. --- gdb/printcmd.c | 83 +++++++++++++++++++++++++++++++++++++++++++++++++- gdb/valprint.h | 1 + 2 files changed, 83 insertions(+), 1 deletion(-) diff --git a/gdb/printcmd.c b/gdb/printcmd.c index 1c6e05b3c5..0459f912d0 100644 --- a/gdb/printcmd.c +++ b/gdb/printcmd.c @@ -54,6 +54,7 @@ #include "gdbsupport/byte-vector.h" #include "gdbsupport/gdb_optional.h" #include "gdbsupport/rsp-low.h" +#include "infrun.h" /* For memtag setting. */ /* Chain containing all defined mtag subcommands. */ @@ -210,6 +211,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 == '-') { @@ -232,6 +234,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 @@ -1116,12 +1123,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 && memtag + && 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); @@ -1152,6 +1194,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"); } @@ -1224,6 +1271,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 (memtag && 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 * @@ -1259,7 +1326,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 (should_validate_memtags (val) + && gdbarch_memtag_mismatch_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); + } } /* See valprint.h. */ diff --git a/gdb/valprint.h b/gdb/valprint.h index 489d14ba0e..19bfb61378 100644 --- a/gdb/valprint.h +++ b/gdb/valprint.h @@ -255,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.17.1