1 /* Language-dependent hooks for C++. 2 Copyright (C) 2001-2015 Free Software Foundation, Inc. 3 Contributed by Alexandre Oliva <aoliva@redhat.com> 4 5 This file is part of GCC. 6 7 GCC 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 3, or (at your option) 10 any later version. 11 12 GCC 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 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 "hash-set.h" 26 #include "machmode.h" 27 #include "vec.h" 28 #include "double-int.h" 29 #include "input.h" 30 #include "alias.h" 31 #include "symtab.h" 32 #include "wide-int.h" 33 #include "inchash.h" 34 #include "tree.h" 35 #include "stor-layout.h" 36 #include "cp-tree.h" 37 #include "c-family/c-common.h" 38 #include "langhooks.h" 39 #include "langhooks-def.h" 40 #include "debug.h" 41 #include "cp-objcp-common.h" 42 #include "hashtab.h" 43 #include "target.h" 44 #include "parser.h" 45 46 enum c_language_kind c_language = clk_cxx; 47 static void cp_init_ts (void); 48 static const char * cxx_dwarf_name (tree t, int verbosity); 49 static enum classify_record cp_classify_record (tree type); 50 static tree cp_eh_personality (void); 51 static tree get_template_innermost_arguments_folded (const_tree); 52 static tree get_template_argument_pack_elems_folded (const_tree); 53 static tree cxx_enum_underlying_base_type (const_tree); 54 55 /* Lang hooks common to C++ and ObjC++ are declared in cp/cp-objcp-common.h; 56 consequently, there should be very few hooks below. */ 57 58 #undef LANG_HOOKS_NAME 59 #define LANG_HOOKS_NAME "GNU C++" 60 #undef LANG_HOOKS_INIT 61 #define LANG_HOOKS_INIT cxx_init 62 #undef LANG_HOOKS_CLASSIFY_RECORD 63 #define LANG_HOOKS_CLASSIFY_RECORD cp_classify_record 64 #undef LANG_HOOKS_GENERIC_TYPE_P 65 #define LANG_HOOKS_GENERIC_TYPE_P class_tmpl_impl_spec_p 66 67 #undef LANG_HOOKS_GET_INNERMOST_GENERIC_PARMS 68 #define LANG_HOOKS_GET_INNERMOST_GENERIC_PARMS \ 69 get_primary_template_innermost_parameters 70 #undef LANG_HOOKS_GET_INNERMOST_GENERIC_ARGS 71 #define LANG_HOOKS_GET_INNERMOST_GENERIC_ARGS \ 72 get_template_innermost_arguments_folded 73 #undef LANG_HOOKS_FUNCTION_PARAMETER_PACK_P 74 #define LANG_HOOKS_FUNCTION_PARAMETER_PACK_P \ 75 function_parameter_pack_p 76 #undef LANG_HOOKS_GET_ARGUMENT_PACK_ELEMS 77 #define LANG_HOOKS_GET_ARGUMENT_PACK_ELEMS \ 78 get_template_argument_pack_elems_folded 79 #undef LANG_HOOKS_GENERIC_GENERIC_PARAMETER_DECL_P 80 #define LANG_HOOKS_GENERIC_GENERIC_PARAMETER_DECL_P \ 81 template_template_parameter_p 82 #undef LANG_HOOKS_FUNCTION_PARM_EXPANDED_FROM_PACK_P 83 #define LANG_HOOKS_FUNCTION_PARM_EXPANDED_FROM_PACK_P \ 84 function_parameter_expanded_from_pack_p 85 #undef LANG_HOOKS_GET_GENERIC_FUNCTION_DECL 86 #define LANG_HOOKS_GET_GENERIC_FUNCTION_DECL get_function_template_decl 87 #undef LANG_HOOKS_DWARF_NAME 88 #define LANG_HOOKS_DWARF_NAME cxx_dwarf_name 89 #undef LANG_HOOKS_INIT_TS 90 #define LANG_HOOKS_INIT_TS cp_init_ts 91 #undef LANG_HOOKS_EH_PERSONALITY 92 #define LANG_HOOKS_EH_PERSONALITY cp_eh_personality 93 #undef LANG_HOOKS_EH_RUNTIME_TYPE 94 #define LANG_HOOKS_EH_RUNTIME_TYPE build_eh_type_type 95 #undef LANG_HOOKS_ENUM_UNDERLYING_BASE_TYPE 96 #define LANG_HOOKS_ENUM_UNDERLYING_BASE_TYPE cxx_enum_underlying_base_type 97 98 /* Each front end provides its own lang hook initializer. */ 99 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER; 100 101 /* Lang hook routines common to C++ and ObjC++ appear in cp/cp-objcp-common.c; 102 there should be very few routines below. */ 103 104 /* The following function does something real, but only in Objective-C++. */ 105 106 tree 107 objcp_tsubst_copy_and_build (tree /*t*/, 108 tree /*args*/, 109 tsubst_flags_t /*complain*/, 110 tree /*in_decl*/, 111 bool /*function_p*/) 112 { 113 return NULL_TREE; 114 } 115 116 static void 117 cp_init_ts (void) 118 { 119 cp_common_init_ts (); 120 121 init_shadowed_var_for_decl (); 122 } 123 124 static const char * 125 cxx_dwarf_name (tree t, int verbosity) 126 { 127 gcc_assert (DECL_P (t)); 128 129 if (DECL_NAME (t) 130 && (ANON_AGGRNAME_P (DECL_NAME (t)) || LAMBDA_TYPE_P (t))) 131 return NULL; 132 if (verbosity >= 2) 133 return decl_as_dwarf_string (t, 134 TFF_DECL_SPECIFIERS | TFF_UNQUALIFIED_NAME 135 | TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS); 136 137 return lang_decl_dwarf_name (t, verbosity, false); 138 } 139 140 static enum classify_record 141 cp_classify_record (tree type) 142 { 143 if (TYPE_LANG_SPECIFIC (type) 144 && CLASSTYPE_DECLARED_CLASS (type)) 145 return RECORD_IS_CLASS; 146 147 return RECORD_IS_STRUCT; 148 } 149 150 static GTY(()) tree cp_eh_personality_decl; 151 152 static tree 153 cp_eh_personality (void) 154 { 155 if (!cp_eh_personality_decl) 156 { 157 const char *lang = (pragma_java_exceptions ? "gcj" : "gxx"); 158 cp_eh_personality_decl = build_personality_function (lang); 159 } 160 161 return cp_eh_personality_decl; 162 } 163 164 /* This is a subroutine of fold_cplus_constants. It returns TRUE if T 165 is a C++ specific constant that needs to be folded further before 166 being passed to the debug info emitter. */ 167 168 static bool 169 template_arg_needs_folding (const_tree t) 170 { 171 /* For now only PTRMEM_CST nodes are to be folded further. */ 172 if (TREE_CODE (t) == PTRMEM_CST) 173 return true; 174 return false; 175 } 176 177 /* Fold the elements of the TREE_VEC C which are C++ specific nodes 178 that would need folding so that they can be processed by the debug 179 info emitter. This is a subroutine of 180 get_template_innermost_arguments_folded and 181 get_template_argument_pack_elems_folded. */ 182 183 static tree 184 fold_cplus_constants (const_tree c) 185 { 186 tree folded_elems, elems = CONST_CAST_TREE (c); 187 int vec_len, i; 188 189 if (elems == NULL_TREE || elems == error_mark_node) 190 return elems; 191 192 vec_len = TREE_VEC_LENGTH (elems); 193 194 /* First check if there is at least one element that needs 195 folding. If there is none, we just return ELEMS. Otherwise create 196 and return a new tree vector that contains the folded versions of 197 ELEMS. This is to avoid allocating memory if we don't need 198 to. */ 199 for (i = 0; i < vec_len; ++i) 200 { 201 if (template_arg_needs_folding (TREE_VEC_ELT (elems, i))) 202 break; 203 } 204 if (i == vec_len) 205 return elems; 206 207 folded_elems = make_tree_vec (vec_len); 208 for (i = 0; i < vec_len; ++i) 209 { 210 tree elem = TREE_VEC_ELT (elems, i); 211 TREE_VEC_ELT (folded_elems, i) = 212 (elem && !TYPE_P (elem)) ? cplus_expand_constant (elem) : elem; 213 214 } 215 return folded_elems; 216 } 217 218 /* The C++ implementation of the LANG_HOOKS_GET_INNERMOST_GENERIC_ARGS 219 hook. It returns the innermost template arguments of type T, and 220 makes sure those arguments are folded enough for the debug info 221 emitter. */ 222 223 static tree 224 get_template_innermost_arguments_folded (const_tree t) 225 { 226 return fold_cplus_constants (get_template_innermost_arguments (t)); 227 } 228 229 static tree 230 get_template_argument_pack_elems_folded (const_tree t) 231 { 232 return fold_cplus_constants (get_template_argument_pack_elems (t)); 233 } 234 235 /* The C++ version of the enum_underlying_base_type langhook. 236 See also cp/semantics.c (finish_underlying_type). */ 237 238 static 239 tree cxx_enum_underlying_base_type (const_tree type) 240 { 241 tree underlying_type = ENUM_UNDERLYING_TYPE (type); 242 243 if (! ENUM_FIXED_UNDERLYING_TYPE_P (type)) 244 underlying_type 245 = c_common_type_for_mode (TYPE_MODE (underlying_type), 246 TYPE_UNSIGNED (underlying_type)); 247 248 return underlying_type; 249 } 250 251 #include "gt-cp-cp-lang.h" 252 #include "gtype-cp.h" 253