1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2019, 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
;
31 with Debug
; use Debug
;
33 with Errout
; use Errout
;
36 with Fname
; use Fname
;
37 with Fname
.UF
; use Fname
.UF
;
39 with Ghost
; use Ghost
;
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
;
55 with Rident
; use Rident
;
64 with Sem_SPARK
; use Sem_SPARK
;
67 with Sinfo
; use Sinfo
;
68 with Sinput
.L
; use Sinput
.L
;
69 with Snames
; use Snames
;
70 with Sprint
; use Sprint
;
72 with Stylesw
; use Stylesw
;
73 with Targparm
; use Targparm
;
76 with Treepr
; use Treepr
;
78 with Types
; use Types
;
80 with Uname
; use Uname
;
83 with Validsw
; use Validsw
;
85 with System
.Assertions
;
93 procedure Adjust_Global_Switches
;
94 -- There are various interactions between front-end switch settings,
95 -- including debug switch settings and target dependent parameters.
96 -- This procedure takes care of properly handling these interactions.
97 -- We do it after scanning out all the switches, so that we are not
98 -- depending on the order in which switches appear.
100 procedure Check_Bad_Body
(Unit_Node
: Node_Id
; Unit_Kind
: Node_Kind
);
101 -- Called to check whether a unit described by its compilation unit node
102 -- and kind has a bad body.
104 procedure Check_Rep_Info
;
105 -- Called when we are not generating code, to check if -gnatR was requested
106 -- and if so, explain that we will not be honoring the request.
108 procedure Post_Compilation_Validation_Checks
;
109 -- This procedure performs various validation checks that have to be left
110 -- to the end of the compilation process, after generating code but before
111 -- issuing error messages. In particular, these checks generally require
112 -- the information provided by the back end in back annotation of declared
113 -- entities (e.g. actual size and alignment values chosen by the back end).
115 ----------------------------
116 -- Adjust_Global_Switches --
117 ----------------------------
119 procedure Adjust_Global_Switches
is
120 procedure SPARK_Library_Warning
(Kind
: String);
121 -- Issue a warning in GNATprove mode if the run-time library does not
122 -- fully support IEEE-754 floating-point semantics.
124 ---------------------------
125 -- SPARK_Library_Warning --
126 ---------------------------
128 procedure SPARK_Library_Warning
(Kind
: String) is
131 ("warning: run-time library may be configured incorrectly");
133 ("warning: (SPARK analysis requires support for " & Kind
& ')');
134 end SPARK_Library_Warning
;
136 -- Start of processing for Adjust_Global_Switches
139 -- Define pragma GNAT_Annotate as an alias of pragma Annotate, to be
140 -- able to work around bootstrap limitations with the old syntax of
141 -- pragma Annotate, and use pragma GNAT_Annotate in compiler sources
144 Map_Pragma_Name
(From
=> Name_Gnat_Annotate
, To
=> Name_Annotate
);
146 -- -gnatd.M enables Relaxed_RM_Semantics
148 if Debug_Flag_Dot_MM
then
149 Relaxed_RM_Semantics
:= True;
152 -- -gnatd.1 enables unnesting of subprograms
154 if Debug_Flag_Dot_1
then
155 Unnest_Subprogram_Mode
:= True;
158 -- -gnatd.u enables special C expansion mode
160 if Debug_Flag_Dot_U
then
161 Modify_Tree_For_C
:= True;
164 -- -gnatd_A disables generation of ALI files
166 if Debug_Flag_Underscore_AA
then
167 Disable_ALI_File
:= True;
170 -- Set all flags required when generating C code
172 if Generate_C_Code
then
173 Modify_Tree_For_C
:= True;
174 Unnest_Subprogram_Mode
:= True;
175 Building_Static_Dispatch_Tables
:= False;
176 Minimize_Expression_With_Actions
:= True;
177 Expand_Nonbinary_Modular_Ops
:= True;
179 -- Set operating mode to Generate_Code to benefit from full front-end
180 -- expansion (e.g. generics).
182 Operating_Mode
:= Generate_Code
;
184 -- Suppress alignment checks since we do not have access to alignment
185 -- info on the target.
187 Suppress_Options
.Suppress
(Alignment_Check
) := False;
190 -- -gnatd.E sets Error_To_Warning mode, causing selected error messages
191 -- to be treated as warnings instead of errors.
193 if Debug_Flag_Dot_EE
then
194 Error_To_Warning
:= True;
197 -- -gnatdJ sets Include_Subprogram_In_Messages, adding the related
198 -- subprogram as part of the error and warning messages.
200 if Debug_Flag_JJ
then
201 Include_Subprogram_In_Messages
:= True;
204 -- Disable CodePeer_Mode in Check_Syntax, since we need front-end
207 if Operating_Mode
= Check_Syntax
then
208 CodePeer_Mode
:= False;
211 -- Set ASIS mode if -gnatt and -gnatc are set
213 if Operating_Mode
= Check_Semantics
and then Tree_Output
then
216 -- Set ASIS GNSA mode if -gnatd.H is set
218 if Debug_Flag_Dot_HH
then
219 ASIS_GNSA_Mode
:= True;
222 -- Turn off inlining in ASIS mode, since ASIS cannot handle the extra
223 -- information in the trees caused by inlining being active.
225 -- More specifically, the tree seems to be malformed from the ASIS
226 -- point of view if -gnatc and -gnatn appear together???
228 Inline_Active
:= False;
230 -- Turn off SCIL generation and CodePeer mode in semantics mode,
231 -- since SCIL requires front-end expansion.
233 Generate_SCIL
:= False;
234 CodePeer_Mode
:= False;
237 -- SCIL mode needs to disable front-end inlining since the generated
238 -- trees (in particular order and consistency between specs compiled
239 -- as part of a main unit or as part of a with-clause) are causing
242 if Generate_SCIL
then
243 Front_End_Inlining
:= False;
246 -- Tune settings for optimal SCIL generation in CodePeer mode
248 if CodePeer_Mode
then
250 -- Turn off gnatprove mode (which can be set via e.g. -gnatd.F), not
251 -- compatible with CodePeer mode.
253 GNATprove_Mode
:= False;
254 Debug_Flag_Dot_FF
:= False;
256 -- Turn off length expansion. CodePeer has its own mechanism to
257 -- handle length attribute.
259 Debug_Flag_Dot_PP
:= True;
261 -- Turn off C tree generation, not compatible with CodePeer mode. We
262 -- do not expect this to happen in normal use, since both modes are
263 -- enabled by special tools, but it is useful to turn off these flags
264 -- this way when we are doing CodePeer tests on existing test suites
265 -- that may have -gnateg set, to avoid the need for special casing.
267 Modify_Tree_For_C
:= False;
268 Generate_C_Code
:= False;
269 Unnest_Subprogram_Mode
:= False;
271 -- Turn off inlining, confuses CodePeer output and gains nothing
273 Front_End_Inlining
:= False;
274 Inline_Active
:= False;
276 -- Disable front-end optimizations, to keep the tree as close to the
277 -- source code as possible, and also to avoid inconsistencies between
278 -- trees when using different optimization switches.
280 Optimization_Level
:= 0;
282 -- Enable some restrictions systematically to simplify the generated
283 -- code (and ease analysis). Note that restriction checks are also
284 -- disabled in CodePeer mode, see Restrict.Check_Restriction, and
285 -- user specified Restrictions pragmas are ignored, see
286 -- Sem_Prag.Process_Restrictions_Or_Restriction_Warnings.
288 Restrict
.Restrictions
.Set
(No_Exception_Registration
) := True;
289 Restrict
.Restrictions
.Set
(No_Initialize_Scalars
) := True;
290 Restrict
.Restrictions
.Set
(No_Task_Hierarchy
) := True;
291 Restrict
.Restrictions
.Set
(No_Abort_Statements
) := True;
292 Restrict
.Restrictions
.Set
(Max_Asynchronous_Select_Nesting
) := True;
293 Restrict
.Restrictions
.Value
(Max_Asynchronous_Select_Nesting
) := 0;
295 -- Enable pragma Ignore_Pragma (Global) to support legacy code. As a
296 -- consequence, Refined_Global pragma should be ignored as well, as
297 -- it is only allowed on a body when pragma Global is given for the
300 Set_Name_Table_Boolean3
(Name_Global
, True);
301 Set_Name_Table_Boolean3
(Name_Refined_Global
, True);
303 -- Suppress division by zero checks since they are handled
304 -- implicitly by CodePeer.
306 -- Turn off dynamic elaboration checks: generates inconsistencies in
307 -- trees between specs compiled as part of a main unit or as part of
310 -- Turn off alignment checks: these cannot be proved statically by
311 -- CodePeer and generate false positives.
313 -- Enable all other language checks
315 Suppress_Options
.Suppress
:=
316 (Alignment_Check
=> True,
317 Division_Check
=> True,
318 Elaboration_Check
=> True,
321 Dynamic_Elaboration_Checks
:= False;
323 -- Set STRICT mode for overflow checks if not set explicitly. This
324 -- prevents suppressing of overflow checks by default, in code down
327 if Suppress_Options
.Overflow_Mode_General
= Not_Set
then
328 Suppress_Options
.Overflow_Mode_General
:= Strict
;
329 Suppress_Options
.Overflow_Mode_Assertions
:= Strict
;
332 -- CodePeer handles division and overflow checks directly, based on
333 -- the marks set by the frontend, hence no special expansion should
334 -- be performed in the frontend for division and overflow checks.
336 Backend_Divide_Checks_On_Target
:= True;
337 Backend_Overflow_Checks_On_Target
:= True;
339 -- Kill debug of generated code, since it messes up sloc values
341 Debug_Generated_Code
:= False;
343 -- Ditto for -gnateG which interacts badly with handling of pragma
344 -- Annotate in gnat2scil.
346 Generate_Processed_File
:= False;
348 -- Disable Exception_Extra_Info (-gnateE) which generates more
349 -- complex trees with no added value, and may confuse CodePeer.
351 Exception_Extra_Info
:= False;
353 -- Turn cross-referencing on in case it was disabled (e.g. by -gnatD)
354 -- to support source navigation.
358 -- Polling mode forced off, since it generates confusing junk
360 Polling_Required
:= False;
362 -- Set operating mode to Generate_Code to benefit from full front-end
363 -- expansion (e.g. generics).
365 Operating_Mode
:= Generate_Code
;
367 -- We need SCIL generation of course
369 Generate_SCIL
:= True;
371 -- Enable assertions, since they give CodePeer valuable extra info
373 Assertions_Enabled
:= True;
375 -- Set normal RM validity checking and checking of copies (to catch
376 -- e.g. wrong values used in unchecked conversions).
377 -- All other validity checking is turned off, since this can generate
378 -- very complex trees that only confuse CodePeer and do not bring
379 -- enough useful info.
381 Reset_Validity_Check_Options
;
382 Validity_Check_Default
:= True;
383 Validity_Check_Copies
:= True;
384 Check_Validity_Of_Parameters
:= False;
386 -- Turn off style check options and ignore any style check pragmas
387 -- since we are not interested in any front-end warnings when we are
388 -- getting CodePeer output.
390 Reset_Style_Check_Options
;
391 Ignore_Style_Checks_Pragmas
:= True;
393 -- Always perform semantics and generate ali files in CodePeer mode,
394 -- so that a gnatmake -c -k will proceed further when possible.
396 Force_ALI_Tree_File
:= True;
397 Try_Semantics
:= True;
399 -- Make the Ada front end more liberal so that the compiler will
400 -- allow illegal code that is allowed by other compilers. CodePeer
401 -- is in the business of finding problems, not enforcing rules.
402 -- This is useful when using CodePeer mode with other compilers.
404 Relaxed_RM_Semantics
:= True;
406 if not Generate_CodePeer_Messages
then
408 -- Suppress compiler warnings by default when generating SCIL for
409 -- CodePeer, except when combined with -gnateC where we do want to
410 -- emit GNAT warnings.
412 Warning_Mode
:= Suppress
;
415 -- Disable all simple value propagation. This is an optimization
416 -- which is valuable for code optimization, and also for generation
417 -- of compiler warnings, but these are being turned off by default,
418 -- and CodePeer generates better messages (referencing original
419 -- variables) this way.
420 -- Do this only if -gnatws is set (the default with -gnatcC), so that
421 -- if warnings are enabled, we'll get better messages from GNAT.
423 if Warning_Mode
= Suppress
then
424 Debug_Flag_MM
:= True;
428 -- Enable some individual switches that are implied by relaxed RM
431 if Relaxed_RM_Semantics
then
432 Opt
.Allow_Integer_Address
:= True;
433 Overriding_Renamings
:= True;
434 Treat_Categorization_Errors_As_Warnings
:= True;
437 -- Enable GNATprove_Mode when using -gnatd.F switch
439 if Debug_Flag_Dot_FF
then
440 GNATprove_Mode
:= True;
443 -- GNATprove_Mode is also activated by default in the gnat2why
446 if GNATprove_Mode
then
448 -- Turn off CodePeer mode (which can be set via e.g. -gnatC or
449 -- -gnateC), not compatible with GNATprove mode.
451 CodePeer_Mode
:= False;
452 Generate_SCIL
:= False;
454 -- Turn off C tree generation, not compatible with GNATprove mode. We
455 -- do not expect this to happen in normal use, since both modes are
456 -- enabled by special tools, but it is useful to turn off these flags
457 -- this way when we are doing GNATprove tests on existing test suites
458 -- that may have -gnateg set, to avoid the need for special casing.
460 Modify_Tree_For_C
:= False;
461 Generate_C_Code
:= False;
462 Unnest_Subprogram_Mode
:= False;
464 -- Turn off inlining, which would confuse formal verification output
467 Front_End_Inlining
:= False;
468 Inline_Active
:= False;
470 -- Issue warnings for failure to inline subprograms, as otherwise
471 -- expected in GNATprove mode for the local subprograms without
474 Ineffective_Inline_Warnings
:= True;
476 -- Do not issue warnings for possible propagation of exception.
477 -- GNATprove already issues messages about possible exceptions.
479 No_Warn_On_Non_Local_Exception
:= True;
480 Warn_On_Non_Local_Exception
:= False;
482 -- Disable front-end optimizations, to keep the tree as close to the
483 -- source code as possible, and also to avoid inconsistencies between
484 -- trees when using different optimization switches.
486 Optimization_Level
:= 0;
488 -- Enable some restrictions systematically to simplify the generated
489 -- code (and ease analysis).
491 Restrict
.Restrictions
.Set
(No_Initialize_Scalars
) := True;
493 -- Note: at this point we used to suppress various checks, but that
494 -- is not what we want. We need the semantic processing for these
495 -- checks (which will set flags like Do_Overflow_Check, showing the
496 -- points at which potential checks are required semantically). We
497 -- don't want the expansion associated with these checks, but that
498 -- happens anyway because this expansion is simply not done in the
499 -- SPARK version of the expander.
501 -- On the contrary, we need to enable explicitly all language checks,
502 -- as they may have been suppressed by the use of switch -gnatp.
504 Suppress_Options
.Suppress
:= (others => False);
506 -- Detect overflow on unconstrained floating-point types, such as
507 -- the predefined types Float, Long_Float and Long_Long_Float from
508 -- package Standard. Not necessary if float overflows are checked
509 -- (Machine_Overflow true), since appropriate Do_Overflow_Check flags
510 -- will be set in any case.
512 Check_Float_Overflow
:= not Machine_Overflows_On_Target
;
514 -- Set STRICT mode for overflow checks if not set explicitly. This
515 -- prevents suppressing of overflow checks by default, in code down
518 if Suppress_Options
.Overflow_Mode_General
= Not_Set
then
519 Suppress_Options
.Overflow_Mode_General
:= Strict
;
520 Suppress_Options
.Overflow_Mode_Assertions
:= Strict
;
523 -- Kill debug of generated code, since it messes up sloc values
525 Debug_Generated_Code
:= False;
527 -- Turn cross-referencing on in case it was disabled (e.g. by -gnatD)
528 -- as it is needed for computing effects of subprograms in the formal
529 -- verification backend.
533 -- Polling mode forced off, since it generates confusing junk
535 Polling_Required
:= False;
537 -- Set operating mode to Check_Semantics, but a light front-end
538 -- expansion is still performed.
540 Operating_Mode
:= Check_Semantics
;
542 -- Enable assertions, since they give valuable extra information for
543 -- formal verification.
545 Assertions_Enabled
:= True;
547 -- Disable validity checks, since it generates code raising
548 -- exceptions for invalid data, which confuses GNATprove. Invalid
549 -- data is directly detected by GNATprove's flow analysis.
551 Validity_Checks_On
:= False;
552 Check_Validity_Of_Parameters
:= False;
554 -- Turn off style check options since we are not interested in any
555 -- front-end warnings when we are getting SPARK output.
557 Reset_Style_Check_Options
;
559 -- Suppress the generation of name tables for enumerations, which are
560 -- not needed for formal verification, and fall outside the SPARK
561 -- subset (use of pointers).
563 Global_Discard_Names
:= True;
565 -- Suppress the expansion of tagged types and dispatching calls,
566 -- which lead to the generation of non-SPARK code (use of pointers),
567 -- which is more complex to formally verify than the original source.
569 Tagged_Type_Expansion
:= False;
571 -- Detect that the runtime library support for floating-point numbers
572 -- may not be compatible with SPARK analysis of IEEE-754 floats.
574 if Denorm_On_Target
= False then
575 SPARK_Library_Warning
("float subnormals");
577 elsif Machine_Rounds_On_Target
= False then
578 SPARK_Library_Warning
("float rounding");
580 elsif Signed_Zeros_On_Target
= False then
581 SPARK_Library_Warning
("signed zeros");
585 -- Set Configurable_Run_Time mode if system.ads flag set or if the
586 -- special debug flag -gnatdY is set.
588 if Targparm
.Configurable_Run_Time_On_Target
or Debug_Flag_YY
then
589 Configurable_Run_Time_Mode
:= True;
592 -- Set -gnatRm mode if debug flag A set
594 if Debug_Flag_AA
then
595 Back_Annotate_Rep_Info
:= True;
596 List_Representation_Info
:= 1;
597 List_Representation_Info_Mechanisms
:= True;
600 -- Force Target_Strict_Alignment true if debug flag -gnatd.a is set
602 if Debug_Flag_Dot_A
then
603 Ttypes
.Target_Strict_Alignment
:= True;
606 -- Increase size of allocated entities if debug flag -gnatd.N is set
608 if Debug_Flag_Dot_NN
then
609 Atree
.Num_Extension_Nodes
:= Atree
.Num_Extension_Nodes
+ 1;
612 -- Disable static allocation of dispatch tables if -gnatd.t is enabled.
613 -- The front end's layout phase currently treats types that have
614 -- discriminant-dependent arrays as not being static even when a
615 -- discriminant constraint on the type is static, and this leads to
616 -- problems with subtypes of type Ada.Tags.Dispatch_Table_Wrapper. ???
618 if Debug_Flag_Dot_T
then
619 Building_Static_Dispatch_Tables
:= False;
622 -- Flip endian mode if -gnatd8 set
625 Ttypes
.Bytes_Big_Endian
:= not Ttypes
.Bytes_Big_Endian
;
628 -- Set and check exception mechanism. This is only meaningful when
629 -- compiling, and in particular not meaningful for special modes used
630 -- for program analysis rather than compilation: ASIS mode, CodePeer
631 -- mode and GNATprove mode.
633 if Operating_Mode
= Generate_Code
634 and then not (ASIS_Mode
or CodePeer_Mode
or GNATprove_Mode
)
636 case Targparm
.Frontend_Exceptions_On_Target
is
638 case Targparm
.ZCX_By_Default_On_Target
is
641 ("Run-time library configured incorrectly");
643 ("(requesting support for Frontend ZCX exceptions)");
644 raise Unrecoverable_Error
;
647 Exception_Mechanism
:= Front_End_SJLJ
;
651 case Targparm
.ZCX_By_Default_On_Target
is
653 Exception_Mechanism
:= Back_End_ZCX
;
655 Exception_Mechanism
:= Back_End_SJLJ
;
660 -- Set proper status for overflow check mechanism
662 -- If already set (by -gnato or above in SPARK or CodePeer mode) then we
663 -- have nothing to do.
665 if Opt
.Suppress_Options
.Overflow_Mode_General
/= Not_Set
then
668 -- Otherwise set overflow mode defaults
671 -- Overflow checks are on by default (Suppress set False) except in
672 -- GNAT_Mode, where we want them off by default (we are not ready to
673 -- enable overflow checks in the compiler yet, for one thing the case
674 -- of 64-bit checks needs System.Arith_64 which is not a compiler
675 -- unit and it is a pain to try to include it in the compiler.
677 Suppress_Options
.Suppress
(Overflow_Check
) := GNAT_Mode
;
679 -- Set appropriate default overflow handling mode. Note: at present
680 -- we set STRICT in all three of the following cases. They are
681 -- separated because in the future we may make different choices.
683 -- By default set STRICT mode if -gnatg in effect
686 Suppress_Options
.Overflow_Mode_General
:= Strict
;
687 Suppress_Options
.Overflow_Mode_Assertions
:= Strict
;
689 -- If we have backend divide and overflow checks, then by default
690 -- overflow checks are STRICT. Historically this code used to also
691 -- activate overflow checks, although no target currently has these
692 -- flags set, so this was dead code anyway.
694 elsif Targparm
.Backend_Divide_Checks_On_Target
696 Targparm
.Backend_Overflow_Checks_On_Target
698 Suppress_Options
.Overflow_Mode_General
:= Strict
;
699 Suppress_Options
.Overflow_Mode_Assertions
:= Strict
;
701 -- Otherwise for now, default is STRICT mode. This may change in the
702 -- future, but for now this is the compatible behavior with previous
706 Suppress_Options
.Overflow_Mode_General
:= Strict
;
707 Suppress_Options
.Overflow_Mode_Assertions
:= Strict
;
711 -- Set default for atomic synchronization. As this synchronization
712 -- between atomic accesses can be expensive, and not typically needed
713 -- on some targets, an optional target parameter can turn the option
714 -- off. Note Atomic Synchronization is implemented as check.
716 Suppress_Options
.Suppress
(Atomic_Synchronization
) :=
717 not Atomic_Sync_Default_On_Target
;
719 -- Set default for Alignment_Check, if we are on a machine with non-
720 -- strict alignment, then we suppress this check, since it is over-
721 -- zealous for such machines.
723 if not Ttypes
.Target_Strict_Alignment
then
724 Suppress_Options
.Suppress
(Alignment_Check
) := True;
727 -- Set switch indicating if back end can handle limited types, and
728 -- guarantee that no incorrect copies are made (e.g. in the context
729 -- of an if or case expression).
731 -- Debug flag -gnatd.L decisively sets usage on
733 if Debug_Flag_Dot_LL
then
734 Back_End_Handles_Limited_Types
:= True;
736 -- If no debug flag, usage off for SCIL cases
738 elsif Generate_SCIL
then
739 Back_End_Handles_Limited_Types
:= False;
741 -- Otherwise normal gcc back end, for now still turn flag off by
742 -- default, since there are unresolved problems in the front end.
745 Back_End_Handles_Limited_Types
:= False;
748 -- If the inlining level has not been set by the user, compute it from
749 -- the optimization level: 1 at -O1/-O2 (and -Os), 2 at -O3 and above.
751 if Inline_Level
= 0 then
752 if Optimization_Level
< 3 then
759 -- Treat -gnatn as equivalent to -gnatN for non-GCC targets
761 if Inline_Active
and not Front_End_Inlining
then
763 -- We really should have a tag for this, what if we added a new
764 -- back end some day, it would not be true for this test, but it
765 -- would be non-GCC, so this is a bit troublesome ???
767 Front_End_Inlining
:= Generate_C_Code
;
770 -- Set back-end inlining indication
774 -- No back-end inlining available on C generation
778 -- No back-end inlining in GNATprove mode, since it just confuses
779 -- the formal verification process.
781 and then not GNATprove_Mode
783 -- No back-end inlining if front-end inlining explicitly enabled.
784 -- Done to minimize the output differences to customers still using
785 -- this deprecated switch; in addition, this behavior reduces the
786 -- output differences in old tests.
788 and then not Front_End_Inlining
790 -- Back-end inlining is disabled if debug flag .z is set
792 and then not Debug_Flag_Dot_Z
;
794 -- Output warning if -gnateE specified and cannot be supported
796 if Exception_Extra_Info
797 and then Restrict
.No_Exception_Handlers_Set
801 ("warning: extra exception information (-gnateE) was specified");
804 ("warning: this capability is not available in this configuration");
809 -- Finally capture adjusted value of Suppress_Options as the initial
810 -- value for Scope_Suppress, which will be modified as we move from
811 -- scope to scope (by Suppress/Unsuppress/Overflow_Checks pragmas).
813 Sem
.Scope_Suppress
:= Opt
.Suppress_Options
;
814 end Adjust_Global_Switches
;
820 procedure Check_Bad_Body
(Unit_Node
: Node_Id
; Unit_Kind
: Node_Kind
) is
821 Fname
: File_Name_Type
;
823 procedure Bad_Body_Error
(Msg
: String);
824 -- Issue message for bad body found
830 procedure Bad_Body_Error
(Msg
: String) is
832 Error_Msg_N
(Msg
, Unit_Node
);
833 Error_Msg_File_1
:= Fname
;
834 Error_Msg_N
("remove incorrect body in file{!", Unit_Node
);
839 Sname
: Unit_Name_Type
;
840 Src_Ind
: Source_File_Index
;
842 -- Start of processing for Check_Bad_Body
845 -- Nothing to do if we are only checking syntax, because we don't know
846 -- enough to know if we require or forbid a body in this case.
848 if Operating_Mode
= Check_Syntax
then
852 -- Check for body not allowed
854 if (Unit_Kind
= N_Package_Declaration
855 and then not Body_Required
(Unit_Node
))
856 or else (Unit_Kind
= N_Generic_Package_Declaration
857 and then not Body_Required
(Unit_Node
))
858 or else Unit_Kind
= N_Package_Renaming_Declaration
859 or else Unit_Kind
= N_Subprogram_Renaming_Declaration
860 or else Nkind
(Original_Node
(Unit
(Unit_Node
)))
861 in N_Generic_Instantiation
863 Sname
:= Unit_Name
(Main_Unit
);
865 -- If we do not already have a body name, then get the body name
867 if not Is_Body_Name
(Sname
) then
868 Sname
:= Get_Body_Name
(Sname
);
871 Fname
:= Get_File_Name
(Sname
, Subunit
=> False);
872 Src_Ind
:= Load_Source_File
(Fname
);
874 -- Case where body is present and it is not a subunit. Exclude the
875 -- subunit case, because it has nothing to do with the package we are
876 -- compiling. It is illegal for a child unit and a subunit with the
877 -- same expanded name (RM 10.2(9)) to appear together in a partition,
878 -- but there is nothing to stop a compilation environment from having
879 -- both, and the test here simply allows that. If there is an attempt
880 -- to include both in a partition, this is diagnosed at bind time. In
881 -- Ada 83 mode this is not a warning case.
883 -- Note that in general we do not give the message if the file in
884 -- question does not look like a body. This includes weird cases,
885 -- but in particular means that if the file is just a No_Body pragma,
886 -- then we won't give the message (that's the whole point of this
887 -- pragma, to be used this way and to cause the body file to be
888 -- ignored in this context).
890 if Src_Ind
> No_Source_File
891 and then Source_File_Is_Body
(Src_Ind
)
893 Errout
.Finalize
(Last_Call
=> False);
895 Error_Msg_Unit_1
:= Sname
;
897 -- Ada 83 case of a package body being ignored. This is not an
898 -- error as far as the Ada 83 RM is concerned, but it is almost
899 -- certainly not what is wanted so output a warning. Give this
900 -- message only if there were no errors, since otherwise it may
901 -- be incorrect (we may have misinterpreted a junk spec as not
902 -- needing a body when it really does).
904 if Unit_Kind
= N_Package_Declaration
905 and then Ada_Version
= Ada_83
906 and then Operating_Mode
= Generate_Code
907 and then Distribution_Stub_Mode
/= Generate_Caller_Stub_Body
908 and then not Compilation_Errors
911 ("package $$ does not require a body??", Unit_Node
);
912 Error_Msg_File_1
:= Fname
;
913 Error_Msg_N
("body in file{ will be ignored??", Unit_Node
);
915 -- Ada 95 cases of a body file present when no body is
916 -- permitted. This we consider to be an error.
919 -- For generic instantiations, we never allow a body
921 if Nkind
(Original_Node
(Unit
(Unit_Node
))) in
922 N_Generic_Instantiation
925 ("generic instantiation for $$ does not allow a body");
927 -- A library unit that is a renaming never allows a body
929 elsif Unit_Kind
in N_Renaming_Declaration
then
931 ("renaming declaration for $$ does not allow a body!");
933 -- Remaining cases are packages and generic packages. Here
934 -- we only do the test if there are no previous errors,
935 -- because if there are errors, they may lead us to
936 -- incorrectly believe that a package does not allow a
937 -- body when in fact it does.
939 elsif not Compilation_Errors
then
940 if Unit_Kind
= N_Package_Declaration
then
942 ("package $$ does not allow a body!");
944 elsif Unit_Kind
= N_Generic_Package_Declaration
then
946 ("generic package $$ does not allow a body!");
959 procedure Check_Rep_Info
is
961 if List_Representation_Info
/= 0
962 or else List_Representation_Info_Mechanisms
967 ("cannot generate representation information, no code generated");
974 ----------------------------------------
975 -- Post_Compilation_Validation_Checks --
976 ----------------------------------------
978 procedure Post_Compilation_Validation_Checks
is
980 -- Validate alignment check warnings. In some cases we generate warnings
981 -- about possible alignment errors because we don't know the alignment
982 -- that will be chosen by the back end. This routine is in charge of
983 -- getting rid of those warnings if we can tell they are not needed.
985 Checks
.Validate_Alignment_Check_Warnings
;
987 -- Validate compile time warnings and errors (using the values for size
988 -- and alignment annotated by the backend where possible). We need to
989 -- unlock temporarily these tables to reanalyze their expression.
994 Sem_Ch13
.Validate_Compile_Time_Warning_Errors
;
999 -- Validate unchecked conversions (using the values for size and
1000 -- alignment annotated by the backend where possible).
1002 Sem_Ch13
.Validate_Unchecked_Conversions
;
1004 -- Validate address clauses (again using alignment values annotated
1005 -- by the backend where possible).
1007 Sem_Ch13
.Validate_Address_Clauses
;
1009 -- Validate independence pragmas (again using values annotated by the
1010 -- back end for component layout where possible) but only for non-GCC
1011 -- back ends, as this is done a priori for GCC back ends.
1012 -- ??? We use to test for AAMP_On_Target which is now gone, consider
1014 -- if AAMP_On_Target then
1015 -- Sem_Ch13.Validate_Independence;
1017 end Post_Compilation_Validation_Checks
;
1021 Back_End_Mode
: Back_End
.Back_End_Mode_Type
;
1022 Ecode
: Exit_Code_Type
;
1024 Main_Unit_Kind
: Node_Kind
;
1025 -- Kind of main compilation unit node
1027 Main_Unit_Node
: Node_Id
;
1028 -- Compilation unit node for main unit
1030 -- Start of processing for Gnat1drv
1033 -- This inner block is set up to catch assertion errors and constraint
1034 -- errors. Since the code for handling these errors can cause another
1035 -- exception to be raised (namely Unrecoverable_Error), we need two
1036 -- nested blocks, so that the outer one handles unrecoverable error.
1039 -- Initialize all packages. For the most part, these initialization
1040 -- calls can be made in any order. Exceptions are as follows:
1042 -- Lib.Initialize need to be called before Scan_Compiler_Arguments,
1043 -- because it initializes a table filled by Scan_Compiler_Arguments.
1048 Lib
.Xref
.Initialize
;
1049 Scan_Compiler_Arguments
;
1050 Osint
.Add_Default_Search_Dirs
;
1067 Sem_Ch12
.Initialize
;
1068 Sem_Ch13
.Initialize
;
1069 Sem_Elim
.Initialize
;
1070 Sem_Eval
.Initialize
;
1071 Sem_Type
.Init_Interp_Tables
;
1073 -- Capture compilation date and time
1075 Opt
.Compilation_Time
:= System
.OS_Lib
.Current_Time_String
;
1077 -- Get the target parameters only when -gnats is not used, to avoid
1078 -- failing when there is no default runtime.
1080 if Operating_Mode
/= Check_Syntax
then
1082 -- Acquire target parameters from system.ads (package System source)
1084 Targparm_Acquire
: declare
1087 S
: Source_File_Index
;
1091 Name_Buffer
(1 .. 10) := "system.ads";
1094 S
:= Load_Source_File
(N
);
1096 -- Failed to read system.ads, fatal error
1098 if S
= No_Source_File
then
1100 ("fatal error, run-time library not installed correctly");
1101 Write_Line
("cannot locate file system.ads");
1102 raise Unrecoverable_Error
;
1104 elsif S
= No_Access_To_Source_File
then
1106 ("fatal error, run-time library not installed correctly");
1107 Write_Line
("no read access for file system.ads");
1108 raise Unrecoverable_Error
;
1110 -- Read system.ads successfully, remember its source index
1113 System_Source_File_Index
:= S
;
1116 -- Call to get target parameters. Note that the actual interface
1117 -- routines are in Tbuild. They can't be in this procedure because
1118 -- of accessibility issues.
1120 Targparm
.Get_Target_Parameters
1121 (System_Text
=> Source_Text
(S
),
1122 Source_First
=> Source_First
(S
),
1123 Source_Last
=> Source_Last
(S
),
1124 Make_Id
=> Tbuild
.Make_Id
'Access,
1125 Make_SC
=> Tbuild
.Make_SC
'Access,
1126 Set_NOD
=> Tbuild
.Set_NOD
'Access,
1127 Set_NSA
=> Tbuild
.Set_NSA
'Access,
1128 Set_NUA
=> Tbuild
.Set_NUA
'Access,
1129 Set_NUP
=> Tbuild
.Set_NUP
'Access);
1131 -- Acquire configuration pragma information from Targparm
1133 Restrict
.Restrictions
:= Targparm
.Restrictions_On_Target
;
1134 end Targparm_Acquire
;
1137 -- Perform various adjustments and settings of global switches
1139 Adjust_Global_Switches
;
1141 -- Output copyright notice if full list mode unless we have a list
1142 -- file, in which case we defer this so that it is output in the file.
1144 if (Verbose_Mode
or else (Full_List
and then Full_List_File_Name
= null))
1146 -- Debug flag gnatd7 suppresses this copyright notice
1148 and then not Debug_Flag_7
1151 Write_Str
("GNAT ");
1152 Write_Str
(Gnat_Version_String
);
1154 Write_Str
("Copyright 1992-" & Current_Year
1155 & ", Free Software Foundation, Inc.");
1159 -- Check we do not have more than one source file, this happens only in
1160 -- the case where the driver is called directly, it cannot happen when
1161 -- gnat1 is invoked from gcc in the normal case.
1163 if Osint
.Number_Of_Files
/= 1 then
1165 -- In GNATprove mode, gcc is not called, so we may end up with
1166 -- switches wrongly interpreted as source file names when they are
1167 -- written by mistake without a starting hyphen. Issue a specific
1168 -- error message but do not print the internal 'usage' message.
1170 if GNATprove_Mode
then
1172 ("one of the following is not a valid switch or source file "
1174 Osint
.Dump_Command_Line_Source_File_Names
;
1180 Osint
.Fail
("you must provide one source file");
1182 elsif Usage_Requested
then
1186 -- Generate target dependent output file if requested
1188 if Target_Dependent_Info_Write_Name
/= null then
1189 Set_Targ
.Write_Target_Dependent_Values
;
1192 -- Call the front end
1194 Original_Operating_Mode
:= Operating_Mode
;
1197 -- Exit with errors if the main source could not be parsed
1199 if Sinput
.Main_Source_File
<= No_Source_File
then
1200 Errout
.Finalize
(Last_Call
=> True);
1201 Errout
.Output_Messages
;
1202 Exit_Program
(E_Errors
);
1205 Main_Unit_Node
:= Cunit
(Main_Unit
);
1206 Main_Unit_Kind
:= Nkind
(Unit
(Main_Unit_Node
));
1208 Check_Bad_Body
(Main_Unit_Node
, Main_Unit_Kind
);
1210 -- In CodePeer mode we always delete old SCIL files before regenerating
1211 -- new ones, in case of e.g. errors, and also to remove obsolete scilx
1212 -- files generated by CodePeer itself.
1214 if CodePeer_Mode
then
1215 Comperr
.Delete_SCIL_Files
;
1218 -- Ditto for old C files before regenerating new ones
1220 if Generate_C_Code
then
1225 -- Exit if compilation errors detected
1227 Errout
.Finalize
(Last_Call
=> False);
1229 if Compilation_Errors
then
1231 Post_Compilation_Validation_Checks
;
1232 Errout
.Finalize
(Last_Call
=> True);
1233 Errout
.Output_Messages
;
1236 -- Generate ALI file if specially requested
1238 if Opt
.Force_ALI_Tree_File
then
1239 Write_ALI
(Object
=> False);
1243 Exit_Program
(E_Errors
);
1246 -- Set Generate_Code on main unit and its spec. We do this even if are
1247 -- not generating code, since Lib-Writ uses this to determine which
1248 -- units get written in the ali file.
1250 Set_Generate_Code
(Main_Unit
);
1252 -- If we have a corresponding spec, and it comes from source or it is
1253 -- not a generated spec for a child subprogram body, then we need object
1254 -- code for the spec unit as well.
1256 if Nkind
(Unit
(Main_Unit_Node
)) in N_Unit_Body
1257 and then not Acts_As_Spec
(Main_Unit_Node
)
1259 if Nkind
(Unit
(Main_Unit_Node
)) = N_Subprogram_Body
1260 and then not Comes_From_Source
(Library_Unit
(Main_Unit_Node
))
1265 (Get_Cunit_Unit_Number
(Library_Unit
(Main_Unit_Node
)));
1269 -- Case of no code required to be generated, exit indicating no error
1271 if Original_Operating_Mode
= Check_Syntax
then
1273 Errout
.Finalize
(Last_Call
=> True);
1274 Errout
.Output_Messages
;
1279 -- Use a goto instead of calling Exit_Program so that finalization
1282 goto End_Of_Program
;
1284 elsif Original_Operating_Mode
= Check_Semantics
then
1285 Back_End_Mode
:= Declarations_Only
;
1287 -- All remaining cases are cases in which the user requested that code
1288 -- be generated (i.e. no -gnatc or -gnats switch was used). Check if we
1289 -- can in fact satisfy this request.
1291 -- Cannot generate code if someone has turned off code generation for
1292 -- any reason at all. We will try to figure out a reason below.
1294 elsif Operating_Mode
/= Generate_Code
then
1295 Back_End_Mode
:= Skip
;
1297 -- We can generate code for a subprogram body unless there were missing
1298 -- subunits. Note that we always generate code for all generic units (a
1299 -- change from some previous versions of GNAT).
1301 elsif Main_Unit_Kind
= N_Subprogram_Body
1302 and then not Subunits_Missing
1304 Back_End_Mode
:= Generate_Object
;
1306 -- We can generate code for a package body unless there are subunits
1307 -- missing (note that we always generate code for generic units, which
1308 -- is a change from some earlier versions of GNAT).
1310 elsif Main_Unit_Kind
= N_Package_Body
and then not Subunits_Missing
then
1311 Back_End_Mode
:= Generate_Object
;
1313 -- We can generate code for a package declaration or a subprogram
1314 -- declaration only if it does not required a body.
1316 elsif Nkind_In
(Main_Unit_Kind
, N_Package_Declaration
,
1317 N_Subprogram_Declaration
)
1319 (not Body_Required
(Main_Unit_Node
)
1320 or else Distribution_Stub_Mode
= Generate_Caller_Stub_Body
)
1322 Back_End_Mode
:= Generate_Object
;
1324 -- We can generate code for a generic package declaration of a generic
1325 -- subprogram declaration only if does not require a body.
1327 elsif Nkind_In
(Main_Unit_Kind
, N_Generic_Package_Declaration
,
1328 N_Generic_Subprogram_Declaration
)
1329 and then not Body_Required
(Main_Unit_Node
)
1331 Back_End_Mode
:= Generate_Object
;
1333 -- Compilation units that are renamings do not require bodies, so we can
1334 -- generate code for them.
1336 elsif Nkind_In
(Main_Unit_Kind
, N_Package_Renaming_Declaration
,
1337 N_Subprogram_Renaming_Declaration
)
1339 Back_End_Mode
:= Generate_Object
;
1341 -- Compilation units that are generic renamings do not require bodies
1342 -- so we can generate code for them.
1344 elsif Main_Unit_Kind
in N_Generic_Renaming_Declaration
then
1345 Back_End_Mode
:= Generate_Object
;
1347 -- It is not an error to analyze in CodePeer mode a spec which requires
1348 -- a body, in order to generate SCIL for this spec.
1349 -- Ditto for Generate_C_Code mode and generate a C header for a spec.
1351 elsif CodePeer_Mode
or Generate_C_Code
then
1352 Back_End_Mode
:= Generate_Object
;
1354 -- It is not an error to analyze in GNATprove mode a spec which requires
1355 -- a body, when the body is not available. During frame condition
1356 -- generation, the corresponding ALI file is generated. During
1357 -- analysis, the spec is analyzed.
1359 elsif GNATprove_Mode
then
1360 Back_End_Mode
:= Declarations_Only
;
1362 -- In all other cases (specs which have bodies, generics, and bodies
1363 -- where subunits are missing), we cannot generate code and we generate
1364 -- a warning message. Note that generic instantiations are gone at this
1365 -- stage since they have been replaced by their instances.
1368 Back_End_Mode
:= Skip
;
1371 -- At this stage Back_End_Mode is set to indicate if the backend should
1372 -- be called to generate code. If it is Skip, then code generation has
1373 -- been turned off, even though code was requested by the original
1374 -- command. This is not an error from the user point of view, but it is
1375 -- an error from the point of view of the gcc driver, so we must exit
1376 -- with an error status.
1378 -- We generate an informative message (from the gcc point of view, it
1379 -- is an error message, but from the users point of view this is not an
1380 -- error, just a consequence of compiling something that cannot
1383 if Back_End_Mode
= Skip
then
1385 -- An ignored Ghost unit is rewritten into a null statement because
1386 -- it must not produce an ALI or object file. Do not emit any errors
1387 -- related to code generation because the unit does not exist.
1389 if Is_Ignored_Ghost_Unit
(Main_Unit_Node
) then
1391 -- Exit the gnat driver with success, otherwise external builders
1392 -- such as gnatmake and gprbuild will treat the compilation of an
1393 -- ignored Ghost unit as a failure. Note that this will produce
1394 -- an empty object file for the unit.
1398 -- Otherwise the unit is missing a crucial piece that prevents code
1405 Write_Str
("cannot generate code for file ");
1406 Write_Name
(Unit_File_Name
(Main_Unit
));
1408 if Subunits_Missing
then
1409 Write_Str
(" (missing subunits)");
1412 -- Force generation of ALI file, for backward compatibility
1414 Opt
.Force_ALI_Tree_File
:= True;
1416 elsif Main_Unit_Kind
= N_Subunit
then
1417 Write_Str
(" (subunit)");
1420 -- Do not generate an ALI file in this case, because it would
1421 -- become obsolete when the parent is compiled, and thus
1422 -- confuse tools such as gnatfind.
1424 elsif Main_Unit_Kind
= N_Subprogram_Declaration
then
1425 Write_Str
(" (subprogram spec)");
1428 -- Generic package body in GNAT implementation mode
1430 elsif Main_Unit_Kind
= N_Package_Body
and then GNAT_Mode
then
1431 Write_Str
(" (predefined generic)");
1434 -- Force generation of ALI file, for backward compatibility
1436 Opt
.Force_ALI_Tree_File
:= True;
1438 -- Only other case is a package spec
1441 Write_Str
(" (package spec)");
1446 Set_Standard_Output
;
1448 Post_Compilation_Validation_Checks
;
1449 Errout
.Finalize
(Last_Call
=> True);
1450 Errout
.Output_Messages
;
1454 -- Generate ALI file if specially requested, or for missing subunits,
1455 -- subunits or predefined generic. For ignored ghost code, the object
1456 -- file IS generated, so Object should be True.
1458 if Opt
.Force_ALI_Tree_File
then
1459 Write_ALI
(Object
=> Is_Ignored_Ghost_Unit
(Main_Unit_Node
));
1465 -- Exit the driver with an appropriate status indicator. This will
1466 -- generate an empty object file for ignored Ghost units, otherwise
1467 -- no object file will be generated.
1469 Exit_Program
(Ecode
);
1472 -- In -gnatc mode we only do annotation if -gnatt or -gnatR is also set,
1473 -- or if -gnatwz is enabled (default setting) and there is an unchecked
1474 -- conversion that involves a type whose size is not statically known,
1475 -- as indicated by Back_Annotate_Rep_Info being set to True.
1477 -- We don't call for annotations on a subunit, because to process those
1478 -- the back end requires that the parent(s) be properly compiled.
1480 -- Annotation is suppressed for targets where front-end layout is
1481 -- enabled, because the front end determines representations.
1483 -- The back end is not invoked in ASIS mode with GNSA because all type
1484 -- representation information will be provided by the GNSA back end, not
1487 -- A special back end is always called in CodePeer and GNATprove modes,
1488 -- unless this is a subunit.
1490 if Back_End_Mode
= Declarations_Only
1492 (not (Back_Annotate_Rep_Info
or Generate_SCIL
or GNATprove_Mode
)
1493 or else Main_Unit_Kind
= N_Subunit
1494 or else ASIS_GNSA_Mode
)
1496 Post_Compilation_Validation_Checks
;
1497 Errout
.Finalize
(Last_Call
=> True);
1498 Errout
.Output_Messages
;
1499 Write_ALI
(Object
=> False);
1504 if not (Generate_SCIL
or GNATprove_Mode
) then
1511 -- Ensure that we properly register a dependency on system.ads, since
1512 -- even if we do not semantically depend on this, Targparm has read
1513 -- system parameters from the system.ads file.
1515 Lib
.Writ
.Ensure_System_Dependency
;
1517 -- Add dependencies, if any, on preprocessing data file and on
1518 -- preprocessing definition file(s).
1520 Prepcomp
.Add_Dependencies
;
1522 if GNATprove_Mode
then
1524 -- Perform the new SPARK checking rules for pointer aliasing. This is
1525 -- only activated in GNATprove mode and on SPARK code.
1527 if Debug_Flag_FF
then
1528 Check_Safe_Pointers
(Main_Unit_Node
);
1531 -- In GNATprove mode we're writing the ALI much earlier than usual
1532 -- as flow analysis needs the file present in order to append its
1533 -- own globals to it.
1535 -- Note: In GNATprove mode, an "object" file is always generated as
1536 -- the result of calling gnat1 or gnat2why, although this is not the
1537 -- same as the object file produced for compilation.
1539 Write_ALI
(Object
=> True);
1542 -- Some back ends (for instance Gigi) are known to rely on SCOs for code
1543 -- generation. Make sure they are available.
1545 if Generate_SCO
then
1546 Par_SCO
.SCO_Record_Filtered
;
1549 -- Back end needs to explicitly unlock tables it needs to touch
1563 -- Here we call the back end to generate the output code
1565 Generating_Code
:= True;
1566 Back_End
.Call_Back_End
(Back_End_Mode
);
1568 -- Once the backend is complete, we unlock the names table. This call
1569 -- allows a few extra entries, needed for example for the file name
1570 -- for the library file output.
1574 -- Generate the call-graph output of dispatching calls
1576 Exp_CG
.Generate_CG_Output
;
1578 -- Perform post compilation validation checks
1580 Post_Compilation_Validation_Checks
;
1582 -- Now we complete output of errors, rep info and the tree info. These
1583 -- are delayed till now, since it is perfectly possible for gigi to
1584 -- generate errors, modify the tree (in particular by setting flags
1585 -- indicating that elaboration is required, and also to back annotate
1586 -- representation information for List_Rep_Info).
1588 Errout
.Finalize
(Last_Call
=> True);
1589 Errout
.Output_Messages
;
1590 Repinfo
.List_Rep_Info
(Ttypes
.Bytes_Big_Endian
);
1591 Inline
.List_Inlining_Info
;
1593 -- Only write the library if the backend did not generate any error
1594 -- messages. Otherwise signal errors to the driver program so that
1595 -- there will be no attempt to generate an object file.
1597 if Compilation_Errors
then
1599 Exit_Program
(E_Errors
);
1602 if not GNATprove_Mode
then
1603 Write_ALI
(Object
=> (Back_End_Mode
= Generate_Object
));
1606 if not Compilation_Errors
then
1608 -- In case of ada backends, we need to make sure that the generated
1609 -- object file has a timestamp greater than the ALI file. We do this
1610 -- to make gnatmake happy when checking the ALI and obj timestamps,
1611 -- where it expects the object file being written after the ali file.
1613 -- Gnatmake's assumption is true for gcc platforms where the gcc
1614 -- wrapper needs to call the assembler after calling gnat1, but is
1615 -- not true for ada backends, where the object files are created
1616 -- directly by gnat1 (so are created before the ali file).
1618 Back_End
.Gen_Or_Update_Object_File
;
1621 -- Generate ASIS tree after writing the ALI file, since in ASIS mode,
1622 -- Write_ALI may in fact result in further tree decoration from the
1623 -- original tree file. Note that we dump the tree just before generating
1624 -- it, so that the dump will exactly reflect what is written out.
1629 -- Finalize name table and we are all done
1634 -- Handle fatal internal compiler errors
1636 when Rtsfind
.RE_Not_Available
=>
1637 Comperr
.Compiler_Abort
("RE_Not_Available");
1639 when System
.Assertions
.Assert_Failure
=>
1640 Comperr
.Compiler_Abort
("Assert_Failure");
1642 when Constraint_Error
=>
1643 Comperr
.Compiler_Abort
("Constraint_Error");
1645 when Program_Error
=>
1646 Comperr
.Compiler_Abort
("Program_Error");
1648 -- Assume this is a bug. If it is real, the message will in any case
1649 -- say Storage_Error, giving a strong hint.
1651 when Storage_Error
=>
1652 Comperr
.Compiler_Abort
("Storage_Error");
1654 when Unrecoverable_Error
=>
1658 Comperr
.Compiler_Abort
("exception");
1664 -- The outer exception handler handles an unrecoverable error
1667 when Unrecoverable_Error
=>
1668 Errout
.Finalize
(Last_Call
=> True);
1669 Errout
.Output_Messages
;
1672 Write_Str
("compilation abandoned");
1675 Set_Standard_Output
;
1678 Exit_Program
(E_Errors
);