|
111
|
1 ------------------------------------------------------------------------------
|
|
|
2 -- --
|
|
|
3 -- GNAT COMPILER COMPONENTS --
|
|
|
4 -- --
|
|
|
5 -- I N L I N E --
|
|
|
6 -- --
|
|
|
7 -- S p e c --
|
|
|
8 -- --
|
|
|
9 -- Copyright (C) 1992-2016, 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 module handles four kinds of inlining activity:
|
|
|
27
|
|
|
28 -- a) Instantiation of generic bodies. This is done unconditionally, after
|
|
|
29 -- analysis and expansion of the main unit.
|
|
|
30
|
|
|
31 -- b) Compilation of unit bodies that contain the bodies of inlined sub-
|
|
|
32 -- programs. This is done only if inlining is enabled (-gnatn). Full inlining
|
|
|
33 -- requires that a) and b) be mutually recursive, because each step may
|
|
|
34 -- generate another generic expansion and further inlined calls.
|
|
|
35
|
|
|
36 -- c) Front-end inlining for Inline_Always subprograms. This is primarily an
|
|
|
37 -- expansion activity that is performed for performance reasons, and when the
|
|
|
38 -- target does not use the GCC back end.
|
|
|
39
|
|
|
40 -- d) Front-end inlining for GNATprove, to perform source transformations
|
|
|
41 -- to simplify formal verification. The machinery used is the same as for
|
|
|
42 -- Inline_Always subprograms, but there are fewer restrictions on the source
|
|
|
43 -- of subprograms.
|
|
|
44
|
|
|
45 with Alloc;
|
|
|
46 with Opt; use Opt;
|
|
|
47 with Sem; use Sem;
|
|
|
48 with Table;
|
|
|
49 with Types; use Types;
|
|
|
50 with Warnsw; use Warnsw;
|
|
|
51
|
|
|
52 package Inline is
|
|
|
53
|
|
|
54 --------------------------------
|
|
|
55 -- Generic Body Instantiation --
|
|
|
56 --------------------------------
|
|
|
57
|
|
|
58 -- The bodies of generic instantiations are built after semantic analysis
|
|
|
59 -- of the main unit is complete. Generic instantiations are saved in a
|
|
|
60 -- global data structure, and the bodies constructed by means of a separate
|
|
|
61 -- analysis and expansion step.
|
|
|
62
|
|
|
63 -- See full description in body of Sem_Ch12 for more details
|
|
|
64
|
|
|
65 type Pending_Body_Info is record
|
|
|
66 Inst_Node : Node_Id;
|
|
|
67 -- Node for instantiation that requires the body
|
|
|
68
|
|
|
69 Act_Decl : Node_Id;
|
|
|
70 -- Declaration for package or subprogram spec for instantiation
|
|
|
71
|
|
|
72 Expander_Status : Boolean;
|
|
|
73 -- If the body is instantiated only for semantic checking, expansion
|
|
|
74 -- must be inhibited.
|
|
|
75
|
|
|
76 Current_Sem_Unit : Unit_Number_Type;
|
|
|
77 -- The semantic unit within which the instantiation is found. Must be
|
|
|
78 -- restored when compiling the body, to insure that internal entities
|
|
|
79 -- use the same counter and are unique over spec and body.
|
|
|
80
|
|
|
81 Scope_Suppress : Suppress_Record;
|
|
|
82 Local_Suppress_Stack_Top : Suppress_Stack_Entry_Ptr;
|
|
|
83 -- Save suppress information at the point of instantiation. Used to
|
|
|
84 -- properly inherit check status active at this point (see RM 11.5
|
|
|
85 -- (7.2/2), AI95-00224-01):
|
|
|
86 --
|
|
|
87 -- "If a checking pragma applies to a generic instantiation, then the
|
|
|
88 -- checking pragma also applies to the instance. If a checking pragma
|
|
|
89 -- applies to a call to a subprogram that has a pragma Inline applied
|
|
|
90 -- to it, then the checking pragma also applies to the inlined
|
|
|
91 -- subprogram body".
|
|
|
92 --
|
|
|
93 -- This means we have to capture this information from the current scope
|
|
|
94 -- at the point of instantiation.
|
|
|
95
|
|
|
96 Version : Ada_Version_Type;
|
|
|
97 -- The body must be compiled with the same language version as the
|
|
|
98 -- spec. The version may be set by a configuration pragma in a separate
|
|
|
99 -- file or in the current file, and may differ from body to body.
|
|
|
100
|
|
|
101 Version_Pragma : Node_Id;
|
|
|
102 -- This is linked with the Version value
|
|
|
103
|
|
|
104 Warnings : Warning_Record;
|
|
|
105 -- Capture values of warning flags
|
|
|
106
|
|
|
107 SPARK_Mode : SPARK_Mode_Type;
|
|
|
108 SPARK_Mode_Pragma : Node_Id;
|
|
|
109 -- SPARK_Mode for an instance is the one applicable at the point of
|
|
|
110 -- instantiation. SPARK_Mode_Pragma is the related active pragma.
|
|
|
111 end record;
|
|
|
112
|
|
|
113 package Pending_Instantiations is new Table.Table (
|
|
|
114 Table_Component_Type => Pending_Body_Info,
|
|
|
115 Table_Index_Type => Int,
|
|
|
116 Table_Low_Bound => 0,
|
|
|
117 Table_Initial => Alloc.Pending_Instantiations_Initial,
|
|
|
118 Table_Increment => Alloc.Pending_Instantiations_Increment,
|
|
|
119 Table_Name => "Pending_Instantiations");
|
|
|
120
|
|
|
121 -- The following table records subprograms and packages for which
|
|
|
122 -- generation of subprogram descriptors must be delayed.
|
|
|
123
|
|
|
124 package Pending_Descriptor is new Table.Table (
|
|
|
125 Table_Component_Type => Entity_Id,
|
|
|
126 Table_Index_Type => Int,
|
|
|
127 Table_Low_Bound => 0,
|
|
|
128 Table_Initial => Alloc.Pending_Instantiations_Initial,
|
|
|
129 Table_Increment => Alloc.Pending_Instantiations_Increment,
|
|
|
130 Table_Name => "Pending_Descriptor");
|
|
|
131
|
|
|
132 -- The following should be initialized in an init call in Frontend, we
|
|
|
133 -- have thoughts of making the frontend reusable in future ???
|
|
|
134
|
|
|
135 -----------------
|
|
|
136 -- Subprograms --
|
|
|
137 -----------------
|
|
|
138
|
|
|
139 procedure Initialize;
|
|
|
140 -- Initialize internal tables
|
|
|
141
|
|
|
142 procedure Lock;
|
|
|
143 -- Lock internal tables before calling backend
|
|
|
144
|
|
|
145 procedure Instantiate_Bodies;
|
|
|
146 -- This procedure is called after semantic analysis is complete, to
|
|
|
147 -- instantiate the bodies of generic instantiations that appear in the
|
|
|
148 -- compilation unit.
|
|
|
149
|
|
|
150 procedure Add_Inlined_Body (E : Entity_Id; N : Node_Id);
|
|
|
151 -- E is an inlined subprogram appearing in a call, either explicitly or in
|
|
|
152 -- a discriminant check for which gigi builds a call or an at-end handler.
|
|
|
153 -- Add E's enclosing unit to Inlined_Bodies so that E can be subsequently
|
|
|
154 -- retrieved and analyzed. N is the node giving rise to the call to E.
|
|
|
155
|
|
|
156 procedure Analyze_Inlined_Bodies;
|
|
|
157 -- At end of compilation, analyze the bodies of all units that contain
|
|
|
158 -- inlined subprograms that are actually called.
|
|
|
159
|
|
|
160 procedure Build_Body_To_Inline (N : Node_Id; Spec_Id : Entity_Id);
|
|
|
161 -- If a subprogram has pragma Inline and inlining is active, use generic
|
|
|
162 -- machinery to build an unexpanded body for the subprogram. This body is
|
|
|
163 -- subsequently used for inline expansions at call sites. If subprogram can
|
|
|
164 -- be inlined (depending on size and nature of local declarations) the
|
|
|
165 -- template body is created. Otherwise subprogram body is treated normally
|
|
|
166 -- and calls are not inlined in the frontend. If proper warnings are
|
|
|
167 -- enabled and the subprogram contains a construct that cannot be inlined,
|
|
|
168 -- the problematic construct is flagged accordingly.
|
|
|
169
|
|
|
170 function Call_Can_Be_Inlined_In_GNATprove_Mode
|
|
|
171 (N : Node_Id;
|
|
|
172 Subp : Entity_Id) return Boolean;
|
|
|
173 -- Returns False if the call in node N to subprogram Subp cannot be inlined
|
|
|
174 -- in GNATprove mode, because it may lead to missing a check on type
|
|
|
175 -- conversion of input parameters otherwise. Returns True otherwise.
|
|
|
176
|
|
|
177 function Can_Be_Inlined_In_GNATprove_Mode
|
|
|
178 (Spec_Id : Entity_Id;
|
|
|
179 Body_Id : Entity_Id) return Boolean;
|
|
|
180 -- Returns True if the subprogram identified by Spec_Id and Body_Id can
|
|
|
181 -- be inlined in GNATprove mode. One but not both of Spec_Id and Body_Id
|
|
|
182 -- can be Empty. Body_Id is Empty when doing a partial check on a call
|
|
|
183 -- to a subprogram whose body has not been seen yet, to know whether this
|
|
|
184 -- subprogram could possibly be inlined. GNATprove relies on this to adapt
|
|
|
185 -- its treatment of the subprogram.
|
|
|
186
|
|
|
187 procedure Cannot_Inline
|
|
|
188 (Msg : String;
|
|
|
189 N : Node_Id;
|
|
|
190 Subp : Entity_Id;
|
|
|
191 Is_Serious : Boolean := False);
|
|
|
192 -- This procedure is called if the node N, an instance of a call to
|
|
|
193 -- subprogram Subp, cannot be inlined. Msg is the message to be issued,
|
|
|
194 -- which ends with ? (it does not end with ?p?, this routine takes care of
|
|
|
195 -- the need to change ? to ?p?). The behavior of this routine depends on
|
|
|
196 -- the value of Back_End_Inlining:
|
|
|
197 --
|
|
|
198 -- * If Back_End_Inlining is not set (ie. legacy frontend inlining model)
|
|
|
199 -- then if Subp has a pragma Always_Inlined, then an error message is
|
|
|
200 -- issued (by removing the last character of Msg). If Subp is not
|
|
|
201 -- Always_Inlined, then a warning is issued if the flag Ineffective_
|
|
|
202 -- Inline_Warnings is set, adding ?p to the msg, and if not, the call
|
|
|
203 -- has no effect.
|
|
|
204 --
|
|
|
205 -- * If Back_End_Inlining is set then:
|
|
|
206 -- - If Is_Serious is true, then an error is reported (by removing the
|
|
|
207 -- last character of Msg);
|
|
|
208 --
|
|
|
209 -- - otherwise:
|
|
|
210 --
|
|
|
211 -- * Compiling without optimizations if Subp has a pragma
|
|
|
212 -- Always_Inlined, then an error message is issued; if Subp is
|
|
|
213 -- not Always_Inlined, then a warning is issued if the flag
|
|
|
214 -- Ineffective_Inline_Warnings is set (adding p?), and if not,
|
|
|
215 -- the call has no effect.
|
|
|
216 --
|
|
|
217 -- * Compiling with optimizations then a warning is issued if the
|
|
|
218 -- flag Ineffective_Inline_Warnings is set (adding p?); otherwise
|
|
|
219 -- no effect since inlining may be performed by the backend.
|
|
|
220
|
|
|
221 procedure Check_And_Split_Unconstrained_Function
|
|
|
222 (N : Node_Id;
|
|
|
223 Spec_Id : Entity_Id;
|
|
|
224 Body_Id : Entity_Id);
|
|
|
225 -- Spec_Id and Body_Id are the entities of the specification and body of
|
|
|
226 -- the subprogram body N. If N can be inlined by the frontend (supported
|
|
|
227 -- cases documented in Check_Body_To_Inline) then build the body-to-inline
|
|
|
228 -- associated with N and attach it to the declaration node of Spec_Id.
|
|
|
229
|
|
|
230 procedure Check_Package_Body_For_Inlining (N : Node_Id; P : Entity_Id);
|
|
|
231 -- If front-end inlining is enabled and a package declaration contains
|
|
|
232 -- inlined subprograms, load and compile the package body to collect the
|
|
|
233 -- bodies of these subprograms, so they are available to inline calls.
|
|
|
234 -- N is the compilation unit for the package.
|
|
|
235
|
|
|
236 procedure Expand_Inlined_Call
|
|
|
237 (N : Node_Id;
|
|
|
238 Subp : Entity_Id;
|
|
|
239 Orig_Subp : Entity_Id);
|
|
|
240 -- If called subprogram can be inlined by the front-end, retrieve the
|
|
|
241 -- analyzed body, replace formals with actuals and expand call in place.
|
|
|
242 -- Generate thunks for actuals that are expressions, and insert the
|
|
|
243 -- corresponding constant declarations before the call. If the original
|
|
|
244 -- call is to a derived operation, the return type is the one of the
|
|
|
245 -- derived operation, but the body is that of the original, so return
|
|
|
246 -- expressions in the body must be converted to the desired type (which
|
|
|
247 -- is simply not noted in the tree without inline expansion).
|
|
|
248
|
|
|
249 function Has_Excluded_Declaration
|
|
|
250 (Subp : Entity_Id;
|
|
|
251 Decls : List_Id) return Boolean;
|
|
|
252 -- Check a list of declarations, Decls, that make the inlining of Subp not
|
|
|
253 -- worthwhile
|
|
|
254
|
|
|
255 function Has_Excluded_Statement
|
|
|
256 (Subp : Entity_Id;
|
|
|
257 Stats : List_Id) return Boolean;
|
|
|
258 -- Check a list of statements, Stats, that make inlining of Subp not
|
|
|
259 -- worthwhile, including any tasking statement, nested at any level.
|
|
|
260
|
|
|
261 procedure List_Inlining_Info;
|
|
|
262 -- Generate listing of calls inlined by the frontend plus listing of
|
|
|
263 -- calls to inline subprograms passed to the backend.
|
|
|
264
|
|
|
265 procedure Remove_Dead_Instance (N : Node_Id);
|
|
|
266 -- If an instantiation appears in unreachable code, delete the pending
|
|
|
267 -- body instance.
|
|
|
268
|
|
|
269 end Inline;
|
