From patchwork Sun Dec 8 18:29:29 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 36617 Received: (qmail 102852 invoked by alias); 8 Dec 2019 18:31:01 -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 101226 invoked by uid 89); 8 Dec 2019 18:30:19 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-21.0 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_HELO_PASS autolearn=ham version=3.3.1 spammy=remains X-HELO: gateway21.websitewelcome.com Received: from gateway21.websitewelcome.com (HELO gateway21.websitewelcome.com) (192.185.46.113) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sun, 08 Dec 2019 18:30:13 +0000 Received: from cm16.websitewelcome.com (cm16.websitewelcome.com [100.42.49.19]) by gateway21.websitewelcome.com (Postfix) with ESMTP id 4D635400C646E for ; Sun, 8 Dec 2019 12:30:06 -0600 (CST) Received: from box5379.bluehost.com ([162.241.216.53]) by cmsmtp with SMTP id e1JmiNElMOdBHe1JmiXADp; Sun, 08 Dec 2019 12:30:06 -0600 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=tromey.com; s=default; h=References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From: Sender:Reply-To:MIME-Version:Content-Type:Content-Transfer-Encoding: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=yM8jxYn30NZzfXc9eN0W/tMmqiep7dky9/ClbvPWAIs=; b=Lsij2YmBOaLSbVp0nndhTogL+x mntYKW21xfMR/glKYaClfXAjVWj9ezUmkoHH8GW/0RQ7CuqRr3xt3zdhwqEE+7EDlp0aZWsmkqfkY ise+ON1SKFH2gyG4Z0cBkXMIk; Received: from 75-166-123-50.hlrn.qwest.net ([75.166.123.50]:53622 helo=bapiya.Home) by box5379.bluehost.com with esmtpa (Exim 4.92) (envelope-from ) id 1ie1Jm-0045GG-4O; Sun, 08 Dec 2019 11:30:06 -0700 From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [PATCH 26/55] Convert Fortran printing to value-based API Date: Sun, 8 Dec 2019 11:29:29 -0700 Message-Id: <20191208182958.10181-27-tom@tromey.com> In-Reply-To: <20191208182958.10181-1-tom@tromey.com> References: <20191208182958.10181-1-tom@tromey.com> This finishes the conversion of the Fortran printing code to the value-based API. The body of f_val_print is copied into f_value_print_innner, and then modified as needed to use the value API. Note that not all calls must be updated. For example, f77_print_array remains "val-like", because it does not result in any calls to val_print (f77_print_array_1 calls common_val_print, which is nominally value-based). gdb/ChangeLog 2019-12-08 Tom Tromey * f-valprint.c (f_value_print_innner): Rewrite. Change-Id: I5b805076f203e25688d0954adedc00531175b0c5 --- gdb/ChangeLog | 4 ++ gdb/f-valprint.c | 146 ++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 148 insertions(+), 2 deletions(-) diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c index 9eccabbcd52..cd1977b05cf 100644 --- a/gdb/f-valprint.c +++ b/gdb/f-valprint.c @@ -376,8 +376,150 @@ void f_value_print_innner (struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options) { - f_val_print (value_type (val), value_embedded_offset (val), - value_address (val), stream, recurse, val, options); + struct type *type = check_typedef (value_type (val)); + struct gdbarch *gdbarch = get_type_arch (type); + int printed_field = 0; /* Number of fields printed. */ + struct type *elttype; + CORE_ADDR addr; + int index; + const gdb_byte *valaddr = value_contents_for_printing (val); + const CORE_ADDR address = value_address (val); + + switch (TYPE_CODE (type)) + { + case TYPE_CODE_STRING: + f77_get_dynamic_length_of_aggregate (type); + LA_PRINT_STRING (stream, builtin_type (gdbarch)->builtin_char, + valaddr, TYPE_LENGTH (type), NULL, 0, options); + break; + + case TYPE_CODE_ARRAY: + if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_CHAR) + { + fprintf_filtered (stream, "("); + f77_print_array (type, valaddr, 0, + address, stream, recurse, val, options); + fprintf_filtered (stream, ")"); + } + else + { + struct type *ch_type = TYPE_TARGET_TYPE (type); + + f77_get_dynamic_length_of_aggregate (type); + LA_PRINT_STRING (stream, ch_type, valaddr, + TYPE_LENGTH (type) / TYPE_LENGTH (ch_type), + NULL, 0, options); + } + break; + + case TYPE_CODE_PTR: + if (options->format && options->format != 's') + { + value_print_scalar_formatted (val, options, 0, stream); + break; + } + else + { + int want_space = 0; + + addr = unpack_pointer (type, valaddr); + elttype = check_typedef (TYPE_TARGET_TYPE (type)); + + if (TYPE_CODE (elttype) == TYPE_CODE_FUNC) + { + /* Try to print what function it points to. */ + print_function_pointer_address (options, gdbarch, addr, stream); + return; + } + + if (options->symbol_print) + want_space = print_address_demangle (options, gdbarch, addr, + stream, demangle); + else if (options->addressprint && options->format != 's') + { + fputs_filtered (paddress (gdbarch, addr), stream); + want_space = 1; + } + + /* For a pointer to char or unsigned char, also print the string + pointed to, unless pointer is null. */ + if (TYPE_LENGTH (elttype) == 1 + && TYPE_CODE (elttype) == TYPE_CODE_INT + && (options->format == 0 || options->format == 's') + && addr != 0) + { + if (want_space) + fputs_filtered (" ", stream); + val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1, + stream, options); + } + return; + } + break; + + case TYPE_CODE_INT: + if (options->format || options->output_format) + { + struct value_print_options opts = *options; + + opts.format = (options->format ? options->format + : options->output_format); + value_print_scalar_formatted (val, &opts, 0, stream); + } + else + value_print_scalar_formatted (val, options, 0, stream); + break; + + case TYPE_CODE_STRUCT: + case TYPE_CODE_UNION: + /* Starting from the Fortran 90 standard, Fortran supports derived + types. */ + fprintf_filtered (stream, "( "); + for (index = 0; index < TYPE_NFIELDS (type); index++) + { + struct value *field = value_field (val, index); + + struct type *field_type = check_typedef (TYPE_FIELD_TYPE (type, index)); + + + if (TYPE_CODE (field_type) != TYPE_CODE_FUNC) + { + const char *field_name; + + if (printed_field > 0) + fputs_filtered (", ", stream); + + field_name = TYPE_FIELD_NAME (type, index); + if (field_name != NULL) + { + fputs_filtered (field_name, stream); + fputs_filtered (" = ", stream); + } + + common_val_print (field, stream, recurse + 1, + options, current_language); + + ++printed_field; + } + } + fprintf_filtered (stream, " )"); + break; + + case TYPE_CODE_REF: + case TYPE_CODE_FUNC: + case TYPE_CODE_FLAGS: + case TYPE_CODE_FLT: + case TYPE_CODE_VOID: + case TYPE_CODE_ERROR: + case TYPE_CODE_RANGE: + case TYPE_CODE_UNDEF: + case TYPE_CODE_COMPLEX: + case TYPE_CODE_BOOL: + case TYPE_CODE_CHAR: + default: + generic_value_print (val, stream, recurse, options, &f_decorations); + break; + } } static void