1 ------------------------------------------------------------------------------
3 -- GNAT RUN-TIME COMPONENTS --
9 -- Copyright (C) 1999-2015, 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 -- This package obtains parameters from the target runtime version of System,
27 -- to indicate parameters relevant to the target environment.
29 -- Conceptually, these parameters could be obtained using rtsfind, but
30 -- we do not do this for four reasons:
32 -- 1. Compiling System for every compilation wastes time
34 -- 2. This compilation impedes debugging by adding extra compile steps
36 -- 3. There are recursion problems coming from compiling System itself
37 -- or any of its children.
39 -- 4. The binder also needs the parameters, and we do not want to have
40 -- to drag a lot of front end stuff into the binder.
42 -- For all these reasons, we read in the source of System, and then scan
43 -- it at the text level to extract the parameter values.
45 -- Note however, that later on, when the ali file is written, we make sure
46 -- that the System file is at least parsed, so that the checksum is properly
47 -- computed and set in the ali file. This partially negates points 1 and 2
48 -- above although just parsing is quick and does not impact debugging much.
50 -- The parameters acquired by this routine from system.ads fall into four
53 -- 1. Configuration pragmas, that must appear at the start of the file.
54 -- Any such pragmas automatically apply to any unit compiled in the
55 -- presence of this system file. Only a limited set of such pragmas
56 -- may appear as documented in the corresponding section below,
58 -- 2. Target parameters. These are boolean constants that are defined
59 -- in the private part of the package giving fixed information
60 -- about the target architecture, and the capabilities of the
61 -- code generator and run-time library.
63 -- 3. Identification information. This is an optional string constant
64 -- that gives the name of the run-time library configuration. This
65 -- line may be omitted for a version of system.ads to be used with
66 -- the full Ada 95 run time.
68 -- 4. Other characteristics of package System. At the current time the
69 -- only item in this category is whether type Address is private.
71 with Rident
; use Rident
;
72 with Namet
; use Namet
;
73 with Types
; use Types
;
77 ---------------------------
78 -- Configuration Pragmas --
79 ---------------------------
81 -- The following switches get set if the corresponding configuration
82 -- pragma is scanned from the source of system.ads. No other pragmas
83 -- are permitted to appear at the start of the system.ads source file.
85 -- If a pragma Discard_Names appears, then Opt.Global_Discard_Names is
86 -- set to True to indicate that all units must be compiled in this mode.
88 -- If a pragma Locking_Policy appears, then Opt.Locking_Policy is set
89 -- to the first character of the policy name, and Opt.Locking_Policy_Sloc
90 -- is set to System_Location.
92 -- If a pragma Normalize_Scalars appears, then Opt.Normalize_Scalars
93 -- is set True, as well as Opt.Init_Or_Norm_Scalars.
95 -- If a pragma Queuing_Policy appears, then Opt.Queuing_Policy is set
96 -- to the first character of the policy name, and Opt.Queuing_Policy_Sloc
97 -- is set to System_Location.
99 -- If a pragma Task_Dispatching_Policy appears, then the flag
100 -- Opt.Task_Dispatching_Policy is set to the first character of the
101 -- policy name, and Opt.Task_Dispatching_Policy_Sloc is set to
104 -- If a pragma Polling (On) appears, then the flag Opt.Polling_Required
107 -- If a pragma Detect_Blocking appears, then the flag Opt.Detect_Blocking
110 -- if a pragma Suppress_Exception_Locations appears, then the flag
111 -- Opt.Exception_Locations_Suppressed is set to True.
113 -- If a pragma Profile with a valid profile argument appears, then
114 -- the appropriate restrictions and policy flags are set.
116 -- The only other pragma allowed is a pragma Restrictions that specifies
117 -- a restriction that will be imposed on all units in the partition. Note
118 -- that in this context, only one restriction can be specified in a single
119 -- pragma, and the pragma must appear on its own on a single source line.
121 -- If package System contains exactly the line "type Address is private;"
122 -- then the flag Opt.Address_Is_Private is set True, otherwise this flag
125 Restrictions_On_Target
: Restrictions_Info
:= No_Restrictions
;
126 -- Records restrictions specified by system.ads. Only the Set and Value
127 -- members are modified. The Violated and Count fields are never modified.
128 -- Note that entries can be set either by a pragma Restrictions or by
135 -- This parameter should be regarded as read only by all clients of
136 -- of package. The only way they get modified is by calling the
137 -- Get_Target_Parameters routine which reads the values from a provided
138 -- text buffer containing the source of the system package.
140 -- The corresponding string constant is placed immediately at the start
141 -- of the private part of system.ads if is present, e.g. in the form:
143 -- Run_Time_Name : constant String := "Zero Footprint Run Time";
145 -- the corresponding messages will look something like
147 -- xxx not supported (Zero Footprint Run Time)
149 Run_Time_Name_On_Target
: Name_Id
:= No_Name
;
150 -- Set to appropriate names table entry Id value if a Run_Time_Name
151 -- string constant is defined in system.ads. This name is used only
152 -- for the configurable run-time case, and is used to parameterize
153 -- messages that complain about non-supported run-time features.
154 -- The name should contain only letters A-Z, digits 1-9, spaces,
157 --------------------------
158 -- Executable Extension --
159 --------------------------
161 Executable_Extension_On_Target
: Name_Id
:= No_Name
;
162 -- Executable extension on the target. This name is useful for setting
163 -- the executable extension in a dynamic way, e.g. depending on the
164 -- run time used, rather than using a configure-time macro as done by
165 -- Get_Target_Executable_Suffix. If not set (No_Name), instead use
166 -- System.OS_Lib.Get_Target_Executable_Suffix.
168 -----------------------
169 -- Target Parameters --
170 -----------------------
172 -- The following parameters correspond to the variables defined in the
173 -- private part of System (without the terminating _On_Target). Note
174 -- that it is required that all parameters defined here be specified
175 -- in the target specific version of system.ads. Thus, to add a new
176 -- parameter, add it to all system*.ads files. (There is a defaulting
177 -- mechanism, but we don't normally take advantage of it, as explained
180 -- The default values here are used if no value is found in system.ads.
181 -- This should normally happen if the special version of system.ads used
182 -- by the compiler itself is in use or if the value is only relevant to a
183 -- particular target (e.g. AAMP). The default values are suitable for use
184 -- in normal environments. This approach allows the possibility of new
185 -- versions of the compiler (possibly with new system parameters added)
186 -- being used to compile older versions of the compiler sources, as well as
187 -- avoiding duplicating values in all system-*.ads files for flags that are
188 -- used on a few platforms only.
190 -- All these parameters should be regarded as read only by all clients
191 -- of the package. The only way they get modified is by calling the
192 -- Get_Target_Parameters routine which reads the values from a provided
193 -- text buffer containing the source of the system package.
195 ----------------------------
196 -- Special Target Control --
197 ----------------------------
199 -- The great majority of GNAT ports are based on GCC. The switches in
200 -- this section indicate the use of some non-standard target back end
201 -- or other special targetting requirements.
203 AAMP_On_Target
: Boolean := False;
204 -- Set to True if target is AAMP
206 type Virtual_Machine_Kind
is (No_VM
, JVM_Target
, CLI_Target
);
207 VM_Target
: Virtual_Machine_Kind
:= No_VM
;
208 -- Kind of virtual machine targetted
209 -- No_VM: no virtual machine, default case of a standard processor
210 -- JVM_Target: Java Virtual Machine
211 -- CLI_Target: CLI/.NET Virtual Machine
213 -------------------------------
214 -- Backend Arithmetic Checks --
215 -------------------------------
217 -- Divide and overflow checks are either done in the front end or
218 -- back end. The front end will generate checks when required unless
219 -- the corresponding parameter here is set to indicate that the back
220 -- end will generate the required checks (or that the checks are
221 -- automatically performed by the hardware in an appropriate form).
223 Backend_Divide_Checks_On_Target
: Boolean := False;
224 -- Set True if the back end generates divide checks, or if the hardware
225 -- checks automatically. Set False if the front end must generate the
226 -- required tests using explicit expanded code.
228 Backend_Overflow_Checks_On_Target
: Boolean := False;
229 -- Set True if the back end generates arithmetic overflow checks, or if
230 -- the hardware checks automatically. Set False if the front end must
231 -- generate the required tests using explicit expanded code.
233 -----------------------------------
234 -- Control of Exception Handling --
235 -----------------------------------
237 -- GNAT implements three methods of implementing exceptions:
239 -- Front-End Longjmp/Setjmp Exceptions
241 -- This approach uses longjmp/setjmp to handle exceptions. It
242 -- uses less storage, and can often propagate exceptions faster,
243 -- at the expense of (sometimes considerable) overhead in setting
244 -- up an exception handler. This approach is available on all
245 -- targets, and is the default where it is the only approach.
247 -- The generation of the setjmp and longjmp calls is handled by
248 -- the front end of the compiler (this includes gigi in the case
249 -- of the standard GCC back end). It does not use any back end
250 -- support (such as the GCC3 exception handling mechanism). When
251 -- this approach is used, the compiler generates special exception
252 -- handlers for handling cleanups when an exception is raised.
254 -- Front-End Zero Cost Exceptions
256 -- This approach uses separate exception tables. These use extra
257 -- storage, and exception propagation can be quite slow, but there
258 -- is no overhead in setting up an exception handler (it is to this
259 -- latter operation that the phrase zero-cost refers). This approach
260 -- is only available on some targets, and is the default where it is
263 -- The generation of the exception tables is handled by the front
264 -- end of the compiler. It does not use any back end support (such
265 -- as the GCC3 exception handling mechanism). When this approach
266 -- is used, the compiler generates special exception handlers for
267 -- handling cleanups when an exception is raised.
269 -- Back-End Zero Cost Exceptions
271 -- With this approach, the back end handles the generation and
272 -- handling of exceptions. For example, the GCC3 exception handling
273 -- mechanisms are used in this mode. The front end simply generates
274 -- code for explicit exception handlers, and AT END cleanup handlers
275 -- are simply passed unchanged to the backend for generating cleanups
276 -- both in the exceptional and non-exceptional cases.
278 -- As the name implies, this approach generally uses a zero-cost
279 -- mechanism with tables, but the tables are generated by the back
280 -- end. However, since the back-end is entirely responsible for the
281 -- handling of exceptions, another mechanism might be used. In the
282 -- case of GCC3 for instance, it might be the case that the compiler
283 -- is configured for setjmp/longjmp handling, then everything will
284 -- work correctly. However, it is definitely preferred that the
285 -- back end provide zero cost exception handling.
287 -- Controlling the selection of methods
289 -- On most implementations, back-end zero-cost exceptions are used.
290 -- Otherwise, Front-End Longjmp/Setjmp approach is used.
291 -- Note that there is a requirement that all Ada units in a partition
292 -- be compiled with the same exception model.
294 -- Control of Available Methods and Defaults
296 -- The following switches specify whether ZCX is available, and
297 -- whether it is enabled by default.
299 ZCX_By_Default_On_Target
: Boolean := False;
300 -- Indicates if zero cost exceptions are active by default. If this
301 -- variable is False, then the only possible exception method is the
302 -- front-end setjmp/longjmp approach, and this is the default. If
303 -- this variable is True, then GCC ZCX is used.
305 ------------------------------------
306 -- Run-Time Library Configuration --
307 ------------------------------------
309 -- In configurable run-time mode, the system run-time may not support
310 -- the full Ada language. The effect of setting this switch is to let
311 -- the compiler know that it is not surprising (i.e. the system is not
312 -- misconfigured) if run-time library units or entities within units are
313 -- not present in the run-time.
315 Configurable_Run_Time_On_Target
: Boolean := False;
316 -- Indicates that the system.ads file is for a configurable run-time
318 -- This has some specific effects as follows
320 -- The binder generates the gnat_argc/argv/envp variables in the
321 -- binder file instead of being imported from the run-time library.
322 -- If Command_Line_Args_On_Target is set to False, then the
323 -- generation of these variables is suppressed completely.
325 -- The binder generates the gnat_exit_status variable in the binder
326 -- file instead of being imported from the run-time library. If
327 -- Exit_Status_Supported_On_Target is set to False, then the
328 -- generation of this variable is suppressed entirely.
330 -- The routine __gnat_break_start is defined within the binder file
331 -- instead of being imported from the run-time library.
333 -- The variable __gnat_exit_status is generated within the binder file
334 -- instead of being imported from the run-time library.
336 Suppress_Standard_Library_On_Target
: Boolean := False;
337 -- If this flag is True, then the standard library is not included by
338 -- default in the executable (see unit System.Standard_Library in file
339 -- s-stalib.ads for details of what this includes). This is for example
340 -- set True for the zero foot print case, where these files should not
341 -- be included by default.
343 -- This flag has some other related effects:
345 -- The generation of global variables in the bind file is suppressed,
346 -- with the exception of the priority of the environment task, which
347 -- is needed by the Ravenscar run-time.
349 -- The calls to __gnat_initialize and __gnat_finalize are omitted
351 -- All finalization and initialization (controlled types) is omitted
353 Preallocated_Stacks_On_Target
: Boolean := False;
354 -- If this flag is True, then the expander preallocates all task stacks
355 -- at compile time. If the flag is False, then task stacks are not pre-
356 -- allocated, and task stack allocation is the responsibility of the
357 -- run-time (which typically delegates the task to the underlying
358 -- operating system environment).
360 ---------------------
361 -- Duration Format --
362 ---------------------
364 -- By default, type Duration is a 64-bit fixed-point type with a delta
365 -- and small of 10**(-9) (i.e. it is a count in nanoseconds). This flag
366 -- allows that standard format to be modified.
368 Duration_32_Bits_On_Target
: Boolean := False;
369 -- If True, then Duration is represented in 32 bits and the delta and
370 -- small values are set to 20.0*(10**(-3)) (i.e. it is a count in units
371 -- of 20 milliseconds).
373 ------------------------------------
374 -- Back-End Code Generation Flags --
375 ------------------------------------
377 -- These flags indicate possible limitations in what the code generator
378 -- can handle. They will all be True for a full run-time, but one or more
379 -- of these may be false for a configurable run-time, and if a feature is
380 -- used at the source level, and the corresponding flag is false, then an
381 -- error message will be issued saying the feature is not supported.
383 Atomic_Sync_Default_On_Target
: Boolean := True;
384 -- Access to atomic variables requires memory barrier synchronization in
385 -- the general case to ensure proper behavior when such accesses are used
386 -- on a multi-processor to synchronize tasks (e.g. by using spin locks).
387 -- The setting of this flag determines the default behavior. Normally this
388 -- is True, which will mean that appropriate synchronization instructions
389 -- are generated by default. If it is False, then the default will be that
390 -- these synchronization instructions are not generated. This may be a more
391 -- appropriate default in some cases, e.g. on embedded targets which do not
392 -- allow the possibility of multi-processors. The default can be overridden
393 -- using pragmas Enable/Disable_Atomic_Synchronization and also by use of
394 -- the corresponding debug flags -gnatd.e and -gnatd.d.
396 Support_Aggregates_On_Target
: Boolean := True;
397 -- In the general case, the use of aggregates may generate calls
398 -- to run-time routines in the C library, including memset, memcpy,
399 -- memmove, and bcopy. This flag is set to True if these routines
400 -- are available. If any of these routines is not available, then
401 -- this flag is False, and the use of aggregates is not permitted.
403 Support_Atomic_Primitives_On_Target
: Boolean := False;
404 -- If this flag is True, then the back-end support GCC built-in atomic
405 -- operations for memory model such as atomic load or atomic compare
406 -- exchange (see the GCC manual for more information). If the flag is
407 -- False, then the back-end doesn't provide this support. Note this flag is
408 -- set to True only if the target supports all atomic primitives up to 64
409 -- bits. ??? To be modified.
411 Support_Composite_Assign_On_Target
: Boolean := True;
412 -- The assignment of composite objects other than small records and
413 -- arrays whose size is 64-bits or less and is set by an explicit
414 -- size clause may generate calls to memcpy, memmove, and bcopy.
415 -- If versions of all these routines are available, then this flag
416 -- is set to True. If any of these routines is not available, then
417 -- the flag is set False, and composite assignments are not allowed.
419 Support_Composite_Compare_On_Target
: Boolean := True;
420 -- If this flag is True, then the back end supports bit-wise comparison
421 -- of composite objects for equality, either generating inline code or
422 -- calling appropriate (and available) run-time routines. If this flag
423 -- is False, then the back end does not provide this support, and the
424 -- front end uses component by component comparison for composites.
426 Support_Long_Shifts_On_Target
: Boolean := True;
427 -- If True, the back end supports 64-bit shift operations. If False, then
428 -- the source program may not contain explicit 64-bit shifts. In addition,
429 -- the code generated for packed arrays will avoid the use of long shifts.
431 Support_Nondefault_SSO_On_Target
: Boolean := True;
432 -- If True, the back end supports the non-default Scalar_Storage_Order
433 -- (i.e. allows non-confirming Scalar_Storage_Order attribute definition
440 Always_Compatible_Rep_On_Target
: Boolean := True;
441 -- If True, the Can_Use_Internal_Rep flag (see Einfo) is set to False in
442 -- all cases. This corresponds to the traditional code generation
443 -- strategy. False allows the front end to choose a policy that partly or
444 -- entirely eliminates dynamically generated trampolines.
446 -------------------------------
447 -- Control of Stack Checking --
448 -------------------------------
450 -- GNAT provides three methods of implementing exceptions:
452 -- GCC Probing Mechanism
454 -- This approach uses the standard GCC mechanism for
455 -- stack checking. The method assumes that accessing
456 -- storage immediately beyond the end of the stack
457 -- will result in a trap that is converted to a storage
458 -- error by the runtime system. This mechanism has
459 -- minimal overhead, but requires complex hardware,
460 -- operating system and run-time support. Probing is
461 -- the default method where it is available. The stack
462 -- size for the environment task depends on the operating
463 -- system and cannot be set in a system-independent way.
465 -- GCC Stack-limit Mechanism
467 -- This approach uses the GCC stack limits mechanism.
468 -- It relies on comparing the stack pointer with the
469 -- values of a global symbol. If the check fails, a
470 -- trap is explicitly generated. The advantage is
471 -- that the mechanism requires no memory protection,
472 -- but operating system and run-time support are
473 -- needed to manage the per-task values of the symbol.
474 -- This is the default method after probing where it
477 -- GNAT Stack-limit Checking
479 -- This method relies on comparing the stack pointer
480 -- with per-task stack limits. If the check fails, an
481 -- exception is explicitly raised. The advantage is
482 -- that the method requires no extra system dependent
483 -- runtime support and can be used on systems without
484 -- memory protection as well, but at the cost of more
485 -- overhead for doing the check. This is the fallback
486 -- method if the above two are not supported.
488 Stack_Check_Probes_On_Target
: Boolean := False;
489 -- Indicates if the GCC probing mechanism is used
491 Stack_Check_Limits_On_Target
: Boolean := False;
492 -- Indicates if the GCC stack-limit mechanism is used
494 -- Both flags cannot be simultaneously set to True. If neither
495 -- is, the target independent fallback method is used.
497 Stack_Check_Default_On_Target
: Boolean := False;
498 -- Indicates if stack checking is on by default
500 ----------------------------
501 -- Command Line Arguments --
502 ----------------------------
504 -- For most ports of GNAT, command line arguments are supported. The
505 -- following flag is set to False for targets that do not support
506 -- command line arguments (VxWorks and AAMP). Note that support of
507 -- command line arguments is not required on such targets (RM A.15(13)).
509 Command_Line_Args_On_Target
: Boolean := True;
510 -- Set False if no command line arguments on target. Note that if this
511 -- is False in with Configurable_Run_Time_On_Target set to True, then
512 -- this causes suppression of generation of the argv/argc variables
513 -- used to record command line arguments.
515 -- Similarly, most ports support the use of an exit status, but AAMP
516 -- is an exception (as allowed by RM A.15(18-20))
518 Exit_Status_Supported_On_Target
: Boolean := True;
519 -- Set False if returning of an exit status is not supported on target.
520 -- Note that if this False in with Configurable_Run_Time_On_Target
521 -- set to True, then this causes suppression of the gnat_exit_status
522 -- variable used to record the exit status.
524 -----------------------
525 -- Main Program Name --
526 -----------------------
528 -- When the binder generates the main program to be used to create the
529 -- executable, the main program name is main by default (to match the
530 -- usual Unix practice). If this parameter is set to True, then the
531 -- name is instead by default taken from the actual Ada main program
532 -- name (just the name of the child if the main program is a child unit).
533 -- In either case, this value can be overridden using -M name.
535 Use_Ada_Main_Program_Name_On_Target
: Boolean := False;
536 -- Set True to use the Ada main program name as the main name
538 ----------------------------------------------
539 -- Boolean-Valued Floating-Point Attributes --
540 ----------------------------------------------
542 -- The constants below give the values for representation oriented
543 -- floating-point attributes that are the same for all float types
544 -- on the target. These are all boolean values.
546 -- A value is only True if the target reliably supports the corresponding
547 -- feature. Reliably here means that support is guaranteed for all
548 -- possible settings of the relevant compiler switches (like -mieee),
549 -- since we cannot control the user setting of those switches.
551 -- The attributes cannot dependent on the current setting of compiler
552 -- switches, since the values must be static and consistent throughout
553 -- the partition. We probably should add such consistency checks in future,
554 -- but for now we don't do this.
556 -- Note: the compiler itself does not use floating-point, so the
557 -- settings of the defaults here are not really relevant.
559 -- Note: in some cases, proper support of some of these floating point
560 -- features may require a specific switch (e.g. -mieee on the Alpha)
561 -- to be used to obtain full RM compliant support.
563 Denorm_On_Target
: Boolean := False;
564 -- Set to False on targets that do not reliably support denormals
566 Machine_Rounds_On_Target
: Boolean := True;
567 -- Set to False for targets where S'Machine_Rounds is False
569 Machine_Overflows_On_Target
: Boolean := False;
570 -- Set to True for targets where S'Machine_Overflows is True
572 Signed_Zeros_On_Target
: Boolean := True;
573 -- Set to False on targets that do not reliably support signed zeros
575 -------------------------------------------
576 -- Boolean-Valued Fixed-Point Attributes --
577 -------------------------------------------
579 Fractional_Fixed_Ops_On_Target
: Boolean := False;
580 -- Set to True for targets that support fixed-by-fixed multiplication
581 -- and division for fixed-point types with a small value equal to
582 -- 2 ** (-(T'Object_Size - 1)) and whose values have an absolute
583 -- value less than 1.0.
589 -- Normally when using the GCC backend, Gigi and GCC perform much of the
590 -- data layout using the standard layout capabilities of GCC. If the
591 -- parameter Backend_Layout is set to False, then the front end must
592 -- perform all data layout. For further details see the package Layout.
594 Frontend_Layout_On_Target
: Boolean := False;
595 -- Set True if front end does layout
601 -- These subprograms are used to initialize the target parameter values
602 -- from the system.ads file. Note that this is only done once, so if more
603 -- than one call is made to either routine, the second and subsequent
604 -- calls are ignored. It also reads restriction pragmas from system.ads
605 -- and records them, though as further detailed below, the caller has some
606 -- control over the handling of No_Dependence restrictions.
608 type Make_Id_Type
is access function (Str
: Text_Buffer
) return Node_Id
;
609 -- Parameter type for Get_Target_Parameters for function that creates an
610 -- identifier node with Sloc value System_Location and given string as the
613 type Make_SC_Type
is access function (Pre
, Sel
: Node_Id
) return Node_Id
;
614 -- Parameter type for Get_Target_Parameters for function that creates a
615 -- selected component with Sloc value System_Location and given Prefix
616 -- (Pre) and Selector (Sel) values.
618 type Set_RND_Type
is access procedure (Unit
: Node_Id
);
619 -- Parameter type for Get_Target_Parameters that records a Restriction
620 -- No_Dependence for the given unit (identifier or selected component).
622 procedure Get_Target_Parameters
623 (System_Text
: Source_Buffer_Ptr
;
624 Source_First
: Source_Ptr
;
625 Source_Last
: Source_Ptr
;
626 Make_Id
: Make_Id_Type
:= null;
627 Make_SC
: Make_SC_Type
:= null;
628 Set_RND
: Set_RND_Type
:= null);
629 -- Called at the start of execution to obtain target parameters from
630 -- the source of package System. The parameters provide the source
631 -- text to be scanned (in System_Text (Source_First .. Source_Last)).
632 -- if the three subprograms are left at their default value of null,
633 -- Get_Target_Parameters will ignore pragma Restrictions No_Dependence
634 -- lines, otherwise it will use these three subprograms to record them.
636 procedure Get_Target_Parameters
637 (Make_Id
: Make_Id_Type
:= null;
638 Make_SC
: Make_SC_Type
:= null;
639 Set_RND
: Set_RND_Type
:= null);
640 -- This version reads in system.ads using Osint. The idea is that the
641 -- caller uses the first version if they have to read system.ads anyway
642 -- (e.g. the compiler) and uses this simpler interface if system.ads is
643 -- not otherwise needed.