Mercurial > hg > CbC > CbC_gcc
comparison gcc/ada/targparm.ads @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children | 84e7813d76e9 |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111:04ced10e8804 |
---|---|
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-2017, 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 -- 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 Stack_Check_Limits_On_Target : Boolean := False; | |
459 -- Indicates if the GCC stack-limit mechanism is used | |
460 | |
461 -- Both flags cannot be simultaneously set to True. If neither | |
462 -- is, the target independent fallback method is used. | |
463 | |
464 Stack_Check_Default_On_Target : Boolean := False; | |
465 -- Indicates if stack checking is on by default | |
466 | |
467 ---------------------------- | |
468 -- Command Line Arguments -- | |
469 ---------------------------- | |
470 | |
471 -- For most ports of GNAT, command line arguments are supported. The | |
472 -- following flag is set to False for targets that do not support | |
473 -- command line arguments (VxWorks and AAMP). Note that support of | |
474 -- command line arguments is not required on such targets (RM A.15(13)). | |
475 | |
476 Command_Line_Args_On_Target : Boolean := True; | |
477 -- Set False if no command line arguments on target. Note that if this | |
478 -- is False in with Configurable_Run_Time_On_Target set to True, then | |
479 -- this causes suppression of generation of the argv/argc variables | |
480 -- used to record command line arguments. | |
481 | |
482 -- Similarly, most ports support the use of an exit status, but AAMP | |
483 -- is an exception (as allowed by RM A.15(18-20)) | |
484 | |
485 Exit_Status_Supported_On_Target : Boolean := True; | |
486 -- Set False if returning of an exit status is not supported on target. | |
487 -- Note that if this False in with Configurable_Run_Time_On_Target | |
488 -- set to True, then this causes suppression of the gnat_exit_status | |
489 -- variable used to record the exit status. | |
490 | |
491 ----------------------- | |
492 -- Main Program Name -- | |
493 ----------------------- | |
494 | |
495 -- When the binder generates the main program to be used to create the | |
496 -- executable, the main program name is main by default (to match the | |
497 -- usual Unix practice). If this parameter is set to True, then the | |
498 -- name is instead by default taken from the actual Ada main program | |
499 -- name (just the name of the child if the main program is a child unit). | |
500 -- In either case, this value can be overridden using -M name. | |
501 | |
502 Use_Ada_Main_Program_Name_On_Target : Boolean := False; | |
503 -- Set True to use the Ada main program name as the main name | |
504 | |
505 ---------------------------------------------- | |
506 -- Boolean-Valued Floating-Point Attributes -- | |
507 ---------------------------------------------- | |
508 | |
509 -- The constants below give the values for representation oriented | |
510 -- floating-point attributes that are the same for all float types | |
511 -- on the target. These are all boolean values. | |
512 | |
513 -- A value is only True if the target reliably supports the corresponding | |
514 -- feature. Reliably here means that support is guaranteed for all | |
515 -- possible settings of the relevant compiler switches (like -mieee), | |
516 -- since we cannot control the user setting of those switches. | |
517 | |
518 -- The attributes cannot dependent on the current setting of compiler | |
519 -- switches, since the values must be static and consistent throughout | |
520 -- the partition. We probably should add such consistency checks in future, | |
521 -- but for now we don't do this. | |
522 | |
523 -- Note: the compiler itself does not use floating-point, so the | |
524 -- settings of the defaults here are not really relevant. | |
525 | |
526 -- Note: in some cases, proper support of some of these floating point | |
527 -- features may require a specific switch (e.g. -mieee on the Alpha) | |
528 -- to be used to obtain full RM compliant support. | |
529 | |
530 Denorm_On_Target : Boolean := False; | |
531 -- Set to False on targets that do not reliably support denormals | |
532 | |
533 Machine_Rounds_On_Target : Boolean := True; | |
534 -- Set to False for targets where S'Machine_Rounds is False | |
535 | |
536 Machine_Overflows_On_Target : Boolean := False; | |
537 -- Set to True for targets where S'Machine_Overflows is True | |
538 | |
539 Signed_Zeros_On_Target : Boolean := True; | |
540 -- Set to False on targets that do not reliably support signed zeros | |
541 | |
542 ------------------------------------------- | |
543 -- Boolean-Valued Fixed-Point Attributes -- | |
544 ------------------------------------------- | |
545 | |
546 Fractional_Fixed_Ops_On_Target : Boolean := False; | |
547 -- Set to True for targets that support fixed-by-fixed multiplication | |
548 -- and division for fixed-point types with a small value equal to | |
549 -- 2 ** (-(T'Object_Size - 1)) and whose values have an absolute | |
550 -- value less than 1.0. | |
551 | |
552 ----------------- | |
553 -- Subprograms -- | |
554 ----------------- | |
555 | |
556 -- These subprograms are used to initialize the target parameter values | |
557 -- from the system.ads file. Note that this is only done once, so if more | |
558 -- than one call is made to either routine, the second and subsequent | |
559 -- calls are ignored. It also reads restriction pragmas from system.ads | |
560 -- and records them, though as further detailed below, the caller has some | |
561 -- control over the handling of No_Dependence restrictions. | |
562 | |
563 type Make_Id_Type is access function (Str : Text_Buffer) return Node_Id; | |
564 -- Parameter type for Get_Target_Parameters for function that creates an | |
565 -- identifier node with Sloc value System_Location and given string as the | |
566 -- Chars value. | |
567 | |
568 type Make_SC_Type is access function (Pre, Sel : Node_Id) return Node_Id; | |
569 -- Parameter type for Get_Target_Parameters for function that creates a | |
570 -- selected component with Sloc value System_Location and given Prefix | |
571 -- (Pre) and Selector (Sel) values. | |
572 | |
573 type Set_NOD_Type is access procedure (Unit : Node_Id); | |
574 -- Parameter type for Get_Target_Parameters that records a Restriction | |
575 -- No_Dependence for the given unit (identifier or selected component). | |
576 | |
577 type Set_NSA_Type is access procedure (Asp : Name_Id; OK : out Boolean); | |
578 -- Parameter type for Get_Target_Parameters that records a Restriction | |
579 -- No_Specification_Of_Aspect. Asp is the aspect name. OK is set True | |
580 -- if this is an OK aspect name, and False if it is not an aspect name. | |
581 | |
582 type Set_NUA_Type is access procedure (Attr : Name_Id; OK : out Boolean); | |
583 -- Parameter type for Get_Target_Parameters that records a Restriction | |
584 -- No_Use_Of_Attribute. Attr is the attribute name. OK is set True if | |
585 -- this is an OK attribute name, and False if it is not an attribute name. | |
586 | |
587 type Set_NUP_Type is access procedure (Prag : Name_Id; OK : out Boolean); | |
588 -- Parameter type for Get_Target_Parameters that records a Restriction | |
589 -- No_Use_Of_Pragma. Prag is the pragma name. OK is set True if this is | |
590 -- an OK pragma name, and False if it is not a recognized pragma name. | |
591 | |
592 procedure Get_Target_Parameters | |
593 (System_Text : Source_Buffer_Ptr; | |
594 Source_First : Source_Ptr; | |
595 Source_Last : Source_Ptr; | |
596 Make_Id : Make_Id_Type := null; | |
597 Make_SC : Make_SC_Type := null; | |
598 Set_NOD : Set_NOD_Type := null; | |
599 Set_NSA : Set_NSA_Type := null; | |
600 Set_NUA : Set_NUA_Type := null; | |
601 Set_NUP : Set_NUP_Type := null); | |
602 -- Called at the start of execution to obtain target parameters from the | |
603 -- source of package System. The parameters provide the source text to be | |
604 -- scanned (in System_Text (Source_First .. Source_Last)). If the three | |
605 -- subprograms Make_Id, Make_SC, and Set_NOD are left at their default | |
606 -- value of null, Get_Target_Parameters will ignore pragma Restrictions | |
607 -- (No_Dependence) lines; otherwise it will use these three subprograms to | |
608 -- record them. Similarly, if Set_NUP is left at its default value of null, | |
609 -- then any occurrences of pragma Restrictions (No_Use_Of_Pragma => XXX) | |
610 -- will be ignored; otherwise it will use this procedure to record the | |
611 -- pragma. Similarly for the NSA and NUA cases. | |
612 | |
613 procedure Get_Target_Parameters | |
614 (Make_Id : Make_Id_Type := null; | |
615 Make_SC : Make_SC_Type := null; | |
616 Set_NOD : Set_NOD_Type := null; | |
617 Set_NSA : Set_NSA_Type := null; | |
618 Set_NUA : Set_NUA_Type := null; | |
619 Set_NUP : Set_NUP_Type := null); | |
620 -- This version reads in system.ads using Osint. The idea is that the | |
621 -- caller uses the first version if they have to read system.ads anyway | |
622 -- (e.g. the compiler) and uses this simpler interface if system.ads is | |
623 -- not otherwise needed. | |
624 | |
625 end Targparm; |