gcc/cp/sig.c

   1 /* Functions dealing with signatures and signature pointers/references.
   2    Copyright (C) 1992 Free Software Foundation, Inc.
   3    Contributed by Gerald Baumgartner (gb@cs.purdue.edu)
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21
  22 #include "config.h"
  23 #include <stdio.h>
  24 #include "obstack.h"
  25 #include "tree.h"
  26 #include "cp-tree.h"
  27 #include "flags.h"
  28 #include "assert.h"
  29
  30 extern struct obstack *current_obstack;
  31 extern struct obstack permanent_obstack;
  32 extern struct obstack *saveable_obstack;
  33
  34 extern void error ();
  35 extern void sorry ();
  36 extern void compiler_error ();
  37 extern void make_decl_rtl                       PROTO((tree, char *, int));
  38
  39 /* Used to help generate globally unique names for signature tables.  */
  40
  41 static int global_sigtable_name_counter;
  42
  43 /* Build an identifier for a signature pointer or reference, so we
  44    can use it's name in function name mangling.  */
  45
  46 static tree
  47 build_signature_pointer_or_reference_name (to_type, constp, volatilep, refp)
  48      tree to_type;
  49      int constp, volatilep, refp;
  50 {
  51   char * sig_name = TYPE_NAME_STRING (to_type);
  52   int name_len = TYPE_NAME_LENGTH (to_type) + constp + volatilep;
  53   char * name;
  54
  55   if (refp)
  56     {
  57       name = (char *) alloca (name_len + sizeof (SIGNATURE_REFERENCE_NAME) +2);
  58       sprintf (name, SIGNATURE_REFERENCE_NAME_FORMAT,
  59                constp ? "C" : "", volatilep ? "V": "", sig_name);
  60     }
  61   else
  62     {
  63       name = (char *) alloca (name_len + sizeof (SIGNATURE_POINTER_NAME) + 2);
  64       sprintf (name, SIGNATURE_POINTER_NAME_FORMAT,
  65                constp ? "C" : "", volatilep ? "V": "", sig_name);
  66     }
  67   return get_identifier (name);
  68 }
  69
  70 /* Build a DECL node for a signature pointer or reference, so we can
  71    tell the debugger the structure of signature pointers/references.
  72    This function is called at most eight times for a given signature,
  73    once for each [const] [volatile] signature pointer/reference.  */
  74
  75 static void
  76 build_signature_pointer_or_reference_decl (type, name)
  77      tree type, name;
  78 {
  79   tree decl;
  80
  81   /* We don't enter this declaration in any sort of symbol table.  */
  82   decl = build_decl (TYPE_DECL, name, type);
  83   TYPE_NAME (type) = decl;
  84   TREE_CHAIN (type) = decl;
  85 }
  86
  87 /* Construct, lay out and return the type of pointers or references
  88    to signature TO_TYPE.  If such a type has already been constructed,
  89    reuse it. If CONSTP or VOLATILEP is specified, make the `optr' const
  90    or volatile, respectively.   If we are constructing a const/volatile
  91    type variant and the main type variant doesn't exist yet, it is built
  92    as well.  If REFP is 1, we construct a signature reference, otherwise
  93    a signature pointer is constructed.
  94
  95    This function is a subroutine of `build_signature_pointer_type' and
  96    `build_signature_reference_type'.  */
  97
  98 static tree
  99 build_signature_pointer_or_reference_type (to_type, constp, volatilep, refp)
 100      tree to_type;
 101      int constp, volatilep, refp;
 102 {
 103   register tree t, m;
 104   register struct obstack *ambient_obstack = current_obstack;
 105   register struct obstack *ambient_saveable_obstack = saveable_obstack;
 106
 107   m = refp ? SIGNATURE_REFERENCE_TO (to_type) : SIGNATURE_POINTER_TO (to_type);
 108
 109   /* If we don't have the main variant yet, construct it.  */
 110   if (m == NULL_TREE
 111       && (constp || volatilep))
 112     m = build_signature_pointer_or_reference_type (to_type, 0, 0, refp);
 113
 114   /* Treat any nonzero argument as 1.  */
 115   constp = !!constp;
 116   volatilep = !!volatilep;
 117   refp = !!refp;
 118
 119   /* If not generating auxiliary info, search the chain of variants to see
 120      if there is already one there just like the one we need to have.  If so,
 121      use that existing one.
 122
 123      We don't do this in the case where we are generating aux info because
 124      in that case we want each typedef names to get it's own distinct type
 125      node, even if the type of this new typedef is the same as some other
 126      (existing) type.  */
 127
 128   if (m && !flag_gen_aux_info)
 129     for (t = m; t; t = TYPE_NEXT_VARIANT (t))
 130       if (constp == TYPE_READONLY (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (t))))
 131           && volatilep == TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (t)))))
 132         return t;
 133
 134   /* We need a new one.  If TO_TYPE is permanent, make this permanent too.  */
 135   if (TREE_PERMANENT (to_type))
 136     {
 137       current_obstack = &permanent_obstack;
 138       saveable_obstack = &permanent_obstack;
 139     }
 140
 141   /* A signature pointer or reference to a signature `s' looks like this:
 142
 143        struct {
 144          void * optr;
 145          const s * sptr;
 146          vtbl_type_node * vptr;
 147        };
 148
 149      A `const' signature pointer/reference is a
 150
 151        struct {
 152          const void * optr;
 153          const s * sptr;
 154          vtbl_type_node * vptr;
 155        };
 156
 157      Similarly, for `volatile' and `const volatile'.
 158    */
 159
 160   t = make_lang_type (RECORD_TYPE);
 161   {
 162     tree obj_type = build_type_variant (void_type_node, constp, volatilep);
 163     tree optr_type = build_pointer_type (obj_type);
 164     tree optr, sptr, vptr;
 165
 166     optr = build_lang_field_decl (FIELD_DECL,
 167                                   get_identifier (SIGNATURE_OPTR_NAME),
 168                                   optr_type);
 169     DECL_FIELD_CONTEXT (optr) = t;
 170     DECL_CLASS_CONTEXT (optr) = t;
 171
 172     if (m)
 173       {
 174         /* We can share `sptr' and `vptr' among type variants.  */
 175         sptr = TREE_CHAIN (TYPE_FIELDS (m));
 176         vptr = TREE_CHAIN (sptr);
 177       }
 178     else
 179       {
 180         tree sig_tbl_type = c_build_type_variant (to_type, 1, 0);
 181
 182         sptr = build_lang_field_decl (FIELD_DECL,
 183                                       get_identifier (SIGNATURE_SPTR_NAME),
 184                                       build_pointer_type (sig_tbl_type));
 185         vptr = build_lang_field_decl (FIELD_DECL,
 186                                       get_identifier (SIGNATURE_VPTR_NAME),
 187                                       build_pointer_type (vtbl_type_node));
 188         DECL_FIELD_CONTEXT (sptr) = t;
 189         DECL_CLASS_CONTEXT (sptr) = t;
 190         DECL_FIELD_CONTEXT (vptr) = t;
 191         DECL_CLASS_CONTEXT (vptr) = t;
 192         TREE_CHAIN (sptr) = vptr;
 193         TREE_CHAIN (vptr) = NULL_TREE;
 194       }
 195
 196     TREE_CHAIN (optr) = sptr;
 197     TYPE_FIELDS (t) = optr;
 198     /* To make `build_vfn_ref' work when building a signature method call.  */
 199     CLASSTYPE_VFIELD (t) = vptr;
 200     DECL_FCONTEXT (CLASSTYPE_VFIELD (t)) = t;
 201     TYPE_ALIGN (t) = TYPE_ALIGN (optr_type);
 202   }
 203
 204   {
 205     tree name = build_signature_pointer_or_reference_name (to_type, constp,
 206                                                            volatilep, refp);
 207
 208     /* Build a DECL node for this type, so the debugger has access to it.  */
 209     build_signature_pointer_or_reference_decl (t, name);
 210   }
 211
 212   CLASSTYPE_GOT_SEMICOLON (t) = 1;
 213   IS_SIGNATURE_POINTER (t) = ! refp;
 214   IS_SIGNATURE_REFERENCE (t) = refp;
 215   SIGNATURE_TYPE (t) = to_type;
 216
 217   if (m)
 218     {
 219       /* Add this type to the chain of variants of TYPE.
 220          Every type has to be its own TYPE_MAIN_VARIANT.  */
 221       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
 222       TYPE_NEXT_VARIANT (m) = t;
 223     }
 224   else if (refp)
 225     /* Record this type as the reference to TO_TYPE.  */
 226     SIGNATURE_REFERENCE_TO (to_type) = t;
 227   else
 228     /* Record this type as the pointer to TO_TYPE.  */
 229     SIGNATURE_POINTER_TO (to_type) = t;
 230
 231   /* Lay out the type.  This function has many callers that are concerned
 232      with expression-construction, and this simplifies them all.
 233      Also, it guarantees the TYPE_SIZE is permanent if the type is.  */
 234   layout_type (t);
 235
 236   current_obstack = ambient_obstack;
 237   saveable_obstack = ambient_saveable_obstack;
 238
 239   /* Ouput debug information for this type.  */
 240   rest_of_type_compilation (t, 1);
 241
 242   return t;
 243 }
 244
 245 /* Construct, lay out and return the type of pointers to signature TO_TYPE.  */
 246
 247 tree
 248 build_signature_pointer_type (to_type, constp, volatilep)
 249      tree to_type;
 250      int constp, volatilep;
 251 {
 252   return
 253     build_signature_pointer_or_reference_type (to_type, constp, volatilep, 0);
 254 }
 255
 256 /* Construct, lay out and return the type of pointers to signature TO_TYPE.  */
 257
 258 tree
 259 build_signature_reference_type (to_type, constp, volatilep)
 260      tree to_type;
 261      int constp, volatilep;
 262 {
 263   return
 264     build_signature_pointer_or_reference_type (to_type, constp, volatilep, 1);
 265 }
 266
 267 /* Return the name of the signature table (as an IDENTIFIER_NODE)
 268    for the given signature type SIG_TYPE and rhs type RHS_TYPE.  */
 269
 270 static tree
 271 get_sigtable_name (sig_type, rhs_type)
 272      tree sig_type, rhs_type;
 273 {
 274   tree sig_type_id = build_typename_overload (sig_type);
 275   tree rhs_type_id = build_typename_overload (rhs_type);
 276   char *buf = (char *) alloca (sizeof (SIGTABLE_NAME_FORMAT_LONG)
 277                                + IDENTIFIER_LENGTH (sig_type_id)
 278                                + IDENTIFIER_LENGTH (rhs_type_id) + 20);
 279   char *sig_ptr = IDENTIFIER_POINTER (sig_type_id);
 280   char *rhs_ptr = IDENTIFIER_POINTER (rhs_type_id);
 281   int i, j;
 282
 283   for (i = 0; sig_ptr[i] == OPERATOR_TYPENAME_FORMAT[i]; i++)
 284     /* do nothing */;
 285   while (sig_ptr[i] >= '0' && sig_ptr[i] <= '9')
 286     i += 1;
 287
 288   for (j = 0; rhs_ptr[j] == OPERATOR_TYPENAME_FORMAT[j]; j++)
 289     /* do nothing */;
 290   while (rhs_ptr[j] >= '0' && rhs_ptr[j] <= '9')
 291     j += 1;
 292
 293   if (IS_SIGNATURE (rhs_type))
 294     sprintf (buf, SIGTABLE_NAME_FORMAT_LONG, sig_ptr+i, rhs_ptr+j,
 295              global_sigtable_name_counter++);
 296   else
 297     sprintf (buf, SIGTABLE_NAME_FORMAT, sig_ptr+i, rhs_ptr+j);
 298   return get_identifier (buf);
 299 }
 300
 301 /* Build a field decl that points to a signature member function.  */
 302
 303 static tree
 304 build_member_function_pointer (member)
 305      tree member;
 306 {
 307   char *namstr = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (member));
 308   int namlen = IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (member));
 309   char *name;
 310   tree entry;
 311
 312   name = (char *) alloca (namlen + sizeof (SIGNATURE_FIELD_NAME) + 2);
 313   sprintf (name, SIGNATURE_FIELD_NAME_FORMAT, namstr);
 314
 315   /* @@ Do we really want to xref signature table fields?  */
 316   GNU_xref_ref (current_function_decl, name);
 317
 318   entry = build_lang_field_decl (FIELD_DECL, get_identifier (name),
 319                                  TYPE_MAIN_VARIANT (sigtable_entry_type));
 320   TREE_CONSTANT (entry) = 1;
 321   TREE_READONLY (entry) = 1;
 322
 323   /* @@ Do we really want to xref signature table fields?  */
 324   GNU_xref_decl (current_function_decl, entry);
 325
 326   return entry;
 327 }
 328
 329 /* For each FUNCTION_DECL in a signature we construct a member function
 330    pointer of the appropriate type.  We also need two flags to test
 331    whether the member function pointer points to a virtual function or
 332    to a default implementation.  Those flags will be the two lower order
 333    bits of the member function pointer (or the two higher order bits,
 334    based on the configuration).
 335
 336    The new FIELD_DECLs are appended at the end of the last (and only)
 337    sublist of `list_of_fieldlists.'
 338
 339    As a side effect, each member function in the signature gets the
 340    `decl.ignored' bit turned on, so we don't output debug info for it.  */
 341
 342 void
 343 append_signature_fields (list_of_fieldlists)
 344      tree list_of_fieldlists;
 345 {
 346   tree l, x;
 347   tree last_x = NULL_TREE;
 348   tree mfptr;
 349   tree last_mfptr;
 350   tree mfptr_list = NULL_TREE;
 351
 352   /* For signatures it should actually be only a list with one element.  */
 353   for (l = list_of_fieldlists; l; l = TREE_CHAIN (l))
 354     {
 355       for (x = TREE_VALUE (l); x; x = TREE_CHAIN (x))
 356         {
 357           if (TREE_CODE (x) == FUNCTION_DECL)
 358             {
 359               mfptr = build_member_function_pointer (x);
 360               DECL_MEMFUNC_POINTER_TO (x) = mfptr;
 361               DECL_MEMFUNC_POINTING_TO (mfptr) = x;
 362               DECL_IGNORED_P (x) = 1;
 363               DECL_IN_AGGR_P (mfptr) = 1;
 364               if (! mfptr_list)
 365                 mfptr_list = last_mfptr = mfptr;
 366               else
 367                 {
 368                   TREE_CHAIN (last_mfptr) = mfptr;
 369                   last_mfptr = mfptr;
 370                 }
 371             }
 372           last_x = x;
 373         }
 374     }
 375
 376   /* Append the lists.  */
 377   if (last_x && mfptr_list)
 378     {
 379       TREE_CHAIN (last_x) = mfptr_list;
 380       TREE_CHAIN (last_mfptr) = NULL_TREE;
 381     }
 382 }
 383
 384 /* Compare the types of a signature member function and a class member
 385    function.  Returns 1 if the types are in the C++ `<=' relationship.
 386
 387    If we have a signature pointer/reference as argument or return type
 388    we don't want to do a recursive conformance check.  The conformance
 389    check only succeeds if both LHS and RHS refer to the same signature
 390    pointer.  Otherwise we need to keep information about parameter types
 391    around at run time to initialize the signature table correctly.  */
 392
 393 static int
 394 match_method_types (sig_mtype, class_mtype)
 395      tree sig_mtype, class_mtype;
 396 {
 397   tree sig_return_type = TREE_TYPE (sig_mtype);
 398   tree sig_arg_types = TYPE_ARG_TYPES (sig_mtype);
 399   tree class_return_type = TREE_TYPE (class_mtype);
 400   tree class_arg_types = TYPE_ARG_TYPES (class_mtype);
 401
 402   /* The return types have to be the same.  */
 403   if (! comptypes (sig_return_type, class_return_type, 1))
 404     return 0;
 405
 406   /* Compare the first argument `this.'  */
 407   {
 408     /* Get the type of what the `optr' is pointing to.  */
 409     tree sig_this =
 410       TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_VALUE (sig_arg_types))));
 411     tree class_this = TREE_VALUE (class_arg_types);
 412
 413     if (TREE_CODE (class_this) == RECORD_TYPE)  /* Is `this' a sig ptr?  */
 414       class_this = TREE_TYPE (TREE_TYPE (TYPE_FIELDS (class_this)));
 415     else
 416       class_this = TREE_TYPE (class_this);
 417
 418     /* If a signature method's `this' is const or volatile, so has to be
 419        the corresponding class method's `this.'  */
 420     if ((TYPE_READONLY (sig_this) && ! TYPE_READONLY (class_this))
 421         || (TYPE_VOLATILE (sig_this) && ! TYPE_VOLATILE (class_this)))
 422       return 0;
 423   }
 424
 425   sig_arg_types = TREE_CHAIN (sig_arg_types);
 426   class_arg_types = TREE_CHAIN (class_arg_types);
 427
 428   /* The number of arguments and the argument types have to be the same.  */
 429   return compparms (sig_arg_types, class_arg_types, 3);
 430 }
 431
 432 /* Undo casts of opaque type variables to the RHS types.  */
 433 static void
 434 undo_casts (sig_ty)
 435      tree sig_ty;
 436 {
 437   tree field = TYPE_FIELDS (sig_ty);
 438
 439   /* Since all the FIELD_DECLs for the signature table entries are at the end
 440      of the chain (see `append_signature_fields'), we can do it this way.  */
 441   for (; field && TREE_CODE (field) != FIELD_DECL; field = TREE_CHAIN (field))
 442     if (TYPE_MAIN_VARIANT (TREE_TYPE (field)) == opaque_type_node)
 443       TREE_TYPE (TREE_TYPE (field)) = TREE_TYPE (ptr_type_node);
 444 }
 445
 446 /* Do the type checking necessary to see whether the `rhs' conforms to
 447    the lhs's `sig_ty'.  Depending on the type of `rhs' return a NULL_TREE,
 448    an integer_zero_node, a constructor, or an expression offsetting the
 449    `rhs' signature table.  */
 450
 451 static tree
 452 build_signature_table_constructor (sig_ty, rhs)
 453      tree sig_ty, rhs;
 454 {
 455   tree rhstype = TREE_TYPE (rhs);
 456   tree sig_field = TYPE_FIELDS (sig_ty);
 457   tree result = NULL_TREE;
 458   tree first_rhs_field = NULL_TREE;
 459   tree last_rhs_field;
 460   int sig_ptr_p = IS_SIGNATURE (rhstype);
 461   int offset_p = sig_ptr_p;
 462
 463   rhstype = sig_ptr_p ? rhstype : TREE_TYPE (rhstype);
 464
 465   if (CLASSTYPE_TAGS (sig_ty))
 466     {
 467       sorry ("conformance check with signature containing class declarations");
 468       return error_mark_node;
 469     }
 470
 471   for (; sig_field; sig_field = TREE_CHAIN (sig_field))
 472     {
 473       tree basetype_path, baselink, basetypes;
 474       tree sig_method, sig_mname, sig_mtype;
 475       tree rhs_method, tbl_entry;
 476
 477       if (TREE_CODE (sig_field) == TYPE_DECL)
 478         {
 479           tree sig_field_type = TREE_TYPE (sig_field);
 480
 481           if (TYPE_MAIN_VARIANT (sig_field_type) == opaque_type_node)
 482             {
 483               /* We've got an opaque type here.  */
 484               tree oty_name = DECL_NAME (sig_field);
 485               tree oty_type = lookup_field (rhstype, oty_name, 1, 1);
 486
 487               if (oty_type == NULL_TREE || oty_type == error_mark_node)
 488                 {
 489                   cp_error ("class `%T' does not contain type `%T'",
 490                             rhstype, oty_type);
 491                   undo_casts (sig_ty);
 492                   return error_mark_node;
 493                 }
 494               oty_type = TREE_TYPE (oty_type);
 495
 496               /* Cast `sig_field' to be of type `oty_type'.  This will be
 497                  undone in `undo_casts' by walking over all the TYPE_DECLs.  */
 498               TREE_TYPE (sig_field_type) = TREE_TYPE (oty_type);
 499             }
 500           /* If we don't have an opaque type, we can ignore the `typedef'.  */
 501           continue;
 502         }
 503
 504       /* Find the signature method corresponding to `sig_field'.  */
 505       sig_method = DECL_MEMFUNC_POINTING_TO (sig_field);
 506       sig_mname = DECL_NAME (sig_method);
 507       sig_mtype = TREE_TYPE (sig_method);
 508
 509       basetype_path = TYPE_BINFO (rhstype);
 510       baselink = lookup_fnfields (basetype_path, sig_mname, 0);
 511       if (baselink == NULL_TREE || baselink == error_mark_node)
 512         {
 513           if (! IS_DEFAULT_IMPLEMENTATION (sig_method))
 514             {
 515               cp_error ("class `%T' does not contain method `%D'",
 516                         rhstype, sig_mname);
 517               undo_casts (sig_ty);
 518               return error_mark_node;
 519             }
 520           else
 521             {
 522               /* We use the signature's default implementation.  */
 523               rhs_method = sig_method;
 524             }
 525         }
 526       else
 527         {
 528           /* Find the class method of the correct type.  */
 529
 530           basetypes = TREE_PURPOSE (baselink);
 531           if (TREE_CODE (basetypes) == TREE_LIST)
 532             basetypes = TREE_VALUE (basetypes);
 533
 534           rhs_method = TREE_VALUE (baselink);
 535           for (; rhs_method; rhs_method = TREE_CHAIN (rhs_method))
 536             if (sig_mname == DECL_NAME (rhs_method)
 537                 && ! DECL_STATIC_FUNCTION_P (rhs_method)
 538                 && match_method_types (sig_mtype, TREE_TYPE (rhs_method)))
 539               break;
 540
 541           if (rhs_method == NULL_TREE
 542               || (compute_access (basetypes, rhs_method)
 543                   != access_public))
 544             {
 545               error ("class `%s' does not contain a method conforming to `%s'",
 546                      TYPE_NAME_STRING (rhstype),
 547                      fndecl_as_string (NULL, sig_method, 1));
 548               undo_casts (sig_ty);
 549               return error_mark_node;
 550             }
 551         }
 552
 553       if (sig_ptr_p && rhs_method != sig_method)
 554         {
 555           tree rhs_field = DECL_MEMFUNC_POINTER_TO (rhs_method);
 556
 557           if (first_rhs_field == NULL_TREE)
 558             {
 559               first_rhs_field = rhs_field;
 560               last_rhs_field = rhs_field;
 561             }
 562           else if (TREE_CHAIN (last_rhs_field) == rhs_field)
 563             last_rhs_field = rhs_field;
 564           else
 565             offset_p = 0;
 566
 567           tbl_entry = build_component_ref (rhs, DECL_NAME (rhs_field),
 568                                            NULL_TREE, 1);
 569         }
 570       else
 571         {
 572           tree code, offset, pfn;
 573
 574           if (rhs_method == sig_method)
 575             {
 576               code = integer_two_node;
 577               offset = integer_zero_node;
 578               pfn = build_unary_op (ADDR_EXPR, rhs_method, 0);
 579               TREE_TYPE (pfn) = ptr_type_node;
 580               offset_p = 0;     /* we can't offset the rhs sig table */
 581             }
 582           else if (DECL_VINDEX (rhs_method))
 583             {
 584               code = integer_one_node;
 585               offset = DECL_VINDEX (rhs_method);
 586               pfn = null_pointer_node;
 587             }
 588           else
 589             {
 590               code = integer_zero_node;
 591               offset = integer_zero_node;
 592               pfn = build_unary_op (ADDR_EXPR, rhs_method, 0);
 593               TREE_TYPE (pfn) = ptr_type_node;
 594             }
 595
 596           tbl_entry = tree_cons (NULL_TREE, code,
 597                                  tree_cons (NULL_TREE, offset,
 598                                             build_tree_list (NULL_TREE, pfn)));
 599           tbl_entry = build_nt (CONSTRUCTOR, NULL_TREE, tbl_entry);
 600           TREE_HAS_CONSTRUCTOR (tbl_entry) = 1;
 601           TREE_CONSTANT (tbl_entry) = 1;
 602         }
 603
 604       /* Chain those function address expressions together.  */
 605       if (result)
 606         result = tree_cons (NULL_TREE, tbl_entry, result);
 607       else
 608         result = build_tree_list (NULL_TREE, tbl_entry);
 609     }
 610
 611   if (result == NULL_TREE)
 612     {
 613       /* The signature was empty, we don't need a signature table.  */
 614       undo_casts (sig_ty);
 615       return NULL_TREE;
 616     }
 617
 618   if (offset_p)
 619     {
 620       if (first_rhs_field == TYPE_FIELDS (rhstype))
 621         {
 622           /* The sptr field on the lhs can be copied from the rhs.  */
 623           undo_casts (sig_ty);
 624           return integer_zero_node;
 625         }
 626       else
 627         {
 628           /* The sptr field on the lhs will point into the rhs sigtable.  */
 629           undo_casts (sig_ty);
 630           return build_component_ref (rhs, DECL_NAME (first_rhs_field),
 631                                       NULL_TREE, 0);
 632         }
 633     }
 634
 635   /* We need to construct a new signature table.  */
 636   result = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (result));
 637   TREE_HAS_CONSTRUCTOR (result) = 1;
 638   TREE_CONSTANT (result) = !sig_ptr_p;
 639
 640   undo_casts (sig_ty);
 641   return result;
 642 }
 643
 644 /* Build a signature table declaration and initialize it or return an
 645    existing one if we built one already.  If we don't get a constructor
 646    as initialization expression, we don't need a new signature table
 647    variable and just hand back the init expression.
 648
 649    The declaration processing is done by hand instead of using `finish_decl'
 650    so that we can make signature pointers global variables instead of
 651    static ones.  */
 652
 653 static tree
 654 build_sigtable (sig_type, rhs_type, init_from)
 655      tree sig_type, rhs_type, init_from;
 656 {
 657   tree name = NULL_TREE;
 658   tree decl = NULL_TREE;
 659   tree init_expr;
 660
 661   push_obstacks_nochange ();
 662   end_temporary_allocation ();
 663
 664   if (! IS_SIGNATURE (rhs_type))
 665     {
 666       name = get_sigtable_name (sig_type, rhs_type);
 667       decl = IDENTIFIER_GLOBAL_VALUE (name);
 668     }
 669   if (decl == NULL_TREE)
 670     {
 671       tree init;
 672
 673       /* We allow only one signature table to be generated for signatures
 674          with opaque types.  Otherwise we create a loophole in the type
 675          system since we could cast data from one classes implementation
 676          of the opaque type to that of another class.  */
 677       if (SIGNATURE_HAS_OPAQUE_TYPEDECLS (sig_type)
 678           && SIGTABLE_HAS_BEEN_GENERATED (sig_type))
 679         {
 680           error ("signature with opaque type implemented by multiple classes");
 681           return error_mark_node;
 682         }
 683       SIGTABLE_HAS_BEEN_GENERATED (sig_type) = 1;
 684
 685       init_expr = build_signature_table_constructor (sig_type, init_from);
 686       if (init_expr == NULL_TREE || TREE_CODE (init_expr) != CONSTRUCTOR)
 687         return init_expr;
 688
 689       if (name == NULL_TREE)
 690         name = get_sigtable_name (sig_type, rhs_type);
 691       {
 692         tree context = current_function_decl;
 693
 694         /* Make the signature table global, not just static in whichever
 695            function a signature pointer/ref is used for the first time.  */
 696         current_function_decl = NULL_TREE;
 697         decl = pushdecl_top_level (build_decl (VAR_DECL, name, sig_type));
 698         current_function_decl = context;
 699       }
 700       IDENTIFIER_GLOBAL_VALUE (name) = decl;
 701       store_init_value (decl, init_expr);
 702       if (IS_SIGNATURE (rhs_type))
 703         {
 704           init = DECL_INITIAL (decl);
 705           DECL_INITIAL (decl) = error_mark_node;
 706         }
 707
 708       DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
 709                                DECL_ALIGN (decl));
 710 #if 0
 711       /* GDB-4.7 doesn't find the initialization value of a signature table
 712          when it is constant.  */
 713       TREE_READONLY (decl) = 1;
 714 #endif
 715       TREE_STATIC (decl) = 1;
 716       TREE_USED (decl) = 1;
 717
 718       make_decl_rtl (decl, NULL, 1);
 719       if (IS_SIGNATURE (rhs_type))
 720         expand_static_init (decl, init);
 721     }
 722
 723   pop_obstacks ();
 724
 725   return decl;
 726 }
 727
 728 /* Create a constructor or modify expression if the LHS of an assignment
 729    is a signature pointer or a signature reference.  If LHS is a record
 730    type node, we build a constructor, otherwise a compound expression.  */
 731
 732 tree
 733 build_signature_pointer_constructor (lhs, rhs)
 734      tree lhs, rhs;
 735 {
 736   register struct obstack *ambient_obstack = current_obstack;
 737   register struct obstack *ambient_saveable_obstack = saveable_obstack;
 738   int initp = (TREE_CODE (lhs) == RECORD_TYPE);
 739   tree lhstype = initp ? lhs : TREE_TYPE (lhs);
 740   tree rhstype = TREE_TYPE (rhs);
 741   tree sig_ty  = SIGNATURE_TYPE (lhstype);
 742   tree sig_tbl, sptr_expr, optr_expr, vptr_expr;
 743   tree result;
 744
 745   if (! ((TREE_CODE (rhstype) == POINTER_TYPE
 746           && TREE_CODE (TREE_TYPE (rhstype)) == RECORD_TYPE)
 747          || (TYPE_LANG_SPECIFIC (rhstype) &&
 748              (IS_SIGNATURE_POINTER (rhstype)
 749               || IS_SIGNATURE_REFERENCE (rhstype)))))
 750     {
 751       error ("invalid assignment to signature pointer or reference");
 752       return error_mark_node;
 753     }
 754
 755   if (TYPE_SIZE (sig_ty) == NULL_TREE)
 756     {
 757       cp_error ("undefined signature `%T' used in signature %s declaration",
 758                 sig_ty,
 759                 IS_SIGNATURE_POINTER (lhstype) ? "pointer" : "reference");
 760       return error_mark_node;
 761     }
 762
 763   /* If SIG_TY is permanent, make the signature table constructor and
 764      the signature pointer/reference constructor permanent too.  */
 765   if (TREE_PERMANENT (sig_ty))
 766     {
 767       current_obstack = &permanent_obstack;
 768       saveable_obstack = &permanent_obstack;
 769     }
 770
 771   if (TYPE_LANG_SPECIFIC (rhstype) &&
 772       (IS_SIGNATURE_POINTER (rhstype) || IS_SIGNATURE_REFERENCE (rhstype)))
 773     {
 774       if (SIGNATURE_TYPE (rhstype) == sig_ty)
 775         {
 776           /* LHS and RHS are signature pointers/refs of the same signature.  */
 777           optr_expr = build_optr_ref (rhs);
 778           sptr_expr = build_sptr_ref (rhs);
 779           vptr_expr = build_vptr_ref (rhs);
 780         }
 781       else
 782         {
 783           /* We need to create a new signature table and copy
 784              elements from the rhs signature table.  */
 785           tree rhs_sptr_ref = build_sptr_ref (rhs);
 786           tree rhs_tbl = build1 (INDIRECT_REF, SIGNATURE_TYPE (rhstype),
 787                                  rhs_sptr_ref);
 788
 789           sig_tbl = build_sigtable (sig_ty, SIGNATURE_TYPE (rhstype), rhs_tbl);
 790           if (sig_tbl == error_mark_node)
 791             return error_mark_node;
 792
 793           optr_expr = build_optr_ref (rhs);
 794           if (sig_tbl == NULL_TREE)
 795             /* The signature was empty.  The signature pointer is
 796                pretty useless, but the user has been warned.  */
 797             sptr_expr = copy_node (null_pointer_node);
 798           else if (sig_tbl == integer_zero_node)
 799             sptr_expr = rhs_sptr_ref;
 800           else
 801             sptr_expr = build_unary_op (ADDR_EXPR, sig_tbl, 0);
 802           TREE_TYPE (sptr_expr) = build_pointer_type (sig_ty);
 803           vptr_expr = build_vptr_ref (rhs);
 804         }
 805     }
 806   else
 807     {
 808       tree rhs_vptr;
 809
 810       if (TYPE_USES_COMPLEX_INHERITANCE (TREE_TYPE (rhstype)))
 811         {
 812           sorry ("class with multiple inheritance as implementation of signature");
 813           return error_mark_node;
 814         }
 815
 816       sig_tbl = build_sigtable (sig_ty, TREE_TYPE (rhstype), rhs);
 817       if (sig_tbl == error_mark_node)
 818         return error_mark_node;
 819
 820       optr_expr = rhs;
 821       if (sig_tbl == NULL_TREE)
 822         /* The signature was empty.  The signature pointer is
 823            pretty useless, but the user has been warned.  */
 824         {
 825           sptr_expr = copy_node (null_pointer_node);
 826           TREE_TYPE (sptr_expr) = build_pointer_type (sig_ty);
 827         }
 828       else
 829         sptr_expr = build_unary_op (ADDR_EXPR, sig_tbl, 0);
 830       if (CLASSTYPE_VFIELD (TREE_TYPE (rhstype)))
 831         {
 832           rhs_vptr = DECL_NAME (CLASSTYPE_VFIELD (TREE_TYPE (rhstype)));
 833           vptr_expr = build_component_ref (build_indirect_ref (rhs, 0),
 834                                            rhs_vptr, NULL_TREE, 0);
 835         }
 836       else
 837         vptr_expr = copy_node (null_pointer_node);
 838       TREE_TYPE (vptr_expr) = build_pointer_type (vtbl_type_node);
 839     }
 840
 841   if (initp)
 842     {
 843       result = tree_cons (NULL_TREE, optr_expr,
 844                           tree_cons (NULL_TREE, sptr_expr,
 845                                      build_tree_list (NULL_TREE, vptr_expr)));
 846       result = build_nt (CONSTRUCTOR, NULL_TREE, result);
 847       TREE_HAS_CONSTRUCTOR (result) = 1;
 848       result = digest_init (lhstype, result, 0);
 849     }
 850   else
 851     {
 852       if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype))
 853           readonly_error (lhs, "assignment", 0);
 854
 855       optr_expr = build_modify_expr (build_optr_ref (lhs), NOP_EXPR,
 856                                      optr_expr);
 857       sptr_expr = build_modify_expr (build_sptr_ref (lhs), NOP_EXPR,
 858                                      sptr_expr);
 859       vptr_expr = build_modify_expr (build_vptr_ref (lhs), NOP_EXPR,
 860                                      vptr_expr);
 861
 862       result = tree_cons (NULL_TREE, optr_expr,
 863                           tree_cons (NULL_TREE, sptr_expr,
 864                                      tree_cons (NULL_TREE, vptr_expr,
 865                                                 build_tree_list (NULL_TREE,
 866                                                                  lhs))));
 867       result = build_compound_expr (result);
 868     }
 869
 870   current_obstack = ambient_obstack;
 871   saveable_obstack = ambient_saveable_obstack;
 872   return result;
 873 }
 874
 875 /* Build a temporary variable declaration for the instance of a signature
 876    member function call if it isn't a declaration node already.  Simply
 877    using a SAVE_EXPR doesn't work since we need `this' in both branches
 878    of a conditional expression.  */
 879
 880 static tree
 881 save_this (instance)
 882      tree instance;
 883 {
 884   tree decl;
 885
 886   if (TREE_CODE_CLASS (TREE_CODE (instance)) == 'd')
 887     decl = instance;
 888   else
 889     {
 890       decl = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (instance));
 891       DECL_REGISTER (decl) = 1;
 892       layout_decl (decl, 0);
 893       expand_decl (decl);
 894     }
 895
 896   return decl;
 897 }
 898
 899 /* Build a signature member function call.  Looks up the signature table
 900    entry corresponding to FUNCTION.  Depending on the value of the CODE
 901    field, either call the function in PFN directly, or use OFFSET to
 902    index INSTANCE's virtual function table.  */
 903
 904 tree
 905 build_signature_method_call (basetype, instance, function, parms)
 906      tree basetype, instance, function, parms;
 907 {
 908   tree saved_instance = save_this (instance);   /* Create temp for `this'.  */
 909   tree signature_tbl_ptr = build_sptr_ref (saved_instance);
 910   tree sig_field_name = DECL_NAME (DECL_MEMFUNC_POINTER_TO (function));
 911   tree basetype_path = TYPE_BINFO (basetype);
 912   tree tbl_entry = build_component_ref (build1 (INDIRECT_REF, basetype,
 913                                                 signature_tbl_ptr),
 914                                         sig_field_name, basetype_path, 1);
 915   tree code, offset, pfn, vfn;
 916   tree deflt_call = NULL_TREE, direct_call, virtual_call, result;
 917
 918   code = build_component_ref (tbl_entry, get_identifier (SIGTABLE_CODE_NAME),
 919                              NULL_TREE, 1);
 920   offset = build_component_ref (tbl_entry,
 921                                 get_identifier (SIGTABLE_OFFSET_NAME),
 922                              NULL_TREE, 1);
 923   pfn = build_component_ref (tbl_entry, get_identifier (SIGTABLE_PFN_NAME),
 924                              NULL_TREE, 1);
 925   TREE_TYPE (pfn) = build_pointer_type (TREE_TYPE (function));
 926
 927   if (IS_DEFAULT_IMPLEMENTATION (function))
 928     {
 929       pfn = save_expr (pfn);
 930       deflt_call = build_function_call (pfn,
 931                                         tree_cons (NULL_TREE, saved_instance,
 932                                                    TREE_CHAIN (parms)));
 933     }
 934
 935   {
 936     /* Cast the signature method to have `this' of a normal pointer type.  */
 937     tree old_this = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn))));
 938
 939     TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn)))) =
 940       build_type_variant (TYPE_POINTER_TO (basetype),
 941                           TYPE_READONLY (old_this),
 942                           TYPE_VOLATILE (old_this));
 943
 944     direct_call = build_function_call (pfn, parms);
 945
 946     vfn = build_vfn_ref (&TREE_VALUE (parms), saved_instance, offset);
 947     TREE_TYPE (vfn) = build_pointer_type (TREE_TYPE (function));
 948     virtual_call = build_function_call (vfn, parms);
 949
 950     /* Undo the cast, make `this' a signature pointer again.  */
 951     TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn)))) = old_this;
 952   }
 953
 954   /* Once the function was found, there should be no reason why we
 955      couldn't build the member function pointer call.  */
 956   if (!direct_call || direct_call == error_mark_node
 957       || !virtual_call || virtual_call == error_mark_node
 958       || (IS_DEFAULT_IMPLEMENTATION (function)
 959           && (!deflt_call || deflt_call == error_mark_node)))
 960     {
 961       compiler_error ("cannot build call of signature member function `%s'",
 962                       fndecl_as_string (NULL, function, 1));
 963       return error_mark_node;
 964     }
 965
 966   if (IS_DEFAULT_IMPLEMENTATION (function))
 967     {
 968       tree test = build_binary_op_nodefault (EQ_EXPR, code, integer_one_node,
 969                                              EQ_EXPR);
 970       result = build_conditional_expr (code,
 971                                        build_conditional_expr (test,
 972                                                                virtual_call,
 973                                                                deflt_call),
 974                                        direct_call);
 975     }
 976   else
 977     result = build_conditional_expr (code, virtual_call, direct_call);
 978
 979   /* If we created a temporary variable for `this', initialize it first.  */
 980   if (instance != saved_instance)
 981     result = build (COMPOUND_EXPR, TREE_TYPE (result),
 982                     build_modify_expr (saved_instance, NOP_EXPR, instance),
 983                     result);
 984
 985   return result;
 986 }
 987
 988 /* Create a COMPONENT_REF expression for referencing the OPTR field
 989    of a signature pointer or reference.  */
 990
 991 tree
 992 build_optr_ref (instance)
 993      tree instance;
 994 {
 995   tree field = get_identifier (SIGNATURE_OPTR_NAME);
 996
 997   return build_component_ref (instance, field, NULL_TREE, 1);
 998 }
 999
1000 /* Create a COMPONENT_REF expression for referencing the SPTR field
1001    of a signature pointer or reference.  */
1002
1003 tree
1004 build_sptr_ref (instance)
1005      tree instance;
1006 {
1007   tree field = get_identifier (SIGNATURE_SPTR_NAME);
1008
1009   return build_component_ref (instance, field, NULL_TREE, 1);
1010 }
1011
1012 /* Create a COMPONENT_REF expression for referencing the VPTR field
1013    of a signature pointer or reference.  */
1014
1015 tree
1016 build_vptr_ref (instance)
1017      tree instance;
1018 {
1019   tree field = get_identifier (SIGNATURE_VPTR_NAME);
1020
1021   return build_component_ref (instance, field, NULL_TREE, 1);
1022 }