From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-il1-x12a.google.com (mail-il1-x12a.google.com [IPv6:2607:f8b0:4864:20::12a]) by sourceware.org (Postfix) with ESMTPS id BD4BE3858C5E for ; Thu, 9 Mar 2023 17:51:15 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org BD4BE3858C5E Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=adacore.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=adacore.com Received: by mail-il1-x12a.google.com with SMTP id x10so1432611ill.12 for ; Thu, 09 Mar 2023 09:51:15 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=adacore.com; s=google; t=1678384275; h=to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=LTGjMp5kN921YvHpXcrby47SxjTXFBjZFKF+FQMeZLw=; b=fNGUOmMT3+nsv9myobaAgFEZpqE1msbcQ1OJkq8u5BEx6P2lzDBZoEBejaay41Fa/Q TRlGTp1QzGUOfILQ3oqBji14DDjEvIkCK7FMEKHfYlQgsxMiplGaA7ShlqHs311Tx1Wk bO2QDwiVqcRihCvixr1mv9HCGQMQi0Xv8G3/ozlDJqjeBX6lIcM6xK4KFpVyTP0O1i47 RXTDZT6qvptHvyElGWsmRf3lJdvGeu2nEIV3euK55WzLa/G81duuD3v5WDaCqQSTbnDD cWJsyh9tk7uxChsLz/XnhmuvEylV+eVGvAKKFB7N7QREyqjz6PWScj+ohth4CImeKnqV Gcog== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1678384275; h=to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=LTGjMp5kN921YvHpXcrby47SxjTXFBjZFKF+FQMeZLw=; b=vyIGwGlddMeK27cieIvKW6Eiw3K/HSTyyyMp5+gXVuJrGdeRjPXebojIp1jmPsEfT4 voFiRhrAel9g/seAnZAYks2sTlY+pFeHeo1eI/bjCid/VEoCoZ9/LjES6ZSkf6o0s1uG EqhI0jr1zFUVUUuDG11eQEXFY5v2cPsnsr8+XdC444HXkPwx4LbGN/jFCZmQXvqMCl8h /yf3y17U1CMB07Pp4vTnkWspPVLR9H374ZjrEoA+p+lfkIvUIGigIYe7p9Bbr4+NTfIx uAQUL6tBjX9D3refwwHTNim7ie/bJcWh4fIGj0eM3f0mcrHdBqp0LLO6b9DFnlZYDPl6 QwnA== X-Gm-Message-State: AO0yUKUcWOcz5dq1DJWHlTez6PxsF+UdOSei0BCmTBGaEYeU4gbVz9DL LvPcrKBkaHajL1xqq/F1yljkR+ky0kTKqjz3WPY= X-Google-Smtp-Source: AK7set+8j8Fn14jYF+fiuKNjzElqN5gvXgNUsGTxTeiA05sZ5v8z9l0fWAkiv/rjLfBTUOJQMH/omQ== X-Received: by 2002:a05:6e02:b4d:b0:314:e6f:f2d1 with SMTP id f13-20020a056e020b4d00b003140e6ff2d1mr16745131ilu.31.1678384274918; Thu, 09 Mar 2023 09:51:14 -0800 (PST) Received: from localhost.localdomain (71-211-185-113.hlrn.qwest.net. [71.211.185.113]) by smtp.gmail.com with ESMTPSA id j5-20020a056e020ee500b00315785bfabfsm5572276ilk.47.2023.03.09.09.51.14 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 09 Mar 2023 09:51:14 -0800 (PST) From: Tom Tromey Date: Thu, 09 Mar 2023 10:50:55 -0700 Subject: [PATCH 1/3] Add frame parameter to resolve_dynamic_type MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Message-Id: <20230309-submit-static-link-fix-v1-1-23af27781fd2@adacore.com> References: <20230309-submit-static-link-fix-v1-0-23af27781fd2@adacore.com> In-Reply-To: <20230309-submit-static-link-fix-v1-0-23af27781fd2@adacore.com> To: gdb-patches@sourceware.org X-Mailer: b4 0.12.1 X-Spam-Status: No, score=-11.6 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,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 List-Id: This adds a frame parameter to resolve_dynamic_type and arranges for it to be passed through the call tree and, in particular, to all calls to dwarf2_evaluate_property. Nothing passes this parameter yet, so this patch should have no visible effect. A 'const frame_info_ptr *' is used here to avoid including frame.h from gdbtypes.h. --- gdb/gdbtypes.c | 71 +++++++++++++++++++++++++++++++++++----------------------- gdb/gdbtypes.h | 6 ++++- 2 files changed, 48 insertions(+), 29 deletions(-) diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index f22ba44a538..37203b5a436 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -2190,7 +2190,8 @@ is_dynamic_type (struct type *type) } static struct type *resolve_dynamic_type_internal - (struct type *type, struct property_addr_info *addr_stack, int top_level); + (struct type *type, struct property_addr_info *addr_stack, + const frame_info_ptr &frame, int top_level); /* Given a dynamic range type (dyn_range_type) and a stack of struct property_addr_info elements, return a static version @@ -2211,6 +2212,7 @@ static struct type *resolve_dynamic_type_internal static struct type * resolve_dynamic_range (struct type *dyn_range_type, struct property_addr_info *addr_stack, + const frame_info_ptr &frame, int rank, bool resolve_p = true) { CORE_ADDR value; @@ -2221,14 +2223,14 @@ resolve_dynamic_range (struct type *dyn_range_type, gdb_assert (rank >= 0); const struct dynamic_prop *prop = &dyn_range_type->bounds ()->low; - if (resolve_p && dwarf2_evaluate_property (prop, NULL, addr_stack, &value, + if (resolve_p && dwarf2_evaluate_property (prop, frame, addr_stack, &value, { (CORE_ADDR) rank })) low_bound.set_const_val (value); else low_bound.set_undefined (); prop = &dyn_range_type->bounds ()->high; - if (resolve_p && dwarf2_evaluate_property (prop, NULL, addr_stack, &value, + if (resolve_p && dwarf2_evaluate_property (prop, frame, addr_stack, &value, { (CORE_ADDR) rank })) { high_bound.set_const_val (value); @@ -2242,7 +2244,7 @@ resolve_dynamic_range (struct type *dyn_range_type, bool byte_stride_p = dyn_range_type->bounds ()->flag_is_byte_stride; prop = &dyn_range_type->bounds ()->stride; - if (resolve_p && dwarf2_evaluate_property (prop, NULL, addr_stack, &value, + if (resolve_p && dwarf2_evaluate_property (prop, frame, addr_stack, &value, { (CORE_ADDR) rank })) { stride.set_const_val (value); @@ -2265,7 +2267,7 @@ resolve_dynamic_range (struct type *dyn_range_type, static_target_type = resolve_dynamic_type_internal (dyn_range_type->target_type (), - addr_stack, 0); + addr_stack, frame, 0); LONGEST bias = dyn_range_type->bounds ()->bias; static_range_type = create_range_type_with_stride (copy_type (dyn_range_type), static_target_type, @@ -2296,6 +2298,7 @@ resolve_dynamic_range (struct type *dyn_range_type, static struct type * resolve_dynamic_array_or_string_1 (struct type *type, struct property_addr_info *addr_stack, + const frame_info_ptr &frame, int rank, bool resolve_p) { CORE_ADDR value; @@ -2325,7 +2328,7 @@ resolve_dynamic_array_or_string_1 (struct type *type, dimension of the array. */ prop = TYPE_ALLOCATED_PROP (type); if (prop != NULL && resolve_p - && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + && dwarf2_evaluate_property (prop, frame, addr_stack, &value)) { prop->set_const_val (value); if (value == 0) @@ -2334,7 +2337,7 @@ resolve_dynamic_array_or_string_1 (struct type *type, prop = TYPE_ASSOCIATED_PROP (type); if (prop != NULL && resolve_p - && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + && dwarf2_evaluate_property (prop, frame, addr_stack, &value)) { prop->set_const_val (value); if (value == 0) @@ -2343,14 +2346,15 @@ resolve_dynamic_array_or_string_1 (struct type *type, range_type = check_typedef (type->index_type ()); range_type - = resolve_dynamic_range (range_type, addr_stack, rank, resolve_p); + = resolve_dynamic_range (range_type, addr_stack, frame, rank, resolve_p); ary_dim = check_typedef (type->target_type ()); if (ary_dim != NULL && ary_dim->code () == TYPE_CODE_ARRAY) { ary_dim = copy_type (ary_dim); elt_type = resolve_dynamic_array_or_string_1 (ary_dim, addr_stack, - rank - 1, resolve_p); + frame, rank - 1, + resolve_p); } else elt_type = type->target_type (); @@ -2358,7 +2362,7 @@ resolve_dynamic_array_or_string_1 (struct type *type, prop = type->dyn_prop (DYN_PROP_BYTE_STRIDE); if (prop != NULL && resolve_p) { - if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + if (dwarf2_evaluate_property (prop, frame, addr_stack, &value)) { type->remove_dyn_prop (DYN_PROP_BYTE_STRIDE); bit_stride = (unsigned int) (value * 8); @@ -2385,7 +2389,8 @@ resolve_dynamic_array_or_string_1 (struct type *type, static struct type * resolve_dynamic_array_or_string (struct type *type, - struct property_addr_info *addr_stack) + struct property_addr_info *addr_stack, + const frame_info_ptr &frame) { CORE_ADDR value; int rank = 0; @@ -2399,7 +2404,7 @@ resolve_dynamic_array_or_string (struct type *type, /* Resolve the rank property to get rank value. */ struct dynamic_prop *prop = TYPE_RANK_PROP (type); - if (dwarf2_evaluate_property (prop, nullptr, addr_stack, &value)) + if (dwarf2_evaluate_property (prop, frame, addr_stack, &value)) { prop->set_const_val (value); rank = value; @@ -2467,7 +2472,8 @@ resolve_dynamic_array_or_string (struct type *type, reduce the rank by 1 here. */ --rank; - return resolve_dynamic_array_or_string_1 (type, addr_stack, rank, true); + return resolve_dynamic_array_or_string_1 (type, addr_stack, frame, rank, + true); } /* Resolve dynamic bounds of members of the union TYPE to static @@ -2476,7 +2482,8 @@ resolve_dynamic_array_or_string (struct type *type, static struct type * resolve_dynamic_union (struct type *type, - struct property_addr_info *addr_stack) + struct property_addr_info *addr_stack, + const frame_info_ptr &frame) { struct type *resolved_type; int i; @@ -2500,7 +2507,7 @@ resolve_dynamic_union (struct type *type, continue; t = resolve_dynamic_type_internal (resolved_type->field (i).type (), - addr_stack, 0); + addr_stack, frame, 0); resolved_type->field (i).set_type (t); struct type *real_type = check_typedef (t); @@ -2675,7 +2682,8 @@ compute_variant_fields (struct type *type, static struct type * resolve_dynamic_struct (struct type *type, - struct property_addr_info *addr_stack) + struct property_addr_info *addr_stack, + const frame_info_ptr &frame) { struct type *resolved_type; int i; @@ -2725,7 +2733,7 @@ resolve_dynamic_struct (struct type *type, prop.set_locexpr (&baton); CORE_ADDR addr; - if (dwarf2_evaluate_property (&prop, nullptr, addr_stack, &addr, + if (dwarf2_evaluate_property (&prop, frame, addr_stack, &addr, {addr_stack->addr})) resolved_type->field (i).set_loc_bitpos (TARGET_CHAR_BIT * (addr - addr_stack->addr)); @@ -2752,7 +2760,7 @@ resolve_dynamic_struct (struct type *type, resolved_type->field (i).set_type (resolve_dynamic_type_internal (resolved_type->field (i).type (), - &pinfo, 0)); + &pinfo, frame, 0)); gdb_assert (resolved_type->field (i).loc_kind () == FIELD_LOC_KIND_BITPOS); @@ -2797,6 +2805,7 @@ resolve_dynamic_struct (struct type *type, static struct type * resolve_dynamic_type_internal (struct type *type, struct property_addr_info *addr_stack, + const frame_info_ptr &frame, int top_level) { struct type *real_type = check_typedef (type); @@ -2810,7 +2819,7 @@ resolve_dynamic_type_internal (struct type *type, gdb::optional type_length; prop = TYPE_DYNAMIC_LENGTH (type); if (prop != NULL - && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + && dwarf2_evaluate_property (prop, frame, addr_stack, &value)) type_length = value; if (type->code () == TYPE_CODE_TYPEDEF) @@ -2818,7 +2827,7 @@ resolve_dynamic_type_internal (struct type *type, resolved_type = copy_type (type); resolved_type->set_target_type (resolve_dynamic_type_internal (type->target_type (), addr_stack, - top_level)); + frame, top_level)); } else { @@ -2843,7 +2852,7 @@ resolve_dynamic_type_internal (struct type *type, resolved_type = copy_type (type); resolved_type->set_target_type (resolve_dynamic_type_internal (type->target_type (), - &pinfo, top_level)); + &pinfo, frame, top_level)); break; } @@ -2851,7 +2860,8 @@ resolve_dynamic_type_internal (struct type *type, /* Strings are very much like an array of characters, and can be treated as one here. */ case TYPE_CODE_ARRAY: - resolved_type = resolve_dynamic_array_or_string (type, addr_stack); + resolved_type = resolve_dynamic_array_or_string (type, addr_stack, + frame); break; case TYPE_CODE_RANGE: @@ -2860,15 +2870,15 @@ resolve_dynamic_type_internal (struct type *type, this rank value is not actually required for the resolution of the dynamic range, otherwise, we'd be resolving this range within the context of a dynamic array. */ - resolved_type = resolve_dynamic_range (type, addr_stack, 0); + resolved_type = resolve_dynamic_range (type, addr_stack, frame, 0); break; case TYPE_CODE_UNION: - resolved_type = resolve_dynamic_union (type, addr_stack); + resolved_type = resolve_dynamic_union (type, addr_stack, frame); break; case TYPE_CODE_STRUCT: - resolved_type = resolve_dynamic_struct (type, addr_stack); + resolved_type = resolve_dynamic_struct (type, addr_stack, frame); break; } } @@ -2885,7 +2895,7 @@ resolve_dynamic_type_internal (struct type *type, /* Resolve data_location attribute. */ prop = TYPE_DATA_LOCATION (resolved_type); if (prop != NULL - && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + && dwarf2_evaluate_property (prop, frame, addr_stack, &value)) { /* Start of Fortran hack. See comment in f-lang.h for what is going on here.*/ @@ -2905,12 +2915,17 @@ resolve_dynamic_type_internal (struct type *type, struct type * resolve_dynamic_type (struct type *type, gdb::array_view valaddr, - CORE_ADDR addr) + CORE_ADDR addr, + const frame_info_ptr *in_frame) { struct property_addr_info pinfo = {check_typedef (type), valaddr, addr, NULL}; - return resolve_dynamic_type_internal (type, &pinfo, 1); + frame_info_ptr frame; + if (in_frame != nullptr) + frame = *in_frame; + + return resolve_dynamic_type_internal (type, &pinfo, frame, 1); } /* See gdbtypes.h */ diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index c4889a4a05b..884cdc5bfb0 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -2419,6 +2419,10 @@ extern CORE_ADDR get_pointer_type_max (struct type *); If TYPE has no dynamic properties return TYPE; otherwise a new type with static properties is returned. + If FRAME is given, it is used when evaluating dynamic properties. + This can be important when a static link is seen. If not given, + the selected frame is used. + For an array type, if the element type is dynamic, then that will not be resolved. This is done because each individual element may have a different type when resolved (depending on the contents of @@ -2426,7 +2430,7 @@ extern CORE_ADDR get_pointer_type_max (struct type *); true for the return value of this function. */ extern struct type *resolve_dynamic_type (struct type *type, gdb::array_view valaddr, - CORE_ADDR addr); + CORE_ADDR addr, const frame_info_ptr *frame = nullptr); /* * Predicate if the type has dynamic values, which are not resolved yet. See the caveat in 'resolve_dynamic_type' to understand a scenario -- 2.39.1