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