From 0c61772a122cc888d0aafffbaa35d4c95cc7abcc Mon Sep 17 00:00:00 2001 From: Arnaud Charlet Date: Wed, 20 Apr 2016 12:40:48 +0200 Subject: [PATCH] [multiple changes] 2016-04-20 Vincent Celier * gnatcmd.adb: Do not invoke gprls when the invocation of "gnat ls" includes the switch -V. * clean.adb: "-gnatclean -P" now calls "gprclean --target=" * make.adb: "-gnatmake -P" now calls "gprbuild --target=" 2016-04-20 Hristian Kirtchev * sem_ch12.adb (Qualify_Type): Do not perform partial qualification when the immediate scope is a generic unit. From-SVN: r235260 --- gcc/ada/ChangeLog | 14 + gcc/ada/clean.adb | 57 ++-- gcc/ada/gnatcmd.adb | 603 ++++++++++++++++++++++++++++++++++++++++++- gcc/ada/make.adb | 55 ++-- gcc/ada/sem_ch12.adb | 2 +- 5 files changed, 686 insertions(+), 45 deletions(-) diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 21637a7662a..dca79d9cddd 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,17 @@ +2016-04-20 Vincent Celier + + * gnatcmd.adb: Do not invoke gprls when the invocation of "gnat + ls" includes the switch -V. + * clean.adb: "-gnatclean -P" now calls "gprclean + --target=" + * make.adb: "-gnatmake -P" now calls "gprbuild + --target=" + +2016-04-20 Hristian Kirtchev + + * sem_ch12.adb (Qualify_Type): Do not perform + partial qualification when the immediate scope is a generic unit. + 2016-04-20 Hristian Kirtchev * exp_unst.adb: Minor reformatting. diff --git a/gcc/ada/clean.adb b/gcc/ada/clean.adb index db9be956b6b..615cc48c594 100644 --- a/gcc/ada/clean.adb +++ b/gcc/ada/clean.adb @@ -1619,8 +1619,8 @@ package body Clean is procedure Parse_Cmd_Line is Last : constant Natural := Argument_Count; - Source_Index : Int := 0; Index : Positive; + Source_Index : Int := 0; procedure Check_Version_And_Help is new Check_Version_And_Help_G (Usage); @@ -1629,16 +1629,29 @@ package body Clean is Check_Version_And_Help ("GNATCLEAN", "2003"); - -- First, for native gnatclean, check for switch -P and, if found and - -- gprclean is available, silently invoke gprclean. + -- First, check for switch -P and, if found and gprclean is available, + -- silently invoke gprclean, with switch --target if not on a native + -- platform. - Find_Program_Name; + declare + Arg_Len : Positive := Argument_Count; + Call_Gprclean : Boolean := False; + Gprclean : String_Access := null; + Pos : Natural := 0; + Success : Boolean; + Target : String_Access := null; - if Name_Buffer (1 .. Name_Len) = "gnatclean" then - declare - Call_Gprclean : Boolean := False; + begin + Find_Program_Name; + + if Name_Len >= 9 + and then Name_Buffer (Name_Len - 8 .. Name_Len) = "gnatclean" + then + if Name_Len > 9 then + Target := new String'(Name_Buffer (1 .. Name_Len - 10)); + Arg_Len := Arg_Len + 1; + end if; - begin for J in 1 .. Argument_Count loop declare Arg : constant String := Argument (J); @@ -1653,16 +1666,20 @@ package body Clean is end loop; if Call_Gprclean then - declare - Gprclean : String_Access := - Locate_Exec_On_Path (Exec_Name => "gprclean"); - Args : Argument_List (1 .. Argument_Count); - Success : Boolean; + Gprclean := Locate_Exec_On_Path (Exec_Name => "gprclean"); + + if Gprclean /= null then + declare + Args : Argument_List (1 .. Arg_Len); + begin + if Target /= null then + Args (1) := new String'("--target=" & Target.all); + Pos := 1; + end if; - begin - if Gprclean /= null then for J in 1 .. Argument_Count loop - Args (J) := new String'(Argument (J)); + Pos := Pos + 1; + Args (Pos) := new String'(Argument (J)); end loop; Spawn (Gprclean.all, Args, Success); @@ -1672,11 +1689,11 @@ package body Clean is if Success then Exit_Program (E_Success); end if; - end if; - end; + end; + end if; end if; - end; - end if; + end if; + end; Index := 1; while Index <= Last loop diff --git a/gcc/ada/gnatcmd.adb b/gcc/ada/gnatcmd.adb index 0d36566b8e4..2432f89f8f4 100644 --- a/gcc/ada/gnatcmd.adb +++ b/gcc/ada/gnatcmd.adb @@ -23,19 +23,35 @@ -- -- ------------------------------------------------------------------------------ +with Csets; with Gnatvsn; +with Makeutl; use Makeutl; with Namet; use Namet; with Opt; use Opt; with Osint; use Osint; +with Output; use Output; +with Prj; use Prj; +with Prj.Env; +with Prj.Ext; use Prj.Ext; +with Prj.Pars; +with Prj.Tree; use Prj.Tree; +with Prj.Util; use Prj.Util; +with Sdefault; +with Sinput.P; +with Snames; use Snames; +with Stringt; with Switch; use Switch; with Table; with Targparm; use Targparm; +with Tempdir; +with Types; use Types; with Ada.Characters.Handling; use Ada.Characters.Handling; with Ada.Command_Line; use Ada.Command_Line; with Ada.Text_IO; use Ada.Text_IO; -with GNAT.OS_Lib; use GNAT.OS_Lib; +with GNAT.Directory_Operations; use GNAT.Directory_Operations; +with GNAT.OS_Lib; use GNAT.OS_Lib; procedure GNATCmd is Gprbuild : constant String := "gprbuild"; @@ -82,6 +98,25 @@ procedure GNATCmd is Pp => Pretty); -- Mapping of alternate commands to commands + Call_GPR_Tool : Boolean := False; + -- True when a GPR tool should be called, if available + + Project_Node_Tree : Project_Node_Tree_Ref; + Project_File : String_Access; + Project : Prj.Project_Id; + Current_Verbosity : Prj.Verbosity := Prj.Default; + Tool_Package_Name : Name_Id := No_Name; + + Project_Tree : constant Project_Tree_Ref := + new Project_Tree_Data (Is_Root_Tree => True); + -- The project tree + + All_Projects : Boolean := False; + + Temp_File_Name : Path_Name_Type := No_Path; + -- The name of the temporary text file to put a list of source/object + -- files to pass to a tool. + package First_Switches is new Table.Table (Table_Component_Type => String_Access, Table_Index_Type => Integer, @@ -222,16 +257,177 @@ procedure GNATCmd is Unixsws => null) ); + subtype SA is String_Access; + + Naming_String : constant SA := new String'("naming"); + Gnatls_String : constant SA := new String'("gnatls"); + + Packages_To_Check_By_Gnatls : constant String_List_Access := + new String_List'((Naming_String, Gnatls_String)); + + Packages_To_Check : String_List_Access := Prj.All_Packages; + ----------------------- -- Local Subprograms -- ----------------------- + procedure Check_Files; + -- For GNAT LIST -V, check if a project file is specified, without any file + -- arguments and without a switch -files=. If it is the case, invoke the + -- GNAT tool with the proper list of files, derived from the sources of + -- the project. + procedure Output_Version; -- Output the version of this program procedure Usage; -- Display usage + ----------------- + -- Check_Files -- + ----------------- + + procedure Check_Files is + Add_Sources : Boolean := True; + Unit : Prj.Unit_Index; + Subunit : Boolean := False; + FD : File_Descriptor := Invalid_FD; + Status : Integer; + Success : Boolean; + + procedure Add_To_Response_File + (File_Name : String; + Check_File : Boolean := True); + -- Include the file name passed as parameter in the response file for + -- the tool being called. If the response file can not be written then + -- the file name is passed in the parameter list of the tool. If the + -- Check_File parameter is True then the procedure verifies the + -- existence of the file before adding it to the response file. + + -------------------------- + -- Add_To_Response_File -- + -------------------------- + + procedure Add_To_Response_File + (File_Name : String; + Check_File : Boolean := True) + is + begin + Name_Len := 0; + + Add_Str_To_Name_Buffer (File_Name); + + if not Check_File or else + Is_Regular_File (Name_Buffer (1 .. Name_Len)) + then + if FD /= Invalid_FD then + Name_Len := Name_Len + 1; + Name_Buffer (Name_Len) := ASCII.LF; + + Status := Write (FD, Name_Buffer (1)'Address, Name_Len); + + if Status /= Name_Len then + Osint.Fail ("disk full"); + end if; + else + Last_Switches.Increment_Last; + Last_Switches.Table (Last_Switches.Last) := + new String'(File_Name); + end if; + end if; + end Add_To_Response_File; + + -- Start of processing for Check_Files + + begin + -- Check if there is at least one argument that is not a switch + + for Index in 1 .. Last_Switches.Last loop + if Last_Switches.Table (Index) (1) /= '-' + or else (Last_Switches.Table (Index).all'Length > 7 + and then Last_Switches.Table (Index) (1 .. 7) = "-files=") + then + Add_Sources := False; + exit; + end if; + end loop; + + -- If all arguments are switches and there is no switch -files=, add the + -- path names of all the sources of the main project. + + if Add_Sources then + Tempdir.Create_Temp_File (FD, Temp_File_Name); + Last_Switches.Increment_Last; + Last_Switches.Table (Last_Switches.Last) := + new String'("-files=" & Get_Name_String (Temp_File_Name)); + + Unit := Units_Htable.Get_First (Project_Tree.Units_HT); + while Unit /= No_Unit_Index loop + + -- We only need to put the library units, body or spec, but not + -- the subunits. + + if Unit.File_Names (Impl) /= null + and then not Unit.File_Names (Impl).Locally_Removed + then + -- There is a body, check if it is for this project + + if All_Projects + or else Unit.File_Names (Impl).Project = Project + then + Subunit := False; + + if Unit.File_Names (Spec) = null + or else Unit.File_Names (Spec).Locally_Removed + then + -- We have a body with no spec: we need to check if + -- this is a subunit, because gnatls will complain + -- about subunits. + + declare + Src_Ind : constant Source_File_Index := + Sinput.P.Load_Project_File + (Get_Name_String + (Unit.File_Names (Impl).Path.Name)); + begin + Subunit := Sinput.P.Source_File_Is_Subunit (Src_Ind); + end; + end if; + + if not Subunit then + Add_To_Response_File + (Get_Name_String (Unit.File_Names (Impl).Display_File), + Check_File => False); + end if; + end if; + + elsif Unit.File_Names (Spec) /= null + and then not Unit.File_Names (Spec).Locally_Removed + then + -- We have a spec with no body. Check if it is for this project + + if All_Projects + or else Unit.File_Names (Spec).Project = Project + then + Add_To_Response_File + (Get_Name_String (Unit.File_Names (Spec).Display_File), + Check_File => False); + end if; + end if; + + Unit := Units_Htable.Get_Next (Project_Tree.Units_HT); + end loop; + + if FD /= Invalid_FD then + Close (FD, Success); + + if not Success then + Osint.Fail ("disk full"); + end if; + end if; + end if; + end Check_Files; + -------------------- -- Output_Version -- -------------------- @@ -293,8 +489,23 @@ procedure GNATCmd is -- Start of processing for GNATCmd begin + -- All output from GNATCmd is debugging or error output: send to stderr + + Set_Standard_Error; + -- Initializations + Csets.Initialize; + Snames.Initialize; + Stringt.Initialize; + + Prj.Tree.Initialize (Root_Environment, Gnatmake_Flags); + + Project_Node_Tree := new Project_Node_Tree_Data; + Prj.Tree.Initialize (Project_Node_Tree); + + Prj.Initialize (Project_Tree); + Last_Switches.Init; Last_Switches.Set_Last (0); @@ -485,21 +696,27 @@ begin or else The_Command = List then declare - Project_File_Used : Boolean := False; Switch : String_Access; + Dash_V_Switch : constant String := "-V"; begin for J in 1 .. Last_Switches.Last loop Switch := Last_Switches.Table (J); + + if The_Command = List and then Switch.all = Dash_V_Switch + then + Call_GPR_Tool := False; + exit; + end if; + if Switch'Length >= 2 and then Switch (Switch'First .. Switch'First + 1) = "-P" then - Project_File_Used := True; - exit; + Call_GPR_Tool := True; end if; end loop; - if Project_File_Used then + if Call_GPR_Tool then case The_Command is when Make | Compile | Bind | Link => if Locate_Exec_On_Path (Gprbuild) /= null then @@ -602,6 +819,382 @@ begin end; end if; + if The_Command = List and then not Call_GPR_Tool then + Tool_Package_Name := Name_Gnatls; + Packages_To_Check := Packages_To_Check_By_Gnatls; + + -- Check that the switches are consistent. Detect project file + -- related switches. + + Inspect_Switches : declare + Arg_Num : Positive := 1; + Argv : String_Access; + + procedure Remove_Switch (Num : Positive); + -- Remove a project related switch from table Last_Switches + + ------------------- + -- Remove_Switch -- + ------------------- + + procedure Remove_Switch (Num : Positive) is + begin + Last_Switches.Table (Num .. Last_Switches.Last - 1) := + Last_Switches.Table (Num + 1 .. Last_Switches.Last); + Last_Switches.Decrement_Last; + end Remove_Switch; + + -- Start of processing for Inspect_Switches + + begin + while Arg_Num <= Last_Switches.Last loop + Argv := Last_Switches.Table (Arg_Num); + + if Argv (Argv'First) = '-' then + if Argv'Length = 1 then + Fail ("switch character cannot be followed by a blank"); + end if; + + -- --subdirs=... Specify Subdirs + + if Argv'Length > Makeutl.Subdirs_Option'Length + and then + Argv + (Argv'First .. + Argv'First + Makeutl.Subdirs_Option'Length - 1) = + Makeutl.Subdirs_Option + then + Subdirs := + new String' + (Argv (Argv'First + Makeutl.Subdirs_Option'Length .. + Argv'Last)); + + Remove_Switch (Arg_Num); + + -- -aPdir Add dir to the project search path + + elsif Argv'Length > 3 + and then Argv (Argv'First + 1 .. Argv'First + 2) = "aP" + then + Prj.Env.Add_Directories + (Root_Environment.Project_Path, + Argv (Argv'First + 3 .. Argv'Last)); + + -- Pass -aPdir to gnatls, but not to other tools + + if The_Command = List then + Arg_Num := Arg_Num + 1; + else + Remove_Switch (Arg_Num); + end if; + + -- -eL Follow links for files + + elsif Argv.all = "-eL" then + Follow_Links_For_Files := True; + Follow_Links_For_Dirs := True; + + Remove_Switch (Arg_Num); + + -- -vPx Specify verbosity while parsing project files + + elsif Argv'Length >= 3 + and then Argv (Argv'First + 1 .. Argv'First + 2) = "vP" + then + if Argv'Length = 4 + and then Argv (Argv'Last) in '0' .. '2' + then + case Argv (Argv'Last) is + when '0' => + Current_Verbosity := Prj.Default; + when '1' => + Current_Verbosity := Prj.Medium; + when '2' => + Current_Verbosity := Prj.High; + when others => + + -- Cannot happen + + raise Program_Error; + end case; + else + Fail ("invalid verbosity level: " + & Argv (Argv'First + 3 .. Argv'Last)); + end if; + + Remove_Switch (Arg_Num); + + -- -Pproject_file Specify project file to be used + + elsif Argv (Argv'First + 1) = 'P' then + + -- Only one -P switch can be used + + if Project_File /= null then + Fail + (Argv.all + & ": second project file forbidden (first is """ + & Project_File.all & """)"); + + elsif Argv'Length = 2 then + + -- There is space between -P and the project file + -- name. -P cannot be the last option. + + if Arg_Num = Last_Switches.Last then + Fail ("project file name missing after -P"); + + else + Remove_Switch (Arg_Num); + Argv := Last_Switches.Table (Arg_Num); + + -- After -P, there must be a project file name, + -- not another switch. + + if Argv (Argv'First) = '-' then + Fail ("project file name missing after -P"); + + else + Project_File := new String'(Argv.all); + end if; + end if; + + else + -- No space between -P and project file name + + Project_File := + new String'(Argv (Argv'First + 2 .. Argv'Last)); + end if; + + Remove_Switch (Arg_Num); + + -- -Xexternal=value Specify an external reference to be + -- used in project files + + elsif Argv'Length >= 5 + and then Argv (Argv'First + 1) = 'X' + then + if not Check (Root_Environment.External, + Argv (Argv'First + 2 .. Argv'Last)) + then + Fail + (Argv.all & " is not a valid external assignment."); + end if; + + Remove_Switch (Arg_Num); + + elsif + The_Command = List + and then Argv'Length = 2 + and then Argv (2) = 'U' + then + All_Projects := True; + Remove_Switch (Arg_Num); + + else + Arg_Num := Arg_Num + 1; + end if; + + else + Arg_Num := Arg_Num + 1; + end if; + end loop; + end Inspect_Switches; + end if; + + -- Add the default project search directories now, after the directories + -- that have been specified by switches -aP. + + Prj.Env.Initialize_Default_Project_Path + (Root_Environment.Project_Path, + Target_Name => Sdefault.Target_Name.all); + + -- If there is a project file specified, parse it, get the switches + -- for the tool and setup PATH environment variables. + + if Project_File /= null then + Prj.Pars.Set_Verbosity (To => Current_Verbosity); + + Prj.Pars.Parse + (Project => Project, + In_Tree => Project_Tree, + In_Node_Tree => Project_Node_Tree, + Project_File_Name => Project_File.all, + Env => Root_Environment, + Packages_To_Check => Packages_To_Check); + + -- Prj.Pars.Parse calls Set_Standard_Output, reset to stderr + + Set_Standard_Error; + + if Project = Prj.No_Project then + Fail ("""" & Project_File.all & """ processing failed"); + + elsif Project.Qualifier = Aggregate then + Fail ("aggregate projects are not supported"); + + elsif Aggregate_Libraries_In (Project_Tree) then + Fail ("aggregate library projects are not supported"); + end if; + + -- Check if a package with the name of the tool is in the project + -- file and if there is one, get the switches, if any, and scan them. + + declare + Pkg : constant Prj.Package_Id := + Prj.Util.Value_Of + (Name => Tool_Package_Name, + In_Packages => Project.Decl.Packages, + Shared => Project_Tree.Shared); + + Element : Package_Element; + + Switches_Array : Array_Element_Id; + + The_Switches : Prj.Variable_Value; + Current : Prj.String_List_Id; + The_String : String_Element; + + Main : String_Access := null; + + begin + if Pkg /= No_Package then + Element := Project_Tree.Shared.Packages.Table (Pkg); + + -- Package Gnatls has a single attribute Switches, that is not + -- an associative array. + + if The_Command = List then + The_Switches := + Prj.Util.Value_Of + (Variable_Name => Snames.Name_Switches, + In_Variables => Element.Decl.Attributes, + Shared => Project_Tree.Shared); + + -- Packages Binder (for gnatbind), Cross_Reference (for + -- gnatxref), Linker (for gnatlink), Finder (for gnatfind), + -- have an attributed Switches, an associative array, indexed + -- by the name of the file. + + -- They also have an attribute Default_Switches, indexed by the + -- name of the programming language. + + else + -- First check if there is a single main + + for J in 1 .. Last_Switches.Last loop + if Last_Switches.Table (J) (1) /= '-' then + if Main = null then + Main := Last_Switches.Table (J); + else + Main := null; + exit; + end if; + end if; + end loop; + + if Main /= null then + Switches_Array := + Prj.Util.Value_Of + (Name => Name_Switches, + In_Arrays => Element.Decl.Arrays, + Shared => Project_Tree.Shared); + Name_Len := 0; + + -- If the single main has been specified as an absolute + -- path, use only the simple file name. If the absolute + -- path is incorrect, an error will be reported by the + -- underlying tool and it does not make a difference + -- what switches are used. + + if Is_Absolute_Path (Main.all) then + Add_Str_To_Name_Buffer (File_Name (Main.all)); + else + Add_Str_To_Name_Buffer (Main.all); + end if; + + The_Switches := Prj.Util.Value_Of + (Index => Name_Find, + Src_Index => 0, + In_Array => Switches_Array, + Shared => Project_Tree.Shared); + end if; + + if The_Switches.Kind = Prj.Undefined then + Switches_Array := + Prj.Util.Value_Of + (Name => Name_Default_Switches, + In_Arrays => Element.Decl.Arrays, + Shared => Project_Tree.Shared); + The_Switches := Prj.Util.Value_Of + (Index => Name_Ada, + Src_Index => 0, + In_Array => Switches_Array, + Shared => Project_Tree.Shared); + end if; + end if; + + -- If there are switches specified in the package of the + -- project file corresponding to the tool, scan them. + + case The_Switches.Kind is + when Prj.Undefined => + null; + + when Prj.Single => + declare + Switch : constant String := + Get_Name_String (The_Switches.Value); + begin + if Switch'Length > 0 then + First_Switches.Increment_Last; + First_Switches.Table (First_Switches.Last) := + new String'(Switch); + end if; + end; + + when Prj.List => + Current := The_Switches.Values; + while Current /= Prj.Nil_String loop + The_String := Project_Tree.Shared.String_Elements. + Table (Current); + + declare + Switch : constant String := + Get_Name_String (The_String.Value); + begin + if Switch'Length > 0 then + First_Switches.Increment_Last; + First_Switches.Table (First_Switches.Last) := + new String'(Switch); + end if; + end; + + Current := The_String.Next; + end loop; + end case; + end if; + end; + + if The_Command = Bind or else The_Command = Link then + if Project.Object_Directory.Name = No_Path then + Fail ("project " & Get_Name_String (Project.Display_Name) + & " has no object directory"); + end if; + + Change_Dir (Get_Name_String (Project.Object_Directory.Name)); + end if; + + -- Set up the env vars for project path files + + Prj.Env.Set_Ada_Paths + (Project, Project_Tree, Including_Libraries => True); + + if The_Command = List then + Check_Files; + end if; + end if; + -- Gather all the arguments and invoke the executable declare diff --git a/gcc/ada/make.adb b/gcc/ada/make.adb index a072513a288..a2c4c9e278f 100644 --- a/gcc/ada/make.adb +++ b/gcc/ada/make.adb @@ -6413,16 +6413,29 @@ package body Make is -- Scan again the switch and arguments, now that we are sure that they -- do not include --version or --help. - -- First, for native gnatmake, check for switch -P and, if found and - -- gprbuild is available, silently invoke gprbuild. + -- First, check for switch -P and, if found and gprbuild is available, + -- silently invoke gprbuild, with switch --target if not on a native + -- platform. - Find_Program_Name; + declare + Arg_Len : Positive := Argument_Count; + Call_Gprbuild : Boolean := False; + Gprbuild : String_Access := null; + Pos : Natural := 0; + Success : Boolean; + Target : String_Access := null; - if Name_Buffer (1 .. Name_Len) = "gnatmake" then - declare - Call_Gprbuild : Boolean := False; + begin + Find_Program_Name; + + if Name_Len >= 8 + and then Name_Buffer (Name_Len - 7 .. Name_Len) = "gnatmake" + then + if Name_Len > 8 then + Target := new String'(Name_Buffer (1 .. Name_Len - 9)); + Arg_Len := Arg_Len + 1; + end if; - begin for J in 1 .. Argument_Count loop declare Arg : constant String := Argument (J); @@ -6437,16 +6450,20 @@ package body Make is end loop; if Call_Gprbuild then - declare - Gprbuild : String_Access := - Locate_Exec_On_Path (Exec_Name => "gprbuild"); - Args : Argument_List (1 .. Argument_Count); - Success : Boolean; + Gprbuild := Locate_Exec_On_Path (Exec_Name => "gprbuild"); + + if Gprbuild /= null then + declare + Args : Argument_List (1 .. Arg_Len); + begin + if Target /= null then + Args (1) := new String'("--target=" & Target.all); + Pos := 1; + end if; - begin - if Gprbuild /= null then for J in 1 .. Argument_Count loop - Args (J) := new String'(Argument (J)); + Pos := Pos + 1; + Args (Pos) := new String'(Argument (J)); end loop; Spawn (Gprbuild.all, Args, Success); @@ -6456,11 +6473,11 @@ package body Make is if Success then Exit_Program (E_Success); end if; - end if; - end; + end; + end if; end if; - end; - end if; + end if; + end; Scan_Args : for Next_Arg in 1 .. Argument_Count loop Scan_Make_Arg (Env, Argument (Next_Arg), And_Save => True); diff --git a/gcc/ada/sem_ch12.adb b/gcc/ada/sem_ch12.adb index e6d5af5f216..5f77f571999 100644 --- a/gcc/ada/sem_ch12.adb +++ b/gcc/ada/sem_ch12.adb @@ -14052,7 +14052,7 @@ package body Sem_Ch12 is begin Result := Make_Identifier (Loc, Chars (Typ)); - if Present (Scop) and then Scop /= Standard_Standard then + if Present (Scop) and then not Is_Generic_Unit (Scop) then Result := Make_Selected_Component (Loc, Prefix => Make_Identifier (Loc, Chars (Scop)),