home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / NeXT / GnuSource / cc-61.0.1 / cc / cplus-gc.c < prev    next >
C/C++ Source or Header  |  1991-06-03  |  23KB  |  741 lines
  1. /* Garbage collection primitives for GNU C++.
  2.    Copyright (C) 1990 Free Software Foundation, Inc.
  3.    Contributed by Michael Tiemann (tiemann@cygnus.com)
  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 "tree.h"
  24. #include "cplus-tree.h"
  25. #include "flags.h"
  26. #include "assert.h"
  27. #define NULL 0
  28.  
  29. extern tree build_t_desc_overload ();
  30. extern tree build_i_desc_overload ();
  31. extern tree build_m_desc_overload ();
  32.  
  33. /* This is the function decl for the (pseudo-builtin) __gc_protect
  34.    function.  Args are (class *value, int index); Returns value.  */
  35. tree gc_protect_fndecl;
  36.  
  37. /* This is the function decl for the (pseudo-builtin) __gc_unprotect
  38.    function.  Args are (int index); void return.  */
  39. tree gc_unprotect_fndecl;
  40.  
  41. /* This is the function decl for the (pseudo-builtin) __gc_push
  42.    function.  Args are (int length); void return.  */
  43. tree gc_push_fndecl;
  44.  
  45. /* This is the function decl for the (pseudo-builtin) __gc_pop
  46.    function.  Args are void; void return.  */
  47. tree gc_pop_fndecl;
  48.  
  49. /* Special integers that are used to represent bits in gc-safe objects.  */
  50. tree gc_nonobject;
  51. tree gc_visible;
  52. tree gc_white;
  53. tree gc_offwhite;
  54. tree gc_grey;
  55. tree gc_black;
  56.  
  57. /* Predicate that returns non-zero if TYPE needs some kind of
  58.    entry for the GC.  Returns zero otherwise.  */
  59. int
  60. type_needs_gc_entry (type)
  61.      tree type;
  62. {
  63.   tree ttype = type;
  64.  
  65.   if (! flag_gc || type == error_mark_node)
  66.     return 0;
  67.  
  68.   /* Aggregate types need gc entries if any of their members
  69.      need gc entries.  */
  70.   if (IS_AGGR_TYPE (type))
  71.     {
  72.       tree fields = TYPE_FIELDS (type);
  73.       int i;
  74.  
  75.       /* We don't care about certain pointers.  Pointers
  76.      to virtual baseclasses are always up front.  We also
  77.      cull out virtual function table pointers because it's
  78.      easy, and it simplifies the logic.*/
  79.       while (fields
  80.          && (DECL_NAME (fields) == NULL_TREE
  81.          || VFIELD_NAME_P (DECL_NAME (fields))
  82.          || VBASE_NAME_P (DECL_NAME (fields))
  83.          || !strcmp (IDENTIFIER_POINTER (DECL_NAME (fields)), "__bits")))
  84.     fields = TREE_CHAIN (fields);
  85.  
  86.       while (fields)
  87.     {
  88.       if (type_needs_gc_entry (TREE_TYPE (fields)))
  89.         return 1;
  90.       fields = TREE_CHAIN (fields);
  91.     }
  92.  
  93.       for (i = CLASSTYPE_N_BASECLASSES (type)-1; i >= 0; i--)
  94.     if (type_needs_gc_entry (CLASSTYPE_BASECLASS (type, i)))
  95.       return 1;
  96.  
  97.       return 0;
  98.     }
  99.  
  100.   while (TREE_CODE (ttype) == ARRAY_TYPE
  101.      && TREE_CODE (TREE_TYPE (ttype)) == ARRAY_TYPE)
  102.     ttype = TREE_TYPE (ttype);
  103.   if ((TREE_CODE (ttype) == POINTER_TYPE
  104.        || TREE_CODE (ttype) == ARRAY_TYPE
  105.        || TREE_CODE (ttype) == REFERENCE_TYPE)
  106.       && IS_AGGR_TYPE (TREE_TYPE (ttype))
  107.       && CLASSTYPE_DOSSIER (TREE_TYPE (ttype)))
  108.     return 1;
  109.  
  110.   return 0;
  111. }
  112.  
  113. /* Predicate that returns non-zero iff FROM is safe from the GC.
  114.    
  115.    If TO is nonzero, it means we know that FROM is being stored
  116.    in TO, which make make it safe.  */
  117. int
  118. value_safe_from_gc (to, from)
  119.      tree to, from;
  120. {
  121.   /* First, return non-zero for easy cases: parameters,
  122.      static variables.  */
  123.   if (TREE_CODE (from) == PARM_DECL
  124.       || (TREE_CODE (from) == VAR_DECL
  125.       && TREE_STATIC (from)))
  126.     return 1;
  127.  
  128.   /* If something has its address taken, it cannot be
  129.      in the heap, so it doesn't need to be protected.  */
  130.   if (TREE_CODE (from) == ADDR_EXPR || TREE_REFERENCE_EXPR (from))
  131.     return 1;
  132.  
  133.   /* If we are storing into a static variable, then what
  134.      we store will be safe from the gc.  */
  135.   if (to && TREE_CODE (to) == VAR_DECL
  136.       && TREE_STATIC (to))
  137.     return 1;
  138.  
  139.   /* Now recurse on structure of FROM.  */
  140.   switch (TREE_CODE (from))
  141.     {
  142.     case COMPONENT_REF:
  143.       /* These guys are special, and safe.  */
  144.       if (TREE_CODE (TREE_OPERAND (from, 1)) == FIELD_DECL
  145.       && (VFIELD_NAME_P (DECL_NAME (TREE_OPERAND (from, 1)))
  146.           || VBASE_NAME_P (DECL_NAME (TREE_OPERAND (from, 1)))))
  147.     return 1;
  148.       /* fall through...  */
  149.     case NOP_EXPR:
  150.     case CONVERT_EXPR:
  151.     case NON_LVALUE_EXPR:
  152.     case WITH_CLEANUP_EXPR:
  153.     case SAVE_EXPR:
  154.     case PREDECREMENT_EXPR:
  155.     case PREINCREMENT_EXPR:
  156.     case POSTDECREMENT_EXPR:
  157.     case POSTINCREMENT_EXPR:
  158.       if (value_safe_from_gc (to, TREE_OPERAND (from, 0)))
  159.     return 1;
  160.       break;
  161.  
  162.     case VAR_DECL:
  163.     case PARM_DECL:
  164.       /* We can safely pass these things as parameters to functions.  */
  165.       if (to == 0)
  166.     return 1;
  167.  
  168.     case ARRAY_REF:
  169.     case INDIRECT_REF:
  170.     case RESULT_DECL:
  171.     case OFFSET_REF:
  172.     case CALL_EXPR:
  173.     case METHOD_CALL_EXPR:
  174.       break;
  175.  
  176.     case COMPOUND_EXPR:
  177.     case TARGET_EXPR:
  178.       if (value_safe_from_gc (to, TREE_OPERAND (from, 1)))
  179.     return 1;
  180.       break;
  181.  
  182.     case COND_EXPR:
  183.       if (value_safe_from_gc (to, TREE_OPERAND (from, 1))
  184.       && value_safe_from_gc (to, TREE_OPERAND (from, 2)))
  185.     return 1;
  186.       break;
  187.  
  188.     case PLUS_EXPR:
  189.     case MINUS_EXPR:
  190.       if ((type_needs_gc_entry (TREE_TYPE (TREE_OPERAND (from, 0)))
  191.        || value_safe_from_gc (to, TREE_OPERAND (from, 0)))
  192.       && (type_needs_gc_entry (TREE_TYPE (TREE_OPERAND (from, 1))) == 0
  193.           || value_safe_from_gc (to, TREE_OPERAND (from, 1))))
  194.     return 1;
  195.       break;
  196.  
  197.     case RTL_EXPR:
  198.       /* Every time we build an RTL_EXPR in the front-end, we must
  199.      ensure that everything in it is safe from the garbage collector.
  200.      ??? This has only been done for `build_new'.  */
  201.       return 1;
  202.  
  203.     default:
  204.       abort ();
  205.     }
  206.  
  207.   if (to == 0)
  208.     return 0;
  209.  
  210.   /* FROM wasn't safe.  But other properties of TO might make it safe.  */
  211.   switch (TREE_CODE (to))
  212.     {
  213.     case VAR_DECL:
  214.     case PARM_DECL:
  215.       /* We already culled out static VAR_DECLs above.  */
  216.       return 0;
  217.  
  218.     case COMPONENT_REF:
  219.       /* These guys are special, and safe.  */
  220.       if (TREE_CODE (TREE_OPERAND (to, 1)) == FIELD_DECL
  221.       && (VFIELD_NAME_P (DECL_NAME (TREE_OPERAND (to, 1)))
  222.           || VBASE_NAME_P (DECL_NAME (TREE_OPERAND (to, 1)))))
  223.     return 1;
  224.       /* fall through...  */
  225.  
  226.     case NOP_EXPR:
  227.     case NON_LVALUE_EXPR:
  228.     case WITH_CLEANUP_EXPR:
  229.     case SAVE_EXPR:
  230.     case PREDECREMENT_EXPR:
  231.     case PREINCREMENT_EXPR:
  232.     case POSTDECREMENT_EXPR:
  233.     case POSTINCREMENT_EXPR:
  234.       return value_safe_from_gc (TREE_OPERAND (to, 0), from);
  235.  
  236.     case COMPOUND_EXPR:
  237.     case TARGET_EXPR:
  238.       return value_safe_from_gc (TREE_OPERAND (to, 1), from);
  239.  
  240.     case COND_EXPR:
  241.       return (value_safe_from_gc (TREE_OPERAND (to, 1), from)
  242.           && value_safe_from_gc (TREE_OPERAND (to, 2), from));
  243.  
  244.     case INDIRECT_REF:
  245.     case ARRAY_REF:
  246.       /* This used to be 0, but our current restricted model
  247.      allows this to be 1.  We'll never get arrays this way.  */
  248.       return 1;
  249.  
  250.     default:
  251.       abort ();
  252.     }
  253.  
  254.   /* Catch-all case is that TO/FROM is not safe.  */
  255.   return 0;
  256. }
  257.  
  258. /* Function to build a static GC entry for DECL.  TYPE is DECL's type.
  259.  
  260.    For objects of type `class *', this is just an entry in the
  261.    static vector __PTR_LIST__.
  262.  
  263.    For objects of type `class[]', this requires building an entry
  264.    in the static vector __ARR_LIST__.
  265.  
  266.    For aggregates, this records all fields of type `class *'
  267.    and `class[]' in the respective lists above.  */
  268. void
  269. build_static_gc_entry (decl, type)
  270.      tree decl;
  271.      tree type;
  272. {
  273.   extern struct _iob *asm_out_file;
  274.  
  275. #if defined(DBX_DEBUGGING_INFO) && !defined(FASCIST_ASSEMBLER) && !defined(SDB_DEBUGGING_INFO)
  276.   /* Now, figure out what sort of entry to build.  */
  277.   if (TREE_CODE (type) == POINTER_TYPE
  278.       || TREE_CODE (type) == REFERENCE_TYPE)
  279.     {
  280.       fprintf (asm_out_file, ".stabs \"___PTR_LIST__\",22,0,0,");
  281.       assemble_name (asm_out_file, IDENTIFIER_POINTER (DECL_NAME (decl)));
  282.       fputc ('\n', asm_out_file);
  283.     }
  284.   else if (TREE_CODE (type) == RECORD_TYPE)
  285.     {
  286.       tree ref = get_temp_name (build_reference_type (type), 1);
  287.       DECL_INITIAL (ref) = build1 (ADDR_EXPR, TREE_TYPE (ref), decl);
  288.       TREE_CONSTANT (DECL_INITIAL (ref)) = 1;
  289.       finish_decl (ref, DECL_INITIAL (ref), 0);
  290.     }
  291.   else
  292.     {
  293.       /* Not yet implemented.
  294.  
  295.      Cons up a static variable that holds address and length info
  296.      and add that to ___ARR_LIST__.  */
  297.       abort ();
  298.     }
  299. #else
  300.   fatal ("sorry, gc not supported without a.out format");
  301. #endif
  302. }
  303.  
  304. /* Protect FROM from the GC, assuming FROM is going to be
  305.    stored into TO.  We handle three cases for TO here:
  306.  
  307.    case 1: TO is a stack variable.
  308.    case 2: TO is zero (which means it is a parameter).
  309.    case 3: TO is a return value.  */
  310.  
  311. tree
  312. protect_value_from_gc (to, from)
  313.      tree to, from;
  314. {
  315.   if (to == 0)
  316.     {
  317.       tree cleanup;
  318.  
  319.       to = get_temp_regvar (TREE_TYPE (from), from);
  320.  
  321.       /* Convert from integer to list form since we'll use it twice.  */
  322.       DECL_GC_OFFSET (to) = build_tree_list (NULL_TREE, DECL_GC_OFFSET (to));
  323.       cleanup = build_function_call (gc_unprotect_fndecl,
  324.                      DECL_GC_OFFSET (to));
  325.  
  326.       if (! expand_decl_cleanup (to, cleanup))
  327.     {
  328.       compiler_error ("cannot unprotect parameter in this scope");
  329.       return error_mark_node;
  330.     }
  331.     }
  332.  
  333.   /* Should never need to protect a value that's headed for static storage.  */
  334.   if (TREE_STATIC (to))
  335.     abort ();
  336.  
  337.   switch (TREE_CODE (to))
  338.     {
  339.     case COMPONENT_REF:
  340.     case INDIRECT_REF:
  341.       return protect_value_from_gc (TREE_OPERAND (to, 0), from);
  342.  
  343.     case VAR_DECL:
  344.     case PARM_DECL:
  345.       {
  346.     tree rval;
  347.     if (DECL_GC_OFFSET (to) == NULL_TREE)
  348.       {
  349.         /* Because of a cast or a conversion, we might stick
  350.            a value into a variable that would not normally
  351.            have a GC entry.  */
  352.         DECL_GC_OFFSET (to) = size_int (++current_function_obstack_index);
  353.       }
  354.  
  355.     if (TREE_CODE (DECL_GC_OFFSET (to)) != TREE_LIST)
  356.       {
  357.         DECL_GC_OFFSET (to)
  358.           = build_tree_list (NULL_TREE, DECL_GC_OFFSET (to));
  359.       }
  360.  
  361.     current_function_obstack_usage = 1;
  362.     rval = build_function_call (gc_protect_fndecl,
  363.                     tree_cons (NULL_TREE, from,
  364.                            DECL_GC_OFFSET (to)));
  365.     TREE_TYPE (rval) = TREE_TYPE (from);
  366.     return rval;
  367.       }
  368.     }
  369.  
  370.   /* If we fall through the switch, assume we lost.  */
  371.   abort ();
  372. }
  373.  
  374. /* Given the expression EXP of type `class *', return the head
  375.    of the object pointed to by EXP.  */
  376. tree
  377. build_headof (exp)
  378.      tree exp;
  379. {
  380.   tree type = TREE_TYPE (exp);
  381.   tree vptr, offset;
  382.  
  383.   if (TREE_CODE (type) != POINTER_TYPE)
  384.     {
  385.       error ("`headof' applied to non-pointer type");
  386.       return error_mark_node;
  387.     }
  388.  
  389.   vptr = build1 (INDIRECT_REF, TYPE_POINTER_TO (vtable_entry_type), exp);
  390.   offset = build_component_ref (build_array_ref (vptr, integer_one_node),
  391.                 get_identifier (VTABLE_DELTA_NAME),
  392.                 NULL_TREE, 0);
  393.   return build (PLUS_EXPR, class_star_type_node, exp,
  394.         convert (integer_type_node, offset));
  395. }
  396.  
  397. /* Given the expression EXP of type `class *', return the
  398.    type descriptor for the object pointed to by EXP.  */
  399. tree
  400. build_classof (exp)
  401.      tree exp;
  402. {
  403.   tree type = TREE_TYPE (exp);
  404.   tree vptr;
  405.   tree t_desc_entry;
  406.  
  407.   if (TREE_CODE (type) != POINTER_TYPE)
  408.     {
  409.       error ("`classof' applied to non-pointer type");
  410.       return error_mark_node;
  411.     }
  412.  
  413.   vptr = build1 (INDIRECT_REF, TYPE_POINTER_TO (vtable_entry_type), exp);
  414.   t_desc_entry = build_component_ref (build_array_ref (vptr, integer_one_node),
  415.                       get_identifier (VTABLE_PFN_NAME),
  416.                       NULL_TREE, 0);
  417.   TREE_TYPE (t_desc_entry) = TYPE_POINTER_TO (__t_desc_type_node);
  418.   return t_desc_entry;
  419. }
  420.  
  421. /* Build and initialize various sorts of descriptors.  Every descriptor
  422.    node has a name associated with it (the name created by mangling).
  423.    For this reason, we use the identifier as our access to the __*_desc
  424.    nodes, instead of sticking them directly in the types.  Otherwise we
  425.    would burden all built-in types (and pointer types) with slots that
  426.    we don't necessarily want to use.
  427.  
  428.    For each descriptor we build, we build a variable that contains
  429.    the descriptor's information.  When we need this info at runtime,
  430.    all we need is access to these variables.
  431.  
  432.    Note: these constructors always return the address of the descriptor
  433.    info, since that is simplest for their mutual interaction.  */
  434.  
  435. static tree
  436. build_generic_desc (decl, elems)
  437.      tree decl;
  438.      tree elems;
  439. {
  440.   tree init = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE, elems);
  441.   TREE_CONSTANT (init) = 1;
  442.   TREE_STATIC (init) = 1;
  443.   TREE_READONLY (init) = 1;
  444.  
  445.   DECL_INITIAL (decl) = init;
  446.   TREE_STATIC (decl) = 1;
  447.   layout_decl (decl, 0);
  448.   finish_decl (decl, init, 0);
  449.  
  450.   return IDENTIFIER_AS_DESC (DECL_NAME (decl));
  451. }
  452.  
  453. /* Build an initializer for a __t_desc node.  So that we can take advantage
  454.    of recursion, we accept NULL for TYPE.
  455.    DEFINITION is greater than zero iff we must define the type descriptor
  456.    (as opposed to merely referencing it).  1 means treat according to
  457.    #pragma interface/#pragma implementation rules.  2 means define as
  458.    global and public, no matter what.  */
  459. tree
  460. build_t_desc (type, definition)
  461.      tree type;
  462.      int definition;
  463. {
  464.   tree tdecl;
  465.   tree tname, name_string;
  466.   tree elems, fields;
  467.   tree parents, vbases, offsets, ivars, methods;
  468.  
  469.   if (type == NULL_TREE)
  470.     return NULL_TREE;
  471.  
  472.   tname = build_t_desc_overload (type);
  473.   if (IDENTIFIER_AS_DESC (tname)
  474.       && (!definition || TREE_ASM_WRITTEN (IDENTIFIER_AS_DESC (tname))))
  475.     return IDENTIFIER_AS_DESC (tname);
  476.  
  477.   tdecl = lookup_name (tname);
  478.   if (tdecl == NULL_TREE)
  479.     {
  480.       tdecl = build_decl (VAR_DECL, tname, __t_desc_type_node);
  481.       TREE_EXTERNAL (tdecl) = 1;
  482.       TREE_PUBLIC (tdecl) = 1;
  483.       tdecl = pushdecl_top_level (tdecl);
  484.     }
  485.   /* If we previously defined it, return the defined result.  */
  486.   else if (definition && DECL_INITIAL (tdecl))
  487.     return IDENTIFIER_AS_DESC (tname);
  488.  
  489.   if (definition)
  490.     {
  491.       tree taggr = type;
  492.       /* Let T* and T& be written only when T is written (if T is an aggr).
  493.          We do this for const, but not for volatile, since volatile
  494.      is rare and const is not.  */
  495.       if (!TYPE_VOLATILE (taggr)
  496.       && (TREE_CODE (taggr) == POINTER_TYPE
  497.           || TREE_CODE (taggr) == REFERENCE_TYPE)
  498.       && IS_AGGR_TYPE (TREE_TYPE (taggr)))
  499.     taggr = TREE_TYPE (taggr);
  500.  
  501.       /* If we know that we don't need to write out this type's
  502.      vtable, then don't write out it's dossier.  Somebody
  503.      else will take care of that.  */
  504.       if (IS_AGGR_TYPE (taggr) && CLASSTYPE_VFIELD (taggr))
  505.     {
  506.       if (CLASSTYPE_VTABLE_NEEDS_WRITING (taggr))
  507.         {
  508.           TREE_PUBLIC (tdecl) = !(CLASSTYPE_INTERFACE_ONLY (taggr)
  509.                       || CLASSTYPE_INTERFACE_UNKNOWN (taggr));
  510.           TREE_STATIC (tdecl) = 1;
  511.           TREE_EXTERNAL (tdecl) = 0;
  512.         }
  513.       else
  514.         {
  515.           if (write_virtuals != 0)
  516.         TREE_PUBLIC (tdecl) = 1;
  517.         }
  518.     }
  519.       else
  520.     {
  521.       TREE_EXTERNAL (tdecl) = 0;
  522.       TREE_STATIC (tdecl) = 1;
  523.       TREE_PUBLIC (tdecl) = (definition > 1);
  524.     }
  525.     }
  526.   SET_IDENTIFIER_AS_DESC (tname, build_unary_op (ADDR_EXPR, tdecl, 0));
  527.   if (!definition || TREE_EXTERNAL (tdecl))
  528.     {
  529.       /* That's it!  */
  530.       finish_decl (tdecl, 0, 0);
  531.       return IDENTIFIER_AS_DESC (tname);
  532.     }
  533.  
  534.   /* Show that we are defining the t_desc for this type.  */
  535.   DECL_INITIAL (tdecl) = error_mark_node;
  536.  
  537.   parents = build_tree_list (NULL_TREE, integer_zero_node);
  538.   vbases = build_tree_list (NULL_TREE, integer_zero_node);
  539.   offsets = build_tree_list (NULL_TREE, integer_zero_node);
  540.   methods = build_tree_list (NULL_TREE, integer_zero_node);
  541.   ivars = build_tree_list (NULL_TREE, integer_zero_node);
  542.  
  543.   if (TYPE_LANG_SPECIFIC (type))
  544.     {
  545.       int i = CLASSTYPE_N_BASECLASSES (type);
  546.       tree method_vec = CLASSTYPE_METHOD_VEC (type);
  547.       tree *meth, *end;
  548.       tree vb = CLASSTYPE_VBASECLASSES (type);
  549.  
  550.       while (--i >= 0)
  551.     parents = tree_cons (NULL_TREE, build_t_desc (CLASSTYPE_BASECLASS (type, i), 0), parents);
  552.  
  553.       while (vb)
  554.     {
  555.       vbases = tree_cons (NULL_TREE, build_t_desc (ASSOC_VALUE (vb), 0), vbases);
  556.       offsets = tree_cons (NULL_TREE, ASSOC_OFFSET (vb), offsets);
  557.       vb = TREE_CHAIN (vb);
  558.     }
  559.  
  560.       if (method_vec)
  561.     for (meth = TREE_VEC_END (method_vec),
  562.          end = &TREE_VEC_ELT (method_vec, 0); meth-- != end; )
  563.       if (*meth)
  564.         methods = tree_cons (NULL_TREE, build_m_desc (*meth), methods);
  565.     }
  566.  
  567.   if (IS_AGGR_TYPE (type))
  568.     {
  569.       for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
  570.     ivars = tree_cons (NULL_TREE, build_i_desc (fields), ivars);
  571.       ivars = nreverse (ivars);
  572.     }
  573.  
  574.   parents = finish_table (0, TYPE_POINTER_TO (__t_desc_type_node), parents, 0);
  575.   vbases = finish_table (0, TYPE_POINTER_TO (__t_desc_type_node), vbases, 0);
  576.   offsets = finish_table (0, integer_type_node, offsets, 0);
  577.   methods = finish_table (0, TYPE_POINTER_TO (__m_desc_type_node), methods, 0);
  578.   ivars = finish_table (0, TYPE_POINTER_TO (__i_desc_type_node), ivars, 0);
  579.  
  580.   name_string = combine_strings (build_string (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
  581.  
  582.   elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
  583.         tree_cons (NULL_TREE,
  584.                TYPE_SIZE (type) ? size_in_bytes (type) : integer_zero_node,
  585.           /* really should use bitfield initialization here.  */
  586.           tree_cons (NULL_TREE, integer_zero_node,
  587.         tree_cons (NULL_TREE, build_t_desc (TREE_TYPE (type), 1),
  588.           tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, ivars, 0),
  589.             tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, methods, 0),
  590.               tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, parents, 0),
  591.             tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, vbases, 0),
  592.               build_tree_list (NULL_TREE, build_unary_op (ADDR_EXPR, offsets, 0))))))))));
  593.   return build_generic_desc (tdecl, elems);
  594. }
  595.  
  596. /* Build an initializer for a __i_desc node.  */
  597. tree
  598. build_i_desc (decl)
  599.      tree decl;
  600. {
  601.   tree idecl;
  602.   tree iname = build_i_desc_overload (decl);
  603.   tree elems, name_string;
  604.  
  605.   if (IDENTIFIER_AS_DESC (iname))
  606.     return IDENTIFIER_AS_DESC (iname);
  607.  
  608.   idecl = build_decl (VAR_DECL, iname, __i_desc_type_node);
  609.   idecl = pushdecl_top_level (idecl);
  610.   SET_IDENTIFIER_AS_DESC (iname, build_unary_op (ADDR_EXPR, idecl, 0));
  611.  
  612.   name_string = combine_strings (build_string (IDENTIFIER_LENGTH (iname)+1, IDENTIFIER_POINTER (iname)));
  613.  
  614.   elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
  615.          tree_cons (NULL_TREE, DECL_FIELD_BITPOS (decl),
  616.         build_tree_list (NULL_TREE, build_t_desc (TREE_TYPE (decl), 1))));
  617.   return build_generic_desc (idecl, elems);
  618. }
  619.  
  620. /* Build an initializer for a __m_desc node.  */
  621. tree
  622. build_m_desc (decl)
  623.      tree decl;
  624. {
  625.   tree mdecl;
  626.   tree mname = build_m_desc_overload (decl);
  627.   tree elems, name_string;
  628.   tree parm_types, parm_count, req_count, vindex, vcontext;
  629.   tree parms;
  630.   int p_count, r_count;
  631.  
  632.   if (IDENTIFIER_AS_DESC (mname))
  633.     return IDENTIFIER_AS_DESC (mname);
  634.  
  635.   mdecl = build_decl (VAR_DECL, mname, __m_desc_type_node);
  636.   mdecl = pushdecl_top_level (mdecl);
  637.   SET_IDENTIFIER_AS_DESC (mname, build_unary_op (ADDR_EXPR, mdecl, 0));
  638.  
  639.   parm_types = build_tree_list (NULL_TREE, integer_zero_node);
  640.   for (parms = TYPE_ARG_TYPES (TREE_TYPE (decl)), p_count = 0, r_count = 0;
  641.        parms != NULL_TREE; parms = TREE_CHAIN (parms), p_count++)
  642.     {
  643.       parm_types = tree_cons (NULL_TREE, build_t_desc (TREE_VALUE (parms), 1),
  644.                   parm_types);
  645.       if (TREE_PURPOSE (parms) == NULL_TREE)
  646.     r_count++;
  647.     }
  648.  
  649.   parm_types = finish_table (0, TYPE_POINTER_TO (__t_desc_type_node),
  650.                  nreverse (parm_types), 0);
  651.   parm_count = build_int_2 (p_count, 0);
  652.   req_count = build_int_2 (r_count, 0);
  653.  
  654.   if (DECL_VINDEX (decl))
  655.     vindex = DECL_VINDEX (decl);
  656.   else
  657.     vindex = integer_zero_node;
  658.   if (DECL_VCONTEXT (decl))
  659.     vcontext = build_t_desc (DECL_VCONTEXT (decl), 0);
  660.   else
  661.     vcontext = integer_zero_node;
  662.   name_string = combine_strings (build_string (IDENTIFIER_LENGTH (mname)+1, IDENTIFIER_POINTER (mname)));
  663.  
  664.   elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
  665.          tree_cons (NULL_TREE, vindex,
  666.         tree_cons (NULL_TREE, vcontext,
  667.            tree_cons (NULL_TREE, build_t_desc (TREE_TYPE (TREE_TYPE (decl)), 1),
  668.               tree_cons (NULL_TREE, build_c_cast (TYPE_POINTER_TO (default_function_type), build_unary_op (ADDR_EXPR, decl, 0)),
  669.              tree_cons (NULL_TREE, parm_count,
  670.                 tree_cons (NULL_TREE, req_count,
  671.                    build_tree_list (NULL_TREE, build_unary_op (ADDR_EXPR, parm_types, 0)))))))));
  672.   return build_generic_desc (mdecl, elems);
  673. }
  674.  
  675. void
  676. expand_gc_prologue_and_epilogue ()
  677. {
  678.   struct rtx_def *head, *last_parm_insn, *mark;
  679.   extern struct rtx_def *get_last_insn ();
  680.   extern struct rtx_def *get_first_nonparm_insn ();
  681.   extern struct rtx_def *previous_insn ();
  682.   tree action;
  683.  
  684.   /* If we didn't need the obstack, don't cons any space.  */
  685.   if (current_function_obstack_index == 0
  686.       || current_function_obstack_usage == 0)
  687.     return;
  688.  
  689.   mark = get_last_insn ();
  690.   last_parm_insn = get_first_nonparm_insn ();
  691.   if (last_parm_insn == 0) last_parm_insn = mark;
  692.   else last_parm_insn = previous_insn (last_parm_insn);
  693.  
  694.   action = build_function_call (gc_push_fndecl,
  695.                 build_tree_list (NULL_TREE, size_int (++current_function_obstack_index)));
  696.   expand_expr_stmt (action);
  697.  
  698.   reorder_insns (next_insn (mark), get_last_insn (), last_parm_insn);
  699.  
  700.   action = build_function_call (gc_pop_fndecl, NULL_TREE);
  701.   expand_expr_stmt (action);
  702. }
  703.  
  704. /* Some day we'll use this function as a call-back and clean
  705.    up all the unnecessary gc dribble that we otherwise create.  */
  706. void
  707. lang_expand_end_bindings (first, last)
  708.      struct rtx_def *first, *last;
  709. {
  710. }
  711.  
  712. void
  713. init_gc_processing ()
  714. {
  715.   tree parmtypes = hash_tree_chain (class_star_type_node,
  716.                     hash_tree_chain (integer_type_node, NULL_TREE));
  717.   gc_protect_fndecl = define_function ("__gc_protect",
  718.                        build_function_type (class_star_type_node, parmtypes),
  719.                        NOT_BUILT_IN, 0, 0);
  720.  
  721.   parmtypes = hash_tree_chain (integer_type_node, NULL_TREE);
  722.   gc_unprotect_fndecl = define_function ("__gc_unprotect",
  723.                      build_function_type (void_type_node, parmtypes),
  724.                      NOT_BUILT_IN, 0, 0);
  725.  
  726.   gc_push_fndecl = define_function ("__gc_push",
  727.                     TREE_TYPE (gc_unprotect_fndecl),
  728.                     NOT_BUILT_IN, 0, 0);
  729.  
  730.   gc_pop_fndecl = define_function ("__gc_pop",
  731.                    build_function_type (void_type_node,
  732.                             void_list_node),
  733.                    NOT_BUILT_IN, 0, 0);
  734.   gc_nonobject = build_int_2 (0x80000000, 0);
  735.   gc_visible = build_int_2 (0x40000000, 0);
  736.   gc_white = integer_zero_node;
  737.   gc_offwhite = build_int_2 (0x10000000, 0);
  738.   gc_grey = build_int_2 (0x20000000, 0);
  739.   gc_black = build_int_2 (0x30000000, 0);
  740. }
  741.