From patchwork Wed Jan 4 16:44:52 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 62707 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 1641D385842E for ; Wed, 4 Jan 2023 16:45:30 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 1641D385842E DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1672850730; bh=GJzF/GXK5YkAvfNJ6gHhWWwVXzdtX51/JXHeXvgBMxY=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=pTujq0kOrdvjhtZQdY7AHYALJ6o7XwSb+820JgnQv/KId2pgpB8zd+uDI5F7bI5+a K/5QGilxXXbKjACUJZDhASHN167hjQ26UmBUwx44ZOauKubHqUd32yoaiqj34lbnMU oeQ6n6M763gAiKO0XwzQSNO3qqRaodTR5VPmOzZM= X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from mail-io1-xd2a.google.com (mail-io1-xd2a.google.com [IPv6:2607:f8b0:4864:20::d2a]) by sourceware.org (Postfix) with ESMTPS id 24D2D3858C50 for ; Wed, 4 Jan 2023 16:45:04 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 24D2D3858C50 Received: by mail-io1-xd2a.google.com with SMTP id r72so18279818iod.5 for ; Wed, 04 Jan 2023 08:45:04 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=GJzF/GXK5YkAvfNJ6gHhWWwVXzdtX51/JXHeXvgBMxY=; b=3Ag1NfS9UXwn+pJzes475XQ1lfveY3W+oywYUlYgw2FDuyyVokU+XkN2Z+pOtZlXQv 60NoBY2WXxO2gJl33BiBM2OxjSAIt3pVh+e9GyYAJ97EgFOHcl/RtF7kidsI/7yXWuMD i3s5nT6vOF98gmY8fh4Nwk4hpjArRac+SJbkQdYusSw9o4r2GvD+FZg68uQDCy+bLWw1 EBzyN8djlrGDsrb02EXNvS9KZSMJKeBb4zt4cY9jZnE1bGrTt++jMcDzEx/11O88pW8t JlS4g6jmXy4CS1DM08/cHxbHuUpxcnxexPAjcIQ2+eQpa2pcS2N5ZtuFfu3/n4e2Wzbr f5uA== X-Gm-Message-State: AFqh2krp9qJaX+2VWIRMvGieXoD86B/37QGVL3DZlexO2l71ndOGZ4FU Mv/V5u0ivSd4Zj49f6QqY94uvFwvBhC8Look X-Google-Smtp-Source: AMrXdXvqRNESy4uLSp6/xYkkKzQQC87F1MRba29zLaW562R5l9pcmprUC3jJu8+/FJSLpQIj94mm5g== X-Received: by 2002:a6b:d919:0:b0:6e9:9776:a6c8 with SMTP id r25-20020a6bd919000000b006e99776a6c8mr39710253ioc.2.1672850703371; Wed, 04 Jan 2023 08:45:03 -0800 (PST) Received: from localhost.localdomain (97-122-76-186.hlrn.qwest.net. [97.122.76.186]) by smtp.gmail.com with ESMTPSA id h145-20020a6bb797000000b006e02c489089sm12700680iof.32.2023.01.04.08.45.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 04 Jan 2023 08:45:02 -0800 (PST) To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [PATCH 2/2] Handle range types in ax-gdb.c Date: Wed, 4 Jan 2023 09:44:52 -0700 Message-Id: <20230104164452.1154744-3-tromey@adacore.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20230104164452.1154744-1-tromey@adacore.com> References: <20230104164452.1154744-1-tromey@adacore.com> MIME-Version: 1.0 X-Spam-Status: No, score=-11.4 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.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: , X-Patchwork-Original-From: Tom Tromey via Gdb-patches From: Tom Tromey Reply-To: Tom Tromey Errors-To: gdb-patches-bounces+patchwork=sourceware.org@sourceware.org Sender: "Gdb-patches" A range type can usually be treated the same as its underlying integer type, at least for the purposes of agent expressions. This patch arranges for range types to be handled this way in ax-gdb.c, letting a somewhat larger subset of Ada expressions be compiled. --- gdb/ax-gdb.c | 60 +++++++++++++++++---------- gdb/testsuite/gdb.ada/ax-ada.exp | 1 + gdb/testsuite/gdb.ada/ax-ada/prog.adb | 3 ++ 3 files changed, 42 insertions(+), 22 deletions(-) diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c index fc214e7dfe1..dc2c25410fe 100644 --- a/gdb/ax-gdb.c +++ b/gdb/ax-gdb.c @@ -353,6 +353,16 @@ gen_extend (struct agent_expr *ax, struct type *type) ((type->is_unsigned () ? ax_zero_ext : ax_ext) (ax, bits)); } +/* A helper that returns the target type if TYPE is a range type, or + otherwise just returns TYPE. */ + +static struct type * +strip_range_type (struct type *type) +{ + if (type->code () == TYPE_CODE_RANGE) + return type->target_type (); + return type; +} /* Assume that the top of the stack contains a value of type "pointer to TYPE"; generate code to fetch its value. Note that TYPE is the @@ -366,8 +376,7 @@ gen_fetch (struct agent_expr *ax, struct type *type) ax_trace_quick (ax, type->length ()); } - if (type->code () == TYPE_CODE_RANGE) - type = type->target_type (); + type = strip_range_type (type); switch (type->code ()) { @@ -832,9 +841,12 @@ static void gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1, struct axs_value *value2) { + struct type *type1 = strip_range_type (value1->type); + struct type *type2 = strip_range_type (value2->type); + /* Do the usual binary conversions. */ - if (value1->type->code () == TYPE_CODE_INT - && value2->type->code () == TYPE_CODE_INT) + if (type1->code () == TYPE_CODE_INT + && type2->code () == TYPE_CODE_INT) { /* The ANSI integral promotions seem to work this way: Order the integer types by size, and then by signedness: an n-bit @@ -842,18 +854,18 @@ gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1, type. Promote to the "wider" of the two types, and always promote at least to int. */ struct type *target = max_type (builtin_type (ax->gdbarch)->builtin_int, - max_type (value1->type, value2->type)); + max_type (type1, type2)); /* Deal with value2, on the top of the stack. */ - gen_conversion (ax, value2->type, target); + gen_conversion (ax, type2, target); /* Deal with value1, not on the top of the stack. Don't generate the `swap' instructions if we're not actually going to do anything. */ - if (is_nontrivial_conversion (value1->type, target)) + if (is_nontrivial_conversion (type1, target)) { ax_simple (ax, aop_swap); - gen_conversion (ax, value1->type, target); + gen_conversion (ax, type1, target); ax_simple (ax, aop_swap); } @@ -892,6 +904,7 @@ gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type) require_rvalue (ax, value); /* Dereference typedefs. */ type = check_typedef (type); + type = strip_range_type (type); switch (type->code ()) { @@ -960,7 +973,7 @@ gen_ptradd (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2) { gdb_assert (value1->type->is_pointer_or_reference ()); - gdb_assert (value2->type->code () == TYPE_CODE_INT); + gdb_assert (strip_range_type (value2->type)->code () == TYPE_CODE_INT); gen_scale (ax, aop_mul, value1->type); ax_simple (ax, aop_add); @@ -976,7 +989,7 @@ gen_ptrsub (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2) { gdb_assert (value1->type->is_pointer_or_reference ()); - gdb_assert (value2->type->code () == TYPE_CODE_INT); + gdb_assert (strip_range_type (value2->type)->code () == TYPE_CODE_INT); gen_scale (ax, aop_mul, value1->type); ax_simple (ax, aop_sub); @@ -1048,14 +1061,15 @@ gen_binop (struct agent_expr *ax, struct axs_value *value, int may_carry, const char *name) { /* We only handle INT op INT. */ - if ((value1->type->code () != TYPE_CODE_INT) - || (value2->type->code () != TYPE_CODE_INT)) + struct type *type1 = strip_range_type (value1->type); + if ((type1->code () != TYPE_CODE_INT) + || (strip_range_type (value2->type)->code () != TYPE_CODE_INT)) error (_("Invalid combination of types in %s."), name); - ax_simple (ax, value1->type->is_unsigned () ? op_unsigned : op); + ax_simple (ax, type1->is_unsigned () ? op_unsigned : op); if (may_carry) - gen_extend (ax, value1->type); /* catch overflow */ - value->type = value1->type; + gen_extend (ax, type1); /* catch overflow */ + value->type = type1; value->kind = axs_rvalue; } @@ -1064,8 +1078,9 @@ static void gen_logical_not (struct agent_expr *ax, struct axs_value *value, struct type *result_type) { - if (value->type->code () != TYPE_CODE_INT - && value->type->code () != TYPE_CODE_PTR) + struct type *type = strip_range_type (value->type); + if (type->code () != TYPE_CODE_INT + && type->code () != TYPE_CODE_PTR) error (_("Invalid type of operand to `!'.")); ax_simple (ax, aop_log_not); @@ -1076,11 +1091,12 @@ gen_logical_not (struct agent_expr *ax, struct axs_value *value, static void gen_complement (struct agent_expr *ax, struct axs_value *value) { - if (value->type->code () != TYPE_CODE_INT) + struct type *type = strip_range_type (value->type); + if (type->code () != TYPE_CODE_INT) error (_("Invalid type of operand to `~'.")); ax_simple (ax, aop_bit_not); - gen_extend (ax, value->type); + gen_extend (ax, type); } @@ -2078,7 +2094,7 @@ gen_expr_binop_rest (struct expression *exp, switch (op) { case BINOP_ADD: - if (value1->type->code () == TYPE_CODE_INT + if (strip_range_type (value1->type)->code () == TYPE_CODE_INT && value2->type->is_pointer_or_reference ()) { /* Swap the values and proceed normally. */ @@ -2086,7 +2102,7 @@ gen_expr_binop_rest (struct expression *exp, gen_ptradd (ax, value, value2, value1); } else if (value1->type->is_pointer_or_reference () - && value2->type->code () == TYPE_CODE_INT) + && strip_range_type (value2->type)->code () == TYPE_CODE_INT) gen_ptradd (ax, value, value1, value2); else gen_binop (ax, value, value1, value2, @@ -2094,7 +2110,7 @@ gen_expr_binop_rest (struct expression *exp, break; case BINOP_SUB: if (value1->type->is_pointer_or_reference () - && value2->type->code () == TYPE_CODE_INT) + && strip_range_type (value2->type)->code () == TYPE_CODE_INT) gen_ptrsub (ax,value, value1, value2); else if (value1->type->is_pointer_or_reference () && value2->type->is_pointer_or_reference ()) diff --git a/gdb/testsuite/gdb.ada/ax-ada.exp b/gdb/testsuite/gdb.ada/ax-ada.exp index b08f7c4362c..d0464b7a5b8 100644 --- a/gdb/testsuite/gdb.ada/ax-ada.exp +++ b/gdb/testsuite/gdb.ada/ax-ada.exp @@ -29,3 +29,4 @@ set bp_location [gdb_get_line_number "START" ${testdir}/prog.adb] runto "prog.adb:$bp_location" gdb_test "maint agent-eval variable = 23" ".*end" +gdb_test "maint agent-eval range_variable = 23" ".*end" diff --git a/gdb/testsuite/gdb.ada/ax-ada/prog.adb b/gdb/testsuite/gdb.ada/ax-ada/prog.adb index 3852711e88c..85148d0c9c5 100644 --- a/gdb/testsuite/gdb.ada/ax-ada/prog.adb +++ b/gdb/testsuite/gdb.ada/ax-ada/prog.adb @@ -14,7 +14,10 @@ -- along with this program. If not, see . procedure Prog is + type Range_Type is range -15 .. 73; + Variable : Integer := 23; + Range_Variable : Range_Type := 23; begin null; -- START end Prog;