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-2013, 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 two 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) an b) be mutually recursive, because each step may 34-- generate another generic expansion and further inlined calls. For now each 35-- of them uses a workpile algorithm, but they are called independently from 36-- Frontend, and thus are not mutually recursive. 37 38with Alloc; 39with Opt; use Opt; 40with Sem; use Sem; 41with Table; 42with Types; use Types; 43with Warnsw; use Warnsw; 44 45package Inline is 46 47 -------------------------------- 48 -- Generic Body Instantiation -- 49 -------------------------------- 50 51 -- The bodies of generic instantiations are built after semantic analysis 52 -- of the main unit is complete. Generic instantiations are saved in a 53 -- global data structure, and the bodies constructed by means of a separate 54 -- analysis and expansion step. 55 56 -- See full description in body of Sem_Ch12 for more details 57 58 type Pending_Body_Info is record 59 Inst_Node : Node_Id; 60 -- Node for instantiation that requires the body 61 62 Act_Decl : Node_Id; 63 -- Declaration for package or subprogram spec for instantiation 64 65 Expander_Status : Boolean; 66 -- If the body is instantiated only for semantic checking, expansion 67 -- must be inhibited. 68 69 Current_Sem_Unit : Unit_Number_Type; 70 -- The semantic unit within which the instantiation is found. Must 71 -- be restored when compiling the body, to insure that internal enti- 72 -- ties use the same counter and are unique over spec and body. 73 74 Scope_Suppress : Suppress_Record; 75 Local_Suppress_Stack_Top : Suppress_Stack_Entry_Ptr; 76 -- Save suppress information at the point of instantiation. Used to 77 -- properly inherit check status active at this point (see RM 11.5 78 -- (7.2/2), AI95-00224-01): 79 -- 80 -- "If a checking pragma applies to a generic instantiation, then the 81 -- checking pragma also applies to the instance. If a checking pragma 82 -- applies to a call to a subprogram that has a pragma Inline applied 83 -- to it, then the checking pragma also applies to the inlined 84 -- subprogram body". 85 -- 86 -- This means we have to capture this information from the current scope 87 -- at the point of instantiation. 88 89 Version : Ada_Version_Type; 90 -- The body must be compiled with the same language version as the 91 -- spec. The version may be set by a configuration pragma in a separate 92 -- file or in the current file, and may differ from body to body. 93 94 Version_Pragma : Node_Id; 95 -- This is linked with the Version value 96 97 Warnings : Warning_Record; 98 -- Capture values of warning flags 99 100 SPARK_Mode : SPARK_Mode_Type; 101 SPARK_Mode_Pragma : Node_Id; 102 -- SPARK_Mode for an instance is the one applicable at the point of 103 -- instantiation. SPARK_Mode_Pragma is the related active pragma. 104 end record; 105 106 package Pending_Instantiations is new Table.Table ( 107 Table_Component_Type => Pending_Body_Info, 108 Table_Index_Type => Int, 109 Table_Low_Bound => 0, 110 Table_Initial => Alloc.Pending_Instantiations_Initial, 111 Table_Increment => Alloc.Pending_Instantiations_Increment, 112 Table_Name => "Pending_Instantiations"); 113 114 -- The following table records subprograms and packages for which 115 -- generation of subprogram descriptors must be delayed. 116 117 package Pending_Descriptor is new Table.Table ( 118 Table_Component_Type => Entity_Id, 119 Table_Index_Type => Int, 120 Table_Low_Bound => 0, 121 Table_Initial => Alloc.Pending_Instantiations_Initial, 122 Table_Increment => Alloc.Pending_Instantiations_Increment, 123 Table_Name => "Pending_Descriptor"); 124 125 ----------------- 126 -- Subprograms -- 127 ----------------- 128 129 procedure Initialize; 130 -- Initialize internal tables 131 132 procedure Lock; 133 -- Lock internal tables before calling backend 134 135 procedure Instantiate_Bodies; 136 -- This procedure is called after semantic analysis is complete, to 137 -- instantiate the bodies of generic instantiations that appear in the 138 -- compilation unit. 139 140 procedure Add_Inlined_Body (E : Entity_Id); 141 -- E is an inlined subprogram appearing in a call, either explicitly, or 142 -- a discriminant check for which gigi builds a call. Add E's enclosing 143 -- unit to Inlined_Bodies so that body of E can be subsequently retrieved 144 -- and analyzed. 145 146 procedure Analyze_Inlined_Bodies; 147 -- At end of compilation, analyze the bodies of all units that contain 148 -- inlined subprograms that are actually called. 149 150 procedure Check_Body_For_Inlining (N : Node_Id; P : Entity_Id); 151 -- If front-end inlining is enabled and a package declaration contains 152 -- inlined subprograms, load and compile the package body to collect the 153 -- bodies of these subprograms, so they are available to inline calls. 154 -- N is the compilation unit for the package. 155 156 procedure Remove_Dead_Instance (N : Node_Id); 157 -- If an instantiation appears in unreachable code, delete the pending 158 -- body instance. 159 160end Inline; 161