gcc/ada/targparm.ads

   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-2015, 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
  71 with Rident; use Rident;
  72 with Namet;  use Namet;
  73 with Types;  use Types;
  74
  75 package 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    -- Special Target Control --
 197    ----------------------------
 198
 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.
 202
 203    AAMP_On_Target : Boolean := False;
 204    --  Set to True if target is AAMP
 205
 206    -------------------------------
 207    -- Backend Arithmetic Checks --
 208    -------------------------------
 209
 210    --  Divide and overflow checks are either done in the front end or
 211    --  back end. The front end will generate checks when required unless
 212    --  the corresponding parameter here is set to indicate that the back
 213    --  end will generate the required checks (or that the checks are
 214    --  automatically performed by the hardware in an appropriate form).
 215
 216    Backend_Divide_Checks_On_Target : Boolean := False;
 217    --  Set True if the back end generates divide checks, or if the hardware
 218    --  checks automatically. Set False if the front end must generate the
 219    --  required tests using explicit expanded code.
 220
 221    Backend_Overflow_Checks_On_Target : Boolean := False;
 222    --  Set True if the back end generates arithmetic overflow checks, or if
 223    --  the hardware checks automatically. Set False if the front end must
 224    --  generate the required tests using explicit expanded code.
 225
 226    -----------------------------------
 227    -- Control of Exception Handling --
 228    -----------------------------------
 229
 230    --  GNAT implements three methods of implementing exceptions:
 231
 232    --    Front-End Longjmp/Setjmp Exceptions
 233
 234    --      This approach uses longjmp/setjmp to handle exceptions. It
 235    --      uses less storage, and can often propagate exceptions faster,
 236    --      at the expense of (sometimes considerable) overhead in setting
 237    --      up an exception handler.
 238
 239    --      The generation of the setjmp and longjmp calls is handled by
 240    --      the front end of the compiler (this includes gigi in the case
 241    --      of the standard GCC back end). It does not use any back end
 242    --      support (such as the GCC3 exception handling mechanism). When
 243    --      this approach is used, the compiler generates special exception
 244    --      handlers for handling cleanups (AT-END actions) when an exception
 245    --      is raised.
 246
 247    --    Back-End Zero Cost Exceptions
 248
 249    --      With this approach, the back end handles the generation and
 250    --      handling of exceptions. For example, the GCC3 exception handling
 251    --      mechanisms are used in this mode. The front end simply generates
 252    --      code for explicit exception handlers, and AT-END cleanup handlers
 253    --      are simply passed unchanged to the backend for generating cleanups
 254    --      both in the exceptional and non-exceptional cases.
 255
 256    --      As the name implies, this approach uses a table-based mechanism,
 257    --      which incurs no setup when entering a region covered by handlers
 258    --      but requires complex unwinding to walk up the call chain and search
 259    --      for handlers at propagation time.
 260
 261    --    Back-End Setjmp/Longjmp Exceptions
 262
 263    --      With this approach, the back end also handles the generation and
 264    --      handling of exceptions, using setjmp/longjmp to set up receivers and
 265    --      propagate. AT-END actions on exceptional paths are also taken care
 266    --      of by the back end and the front end doesn't need to generate
 267    --      explicit exception handlers for these.
 268
 269    --    Control of Available Methods and Defaults
 270
 271    --      The following switches specify whether we're using a front-end or a
 272    --      back-end mechanism and whether this is a zero-cost or a sjlj scheme.
 273
 274    --      The per-switch default values correspond to the default value of
 275    --      Opt.Exception_Mechanism.
 276
 277    ZCX_By_Default_On_Target : Boolean := False;
 278    --  Indicates if zero cost scheme for exceptions
 279
 280    Frontend_Exceptions_On_Target : Boolean := True;
 281    --  Indicates if we're using a front-end scheme for exceptions
 282
 283    ------------------------------------
 284    -- Run-Time Library Configuration --
 285    ------------------------------------
 286
 287    --  In configurable run-time mode, the system run-time may not support
 288    --  the full Ada language. The effect of setting this switch is to let
 289    --  the compiler know that it is not surprising (i.e. the system is not
 290    --  misconfigured) if run-time library units or entities within units are
 291    --  not present in the run-time.
 292
 293    Configurable_Run_Time_On_Target : Boolean := False;
 294    --  Indicates that the system.ads file is for a configurable run-time
 295    --
 296    --  This has some specific effects as follows
 297    --
 298    --    The binder generates the gnat_argc/argv/envp variables in the
 299    --    binder file instead of being imported from the run-time library.
 300    --    If Command_Line_Args_On_Target is set to False, then the
 301    --    generation of these variables is suppressed completely.
 302    --
 303    --    The binder generates the gnat_exit_status variable in the binder
 304    --    file instead of being imported from the run-time library. If
 305    --    Exit_Status_Supported_On_Target is set to False, then the
 306    --    generation of this variable is suppressed entirely.
 307    --
 308    --    The routine __gnat_break_start is defined within the binder file
 309    --    instead of being imported from the run-time library.
 310    --
 311    --    The variable __gnat_exit_status is generated within the binder file
 312    --    instead of being imported from the run-time library.
 313
 314    Suppress_Standard_Library_On_Target : Boolean := False;
 315    --  If this flag is True, then the standard library is not included by
 316    --  default in the executable (see unit System.Standard_Library in file
 317    --  s-stalib.ads for details of what this includes). This is for example
 318    --  set True for the zero foot print case, where these files should not
 319    --  be included by default.
 320    --
 321    --  This flag has some other related effects:
 322    --
 323    --    The generation of global variables in the bind file is suppressed,
 324    --    with the exception of the priority of the environment task, which
 325    --    is needed by the Ravenscar run-time.
 326    --
 327    --    The calls to __gnat_initialize and __gnat_finalize are omitted
 328    --
 329    --    All finalization and initialization (controlled types) is omitted
 330
 331    Preallocated_Stacks_On_Target : Boolean := False;
 332    --  If this flag is True, then the expander preallocates all task stacks
 333    --  at compile time. If the flag is False, then task stacks are not pre-
 334    --  allocated, and task stack allocation is the responsibility of the
 335    --  run-time (which typically delegates the task to the underlying
 336    --  operating system environment).
 337
 338    ---------------------
 339    -- Duration Format --
 340    ---------------------
 341
 342    --  By default, type Duration is a 64-bit fixed-point type with a delta
 343    --  and small of 10**(-9) (i.e. it is a count in nanoseconds). This flag
 344    --  allows that standard format to be modified.
 345
 346    Duration_32_Bits_On_Target : Boolean := False;
 347    --  If True, then Duration is represented in 32 bits and the delta and
 348    --  small values are set to 20.0*(10**(-3)) (i.e. it is a count in units
 349    --  of 20 milliseconds).
 350
 351    ------------------------------------
 352    -- Back-End Code Generation Flags --
 353    ------------------------------------
 354
 355    --  These flags indicate possible limitations in what the code generator
 356    --  can handle. They will all be True for a full run-time, but one or more
 357    --  of these may be false for a configurable run-time, and if a feature is
 358    --  used at the source level, and the corresponding flag is false, then an
 359    --  error message will be issued saying the feature is not supported.
 360
 361    Atomic_Sync_Default_On_Target : Boolean := True;
 362    --  Access to atomic variables requires memory barrier synchronization in
 363    --  the general case to ensure proper behavior when such accesses are used
 364    --  on a multi-processor to synchronize tasks (e.g. by using spin locks).
 365    --  The setting of this flag determines the default behavior. Normally this
 366    --  is True, which will mean that appropriate synchronization instructions
 367    --  are generated by default. If it is False, then the default will be that
 368    --  these synchronization instructions are not generated. This may be a more
 369    --  appropriate default in some cases, e.g. on embedded targets which do not
 370    --  allow the possibility of multi-processors. The default can be overridden
 371    --  using pragmas Enable/Disable_Atomic_Synchronization and also by use of
 372    --  the corresponding debug flags -gnatd.e and -gnatd.d.
 373
 374    Support_Aggregates_On_Target : Boolean := True;
 375    --  In the general case, the use of aggregates may generate calls
 376    --  to run-time routines in the C library, including memset, memcpy,
 377    --  memmove, and bcopy. This flag is set to True if these routines
 378    --  are available. If any of these routines is not available, then
 379    --  this flag is False, and the use of aggregates is not permitted.
 380
 381    Support_Atomic_Primitives_On_Target : Boolean := False;
 382    --  If this flag is True, then the back-end support GCC built-in atomic
 383    --  operations for memory model such as atomic load or atomic compare
 384    --  exchange (see the GCC manual for more information). If the flag is
 385    --  False, then the back-end doesn't provide this support. Note this flag is
 386    --  set to True only if the target supports all atomic primitives up to 64
 387    --  bits. ??? To be modified.
 388
 389    Support_Composite_Assign_On_Target : Boolean := True;
 390    --  The assignment of composite objects other than small records and
 391    --  arrays whose size is 64-bits or less and is set by an explicit
 392    --  size clause may generate calls to memcpy, memmove, and bcopy.
 393    --  If versions of all these routines are available, then this flag
 394    --  is set to True. If any of these routines is not available, then
 395    --  the flag is set False, and composite assignments are not allowed.
 396
 397    Support_Composite_Compare_On_Target : Boolean := True;
 398    --  If this flag is True, then the back end supports bit-wise comparison
 399    --  of composite objects for equality, either generating inline code or
 400    --  calling appropriate (and available) run-time routines. If this flag
 401    --  is False, then the back end does not provide this support, and the
 402    --  front end uses component by component comparison for composites.
 403
 404    Support_Long_Shifts_On_Target : Boolean := True;
 405    --  If True, the back end supports 64-bit shift operations. If False, then
 406    --  the source program may not contain explicit 64-bit shifts. In addition,
 407    --  the code generated for packed arrays will avoid the use of long shifts.
 408
 409    Support_Nondefault_SSO_On_Target : Boolean := True;
 410    --  If True, the back end supports the non-default Scalar_Storage_Order
 411    --  (i.e. allows non-confirming Scalar_Storage_Order attribute definition
 412    --  clauses).
 413
 414    --------------------
 415    -- Indirect Calls --
 416    --------------------
 417
 418    Always_Compatible_Rep_On_Target : Boolean := True;
 419    --  If True, the Can_Use_Internal_Rep flag (see Einfo) is set to False in
 420    --  all cases. This corresponds to the traditional code generation
 421    --  strategy. False allows the front end to choose a policy that partly or
 422    --  entirely eliminates dynamically generated trampolines.
 423
 424    -------------------------------
 425    -- Control of Stack Checking --
 426    -------------------------------
 427
 428    --  GNAT provides three methods of implementing exceptions:
 429
 430    --    GCC Probing Mechanism
 431
 432    --      This approach uses the standard GCC mechanism for
 433    --      stack checking. The method assumes that accessing
 434    --      storage immediately beyond the end of the stack
 435    --      will result in a trap that is converted to a storage
 436    --      error by the runtime system. This mechanism has
 437    --      minimal overhead, but requires complex hardware,
 438    --      operating system and run-time support. Probing is
 439    --      the default method where it is available. The stack
 440    --      size for the environment task depends on the operating
 441    --      system and cannot be set in a system-independent way.
 442
 443    --   GCC Stack-limit Mechanism
 444
 445    --      This approach uses the GCC stack limits mechanism.
 446    --      It relies on comparing the stack pointer with the
 447    --      values of a global symbol. If the check fails, a
 448    --      trap is explicitly generated. The advantage is
 449    --      that the mechanism requires no memory protection,
 450    --      but operating system and run-time support are
 451    --      needed to manage the per-task values of the symbol.
 452    --      This is the default method after probing where it
 453    --      is available.
 454
 455    --   GNAT Stack-limit Checking
 456
 457    --      This method relies on comparing the stack pointer
 458    --      with per-task stack limits. If the check fails, an
 459    --      exception is explicitly raised. The advantage is
 460    --      that the method requires no extra system dependent
 461    --      runtime support and can be used on systems without
 462    --      memory protection as well, but at the cost of more
 463    --      overhead for doing the check. This is the fallback
 464    --      method if the above two are not supported.
 465
 466    Stack_Check_Probes_On_Target : Boolean := False;
 467    --  Indicates if the GCC probing mechanism is used
 468
 469    Stack_Check_Limits_On_Target : Boolean := False;
 470    --  Indicates if the GCC stack-limit mechanism is used
 471
 472    --  Both flags cannot be simultaneously set to True. If neither
 473    --  is, the target independent fallback method is used.
 474
 475    Stack_Check_Default_On_Target : Boolean := False;
 476    --  Indicates if stack checking is on by default
 477
 478    ----------------------------
 479    -- Command Line Arguments --
 480    ----------------------------
 481
 482    --  For most ports of GNAT, command line arguments are supported. The
 483    --  following flag is set to False for targets that do not support
 484    --  command line arguments (VxWorks and AAMP). Note that support of
 485    --  command line arguments is not required on such targets (RM A.15(13)).
 486
 487    Command_Line_Args_On_Target : Boolean := True;
 488    --  Set False if no command line arguments on target. Note that if this
 489    --  is False in with Configurable_Run_Time_On_Target set to True, then
 490    --  this causes suppression of generation of the argv/argc variables
 491    --  used to record command line arguments.
 492
 493    --  Similarly, most ports support the use of an exit status, but AAMP
 494    --  is an exception (as allowed by RM A.15(18-20))
 495
 496    Exit_Status_Supported_On_Target : Boolean := True;
 497    --  Set False if returning of an exit status is not supported on target.
 498    --  Note that if this False in with Configurable_Run_Time_On_Target
 499    --  set to True, then this causes suppression of the gnat_exit_status
 500    --  variable used to record the exit status.
 501
 502    -----------------------
 503    -- Main Program Name --
 504    -----------------------
 505
 506    --  When the binder generates the main program to be used to create the
 507    --  executable, the main program name is main by default (to match the
 508    --  usual Unix practice). If this parameter is set to True, then the
 509    --  name is instead by default taken from the actual Ada main program
 510    --  name (just the name of the child if the main program is a child unit).
 511    --  In either case, this value can be overridden using -M name.
 512
 513    Use_Ada_Main_Program_Name_On_Target : Boolean := False;
 514    --  Set True to use the Ada main program name as the main name
 515
 516    ----------------------------------------------
 517    -- Boolean-Valued Floating-Point Attributes --
 518    ----------------------------------------------
 519
 520    --  The constants below give the values for representation oriented
 521    --  floating-point attributes that are the same for all float types
 522    --  on the target. These are all boolean values.
 523
 524    --  A value is only True if the target reliably supports the corresponding
 525    --  feature. Reliably here means that support is guaranteed for all
 526    --  possible settings of the relevant compiler switches (like -mieee),
 527    --  since we cannot control the user setting of those switches.
 528
 529    --  The attributes cannot dependent on the current setting of compiler
 530    --  switches, since the values must be static and consistent throughout
 531    --  the partition. We probably should add such consistency checks in future,
 532    --  but for now we don't do this.
 533
 534    --  Note: the compiler itself does not use floating-point, so the
 535    --  settings of the defaults here are not really relevant.
 536
 537    --  Note: in some cases, proper support of some of these floating point
 538    --  features may require a specific switch (e.g. -mieee on the Alpha)
 539    --  to be used to obtain full RM compliant support.
 540
 541    Denorm_On_Target : Boolean := False;
 542    --  Set to False on targets that do not reliably support denormals
 543
 544    Machine_Rounds_On_Target : Boolean := True;
 545    --  Set to False for targets where S'Machine_Rounds is False
 546
 547    Machine_Overflows_On_Target : Boolean := False;
 548    --  Set to True for targets where S'Machine_Overflows is True
 549
 550    Signed_Zeros_On_Target : Boolean := True;
 551    --  Set to False on targets that do not reliably support signed zeros
 552
 553    -------------------------------------------
 554    -- Boolean-Valued Fixed-Point Attributes --
 555    -------------------------------------------
 556
 557    Fractional_Fixed_Ops_On_Target : Boolean := False;
 558    --  Set to True for targets that support fixed-by-fixed multiplication
 559    --  and division for fixed-point types with a small value equal to
 560    --  2 ** (-(T'Object_Size - 1)) and whose values have an absolute
 561    --  value less than 1.0.
 562
 563    -----------------
 564    -- Data Layout --
 565    -----------------
 566
 567    --  Normally when using the GCC backend, Gigi and GCC perform much of the
 568    --  data layout using the standard layout capabilities of GCC. If the
 569    --  parameter Backend_Layout is set to False, then the front end must
 570    --  perform all data layout. For further details see the package Layout.
 571
 572    Frontend_Layout_On_Target : Boolean := False;
 573    --  Set True if front end does layout
 574
 575    -----------------
 576    -- Subprograms --
 577    -----------------
 578
 579    --  These subprograms are used to initialize the target parameter values
 580    --  from the system.ads file. Note that this is only done once, so if more
 581    --  than one call is made to either routine, the second and subsequent
 582    --  calls are ignored. It also reads restriction pragmas from system.ads
 583    --  and records them, though as further detailed below, the caller has some
 584    --  control over the handling of No_Dependence restrictions.
 585
 586    type Make_Id_Type is access function (Str : Text_Buffer) return Node_Id;
 587    --  Parameter type for Get_Target_Parameters for function that creates an
 588    --  identifier node with Sloc value System_Location and given string as the
 589    --  Chars value.
 590
 591    type Make_SC_Type is access function (Pre, Sel : Node_Id) return Node_Id;
 592    --  Parameter type for Get_Target_Parameters for function that creates a
 593    --  selected component with Sloc value System_Location and given Prefix
 594    --  (Pre) and Selector (Sel) values.
 595
 596    type Set_NOD_Type is access procedure (Unit : Node_Id);
 597    --  Parameter type for Get_Target_Parameters that records a Restriction
 598    --  No_Dependence for the given unit (identifier or selected component).
 599
 600    type Set_NSA_Type is access procedure (Asp : Name_Id; OK : out Boolean);
 601    --  Parameter type for Get_Target_Parameters that records a Restriction
 602    --  No_Specification_Of_Aspect. Asp is the aspect name. OK is set True
 603    --  if this is an OK aspect name, and False if it is not an aspect name.
 604
 605    type Set_NUA_Type is access procedure (Attr : Name_Id; OK : out Boolean);
 606    --  Parameter type for Get_Target_Parameters that records a Restriction
 607    --  No_Use_Of_Attribute. Attr is the attribute name. OK is set True if
 608    --  this is an OK attribute name, and False if it is not an attribute name.
 609
 610    type Set_NUP_Type is access procedure (Prag : Name_Id; OK : out Boolean);
 611    --  Parameter type for Get_Target_Parameters that records a Restriction
 612    --  No_Use_Of_Pragma. Prag is the pragma name. OK is set True if this is
 613    --  an OK pragma name, and False if it is not a recognized pragma name.
 614
 615    procedure Get_Target_Parameters
 616      (System_Text  : Source_Buffer_Ptr;
 617       Source_First : Source_Ptr;
 618       Source_Last  : Source_Ptr;
 619       Make_Id      : Make_Id_Type := null;
 620       Make_SC      : Make_SC_Type := null;
 621       Set_NOD      : Set_NOD_Type := null;
 622       Set_NSA      : Set_NSA_Type := null;
 623       Set_NUA      : Set_NUA_Type := null;
 624       Set_NUP      : Set_NUP_Type := null);
 625    --  Called at the start of execution to obtain target parameters from the
 626    --  source of package System. The parameters provide the source text to be
 627    --  scanned (in System_Text (Source_First .. Source_Last)). If the three
 628    --  subprograms Make_Id, Make_SC, and Set_NOD are left at their default
 629    --  value of null, Get_Target_Parameters will ignore pragma Restrictions
 630    --  (No_Dependence) lines; otherwise it will use these three subprograms to
 631    --  record them. Similarly, if Set_NUP is left at its default value of null,
 632    --  then any occurrences of pragma Restrictions (No_Use_Of_Pragma => XXX)
 633    --  will be ignored; otherwise it will use this procedure to record the
 634    --  pragma. Similarly for the NSA and NUA cases.
 635
 636    procedure Get_Target_Parameters
 637      (Make_Id : Make_Id_Type := null;
 638       Make_SC : Make_SC_Type := null;
 639       Set_NOD : Set_NOD_Type := null;
 640       Set_NSA : Set_NSA_Type := null;
 641       Set_NUA : Set_NUA_Type := null;
 642       Set_NUP : Set_NUP_Type := null);
 643    --  This version reads in system.ads using Osint. The idea is that the
 644    --  caller uses the first version if they have to read system.ads anyway
 645    --  (e.g. the compiler) and uses this simpler interface if system.ads is
 646    --  not otherwise needed.
 647
 648 end Targparm;