home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gnat-2.06-src.tgz / tar.out / fsf / gnat / ada / a-trans3.h < prev    next >
C/C++ Source or Header  |  1996-09-28  |  20KB  |  467 lines
  1. /****************************************************************************/
  2. /*                                                                          */
  3. /*                         GNAT COMPILER COMPONENTS                         */
  4. /*                                                                          */
  5. /*                             A - T R A N S 3                              */
  6. /*                                                                          */
  7. /*                              C Header File                               */
  8. /*                                                                          */
  9. /*                            $Revision: 1.84 $                             */
  10. /*                                                                          */
  11. /*           Copyright (c) 1992,1993,1994 NYU, All Rights Reserved          */
  12. /*                                                                          */
  13. /* GNAT is free software;  you can  redistribute it  and/or modify it under */
  14. /* terms of the  GNU General Public License as published  by the Free Soft- */
  15. /* ware  Foundation;  either version 2,  or (at your option) any later ver- */
  16. /* sion.  GNAT is distributed in the hope that it will be useful, but WITH- */
  17. /* OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY */
  18. /* or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License */
  19. /* for  more details.  You should have  received  a copy of the GNU General */
  20. /* Public License  distributed with GNAT;  see file COPYING.  If not, write */
  21. /* to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  22. /*                                                                          */
  23. /****************************************************************************/
  24.  
  25. /* If nonzero, pretend we are allocating at global level.  */
  26. extern int force_global;
  27.  
  28. /* Standard data type sizes.  Most of these are not used.  */
  29.  
  30. #ifndef CHAR_TYPE_SIZE
  31. #define CHAR_TYPE_SIZE BITS_PER_UNIT
  32. #endif
  33.  
  34. #ifndef SHORT_TYPE_SIZE
  35. #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
  36. #endif
  37.  
  38. #ifndef INT_TYPE_SIZE
  39. #define INT_TYPE_SIZE BITS_PER_WORD
  40. #endif
  41.  
  42. #ifndef LONG_TYPE_SIZE
  43. #define LONG_TYPE_SIZE BITS_PER_WORD
  44. #endif
  45.  
  46. #ifndef LONG_LONG_TYPE_SIZE
  47. #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
  48. #endif
  49.  
  50. #ifndef FLOAT_TYPE_SIZE
  51. #define FLOAT_TYPE_SIZE BITS_PER_WORD
  52. #endif
  53.  
  54. #ifndef DOUBLE_TYPE_SIZE
  55. #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
  56. #endif
  57.  
  58. #ifndef LONG_DOUBLE_TYPE_SIZE
  59. #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
  60. #endif
  61.  
  62. /* The choice of SIZE_TYPE here is very problematic.  We need a signed
  63.    type whose bit width is Pmode.  Assume "long" is such a type here.  */
  64. #undef SIZE_TYPE
  65. #define SIZE_TYPE "long int"
  66.  
  67. /* Flags added to GCC type nodes.  */
  68.  
  69. /* Nonzero if this type is a record corresponding to a fat pointer.  */
  70. #define TYPE_FAT_POINTER_P(NODE) TYPE_LANG_FLAG_0 (NODE)
  71.  
  72. /* For INTEGER_TYPE, nonzero if this is a modular type with a modulus that
  73.    is not equal to two to the power of its mode's size.  */
  74. #define TYPE_MODULAR_P(NODE) TYPE_LANG_FLAG_1 (NODE)
  75.  
  76. /* For ARRAY_TYPE, nonzero if this type corresponds to a dimension of
  77.    an Ada array other than the first.  */
  78. #define TYPE_MULTI_ARRAY_P(NODE)  TYPE_LANG_FLAG_1 (NODE)
  79.  
  80. /* For FUNCTION_TYPE, nonzero if this denotes a function returning an
  81.    unconstrained array or record.  */
  82. #define TYPE_RETURNS_UNCONSTRAINED_P(NODE) TYPE_LANG_FLAG_1 (NODE)
  83.  
  84. /* For RECORD_TYPE, nonzero if this type has a record rep clause.  */
  85. #define TYPE_HAS_REP_CLAUSE_P(NODE)  TYPE_LANG_FLAG_1 (NODE)
  86.  
  87. /* Nonzero in an arithmetic subtype if this is a subtype not known to the
  88.    front-end.  */
  89. #define TYPE_EXTRA_SUBTYPE_P(NODE) TYPE_LANG_FLAG_2 (NODE)
  90.  
  91. /* Nonzero if this is the type for an object whose type includes
  92.    its template in addition to its value.  */
  93. #define TYPE_CONTAINS_TEMPLATE_P(NODE) TYPE_LANG_FLAG_3 (NODE)
  94.  
  95. /* For ARRAY_TYPEs, nonzero if the array type has Convention_Fortran.  */
  96. #define TYPE_CONVENTION_FORTRAN_P(NODE) TYPE_LANG_FLAG_4 (NODE)
  97.  
  98. /* For FUNCTION_TYPEs, nonzero if the function returns by reference.  */
  99. #define TYPE_RETURNS_BY_REF_P(NODE) TYPE_LANG_FLAG_4 (NODE)
  100.  
  101. /* For VOID_TYPE and RECORD_TYPE, nonzero if this is a dummy type,
  102.    make to correspond to a private or incomplete type.  */
  103. #define TYPE_DUMMY_P(NODE) TYPE_LANG_FLAG_4 (NODE)
  104.  
  105. /* True if TYPE is such a dummy type.  */
  106. #define TYPE_IS_DUMMY_P(NODE) \
  107.   ((TREE_CODE (NODE) == VOID_TYPE || TREE_CODE (NODE) == RECORD_TYPE) \
  108.    && TYPE_DUMMY_P (NODE))
  109.  
  110. /* Nonzero if this corresponds to a type where alignment is guaranteed
  111.    by other mechanisms (a tagged or packed type).  */
  112. #define TYPE_ALIGN_OK_P(NODE) TYPE_LANG_FLAG_5 (NODE)
  113.  
  114. /* For RECORD_TYPE, nonzero if this was made for the component type
  115.    of an ARRAY_TYPE where we had to use max_size.  */
  116. #define TYPE_COMPONENT_MAX_TYPE_P(NODE) TYPE_LANG_FLAG_6 (NODE)
  117.  
  118. /* This field is only defined for FUNCTION_TYPE nodes. If the Ada
  119.    subprogram contains no parameters passed by copy in/copy out then this
  120.    field is 0. Otherwise it points to a list of nodes used to specify the
  121.    return values of the out (or in out) parameters that qualify to be passed
  122.    by copy in copy out.  It is a CONSTRUCTOR.  For a full description of the
  123.    cico parameter passing mechanism refer to the routine gnat_to_gnu_entity. */
  124. #define TYPE_CI_CO_LIST(NODE)   (tree) TYPE_LANG_SPECIFIC (NODE)
  125.  
  126. /* For an INTEGER_TYPE with TYPE_MODULAR_P, this is the value of the
  127.    modulus. */
  128. #define TYPE_MODULUS(NODE)    (tree) TYPE_LANG_SPECIFIC (NODE)
  129.  
  130. /* For an INTEGER_TYPE that is the TYPE_DOMAIN of some ARRAY_TYPE, points to
  131.    the type corresponding to the Ada index type.  */
  132. #define TYPE_INDEX_TYPE(NODE)    (tree) TYPE_LANG_SPECIFIC (NODE)
  133.  
  134. /* For a RECORD_TYPE that is a fat pointer, point to the type for the
  135.    unconstrained object.  */
  136. #define TYPE_UNCONSTRAINED_ARRAY(NODE)  (tree) TYPE_LANG_SPECIFIC (NODE)
  137.  
  138. /* For an ARRAY_TYPE, this is the index type that should be used when
  139.    the actual bounds are required for a template.  This is used in
  140.    the case of packed arrays.  */
  141. #define TYPE_ACTUAL_BOUNDS(NODE)   (tree) TYPE_LANG_SPECIFIC (NODE)
  142.  
  143. /* For a RECORD_TYPE that is not a fat pointer, point to the original subtype
  144.    for the _parent field, if there was one.  */
  145. #define TYPE_PARENT_SUBTYPE(NODE)  (tree) TYPE_LANG_SPECIFIC (NODE)
  146.  
  147. /* Nonzero in a FIELD_DECL that represents a discriminant.  */
  148. #define DECL_DISCRIMINANT_P(NODE) DECL_LANG_FLAG_0 (NODE)
  149.  
  150. /* Nonzero if this decl is always used by reference; i.e., an INDIRECT_REF
  151.    is needed to access the object.  */
  152. #define DECL_BY_REF_P(NODE) DECL_LANG_FLAG_1 (NODE)
  153.  
  154. /* Nonzero in a FIELD_DECL that is a parent field.  */
  155. #define DECL_PARENT_P(NODE) DECL_LANG_FLAG_2 (NODE)
  156.  
  157. /* Nonzero in a PARM_DECL if this was an Ada array being passed to a
  158.    foreign convention subprogram.  */
  159. #define DECL_BY_COMPONENT_PTR_P(NODE) DECL_LANG_FLAG_3 (NODE)
  160.  
  161. /* Nonzero in a FIELD_DECL that is the first field in a variant of
  162.    record with a record rep clause.  */
  163. #define DECL_FIRST_FIELD_IN_VARIANT_P(NODE) DECL_LANG_FLAG_4 (NODE)
  164.  
  165. /* Nonzero in a FIELD_DECL that is a dummy built for a variant part.  */
  166. #define DECL_FOR_VARIANT_P(NODE) DECL_LANG_FLAG_5 (NODE)
  167.  
  168. /* Nonzero if this is a decl for a pointer that points to something which
  169.    is readonly.  Used mostly for fat pointers.  */
  170. #define DECL_POINTS_TO_READONLY_P(NODE) DECL_LANG_FLAG_6 (NODE)
  171.  
  172. /* Nonzero in a TRANSFORM_EXPR if we are to take its address.  */
  173. #define TREE_TRANSFORM_ADDR(NODE) TREE_STATIC (NODE)
  174.  
  175. /* Variables expected by the GCC back-end.  */
  176.  
  177. /* A node which has tree code ERROR_MARK, and whose type is itself.  */
  178. extern tree error_mark_node;
  179.  
  180. /* Various standard data types and nodes.  */
  181.  
  182. extern tree integer_type_node;
  183. extern tree unsigned_type_node;
  184. extern tree char_type_node;
  185. extern tree longest_float_type_node;
  186. extern tree void_type_node;
  187. extern tree void_type_decl_node;
  188. extern tree integer_zero_node;
  189. extern tree integer_one_node;
  190. extern tree null_pointer_node;
  191.  
  192. /* The type of an exception.  */
  193. extern tree except_type_node;
  194.  
  195. /* The FUNCTION_DECL node for the function currently being compiled, or 0
  196.    if between functions.  */
  197. extern tree current_function_decl;
  198.  
  199. /* Variables created for the sole tree translator sake. Their names and
  200.    types can be changed as desired.  */
  201.  
  202. /* type declaration node  <==> typedef void *T */
  203. extern tree ptr_void_type_node;
  204.  
  205. /* function type declaration -- void T() */
  206. extern tree void_ftype;
  207.  
  208. /* type declaration node  <==> typedef void *T() */
  209. extern tree ptr_void_ftype;
  210.  
  211. /* A function declaration node for a run-time function for allocating memory.
  212.    Ada allocators cause calls to this function to be generated.   */
  213. extern tree malloc_decl;
  214.  
  215. /* Likewise for freeing memory.  */
  216. extern tree free_decl;
  217.  
  218. /* Types and decls used by our temporary exception mechanism.  See
  219.    init_decl_processing for details.  */
  220. extern tree jmpbuf_type;
  221. extern tree jmpbuf_ptr_type;
  222. extern tree get_jmpbuf_decl;
  223. extern tree set_jmpbuf_decl;
  224. extern tree get_excptr_decl;
  225. extern tree raise_decl;
  226. extern tree raise_nodefer_decl;
  227. extern tree setjmp_decl;
  228. extern tree longjmp_decl;
  229. extern tree raise_constraint_error_decl;
  230. extern tree raise_program_error_decl;
  231. extern tree unchecked_union_node;
  232.  
  233. /* Routines expected by the gcc back-end. They must have exactly the same
  234.    prototype and names as below.  */
  235.  
  236. /* Returns non-zero if we are currently in the global binding level       */
  237. extern int global_bindings_p    PROTO((void));
  238.  
  239. /* Returns the list of declarations in the current level. Note that this list
  240.    is in reverse order (it has to be so for back-end compatibility).  */
  241. extern tree getdecls            PROTO((void));
  242.  
  243. /* Nonzero if the current level needs to have a BLOCK made.  */
  244. extern int kept_level_p         PROTO((void));
  245.  
  246. /* Enter a new binding level. The input parameter is ignored, but has to be
  247.    specified for back-end compatibility.  */
  248. extern void pushlevel            PROTO((int));
  249.  
  250. /* Exit a binding level.
  251.    Pop the level off, and restore the state of the identifier-decl mappings
  252.    that were in effect when this level was entered.
  253.  
  254.    If KEEP is nonzero, this level had explicit declarations, so
  255.    and create a "block" (a BLOCK node) for the level
  256.    to record its declarations and subblocks for symbol table output.
  257.  
  258.    If FUNCTIONBODY is nonzero, this level is the body of a function,
  259.    so create a block as if KEEP were set and also clear out all
  260.    label names.
  261.  
  262.    If REVERSE is nonzero, reverse the order of decls before putting
  263.    them into the BLOCK.  */
  264. extern tree poplevel        PROTO((int,int, int));
  265.  
  266. /* Insert BLOCK at the end of the list of subblocks of the
  267.    current binding level.  This is used when a BIND_EXPR is expanded,
  268.    to handle the BLOCK node inside the BIND_EXPR.  */
  269. extern void insert_block        PROTO((tree));
  270.  
  271. /* Set the BLOCK node for the innermost scope
  272.    (the one we are currently in).  */
  273. extern void set_block            PROTO((tree));
  274.  
  275. /* Records a ..._DECL node DECL as belonging to the current lexical scope.
  276.    Returns the ..._DECL node. */
  277. extern tree pushdecl            PROTO((tree));
  278.  
  279. /* Create the predefined scalar types such as `integer_type_node' needed 
  280.    in the gcc back-end and initialize the global binding level.  */
  281. extern void init_decl_processing    PROTO((void));
  282.  
  283. /* Return an integer type with the number of bits of precision given by  
  284.    PRECISION.  UNSIGNEDP is nonzero if the type is unsigned; otherwise
  285.    it is a signed type.  */
  286. extern tree type_for_size        PROTO((unsigned, int));
  287.  
  288. /* Return a data type that has machine mode MODE.  UNSIGNEDP selects
  289.    an unsigned type; otherwise a signed type is returned.  */
  290. extern tree type_for_mode        PROTO((enum machine_mode, int));
  291.  
  292. /* Return the unsigned version of a TYPE_NODE, a scalar type.  */
  293. extern tree unsigned_type        PROTO((tree));
  294.  
  295. /* Return the signed version of a TYPE_NODE, a scalar type.  */
  296. extern tree signed_type            PROTO((tree));
  297.  
  298. /* Return a type the same as TYPE except unsigned or signed according to
  299.    UNSIGNEDP.  */
  300. extern tree signed_or_unsigned_type    PROTO((int, tree));
  301.  
  302. /* This routine is called in tree.c to print an error message for invalid use
  303.    of an incomplete type.  */
  304. extern void incomplete_type_error    PROTO((tree, tree));
  305.  
  306. /* This function is called indirectly from toplev.c to handle incomplete 
  307.    declarations, i.e. VAR_DECL nodes whose DECL_SIZE is zero.  To be precise,
  308.    compile_file in toplev.c makes an indirect call through the function pointer
  309.    incomplete_decl_finalize_hook which is initialized to this routine in
  310.    init_decl_processing.  */
  311. extern void finish_incomplete_decl    PROTO((tree));
  312.  
  313. /* Create an expression whose value is that of EXPR,
  314.    converted to type TYPE.  The TREE_TYPE of the value
  315.    is always TYPE.  This function implements all reasonable
  316.    conversions; callers should filter out those that are
  317.    not permitted by the language being compiled.  */
  318. extern tree convert            PROTO((tree, tree));
  319.  
  320. /* Routines created solely for the tree translator's sake. Their prototypes
  321.    can be changed as desired.  */
  322.  
  323. /* GNAT_ENTITY is a GNAT tree node for a defining identifier.
  324.    GNU_DECL is the GCC tree which is to be associated with
  325.    GNAT_ENTITY. Such gnu tree node is always an ..._DECL node.
  326.    If NO_CHECK is nonzero, the latter check is suppressed. 
  327.    If GNU_DECL is zero, a previous association is to be reset.  */
  328. extern void save_gnu_tree        PROTO((Entity_Id, tree, int));
  329.  
  330. /* GNAT_ENTITY is a GNAT tree node for a defining identifier.
  331.    Return the ..._DECL node that was associated with it.  If there is no tree
  332.    node associated with GNAT_ENTITY, abort.  */
  333. extern tree get_gnu_tree        PROTO((Entity_Id));
  334.  
  335. /* Return nonzero if a GCC tree has been associated with GNAT_ENTITY.  */
  336. extern int present_gnu_tree    PROTO((Entity_Id));
  337.  
  338. /* Initialize tables for above routines.  */
  339. extern void init_gnat_to_gnu        PROTO((void));
  340.  
  341. /* Given a record type (RECORD_TYPE) and a chain of FIELD_DECL
  342.    nodes (FIELDLIST), finish constructing the record or union type. 
  343.    If HAS_REP is nonzero, this record has a rep clause; don't call
  344.    layout_type but merely set the size and alignment ourselves.
  345.    If DEFER_DEBUG is nonzero, do not call the debugging routines
  346.    on this type; it will be done later. */
  347. extern void finish_record_type        PROTO((tree, tree, int, int));
  348.  
  349. /* Returns a FUNCTION_TYPE node. RETURN_TYPE is the type returned by the
  350.    subprogram. If it is void_type_node, then we are dealing with a procedure,
  351.    otherwise we are dealing with a function. PARAM_DECL_LIST is a list of
  352.    PARM_DECL nodes that are the subprogram arguments.  CICO_LIST is the
  353.    copy-in/copy-out list to be stored into TYPE_CI_CO_LIST. 
  354.    RETURNS_UNCONSTRAINED is nonzero if the function returns an unconstrained
  355.    object.  RETURNS_BY_REF is nonzero if the function returns by reference.  */
  356. extern tree create_subprog_type        PROTO((tree, tree, tree, int, int));
  357.  
  358. /* Return a copy of TYPE, in the same obstack as it was, but safe to modify
  359.    in any way.  */
  360.  
  361. extern tree copy_type            PROTO((tree));
  362.  
  363. /* Return an INTEGER_TYPE of SIZETYPE with range MIN to MAX and whose
  364.    TYPE_INDEX_TYPE is INDEX.  */
  365. extern tree create_index_type        PROTO((tree, tree, tree));
  366.  
  367. /* Returns a TYPE_DECL node. TYPE_NAME gives the name of the type (a character
  368.    string) and TYPE is a ..._TYPE node giving its data type.  */
  369. extern tree create_type_decl        PROTO((char *, tree));
  370.  
  371. /* Returns a GCC VAR_DECL node. VAR_NAME gives the name of the variable (a
  372.    character string). ASM_NAME is its assembler name (if provided).  TYPE is
  373.    its data type (a GCC ..._TYPE node).  VAR_INIT is the GCC tree for an
  374.    optional initial expression; NULL_TREE if none.
  375.  
  376.    SIZE, if nonzero, is a GCC tree to be used for the size of the variable.
  377.    ALIGN, if nonzero, is the required alignment of the variable.
  378.  
  379.    CONST_FLAG is nonzero if this variable is constant.
  380.  
  381.    PUBLIC_FLAG is nonzero if this definition is to be made visible outside of
  382.    the current compilation unit. This flag should be set when processing the
  383.    variable definitions in a package specification.  EXTERN_FLAG is nonzero 
  384.    when processing an external variable declaration (as opposed to a
  385.    definition: no storage is to be allocated for the variable here).
  386.    STATIC_FLAG is only relevant when not at top level.  In that case
  387.    it indicates whether to always allocate storage to the variable.  */
  388. extern tree create_var_decl    PROTO((char *, char *, tree, tree, tree, int,
  389.                        int, int, int, int));
  390.  
  391. /* Obtain any pending elaborations and clear the old list.  */
  392. extern tree get_pending_elaborations PROTO((void));
  393.  
  394. /* Save a copy of the current pending elaboration list and make a new
  395.    one.  */
  396. extern void push_pending_elaborations PROTO((void));
  397.  
  398. /* Pop the stack of pending elaborations.  */
  399. extern void pop_pending_elaborations PROTO((void));
  400.  
  401. /* Return the current position in pending_elaborations so we can insert
  402.    elaborations after that point.  */
  403. extern tree get_elaboration_location PROTO((void));
  404.  
  405. /* Insert the current elaborations after ELAB, which is in some elaboration
  406.    list.  */
  407. extern void insert_elaboration_list PROTO((tree));
  408.  
  409. /* Add some pending elaborations to the current list.  */
  410. extern void add_pending_elaborations PROTO((tree, tree));
  411.  
  412. /* Returns a FIELD_DECL node. FIELD_NAME the field name, FIELD_TYPE is its
  413.    type, and RECORD_TYPE is the type of the parent.  PACKED is nonzero if
  414.    this field is in a record type with a "pragma pack".  If SIZE is nonnegative
  415.    it is the specified size for this field and POS is the bit position.  
  416.    If SIZE is the special value -2, it means we should not replace a
  417.    discriminated size with the maximum value; this is used in laying
  418.    out nested variants.  */
  419. extern tree create_field_decl    PROTO((char *, tree, tree, int, int, int));
  420.  
  421. /* Returns a PARM_DECL node. PARAM_NAME is the name of the parameter,
  422.    PARAM_TYPE is its type.  READONLY is nonzero if the parameter is
  423.    readonly (either an IN parameter or an address of a pass-by-ref
  424.    parameter). */
  425. extern tree create_param_decl    PROTO((char *, tree, int));
  426.  
  427. /* Returns a FUNCTION_DECL node.  SUBPROG_NAME is the name of the subprogram,
  428.    ASM_NAME is its assembler name, SUBPROG_TYPE is its type (a FUNCTION_TYPE
  429.    node), PARAM_DECL_LIST is the list of the subprogram arguments (a list of
  430.    PARM_DECL nodes chained through the TREE_CHAIN field).
  431.  
  432.    INLINE_FLAG, PUBLIC_FLAG, EXTERN_FLAG, and PURE_FLAG are used to set the
  433.    appropriate fields in the FUNCTION_DECL.  */
  434. extern tree create_subprog_decl    PROTO((char *, char *, tree, tree,
  435.                        int, int, int, int, tree));
  436.  
  437. /* Returns a LABEL_DECL node for LABEL_NAME.  */
  438. extern tree create_label_decl    PROTO((char *));
  439.  
  440. /* Set up the framework for generating code for SUBPROG_DECL, a subprogram
  441.    body. This routine needs to be invoked before processing the declarations
  442.    appearing in the subprogram.  */
  443. extern void begin_subprog_body    PROTO((tree));
  444.  
  445. /* Finish the definition of the current subprogram and compile it all the way
  446.    to assembler language output.  */
  447. extern void end_subprog_body    PROTO((void));
  448.  
  449. /* Build a template of type TEMPLATE_TYPE from the array bounds of ARRAY_TYPE.
  450.    EXPR is an expression that we can use to locate any PLACEHOLDER_EXPRs.
  451.    Return a constructor for the template.  */
  452. extern tree build_template    PROTO((tree, tree, tree));
  453.  
  454. /* Update anything previously pointing to OLD_TYPE to point to NEW_TYPE.  In
  455.    the normal case this is just two adjustments, but we have more to do
  456.    if NEW is an UNCONSTRAINED_ARRAY_TYPE.  */
  457. extern void update_pointer_to    PROTO((tree, tree));
  458.  
  459. /* Convert a pointer to a constrained array into a pointer to an unconstrained
  460.    array.  This involves making a template.  */
  461. extern tree convert_to_unconstrained PROTO((tree, tree));
  462.  
  463. /* EXP is an expression for the size of an object.  If this size contains
  464.    discriminant references, replace them with the maximum (if MAX_P) or
  465.    minimum (if ! MAX_P) possible value of the discriminant.  */
  466. extern tree max_size        PROTO((tree, int));
  467.