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       || (POINTER_TYPE_P (t)
  49           && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))))
  50     return 0;
  51
  52   return c_common_get_alias_set (t);
  53 }
  54
  55 /* Called from check_global_declarations.  */
  56
  57 bool
  58 cxx_warn_unused_global_decl (const_tree decl)
  59 {
  60   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
  61     return false;
  62   if (DECL_IN_SYSTEM_HEADER (decl))
  63     return false;
  64
  65   /* Const variables take the place of #defines in C++.  */
  66   if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl))
  67     return false;
  68
  69   return true;
  70 }
  71
  72 /* Langhook for expr_size: Tell the back end that the value of an expression
  73    of non-POD class type does not include any tail padding; a derived class
  74    might have allocated something there.  */
  75
  76 tree
  77 cp_expr_size (const_tree exp)
  78 {
  79   tree type = TREE_TYPE (exp);
  80
  81   if (CLASS_TYPE_P (type))
  82     {
  83       /* The back end should not be interested in the size of an expression
  84          of a type with both of these set; all copies of such types must go
  85          through a constructor or assignment op.  */
  86       if (!TYPE_HAS_COMPLEX_INIT_REF (type)
  87           || !TYPE_HAS_COMPLEX_ASSIGN_REF (type)
  88           /* But storing a CONSTRUCTOR isn't a copy.  */
  89           || TREE_CODE (exp) == CONSTRUCTOR
  90           /* And, the gimplifier will sometimes make a copy of
  91              an aggregate.  In particular, for a case like:
  92
  93                 struct S { S(); };
  94                 struct X { int a; S s; };
  95                 X x = { 0 };
  96
  97              the gimplifier will create a temporary with
  98              static storage duration, perform static
  99              initialization of the temporary, and then copy
 100              the result.  Since the "s" subobject is never
 101              constructed, this is a valid transformation.  */
 102           || CP_AGGREGATE_TYPE_P (type))
 103         /* This would be wrong for a type with virtual bases.  */
 104         return (is_empty_class (type)
 105                 ? size_zero_node
 106                 : CLASSTYPE_SIZE_UNIT (type));
 107       else
 108         return NULL_TREE;
 109     }
 110   else
 111     /* Use the default code.  */
 112     return lhd_expr_size (exp);
 113 }
 114
 115 /* Langhook for tree_size: determine size of our 'x' and 'c' nodes.  */
 116 size_t
 117 cp_tree_size (enum tree_code code)
 118 {
 119   switch (code)
 120     {
 121     case PTRMEM_CST:            return sizeof (struct ptrmem_cst);
 122     case BASELINK:              return sizeof (struct tree_baselink);
 123     case TEMPLATE_PARM_INDEX:   return sizeof (template_parm_index);
 124     case DEFAULT_ARG:           return sizeof (struct tree_default_arg);
 125     case OVERLOAD:              return sizeof (struct tree_overload);
 126     case STATIC_ASSERT:         return sizeof (struct tree_static_assert);
 127     case TYPE_ARGUMENT_PACK:
 128     case TYPE_PACK_EXPANSION:
 129       return sizeof (struct tree_common);
 130
 131     case NONTYPE_ARGUMENT_PACK:
 132     case EXPR_PACK_EXPANSION:
 133       return sizeof (struct tree_exp);
 134
 135     case ARGUMENT_PACK_SELECT:
 136       return sizeof (struct tree_argument_pack_select);
 137
 138     case TRAIT_EXPR:
 139       return sizeof (struct tree_trait_expr);
 140
 141     default:
 142       gcc_unreachable ();
 143     }
 144   /* NOTREACHED */
 145 }
 146
 147 /* Returns true if T is a variably modified type, in the sense of C99.
 148    FN is as passed to variably_modified_p.
 149    This routine needs only check cases that cannot be handled by the
 150    language-independent logic in tree.c.  */
 151
 152 bool
 153 cp_var_mod_type_p (tree type, tree fn)
 154 {
 155   /* If TYPE is a pointer-to-member, it is variably modified if either
 156      the class or the member are variably modified.  */
 157   if (TYPE_PTR_TO_MEMBER_P (type))
 158     return (variably_modified_type_p (TYPE_PTRMEM_CLASS_TYPE (type), fn)
 159             || variably_modified_type_p (TYPE_PTRMEM_POINTED_TO_TYPE (type),
 160                                          fn));
 161
 162   /* All other types are not variably modified.  */
 163   return false;
 164 }
 165
 166 /* Construct a C++-aware pretty-printer for CONTEXT.  It is assumed
 167    that CONTEXT->printer is an already constructed basic pretty_printer.  */
 168 void
 169 cxx_initialize_diagnostics (diagnostic_context *context)
 170 {
 171   pretty_printer *base = context->printer;
 172   cxx_pretty_printer *pp = XNEW (cxx_pretty_printer);
 173   memcpy (pp_base (pp), base, sizeof (pretty_printer));
 174   pp_cxx_pretty_printer_init (pp);
 175   context->printer = (pretty_printer *) pp;
 176
 177   /* It is safe to free this object because it was previously malloc()'d.  */
 178   free (base);
 179 }
 180
 181 /* This compares two types for equivalence ("compatible" in C-based languages).
 182    This routine should only return 1 if it is sure.  It should not be used
 183    in contexts where erroneously returning 0 causes problems.  */
 184
 185 int
 186 cxx_types_compatible_p (tree x, tree y)
 187 {
 188   return same_type_ignoring_top_level_qualifiers_p (x, y);
 189 }
 190
 191 tree
 192 cxx_staticp (tree arg)
 193 {
 194   switch (TREE_CODE (arg))
 195     {
 196     case BASELINK:
 197       return staticp (BASELINK_FUNCTIONS (arg));
 198
 199     default:
 200       break;
 201     }
 202
 203   return NULL_TREE;
 204 }
 205
 206 /* Stubs to keep c-opts.c happy.  */
 207 void
 208 push_file_scope (void)
 209 {
 210 }
 211
 212 void
 213 pop_file_scope (void)
 214 {
 215 }
 216
 217 /* c-pragma.c needs to query whether a decl has extern "C" linkage.  */
 218 bool
 219 has_c_linkage (const_tree decl)
 220 {
 221   return DECL_EXTERN_C_P (decl);
 222 }
 223
 224 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
 225      htab_t shadowed_var_for_decl;
 226
 227 /* Lookup a shadowed var for FROM, and return it if we find one.  */
 228
 229 tree
 230 decl_shadowed_for_var_lookup (tree from)
 231 {
 232   struct tree_map *h, in;
 233   in.base.from = from;
 234
 235   h = (struct tree_map *) htab_find_with_hash (shadowed_var_for_decl, &in,
 236                                                htab_hash_pointer (from));
 237   if (h)
 238     return h->to;
 239   return NULL_TREE;
 240 }
 241
 242 /* Insert a mapping FROM->TO in the shadowed var hashtable.  */
 243
 244 void
 245 decl_shadowed_for_var_insert (tree from, tree to)
 246 {
 247   struct tree_map *h;
 248   void **loc;
 249
 250   h = GGC_NEW (struct tree_map);
 251   h->hash = htab_hash_pointer (from);
 252   h->base.from = from;
 253   h->to = to;
 254   loc = htab_find_slot_with_hash (shadowed_var_for_decl, h, h->hash, INSERT);
 255   *(struct tree_map **) loc = h;
 256 }
 257
 258 void
 259 init_shadowed_var_for_decl (void)
 260 {
 261   shadowed_var_for_decl = htab_create_ggc (512, tree_map_hash,
 262                                            tree_map_eq, 0);
 263 }
 264
 265
 266 #include "gt-cp-cp-objcp-common.h"