gcc/cp/cp-objcp-common.c

   1 /* Some code common to C++ and ObjC++ front ends.
   2    Copyright (C) 2004, 2007 Free Software Foundation, Inc.
   3    Contributed by Ziemowit Laski  <zlaski@apple.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "tree.h"
  26 #include "cp-tree.h"
  27 #include "c-common.h"
  28 #include "toplev.h"
  29 #include "langhooks.h"
  30 #include "langhooks-def.h"
  31 #include "diagnostic.h"
  32 #include "debug.h"
  33 #include "cxx-pretty-print.h"
  34 #include "cp-objcp-common.h"
  35
  36 /* Special routine to get the alias set for C++.  */
  37
  38 alias_set_type
  39 cxx_get_alias_set (tree t)
  40 {
  41   if (IS_FAKE_BASE_TYPE (t))
  42     /* The base variant of a type must be in the same alias set as the
  43        complete type.  */
  44     return get_alias_set (TYPE_CONTEXT (t));
  45
  46   /* Punt on PMFs until we canonicalize functions properly.  */
  47   if (TYPE_PTRMEMFUNC_P (t))
  48     return 0;
  49
  50   return c_common_get_alias_set (t);
  51 }
  52
  53 /* Called from check_global_declarations.  */
  54
  55 bool
  56 cxx_warn_unused_global_decl (const_tree decl)
  57 {
  58   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
  59     return false;
  60   if (DECL_IN_SYSTEM_HEADER (decl))
  61     return false;
  62
  63   /* Const variables take the place of #defines in C++.  */
  64   if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl))
  65     return false;
  66
  67   return true;
  68 }
  69
  70 /* Langhook for expr_size: Tell the back end that the value of an expression
  71    of non-POD class type does not include any tail padding; a derived class
  72    might have allocated something there.  */
  73
  74 tree
  75 cp_expr_size (const_tree exp)
  76 {
  77   tree type = TREE_TYPE (exp);
  78
  79   if (CLASS_TYPE_P (type))
  80     {
  81       /* The back end should not be interested in the size of an expression
  82          of a type with both of these set; all copies of such types must go
  83          through a constructor or assignment op.  */
  84       if (!TYPE_HAS_COMPLEX_INIT_REF (type)
  85           || !TYPE_HAS_COMPLEX_ASSIGN_REF (type)
  86           /* But storing a CONSTRUCTOR isn't a copy.  */
  87           || TREE_CODE (exp) == CONSTRUCTOR
  88           /* And, the gimplifier will sometimes make a copy of
  89              an aggregate.  In particular, for a case like:
  90
  91                 struct S { S(); };
  92                 struct X { int a; S s; };
  93                 X x = { 0 };
  94
  95              the gimplifier will create a temporary with
  96              static storage duration, perform static
  97              initialization of the temporary, and then copy
  98              the result.  Since the "s" subobject is never
  99              constructed, this is a valid transformation.  */
 100           || CP_AGGREGATE_TYPE_P (type))
 101         /* This would be wrong for a type with virtual bases.  */
 102         return (is_empty_class (type)
 103                 ? size_zero_node
 104                 : CLASSTYPE_SIZE_UNIT (type));
 105       else
 106         return NULL_TREE;
 107     }
 108   else
 109     /* Use the default code.  */
 110     return lhd_expr_size (exp);
 111 }
 112
 113 /* Langhook for tree_size: determine size of our 'x' and 'c' nodes.  */
 114 size_t
 115 cp_tree_size (enum tree_code code)
 116 {
 117   switch (code)
 118     {
 119     case TINST_LEVEL:           return sizeof (struct tinst_level_s);
 120     case PTRMEM_CST:            return sizeof (struct ptrmem_cst);
 121     case BASELINK:              return sizeof (struct tree_baselink);
 122     case TEMPLATE_PARM_INDEX:   return sizeof (template_parm_index);
 123     case DEFAULT_ARG:           return sizeof (struct tree_default_arg);
 124     case OVERLOAD:              return sizeof (struct tree_overload);
 125     case STATIC_ASSERT:         return sizeof (struct tree_static_assert);
 126     case TYPE_ARGUMENT_PACK:
 127     case TYPE_PACK_EXPANSION:
 128       return sizeof (struct tree_common);
 129
 130     case NONTYPE_ARGUMENT_PACK:
 131     case EXPR_PACK_EXPANSION:
 132       return sizeof (struct tree_exp);
 133
 134     case ARGUMENT_PACK_SELECT:
 135       return sizeof (struct tree_argument_pack_select);
 136
 137     case TRAIT_EXPR:
 138       return sizeof (struct tree_trait_expr);
 139
 140     default:
 141       gcc_unreachable ();
 142     }
 143   /* NOTREACHED */
 144 }
 145
 146 /* Returns true if T is a variably modified type, in the sense of C99.
 147    FN is as passed to variably_modified_p.
 148    This routine needs only check cases that cannot be handled by the
 149    language-independent logic in tree.c.  */
 150
 151 bool
 152 cp_var_mod_type_p (tree type, tree fn)
 153 {
 154   /* If TYPE is a pointer-to-member, it is variably modified if either
 155      the class or the member are variably modified.  */
 156   if (TYPE_PTR_TO_MEMBER_P (type))
 157     return (variably_modified_type_p (TYPE_PTRMEM_CLASS_TYPE (type), fn)
 158             || variably_modified_type_p (TYPE_PTRMEM_POINTED_TO_TYPE (type),
 159                                          fn));
 160
 161   /* All other types are not variably modified.  */
 162   return false;
 163 }
 164
 165 /* Construct a C++-aware pretty-printer for CONTEXT.  It is assumed
 166    that CONTEXT->printer is an already constructed basic pretty_printer.  */
 167 void
 168 cxx_initialize_diagnostics (diagnostic_context *context)
 169 {
 170   pretty_printer *base = context->printer;
 171   cxx_pretty_printer *pp = XNEW (cxx_pretty_printer);
 172   memcpy (pp_base (pp), base, sizeof (pretty_printer));
 173   pp_cxx_pretty_printer_init (pp);
 174   context->printer = (pretty_printer *) pp;
 175
 176   /* It is safe to free this object because it was previously malloc()'d.  */
 177   free (base);
 178 }
 179
 180 /* This compares two types for equivalence ("compatible" in C-based languages).
 181    This routine should only return 1 if it is sure.  It should not be used
 182    in contexts where erroneously returning 0 causes problems.  */
 183
 184 int
 185 cxx_types_compatible_p (tree x, tree y)
 186 {
 187   if (same_type_ignoring_top_level_qualifiers_p (x, y))
 188     return 1;
 189
 190   /* Once we get to the middle-end, references and pointers are
 191      interchangeable.  FIXME should we try to replace all references with
 192      pointers?  */
 193   if (POINTER_TYPE_P (x) && POINTER_TYPE_P (y)
 194       && TYPE_MODE (x) == TYPE_MODE (y)
 195       && TYPE_REF_CAN_ALIAS_ALL (x) == TYPE_REF_CAN_ALIAS_ALL (y)
 196       && same_type_p (TREE_TYPE (x), TREE_TYPE (y)))
 197     return 1;
 198
 199   return 0;
 200 }
 201
 202 tree
 203 cxx_staticp (tree arg)
 204 {
 205   switch (TREE_CODE (arg))
 206     {
 207     case BASELINK:
 208       return staticp (BASELINK_FUNCTIONS (arg));
 209
 210     default:
 211       break;
 212     }
 213
 214   return NULL_TREE;
 215 }
 216
 217 /* Stubs to keep c-opts.c happy.  */
 218 void
 219 push_file_scope (void)
 220 {
 221 }
 222
 223 void
 224 pop_file_scope (void)
 225 {
 226 }
 227
 228 /* c-pragma.c needs to query whether a decl has extern "C" linkage.  */
 229 bool
 230 has_c_linkage (tree decl)
 231 {
 232   return DECL_EXTERN_C_P (decl);
 233 }
 234
 235 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
 236      htab_t shadowed_var_for_decl;
 237
 238 /* Lookup a shadowed var for FROM, and return it if we find one.  */
 239
 240 tree
 241 decl_shadowed_for_var_lookup (tree from)
 242 {
 243   struct tree_map *h, in;
 244   in.base.from = from;
 245
 246   h = (struct tree_map *) htab_find_with_hash (shadowed_var_for_decl, &in,
 247                                                htab_hash_pointer (from));
 248   if (h)
 249     return h->to;
 250   return NULL_TREE;
 251 }
 252
 253 /* Insert a mapping FROM->TO in the shadowed var hashtable.  */
 254
 255 void
 256 decl_shadowed_for_var_insert (tree from, tree to)
 257 {
 258   struct tree_map *h;
 259   void **loc;
 260
 261   h = GGC_NEW (struct tree_map);
 262   h->hash = htab_hash_pointer (from);
 263   h->base.from = from;
 264   h->to = to;
 265   loc = htab_find_slot_with_hash (shadowed_var_for_decl, h, h->hash, INSERT);
 266   *(struct tree_map **) loc = h;
 267 }
 268
 269 void
 270 init_shadowed_var_for_decl (void)
 271 {
 272   shadowed_var_for_decl = htab_create_ggc (512, tree_map_hash,
 273                                            tree_map_eq, 0);
 274 }
 275
 276
 277 #include "gt-cp-cp-objcp-common.h"