From patchwork Mon Mar 6 15:31:55 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrew Burgess X-Patchwork-Id: 66033 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 176813853567 for ; Mon, 6 Mar 2023 15:32:46 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 176813853567 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1678116766; bh=6s+kgrU59Xm9Es1+bJ75lFLErd+KHsOQyJSxmH5nKcg=; 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=TJRER8wwgqfwkTohsL8BvjyiHghBd8LyPGw2LqqEQZ2NrkScYgbLfWAJ1a/eYFCyH 8Y4byvSCW4ea2MEMLqPFavgeNDPQzBm7KZtteLcQmG4TrTQw3vk3sSN2zaOqMCvcbg HE07Ngt8gTBp7imZ5ceuSr1P9knsDQ11fDpjdH7A= X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id 60E9238582A3 for ; Mon, 6 Mar 2023 15:32:08 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 60E9238582A3 Received: from mail-ed1-f71.google.com (mail-ed1-f71.google.com [209.85.208.71]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-355-i_ldF0E7N8-nIrQUlDLpWg-1; Mon, 06 Mar 2023 10:32:06 -0500 X-MC-Unique: i_ldF0E7N8-nIrQUlDLpWg-1 Received: by mail-ed1-f71.google.com with SMTP id ec11-20020a0564020d4b00b004e2cb85c8bcso5305312edb.16 for ; Mon, 06 Mar 2023 07:32:06 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1678116725; 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=6s+kgrU59Xm9Es1+bJ75lFLErd+KHsOQyJSxmH5nKcg=; b=3q7juUOZZYspH+71R94CTKgPejGnXD/mObJowX4884BoqrtfGXjujhGnz2xbZ45F0Z 0I33ix3Wdfn6Tvaa24zdTcMiYr4RD3Cb5G/g7n71CqFVyH0PDn4Wvhg6qK7AuHpNQ8qL yoALyeJPCrXbEVABHfWtwlOWY/+/f+kW5adUD+DdRSZXMXbqHC2JIumkiCYPl8V6+2oQ AYhB0dEkcMtPE3D1g0CWZvlo0vS5ZCQ5soziqi4bfmdeYdSu4gGPg+chEUkETStVcXqy eDS8Lf+Xa7VURse32D6aGy6x9tvS4DgI04x+mNyM2aQ6JPoka9iz2vhXxUjdUVd9ynVV 74eg== X-Gm-Message-State: AO0yUKW+fFyMEE5nZZDZ9CAppSrSYzdYI7+sZc7PEXmq7CHbCdarFs4u cW1he8PVcrg7akHMDRudkPq834iGypprvNUwxWS/6Y0+3adQxP8Pxy7NMfAR4QbxHHrG/VVG1XX jDHOAJj2EM4JGKP5borKSaSb7e8urW5BEaLhmwoQnx3cwqiEZQL8CzVTCZxUDmVGlH8WNh4RXI0 wrGHpMbQ== X-Received: by 2002:a17:907:1045:b0:8a6:93a4:c892 with SMTP id oy5-20020a170907104500b008a693a4c892mr11089330ejb.44.1678116725060; Mon, 06 Mar 2023 07:32:05 -0800 (PST) X-Google-Smtp-Source: AK7set9fi4OvsoTzFLyfOwSpSc48ZmjzWvcEorU6pi17wo0802tE2Ek+zent5wFBOpubCHaPJ+DLew== X-Received: by 2002:a17:907:1045:b0:8a6:93a4:c892 with SMTP id oy5-20020a170907104500b008a693a4c892mr11089318ejb.44.1678116724689; Mon, 06 Mar 2023 07:32:04 -0800 (PST) Received: from localhost (95.72.115.87.dyn.plus.net. [87.115.72.95]) by smtp.gmail.com with ESMTPSA id u2-20020a50d502000000b004c0057b478bsm5339363edi.34.2023.03.06.07.32.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 06 Mar 2023 07:32:04 -0800 (PST) To: gdb-patches@sourceware.org Cc: Andrew Burgess Subject: [PATCHv2 3/5] gdb/gdbarch: split postdefault setup from invalid check in gdbarch.py Date: Mon, 6 Mar 2023 15:31:55 +0000 Message-Id: <06694cb90bbc2a7b8acc8ecc262d28ee3a565331.1678116328.git.aburgess@redhat.com> X-Mailer: git-send-email 2.25.4 In-Reply-To: References: MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-11.7 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, 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: Andrew Burgess via Gdb-patches From: Andrew Burgess Reply-To: Andrew Burgess Errors-To: gdb-patches-bounces+patchwork=sourceware.org@sourceware.org Sender: "Gdb-patches" Restructure how gdbarch.py generates the verify_gdbarch function. Previously the postdefault handling was bundled together with the validation. This means that a field can't have both a postdefault, and set its invalid attribute to a string. This doesn't seem reasonable to me, I see no reason why a field can't have both a postdefault (used when the tdep doesn't set the field), and an invalid expression, which can be used to validate the value that a tdep might set. In this commit I restructure the verify_gdbarch generation code to allow the above, there is no change in the actual generated code in this commit, that will come in later commit. I did end up having to remove the "invalid" attribute (where the attribute was set to True) from a number of fields in this commit. This invalid attribute was never having an effect as these components all have a postdefault. Consider; the "postdefault" is applied if the field still has its initial value, while an "invalid" attribute set to True means error if the field still has its default value. But the field never will have its default value, it will always have its postdefault value. --- gdb/gdbarch.py | 38 ++++++++++++++++++++++--------------- gdb/gdbarch_components.py | 40 +++++++++++++++++---------------------- 2 files changed, 40 insertions(+), 38 deletions(-) diff --git a/gdb/gdbarch.py b/gdb/gdbarch.py index 93b1e8bf84e..806aee26831 100755 --- a/gdb/gdbarch.py +++ b/gdb/gdbarch.py @@ -203,35 +203,43 @@ with open("gdbarch.c", "w") as f: file=f, ) for c in filter(not_info, components): + # An opportunity to write in the 'postdefault' value. We + # change field's value to the postdefault if its current value + # is not different to the initial value of the field. + if c.postdefault is not None: + init_value = c.predefault or "0" + print(f" if (gdbarch->{c.name} == {init_value})", file=f) + print(f" gdbarch->{c.name} = {c.postdefault};", file=f) + + # Now validate the value. if c.invalid is False: print(f" /* Skip verify of {c.name}, invalid_p == 0 */", file=f) elif c.predicate: print(f" /* Skip verify of {c.name}, has predicate. */", file=f) - elif isinstance(c.invalid, str) and c.postdefault is not None: - print(f" if ({c.invalid})", file=f) - print(f" gdbarch->{c.name} = {c.postdefault};", file=f) - elif c.predefault is not None and c.postdefault is not None: - print(f" if (gdbarch->{c.name} == {c.predefault})", file=f) - print(f" gdbarch->{c.name} = {c.postdefault};", file=f) - elif c.postdefault is not None: - print(f" if (gdbarch->{c.name} == 0)", file=f) - print(f" gdbarch->{c.name} = {c.postdefault};", file=f) + elif c.invalid is None: + # No validation has been requested for this component. + pass elif isinstance(c.invalid, str): print(f" if ({c.invalid})", file=f) print(f""" log.puts ("\\n\\t{c.name}");""", file=f) - elif c.predefault is not None: - print(f" if (gdbarch->{c.name} == {c.predefault})", file=f) - print(f""" log.puts ("\\n\\t{c.name}");""", file=f) elif c.invalid is True: - print(f" if (gdbarch->{c.name} == 0)", file=f) - print(f""" log.puts ("\\n\\t{c.name}");""", file=f) + if c.postdefault is not None: + # This component has its 'invalid' field set to True, but + # also has a postdefault. This makes no sense, the + # postdefault will have been applied above, so this field + # will not have a zero value. + raise Exception(f"component {c.name} has postdefault and invalid set to True") + else: + init_value = c.predefault or "0" + print(f" if (gdbarch->{c.name} == {init_value})", file=f) + print(f""" log.puts ("\\n\\t{c.name}");""", file=f) else: # We should not allow ourselves to simply do nothing here # because no other case applies. If we end up here then # either the input data needs adjusting so one of the # above cases matches, or we need additional cases adding # here. - raise Exception("unhandled case when generating gdbarch validation") + raise Exception(f"unhandled case when generating gdbarch validation: {c.name}") print(" if (!log.empty ())", file=f) print( """ internal_error (_("verify_gdbarch: the following are invalid ...%s"),""", diff --git a/gdb/gdbarch_components.py b/gdb/gdbarch_components.py index d3dfcfc806f..1f217123216 100644 --- a/gdb/gdbarch_components.py +++ b/gdb/gdbarch_components.py @@ -63,34 +63,28 @@ # * "predefault", "postdefault", and "invalid" - These are used for # the initialization and verification steps: # -# A gdbarch is zero-initialized. Then, if a field has a pre-default, -# the field is set to that value. After initialization is complete -# (that is, after the tdep code has a chance to change the settings), -# the post-initialization step is done. +# A gdbarch is zero-initialized. Then, if a field has a "predefault", +# the field is set to that value. This becomes the field's initial +# value. # -# There is a generic algorithm to generate a "validation function" for -# all fields. If the field has an "invalid" attribute with a string -# value, then this string is the expression (note that a string-valued -# "invalid" and "predicate" are mutually exclusive; and the case where -# invalid is True means to ignore this field and instead use the -# default checking that is about to be described). Otherwise, if -# there is a "predefault", then the field is valid if it differs from -# the predefault. Otherwise, the check is done against 0 (really NULL -# for function pointers, but same idea). -# -# In post-initialization / validation, there are several cases. +# After initialization is complete (that is, after the tdep code has a +# chance to change the settings), the post-initialization step is +# done. # -# * If "invalid" is False, or if the field specifies "predicate", -# validation is skipped. Otherwise, a validation step is emitted. +# If the field still has its initial value (see above), and the field +# has a "postdefault", then the field is set to this value. # -# * Otherwise, the validity is checked using the usual validation -# function (see above). If the field is considered valid, nothing is -# done. +# After the possible "postdefault" assignment, validation is +# performed for fields that don't have a "predicate". # -# * Otherwise, the field's value is invalid. If there is a -# "postdefault", then the field is assigned that value. +# If the field has an "invalid" attribute with a string value, then +# this string is the expression that should evaluate to true when the +# field is invalid. # -# * Otherwise, the gdbarch will fail validation and gdb will crash. +# Otherwise, if "invalid" is True, then the generic validation +# function is used: the field is considered invalid it still contains +# its default value. This validation is what is used within the _p +# predicate function if the field has "predicate" set to True. # # Function and Method share: #