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-2018, 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 45with Alloc; 46with Opt; use Opt; 47with Sem; use Sem; 48with Table; 49with Types; use Types; 50with Warnsw; use Warnsw; 51 52package 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 269end Inline; 270