From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1914) id 2F0163815FE9; Mon, 30 May 2022 08:31:13 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 2F0163815FE9 MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Pierre-Marie de Rodat To: gcc-cvs@gcc.gnu.org Subject: [gcc r13-841] [Ada] Deconstruct deferred references X-Act-Checkin: gcc X-Git-Author: Piotr Trojanek X-Git-Refname: refs/heads/master X-Git-Oldrev: 6a91be29578fa466376cd482d3abed5eb20685b4 X-Git-Newrev: b341b8130f80c9acec384e7acc98283bccd349d2 Message-Id: <20220530083113.2F0163815FE9@sourceware.org> Date: Mon, 30 May 2022 08:31:13 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 30 May 2022 08:31:13 -0000 https://gcc.gnu.org/g:b341b8130f80c9acec384e7acc98283bccd349d2 commit r13-841-gb341b8130f80c9acec384e7acc98283bccd349d2 Author: Piotr Trojanek Date: Tue Apr 26 15:21:00 2022 +0200 [Ada] Deconstruct deferred references While cleaning up and modifying code for unreferenced warnings we removed all calls to Defer_Reference, which was the only routine that populated the Deferred_References table. Consequently, all the code related to this table became dead. gcc/ada/ * lib-xref.ads (Deferred_Reference_Entry, Defer_Reference, Process_Deferred_References, Has_Deferred_Reference): Remove client API. * lib-xref.adb (Deferred_References, Defer_Reference, Has_Deferred_Reference, Process_Deferred_References): Remove implementation. * frontend.adb, sem_ch11.adb, sem_ch5.adb, sem_res.adb, sem_util.adb, sem_warn.adb: Remove uses of Deferred_References. Diff: --- gcc/ada/frontend.adb | 2 -- gcc/ada/lib-xref.adb | 65 ---------------------------------------------------- gcc/ada/lib-xref.ads | 34 --------------------------- gcc/ada/sem_ch11.adb | 3 +-- gcc/ada/sem_ch5.adb | 11 +-------- gcc/ada/sem_res.adb | 16 ------------- gcc/ada/sem_util.adb | 4 ++-- gcc/ada/sem_warn.adb | 7 ------ 8 files changed, 4 insertions(+), 138 deletions(-) diff --git a/gcc/ada/frontend.adb b/gcc/ada/frontend.adb index c60234dc11d..12c91b11d9a 100644 --- a/gcc/ada/frontend.adb +++ b/gcc/ada/frontend.adb @@ -38,7 +38,6 @@ with Ghost; use Ghost; with Inline; use Inline; with Lib; use Lib; with Lib.Load; use Lib.Load; -with Lib.Xref; with Live; use Live; with Namet; use Namet; with Nlists; use Nlists; @@ -481,7 +480,6 @@ begin -- Output waiting warning messages - Lib.Xref.Process_Deferred_References; Sem_Warn.Output_Non_Modified_In_Out_Warnings; Sem_Warn.Output_Unreferenced_Messages; Sem_Warn.Check_Unused_Withs; diff --git a/gcc/ada/lib-xref.adb b/gcc/ada/lib-xref.adb index 919e41fd2c2..a4ff69a723f 100644 --- a/gcc/ada/lib-xref.adb +++ b/gcc/ada/lib-xref.adb @@ -57,14 +57,6 @@ package body Lib.Xref is -- Declarations -- ------------------ - package Deferred_References is new Table.Table ( - Table_Component_Type => Deferred_Reference_Entry, - Table_Index_Type => Int, - Table_Low_Bound => 0, - Table_Initial => 512, - Table_Increment => 200, - Table_Name => "Name_Deferred_References"); - -- The Xref table is used to record references. The Loc field is set -- to No_Location for a definition entry. @@ -211,21 +203,6 @@ package body Lib.Xref is end if; end Add_Entry; - --------------------- - -- Defer_Reference -- - --------------------- - - procedure Defer_Reference (Deferred_Reference : Deferred_Reference_Entry) is - begin - -- If Get_Ignore_Errors, then we are in Preanalyze_Without_Errors, and - -- we should not record cross references, because that will cause - -- duplicates when we call Analyze. - - if not Get_Ignore_Errors then - Deferred_References.Append (Deferred_Reference); - end if; - end Defer_Reference; - ----------- -- Equal -- ----------- @@ -1291,21 +1268,6 @@ package body Lib.Xref is return E; end Get_Key; - ---------------------------- - -- Has_Deferred_Reference -- - ---------------------------- - - function Has_Deferred_Reference (Ent : Entity_Id) return Boolean is - begin - for J in Deferred_References.First .. Deferred_References.Last loop - if Deferred_References.Table (J).E = Ent then - return True; - end if; - end loop; - - return False; - end Has_Deferred_Reference; - ---------- -- Hash -- ---------- @@ -2753,33 +2715,6 @@ package body Lib.Xref is end Output_Refs; end Output_References; - --------------------------------- - -- Process_Deferred_References -- - --------------------------------- - - procedure Process_Deferred_References is - begin - for J in Deferred_References.First .. Deferred_References.Last loop - declare - D : Deferred_Reference_Entry renames Deferred_References.Table (J); - - begin - case Known_To_Be_Assigned (D.N) is - when True => - Generate_Reference (D.E, D.N, 'm'); - - when False => - Generate_Reference (D.E, D.N, 'r'); - - end case; - end; - end loop; - - -- Clear processed entries from table - - Deferred_References.Init; - end Process_Deferred_References; - -- Start of elaboration for Lib.Xref begin diff --git a/gcc/ada/lib-xref.ads b/gcc/ada/lib-xref.ads index 729acd3a90d..977446ad0e4 100644 --- a/gcc/ada/lib-xref.ads +++ b/gcc/ada/lib-xref.ads @@ -578,40 +578,6 @@ package Lib.Xref is -- Export at line 4, that its body is exported to C, and that the link name -- as given in the pragma is "here". - ------------------------- - -- Deferred_References -- - ------------------------- - - -- Normally we generate references as we go along, but as discussed in - -- Sem_Util.Is_LHS, and Sem_Ch8.Find_Direct_Name/Find_Selected_Component, - -- we have one case where that is tricky, which is when we have something - -- like X.A := 3, where we don't know until we know the type of X whether - -- this is a reference (if X is an access type, so what we really have is - -- X.all.A := 3) or a modification, where X is not an access type. - - -- What we do in such cases is to gather nodes, where we would have liked - -- to call Generate_Reference but we couldn't because we didn't know enough - -- into a table, then we deal with generating references later on when we - -- have sufficient information to do it right. - - type Deferred_Reference_Entry is record - E : Entity_Id; - N : Node_Id; - end record; - -- One entry, E, N are as required for Generate_Reference call - - procedure Defer_Reference (Deferred_Reference : Deferred_Reference_Entry); - -- Add one entry to the deferred reference table - - procedure Process_Deferred_References; - -- This procedure is called from Frontend to process these table entries. - -- It is also called from Sem_Warn. - - function Has_Deferred_Reference (Ent : Entity_Id) return Boolean; - -- Determine whether arbitrary entity Ent has a pending reference in order - -- to suppress premature warnings about useless assignments. See comments - -- in Analyze_Assignment in sem_ch5.adb. - ----------------------------- -- SPARK Xrefs Information -- ----------------------------- diff --git a/gcc/ada/sem_ch11.adb b/gcc/ada/sem_ch11.adb index 034d4cd9e92..a15fd09f6c7 100644 --- a/gcc/ada/sem_ch11.adb +++ b/gcc/ada/sem_ch11.adb @@ -432,8 +432,7 @@ package body Sem_Ch11 is -- If the current scope is a subprogram, entry or task body or declare -- block then this is the right place to check for hanging useless -- assignments from the statement sequence. Skip this in the body of a - -- postcondition, since in that case there are no source references, and - -- we need to preserve deferred references from the enclosing scope. + -- postcondition, since in that case there are no source references. if (Is_Subprogram_Or_Entry (Current_Scope) and then Chars (Current_Scope) /= Name_uPostconditions) diff --git a/gcc/ada/sem_ch5.adb b/gcc/ada/sem_ch5.adb index e6d34c30c0b..66315ad385e 100644 --- a/gcc/ada/sem_ch5.adb +++ b/gcc/ada/sem_ch5.adb @@ -1207,21 +1207,12 @@ package body Sem_Ch5 is -- There may have been a previous reference to a component of -- the variable, which in general removes the Last_Assignment -- field of the variable to indicate a relevant use of the - -- previous assignment. However, if the assignment is to a - -- subcomponent the reference may not have registered, because - -- it is not possible to determine whether the context is an - -- assignment. In those cases we generate a Deferred_Reference, - -- to be used at the end of compilation to generate the right - -- kind of reference, and we suppress a potential warning for - -- a useless assignment, which might be premature. This may - -- lose a warning in rare cases, but seems preferable to a - -- misleading warning. + -- previous assignment. if Warn_On_Modified_Unread and then Is_Assignable (Ent) and then Comes_From_Source (N) and then In_Extended_Main_Source_Unit (Ent) - and then not Has_Deferred_Reference (Ent) and then not Has_Target_Names (N) then Warn_On_Useless_Assignment (Ent, N); diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb index 930980eafed..4ffb64c5ec7 100644 --- a/gcc/ada/sem_res.adb +++ b/gcc/ada/sem_res.adb @@ -11211,22 +11211,6 @@ package body Sem_Res is else T := Etype (P); - - -- If the prefix is an entity it may have a deferred reference set - -- during analysis of the selected component. After resolution we - -- can transform it into a proper reference. This prevents spurious - -- warnings on useless assignments when the same selected component - -- is the actual for an out parameter in a subsequent call. - - if Is_Entity_Name (P) - and then Has_Deferred_Reference (Entity (P)) - then - if Known_To_Be_Assigned (N) then - Generate_Reference (Entity (P), P, 'm'); - else - Generate_Reference (Entity (P), P, 'r'); - end if; - end if; end if; -- Set flag for expander if discriminant check required on a component diff --git a/gcc/ada/sem_util.adb b/gcc/ada/sem_util.adb index 0a809154296..1d527bc02e6 100644 --- a/gcc/ada/sem_util.adb +++ b/gcc/ada/sem_util.adb @@ -9309,8 +9309,8 @@ package body Sem_Util is return; -- An actual that is the prefix in a prefixed call may have - -- been rewritten in the call, after the deferred reference - -- was collected. Check if sloc and kinds and names match. + -- been rewritten in the call. Check if sloc and kinds and + -- names match. elsif Sloc (Actual) = Sloc (N) and then Nkind (Actual) = N_Identifier diff --git a/gcc/ada/sem_warn.adb b/gcc/ada/sem_warn.adb index c8d00a5ff5b..1bc248ce00e 100644 --- a/gcc/ada/sem_warn.adb +++ b/gcc/ada/sem_warn.adb @@ -31,7 +31,6 @@ with Einfo.Utils; use Einfo.Utils; with Errout; use Errout; with Exp_Code; use Exp_Code; with Lib; use Lib; -with Lib.Xref; use Lib.Xref; with Namet; use Namet; with Nlists; use Nlists; with Opt; use Opt; @@ -1132,8 +1131,6 @@ package body Sem_Warn is -- Start of processing for Check_References begin - Process_Deferred_References; - -- No messages if warnings are suppressed, or if we have detected any -- real errors so far (this last check avoids junk messages resulting -- from errors, e.g. a subunit that is not loaded). @@ -2762,8 +2759,6 @@ package body Sem_Warn is return; end if; - Process_Deferred_References; - -- Flag any unused with clauses. For a subunit, check only the units -- in its context, not those of the parent, which may be needed by other -- subunits. We will get the full warnings when we compile the parent, @@ -4703,8 +4698,6 @@ package body Sem_Warn is Ent : Entity_Id; begin - Process_Deferred_References; - if Warn_On_Modified_Unread and then In_Extended_Main_Source_Unit (E) then