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-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
  38 with Alloc;
  39 with Opt;    use Opt;
  40 with Sem;    use Sem;
  41 with Table;
  42 with Types;  use Types;
  43 with Warnsw; use Warnsw;
  44
  45 package 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
 160 end Inline;