1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1996-2020, Free Software Foundation, Inc. --
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. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 with Atree
; use Atree
;
27 with Einfo
; use Einfo
;
28 with Errout
; use Errout
;
29 with Namet
; use Namet
;
31 with Sem_Aux
; use Sem_Aux
;
32 with Sinfo
; use Sinfo
;
33 with Snames
; use Snames
;
35 package body Sem_Mech
is
37 -------------------------
38 -- Set_Mechanism_Value --
39 -------------------------
41 procedure Set_Mechanism_Value
(Ent
: Entity_Id
; Mech_Name
: Node_Id
) is
43 procedure Bad_Mechanism
;
44 -- Signal bad mechanism name
50 procedure Bad_Mechanism
is
52 Error_Msg_N
("unrecognized mechanism name", Mech_Name
);
55 -- Start of processing for Set_Mechanism_Value
58 if Mechanism
(Ent
) /= Default_Mechanism
then
60 ("mechanism for & has already been set", Mech_Name
, Ent
);
63 -- MECHANISM_NAME ::= value | reference
65 if Nkind
(Mech_Name
) = N_Identifier
then
66 if Chars
(Mech_Name
) = Name_Value
then
67 Set_Mechanism_With_Checks
(Ent
, By_Copy
, Mech_Name
);
69 elsif Chars
(Mech_Name
) = Name_Reference
then
70 Set_Mechanism_With_Checks
(Ent
, By_Reference
, Mech_Name
);
72 elsif Chars
(Mech_Name
) = Name_Copy
then
73 Error_Msg_N
("bad mechanism name, Value assumed", Mech_Name
);
74 Set_Mechanism
(Ent
, By_Copy
);
83 end Set_Mechanism_Value
;
85 -------------------------------
86 -- Set_Mechanism_With_Checks --
87 -------------------------------
89 procedure Set_Mechanism_With_Checks
91 Mech
: Mechanism_Type
;
94 pragma Unreferenced
(Enod
);
97 -- Right now we don't do any checks, should we do more ???
99 Set_Mechanism
(Ent
, Mech
);
100 end Set_Mechanism_With_Checks
;
106 procedure Set_Mechanisms
(E
: Entity_Id
) is
111 -- Skip this processing if inside a generic template. Not only is
112 -- it unnecessary (since neither extra formals nor mechanisms are
113 -- relevant for the template itself), but at least at the moment,
114 -- procedures get frozen early inside a template so attempting to
115 -- look at the formal types does not work too well if they are
116 -- private types that have not been frozen yet.
118 if Inside_A_Generic
then
122 -- Loop through formals
124 Formal
:= First_Formal
(E
);
125 while Present
(Formal
) loop
127 if Mechanism
(Formal
) = Default_Mechanism
then
128 Typ
:= Underlying_Type
(Etype
(Formal
));
130 -- If there is no underlying type, then skip this processing and
131 -- leave the convention set to Default_Mechanism. It seems odd
132 -- that there should ever be such cases but there are (see
133 -- comments for filed regression tests 1418-001 and 1912-009) ???
139 case Convention
(E
) is
145 -- Note: all RM defined conventions are treated the same from
146 -- the point of view of parameter passing mechanism. Convention
147 -- Ghost has the same dynamic semantics as convention Ada.
151 | Convention_Intrinsic
152 | Convention_Protected
155 -- By reference types are passed by reference (RM 6.2(4))
157 if Is_By_Reference_Type
(Typ
) then
158 Set_Mechanism
(Formal
, By_Reference
);
160 -- By copy types are passed by copy (RM 6.2(3))
162 elsif Is_By_Copy_Type
(Typ
) then
163 Set_Mechanism
(Formal
, By_Copy
);
165 -- All other types we leave the Default_Mechanism set, so
166 -- that the backend can choose the appropriate method.
172 -- Special Ada conventions specifying passing mechanism
174 when Convention_Ada_Pass_By_Copy
=>
175 Set_Mechanism
(Formal
, By_Copy
);
177 when Convention_Ada_Pass_By_Reference
=>
178 Set_Mechanism
(Formal
, By_Reference
);
184 -- Note: Assembler and Stdcall also use C conventions
186 when Convention_Assembler
187 | Convention_C_Family
190 -- The following values are passed by copy
192 -- IN Scalar parameters (RM B.3(66))
193 -- IN parameters of access types (RM B.3(67))
194 -- Access parameters (RM B.3(68))
195 -- Access to subprogram types (RM B.3(71))
197 -- Note: in the case of access parameters, it is the pointer
198 -- that is passed by value. In GNAT access parameters are
199 -- treated as IN parameters of an anonymous access type, so
200 -- this falls out free.
202 -- The bottom line is that all IN elementary types are
203 -- passed by copy in GNAT.
205 if Is_Elementary_Type
(Typ
) then
206 if Ekind
(Formal
) = E_In_Parameter
then
207 Set_Mechanism
(Formal
, By_Copy
);
209 -- OUT and IN OUT parameters of elementary types are
210 -- passed by reference (RM B.3(68)). Note that we are
211 -- not following the advice to pass the address of a
212 -- copy to preserve by copy semantics.
215 Set_Mechanism
(Formal
, By_Reference
);
218 -- Records are normally passed by reference (RM B.3(69)).
219 -- However, this can be overridden by the use of the
220 -- C_Pass_By_Copy pragma or C_Pass_By_Copy convention.
222 elsif Is_Record_Type
(Typ
) then
224 -- If the record is not convention C, then we always
225 -- pass by reference, C_Pass_By_Copy does not apply.
227 if Convention
(Typ
) /= Convention_C
then
228 Set_Mechanism
(Formal
, By_Reference
);
230 -- OUT and IN OUT parameters of record types are passed
231 -- by reference regardless of pragmas (RM B.3 (69/2)).
233 elsif Ekind
(Formal
) in
234 E_Out_Parameter | E_In_Out_Parameter
236 Set_Mechanism
(Formal
, By_Reference
);
238 -- IN parameters of record types are passed by copy only
239 -- when the related type has convention C_Pass_By_Copy
240 -- (RM B.3 (68.1/2)).
242 elsif Ekind
(Formal
) = E_In_Parameter
243 and then C_Pass_By_Copy
(Typ
)
245 Set_Mechanism
(Formal
, By_Copy
);
247 -- Otherwise, for a C convention record, we set the
248 -- convention in accordance with a possible use of
249 -- the C_Pass_By_Copy pragma. Note that the value of
250 -- Default_C_Record_Mechanism in the absence of such
251 -- a pragma is By_Reference.
254 Set_Mechanism
(Formal
, Default_C_Record_Mechanism
);
257 -- Array types are passed by reference (B.3 (71))
259 elsif Is_Array_Type
(Typ
) then
260 Set_Mechanism
(Formal
, By_Reference
);
262 -- For all other types, use Default_Mechanism mechanism
272 when Convention_COBOL
=>
274 -- Access parameters (which in GNAT look like IN parameters
275 -- of an access type) are passed by copy (RM B.4(96)) as
276 -- are all other IN parameters of scalar type (RM B.4(97)).
278 -- For now we pass these parameters by reference as well.
279 -- The RM specifies the intent BY_CONTENT, but gigi does
280 -- not currently transform By_Copy properly. If we pass by
281 -- reference, it will be imperative to introduce copies ???
283 if Is_Elementary_Type
(Typ
)
284 and then Ekind
(Formal
) = E_In_Parameter
286 Set_Mechanism
(Formal
, By_Reference
);
288 -- All other parameters (i.e. all non-scalar types, and
289 -- all OUT or IN OUT parameters) are passed by reference.
290 -- Note that at the moment we are not bothering to make
291 -- copies of scalar types as recommended in the RM.
294 Set_Mechanism
(Formal
, By_Reference
);
301 when Convention_Fortran
=>
303 -- Access types are passed by default (presumably this
304 -- will mean they are passed by copy)
306 if Is_Access_Type
(Typ
) then
309 -- For now, we pass all other parameters by reference.
310 -- It is not clear that this is right in the long run,
311 -- but it seems to correspond to what gnu f77 wants.
314 Set_Mechanism
(Formal
, By_Reference
);
319 <<Skip_Formal
>> -- remove this when problem above is fixed ???
321 Next_Formal
(Formal
);
324 -- Note: there is nothing we need to do for the return type here.
325 -- We deal with returning by reference in the Ada sense, by use of
326 -- the flag By_Ref, rather than by messing with mechanisms.
328 -- A mechanism of Reference for the return means that an extra
329 -- parameter must be provided for the return value (that is the
330 -- DEC meaning of the pragma), and is unrelated to the Ada notion
331 -- of return by reference.
333 -- Note: there was originally code here to set the mechanism to
334 -- By_Reference for types that are "by reference" in the Ada sense,
335 -- but, in accordance with the discussion above, this is wrong, and
336 -- the code was removed.