gcc/ada/inline.ads

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