gcc/ada/a-tags.ads

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT RUN-TIME COMPONENTS                         --
   4 --                                                                          --
   5 --                             A D A . T A G S                              --
   6 --                                                                          --
   7 --                                 S p e c                                  --
   8 --                                                                          --
   9 --          Copyright (C) 1992-2014, Free Software Foundation, Inc.         --
  10 --                                                                          --
  11 -- This specification is derived from the Ada Reference Manual for use with --
  12 -- GNAT. The copyright notice above, and the license provisions that follow --
  13 -- apply solely to the  contents of the part following the private keyword. --
  14 --                                                                          --
  15 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  16 -- terms of the  GNU General Public License as published  by the Free Soft- --
  17 -- ware  Foundation;  either version 3,  or (at your option) any later ver- --
  18 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  19 -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  20 -- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
  21 --                                                                          --
  22 -- As a special exception under Section 7 of GPL version 3, you are granted --
  23 -- additional permissions described in the GCC Runtime Library Exception,   --
  24 -- version 3.1, as published by the Free Software Foundation.               --
  25 --                                                                          --
  26 -- You should have received a copy of the GNU General Public License and    --
  27 -- a copy of the GCC Runtime Library Exception along with this program;     --
  28 -- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
  29 -- <http://www.gnu.org/licenses/>.                                          --
  30 --                                                                          --
  31 -- GNAT was originally developed  by the GNAT team at  New York University. --
  32 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  33 --                                                                          --
  34 ------------------------------------------------------------------------------
  35
  36 --  The operations in this package provide the guarantee that all dispatching
  37 --  calls on primitive operations of tagged types and interfaces take constant
  38 --  time (in terms of source lines executed), that is to say, the cost of these
  39 --  calls is independent of the number of primitives of the type or interface,
  40 --  and independent of the number of ancestors or interface progenitors that a
  41 --  tagged type may have.
  42
  43 --  The following subprograms of the public part of this package take constant
  44 --  time (in terms of source lines executed):
  45
  46 --    Expanded_Name, Wide_Expanded_Name, Wide_Wide_Expanded_Name, External_Tag,
  47 --    Is_Descendant_At_Same_Level, Parent_Tag
  48 --    Descendant_Tag (when used with a library-level tagged type),
  49 --    Internal_Tag (when used with a library-level tagged type).
  50
  51 --  The following subprograms of the public part of this package take non
  52 --  constant time (in terms of sources line executed):
  53
  54 --    Descendant_Tag (when used with a locally defined tagged type)
  55 --    Internal_Tag (when used with a locally defined tagged type)
  56 --    Interface_Ancestor_Tagswith System
  57
  58 with System.Storage_Elements;
  59
  60 package Ada.Tags is
  61    pragma Preelaborate;
  62    --  In accordance with Ada 2005 AI-362
  63
  64    type Tag is private;
  65    pragma Preelaborable_Initialization (Tag);
  66
  67    No_Tag : constant Tag;
  68
  69    function Expanded_Name (T : Tag) return String;
  70
  71    function Wide_Expanded_Name (T : Tag) return Wide_String;
  72    pragma Ada_05 (Wide_Expanded_Name);
  73
  74    function Wide_Wide_Expanded_Name (T : Tag) return Wide_Wide_String;
  75    pragma Ada_05 (Wide_Wide_Expanded_Name);
  76
  77    function External_Tag (T : Tag) return String;
  78
  79    function Internal_Tag (External : String) return Tag;
  80
  81    function Descendant_Tag
  82      (External : String;
  83       Ancestor : Tag) return Tag;
  84    pragma Ada_05 (Descendant_Tag);
  85
  86    function Is_Descendant_At_Same_Level
  87      (Descendant : Tag;
  88       Ancestor   : Tag) return Boolean;
  89    pragma Ada_05 (Is_Descendant_At_Same_Level);
  90
  91    function Parent_Tag (T : Tag) return Tag;
  92    pragma Ada_05 (Parent_Tag);
  93
  94    type Tag_Array is array (Positive range <>) of Tag;
  95
  96    function Interface_Ancestor_Tags (T : Tag) return Tag_Array;
  97    pragma Ada_05 (Interface_Ancestor_Tags);
  98
  99    function Type_Is_Abstract (T : Tag) return Boolean;
 100    pragma Ada_2012 (Type_Is_Abstract);
 101
 102    Tag_Error : exception;
 103
 104 private
 105    --  Structure of the GNAT Primary Dispatch Table
 106
 107    --           +--------------------+
 108    --           |      Signature     |
 109    --           +--------------------+
 110    --           |     Tagged_Kind    |
 111    --           +--------------------+                            Predef Prims
 112    --           |    Predef_Prims -----------------------------> +------------+
 113    --           +--------------------+                           |  table of  |
 114    --           |    Offset_To_Top   |                           | predefined |
 115    --           +--------------------+                           | primitives |
 116    --           |Typeinfo_Ptr/TSD_Ptr---> Type Specific Data     +------------+
 117    --  Tag ---> +--------------------+   +-------------------+
 118    --           |      table of      |   | inheritance depth |
 119    --           :   primitive ops    :   +-------------------+
 120    --           |      pointers      |   |   access level    |
 121    --           +--------------------+   +-------------------+
 122    --                                    |     alignment     |
 123    --                                    +-------------------+
 124    --                                    |   expanded name   |
 125    --                                    +-------------------+
 126    --                                    |   external tag    |
 127    --                                    +-------------------+
 128    --                                    |   hash table link |
 129    --                                    +-------------------+
 130    --                                    |   transportable   |
 131    --                                    +-------------------+
 132    --                                    |  type_is_abstract |
 133    --                                    +-------------------+
 134    --                                    | needs finalization|
 135    --                                    +-------------------+
 136    --                                    |   Ifaces_Table   ---> Interface Data
 137    --                                    +-------------------+   +------------+
 138    --         Select Specific Data  <----        SSD         |   |  Nb_Ifaces |
 139    --         +------------------+       +-------------------+   +------------+
 140    --         |table of primitive|       | table of          |   |  table     |
 141    --         :   operation      :       :    ancestor       :   :    of      :
 142    --         |      kinds       |       |       tags        |   | interfaces |
 143    --         +------------------+       +-------------------+   +------------+
 144    --         |table of          |
 145    --         :   entry          :
 146    --         |      indexes     |
 147    --         +------------------+
 148
 149    --  Structure of the GNAT Secondary Dispatch Table
 150
 151    --           +--------------------+
 152    --           |      Signature     |
 153    --           +--------------------+
 154    --           |     Tagged_Kind    |
 155    --           +--------------------+                            Predef Prims
 156    --           |    Predef_Prims -----------------------------> +------------+
 157    --           +--------------------+                           |  table of  |
 158    --           |    Offset_To_Top   |                           | predefined |
 159    --           +--------------------+                           | primitives |
 160    --           |       OSD_Ptr      |---> Object Specific Data  |   thunks   |
 161    --  Tag ---> +--------------------+      +---------------+    +------------+
 162    --           |      table of      |      | num prim ops  |
 163    --           :    primitive op    :      +---------------+
 164    --           |   thunk pointers   |      | table of      |
 165    --           +--------------------+      +   primitive   |
 166    --                                       |    op offsets |
 167    --                                       +---------------+
 168
 169    --  The runtime information kept for each tagged type is separated into two
 170    --  objects: the Dispatch Table and the Type Specific Data record.
 171
 172    package SSE renames System.Storage_Elements;
 173
 174    subtype Cstring is String (Positive);
 175    type Cstring_Ptr is access all Cstring;
 176    pragma No_Strict_Aliasing (Cstring_Ptr);
 177
 178    --  Declarations for the table of interfaces
 179
 180    type Offset_To_Top_Function_Ptr is
 181      access function (This : System.Address) return SSE.Storage_Offset;
 182    --  Type definition used to call the function that is generated by the
 183    --  expander in case of tagged types with discriminants that have secondary
 184    --  dispatch tables. This function provides the Offset_To_Top value in this
 185    --  specific case.
 186
 187    type Interface_Data_Element is record
 188       Iface_Tag            : Tag;
 189       Static_Offset_To_Top : Boolean;
 190       Offset_To_Top_Value  : SSE.Storage_Offset;
 191       Offset_To_Top_Func   : Offset_To_Top_Function_Ptr;
 192       Secondary_DT         : Tag;
 193    end record;
 194    --  If some ancestor of the tagged type has discriminants the field
 195    --  Static_Offset_To_Top is False and the field Offset_To_Top_Func
 196    --  is used to store the access to the function generated by the
 197    --  expander which provides this value; otherwise Static_Offset_To_Top
 198    --  is True and such value is stored in the Offset_To_Top_Value field.
 199    --  Secondary_DT references a secondary dispatch table whose contents
 200    --  are pointers to the primitives of the tagged type that cover the
 201    --  interface primitives. Secondary_DT gives support to dispatching
 202    --  calls through interface types associated with Generic Dispatching
 203    --  Constructors.
 204
 205    type Interfaces_Array is array (Natural range <>) of Interface_Data_Element;
 206
 207    type Interface_Data (Nb_Ifaces : Positive) is record
 208       Ifaces_Table : Interfaces_Array (1 .. Nb_Ifaces);
 209    end record;
 210
 211    type Interface_Data_Ptr is access all Interface_Data;
 212    --  Table of abstract interfaces used to give support to backward interface
 213    --  conversions and also to IW_Membership.
 214
 215    --  Primitive operation kinds. These values differentiate the kinds of
 216    --  callable entities stored in the dispatch table. Certain kinds may
 217    --  not be used, but are added for completeness.
 218
 219    type Prim_Op_Kind is
 220      (POK_Function,
 221       POK_Procedure,
 222       POK_Protected_Entry,
 223       POK_Protected_Function,
 224       POK_Protected_Procedure,
 225       POK_Task_Entry,
 226       POK_Task_Function,
 227       POK_Task_Procedure);
 228
 229    --  Select specific data types
 230
 231    type Select_Specific_Data_Element is record
 232       Index : Positive;
 233       Kind  : Prim_Op_Kind;
 234    end record;
 235
 236    type Select_Specific_Data_Array is
 237      array (Positive range <>) of Select_Specific_Data_Element;
 238
 239    type Select_Specific_Data (Nb_Prim : Positive) is record
 240       SSD_Table : Select_Specific_Data_Array (1 .. Nb_Prim);
 241       --  NOTE: Nb_Prim is the number of non-predefined primitive operations
 242    end record;
 243
 244    type Select_Specific_Data_Ptr is access all Select_Specific_Data;
 245    --  A table used to store the primitive operation kind and entry index of
 246    --  primitive subprograms of a type that implements a limited interface.
 247    --  The Select Specific Data table resides in the Type Specific Data of a
 248    --  type. This construct is used in the handling of dispatching triggers
 249    --  in select statements.
 250
 251    type Prim_Ptr is access procedure;
 252    type Address_Array is array (Positive range <>) of Prim_Ptr;
 253
 254    subtype Dispatch_Table is Address_Array (1 .. 1);
 255    --  Used by GDB to identify the _tags and traverse the run-time structure
 256    --  associated with tagged types. For compatibility with older versions of
 257    --  gdb, its name must not be changed.
 258
 259    type Tag is access all Dispatch_Table;
 260    pragma No_Strict_Aliasing (Tag);
 261
 262    type Interface_Tag is access all Dispatch_Table;
 263
 264    No_Tag : constant Tag := null;
 265
 266    --  The expander ensures that Tag objects reference the Prims_Ptr component
 267    --  of the wrapper.
 268
 269    type Tag_Ptr is access all Tag;
 270    pragma No_Strict_Aliasing (Tag_Ptr);
 271
 272    type Offset_To_Top_Ptr is access all SSE.Storage_Offset;
 273    pragma No_Strict_Aliasing (Offset_To_Top_Ptr);
 274
 275    type Tag_Table is array (Natural range <>) of Tag;
 276
 277    type Size_Ptr is
 278      access function (A : System.Address) return Long_Long_Integer;
 279
 280    type Type_Specific_Data (Idepth : Natural) is record
 281    --  The discriminant Idepth is the Inheritance Depth Level: Used to
 282    --  implement the membership test associated with single inheritance of
 283    --  tagged types in constant-time. It also indicates the size of the
 284    --  Tags_Table component.
 285
 286       Access_Level : Natural;
 287       --  Accessibility level required to give support to Ada 2005 nested type
 288       --  extensions. This feature allows safe nested type extensions by
 289       --  shifting the accessibility checks to certain operations, rather than
 290       --  being enforced at the type declaration. In particular, by performing
 291       --  run-time accessibility checks on class-wide allocators, class-wide
 292       --  function return, and class-wide stream I/O, the danger of objects
 293       --  outliving their type declaration can be eliminated (Ada 2005: AI-344)
 294
 295       Alignment     : Natural;
 296       Expanded_Name : Cstring_Ptr;
 297       External_Tag  : Cstring_Ptr;
 298       HT_Link       : Tag_Ptr;
 299       --  Components used to support to the Ada.Tags subprograms in RM 3.9
 300
 301       --  Note: Expanded_Name is referenced by GDB to determine the actual name
 302       --  of the tagged type. Its requirements are: 1) it must have this exact
 303       --  name, and 2) its contents must point to a C-style Nul terminated
 304       --  string containing its expanded name. GDB has no requirement on a
 305       --  given position inside the record.
 306
 307       Transportable : Boolean;
 308       --  Used to check RM E.4(18), set for types that satisfy the requirements
 309       --  for being used in remote calls as actuals for classwide formals or as
 310       --  return values for classwide functions.
 311
 312       Type_Is_Abstract : Boolean;
 313       --  True if the type is abstract (Ada 2012: AI05-0173)
 314
 315       Needs_Finalization : Boolean;
 316       --  Used to dynamically check whether an object is controlled or not
 317
 318       Size_Func : Size_Ptr;
 319       --  Pointer to the subprogram computing the _size of the object. Used by
 320       --  the run-time whenever a call to the 'size primitive is required. We
 321       --  cannot assume that the contents of dispatch tables are addresses
 322       --  because in some architectures the ABI allows descriptors.
 323
 324       Interfaces_Table : Interface_Data_Ptr;
 325       --  Pointer to the table of interface tags. It is used to implement the
 326       --  membership test associated with interfaces and also for backward
 327       --  abstract interface type conversions (Ada 2005:AI-251)
 328
 329       SSD : Select_Specific_Data_Ptr;
 330       --  Pointer to a table of records used in dispatching selects. This field
 331       --  has a meaningful value for all tagged types that implement a limited,
 332       --  protected, synchronized or task interfaces and have non-predefined
 333       --  primitive operations.
 334
 335       Tags_Table : Tag_Table (0 .. Idepth);
 336       --  Table of ancestor tags. Its size actually depends on the inheritance
 337       --  depth level of the tagged type.
 338    end record;
 339
 340    type Type_Specific_Data_Ptr is access all Type_Specific_Data;
 341    pragma No_Strict_Aliasing (Type_Specific_Data_Ptr);
 342
 343    --  Declarations for the dispatch table record
 344
 345    type Signature_Kind is
 346       (Unknown,
 347        Primary_DT,
 348        Secondary_DT);
 349
 350    --  Tagged type kinds with respect to concurrency and limitedness
 351
 352    type Tagged_Kind is
 353      (TK_Abstract_Limited_Tagged,
 354       TK_Abstract_Tagged,
 355       TK_Limited_Tagged,
 356       TK_Protected,
 357       TK_Tagged,
 358       TK_Task);
 359
 360    type Dispatch_Table_Wrapper (Num_Prims : Natural) is record
 361       Signature     : Signature_Kind;
 362       Tag_Kind      : Tagged_Kind;
 363       Predef_Prims  : System.Address;
 364       --  Pointer to the dispatch table of predefined Ada primitives
 365
 366       --  According to the C++ ABI the components Offset_To_Top and TSD are
 367       --  stored just "before" the dispatch table, and they are referenced with
 368       --  negative offsets referring to the base of the dispatch table. The
 369       --   _Tag (or the VTable_Ptr in C++ terminology) must point to the base
 370       --  of the virtual table, just after these components, to point to the
 371       --  Prims_Ptr table.
 372
 373       Offset_To_Top : SSE.Storage_Offset;
 374       TSD           : System.Address;
 375
 376       Prims_Ptr : aliased Address_Array (1 .. Num_Prims);
 377       --  The size of the Prims_Ptr array actually depends on the tagged type
 378       --  to which it applies. For each tagged type, the expander computes the
 379       --  actual array size, allocates the Dispatch_Table record accordingly.
 380    end record;
 381
 382    type Dispatch_Table_Ptr is access all Dispatch_Table_Wrapper;
 383    pragma No_Strict_Aliasing (Dispatch_Table_Ptr);
 384
 385    --  The following type declaration is used by the compiler when the program
 386    --  is compiled with restriction No_Dispatching_Calls. It is also used with
 387    --  interface types to generate the tag and run-time information associated
 388    --  with them.
 389
 390    type No_Dispatch_Table_Wrapper is record
 391       NDT_TSD       : System.Address;
 392       NDT_Prims_Ptr : Natural;
 393    end record;
 394
 395    DT_Predef_Prims_Size : constant SSE.Storage_Count :=
 396                             SSE.Storage_Count
 397                               (1 * (Standard'Address_Size /
 398                                       System.Storage_Unit));
 399    --  Size of the Predef_Prims field of the Dispatch_Table
 400
 401    DT_Offset_To_Top_Size : constant SSE.Storage_Count :=
 402                              SSE.Storage_Count
 403                                (1 * (Standard'Address_Size /
 404                                        System.Storage_Unit));
 405    --  Size of the Offset_To_Top field of the Dispatch Table
 406
 407    DT_Typeinfo_Ptr_Size : constant SSE.Storage_Count :=
 408                             SSE.Storage_Count
 409                               (1 * (Standard'Address_Size /
 410                                       System.Storage_Unit));
 411    --  Size of the Typeinfo_Ptr field of the Dispatch Table
 412
 413    use type System.Storage_Elements.Storage_Offset;
 414
 415    DT_Offset_To_Top_Offset : constant SSE.Storage_Count :=
 416                                DT_Typeinfo_Ptr_Size
 417                                  + DT_Offset_To_Top_Size;
 418
 419    DT_Predef_Prims_Offset : constant SSE.Storage_Count :=
 420                               DT_Typeinfo_Ptr_Size
 421                                 + DT_Offset_To_Top_Size
 422                                 + DT_Predef_Prims_Size;
 423    --  Offset from Prims_Ptr to Predef_Prims component
 424
 425    --  Object Specific Data record of secondary dispatch tables
 426
 427    type Object_Specific_Data_Array is array (Positive range <>) of Positive;
 428
 429    type Object_Specific_Data (OSD_Num_Prims : Positive) is record
 430       OSD_Table : Object_Specific_Data_Array (1 .. OSD_Num_Prims);
 431       --  Table used in secondary DT to reference their counterpart in the
 432       --  select specific data (in the TSD of the primary DT). This construct
 433       --  is used in the handling of dispatching triggers in select statements.
 434       --  Nb_Prim is the number of non-predefined primitive operations.
 435    end record;
 436
 437    type Object_Specific_Data_Ptr is access all Object_Specific_Data;
 438    pragma No_Strict_Aliasing (Object_Specific_Data_Ptr);
 439
 440    --  The following subprogram specifications are placed here instead of the
 441    --  package body to see them from the frontend through rtsfind.
 442
 443    function Base_Address (This : System.Address) return System.Address;
 444    --  Ada 2005 (AI-251): Displace "This" to point to the base address of the
 445    --  object (that is, the address of the primary tag of the object).
 446
 447    procedure Check_TSD (TSD : Type_Specific_Data_Ptr);
 448    --  Ada 2012 (AI-113): Raise Program_Error if the external tag of this TSD
 449    --  is the same as the external tag for some other tagged type declaration.
 450
 451    function Displace (This : System.Address; T : Tag) return System.Address;
 452    --  Ada 2005 (AI-251): Displace "This" to point to the secondary dispatch
 453    --  table of T.
 454
 455    function Secondary_Tag (T, Iface : Tag) return Tag;
 456    --  Ada 2005 (AI-251): Given a primary tag T associated with a tagged type
 457    --  Typ, search for the secondary tag of the interface type Iface covered
 458    --  by Typ.
 459
 460    function DT (T : Tag) return Dispatch_Table_Ptr;
 461    --  Return the pointer to the TSD record associated with T
 462
 463    function Get_Entry_Index (T : Tag; Position : Positive) return Positive;
 464    --  Ada 2005 (AI-251): Return a primitive operation's entry index (if entry)
 465    --  given a dispatch table T and a position of a primitive operation in T.
 466
 467    function Get_Offset_Index
 468      (T        : Tag;
 469       Position : Positive) return Positive;
 470    --  Ada 2005 (AI-251): Given a pointer to a secondary dispatch table (T)
 471    --  and a position of an operation in the DT, retrieve the corresponding
 472    --  operation's position in the primary dispatch table from the Offset
 473    --  Specific Data table of T.
 474
 475    function Get_Prim_Op_Kind
 476      (T        : Tag;
 477       Position : Positive) return Prim_Op_Kind;
 478    --  Ada 2005 (AI-251): Return a primitive operation's kind given a dispatch
 479    --  table T and a position of a primitive operation in T.
 480
 481    function Get_Tagged_Kind (T : Tag) return Tagged_Kind;
 482    --  Ada 2005 (AI-345): Given a pointer to either a primary or a secondary
 483    --  dispatch table, return the tagged kind of a type in the context of
 484    --  concurrency and limitedness.
 485
 486    function IW_Membership (This : System.Address; T : Tag) return Boolean;
 487    --  Ada 2005 (AI-251): General routine that checks if a given object
 488    --  implements a tagged type. Its common usage is to check if Obj is in
 489    --  Iface'Class, but it is also used to check if a class-wide interface
 490    --  implements a given type (Iface_CW_Typ in T'Class). For example:
 491    --
 492    --      type I is interface;
 493    --      type T is tagged ...
 494    --
 495    --      function Test (O : I'Class) is
 496    --      begin
 497    --         return O in T'Class.
 498    --      end Test;
 499
 500    function Offset_To_Top
 501      (This : System.Address) return SSE.Storage_Offset;
 502    --  Ada 2005 (AI-251): Returns the current value of the Offset_To_Top
 503    --  component available in the prologue of the dispatch table. If the parent
 504    --  of the tagged type has discriminants this value is stored in a record
 505    --  component just immediately after the tag component.
 506
 507    function Needs_Finalization (T : Tag) return Boolean;
 508    --  A helper routine used in conjunction with finalization collections which
 509    --  service class-wide types. The function dynamically determines whether an
 510    --  object is controlled or has controlled components.
 511
 512    function Parent_Size
 513      (Obj : System.Address;
 514       T   : Tag) return SSE.Storage_Count;
 515    --  Computes the size the ancestor part of a tagged extension object whose
 516    --  address is 'obj' by calling indirectly the ancestor _size function. The
 517    --  ancestor is the parent of the type represented by tag T. This function
 518    --  assumes that _size is always in slot one of the dispatch table.
 519
 520    pragma Export (Ada, Parent_Size, "ada__tags__parent_size");
 521    --  This procedure is used in s-finimp and is thus exported manually
 522
 523    procedure Register_Interface_Offset
 524      (This         : System.Address;
 525       Interface_T  : Tag;
 526       Is_Static    : Boolean;
 527       Offset_Value : SSE.Storage_Offset;
 528       Offset_Func  : Offset_To_Top_Function_Ptr);
 529    --  Register in the table of interfaces of the tagged type associated with
 530    --  "This" object the offset of the record component associated with the
 531    --  progenitor Interface_T (that is, the distance from "This" to the object
 532    --  component containing the tag of the secondary dispatch table). In case
 533    --  of constant offset, Is_Static is true and Offset_Value has such value.
 534    --  In case of variable offset, Is_Static is false and Offset_Func is an
 535    --  access to function that must be called to evaluate the offset.
 536
 537    procedure Register_Tag (T : Tag);
 538    --  Insert the Tag and its associated external_tag in a table for the sake
 539    --  of Internal_Tag.
 540
 541    procedure Set_Dynamic_Offset_To_Top
 542      (This         : System.Address;
 543       Interface_T  : Tag;
 544       Offset_Value : SSE.Storage_Offset;
 545       Offset_Func  : Offset_To_Top_Function_Ptr);
 546    --  Ada 2005 (AI-251): The compiler generates calls to this routine only
 547    --  when initializing the Offset_To_Top field of dispatch tables associated
 548    --  with tagged type whose parent has variable size components. "This" is
 549    --  the object whose dispatch table is being initialized. Interface_T is the
 550    --  interface for which the secondary dispatch table is being initialized,
 551    --  and Offset_Value is the distance from "This" to the object component
 552    --  containing the tag of the secondary dispatch table (a zero value means
 553    --  that this interface shares the primary dispatch table). Offset_Func
 554    --  references a function that must be called to evaluate the offset at
 555    --  runtime. This routine also takes care of registering these values in
 556    --  the table of interfaces of the type.
 557
 558    procedure Set_Entry_Index (T : Tag; Position : Positive; Value : Positive);
 559    --  Ada 2005 (AI-345): Set the entry index of a primitive operation in T's
 560    --  TSD table indexed by Position.
 561
 562    procedure Set_Prim_Op_Kind
 563      (T        : Tag;
 564       Position : Positive;
 565       Value    : Prim_Op_Kind);
 566    --  Ada 2005 (AI-251): Set the kind of a primitive operation in T's TSD
 567    --  table indexed by Position.
 568
 569    procedure Unregister_Tag (T : Tag);
 570    --  Remove a particular tag from the external tag hash table
 571
 572    Max_Predef_Prims : constant Positive := 15;
 573    --  Number of reserved slots for the following predefined ada primitives:
 574    --
 575    --    1. Size
 576    --    2. Read
 577    --    3. Write
 578    --    4. Input
 579    --    5. Output
 580    --    6. "="
 581    --    7. assignment
 582    --    8. deep adjust
 583    --    9. deep finalize
 584    --   10. async select
 585    --   11. conditional select
 586    --   12. prim_op kind
 587    --   13. task_id
 588    --   14. dispatching requeue
 589    --   15. timed select
 590    --
 591    --  The compiler checks that the value here is correct
 592
 593    subtype Predef_Prims_Table  is Address_Array (1 .. Max_Predef_Prims);
 594    type Predef_Prims_Table_Ptr is access Predef_Prims_Table;
 595    pragma No_Strict_Aliasing (Predef_Prims_Table_Ptr);
 596
 597    type Addr_Ptr is access System.Address;
 598    pragma No_Strict_Aliasing (Addr_Ptr);
 599    --  This type is used by the frontend to generate the code that handles
 600    --  dispatch table slots of types declared at the local level.
 601
 602 end Ada.Tags;