home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / gcc-2.3.3-src.lha / GNU / src / amiga / gcc-2.3.3 / cp-tree.c < prev    next >
C/C++ Source or Header  |  1994-02-06  |  49KB  |  1,754 lines
  1. /* Language-dependent node constructors for parse phase of GNU compiler.
  2.    Copyright (C) 1987, 1988, 1992 Free Software Foundation, Inc.
  3.    Hacked 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. #include "config.h"
  22. #include <stdio.h>
  23. #include "obstack.h"
  24. #include "tree.h"
  25. #include "cp-tree.h"
  26. #include "flags.h"
  27.  
  28. #define CEIL(x,y) (((x) + (y) - 1) / (y))
  29.  
  30. /* Return nonzero if REF is an lvalue valid for this language.
  31.    Lvalues can be assigned, unless they have TREE_READONLY.
  32.    Lvalues can have their address taken, unless they have DECL_REGISTER.  */
  33.  
  34. int
  35. lvalue_p (ref)
  36.      tree ref;
  37. {
  38.   register enum tree_code code = TREE_CODE (ref);
  39.  
  40.   if (language_lvalue_valid (ref))
  41.     switch (code)
  42.       {
  43.     /* preincrements and predecrements are valid lvals, provided
  44.        what they refer to are valid lvals. */
  45.       case PREINCREMENT_EXPR:
  46.       case PREDECREMENT_EXPR:
  47.       case COMPONENT_REF:
  48.     return lvalue_p (TREE_OPERAND (ref, 0));
  49.  
  50.       case STRING_CST:
  51.     return 1;
  52.  
  53.       case VAR_DECL:
  54.     if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
  55.         && DECL_LANG_SPECIFIC (ref)
  56.         && DECL_IN_AGGR_P (ref))
  57.       return 0;
  58.       case INDIRECT_REF:
  59.       case ARRAY_REF:
  60.       case PARM_DECL:
  61.       case RESULT_DECL:
  62.       case ERROR_MARK:
  63.     if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
  64.         && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
  65.       return 1;
  66.     break;
  67.  
  68.       case TARGET_EXPR:
  69.       case WITH_CLEANUP_EXPR:
  70.     return 1;
  71.  
  72.       case CALL_EXPR:
  73.     if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE
  74.         /* unary_complex_lvalue knows how to deal with this case.  */
  75.         || TREE_ADDRESSABLE (TREE_TYPE (ref)))
  76.       return 1;
  77.     break;
  78.  
  79.     /* A currently unresolved scope ref.  */
  80.       case SCOPE_REF:
  81.     my_friendly_abort (103);
  82.       case OFFSET_REF:
  83.     if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
  84.       return 1;
  85.     if (TREE_CODE (TREE_OPERAND (ref, 1)) == VAR_DECL)
  86.       if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
  87.           && DECL_LANG_SPECIFIC (ref)
  88.           && DECL_IN_AGGR_P (ref))
  89.         return 0;
  90.       else
  91.         return 1;
  92.     break;
  93.  
  94.       case ADDR_EXPR:
  95.     /* ANSI C++ June 5 1992 WP 5.4.14.  The result of a cast to a
  96.        reference is an lvalue.  */
  97.     if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
  98.       return 1;
  99.     break;
  100.       }
  101.   return 0;
  102. }
  103.  
  104. /* Return nonzero if REF is an lvalue valid for this language;
  105.    otherwise, print an error message and return zero.  */
  106.  
  107. int
  108. lvalue_or_else (ref, string)
  109.      tree ref;
  110.      char *string;
  111. {
  112.   int win = lvalue_p (ref);
  113.   if (! win)
  114.     error ("invalid lvalue in %s", string);
  115.   return win;
  116. }
  117.  
  118. /* INIT is a CALL_EXPR which needs info about its target.
  119.    TYPE is the type that this initialization should appear to have.
  120.  
  121.    Build an encapsulation of the initialization to perform
  122.    and return it so that it can be processed by language-independent
  123.    and language-specific expression expanders.
  124.  
  125.    If WITH_CLEANUP_P is nonzero, we build a cleanup for this expression.
  126.    Otherwise, cleanups are not built here.  For example, when building
  127.    an initialization for a stack slot, since the called function handles
  128.    the cleanup, we would not want to do it here.  */
  129. tree
  130. build_cplus_new (type, init, with_cleanup_p)
  131.      tree type;
  132.      tree init;
  133.      int with_cleanup_p;
  134. {
  135.   tree slot = build (VAR_DECL, type);
  136.   tree rval = build (NEW_EXPR, type,
  137.              TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), slot);
  138.   TREE_SIDE_EFFECTS (rval) = 1;
  139.   TREE_ADDRESSABLE (rval) = 1;
  140.   rval = build (TARGET_EXPR, type, slot, rval, 0);
  141.   TREE_SIDE_EFFECTS (rval) = 1;
  142.   TREE_ADDRESSABLE (rval) = 1;
  143.  
  144.   if (with_cleanup_p && TYPE_NEEDS_DESTRUCTOR (type))
  145.     {
  146.       rval = build (WITH_CLEANUP_EXPR, type, rval, 0,
  147.             build_delete (TYPE_POINTER_TO (type),
  148.                   build_unary_op (ADDR_EXPR, slot, 0),
  149.                   integer_two_node,
  150.                   LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0, 0));
  151.       TREE_SIDE_EFFECTS (rval) = 1;
  152.     }
  153.   return rval;
  154. }
  155.  
  156. /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
  157.    these CALL_EXPRs with tree nodes that will perform the cleanups.  */
  158.  
  159. tree
  160. break_out_cleanups (exp)
  161.      tree exp;
  162. {
  163.   tree tmp = exp;
  164.  
  165.   if (TREE_CODE (tmp) == CALL_EXPR
  166.       && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp)))
  167.     return build_cplus_new (TREE_TYPE (tmp), tmp, 1);
  168.  
  169.   while (TREE_CODE (tmp) == NOP_EXPR
  170.      || TREE_CODE (tmp) == CONVERT_EXPR
  171.      || TREE_CODE (tmp) == NON_LVALUE_EXPR)
  172.     {
  173.       if (TREE_CODE (TREE_OPERAND (tmp, 0)) == CALL_EXPR
  174.       && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp, 0))))
  175.     {
  176.       TREE_OPERAND (tmp, 0)
  177.         = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp, 0)),
  178.                    TREE_OPERAND (tmp, 0), 1);
  179.       break;
  180.     }
  181.       else
  182.     tmp = TREE_OPERAND (tmp, 0);
  183.     }
  184.   return exp;
  185. }
  186.  
  187. /* Recursively perform a preorder search EXP for CALL_EXPRs, making
  188.    copies where they are found.  Returns a deep copy all nodes transitively
  189.    containing CALL_EXPRs.  */
  190.  
  191. tree
  192. break_out_calls (exp)
  193.      tree exp;
  194. {
  195.   register tree t1, t2;
  196.   register enum tree_code code;
  197.   register int changed = 0;
  198.   register int i;
  199.  
  200.   if (exp == NULL_TREE)
  201.     return exp;
  202.  
  203.   code = TREE_CODE (exp);
  204.  
  205.   if (code == CALL_EXPR)
  206.     return copy_node (exp);
  207.  
  208.   /* Don't try and defeat a save_expr, as it should only be done once. */
  209.     if (code == SAVE_EXPR)
  210.        return exp;
  211.  
  212.   switch (TREE_CODE_CLASS (code))
  213.     {
  214.     default:
  215.       abort ();
  216.  
  217.     case 'c':  /* a constant */
  218.     case 't':  /* a type node */
  219.     case 'x':  /* something random, like an identifier or an ERROR_MARK.  */
  220.       return exp;
  221.  
  222.     case 'd':  /* A decl node */
  223.       t1 = break_out_calls (DECL_INITIAL (exp));
  224.       if (t1 != DECL_INITIAL (exp))
  225.     {
  226.       exp = copy_node (exp);
  227.       DECL_INITIAL (exp) = t1;
  228.     }
  229.       return exp;
  230.  
  231.     case 'b':  /* A block node */
  232.       {
  233.     /* Don't know how to handle these correctly yet.   Must do a
  234.        break_out_calls on all DECL_INITIAL values for local variables,
  235.        and also break_out_calls on all sub-blocks and sub-statements.  */
  236.     abort ();
  237.       }
  238.       return exp;
  239.  
  240.     case 'e':  /* an expression */
  241.     case 'r':  /* a reference */
  242.     case 's':  /* an expression with side effects */
  243.       for (i = tree_code_length[(int) code] - 1; i >= 0; i--)
  244.     {
  245.       t1 = break_out_calls (TREE_OPERAND (exp, i));
  246.       if (t1 != TREE_OPERAND (exp, i))
  247.         {
  248.           if (changed++ == 0)
  249.         exp = copy_node (exp);
  250.           TREE_OPERAND (exp, i) = t1;
  251.         }
  252.     }
  253.       return exp;
  254.  
  255.     case '<':  /* a comparison expression */
  256.     case '2':  /* a binary arithmetic expression */
  257.       t2 = break_out_calls (TREE_OPERAND (exp, 1));
  258.       if (t2 != TREE_OPERAND (exp, 1))
  259.     changed = 1;
  260.     case '1':  /* a unary arithmetic expression */
  261.       t1 = break_out_calls (TREE_OPERAND (exp, 0));
  262.       if (t1 != TREE_OPERAND (exp, 0))
  263.     changed = 1;
  264.       if (changed)
  265.     {
  266.       if (tree_code_length[(int) code] == 1)
  267.         return build1 (code, TREE_TYPE (exp), t1);
  268.       else
  269.         return build (code, TREE_TYPE (exp), t1, t2);
  270.     }
  271.       return exp;
  272.     }
  273.  
  274. }
  275.  
  276. extern struct obstack *current_obstack;
  277. extern struct obstack permanent_obstack, class_obstack;
  278. extern struct obstack *saveable_obstack;
  279.  
  280. /* Here is how primitive or already-canonicalized types' hash
  281.    codes are made.  MUST BE CONSISTENT WITH tree.c !!! */
  282. #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
  283.  
  284. /* Construct, lay out and return the type of methods belonging to class
  285.    BASETYPE and whose arguments and values are described by TYPE.
  286.    If that type exists already, reuse it.
  287.    TYPE must be a FUNCTION_TYPE node.  */
  288.  
  289. tree
  290. build_cplus_method_type (basetype, rettype, argtypes)
  291.      tree basetype, rettype,