1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 with Atree; use Atree;
27 with Back_End; use Back_End;
30 with Csets; use Csets;
31 with Debug; use Debug;
33 with Errout; use Errout;
36 with Fname; use Fname;
37 with Fname.UF; use Fname.UF;
40 with Gnatvsn; use Gnatvsn;
43 with Lib.Writ; use Lib.Writ;
45 with Namet; use Namet;
48 with Osint; use Osint;
49 with Osint.C; use Osint.C;
50 with Output; use Output;
53 with Repinfo; use Repinfo;
55 with Rident; use Rident;
66 with Sinfo; use Sinfo;
67 with Sinput.L; use Sinput.L;
69 with Sprint; use Sprint;
71 with Stylesw; use Stylesw;
72 with Targparm; use Targparm;
75 with Treepr; use Treepr;
77 with Types; use Types;
78 with Uintp; use Uintp;
79 with Uname; use Uname;
82 with Validsw; use Validsw;
84 with System.Assertions;
92 procedure Adjust_Global_Switches;
93 -- There are various interactions between front-end switch settings,
94 -- including debug switch settings and target dependent parameters.
95 -- This procedure takes care of properly handling these interactions.
96 -- We do it after scanning out all the switches, so that we are not
97 -- depending on the order in which switches appear.
99 procedure Check_Bad_Body (Unit_Node : Node_Id; Unit_Kind : Node_Kind);
100 -- Called to check whether a unit described by its compilation unit node
101 -- and kind has a bad body.
103 procedure Check_Rep_Info;
104 -- Called when we are not generating code, to check if -gnatR was requested
105 -- and if so, explain that we will not be honoring the request.
107 procedure Post_Compilation_Validation_Checks;
108 -- This procedure performs various validation checks that have to be left
109 -- to the end of the compilation process, after generating code but before
110 -- issuing error messages. In particular, these checks generally require
111 -- the information provided by the back end in back annotation of declared
112 -- entities (e.g. actual size and alignment values chosen by the back end).
114 ----------------------------
115 -- Adjust_Global_Switches --
116 ----------------------------
118 procedure Adjust_Global_Switches is
120 -- -gnatd.M enables Relaxed_RM_Semantics
122 if Debug_Flag_Dot_MM then
123 Relaxed_RM_Semantics := True;
126 -- -gnatd.1 enables unnesting of subprograms
128 if Debug_Flag_Dot_1 then
129 Unnest_Subprogram_Mode := True;
132 -- -gnatd.u enables special C expansion mode
134 if Debug_Flag_Dot_U then
135 Modify_Tree_For_C := True;
138 -- Set all flags required when generating C code
140 if Generate_C_Code then
141 Modify_Tree_For_C := True;
142 Unnest_Subprogram_Mode := True;
143 Minimize_Expression_With_Actions := True;
145 -- Set operating mode to Generate_Code to benefit from full front-end
146 -- expansion (e.g. generics).
148 Operating_Mode := Generate_Code;
150 -- Suppress alignment checks since we do not have access to alignment
151 -- info on the target.
153 Suppress_Options.Suppress (Alignment_Check) := False;
156 -- -gnatd.E sets Error_To_Warning mode, causing selected error messages
157 -- to be treated as warnings instead of errors.
159 if Debug_Flag_Dot_EE then
160 Error_To_Warning := True;
163 -- Disable CodePeer_Mode in Check_Syntax, since we need front-end
166 if Operating_Mode = Check_Syntax then
167 CodePeer_Mode := False;
170 -- Set ASIS mode if -gnatt and -gnatc are set
172 if Operating_Mode = Check_Semantics and then Tree_Output then
175 -- Set ASIS GNSA mode if -gnatd.H is set
177 if Debug_Flag_Dot_HH then
178 ASIS_GNSA_Mode := True;
181 -- Turn off inlining in ASIS mode, since ASIS cannot handle the extra
182 -- information in the trees caused by inlining being active.
184 -- More specifically, the tree seems to be malformed from the ASIS
185 -- point of view if -gnatc and -gnatn appear together???
187 Inline_Active := False;
189 -- Turn off SCIL generation and CodePeer mode in semantics mode,
190 -- since SCIL requires front-end expansion.
192 Generate_SCIL := False;
193 CodePeer_Mode := False;
196 -- SCIL mode needs to disable front-end inlining since the generated
197 -- trees (in particular order and consistency between specs compiled
198 -- as part of a main unit or as part of a with-clause) are causing
201 if Generate_SCIL then
202 Front_End_Inlining := False;
205 -- Tune settings for optimal SCIL generation in CodePeer mode
207 if CodePeer_Mode then
209 -- Turn off gnatprove mode (which can be set via e.g. -gnatd.F), not
210 -- compatible with CodePeer mode.
212 GNATprove_Mode := False;
213 Debug_Flag_Dot_FF := False;
215 -- Turn off C tree generation, not compatible with CodePeer mode. We
216 -- do not expect this to happen in normal use, since both modes are
217 -- enabled by special tools, but it is useful to turn off these flags
218 -- this way when we are doing CodePeer tests on existing test suites
219 -- that may have -gnateg set, to avoid the need for special casing.
221 Modify_Tree_For_C := False;
222 Generate_C_Code := False;
223 Unnest_Subprogram_Mode := False;
225 -- Turn off inlining, confuses CodePeer output and gains nothing
227 Front_End_Inlining := False;
228 Inline_Active := False;
230 -- Disable front-end optimizations, to keep the tree as close to the
231 -- source code as possible, and also to avoid inconsistencies between
232 -- trees when using different optimization switches.
234 Optimization_Level := 0;
236 -- Enable some restrictions systematically to simplify the generated
237 -- code (and ease analysis). Note that restriction checks are also
238 -- disabled in CodePeer mode, see Restrict.Check_Restriction, and
239 -- user specified Restrictions pragmas are ignored, see
240 -- Sem_Prag.Process_Restrictions_Or_Restriction_Warnings.
242 Restrict.Restrictions.Set (No_Exception_Registration) := True;
243 Restrict.Restrictions.Set (No_Initialize_Scalars) := True;
244 Restrict.Restrictions.Set (No_Task_Hierarchy) := True;
245 Restrict.Restrictions.Set (No_Abort_Statements) := True;
246 Restrict.Restrictions.Set (Max_Asynchronous_Select_Nesting) := True;
247 Restrict.Restrictions.Value (Max_Asynchronous_Select_Nesting) := 0;
249 -- Suppress division by zero and access checks since they are handled
250 -- implicitly by CodePeer.
252 -- Turn off dynamic elaboration checks: generates inconsistencies in
253 -- trees between specs compiled as part of a main unit or as part of
256 -- Turn off alignment checks: these cannot be proved statically by
257 -- CodePeer and generate false positives.
259 -- Enable all other language checks
261 Suppress_Options.Suppress :=
262 (Alignment_Check => True,
263 Division_Check => True,
264 Elaboration_Check => True,
267 Dynamic_Elaboration_Checks := False;
269 -- Set STRICT mode for overflow checks if not set explicitly. This
270 -- prevents suppressing of overflow checks by default, in code down
273 if Suppress_Options.Overflow_Mode_General = Not_Set then
274 Suppress_Options.Overflow_Mode_General := Strict;
275 Suppress_Options.Overflow_Mode_Assertions := Strict;
278 -- CodePeer handles division and overflow checks directly, based on
279 -- the marks set by the frontend, hence no special expansion should
280 -- be performed in the frontend for division and overflow checks.
282 Backend_Divide_Checks_On_Target := True;
283 Backend_Overflow_Checks_On_Target := True;
285 -- Kill debug of generated code, since it messes up sloc values
287 Debug_Generated_Code := False;
289 -- Turn cross-referencing on in case it was disabled (e.g. by -gnatD)
290 -- to support source navigation.
294 -- Polling mode forced off, since it generates confusing junk
296 Polling_Required := False;
298 -- Set operating mode to Generate_Code to benefit from full front-end
299 -- expansion (e.g. generics).
301 Operating_Mode := Generate_Code;
303 -- We need SCIL generation of course
305 Generate_SCIL := True;
307 -- Enable assertions, since they give CodePeer valuable extra info
309 Assertions_Enabled := True;
311 -- Set normal RM validity checking and checking of copies (to catch
312 -- e.g. wrong values used in unchecked conversions).
313 -- All other validity checking is turned off, since this can generate
314 -- very complex trees that only confuse CodePeer and do not bring
315 -- enough useful info.
317 Reset_Validity_Check_Options;
318 Validity_Check_Default := True;
319 Validity_Check_Copies := True;
321 -- Turn off style check options and ignore any style check pragmas
322 -- since we are not interested in any front-end warnings when we are
323 -- getting CodePeer output.
325 Reset_Style_Check_Options;
326 Ignore_Style_Checks_Pragmas := True;
328 -- Always perform semantics and generate ali files in CodePeer mode,
329 -- so that a gnatmake -c -k will proceed further when possible.
331 Force_ALI_Tree_File := True;
332 Try_Semantics := True;
334 -- Make the Ada front end more liberal so that the compiler will
335 -- allow illegal code that is allowed by other compilers. CodePeer
336 -- is in the business of finding problems, not enforcing rules.
337 -- This is useful when using CodePeer mode with other compilers.
339 Relaxed_RM_Semantics := True;
341 -- Disable all simple value propagation. This is an optimization
342 -- which is valuable for code optimization, and also for generation
343 -- of compiler warnings, but these are being turned off by default,
344 -- and CodePeer generates better messages (referencing original
345 -- variables) this way.
346 -- Do this only if -gnatws is set (the default with -gnatcC), so that
347 -- if warnings are enabled, we'll get better messages from GNAT.
349 if Warning_Mode = Suppress then
350 Debug_Flag_MM := True;
354 -- Enable some individual switches that are implied by relaxed RM
357 if Relaxed_RM_Semantics then
358 Opt.Allow_Integer_Address := True;
359 Overriding_Renamings := True;
360 Treat_Categorization_Errors_As_Warnings := True;
363 -- Enable GNATprove_Mode when using -gnatd.F switch
365 if Debug_Flag_Dot_FF then
366 GNATprove_Mode := True;
369 -- GNATprove_Mode is also activated by default in the gnat2why
372 if GNATprove_Mode then
374 -- Turn off inlining, which would confuse formal verification output
377 Front_End_Inlining := False;
378 Inline_Active := False;
380 -- Issue warnings for failure to inline subprograms, as otherwise
381 -- expected in GNATprove mode for the local subprograms without
384 Ineffective_Inline_Warnings := True;
386 -- Disable front-end optimizations, to keep the tree as close to the
387 -- source code as possible, and also to avoid inconsistencies between
388 -- trees when using different optimization switches.
390 Optimization_Level := 0;
392 -- Enable some restrictions systematically to simplify the generated
393 -- code (and ease analysis).
395 Restrict.Restrictions.Set (No_Initialize_Scalars) := True;
397 -- Note: at this point we used to suppress various checks, but that
398 -- is not what we want. We need the semantic processing for these
399 -- checks (which will set flags like Do_Overflow_Check, showing the
400 -- points at which potential checks are required semantically). We
401 -- don't want the expansion associated with these checks, but that
402 -- happens anyway because this expansion is simply not done in the
403 -- SPARK version of the expander.
405 -- On the contrary, we need to enable explicitly all language checks,
406 -- as they may have been suppressed by the use of switch -gnatp.
408 Suppress_Options.Suppress := (others => False);
410 -- Detect overflow on unconstrained floating-point types, such as
411 -- the predefined types Float, Long_Float and Long_Long_Float from
412 -- package Standard. Not necessary if float overflows are checked
413 -- (Machine_Overflow true), since appropriate Do_Overflow_Check flags
414 -- will be set in any case.
416 Check_Float_Overflow := not Machine_Overflows_On_Target;
418 -- Set STRICT mode for overflow checks if not set explicitly. This
419 -- prevents suppressing of overflow checks by default, in code down
422 if Suppress_Options.Overflow_Mode_General = Not_Set then
423 Suppress_Options.Overflow_Mode_General := Strict;
424 Suppress_Options.Overflow_Mode_Assertions := Strict;
427 -- Kill debug of generated code, since it messes up sloc values
429 Debug_Generated_Code := False;
431 -- Turn cross-referencing on in case it was disabled (e.g. by -gnatD)
432 -- as it is needed for computing effects of subprograms in the formal
433 -- verification backend.
437 -- Polling mode forced off, since it generates confusing junk
439 Polling_Required := False;
441 -- Set operating mode to Check_Semantics, but a light front-end
442 -- expansion is still performed.
444 Operating_Mode := Check_Semantics;
446 -- Enable assertions, since they give valuable extra information for
447 -- formal verification.
449 Assertions_Enabled := True;
451 -- Disable validity checks, since it generates code raising
452 -- exceptions for invalid data, which confuses GNATprove. Invalid
453 -- data is directly detected by GNATprove's flow analysis.
455 Validity_Checks_On := False;
457 -- Turn off style check options since we are not interested in any
458 -- front-end warnings when we are getting SPARK output.
460 Reset_Style_Check_Options;
462 -- Suppress the generation of name tables for enumerations, which are
463 -- not needed for formal verification, and fall outside the SPARK
464 -- subset (use of pointers).
466 Global_Discard_Names := True;
468 -- Suppress the expansion of tagged types and dispatching calls,
469 -- which lead to the generation of non-SPARK code (use of pointers),
470 -- which is more complex to formally verify than the original source.
472 Tagged_Type_Expansion := False;
475 -- Set Configurable_Run_Time mode if system.ads flag set or if the
476 -- special debug flag -gnatdY is set.
478 if Targparm.Configurable_Run_Time_On_Target or Debug_Flag_YY then
479 Configurable_Run_Time_Mode := True;
482 -- Set -gnatR3m mode if debug flag A set
484 if Debug_Flag_AA then
485 Back_Annotate_Rep_Info := True;
486 List_Representation_Info := 1;
487 List_Representation_Info_Mechanisms := True;
490 -- Force Target_Strict_Alignment true if debug flag -gnatd.a is set
492 if Debug_Flag_Dot_A then
493 Ttypes.Target_Strict_Alignment := True;
496 -- Increase size of allocated entities if debug flag -gnatd.N is set
498 if Debug_Flag_Dot_NN then
499 Atree.Num_Extension_Nodes := Atree.Num_Extension_Nodes + 1;
502 -- Disable static allocation of dispatch tables if -gnatd.t or if layout
503 -- is enabled. The front end's layout phase currently treats types that
504 -- have discriminant-dependent arrays as not being static even when a
505 -- discriminant constraint on the type is static, and this leads to
506 -- problems with subtypes of type Ada.Tags.Dispatch_Table_Wrapper. ???
508 if Debug_Flag_Dot_T or else Frontend_Layout_On_Target then
509 Static_Dispatch_Tables := False;
512 -- Flip endian mode if -gnatd8 set
515 Ttypes.Bytes_Big_Endian := not Ttypes.Bytes_Big_Endian;
518 -- Activate front-end layout if debug flag -gnatdF is set
520 if Debug_Flag_FF then
521 Targparm.Frontend_Layout_On_Target := True;
524 -- Set and check exception mechanism. This is only meaningful when
525 -- compiling, and in particular not meaningful for special modes used
526 -- for program analysis rather than compilation: ASIS mode, CodePeer
527 -- mode and GNATprove mode.
529 if Operating_Mode = Generate_Code
530 and then not (ASIS_Mode or CodePeer_Mode or GNATprove_Mode)
532 case Targparm.Frontend_Exceptions_On_Target is
534 case Targparm.ZCX_By_Default_On_Target is
537 ("Run-time library configured incorrectly");
539 ("(requesting support for Frontend ZCX exceptions)");
540 raise Unrecoverable_Error;
542 Exception_Mechanism := Front_End_SJLJ;
545 case Targparm.ZCX_By_Default_On_Target is
547 Exception_Mechanism := Back_End_ZCX;
549 Exception_Mechanism := Back_End_SJLJ;
554 -- Set proper status for overflow check mechanism
556 -- If already set (by -gnato or above in SPARK or CodePeer mode) then we
557 -- have nothing to do.
559 if Opt.Suppress_Options.Overflow_Mode_General /= Not_Set then
562 -- Otherwise set overflow mode defaults
565 -- Overflow checks are on by default (Suppress set False) except in
566 -- GNAT_Mode, where we want them off by default (we are not ready to
567 -- enable overflow checks in the compiler yet, for one thing the case
568 -- of 64-bit checks needs System.Arith_64 which is not a compiler
569 -- unit and it is a pain to try to include it in the compiler.
571 Suppress_Options.Suppress (Overflow_Check) := GNAT_Mode;
573 -- Set appropriate default overflow handling mode. Note: at present
574 -- we set STRICT in all three of the following cases. They are
575 -- separated because in the future we may make different choices.
577 -- By default set STRICT mode if -gnatg in effect
580 Suppress_Options.Overflow_Mode_General := Strict;
581 Suppress_Options.Overflow_Mode_Assertions := Strict;
583 -- If we have backend divide and overflow checks, then by default
584 -- overflow checks are STRICT. Historically this code used to also
585 -- activate overflow checks, although no target currently has these
586 -- flags set, so this was dead code anyway.
588 elsif Targparm.Backend_Divide_Checks_On_Target
590 Targparm.Backend_Overflow_Checks_On_Target
592 Suppress_Options.Overflow_Mode_General := Strict;
593 Suppress_Options.Overflow_Mode_Assertions := Strict;
595 -- Otherwise for now, default is STRICT mode. This may change in the
596 -- future, but for now this is the compatible behavior with previous
600 Suppress_Options.Overflow_Mode_General := Strict;
601 Suppress_Options.Overflow_Mode_Assertions := Strict;
605 -- Set default for atomic synchronization. As this synchronization
606 -- between atomic accesses can be expensive, and not typically needed
607 -- on some targets, an optional target parameter can turn the option
608 -- off. Note Atomic Synchronization is implemented as check.
610 Suppress_Options.Suppress (Atomic_Synchronization) :=
611 not Atomic_Sync_Default_On_Target;
613 -- Set default for Alignment_Check, if we are on a machine with non-
614 -- strict alignment, then we suppress this check, since it is over-
615 -- zealous for such machines.
617 if not Ttypes.Target_Strict_Alignment then
618 Suppress_Options.Suppress (Alignment_Check) := True;
621 -- Set switch indicating if back end can handle limited types, and
622 -- guarantee that no incorrect copies are made (e.g. in the context
623 -- of an if or case expression).
625 -- Debug flag -gnatd.L decisively sets usage on
627 if Debug_Flag_Dot_LL then
628 Back_End_Handles_Limited_Types := True;
630 -- If no debug flag, usage off for SCIL cases
632 elsif Generate_SCIL then
633 Back_End_Handles_Limited_Types := False;
635 -- Otherwise normal gcc back end, for now still turn flag off by
636 -- default, since there are unresolved problems in the front end.
639 Back_End_Handles_Limited_Types := False;
642 -- If the inlining level has not been set by the user, compute it from
643 -- the optimization level: 1 at -O1/-O2 (and -Os), 2 at -O3 and above.
645 if Inline_Level = 0 then
646 if Optimization_Level < 3 then
653 -- Treat -gnatn as equivalent to -gnatN for non-GCC targets
655 if Inline_Active and not Front_End_Inlining then
657 -- We really should have a tag for this, what if we added a new
658 -- back end some day, it would not be true for this test, but it
659 -- would be non-GCC, so this is a bit troublesome ???
661 Front_End_Inlining := Generate_C_Code;
664 -- Set back-end inlining indication
668 -- No back-end inlining available on C generation
672 -- No back-end inlining in GNATprove mode, since it just confuses
673 -- the formal verification process.
675 and then not GNATprove_Mode
677 -- No back-end inlining if front-end inlining explicitly enabled.
678 -- Done to minimize the output differences to customers still using
679 -- this deprecated switch; in addition, this behavior reduces the
680 -- output differences in old tests.
682 and then not Front_End_Inlining
684 -- Back-end inlining is disabled if debug flag .z is set
686 and then not Debug_Flag_Dot_Z;
688 -- Output warning if -gnateE specified and cannot be supported
690 if Exception_Extra_Info
691 and then Restrict.No_Exception_Handlers_Set
695 ("warning: extra exception information (-gnateE) was specified");
698 ("warning: this capability is not available in this configuration");
703 -- Finally capture adjusted value of Suppress_Options as the initial
704 -- value for Scope_Suppress, which will be modified as we move from
705 -- scope to scope (by Suppress/Unsuppress/Overflow_Checks pragmas).
707 Sem.Scope_Suppress := Opt.Suppress_Options;
708 end Adjust_Global_Switches;
714 procedure Check_Bad_Body (Unit_Node : Node_Id; Unit_Kind : Node_Kind) is
715 Fname : File_Name_Type;
717 procedure Bad_Body_Error (Msg : String);
718 -- Issue message for bad body found
724 procedure Bad_Body_Error (Msg : String) is
726 Error_Msg_N (Msg, Unit_Node);
727 Error_Msg_File_1 := Fname;
728 Error_Msg_N ("remove incorrect body in file{!", Unit_Node);
733 Sname : Unit_Name_Type;
734 Src_Ind : Source_File_Index;
736 -- Start of processing for Check_Bad_Body
739 -- Nothing to do if we are only checking syntax, because we don't know
740 -- enough to know if we require or forbid a body in this case.
742 if Operating_Mode = Check_Syntax then
746 -- Check for body not allowed
748 if (Unit_Kind = N_Package_Declaration
749 and then not Body_Required (Unit_Node))
750 or else (Unit_Kind = N_Generic_Package_Declaration
751 and then not Body_Required (Unit_Node))
752 or else Unit_Kind = N_Package_Renaming_Declaration
753 or else Unit_Kind = N_Subprogram_Renaming_Declaration
754 or else Nkind (Original_Node (Unit (Unit_Node)))
755 in N_Generic_Instantiation
757 Sname := Unit_Name (Main_Unit);
759 -- If we do not already have a body name, then get the body name
761 if not Is_Body_Name (Sname) then
762 Sname := Get_Body_Name (Sname);
765 Fname := Get_File_Name (Sname, Subunit => False);
766 Src_Ind := Load_Source_File (Fname);
768 -- Case where body is present and it is not a subunit. Exclude the
769 -- subunit case, because it has nothing to do with the package we are
770 -- compiling. It is illegal for a child unit and a subunit with the
771 -- same expanded name (RM 10.2(9)) to appear together in a partition,
772 -- but there is nothing to stop a compilation environment from having
773 -- both, and the test here simply allows that. If there is an attempt
774 -- to include both in a partition, this is diagnosed at bind time. In
775 -- Ada 83 mode this is not a warning case.
777 -- Note that in general we do not give the message if the file in
778 -- question does not look like a body. This includes weird cases,
779 -- but in particular means that if the file is just a No_Body pragma,
780 -- then we won't give the message (that's the whole point of this
781 -- pragma, to be used this way and to cause the body file to be
782 -- ignored in this context).
784 if Src_Ind /= No_Source_File
785 and then Source_File_Is_Body (Src_Ind)
787 Errout.Finalize (Last_Call => False);
789 Error_Msg_Unit_1 := Sname;
791 -- Ada 83 case of a package body being ignored. This is not an
792 -- error as far as the Ada 83 RM is concerned, but it is almost
793 -- certainly not what is wanted so output a warning. Give this
794 -- message only if there were no errors, since otherwise it may
795 -- be incorrect (we may have misinterpreted a junk spec as not
796 -- needing a body when it really does).
798 if Unit_Kind = N_Package_Declaration
799 and then Ada_Version = Ada_83
800 and then Operating_Mode = Generate_Code
801 and then Distribution_Stub_Mode /= Generate_Caller_Stub_Body
802 and then not Compilation_Errors
805 ("package $$ does not require a body??", Unit_Node);
806 Error_Msg_File_1 := Fname;
807 Error_Msg_N ("body in file{ will be ignored??", Unit_Node);
809 -- Ada 95 cases of a body file present when no body is
810 -- permitted. This we consider to be an error.
813 -- For generic instantiations, we never allow a body
815 if Nkind (Original_Node (Unit (Unit_Node))) in
816 N_Generic_Instantiation
819 ("generic instantiation for $$ does not allow a body");
821 -- A library unit that is a renaming never allows a body
823 elsif Unit_Kind in N_Renaming_Declaration then
825 ("renaming declaration for $$ does not allow a body!");
827 -- Remaining cases are packages and generic packages. Here
828 -- we only do the test if there are no previous errors,
829 -- because if there are errors, they may lead us to
830 -- incorrectly believe that a package does not allow a
831 -- body when in fact it does.
833 elsif not Compilation_Errors then
834 if Unit_Kind = N_Package_Declaration then
836 ("package $$ does not allow a body!");
838 elsif Unit_Kind = N_Generic_Package_Declaration then
840 ("generic package $$ does not allow a body!");
853 procedure Check_Rep_Info is
855 if List_Representation_Info /= 0
856 or else List_Representation_Info_Mechanisms
861 ("cannot generate representation information, no code generated");
868 ----------------------------------------
869 -- Post_Compilation_Validation_Checks --
870 ----------------------------------------
872 procedure Post_Compilation_Validation_Checks is
874 -- Validate alignment check warnings. In some cases we generate warnings
875 -- about possible alignment errors because we don't know the alignment
876 -- that will be chosen by the back end. This routine is in charge of
877 -- getting rid of those warnings if we can tell they are not needed.
879 Checks.Validate_Alignment_Check_Warnings;
881 -- Validate compile time warnings and errors (using the values for size
882 -- and alignment annotated by the backend where possible). We need to
883 -- unlock temporarily these tables to reanalyze their expression.
888 Sem_Ch13.Validate_Compile_Time_Warning_Errors;
893 -- Validate unchecked conversions (using the values for size and
894 -- alignment annotated by the backend where possible).
896 Sem_Ch13.Validate_Unchecked_Conversions;
898 -- Validate address clauses (again using alignment values annotated
899 -- by the backend where possible).
901 Sem_Ch13.Validate_Address_Clauses;
903 -- Validate independence pragmas (again using values annotated by the
904 -- back end for component layout where possible) but only for non-GCC
905 -- back ends, as this is done a priori for GCC back ends.
907 if AAMP_On_Target then
908 Sem_Ch13.Validate_Independence;
910 end Post_Compilation_Validation_Checks;
914 Back_End_Mode : Back_End.Back_End_Mode_Type;
916 Main_Unit_Kind : Node_Kind;
917 -- Kind of main compilation unit node
919 Main_Unit_Node : Node_Id;
920 -- Compilation unit node for main unit
922 -- Start of processing for Gnat1drv
925 -- This inner block is set up to catch assertion errors and constraint
926 -- errors. Since the code for handling these errors can cause another
927 -- exception to be raised (namely Unrecoverable_Error), we need two
928 -- nested blocks, so that the outer one handles unrecoverable error.
931 -- Initialize all packages. For the most part, these initialization
932 -- calls can be made in any order. Exceptions are as follows:
934 -- Lib.Initialize need to be called before Scan_Compiler_Arguments,
935 -- because it initializes a table filled by Scan_Compiler_Arguments.
941 Scan_Compiler_Arguments;
942 Osint.Add_Default_Search_Dirs;
963 Sem_Type.Init_Interp_Tables;
965 -- Capture compilation date and time
967 Opt.Compilation_Time := System.OS_Lib.Current_Time_String;
969 -- Get the target parameters only when -gnats is not used, to avoid
970 -- failing when there is no default runtime.
972 if Operating_Mode /= Check_Syntax then
974 -- Acquire target parameters from system.ads (package System source)
976 Targparm_Acquire : declare
979 S : Source_File_Index;
983 Name_Buffer (1 .. 10) := "system.ads";
986 S := Load_Source_File (N);
988 -- Failed to read system.ads, fatal error
990 if S = No_Source_File then
992 ("fatal error, run-time library not installed correctly");
993 Write_Line ("cannot locate file system.ads");
994 raise Unrecoverable_Error;
996 -- Read system.ads successfully, remember its source index
999 System_Source_File_Index := S;
1002 -- Call to get target parameters. Note that the actual interface
1003 -- routines are in Tbuild. They can't be in this procedure because
1004 -- of accessibility issues.
1006 Targparm.Get_Target_Parameters
1007 (System_Text => Source_Text (S),
1008 Source_First => Source_First (S),
1009 Source_Last => Source_Last (S),
1010 Make_Id => Tbuild.Make_Id'Access,
1011 Make_SC => Tbuild.Make_SC'Access,
1012 Set_NOD => Tbuild.Set_NOD'Access,
1013 Set_NSA => Tbuild.Set_NSA'Access,
1014 Set_NUA => Tbuild.Set_NUA'Access,
1015 Set_NUP => Tbuild.Set_NUP'Access);
1017 -- Acquire configuration pragma information from Targparm
1019 Restrict.Restrictions := Targparm.Restrictions_On_Target;
1020 end Targparm_Acquire;
1023 -- Perform various adjustments and settings of global switches
1025 Adjust_Global_Switches;
1027 -- Output copyright notice if full list mode unless we have a list
1028 -- file, in which case we defer this so that it is output in the file.
1030 if (Verbose_Mode or else (Full_List and then Full_List_File_Name = null))
1032 -- Debug flag gnatd7 suppresses this copyright notice
1034 and then not Debug_Flag_7
1037 Write_Str ("GNAT ");
1038 Write_Str (Gnat_Version_String);
1040 Write_Str ("Copyright 1992-" & Current_Year
1041 & ", Free Software Foundation, Inc.");
1045 -- Check we do not have more than one source file, this happens only in
1046 -- the case where the driver is called directly, it cannot happen when
1047 -- gnat1 is invoked from gcc in the normal case.
1049 if Osint.Number_Of_Files /= 1 then
1052 Osint.Fail ("you must provide one source file");
1054 elsif Usage_Requested then
1058 -- Generate target dependent output file if requested
1060 if Target_Dependent_Info_Write_Name /= null then
1061 Set_Targ.Write_Target_Dependent_Values;
1064 -- Call the front end
1066 Original_Operating_Mode := Operating_Mode;
1069 -- In GNATprove mode, force loading of System unit to ensure that
1070 -- System.Interrupt_Priority is available to GNATprove for the
1071 -- generation of VCs related to ceiling priority.
1073 if GNATprove_Mode then
1075 Unused_E : constant Entity_Id :=
1076 Rtsfind.RTE (Rtsfind.RE_Interrupt_Priority);
1082 -- Exit with errors if the main source could not be parsed
1084 if Sinput.Main_Source_File = No_Source_File then
1085 Errout.Finalize (Last_Call => True);
1086 Errout.Output_Messages;
1087 Exit_Program (E_Errors);
1090 Main_Unit_Node := Cunit (Main_Unit);
1091 Main_Unit_Kind := Nkind (Unit (Main_Unit_Node));
1093 Check_Bad_Body (Main_Unit_Node, Main_Unit_Kind);
1095 -- In CodePeer mode we always delete old SCIL files before regenerating
1096 -- new ones, in case of e.g. errors, and also to remove obsolete scilx
1097 -- files generated by CodePeer itself.
1099 if CodePeer_Mode then
1100 Comperr.Delete_SCIL_Files;
1103 -- Ditto for old C files before regenerating new ones
1105 if Generate_C_Code then
1110 -- Exit if compilation errors detected
1112 Errout.Finalize (Last_Call => False);
1114 if Compilation_Errors then
1116 Post_Compilation_Validation_Checks;
1117 Errout.Output_Messages;
1120 -- Generate ALI file if specially requested
1122 if Opt.Force_ALI_Tree_File then
1123 Write_ALI (Object => False);
1127 Errout.Finalize (Last_Call => True);
1128 Exit_Program (E_Errors);
1131 -- Set Generate_Code on main unit and its spec. We do this even if are
1132 -- not generating code, since Lib-Writ uses this to determine which
1133 -- units get written in the ali file.
1135 Set_Generate_Code (Main_Unit);
1137 -- If we have a corresponding spec, and it comes from source or it is
1138 -- not a generated spec for a child subprogram body, then we need object
1139 -- code for the spec unit as well.
1141 if Nkind (Unit (Main_Unit_Node)) in N_Unit_Body
1142 and then not Acts_As_Spec (Main_Unit_Node)
1144 if Nkind (Unit (Main_Unit_Node)) = N_Subprogram_Body
1145 and then not Comes_From_Source (Library_Unit (Main_Unit_Node))
1150 (Get_Cunit_Unit_Number (Library_Unit (Main_Unit_Node)));
1154 -- Case of no code required to be generated, exit indicating no error
1156 if Original_Operating_Mode = Check_Syntax then
1158 Errout.Finalize (Last_Call => True);
1159 Errout.Output_Messages;
1164 -- Use a goto instead of calling Exit_Program so that finalization
1167 goto End_Of_Program;
1169 elsif Original_Operating_Mode = Check_Semantics then
1170 Back_End_Mode := Declarations_Only;
1172 -- All remaining cases are cases in which the user requested that code
1173 -- be generated (i.e. no -gnatc or -gnats switch was used). Check if we
1174 -- can in fact satisfy this request.
1176 -- Cannot generate code if someone has turned off code generation for
1177 -- any reason at all. We will try to figure out a reason below.
1179 elsif Operating_Mode /= Generate_Code then
1180 Back_End_Mode := Skip;
1182 -- We can generate code for a subprogram body unless there were missing
1183 -- subunits. Note that we always generate code for all generic units (a
1184 -- change from some previous versions of GNAT).
1186 elsif Main_Unit_Kind = N_Subprogram_Body
1187 and then not Subunits_Missing
1189 Back_End_Mode := Generate_Object;
1191 -- We can generate code for a package body unless there are subunits
1192 -- missing (note that we always generate code for generic units, which
1193 -- is a change from some earlier versions of GNAT).
1195 elsif Main_Unit_Kind = N_Package_Body and then not Subunits_Missing then
1196 Back_End_Mode := Generate_Object;
1198 -- We can generate code for a package declaration or a subprogram
1199 -- declaration only if it does not required a body.
1201 elsif Nkind_In (Main_Unit_Kind, N_Package_Declaration,
1202 N_Subprogram_Declaration)
1204 (not Body_Required (Main_Unit_Node)
1205 or else Distribution_Stub_Mode = Generate_Caller_Stub_Body)
1207 Back_End_Mode := Generate_Object;
1209 -- We can generate code for a generic package declaration of a generic
1210 -- subprogram declaration only if does not require a body.
1212 elsif Nkind_In (Main_Unit_Kind, N_Generic_Package_Declaration,
1213 N_Generic_Subprogram_Declaration)
1214 and then not Body_Required (Main_Unit_Node)
1216 Back_End_Mode := Generate_Object;
1218 -- Compilation units that are renamings do not require bodies, so we can
1219 -- generate code for them.
1221 elsif Nkind_In (Main_Unit_Kind, N_Package_Renaming_Declaration,
1222 N_Subprogram_Renaming_Declaration)
1224 Back_End_Mode := Generate_Object;
1226 -- Compilation units that are generic renamings do not require bodies
1227 -- so we can generate code for them.
1229 elsif Main_Unit_Kind in N_Generic_Renaming_Declaration then
1230 Back_End_Mode := Generate_Object;
1232 -- It is not an error to analyze in CodePeer mode a spec which requires
1233 -- a body, in order to generate SCIL for this spec.
1234 -- Ditto for Generate_C_Code mode and generate a C header for a spec.
1236 elsif CodePeer_Mode or Generate_C_Code then
1237 Back_End_Mode := Generate_Object;
1239 -- It is not an error to analyze in GNATprove mode a spec which requires
1240 -- a body, when the body is not available. During frame condition
1241 -- generation, the corresponding ALI file is generated. During
1242 -- analysis, the spec is analyzed.
1244 elsif GNATprove_Mode then
1245 Back_End_Mode := Declarations_Only;
1247 -- In all other cases (specs which have bodies, generics, and bodies
1248 -- where subunits are missing), we cannot generate code and we generate
1249 -- a warning message. Note that generic instantiations are gone at this
1250 -- stage since they have been replaced by their instances.
1253 Back_End_Mode := Skip;
1256 -- At this stage Back_End_Mode is set to indicate if the backend should
1257 -- be called to generate code. If it is Skip, then code generation has
1258 -- been turned off, even though code was requested by the original
1259 -- command. This is not an error from the user point of view, but it is
1260 -- an error from the point of view of the gcc driver, so we must exit
1261 -- with an error status.
1263 -- We generate an informative message (from the gcc point of view, it
1264 -- is an error message, but from the users point of view this is not an
1265 -- error, just a consequence of compiling something that cannot
1268 if Back_End_Mode = Skip then
1270 -- An ignored Ghost unit is rewritten into a null statement because
1271 -- it must not produce an ALI or object file. Do not emit any errors
1272 -- related to code generation because the unit does not exist.
1274 if Main_Unit_Kind = N_Null_Statement
1275 and then Is_Ignored_Ghost_Node
1276 (Original_Node (Unit (Main_Unit_Node)))
1280 -- Otherwise the unit is missing a crucial piece that prevents code
1285 Write_Str ("cannot generate code for file ");
1286 Write_Name (Unit_File_Name (Main_Unit));
1288 if Subunits_Missing then
1289 Write_Str (" (missing subunits)");
1292 -- Force generation of ALI file, for backward compatibility
1294 Opt.Force_ALI_Tree_File := True;
1296 elsif Main_Unit_Kind = N_Subunit then
1297 Write_Str (" (subunit)");
1300 -- Force generation of ALI file, for backward compatibility
1302 Opt.Force_ALI_Tree_File := True;
1304 elsif Main_Unit_Kind = N_Subprogram_Declaration then
1305 Write_Str (" (subprogram spec)");
1308 -- Generic package body in GNAT implementation mode
1310 elsif Main_Unit_Kind = N_Package_Body and then GNAT_Mode then
1311 Write_Str (" (predefined generic)");
1314 -- Force generation of ALI file, for backward compatibility
1316 Opt.Force_ALI_Tree_File := True;
1318 -- Only other case is a package spec
1321 Write_Str (" (package spec)");
1326 Set_Standard_Output;
1328 Post_Compilation_Validation_Checks;
1329 Errout.Finalize (Last_Call => True);
1330 Errout.Output_Messages;
1334 -- Generate ALI file if specially requested, or for missing subunits,
1335 -- subunits or predefined generic.
1337 if Opt.Force_ALI_Tree_File then
1338 Write_ALI (Object => False);
1344 -- Exit program with error indication, to kill object file
1346 Exit_Program (E_No_Code);
1349 -- In -gnatc mode, we only do annotation if -gnatt or -gnatR is also set
1350 -- as indicated by Back_Annotate_Rep_Info being set to True.
1352 -- We don't call for annotations on a subunit, because to process those
1353 -- the back end requires that the parent(s) be properly compiled.
1355 -- Annotation is suppressed for targets where front-end layout is
1356 -- enabled, because the front end determines representations.
1358 -- The back end is not invoked in ASIS mode with GNSA because all type
1359 -- representation information will be provided by the GNSA back end, not
1362 if Back_End_Mode = Declarations_Only
1364 (not (Back_Annotate_Rep_Info or Generate_SCIL or GNATprove_Mode)
1365 or else Main_Unit_Kind = N_Subunit
1366 or else Frontend_Layout_On_Target
1367 or else ASIS_GNSA_Mode)
1369 Post_Compilation_Validation_Checks;
1370 Errout.Finalize (Last_Call => True);
1371 Errout.Output_Messages;
1372 Write_ALI (Object => False);
1380 -- Ensure that we properly register a dependency on system.ads, since
1381 -- even if we do not semantically depend on this, Targparm has read
1382 -- system parameters from the system.ads file.
1384 Lib.Writ.Ensure_System_Dependency;
1386 -- Add dependencies, if any, on preprocessing data file and on
1387 -- preprocessing definition file(s).
1389 Prepcomp.Add_Dependencies;
1391 -- In gnatprove mode we're writing the ALI much earlier than usual
1392 -- as flow analysis needs the file present in order to append its
1393 -- own globals to it.
1395 if GNATprove_Mode then
1397 -- Note: In GNATprove mode, an "object" file is always generated as
1398 -- the result of calling gnat1 or gnat2why, although this is not the
1399 -- same as the object file produced for compilation.
1401 Write_ALI (Object => True);
1404 -- Some back ends (for instance Gigi) are known to rely on SCOs for code
1405 -- generation. Make sure they are available.
1407 if Generate_SCO then
1408 Par_SCO.SCO_Record_Filtered;
1411 -- Back end needs to explicitly unlock tables it needs to touch
1425 -- Here we call the back end to generate the output code
1427 Generating_Code := True;
1428 Back_End.Call_Back_End (Back_End_Mode);
1430 -- Once the backend is complete, we unlock the names table. This call
1431 -- allows a few extra entries, needed for example for the file name
1432 -- for the library file output.
1436 -- Generate the call-graph output of dispatching calls
1438 Exp_CG.Generate_CG_Output;
1440 -- Perform post compilation validation checks
1442 Post_Compilation_Validation_Checks;
1444 -- Now we complete output of errors, rep info and the tree info. These
1445 -- are delayed till now, since it is perfectly possible for gigi to
1446 -- generate errors, modify the tree (in particular by setting flags
1447 -- indicating that elaboration is required, and also to back annotate
1448 -- representation information for List_Rep_Info.
1450 Errout.Finalize (Last_Call => True);
1451 Errout.Output_Messages;
1452 List_Rep_Info (Ttypes.Bytes_Big_Endian);
1453 Inline.List_Inlining_Info;
1455 -- Only write the library if the backend did not generate any error
1456 -- messages. Otherwise signal errors to the driver program so that
1457 -- there will be no attempt to generate an object file.
1459 if Compilation_Errors then
1461 Exit_Program (E_Errors);
1464 if not GNATprove_Mode then
1465 Write_ALI (Object => (Back_End_Mode = Generate_Object));
1468 if not Compilation_Errors then
1470 -- In case of ada backends, we need to make sure that the generated
1471 -- object file has a timestamp greater than the ALI file. We do this
1472 -- to make gnatmake happy when checking the ALI and obj timestamps,
1473 -- where it expects the object file being written after the ali file.
1475 -- Gnatmake's assumption is true for gcc platforms where the gcc
1476 -- wrapper needs to call the assembler after calling gnat1, but is
1477 -- not true for ada backends, where the object files are created
1478 -- directly by gnat1 (so are created before the ali file).
1480 Back_End.Gen_Or_Update_Object_File;
1483 -- Generate ASIS tree after writing the ALI file, since in ASIS mode,
1484 -- Write_ALI may in fact result in further tree decoration from the
1485 -- original tree file. Note that we dump the tree just before generating
1486 -- it, so that the dump will exactly reflect what is written out.
1491 -- Finalize name table and we are all done
1496 -- Handle fatal internal compiler errors
1498 when Rtsfind.RE_Not_Available =>
1499 Comperr.Compiler_Abort ("RE_Not_Available");
1501 when System.Assertions.Assert_Failure =>
1502 Comperr.Compiler_Abort ("Assert_Failure");
1504 when Constraint_Error =>
1505 Comperr.Compiler_Abort ("Constraint_Error");
1507 when Program_Error =>
1508 Comperr.Compiler_Abort ("Program_Error");
1510 -- Assume this is a bug. If it is real, the message will in any case
1511 -- say Storage_Error, giving a strong hint.
1513 when Storage_Error =>
1514 Comperr.Compiler_Abort ("Storage_Error");
1516 when Unrecoverable_Error =>
1520 Comperr.Compiler_Abort ("exception");
1526 -- The outer exception handler handles an unrecoverable error
1529 when Unrecoverable_Error =>
1530 Errout.Finalize (Last_Call => True);
1531 Errout.Output_Messages;
1534 Write_Str ("compilation abandoned");
1537 Set_Standard_Output;
1540 Exit_Program (E_Errors);