1 ------------------------------------------------------------------------------
3 -- GNAT RUN-TIME COMPONENTS --
9 -- Copyright (C) 1999-2006, 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 2, 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 COPYING. If not, write --
19 -- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
20 -- Boston, MA 02110-1301, USA. --
22 -- As a special exception, if other files instantiate generics from this --
23 -- unit, or you link this unit with other files to produce an executable, --
24 -- this unit does not by itself cause the resulting executable to be --
25 -- covered by the GNU General Public License. This exception does not --
26 -- however invalidate any other reasons why the executable file might be --
27 -- covered by the GNU Public License. --
29 -- GNAT was originally developed by the GNAT team at New York University. --
30 -- Extensive contributions were provided by Ada Core Technologies Inc. --
32 ------------------------------------------------------------------------------
34 -- This package obtains parameters from the target runtime version of
35 -- System, to indicate parameters relevant to the target environment.
37 -- Conceptually, these parameters could be obtained using rtsfind, but
38 -- we do not do this for four reasons:
40 -- 1. Compiling System for every compilation wastes time
42 -- 2. This compilation impedes debugging by adding extra compile steps
44 -- 3. There are recursion problems coming from compiling System itself
45 -- or any of its children.
47 -- 4. The binder also needs the parameters, and we do not want to have
48 -- to drag a lot of front end stuff into the binder.
50 -- For all these reasons, we read in the source of System, and then scan
51 -- it at the text level to extract the parameter values.
53 -- Note however, that later on, when the ali file is written, we make sure
54 -- that the System file is at least parsed, so that the checksum is properly
55 -- computed and set in the ali file. This partially negates points 1 and 2
56 -- above although just parsing is quick and does not impact debugging much.
58 -- The parameters acquired by this routine from system.ads fall into four
61 -- 1. Configuration pragmas, that must appear at the start of the file.
62 -- Any such pragmas automatically apply to any unit compiled in the
63 -- presence of this system file. Only a limited set of such pragmas
64 -- may appear as documented in the corresponding section below,
66 -- 2. Target parameters. These are boolean constants that are defined
67 -- in the private part of the package giving fixed information
68 -- about the target architecture, and the capabilities of the
69 -- code generator and run-time library.
71 -- 3. Identification information. This is an optional string constant
72 -- that gives the name of the run-time library configuration. This
73 -- line may be ommitted for a version of system.ads to be used with
74 -- the full Ada 95 run time.
76 -- 4. Other characterisitics of package System. At the current time the
77 -- only item in this category is whether type Address is private.
79 with Rident; use Rident;
80 with Types; use Types;
84 ---------------------------
85 -- Configuration Pragmas --
86 ---------------------------
88 -- The following switches get set if the corresponding configuration
89 -- pragma is scanned from the source of system.ads. No other pragmas
90 -- are permitted to appear at the start of the system.ads source file.
92 -- If a pragma Discard_Names appears, then Opt.Global_Discard_Names is
93 -- set to True to indicate that all units must be compiled in this mode.
95 -- If a pragma Locking_Policy appears, then Opt.Locking_Policy is set
96 -- to the first character of the policy name, and Opt.Locking_Policy_Sloc
97 -- is set to System_Location.
99 -- If a pragma Normalize_Scalars appears, then Opt.Normalize_Scalars
100 -- is set True, as well as Opt.Init_Or_Norm_Scalars.
102 -- If a pragma Queuing_Policy appears, then Opt.Queuing_Policy is set
103 -- to the first character of the policy name, and Opt.Queuing_Policy_Sloc
104 -- is set to System_Location.
106 -- If a pragma Task_Dispatching_Policy appears, then the flag
107 -- Opt.Task_Dispatching_Policy is set to the first character of the
108 -- policy name, and Opt.Task_Dispatching_Policy_Sloc is set to
111 -- If a pragma Polling (On) appears, then the flag Opt.Polling_Required
114 -- If a pragma Detect_Blocking appears, then the flag Opt.Detect_Blocking
117 -- if a pragma Suppress_Exception_Locations appears, then the flag
118 -- Opt.Exception_Locations_Suppressed is set to True.
120 -- If a pragma Profile with a valid profile argument appears, then
121 -- the appropriate restrictions and policy flags are set.
123 -- The only other pragma allowed is a pragma Restrictions that specifies
124 -- a restriction that will be imposed on all units in the partition. Note
125 -- that in this context, only one restriction can be specified in a single
126 -- pragma, and the pragma must appear on its own on a single source line.
128 -- If package System contains exactly the line "type Address is private;"
129 -- then the flag Opt.Address_Is_Private is set True, otherwise this flag
132 Restrictions_On_Target : Restrictions_Info := No_Restrictions;
133 -- Records restrictions specified by system.ads. Only the Set and Value
134 -- members are modified. The Violated and Count fields are never modified.
135 -- Note that entries can be set either by a pragma Restrictions or by
142 -- This parameter should be regarded as read only by all clients of
143 -- of package. The only way they get modified is by calling the
144 -- Get_Target_Parameters routine which reads the values from a provided
145 -- text buffer containing the source of the system package.
147 -- The corresponding string constant is placed immediately at the start
148 -- of the private part of system.ads if is present, e.g. in the form:
150 -- Run_Time_Name : constant String := "Zero Footprint Run Time";
152 -- the corresponding messages will look something like
154 -- xxx not supported (Zero Footprint Run Time)
156 Run_Time_Name_On_Target : Name_Id := No_Name;
157 -- Set to appropriate names table entry Id value if a Run_Time_Name
158 -- string constant is defined in system.ads. This name is used only
159 -- for the configurable run-time case, and is used to parametrize
160 -- messages that complain about non-supported run-time features.
161 -- The name should contain only letters A-Z, digits 1-9, spaces,
164 --------------------------
165 -- Executable Extension --
166 --------------------------
168 Executable_Extension_On_Target : Name_Id := No_Name;
169 -- Executable extension on the target.
170 -- This name is useful for setting the executable extension in a
171 -- dynamic way, e.g. depending on the run-time used, rather than
172 -- using a configure-time macro as done by Get_Target_Executable_Suffix.
173 -- If not set (No_Name), use GNAT.OS_Lib.Get_Target_Executable_Suffix.
175 -----------------------
176 -- Target Parameters --
177 -----------------------
179 -- The following parameters correspond to the variables defined in the
180 -- private part of System (without the terminating _On_Target). Note
181 -- that it is required that all parameters defined here be specified
182 -- in the target specific version of system.ads (there are no defaults).
184 -- All these parameters should be regarded as read only by all clients
185 -- of the package. The only way they get modified is by calling the
186 -- Get_Target_Parameters routine which reads the values from a provided
187 -- text buffer containing the source of the system package.
189 -- The default values here are used if no value is found in system.ads.
190 -- This should normally happen only if the special version of system.ads
191 -- used by the compiler itself is in use. The default values are suitable
192 -- for use by the compiler itself in normal environments. This approach
193 -- allows the possibility of new versions of the compiler (possibly with
194 -- new system parameters added) being used to compile older versions of
195 -- the compiler sources. This is not guaranteed to work, but often will
196 -- and by setting appropriate default values, we make it more likely that
199 Compiler_System_Version : Boolean := True;
200 -- This is set False in all target dependent versions of System. In the
201 -- compiler default version, it is omitted entirely, meaning that the
202 -- above default value of True will be set. If the flag is False, then
203 -- the scanning circuits in the body of this package do an error check to
204 -- ensure that all parameters other than this one are specified and not
205 -- defaulted. If the parameter is set True, then this check is omitted,
206 -- and any parameters not present in system.ads are left set to their
207 -- default value as described above.
209 ----------------------------
210 -- Special Target Control --
211 ----------------------------
213 -- The great majority of GNAT ports are based on GCC. The switches in
214 -- This section indicate the use of some non-standard target back end
215 -- or other special targetting requirements.
217 AAMP_On_Target : Boolean := False;
218 -- Set to True if target is AAMP
220 OpenVMS_On_Target : Boolean := False;
221 -- Set to True if target is OpenVMS
223 -------------------------------
224 -- Backend Arithmetic Checks --
225 -------------------------------
227 -- Divide and overflow checks are either done in the front end or
228 -- back end. The front end will generate checks when required unless
229 -- the corresponding parameter here is set to indicate that the back
230 -- end will generate the required checks (or that the checks are
231 -- automatically performed by the hardware in an appropriate form).
233 Backend_Divide_Checks_On_Target : Boolean := False;
234 -- Set True if the back end generates divide checks, or if the hardware
235 -- checks automatically. Set False if the front end must generate the
236 -- required tests using explicit expanded code.
238 Backend_Overflow_Checks_On_Target : Boolean := False;
239 -- Set True if the back end generates arithmetic overflow checks, or if
240 -- the hardware checks automatically. Set False if the front end must
241 -- generate the required tests using explicit expanded code.
243 -----------------------------------
244 -- Control of Exception Handling --
245 -----------------------------------
247 -- GNAT implements three methods of implementing exceptions:
249 -- Front-End Longjmp/Setjmp Exceptions
251 -- This approach uses longjmp/setjmp to handle exceptions. It
252 -- uses less storage, and can often propagate exceptions faster,
253 -- at the expense of (sometimes considerable) overhead in setting
254 -- up an exception handler. This approach is available on all
255 -- targets, and is the default where it is the only approach.
257 -- The generation of the setjmp and longjmp calls is handled by
258 -- the front end of the compiler (this includes gigi in the case
259 -- of the standard GCC back end). It does not use any back end
260 -- suport (such as the GCC3 exception handling mechanism). When
261 -- this approach is used, the compiler generates special exception
262 -- handlers for handling cleanups when an exception is raised.
264 -- Front-End Zero Cost Exceptions
266 -- This approach uses separate exception tables. These use extra
267 -- storage, and exception propagation can be quite slow, but there
268 -- is no overhead in setting up an exception handler (it is to this
269 -- latter operation that the phrase zero-cost refers). This approach
270 -- is only available on some targets, and is the default where it is
273 -- The generation of the exception tables is handled by the front
274 -- end of the compiler. It does not use any back end support (such
275 -- as the GCC3 exception handling mechanism). When this approach
276 -- is used, the compiler generates special exception handlers for
277 -- handling cleanups when an exception is raised.
279 -- Back-End Zero Cost Exceptions
281 -- With this approach, the back end handles the generation and
282 -- handling of exceptions. For example, the GCC3 exception handling
283 -- mechanisms are used in this mode. The front end simply generates
284 -- code for explicit exception handlers, and AT END cleanup handlers
285 -- are simply passed unchanged to the backend for generating cleanups
286 -- both in the exceptional and non-exceptional cases.
288 -- As the name implies, this approach generally uses a zero-cost
289 -- mechanism with tables, but the tables are generated by the back
290 -- end. However, since the back-end is entirely responsible for the
291 -- handling of exceptions, another mechanism might be used. In the
292 -- case of GCC3 for instance, it might be the case that the compiler
293 -- is configured for setjmp/longjmp handling, then everything will
294 -- work correctly. However, it is definitely preferred that the
295 -- back end provide zero cost exception handling.
297 -- Controlling the selection of methods
299 -- On most implementations, back-end zero-cost exceptions are used.
300 -- Otherwise, Front-End Longjmp/Setjmp approach is used.
301 -- Note that there is a requirement that all Ada units in a partition
302 -- be compiled with the same exception model.
304 -- Control of Available Methods and Defaults
306 -- The following switches specify whether ZCX is available, and
307 -- whether it is enabled by default.
309 ZCX_By_Default_On_Target : Boolean := False;
310 -- Indicates if zero cost exceptions are active by default. If this
311 -- variable is False, then the only possible exception method is the
312 -- front-end setjmp/longjmp approach, and this is the default. If
313 -- this variable is True, then GCC ZCX is used.
315 GCC_ZCX_Support_On_Target : Boolean := False;
316 -- Indicates that the target supports GCC Exceptions
318 ------------------------------------
319 -- Run-Time Library Configuration --
320 ------------------------------------
322 -- In configurable run-time mode, the system run-time may not support
323 -- the full Ada language. The effect of setting this switch is to let
324 -- the compiler know that it is not surprising (i.e. the system is not
325 -- misconfigured) if run-time library units or entities within units are
326 -- not present in the run-time.
328 Configurable_Run_Time_On_Target : Boolean := False;
329 -- Indicates that the system.ads file is for a configurable run-time
331 -- This has some specific effects as follows
333 -- The binder generates the gnat_argc/argv/envp variables in the
334 -- binder file instead of being imported from the run-time library.
335 -- If Command_Line_Args_On_Target is set to False, then the
336 -- generation of these variables is suppressed completely.
338 -- The binder generates the gnat_exit_status variable in the binder
339 -- file instead of being imported from the run-time library. If
340 -- Exit_Status_Supported_On_Target is set to False, then the
341 -- generation of this variable is suppressed entirely.
343 -- The routine __gnat_break_start is defined within the binder file
344 -- instead of being imported from the run-time library.
346 -- The variable __gnat_exit_status is generated within the binder file
347 -- instead of being imported from the run-time library.
349 Suppress_Standard_Library_On_Target : Boolean := False;
350 -- If this flag is True, then the standard library is not included by
351 -- default in the executable (see unit System.Standard_Library in file
352 -- s-stalib.ads for details of what this includes). This is for example
353 -- set True for the zero foot print case, where these files should not
354 -- be included by default.
356 -- This flag has some other related effects:
358 -- The generation of global variables in the bind file is suppressed,
359 -- with the exception of the priority of the environment task, which
360 -- is needed by the Ravenscar run-time.
362 -- The calls to __gnat_initialize and __gnat_finalize are omitted
364 -- All finalization and initialization (controlled types) is omitted
366 -- The routine __gnat_handler_installed is not imported
368 Preallocated_Stacks_On_Target : Boolean := False;
369 -- If this flag is True, then the expander preallocates all task stacks
370 -- at compile time. If the flag is False, then task stacks are not pre-
371 -- allocated, and task stack allocation is the responsibility of the
372 -- run-time (which typically delegates the task to the underlying
373 -- operating system environment).
375 ---------------------
376 -- Duration Format --
377 ---------------------
379 -- By default, type Duration is a 64-bit fixed-point type with a delta
380 -- and small of 10**(-9) (i.e. it is a count in nanoseconds. This flag
381 -- allows that standard format to be modified.
383 Duration_32_Bits_On_Target : Boolean := False;
384 -- If True, then Duration is represented in 32 bits and the delta and
385 -- small values are set to 20.0*(10**(-3)) (i.e. it is a count in units
386 -- of 20 milliseconds.
388 ------------------------------------
389 -- Back-End Code Generation Flags --
390 ------------------------------------
392 -- These flags indicate possible limitations in what the code generator
393 -- can handle. They will all be True for a full run-time, but one or more
394 -- of these may be false for a configurable run-time, and if a feature is
395 -- used at the source level, and the corresponding flag is false, then an
396 -- error message will be issued saying the feature is not supported.
398 Support_64_Bit_Divides_On_Target : Boolean := True;
399 -- If True, the back end supports 64-bit divide operations. If False, then
400 -- the source program may not contain 64-bit divide operations. This is
401 -- specifically useful in the zero foot-print case, where the issue is
402 -- whether there is a hardware divide instruction for 64-bits so that
403 -- no run-time support is required. It should always be set True if the
404 -- necessary run-time support is present.
406 Support_Aggregates_On_Target : Boolean := True;
407 -- In the general case, the use of aggregates may generate calls
408 -- to run-time routines in the C library, including memset, memcpy,
409 -- memmove, and bcopy. This flag is set to True if these routines
410 -- are available. If any of these routines is not available, then
411 -- this flag is False, and the use of aggregates is not permitted.
413 Support_Composite_Assign_On_Target : Boolean := True;
414 -- The assignment of composite objects other than small records and
415 -- arrays whose size is 64-bits or less and is set by an explicit
416 -- size clause may generate calls to memcpy, memmove, and bcopy.
417 -- If versions of all these routines are available, then this flag
418 -- is set to True. If any of these routines is not available, then
419 -- the flag is set False, and composite assignments are not allowed.
421 Support_Composite_Compare_On_Target : Boolean := True;
422 -- If this flag is True, then the back end supports bit-wise comparison
423 -- of composite objects for equality, either generating inline code or
424 -- calling appropriate (and available) run-time routines. If this flag
425 -- is False, then the back end does not provide this support, and the
426 -- front end uses component by component comparison for composites.
428 Support_Long_Shifts_On_Target : Boolean := True;
429 -- If True, the back end supports 64-bit shift operations. If False, then
430 -- the source program may not contain explicit 64-bit shifts. In addition,
431 -- the code generated for packed arrays will avoid the use of long shifts.
433 -------------------------------
434 -- Control of Stack Checking --
435 -------------------------------
437 -- GNAT provides two methods of implementing exceptions:
439 -- GCC Probing Mechanism
441 -- This approach uses the standard GCC mechanism for
442 -- stack checking. The method assumes that accessing
443 -- storage immediately beyond the end of the stack
444 -- will result in a trap that is converted to a storage
445 -- error by the runtime system. This mechanism has
446 -- minimal overhead, but requires complex hardware,
447 -- operating system and run-time support. Probing is
448 -- the default method where it is available. The stack
449 -- size for the environment task depends on the operating
450 -- system and cannot be set in a system-independent way.
452 -- GNAT Stack-limit Checking
454 -- This method relies on comparing the stack pointer
455 -- with per-task stack limits. If the check fails, an
456 -- exception is explicitly raised. The advantage is
457 -- that the method requires no extra system dependent
458 -- runtime support and can be used on systems without
459 -- memory protection as well, but at the cost of more
460 -- overhead for doing the check. This method is the
461 -- default on systems that lack complete support for
464 Stack_Check_Probes_On_Target : Boolean := False;
465 -- Indicates if stack check probes are used, as opposed to the standard
466 -- target independent comparison method.
468 Stack_Check_Default_On_Target : Boolean := False;
469 -- Indicates if stack checking is on by default
471 ----------------------------
472 -- Command Line Arguments --
473 ----------------------------
475 -- For most ports of GNAT, command line arguments are supported. The
476 -- following flag is set to False for targets that do not support
477 -- command line arguments (VxWorks and AAMP). Note that support of
478 -- command line arguments is not required on such targets (RM A.15(13)).
480 Command_Line_Args_On_Target : Boolean := True;
481 -- Set False if no command line arguments on target. Note that if this
482 -- is False in with Configurable_Run_Time_On_Target set to True, then
483 -- this causes suppression of generation of the argv/argc variables
484 -- used to record command line arguments.
486 -- Similarly, most ports support the use of an exit status, but AAMP
487 -- is an exception (as allowed by RM A.15(18-20))
489 Exit_Status_Supported_On_Target : Boolean := True;
490 -- Set False if returning of an exit status is not supported on target.
491 -- Note that if this False in with Configurable_Run_Time_On_Target
492 -- set to True, then this causes suppression of the gnat_exit_status
493 -- variable used to record the exit status.
495 -----------------------
496 -- Main Program Name --
497 -----------------------
499 -- When the binder generates the main program to be used to create the
500 -- executable, the main program name is main by default (to match the
501 -- usual Unix practice). If this parameter is set to True, then the
502 -- name is instead by default taken from the actual Ada main program
503 -- name (just the name of the child if the main program is a child unit).
504 -- In either case, this value can be overridden using -M name.
506 Use_Ada_Main_Program_Name_On_Target : Boolean := False;
507 -- Set True to use the Ada main program name as the main name
509 ----------------------------------------------
510 -- Boolean-Valued Floating-Point Attributes --
511 ----------------------------------------------
513 -- The constants below give the values for representation oriented
514 -- floating-point attributes that are the same for all float types
515 -- on the target. These are all boolean values.
517 -- A value is only True if the target reliably supports the corresponding
518 -- feature. Reliably here means that support is guaranteed for all
519 -- possible settings of the relevant compiler switches (like -mieee),
520 -- since we cannot control the user setting of those switches.
522 -- The attributes cannot dependent on the current setting of compiler
523 -- switches, since the values must be static and consistent throughout
524 -- the partition. We probably should add such consistency checks in future,
525 -- but for now we don't do this.
527 -- Note: the compiler itself does not use floating-point, so the
528 -- settings of the defaults here are not really relevant.
530 -- Note: in some cases, proper support of some of these floating point
531 -- features may require a specific switch (e.g. -mieee on the Alpha)
532 -- to be used to obtain full RM compliant support.
534 Denorm_On_Target : Boolean := False;
535 -- Set to False on targets that do not reliably support denormals
537 Machine_Rounds_On_Target : Boolean := True;
538 -- Set to False for targets where S'Machine_Rounds is False
540 Machine_Overflows_On_Target : Boolean := False;
541 -- Set to True for targets where S'Machine_Overflows is True
543 Signed_Zeros_On_Target : Boolean := True;
544 -- Set to False on targets that do not reliably support signed zeros
546 -------------------------------------------
547 -- Boolean-Valued Fixed-Point Attributes --
548 -------------------------------------------
550 Fractional_Fixed_Ops_On_Target : Boolean := False;
551 -- Set to True for targets that support fixed-by-fixed multiplication
552 -- and division for fixed-point types with a small value equal to
553 -- 2 ** (-(T'Object_Size - 1)) and whose values have an absolute
554 -- value less than 1.0.
560 -- Normally when using the GCC backend, Gigi and GCC perform much of the
561 -- data layout using the standard layout capabilities of GCC. If the
562 -- parameter Backend_Layout is set to False, then the front end must
563 -- perform all data layout. For further details see the package Layout.
565 Frontend_Layout_On_Target : Boolean := False;
566 -- Set True if front end does layout
572 -- These subprograms are used to initialize the target parameter values
573 -- from the system.ads file. Note that this is only done once, so if more
574 -- than one call is made to either routine, the second and subsequent
575 -- calls are ignored.
577 procedure Get_Target_Parameters
578 (System_Text : Source_Buffer_Ptr;
579 Source_First : Source_Ptr;
580 Source_Last : Source_Ptr);
581 -- Called at the start of execution to obtain target parameters from
582 -- the source of package System. The parameters provide the source
583 -- text to be scanned (in System_Text (Source_First .. Source_Last)).
585 procedure Get_Target_Parameters;
586 -- This version reads in system.ads using Osint. The idea is that the
587 -- caller uses the first version if they have to read system.ads anyway
588 -- (e.g. the compiler) and uses this simpler interface if system.ads is
589 -- not otherwise needed.