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