1------------------------------------------------------------------------------
2--                                                                          --
3--                        GNAT RUN-TIME COMPONENTS                          --
4--                                                                          --
5--                             T A R G P A R M                              --
6--                                                                          --
7--                                 S p e c                                  --
8--                                                                          --
9--          Copyright (C) 1999-2019, Free Software Foundation, Inc.         --
10--                                                                          --
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.          --
20--                                                                          --
21-- GNAT was originally developed  by the GNAT team at  New York University. --
22-- Extensive contributions were provided by Ada Core Technologies Inc.      --
23--                                                                          --
24------------------------------------------------------------------------------
25
26--  This package obtains parameters from the target runtime version of System,
27--  to indicate parameters relevant to the target environment.
28
29--  Conceptually, these parameters could be obtained using rtsfind, but
30--  we do not do this for four reasons:
31
32--    1. Compiling System for every compilation wastes time
33
34--    2. This compilation impedes debugging by adding extra compile steps
35
36--    3. There are recursion problems coming from compiling System itself
37--        or any of its children.
38
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.
41
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.
44
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.
49
50--  The parameters acquired by this routine from system.ads fall into four
51--  categories:
52
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.
57
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.
62
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.
67
68--     4. Other characteristics of package System. At the current time the
69--        only item in this category is whether type Address is private.
70
71with Rident; use Rident;
72with Namet;  use Namet;
73with Types;  use Types;
74
75package Targparm is
76
77   ---------------------------
78   -- Configuration Pragmas --
79   ---------------------------
80
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.
84
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.
87
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.
91
92   --  If a pragma Normalize_Scalars appears, then Opt.Normalize_Scalars
93   --  is set True, as well as Opt.Init_Or_Norm_Scalars.
94
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.
98
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
102   --  System_Location.
103
104   --  If a pragma Polling (On) appears, then the flag Opt.Polling_Required
105   --  is set to True.
106
107   --  If a pragma Detect_Blocking appears, then the flag Opt.Detect_Blocking
108   --  is set to True.
109
110   --  If a pragma Suppress_Exception_Locations appears, then the flag
111   --  Opt.Exception_Locations_Suppressed is set to True.
112
113   --  If a pragma Profile with a valid profile argument appears, then
114   --  the appropriate restrictions and policy flags are set.
115
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.
120
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
123   --  is set False.
124
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
129   --  a pragma Profile.
130
131   -------------------
132   -- Run Time Name --
133   -------------------
134
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.
139
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:
142
143   --    Run_Time_Name : constant String := "Zero Footprint Run Time";
144
145   --  the corresponding messages will look something like
146
147   --    xxx not supported (Zero Footprint Run Time)
148
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,
155   --  and underscores.
156
157   --------------------------
158   -- Executable Extension --
159   --------------------------
160
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.
167
168   -----------------------
169   -- Target Parameters --
170   -----------------------
171
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
178   --  below.)
179
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.
189
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.
194
195   -------------------------------
196   -- Backend Arithmetic Checks --
197   -------------------------------
198
199   --  Divide and overflow checks are either done in the front end or
200   --  back end. The front end will generate checks when required unless
201   --  the corresponding parameter here is set to indicate that the back
202   --  end will generate the required checks (or that the checks are
203   --  automatically performed by the hardware in an appropriate form).
204
205   Backend_Divide_Checks_On_Target : Boolean := False;
206   --  Set True if the back end generates divide checks, or if the hardware
207   --  checks automatically. Set False if the front end must generate the
208   --  required tests using explicit expanded code.
209
210   Backend_Overflow_Checks_On_Target : Boolean := False;
211   --  Set True if the back end generates arithmetic overflow checks, or if
212   --  the hardware checks automatically. Set False if the front end must
213   --  generate the required tests using explicit expanded code.
214
215   -----------------------------------
216   -- Control of Exception Handling --
217   -----------------------------------
218
219   --  GNAT implements three methods of implementing exceptions:
220
221   --    Front-End Longjmp/Setjmp Exceptions
222
223   --      This approach uses longjmp/setjmp to handle exceptions. It
224   --      uses less storage, and can often propagate exceptions faster,
225   --      at the expense of (sometimes considerable) overhead in setting
226   --      up an exception handler.
227
228   --      The generation of the setjmp and longjmp calls is handled by
229   --      the front end of the compiler (this includes gigi in the case
230   --      of the standard GCC back end). It does not use any back end
231   --      support (such as the GCC3 exception handling mechanism). When
232   --      this approach is used, the compiler generates special exception
233   --      handlers for handling cleanups (AT-END actions) when an exception
234   --      is raised.
235
236   --    Back-End Zero Cost Exceptions
237
238   --      With this approach, the back end handles the generation and
239   --      handling of exceptions. For example, the GCC3 exception handling
240   --      mechanisms are used in this mode. The front end simply generates
241   --      code for explicit exception handlers, and AT-END cleanup handlers
242   --      are simply passed unchanged to the backend for generating cleanups
243   --      both in the exceptional and non-exceptional cases.
244
245   --      As the name implies, this approach uses a table-based mechanism,
246   --      which incurs no setup when entering a region covered by handlers
247   --      but requires complex unwinding to walk up the call chain and search
248   --      for handlers at propagation time.
249
250   --    Back-End Setjmp/Longjmp Exceptions
251
252   --      With this approach, the back end also handles the generation and
253   --      handling of exceptions, using setjmp/longjmp to set up receivers and
254   --      propagate. AT-END actions on exceptional paths are also taken care
255   --      of by the back end and the front end doesn't need to generate
256   --      explicit exception handlers for these.
257
258   --    Control of Available Methods and Defaults
259
260   --      The following switches specify whether we're using a front-end or a
261   --      back-end mechanism and whether this is a zero-cost or a sjlj scheme.
262
263   --      The per-switch default values correspond to the default value of
264   --      Opt.Exception_Mechanism.
265
266   ZCX_By_Default_On_Target : Boolean := False;
267   --  Indicates if zero cost scheme for exceptions
268
269   Frontend_Exceptions_On_Target : Boolean := True;
270   --  Indicates if we're using a front-end scheme for exceptions
271
272   ------------------------------------
273   -- Run-Time Library Configuration --
274   ------------------------------------
275
276   --  In configurable run-time mode, the system run-time may not support
277   --  the full Ada language. The effect of setting this switch is to let
278   --  the compiler know that it is not surprising (i.e. the system is not
279   --  misconfigured) if run-time library units or entities within units are
280   --  not present in the run-time.
281
282   Configurable_Run_Time_On_Target : Boolean := False;
283   --  Indicates that the system.ads file is for a configurable run-time
284   --
285   --  This has some specific effects as follows
286   --
287   --    The binder generates the gnat_argc/argv/envp variables in the
288   --    binder file instead of being imported from the run-time library.
289   --    If Command_Line_Args_On_Target is set to False, then the
290   --    generation of these variables is suppressed completely.
291   --
292   --    The binder generates the gnat_exit_status variable in the binder
293   --    file instead of being imported from the run-time library. If
294   --    Exit_Status_Supported_On_Target is set to False, then the
295   --    generation of this variable is suppressed entirely.
296   --
297   --    The routine __gnat_break_start is defined within the binder file
298   --    instead of being imported from the run-time library.
299   --
300   --    The variable __gnat_exit_status is generated within the binder file
301   --    instead of being imported from the run-time library.
302
303   Suppress_Standard_Library_On_Target : Boolean := False;
304   --  If this flag is True, then the standard library is not included by
305   --  default in the executable (see unit System.Standard_Library in file
306   --  s-stalib.ads for details of what this includes). This is for example
307   --  set True for the zero foot print case, where these files should not
308   --  be included by default.
309   --
310   --  This flag has some other related effects:
311   --
312   --    The generation of global variables in the bind file is suppressed,
313   --    with the exception of the priority of the environment task, which
314   --    is needed by the Ravenscar run-time.
315   --
316   --    The calls to __gnat_initialize and __gnat_finalize are omitted
317   --
318   --    All finalization and initialization (controlled types) is omitted
319
320   Preallocated_Stacks_On_Target : Boolean := False;
321   --  If this flag is True, then the expander preallocates all task stacks
322   --  at compile time. If the flag is False, then task stacks are not pre-
323   --  allocated, and task stack allocation is the responsibility of the
324   --  run-time (which typically delegates the task to the underlying
325   --  operating system environment).
326
327   ---------------------
328   -- Duration Format --
329   ---------------------
330
331   --  By default, type Duration is a 64-bit fixed-point type with a delta
332   --  and small of 10**(-9) (i.e. it is a count in nanoseconds). This flag
333   --  allows that standard format to be modified.
334
335   Duration_32_Bits_On_Target : Boolean := False;
336   --  If True, then Duration is represented in 32 bits and the delta and
337   --  small values are set to 20.0*(10**(-3)) (i.e. it is a count in units
338   --  of 20 milliseconds).
339
340   ------------------------------------
341   -- Back-End Code Generation Flags --
342   ------------------------------------
343
344   --  These flags indicate possible limitations in what the code generator
345   --  can handle. They will all be True for a full run-time, but one or more
346   --  of these may be false for a configurable run-time, and if a feature is
347   --  used at the source level, and the corresponding flag is false, then an
348   --  error message will be issued saying the feature is not supported.
349
350   Atomic_Sync_Default_On_Target : Boolean := True;
351   --  Access to atomic variables requires memory barrier synchronization in
352   --  the general case to ensure proper behavior when such accesses are used
353   --  on a multi-processor to synchronize tasks (e.g. by using spin locks).
354   --  The setting of this flag determines the default behavior. Normally this
355   --  is True, which will mean that appropriate synchronization instructions
356   --  are generated by default. If it is False, then the default will be that
357   --  these synchronization instructions are not generated. This may be a more
358   --  appropriate default in some cases, e.g. on embedded targets which do not
359   --  allow the possibility of multi-processors. The default can be overridden
360   --  using pragmas Enable/Disable_Atomic_Synchronization and also by use of
361   --  the corresponding debug flags -gnatd.e and -gnatd.d.
362
363   Support_Aggregates_On_Target : Boolean := True;
364   --  In the general case, the use of aggregates may generate calls
365   --  to run-time routines in the C library, including memset, memcpy,
366   --  memmove, and bcopy. This flag is set to True if these routines
367   --  are available. If any of these routines is not available, then
368   --  this flag is False, and the use of aggregates is not permitted.
369
370   Support_Atomic_Primitives_On_Target : Boolean := False;
371   --  If this flag is True, then the back-end support GCC built-in atomic
372   --  operations for memory model such as atomic load or atomic compare
373   --  exchange (see the GCC manual for more information). If the flag is
374   --  False, then the back-end doesn't provide this support. Note this flag is
375   --  set to True only if the target supports all atomic primitives up to 64
376   --  bits. ??? To be modified.
377
378   Support_Composite_Assign_On_Target : Boolean := True;
379   --  The assignment of composite objects other than small records and
380   --  arrays whose size is 64-bits or less and is set by an explicit
381   --  size clause may generate calls to memcpy, memmove, and bcopy.
382   --  If versions of all these routines are available, then this flag
383   --  is set to True. If any of these routines is not available, then
384   --  the flag is set False, and composite assignments are not allowed.
385
386   Support_Composite_Compare_On_Target : Boolean := True;
387   --  If this flag is True, then the back end supports bit-wise comparison
388   --  of composite objects for equality, either generating inline code or
389   --  calling appropriate (and available) run-time routines. If this flag
390   --  is False, then the back end does not provide this support, and the
391   --  front end uses component by component comparison for composites.
392
393   Support_Long_Shifts_On_Target : Boolean := True;
394   --  If True, the back end supports 64-bit shift operations. If False, then
395   --  the source program may not contain explicit 64-bit shifts. In addition,
396   --  the code generated for packed arrays will avoid the use of long shifts.
397
398   Support_Nondefault_SSO_On_Target : Boolean := True;
399   --  If True, the back end supports the non-default Scalar_Storage_Order
400   --  (i.e. allows non-confirming Scalar_Storage_Order attribute definition
401   --  clauses).
402
403   --------------------
404   -- Indirect Calls --
405   --------------------
406
407   Always_Compatible_Rep_On_Target : Boolean := True;
408   --  If True, the Can_Use_Internal_Rep flag (see Einfo) is set to False in
409   --  all cases. This corresponds to the traditional code generation
410   --  strategy. False allows the front end to choose a policy that partly or
411   --  entirely eliminates dynamically generated trampolines.
412
413   -------------------------------
414   -- Control of Stack Checking --
415   -------------------------------
416
417   --  GNAT provides three methods of implementing exceptions:
418
419   --    GCC Probing Mechanism
420
421   --      This approach uses the standard GCC mechanism for
422   --      stack checking. The method assumes that accessing
423   --      storage immediately beyond the end of the stack
424   --      will result in a trap that is converted to a storage
425   --      error by the runtime system. This mechanism has
426   --      minimal overhead, but requires complex hardware,
427   --      operating system and run-time support. Probing is
428   --      the default method where it is available. The stack
429   --      size for the environment task depends on the operating
430   --      system and cannot be set in a system-independent way.
431
432   --   GCC Stack-limit Mechanism
433
434   --      This approach uses the GCC stack limits mechanism.
435   --      It relies on comparing the stack pointer with the
436   --      values of a global symbol. If the check fails, a
437   --      trap is explicitly generated. The advantage is
438   --      that the mechanism requires no memory protection,
439   --      but operating system and run-time support are
440   --      needed to manage the per-task values of the symbol.
441   --      This is the default method after probing where it
442   --      is available.
443
444   --   GNAT Stack-limit Checking
445
446   --      This method relies on comparing the stack pointer
447   --      with per-task stack limits. If the check fails, an
448   --      exception is explicitly raised. The advantage is
449   --      that the method requires no extra system dependent
450   --      runtime support and can be used on systems without
451   --      memory protection as well, but at the cost of more
452   --      overhead for doing the check. This is the fallback
453   --      method if the above two are not supported.
454
455   Stack_Check_Probes_On_Target : Boolean := False;
456   --  Indicates if the GCC probing mechanism is used
457
458   --  WARNING: There is a matching C declaration of this variable in fe.h
459
460   Stack_Check_Limits_On_Target : Boolean := False;
461   --  Indicates if the GCC stack-limit mechanism is used
462
463   --  Both flags cannot be simultaneously set to True. If neither
464   --  is, the target independent fallback method is used.
465
466   --  WARNING: There is a matching C declaration of this variable in fe.h
467
468   Stack_Check_Default_On_Target : Boolean := False;
469   --  Indicates if stack checking is on by default
470
471   ----------------------------
472   -- Command Line Arguments --
473   ----------------------------
474
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)).
479
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.
485
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))
488
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.
494
495   -----------------------
496   -- Main Program Name --
497   -----------------------
498
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.
505
506   Use_Ada_Main_Program_Name_On_Target : Boolean := False;
507   --  Set True to use the Ada main program name as the main name
508
509   ----------------------------------------------
510   -- Boolean-Valued Floating-Point Attributes --
511   ----------------------------------------------
512
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.
516
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.
521
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.
526
527   --  Note: the compiler itself does not use floating-point, so the
528   --  settings of the defaults here are not really relevant.
529
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.
533
534   Denorm_On_Target : Boolean := False;
535   --  Set to False on targets that do not reliably support denormals
536
537   Machine_Rounds_On_Target : Boolean := True;
538   --  Set to False for targets where S'Machine_Rounds is False
539
540   Machine_Overflows_On_Target : Boolean := False;
541   --  Set to True for targets where S'Machine_Overflows is True
542
543   --  WARNING: There is a matching C declaration of this variable in fe.h
544
545   Signed_Zeros_On_Target : Boolean := True;
546   --  Set to False on targets that do not reliably support signed zeros
547
548   --  WARNING: There is a matching C declaration of this variable in fe.h
549
550   -------------------------------------------
551   -- Boolean-Valued Fixed-Point Attributes --
552   -------------------------------------------
553
554   Fractional_Fixed_Ops_On_Target : Boolean := False;
555   --  Set to True for targets that support fixed-by-fixed multiplication
556   --  and division for fixed-point types with a small value equal to
557   --  2 ** (-(T'Object_Size - 1)) and whose values have an absolute
558   --  value less than 1.0.
559
560   -----------------
561   -- Subprograms --
562   -----------------
563
564   --  These subprograms are used to initialize the target parameter values
565   --  from the system.ads file. Note that this is only done once, so if more
566   --  than one call is made to either routine, the second and subsequent
567   --  calls are ignored. It also reads restriction pragmas from system.ads
568   --  and records them, though as further detailed below, the caller has some
569   --  control over the handling of No_Dependence restrictions.
570
571   type Make_Id_Type is access function (Str : Text_Buffer) return Node_Id;
572   --  Parameter type for Get_Target_Parameters for function that creates an
573   --  identifier node with Sloc value System_Location and given string as the
574   --  Chars value.
575
576   type Make_SC_Type is access function (Pre, Sel : Node_Id) return Node_Id;
577   --  Parameter type for Get_Target_Parameters for function that creates a
578   --  selected component with Sloc value System_Location and given Prefix
579   --  (Pre) and Selector (Sel) values.
580
581   type Set_NOD_Type is access procedure (Unit : Node_Id);
582   --  Parameter type for Get_Target_Parameters that records a Restriction
583   --  No_Dependence for the given unit (identifier or selected component).
584
585   type Set_NSA_Type is access procedure (Asp : Name_Id; OK : out Boolean);
586   --  Parameter type for Get_Target_Parameters that records a Restriction
587   --  No_Specification_Of_Aspect. Asp is the aspect name. OK is set True
588   --  if this is an OK aspect name, and False if it is not an aspect name.
589
590   type Set_NUA_Type is access procedure (Attr : Name_Id; OK : out Boolean);
591   --  Parameter type for Get_Target_Parameters that records a Restriction
592   --  No_Use_Of_Attribute. Attr is the attribute name. OK is set True if
593   --  this is an OK attribute name, and False if it is not an attribute name.
594
595   type Set_NUP_Type is access procedure (Prag : Name_Id; OK : out Boolean);
596   --  Parameter type for Get_Target_Parameters that records a Restriction
597   --  No_Use_Of_Pragma. Prag is the pragma name. OK is set True if this is
598   --  an OK pragma name, and False if it is not a recognized pragma name.
599
600   procedure Get_Target_Parameters
601     (System_Text  : Source_Buffer_Ptr;
602      Source_First : Source_Ptr;
603      Source_Last  : Source_Ptr;
604      Make_Id      : Make_Id_Type := null;
605      Make_SC      : Make_SC_Type := null;
606      Set_NOD      : Set_NOD_Type := null;
607      Set_NSA      : Set_NSA_Type := null;
608      Set_NUA      : Set_NUA_Type := null;
609      Set_NUP      : Set_NUP_Type := null);
610   --  Called at the start of execution to obtain target parameters from the
611   --  source of package System. The parameters provide the source text to be
612   --  scanned (in System_Text (Source_First .. Source_Last)). If the three
613   --  subprograms Make_Id, Make_SC, and Set_NOD are left at their default
614   --  value of null, Get_Target_Parameters will ignore pragma Restrictions
615   --  (No_Dependence) lines; otherwise it will use these three subprograms to
616   --  record them. Similarly, if Set_NUP is left at its default value of null,
617   --  then any occurrences of pragma Restrictions (No_Use_Of_Pragma => XXX)
618   --  will be ignored; otherwise it will use this procedure to record the
619   --  pragma. Similarly for the NSA and NUA cases.
620
621   procedure Get_Target_Parameters
622     (Make_Id : Make_Id_Type := null;
623      Make_SC : Make_SC_Type := null;
624      Set_NOD : Set_NOD_Type := null;
625      Set_NSA : Set_NSA_Type := null;
626      Set_NUA : Set_NUA_Type := null;
627      Set_NUP : Set_NUP_Type := null);
628   --  This version reads in system.ads using Osint. The idea is that the
629   --  caller uses the first version if they have to read system.ads anyway
630   --  (e.g. the compiler) and uses this simpler interface if system.ads is
631   --  not otherwise needed.
632
633end Targparm;
634