/usr/lib/gcc-cross/alpha-linux-gnu/6/adainclude/gnatprj/targparm.ads is in libgnatprj6-dev-alpha-cross 6.3.0-18cross1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 | ------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- T A R G P A R M --
-- --
-- S p e c --
-- --
-- Copyright (C) 1999-2015, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
-- for more details. You should have received a copy of the GNU General --
-- Public License distributed with GNAT; see file COPYING3. If not, go to --
-- http://www.gnu.org/licenses for a complete copy of the license. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-- This package obtains parameters from the target runtime version of System,
-- to indicate parameters relevant to the target environment.
-- Conceptually, these parameters could be obtained using rtsfind, but
-- we do not do this for four reasons:
-- 1. Compiling System for every compilation wastes time
-- 2. This compilation impedes debugging by adding extra compile steps
-- 3. There are recursion problems coming from compiling System itself
-- or any of its children.
-- 4. The binder also needs the parameters, and we do not want to have
-- to drag a lot of front end stuff into the binder.
-- For all these reasons, we read in the source of System, and then scan
-- it at the text level to extract the parameter values.
-- Note however, that later on, when the ali file is written, we make sure
-- that the System file is at least parsed, so that the checksum is properly
-- computed and set in the ali file. This partially negates points 1 and 2
-- above although just parsing is quick and does not impact debugging much.
-- The parameters acquired by this routine from system.ads fall into four
-- categories:
-- 1. Configuration pragmas, that must appear at the start of the file.
-- Any such pragmas automatically apply to any unit compiled in the
-- presence of this system file. Only a limited set of such pragmas
-- may appear as documented in the corresponding section below.
-- 2. Target parameters. These are boolean constants that are defined
-- in the private part of the package giving fixed information
-- about the target architecture, and the capabilities of the
-- code generator and run-time library.
-- 3. Identification information. This is an optional string constant
-- that gives the name of the run-time library configuration. This
-- line may be omitted for a version of system.ads to be used with
-- the full Ada 95 run time.
-- 4. Other characteristics of package System. At the current time the
-- only item in this category is whether type Address is private.
with Rident; use Rident;
with Namet; use Namet;
with Types; use Types;
package Targparm is
---------------------------
-- Configuration Pragmas --
---------------------------
-- The following switches get set if the corresponding configuration
-- pragma is scanned from the source of system.ads. No other pragmas
-- are permitted to appear at the start of the system.ads source file.
-- If a pragma Discard_Names appears, then Opt.Global_Discard_Names is
-- set to True to indicate that all units must be compiled in this mode.
-- If a pragma Locking_Policy appears, then Opt.Locking_Policy is set
-- to the first character of the policy name, and Opt.Locking_Policy_Sloc
-- is set to System_Location.
-- If a pragma Normalize_Scalars appears, then Opt.Normalize_Scalars
-- is set True, as well as Opt.Init_Or_Norm_Scalars.
-- If a pragma Queuing_Policy appears, then Opt.Queuing_Policy is set
-- to the first character of the policy name, and Opt.Queuing_Policy_Sloc
-- is set to System_Location.
-- If a pragma Task_Dispatching_Policy appears, then the flag
-- Opt.Task_Dispatching_Policy is set to the first character of the
-- policy name, and Opt.Task_Dispatching_Policy_Sloc is set to
-- System_Location.
-- If a pragma Polling (On) appears, then the flag Opt.Polling_Required
-- is set to True.
-- If a pragma Detect_Blocking appears, then the flag Opt.Detect_Blocking
-- is set to True.
-- If a pragma Suppress_Exception_Locations appears, then the flag
-- Opt.Exception_Locations_Suppressed is set to True.
-- If a pragma Profile with a valid profile argument appears, then
-- the appropriate restrictions and policy flags are set.
-- The only other pragma allowed is a pragma Restrictions that specifies
-- a restriction that will be imposed on all units in the partition. Note
-- that in this context, only one restriction can be specified in a single
-- pragma, and the pragma must appear on its own on a single source line.
-- If package System contains exactly the line "type Address is private;"
-- then the flag Opt.Address_Is_Private is set True, otherwise this flag
-- is set False.
Restrictions_On_Target : Restrictions_Info := No_Restrictions;
-- Records restrictions specified by system.ads. Only the Set and Value
-- members are modified. The Violated and Count fields are never modified.
-- Note that entries can be set either by a pragma Restrictions or by
-- a pragma Profile.
-------------------
-- Run Time Name --
-------------------
-- This parameter should be regarded as read only by all clients of
-- of package. The only way they get modified is by calling the
-- Get_Target_Parameters routine which reads the values from a provided
-- text buffer containing the source of the system package.
-- The corresponding string constant is placed immediately at the start
-- of the private part of system.ads if is present, e.g. in the form:
-- Run_Time_Name : constant String := "Zero Footprint Run Time";
-- the corresponding messages will look something like
-- xxx not supported (Zero Footprint Run Time)
Run_Time_Name_On_Target : Name_Id := No_Name;
-- Set to appropriate names table entry Id value if a Run_Time_Name
-- string constant is defined in system.ads. This name is used only
-- for the configurable run-time case, and is used to parameterize
-- messages that complain about non-supported run-time features.
-- The name should contain only letters A-Z, digits 1-9, spaces,
-- and underscores.
--------------------------
-- Executable Extension --
--------------------------
Executable_Extension_On_Target : Name_Id := No_Name;
-- Executable extension on the target. This name is useful for setting
-- the executable extension in a dynamic way, e.g. depending on the
-- run time used, rather than using a configure-time macro as done by
-- Get_Target_Executable_Suffix. If not set (No_Name), instead use
-- System.OS_Lib.Get_Target_Executable_Suffix.
-----------------------
-- Target Parameters --
-----------------------
-- The following parameters correspond to the variables defined in the
-- private part of System (without the terminating _On_Target). Note
-- that it is required that all parameters defined here be specified
-- in the target specific version of system.ads. Thus, to add a new
-- parameter, add it to all system*.ads files. (There is a defaulting
-- mechanism, but we don't normally take advantage of it, as explained
-- below.)
-- The default values here are used if no value is found in system.ads.
-- This should normally happen if the special version of system.ads used
-- by the compiler itself is in use or if the value is only relevant to a
-- particular target (e.g. AAMP). The default values are suitable for use
-- in normal environments. This approach allows the possibility of new
-- versions of the compiler (possibly with new system parameters added)
-- being used to compile older versions of the compiler sources, as well as
-- avoiding duplicating values in all system-*.ads files for flags that are
-- used on a few platforms only.
-- All these parameters should be regarded as read only by all clients
-- of the package. The only way they get modified is by calling the
-- Get_Target_Parameters routine which reads the values from a provided
-- text buffer containing the source of the system package.
----------------------------
-- Special Target Control --
----------------------------
-- The great majority of GNAT ports are based on GCC. The switches in
-- this section indicate the use of some non-standard target back end
-- or other special targetting requirements.
AAMP_On_Target : Boolean := False;
-- Set to True if target is AAMP
-------------------------------
-- Backend Arithmetic Checks --
-------------------------------
-- Divide and overflow checks are either done in the front end or
-- back end. The front end will generate checks when required unless
-- the corresponding parameter here is set to indicate that the back
-- end will generate the required checks (or that the checks are
-- automatically performed by the hardware in an appropriate form).
Backend_Divide_Checks_On_Target : Boolean := False;
-- Set True if the back end generates divide checks, or if the hardware
-- checks automatically. Set False if the front end must generate the
-- required tests using explicit expanded code.
Backend_Overflow_Checks_On_Target : Boolean := False;
-- Set True if the back end generates arithmetic overflow checks, or if
-- the hardware checks automatically. Set False if the front end must
-- generate the required tests using explicit expanded code.
-----------------------------------
-- Control of Exception Handling --
-----------------------------------
-- GNAT implements three methods of implementing exceptions:
-- Front-End Longjmp/Setjmp Exceptions
-- This approach uses longjmp/setjmp to handle exceptions. It
-- uses less storage, and can often propagate exceptions faster,
-- at the expense of (sometimes considerable) overhead in setting
-- up an exception handler.
-- The generation of the setjmp and longjmp calls is handled by
-- the front end of the compiler (this includes gigi in the case
-- of the standard GCC back end). It does not use any back end
-- support (such as the GCC3 exception handling mechanism). When
-- this approach is used, the compiler generates special exception
-- handlers for handling cleanups (AT-END actions) when an exception
-- is raised.
-- Back-End Zero Cost Exceptions
-- With this approach, the back end handles the generation and
-- handling of exceptions. For example, the GCC3 exception handling
-- mechanisms are used in this mode. The front end simply generates
-- code for explicit exception handlers, and AT-END cleanup handlers
-- are simply passed unchanged to the backend for generating cleanups
-- both in the exceptional and non-exceptional cases.
-- As the name implies, this approach uses a table-based mechanism,
-- which incurs no setup when entering a region covered by handlers
-- but requires complex unwinding to walk up the call chain and search
-- for handlers at propagation time.
-- Back-End Setjmp/Longjmp Exceptions
-- With this approach, the back end also handles the generation and
-- handling of exceptions, using setjmp/longjmp to setup receivers and
-- propagate. AT-END actions on exceptional paths are also taken care
-- of by the back end and the front end doesn't need to generate
-- explicit exception handlers for these.
-- Control of Available Methods and Defaults
-- The following switches specify whether we're using a front-end or a
-- back-end mechanism and whether this is a zero-cost or a sjlj scheme.
-- The per switch default values correspond to the default value of
-- Opt.Exception_Mechanism.
ZCX_By_Default_On_Target : Boolean := False;
-- Indicates if zero cost scheme for exceptions
Frontend_Exceptions_On_Target : Boolean := True;
-- Indicates if we're using a front-end scheme for exceptions
------------------------------------
-- Run-Time Library Configuration --
------------------------------------
-- In configurable run-time mode, the system run-time may not support
-- the full Ada language. The effect of setting this switch is to let
-- the compiler know that it is not surprising (i.e. the system is not
-- misconfigured) if run-time library units or entities within units are
-- not present in the run-time.
Configurable_Run_Time_On_Target : Boolean := False;
-- Indicates that the system.ads file is for a configurable run-time
--
-- This has some specific effects as follows
--
-- The binder generates the gnat_argc/argv/envp variables in the
-- binder file instead of being imported from the run-time library.
-- If Command_Line_Args_On_Target is set to False, then the
-- generation of these variables is suppressed completely.
--
-- The binder generates the gnat_exit_status variable in the binder
-- file instead of being imported from the run-time library. If
-- Exit_Status_Supported_On_Target is set to False, then the
-- generation of this variable is suppressed entirely.
--
-- The routine __gnat_break_start is defined within the binder file
-- instead of being imported from the run-time library.
--
-- The variable __gnat_exit_status is generated within the binder file
-- instead of being imported from the run-time library.
Suppress_Standard_Library_On_Target : Boolean := False;
-- If this flag is True, then the standard library is not included by
-- default in the executable (see unit System.Standard_Library in file
-- s-stalib.ads for details of what this includes). This is for example
-- set True for the zero foot print case, where these files should not
-- be included by default.
--
-- This flag has some other related effects:
--
-- The generation of global variables in the bind file is suppressed,
-- with the exception of the priority of the environment task, which
-- is needed by the Ravenscar run-time.
--
-- The calls to __gnat_initialize and __gnat_finalize are omitted
--
-- All finalization and initialization (controlled types) is omitted
Preallocated_Stacks_On_Target : Boolean := False;
-- If this flag is True, then the expander preallocates all task stacks
-- at compile time. If the flag is False, then task stacks are not pre-
-- allocated, and task stack allocation is the responsibility of the
-- run-time (which typically delegates the task to the underlying
-- operating system environment).
---------------------
-- Duration Format --
---------------------
-- By default, type Duration is a 64-bit fixed-point type with a delta
-- and small of 10**(-9) (i.e. it is a count in nanoseconds). This flag
-- allows that standard format to be modified.
Duration_32_Bits_On_Target : Boolean := False;
-- If True, then Duration is represented in 32 bits and the delta and
-- small values are set to 20.0*(10**(-3)) (i.e. it is a count in units
-- of 20 milliseconds).
------------------------------------
-- Back-End Code Generation Flags --
------------------------------------
-- These flags indicate possible limitations in what the code generator
-- can handle. They will all be True for a full run-time, but one or more
-- of these may be false for a configurable run-time, and if a feature is
-- used at the source level, and the corresponding flag is false, then an
-- error message will be issued saying the feature is not supported.
Atomic_Sync_Default_On_Target : Boolean := True;
-- Access to atomic variables requires memory barrier synchronization in
-- the general case to ensure proper behavior when such accesses are used
-- on a multi-processor to synchronize tasks (e.g. by using spin locks).
-- The setting of this flag determines the default behavior. Normally this
-- is True, which will mean that appropriate synchronization instructions
-- are generated by default. If it is False, then the default will be that
-- these synchronization instructions are not generated. This may be a more
-- appropriate default in some cases, e.g. on embedded targets which do not
-- allow the possibility of multi-processors. The default can be overridden
-- using pragmas Enable/Disable_Atomic_Synchronization and also by use of
-- the corresponding debug flags -gnatd.e and -gnatd.d.
Support_Aggregates_On_Target : Boolean := True;
-- In the general case, the use of aggregates may generate calls
-- to run-time routines in the C library, including memset, memcpy,
-- memmove, and bcopy. This flag is set to True if these routines
-- are available. If any of these routines is not available, then
-- this flag is False, and the use of aggregates is not permitted.
Support_Atomic_Primitives_On_Target : Boolean := False;
-- If this flag is True, then the back-end support GCC built-in atomic
-- operations for memory model such as atomic load or atomic compare
-- exchange (see the GCC manual for more information). If the flag is
-- False, then the back-end doesn't provide this support. Note this flag is
-- set to True only if the target supports all atomic primitives up to 64
-- bits. ??? To be modified.
Support_Composite_Assign_On_Target : Boolean := True;
-- The assignment of composite objects other than small records and
-- arrays whose size is 64-bits or less and is set by an explicit
-- size clause may generate calls to memcpy, memmove, and bcopy.
-- If versions of all these routines are available, then this flag
-- is set to True. If any of these routines is not available, then
-- the flag is set False, and composite assignments are not allowed.
Support_Composite_Compare_On_Target : Boolean := True;
-- If this flag is True, then the back end supports bit-wise comparison
-- of composite objects for equality, either generating inline code or
-- calling appropriate (and available) run-time routines. If this flag
-- is False, then the back end does not provide this support, and the
-- front end uses component by component comparison for composites.
Support_Long_Shifts_On_Target : Boolean := True;
-- If True, the back end supports 64-bit shift operations. If False, then
-- the source program may not contain explicit 64-bit shifts. In addition,
-- the code generated for packed arrays will avoid the use of long shifts.
Support_Nondefault_SSO_On_Target : Boolean := True;
-- If True, the back end supports the non-default Scalar_Storage_Order
-- (i.e. allows non-confirming Scalar_Storage_Order attribute definition
-- clauses).
--------------------
-- Indirect Calls --
--------------------
Always_Compatible_Rep_On_Target : Boolean := True;
-- If True, the Can_Use_Internal_Rep flag (see Einfo) is set to False in
-- all cases. This corresponds to the traditional code generation
-- strategy. False allows the front end to choose a policy that partly or
-- entirely eliminates dynamically generated trampolines.
-------------------------------
-- Control of Stack Checking --
-------------------------------
-- GNAT provides three methods of implementing exceptions:
-- GCC Probing Mechanism
-- This approach uses the standard GCC mechanism for
-- stack checking. The method assumes that accessing
-- storage immediately beyond the end of the stack
-- will result in a trap that is converted to a storage
-- error by the runtime system. This mechanism has
-- minimal overhead, but requires complex hardware,
-- operating system and run-time support. Probing is
-- the default method where it is available. The stack
-- size for the environment task depends on the operating
-- system and cannot be set in a system-independent way.
-- GCC Stack-limit Mechanism
-- This approach uses the GCC stack limits mechanism.
-- It relies on comparing the stack pointer with the
-- values of a global symbol. If the check fails, a
-- trap is explicitly generated. The advantage is
-- that the mechanism requires no memory protection,
-- but operating system and run-time support are
-- needed to manage the per-task values of the symbol.
-- This is the default method after probing where it
-- is available.
-- GNAT Stack-limit Checking
-- This method relies on comparing the stack pointer
-- with per-task stack limits. If the check fails, an
-- exception is explicitly raised. The advantage is
-- that the method requires no extra system dependent
-- runtime support and can be used on systems without
-- memory protection as well, but at the cost of more
-- overhead for doing the check. This is the fallback
-- method if the above two are not supported.
Stack_Check_Probes_On_Target : Boolean := False;
-- Indicates if the GCC probing mechanism is used
Stack_Check_Limits_On_Target : Boolean := False;
-- Indicates if the GCC stack-limit mechanism is used
-- Both flags cannot be simultaneously set to True. If neither
-- is, the target independent fallback method is used.
Stack_Check_Default_On_Target : Boolean := False;
-- Indicates if stack checking is on by default
----------------------------
-- Command Line Arguments --
----------------------------
-- For most ports of GNAT, command line arguments are supported. The
-- following flag is set to False for targets that do not support
-- command line arguments (VxWorks and AAMP). Note that support of
-- command line arguments is not required on such targets (RM A.15(13)).
Command_Line_Args_On_Target : Boolean := True;
-- Set False if no command line arguments on target. Note that if this
-- is False in with Configurable_Run_Time_On_Target set to True, then
-- this causes suppression of generation of the argv/argc variables
-- used to record command line arguments.
-- Similarly, most ports support the use of an exit status, but AAMP
-- is an exception (as allowed by RM A.15(18-20))
Exit_Status_Supported_On_Target : Boolean := True;
-- Set False if returning of an exit status is not supported on target.
-- Note that if this False in with Configurable_Run_Time_On_Target
-- set to True, then this causes suppression of the gnat_exit_status
-- variable used to record the exit status.
-----------------------
-- Main Program Name --
-----------------------
-- When the binder generates the main program to be used to create the
-- executable, the main program name is main by default (to match the
-- usual Unix practice). If this parameter is set to True, then the
-- name is instead by default taken from the actual Ada main program
-- name (just the name of the child if the main program is a child unit).
-- In either case, this value can be overridden using -M name.
Use_Ada_Main_Program_Name_On_Target : Boolean := False;
-- Set True to use the Ada main program name as the main name
----------------------------------------------
-- Boolean-Valued Floating-Point Attributes --
----------------------------------------------
-- The constants below give the values for representation oriented
-- floating-point attributes that are the same for all float types
-- on the target. These are all boolean values.
-- A value is only True if the target reliably supports the corresponding
-- feature. Reliably here means that support is guaranteed for all
-- possible settings of the relevant compiler switches (like -mieee),
-- since we cannot control the user setting of those switches.
-- The attributes cannot dependent on the current setting of compiler
-- switches, since the values must be static and consistent throughout
-- the partition. We probably should add such consistency checks in future,
-- but for now we don't do this.
-- Note: the compiler itself does not use floating-point, so the
-- settings of the defaults here are not really relevant.
-- Note: in some cases, proper support of some of these floating point
-- features may require a specific switch (e.g. -mieee on the Alpha)
-- to be used to obtain full RM compliant support.
Denorm_On_Target : Boolean := False;
-- Set to False on targets that do not reliably support denormals
Machine_Rounds_On_Target : Boolean := True;
-- Set to False for targets where S'Machine_Rounds is False
Machine_Overflows_On_Target : Boolean := False;
-- Set to True for targets where S'Machine_Overflows is True
Signed_Zeros_On_Target : Boolean := True;
-- Set to False on targets that do not reliably support signed zeros
-------------------------------------------
-- Boolean-Valued Fixed-Point Attributes --
-------------------------------------------
Fractional_Fixed_Ops_On_Target : Boolean := False;
-- Set to True for targets that support fixed-by-fixed multiplication
-- and division for fixed-point types with a small value equal to
-- 2 ** (-(T'Object_Size - 1)) and whose values have an absolute
-- value less than 1.0.
-----------------
-- Data Layout --
-----------------
-- Normally when using the GCC backend, Gigi and GCC perform much of the
-- data layout using the standard layout capabilities of GCC. If the
-- parameter Backend_Layout is set to False, then the front end must
-- perform all data layout. For further details see the package Layout.
Frontend_Layout_On_Target : Boolean := False;
-- Set True if front end does layout
-----------------
-- Subprograms --
-----------------
-- These subprograms are used to initialize the target parameter values
-- from the system.ads file. Note that this is only done once, so if more
-- than one call is made to either routine, the second and subsequent
-- calls are ignored. It also reads restriction pragmas from system.ads
-- and records them, though as further detailed below, the caller has some
-- control over the handling of No_Dependence restrictions.
type Make_Id_Type is access function (Str : Text_Buffer) return Node_Id;
-- Parameter type for Get_Target_Parameters for function that creates an
-- identifier node with Sloc value System_Location and given string as the
-- Chars value.
type Make_SC_Type is access function (Pre, Sel : Node_Id) return Node_Id;
-- Parameter type for Get_Target_Parameters for function that creates a
-- selected component with Sloc value System_Location and given Prefix
-- (Pre) and Selector (Sel) values.
type Set_NOD_Type is access procedure (Unit : Node_Id);
-- Parameter type for Get_Target_Parameters that records a Restriction
-- No_Dependence for the given unit (identifier or selected component).
type Set_NSA_Type is access procedure (Asp : Name_Id; OK : out Boolean);
-- Parameter type for Get_Target_Parameters that records a Restriction
-- No_Specification_Of_Aspect. Asp is the aspect name. OK is set True
-- if this is an OK aspect name, and False if it is not an aspect name.
type Set_NUA_Type is access procedure (Attr : Name_Id; OK : out Boolean);
-- Parameter type for Get_Target_Parameters that records a Restriction
-- No_Use_Of_Attribute. Attr is the attribute name. OK is set True if
-- this is an OK attribute name, and False if it is not an attribute name.
type Set_NUP_Type is access procedure (Prag : Name_Id; OK : out Boolean);
-- Parameter type for Get_Target_Parameters that records a Restriction
-- No_Use_Of_Pragma. Prag is the pragma name. OK is set True if this is
-- an OK pragma name, and False if it is not a recognized pragma name.
procedure Get_Target_Parameters
(System_Text : Source_Buffer_Ptr;
Source_First : Source_Ptr;
Source_Last : Source_Ptr;
Make_Id : Make_Id_Type := null;
Make_SC : Make_SC_Type := null;
Set_NOD : Set_NOD_Type := null;
Set_NSA : Set_NSA_Type := null;
Set_NUA : Set_NUA_Type := null;
Set_NUP : Set_NUP_Type := null);
-- Called at the start of execution to obtain target parameters from the
-- source of package System. The parameters provide the source text to be
-- scanned (in System_Text (Source_First .. Source_Last)). If the three
-- subprograms Make_Id, Make_SC, and Set_NOD are left at their default
-- value of null, Get_Target_Parameters will ignore pragma Restrictions
-- (No_Dependence) lines; otherwise it will use these three subprograms to
-- record them. Similarly, if Set_NUP is left at its default value of null,
-- then any occurrences of pragma Restrictions (No_Use_Of_Pragma => XXX)
-- will be ignored; otherwise it will use this procedure to record the
-- pragma. Similarly for the NSA and NUA cases.
procedure Get_Target_Parameters
(Make_Id : Make_Id_Type := null;
Make_SC : Make_SC_Type := null;
Set_NOD : Set_NOD_Type := null;
Set_NSA : Set_NSA_Type := null;
Set_NUA : Set_NUA_Type := null;
Set_NUP : Set_NUP_Type := null);
-- This version reads in system.ads using Osint. The idea is that the
-- caller uses the first version if they have to read system.ads anyway
-- (e.g. the compiler) and uses this simpler interface if system.ads is
-- not otherwise needed.
end Targparm;
|