blob: 172e1300377de669485c702c4bea8143e115cfd6 [file] [log] [blame]
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- B C H E C K --
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
-- for more details. You should have received a copy of the GNU General --
-- Public License distributed with GNAT; see file COPYING3. If not, go to --
-- http://www.gnu.org/licenses for a complete copy of the license. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
with ALI; use ALI;
with ALI.Util; use ALI.Util;
with Binderr; use Binderr;
with Butil; use Butil;
with Casing; use Casing;
with Fname; use Fname;
with Namet; use Namet;
with Opt; use Opt;
with Osint;
with Output; use Output;
with Rident; use Rident;
with Types; use Types;
package body Bcheck is
-----------------------
-- Local Subprograms --
-----------------------
-- The following checking subprograms make up the parts of the
-- configuration consistency check. See bodies for details of checks.
procedure Check_Consistent_Dispatching_Policy;
procedure Check_Consistent_Dynamic_Elaboration_Checking;
procedure Check_Consistent_Interrupt_States;
procedure Check_Consistent_Locking_Policy;
procedure Check_Consistent_Normalize_Scalars;
procedure Check_Consistent_Optimize_Alignment;
procedure Check_Consistent_Partition_Elaboration_Policy;
procedure Check_Consistent_Queuing_Policy;
procedure Check_Consistent_Restrictions;
procedure Check_Consistent_Restriction_No_Default_Initialization;
procedure Check_Consistent_SSO_Default;
procedure Check_Consistent_Zero_Cost_Exception_Handling;
procedure Consistency_Error_Msg (Msg : String);
-- Produce an error or a warning message, depending on whether an
-- inconsistent configuration is permitted or not.
function Same_Unit (U1 : Unit_Name_Type; U2 : Name_Id) return Boolean;
-- Used to compare two unit names for No_Dependence checks. U1 is in
-- standard unit name format, and U2 is in literal form with periods.
-------------------------------------
-- Check_Configuration_Consistency --
-------------------------------------
procedure Check_Configuration_Consistency is
begin
if Queuing_Policy_Specified /= ' ' then
Check_Consistent_Queuing_Policy;
end if;
if Locking_Policy_Specified /= ' ' then
Check_Consistent_Locking_Policy;
end if;
if Partition_Elaboration_Policy_Specified /= ' ' then
Check_Consistent_Partition_Elaboration_Policy;
end if;
if SSO_Default_Specified then
Check_Consistent_SSO_Default;
end if;
if Zero_Cost_Exceptions_Specified then
Check_Consistent_Zero_Cost_Exception_Handling;
end if;
Check_Consistent_Normalize_Scalars;
Check_Consistent_Optimize_Alignment;
Check_Consistent_Dynamic_Elaboration_Checking;
Check_Consistent_Restrictions;
Check_Consistent_Restriction_No_Default_Initialization;
Check_Consistent_Interrupt_States;
Check_Consistent_Dispatching_Policy;
end Check_Configuration_Consistency;
-----------------------
-- Check_Consistency --
-----------------------
procedure Check_Consistency is
Src : Source_Id;
-- Source file Id for this Sdep entry
ALI_Path_Id : File_Name_Type;
begin
-- First, we go through the source table to see if there are any cases
-- in which we should go after source files and compute checksums of
-- the source files. We need to do this for any file for which we have
-- mismatching time stamps and (so far) matching checksums.
for S in Source.First .. Source.Last loop
-- If all time stamps for a file match, then there is nothing to
-- do, since we will not be checking checksums in that case anyway
if Source.Table (S).All_Timestamps_Match then
null;
-- If we did not find the source file, then we can't compute its
-- checksum anyway. Note that when we have a time stamp mismatch,
-- we try to find the source file unconditionally (i.e. if
-- Check_Source_Files is False).
elsif not Source.Table (S).Source_Found then
null;
-- If we already have non-matching or missing checksums, then no
-- need to try going after source file, since we won't trust the
-- checksums in any case.
elsif not Source.Table (S).All_Checksums_Match then
null;
-- Now we have the case where we have time stamp mismatches, and
-- the source file is around, but so far all checksums match. This
-- is the case where we need to compute the checksum from the source
-- file, since otherwise we would ignore the time stamp mismatches,
-- and that is wrong if the checksum of the source does not agree
-- with the checksums in the ALI files.
elsif Check_Source_Files then
if not Checksums_Match
(Source.Table (S).Checksum,
Get_File_Checksum (Source.Table (S).Sfile))
then
Source.Table (S).All_Checksums_Match := False;
end if;
end if;
end loop;
-- Loop through ALI files
ALIs_Loop : for A in ALIs.First .. ALIs.Last loop
-- Loop through Sdep entries in one ALI file
Sdep_Loop : for D in
ALIs.Table (A).First_Sdep .. ALIs.Table (A).Last_Sdep
loop
if Sdep.Table (D).Dummy_Entry then
goto Continue;
end if;
Src := Source_Id (Get_Name_Table_Int (Sdep.Table (D).Sfile));
-- If the time stamps match, or all checksums match, then we
-- are OK, otherwise we have a definite error.
if Sdep.Table (D).Stamp /= Source.Table (Src).Stamp
and then not Source.Table (Src).All_Checksums_Match
then
Error_Msg_File_1 := ALIs.Table (A).Sfile;
Error_Msg_File_2 := Sdep.Table (D).Sfile;
-- Two styles of message, depending on whether or not
-- the updated file is the one that must be recompiled
if Error_Msg_File_1 = Error_Msg_File_2 then
if Tolerate_Consistency_Errors then
Error_Msg
("?{ has been modified and should be recompiled");
else
Error_Msg
("{ has been modified and must be recompiled");
end if;
else
ALI_Path_Id :=
Osint.Full_Lib_File_Name (ALIs.Table (A).Afile);
if Osint.Is_Readonly_Library (ALI_Path_Id) then
if Tolerate_Consistency_Errors then
Error_Msg ("?{ should be recompiled");
Error_Msg_File_1 := ALI_Path_Id;
Error_Msg ("?({ is obsolete and read-only)");
else
Error_Msg ("{ must be compiled");
Error_Msg_File_1 := ALI_Path_Id;
Error_Msg ("({ is obsolete and read-only)");
end if;
elsif Tolerate_Consistency_Errors then
Error_Msg
("?{ should be recompiled ({ has been modified)");
else
Error_Msg ("{ must be recompiled ({ has been modified)");
end if;
end if;
if (not Tolerate_Consistency_Errors) and Verbose_Mode then
Error_Msg_File_1 := Source.Table (Src).Stamp_File;
if Source.Table (Src).Source_Found then
Error_Msg_File_1 :=
Osint.Full_Source_Name (Error_Msg_File_1);
else
Error_Msg_File_1 :=
Osint.Full_Lib_File_Name (Error_Msg_File_1);
end if;
Error_Msg
("time stamp from { " & String (Source.Table (Src).Stamp));
Error_Msg_File_1 := Sdep.Table (D).Sfile;
Error_Msg
(" conflicts with { timestamp " &
String (Sdep.Table (D).Stamp));
Error_Msg_File_1 :=
Osint.Full_Lib_File_Name (ALIs.Table (A).Afile);
Error_Msg (" from {");
end if;
-- Exit from the loop through Sdep entries once we find one
-- that does not match.
exit Sdep_Loop;
end if;
<<Continue>>
null;
end loop Sdep_Loop;
end loop ALIs_Loop;
end Check_Consistency;
-----------------------------------------
-- Check_Consistent_Dispatching_Policy --
-----------------------------------------
-- The rule is that all files for which the dispatching policy is
-- significant must meet the following rules:
-- 1. All files for which a task dispatching policy is significant must
-- be compiled with the same setting.
-- 2. If a partition contains one or more Priority_Specific_Dispatching
-- pragmas it cannot contain a Task_Dispatching_Policy pragma.
-- 3. No overlap is allowed in the priority ranges specified in
-- Priority_Specific_Dispatching pragmas within the same partition.
-- 4. If a partition contains one or more Priority_Specific_Dispatching
-- pragmas then the Ceiling_Locking policy is the only one allowed for
-- the partition.
procedure Check_Consistent_Dispatching_Policy is
Max_Prio : Nat := 0;
-- Maximum priority value for which a Priority_Specific_Dispatching
-- pragma has been specified.
TDP_Pragma_Afile : ALI_Id := No_ALI_Id;
-- ALI file where a Task_Dispatching_Policy pragma appears
begin
-- Consistency checks in units specifying a Task_Dispatching_Policy
if Task_Dispatching_Policy_Specified /= ' ' then
Find_Policy : for A1 in ALIs.First .. ALIs.Last loop
if ALIs.Table (A1).Task_Dispatching_Policy /= ' ' then
-- Store the place where the first task dispatching pragma
-- appears. We may need this value for issuing consistency
-- errors if Priority_Specific_Dispatching pragmas are used.
TDP_Pragma_Afile := A1;
Check_Policy : declare
Policy : constant Character :=
ALIs.Table (A1).Task_Dispatching_Policy;
begin
for A2 in A1 + 1 .. ALIs.Last loop
if ALIs.Table (A2).Task_Dispatching_Policy /= ' '
and then
ALIs.Table (A2).Task_Dispatching_Policy /= Policy
then
Error_Msg_File_1 := ALIs.Table (A1).Sfile;
Error_Msg_File_2 := ALIs.Table (A2).Sfile;
Consistency_Error_Msg
("{ and { compiled with different task" &
" dispatching policies");
exit Find_Policy;
end if;
end loop;
end Check_Policy;
exit Find_Policy;
end if;
end loop Find_Policy;
end if;
-- If no Priority_Specific_Dispatching entries, nothing else to do
if Specific_Dispatching.Last >= Specific_Dispatching.First then
-- Find out the maximum priority value for which one of the
-- Priority_Specific_Dispatching pragmas applies.
Max_Prio := 0;
for J in Specific_Dispatching.First .. Specific_Dispatching.Last loop
if Specific_Dispatching.Table (J).Last_Priority > Max_Prio then
Max_Prio := Specific_Dispatching.Table (J).Last_Priority;
end if;
end loop;
-- Now establish tables to be used for consistency checking
declare
-- The following record type is used to record locations of the
-- Priority_Specific_Dispatching pragmas applying to the Priority.
type Specific_Dispatching_Entry is record
Dispatching_Policy : Character := ' ';
-- First character (upper case) of corresponding policy name
Afile : ALI_Id := No_ALI_Id;
-- ALI file that generated Priority Specific Dispatching
-- entry for consistency message.
Loc : Nat := 0;
-- Line numbers from Priority_Specific_Dispatching pragma
end record;
PSD_Table : array (0 .. Max_Prio) of Specific_Dispatching_Entry :=
(others => Specific_Dispatching_Entry'
(Dispatching_Policy => ' ',
Afile => No_ALI_Id,
Loc => 0));
-- Array containing an entry per priority containing the location
-- where there is a Priority_Specific_Dispatching pragma that
-- applies to the priority.
begin
for F in ALIs.First .. ALIs.Last loop
for K in ALIs.Table (F).First_Specific_Dispatching ..
ALIs.Table (F).Last_Specific_Dispatching
loop
declare
DTK : Specific_Dispatching_Record
renames Specific_Dispatching.Table (K);
begin
-- Check whether pragma Task_Dispatching_Policy and
-- pragma Priority_Specific_Dispatching are used in the
-- same partition.
if Task_Dispatching_Policy_Specified /= ' ' then
Error_Msg_File_1 := ALIs.Table (F).Sfile;
Error_Msg_File_2 :=
ALIs.Table (TDP_Pragma_Afile).Sfile;
Error_Msg_Nat_1 := DTK.PSD_Pragma_Line;
Consistency_Error_Msg
("Priority_Specific_Dispatching at {:#" &
" incompatible with Task_Dispatching_Policy at {");
end if;
-- Ceiling_Locking must also be specified for a partition
-- with at least one Priority_Specific_Dispatching
-- pragma.
if Locking_Policy_Specified /= ' '
and then Locking_Policy_Specified /= 'C'
then
for A in ALIs.First .. ALIs.Last loop
if ALIs.Table (A).Locking_Policy /= ' '
and then ALIs.Table (A).Locking_Policy /= 'C'
then
Error_Msg_File_1 := ALIs.Table (F).Sfile;
Error_Msg_File_2 := ALIs.Table (A).Sfile;
Error_Msg_Nat_1 := DTK.PSD_Pragma_Line;
Consistency_Error_Msg
("Priority_Specific_Dispatching at {:#" &
" incompatible with Locking_Policy at {");
end if;
end loop;
end if;
-- Check overlapping priority ranges
Find_Overlapping : for Prio in
DTK.First_Priority .. DTK.Last_Priority
loop
if PSD_Table (Prio).Afile = No_ALI_Id then
PSD_Table (Prio) :=
(Dispatching_Policy => DTK.Dispatching_Policy,
Afile => F, Loc => DTK.PSD_Pragma_Line);
elsif PSD_Table (Prio).Dispatching_Policy /=
DTK.Dispatching_Policy
then
Error_Msg_File_1 :=
ALIs.Table (PSD_Table (Prio).Afile).Sfile;
Error_Msg_File_2 := ALIs.Table (F).Sfile;
Error_Msg_Nat_1 := PSD_Table (Prio).Loc;
Error_Msg_Nat_2 := DTK.PSD_Pragma_Line;
Consistency_Error_Msg
("overlapping priority ranges at {:# and {:#");
exit Find_Overlapping;
end if;
end loop Find_Overlapping;
end;
end loop;
end loop;
end;
end if;
end Check_Consistent_Dispatching_Policy;
---------------------------------------------------
-- Check_Consistent_Dynamic_Elaboration_Checking --
---------------------------------------------------
-- The rule here is that if a unit has dynamic elaboration checks,
-- then any unit it withs must meeting one of the following criteria:
-- 1. There is a pragma Elaborate_All for the with'ed unit
-- 2. The with'ed unit was compiled with dynamic elaboration checks
-- 3. The with'ed unit has pragma Preelaborate or Pure
-- 4. It is an internal GNAT unit (including children of GNAT)
procedure Check_Consistent_Dynamic_Elaboration_Checking is
begin
if Dynamic_Elaboration_Checks_Specified then
for U in First_Unit_Entry .. Units.Last loop
declare
UR : Unit_Record renames Units.Table (U);
begin
if UR.Dynamic_Elab then
for W in UR.First_With .. UR.Last_With loop
declare
WR : With_Record renames Withs.Table (W);
begin
if Get_Name_Table_Int (WR.Uname) /= 0 then
declare
WU : Unit_Record renames
Units.Table
(Unit_Id
(Get_Name_Table_Int (WR.Uname)));
begin
-- Case 1. Elaborate_All for with'ed unit
if WR.Elaborate_All then
null;
-- Case 2. With'ed unit has dynamic elab checks
elsif WU.Dynamic_Elab then
null;
-- Case 3. With'ed unit is Preelaborate or Pure
elsif WU.Preelab or else WU.Pure then
null;
-- Case 4. With'ed unit is internal file
elsif Is_Internal_File_Name (WU.Sfile) then
null;
-- Issue warning, not one of the safe cases
else
Error_Msg_File_1 := UR.Sfile;
Error_Msg
("?{ has dynamic elaboration checks " &
"and with's");
Error_Msg_File_1 := WU.Sfile;
Error_Msg
("? { which has static elaboration " &
"checks");
Warnings_Detected := Warnings_Detected - 1;
end if;
end;
end if;
end;
end loop;
end if;
end;
end loop;
end if;
end Check_Consistent_Dynamic_Elaboration_Checking;
---------------------------------------
-- Check_Consistent_Interrupt_States --
---------------------------------------
-- The rule is that if the state of a given interrupt is specified
-- in more than one unit, it must be specified with a consistent state.
procedure Check_Consistent_Interrupt_States is
Max_Intrup : Nat;
begin
-- If no Interrupt_State entries, nothing to do
if Interrupt_States.Last < Interrupt_States.First then
return;
end if;
-- First find out the maximum interrupt value
Max_Intrup := 0;
for J in Interrupt_States.First .. Interrupt_States.Last loop
if Interrupt_States.Table (J).Interrupt_Id > Max_Intrup then
Max_Intrup := Interrupt_States.Table (J).Interrupt_Id;
end if;
end loop;
-- Now establish tables to be used for consistency checking
declare
Istate : array (0 .. Max_Intrup) of Character := (others => 'n');
-- Interrupt state entries, 'u'/'s'/'r' or 'n' to indicate an
-- entry that has not been set.
Afile : array (0 .. Max_Intrup) of ALI_Id;
-- ALI file that generated Istate entry for consistency message
Loc : array (0 .. Max_Intrup) of Nat;
-- Line numbers from IS pragma generating Istate entry
Inum : Nat;
-- Interrupt number from entry being tested
Stat : Character;
-- Interrupt state from entry being tested
Lnum : Nat;
-- Line number from entry being tested
begin
for F in ALIs.First .. ALIs.Last loop
for K in ALIs.Table (F).First_Interrupt_State ..
ALIs.Table (F).Last_Interrupt_State
loop
Inum := Interrupt_States.Table (K).Interrupt_Id;
Stat := Interrupt_States.Table (K).Interrupt_State;
Lnum := Interrupt_States.Table (K).IS_Pragma_Line;
if Istate (Inum) = 'n' then
Istate (Inum) := Stat;
Afile (Inum) := F;
Loc (Inum) := Lnum;
elsif Istate (Inum) /= Stat then
Error_Msg_File_1 := ALIs.Table (Afile (Inum)).Sfile;
Error_Msg_File_2 := ALIs.Table (F).Sfile;
Error_Msg_Nat_1 := Loc (Inum);
Error_Msg_Nat_2 := Lnum;
Consistency_Error_Msg
("inconsistent interrupt states at {:# and {:#");
end if;
end loop;
end loop;
end;
end Check_Consistent_Interrupt_States;
-------------------------------------
-- Check_Consistent_Locking_Policy --
-------------------------------------
-- The rule is that all files for which the locking policy is
-- significant must be compiled with the same setting.
procedure Check_Consistent_Locking_Policy is
begin
-- First search for a unit specifying a policy and then
-- check all remaining units against it.
Find_Policy : for A1 in ALIs.First .. ALIs.Last loop
if ALIs.Table (A1).Locking_Policy /= ' ' then
Check_Policy : declare
Policy : constant Character := ALIs.Table (A1).Locking_Policy;
begin
for A2 in A1 + 1 .. ALIs.Last loop
if ALIs.Table (A2).Locking_Policy /= ' '
and then
ALIs.Table (A2).Locking_Policy /= Policy
then
Error_Msg_File_1 := ALIs.Table (A1).Sfile;
Error_Msg_File_2 := ALIs.Table (A2).Sfile;
Consistency_Error_Msg
("{ and { compiled with different locking policies");
exit Find_Policy;
end if;
end loop;
end Check_Policy;
exit Find_Policy;
end if;
end loop Find_Policy;
end Check_Consistent_Locking_Policy;
----------------------------------------
-- Check_Consistent_Normalize_Scalars --
----------------------------------------
-- The rule is that if any unit is compiled with Normalized_Scalars,
-- then all other units in the partition must also be compiled with
-- Normalized_Scalars in effect.
-- There is some issue as to whether this consistency check is desirable,
-- it is certainly required at the moment by the RM. We should keep a watch
-- on the ARG and HRG deliberations here. GNAT no longer depends on this
-- consistency (it used to do so, but that is no longer the case, since
-- pragma Initialize_Scalars pragma does not require consistency.)
procedure Check_Consistent_Normalize_Scalars is
begin
if Normalize_Scalars_Specified and No_Normalize_Scalars_Specified then
Consistency_Error_Msg
("some but not all files compiled with Normalize_Scalars");
Write_Eol;
Write_Str ("files compiled with Normalize_Scalars");
Write_Eol;
for A1 in ALIs.First .. ALIs.Last loop
if ALIs.Table (A1).Normalize_Scalars then
Write_Str (" ");
Write_Name (ALIs.Table (A1).Sfile);
Write_Eol;
end if;
end loop;
Write_Eol;
Write_Str ("files compiled without Normalize_Scalars");
Write_Eol;
for A1 in ALIs.First .. ALIs.Last loop
if not ALIs.Table (A1).Normalize_Scalars then
Write_Str (" ");
Write_Name (ALIs.Table (A1).Sfile);
Write_Eol;
end if;
end loop;
end if;
end Check_Consistent_Normalize_Scalars;
-----------------------------------------
-- Check_Consistent_Optimize_Alignment --
-----------------------------------------
-- The rule is that all units which depend on the global default setting
-- of Optimize_Alignment must be compiled with the same setting for this
-- default. Units which specify an explicit local value for this setting
-- are exempt from the consistency rule (this includes all internal units).
procedure Check_Consistent_Optimize_Alignment is
OA_Setting : Character := ' ';
-- Reset when we find a unit that depends on the default and does
-- not have a local specification of the Optimize_Alignment setting.
OA_Unit : Unit_Id;
-- Id of unit from which OA_Setting was set
C : Character;
begin
for U in First_Unit_Entry .. Units.Last loop
C := Units.Table (U).Optimize_Alignment;
if C /= 'L' then
if OA_Setting = ' ' then
OA_Setting := C;
OA_Unit := U;
elsif OA_Setting = C then
null;
else
Error_Msg_Unit_1 := Units.Table (OA_Unit).Uname;
Error_Msg_Unit_2 := Units.Table (U).Uname;
Consistency_Error_Msg
("$ and $ compiled with different "
& "default Optimize_Alignment settings");
return;
end if;
end if;
end loop;
end Check_Consistent_Optimize_Alignment;
---------------------------------------------------
-- Check_Consistent_Partition_Elaboration_Policy --
---------------------------------------------------
-- The rule is that all files for which the partition elaboration policy is
-- significant must be compiled with the same setting.
procedure Check_Consistent_Partition_Elaboration_Policy is
begin
-- First search for a unit specifying a policy and then
-- check all remaining units against it.
Find_Policy : for A1 in ALIs.First .. ALIs.Last loop
if ALIs.Table (A1).Partition_Elaboration_Policy /= ' ' then
Check_Policy : declare
Policy : constant Character :=
ALIs.Table (A1).Partition_Elaboration_Policy;
begin
for A2 in A1 + 1 .. ALIs.Last loop
if ALIs.Table (A2).Partition_Elaboration_Policy /= ' '
and then
ALIs.Table (A2).Partition_Elaboration_Policy /= Policy
then
Error_Msg_File_1 := ALIs.Table (A1).Sfile;
Error_Msg_File_2 := ALIs.Table (A2).Sfile;
Consistency_Error_Msg
("{ and { compiled with different partition "
& "elaboration policies");
exit Find_Policy;
end if;
end loop;
end Check_Policy;
-- A No_Task_Hierarchy restriction must be specified for the
-- Sequential policy (RM H.6(6/2)).
if Partition_Elaboration_Policy_Specified = 'S'
and then not Cumulative_Restrictions.Set (No_Task_Hierarchy)
then
Error_Msg_File_1 := ALIs.Table (A1).Sfile;
Error_Msg
("{ has sequential partition elaboration policy, but no");
Error_Msg
("pragma Restrictions (No_Task_Hierarchy) was specified");
end if;
exit Find_Policy;
end if;
end loop Find_Policy;
end Check_Consistent_Partition_Elaboration_Policy;
-------------------------------------
-- Check_Consistent_Queuing_Policy --
-------------------------------------
-- The rule is that all files for which the queuing policy is
-- significant must be compiled with the same setting.
procedure Check_Consistent_Queuing_Policy is
begin
-- First search for a unit specifying a policy and then
-- check all remaining units against it.
Find_Policy : for A1 in ALIs.First .. ALIs.Last loop
if ALIs.Table (A1).Queuing_Policy /= ' ' then
Check_Policy : declare
Policy : constant Character := ALIs.Table (A1).Queuing_Policy;
begin
for A2 in A1 + 1 .. ALIs.Last loop
if ALIs.Table (A2).Queuing_Policy /= ' '
and then
ALIs.Table (A2).Queuing_Policy /= Policy
then
Error_Msg_File_1 := ALIs.Table (A1).Sfile;
Error_Msg_File_2 := ALIs.Table (A2).Sfile;
Consistency_Error_Msg
("{ and { compiled with different queuing policies");
exit Find_Policy;
end if;
end loop;
end Check_Policy;
exit Find_Policy;
end if;
end loop Find_Policy;
end Check_Consistent_Queuing_Policy;
-----------------------------------
-- Check_Consistent_Restrictions --
-----------------------------------
-- The rule is that if a restriction is specified in any unit, then all
-- units must obey the restriction. The check applies only to restrictions
-- which require partition wide consistency, and not to internal units.
procedure Check_Consistent_Restrictions is
Restriction_File_Output : Boolean;
-- Shows if we have output header messages for restriction violation
procedure Print_Restriction_File (R : All_Restrictions);
-- Print header line for R if not printed yet
----------------------------
-- Print_Restriction_File --
----------------------------
procedure Print_Restriction_File (R : All_Restrictions) is
begin
if not Restriction_File_Output then
Restriction_File_Output := True;
-- Find an ali file specifying the restriction
for A in ALIs.First .. ALIs.Last loop
if ALIs.Table (A).Restrictions.Set (R)
and then (R in All_Boolean_Restrictions
or else ALIs.Table (A).Restrictions.Value (R) =
Cumulative_Restrictions.Value (R))
then
-- We have found that ALI file A specifies the restriction
-- that is being violated (the minimum value is specified
-- in the case of a parameter restriction).
declare
M1 : constant String := "{ has restriction ";
S : constant String := Restriction_Id'Image (R);
M2 : String (1 .. 2000); -- big enough
P : Integer;
begin
Name_Buffer (1 .. S'Length) := S;
Name_Len := S'Length;
Set_Casing (Mixed_Case);
M2 (M1'Range) := M1;
P := M1'Length + 1;
M2 (P .. P + S'Length - 1) := Name_Buffer (1 .. S'Length);
P := P + S'Length;
if R in All_Parameter_Restrictions then
M2 (P .. P + 4) := " => #";
Error_Msg_Nat_1 :=
Int (Cumulative_Restrictions.Value (R));
P := P + 5;
end if;
Error_Msg_File_1 := ALIs.Table (A).Sfile;
Consistency_Error_Msg (M2 (1 .. P - 1));
Consistency_Error_Msg
("but the following files violate this restriction:");
return;
end;
end if;
end loop;
end if;
end Print_Restriction_File;
-- Start of processing for Check_Consistent_Restrictions
begin
-- We used to have a special test here:
-- A special test, if we have a main program, then if it has an
-- allocator in the body, this is considered to be a violation of
-- the restriction No_Allocators_After_Elaboration. We just mark
-- this restriction and then the normal circuit will flag it.
-- But we don't do that any more, because in the final version of Ada
-- 2012, it is statically illegal to have an allocator in a library-
-- level subprogram, so we don't need this bind time test any more.
-- If we have a main program with parameters (which GNAT allows), then
-- allocators in that will be caught by the run-time check.
-- Loop through all restriction violations
for R in All_Restrictions loop
-- Check for violation of this restriction
if Cumulative_Restrictions.Set (R)
and then Cumulative_Restrictions.Violated (R)
and then (R in Partition_Boolean_Restrictions
or else (R in All_Parameter_Restrictions
and then
Cumulative_Restrictions.Count (R) >
Cumulative_Restrictions.Value (R)))
then
Restriction_File_Output := False;
-- Loop through files looking for violators
for A2 in ALIs.First .. ALIs.Last loop
declare
T : ALIs_Record renames ALIs.Table (A2);
begin
if T.Restrictions.Violated (R) then
-- We exclude predefined files from the list of
-- violators. This should be rethought. It is not
-- clear that this is the right thing to do, that
-- is particularly the case for restricted runtimes.
if not Is_Internal_File_Name (T.Sfile) then
-- Case of Boolean restriction, just print file name
if R in All_Boolean_Restrictions then
Print_Restriction_File (R);
Error_Msg_File_1 := T.Sfile;
Consistency_Error_Msg (" {");
-- Case of Parameter restriction where violation
-- count exceeds restriction value, print file
-- name and count, adding "at least" if the
-- exact count is not known.
elsif R in Checked_Add_Parameter_Restrictions
or else T.Restrictions.Count (R) >
Cumulative_Restrictions.Value (R)
then
Print_Restriction_File (R);
Error_Msg_File_1 := T.Sfile;
Error_Msg_Nat_1 := Int (T.Restrictions.Count (R));
if T.Restrictions.Unknown (R) then
Consistency_Error_Msg
(" { (count = at least #)");
else
Consistency_Error_Msg
(" { (count = #)");
end if;
end if;
end if;
end if;
end;
end loop;
end if;
end loop;
-- Now deal with No_Dependence indications. Note that we put the loop
-- through entries in the no dependency table first, since this loop
-- is most often empty (no such pragma Restrictions in use).
for ND in No_Deps.First .. No_Deps.Last loop
declare
ND_Unit : constant Name_Id := No_Deps.Table (ND).No_Dep_Unit;
begin
for J in ALIs.First .. ALIs.Last loop
declare
A : ALIs_Record renames ALIs.Table (J);
begin
for K in A.First_Unit .. A.Last_Unit loop
declare
U : Unit_Record renames Units.Table (K);
begin
for L in U.First_With .. U.Last_With loop
if Same_Unit
(Withs.Table (L).Uname, ND_Unit)
then
Error_Msg_File_1 := U.Sfile;
Error_Msg_Name_1 := ND_Unit;
Consistency_Error_Msg
("file { violates restriction " &
"No_Dependence => %");
end if;
end loop;
end;
end loop;
end;
end loop;
end;
end loop;
end Check_Consistent_Restrictions;
------------------------------------------------------------
-- Check_Consistent_Restriction_No_Default_Initialization --
------------------------------------------------------------
-- The Restriction (No_Default_Initialization) has special consistency
-- rules. The rule is that no unit compiled without this restriction
-- that violates the restriction can WITH a unit that is compiled with
-- the restriction.
procedure Check_Consistent_Restriction_No_Default_Initialization is
begin
-- Nothing to do if no one set this restriction
if not Cumulative_Restrictions.Set (No_Default_Initialization) then
return;
end if;
-- Nothing to do if no one violates the restriction
if not Cumulative_Restrictions.Violated (No_Default_Initialization) then
return;
end if;
-- Otherwise we go into a full scan to find possible problems
for U in Units.First .. Units.Last loop
declare
UTE : Unit_Record renames Units.Table (U);
ATE : ALIs_Record renames ALIs.Table (UTE.My_ALI);
begin
if ATE.Restrictions.Violated (No_Default_Initialization) then
for W in UTE.First_With .. UTE.Last_With loop
declare
AFN : constant File_Name_Type := Withs.Table (W).Afile;
begin
-- The file name may not be present for withs of certain
-- generic run-time files. The test can be safely left
-- out in such cases anyway.
if AFN /= No_File then
declare
WAI : constant ALI_Id :=
ALI_Id (Get_Name_Table_Int (AFN));
WTE : ALIs_Record renames ALIs.Table (WAI);
begin
if WTE.Restrictions.Set
(No_Default_Initialization)
then
Error_Msg_Unit_1 := UTE.Uname;
Consistency_Error_Msg
("unit $ compiled without restriction "
& "No_Default_Initialization");
Error_Msg_Unit_1 := Withs.Table (W).Uname;
Consistency_Error_Msg
("withs unit $, compiled with restriction "
& "No_Default_Initialization");
end if;
end;
end if;
end;
end loop;
end if;
end;
end loop;
end Check_Consistent_Restriction_No_Default_Initialization;
----------------------------------
-- Check_Consistent_SSO_Default --
----------------------------------
-- This routine checks for a consistent SSO default setting. Note that
-- internal units are excluded from this check, since we don't in any
-- case allow the pragma to affect types in internal units, and there
-- is thus no requirement to recompile the run-time with the default set.
procedure Check_Consistent_SSO_Default is
Default : Character;
begin
Default := ALIs.Table (ALIs.First).SSO_Default;
-- The default must be set from a non-internal unit
pragma Assert
(not Is_Internal_File_Name (ALIs.Table (ALIs.First).Sfile));
-- Check all entries match the default above from the first entry
for A1 in ALIs.First + 1 .. ALIs.Last loop
if not Is_Internal_File_Name (ALIs.Table (A1).Sfile)
and then ALIs.Table (A1).SSO_Default /= Default
then
Default := '?';
exit;
end if;
end loop;
-- All match, return
if Default /= '?' then
return;
end if;
-- Here we have a mismatch
Consistency_Error_Msg
("files not compiled with same Default_Scalar_Storage_Order");
Write_Eol;
Write_Str ("files compiled with High_Order_First");
Write_Eol;
for A1 in ALIs.First .. ALIs.Last loop
if ALIs.Table (A1).SSO_Default = 'H' then
Write_Str (" ");
Write_Name (ALIs.Table (A1).Sfile);
Write_Eol;
end if;
end loop;
Write_Eol;
Write_Str ("files compiled with Low_Order_First");
Write_Eol;
for A1 in ALIs.First .. ALIs.Last loop
if ALIs.Table (A1).SSO_Default = 'L' then
Write_Str (" ");
Write_Name (ALIs.Table (A1).Sfile);
Write_Eol;
end if;
end loop;
Write_Eol;
Write_Str ("files compiled with no Default_Scalar_Storage_Order");
Write_Eol;
for A1 in ALIs.First .. ALIs.Last loop
if not Is_Internal_File_Name (ALIs.Table (A1).Sfile)
and then ALIs.Table (A1).SSO_Default = ' '
then
Write_Str (" ");
Write_Name (ALIs.Table (A1).Sfile);
Write_Eol;
end if;
end loop;
end Check_Consistent_SSO_Default;
---------------------------------------------------
-- Check_Consistent_Zero_Cost_Exception_Handling --
---------------------------------------------------
-- Check consistent zero cost exception handling. The rule is that
-- all units must have the same exception handling mechanism.
procedure Check_Consistent_Zero_Cost_Exception_Handling is
begin
Check_Mechanism : for A1 in ALIs.First + 1 .. ALIs.Last loop
if ALIs.Table (A1).Zero_Cost_Exceptions /=
ALIs.Table (ALIs.First).Zero_Cost_Exceptions
then
Error_Msg_File_1 := ALIs.Table (A1).Sfile;
Error_Msg_File_2 := ALIs.Table (ALIs.First).Sfile;
Consistency_Error_Msg ("{ and { compiled with different "
& "exception handling mechanisms");
end if;
end loop Check_Mechanism;
end Check_Consistent_Zero_Cost_Exception_Handling;
-------------------------------
-- Check_Duplicated_Subunits --
-------------------------------
procedure Check_Duplicated_Subunits is
begin
for J in Sdep.First .. Sdep.Last loop
if Sdep.Table (J).Subunit_Name /= No_Name then
Get_Decoded_Name_String (Sdep.Table (J).Subunit_Name);
Name_Len := Name_Len + 2;
Name_Buffer (Name_Len - 1) := '%';
-- See if there is a body or spec with the same name
for K in Boolean loop
if K then
Name_Buffer (Name_Len) := 'b';
else
Name_Buffer (Name_Len) := 's';
end if;
declare
Unit : constant Unit_Name_Type := Name_Find;
Info : constant Int := Get_Name_Table_Int (Unit);
begin
if Info /= 0 then
Set_Standard_Error;
Write_Str ("error: subunit """);
Write_Name_Decoded (Sdep.Table (J).Subunit_Name);
Write_Str (""" in file """);
Write_Name_Decoded (Sdep.Table (J).Sfile);
Write_Char ('"');
Write_Eol;
Write_Str (" has same name as unit """);
Write_Unit_Name (Units.Table (Unit_Id (Info)).Uname);
Write_Str (""" found in file """);
Write_Name_Decoded (Units.Table (Unit_Id (Info)).Sfile);
Write_Char ('"');
Write_Eol;
Write_Str (" this is not allowed within a single "
& "partition (RM 10.2(19))");
Write_Eol;
Osint.Exit_Program (Osint.E_Fatal);
end if;
end;
end loop;
end if;
end loop;
end Check_Duplicated_Subunits;
--------------------
-- Check_Versions --
--------------------
procedure Check_Versions is
VL : constant Natural := ALIs.Table (ALIs.First).Ver_Len;
begin
for A in ALIs.First .. ALIs.Last loop
if ALIs.Table (A).Ver_Len /= VL
or else ALIs.Table (A).Ver (1 .. VL) /=
ALIs.Table (ALIs.First).Ver (1 .. VL)
then
Error_Msg_File_1 := ALIs.Table (A).Sfile;
Error_Msg_File_2 := ALIs.Table (ALIs.First).Sfile;
Consistency_Error_Msg
("{ and { compiled with different GNAT versions");
end if;
end loop;
end Check_Versions;
---------------------------
-- Consistency_Error_Msg --
---------------------------
procedure Consistency_Error_Msg (Msg : String) is
begin
if Tolerate_Consistency_Errors then
-- If consistency errors are tolerated,
-- output the message as a warning.
Error_Msg ('?' & Msg);
-- Otherwise the consistency error is a true error
else
Error_Msg (Msg);
end if;
end Consistency_Error_Msg;
---------------
-- Same_Unit --
---------------
function Same_Unit (U1 : Unit_Name_Type; U2 : Name_Id) return Boolean is
begin
-- Note, the string U1 has a terminating %s or %b, U2 does not
if Length_Of_Name (U1) - 2 = Length_Of_Name (U2) then
Get_Name_String (U1);
declare
U1_Str : constant String := Name_Buffer (1 .. Name_Len - 2);
begin
Get_Name_String (U2);
return U1_Str = Name_Buffer (1 .. Name_Len);
end;
else
return False;
end if;
end Same_Unit;
end Bcheck;