|
111
|
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;
|
