gcc/c/c-objc-common.c

   1 /* Some code common to C and ObjC front ends.
   2    Copyright (C) 2001-2020 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "c-tree.h"
  24 #include "intl.h"
  25 #include "c-family/c-pretty-print.h"
  26 #include "tree-pretty-print.h"
  27 #include "gimple-pretty-print.h"
  28 #include "langhooks.h"
  29 #include "c-objc-common.h"
  30 #include "gcc-rich-location.h"
  31 #include "stringpool.h"
  32 #include "attribs.h"
  33
  34 static bool c_tree_printer (pretty_printer *, text_info *, const char *,
  35                             int, bool, bool, bool, bool *, const char **);
  36
  37 bool
  38 c_missing_noreturn_ok_p (tree decl)
  39 {
  40   /* A missing noreturn is not ok for freestanding implementations and
  41      ok for the `main' function in hosted implementations.  */
  42   return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
  43 }
  44
  45 /* Called from check_global_declaration.  */
  46
  47 bool
  48 c_warn_unused_global_decl (const_tree decl)
  49 {
  50   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
  51     return false;
  52   if (DECL_IN_SYSTEM_HEADER (decl))
  53     return false;
  54
  55   return true;
  56 }
  57
  58 /* Initialization common to C and Objective-C front ends.  */
  59 bool
  60 c_objc_common_init (void)
  61 {
  62   c_init_decl_processing ();
  63
  64   return c_common_init ();
  65 }
  66
  67 /* Decide whether it's worth saying that TYPE is also known as some other
  68    type.  Return the other type if so, otherwise return TYPE.  */
  69
  70 static tree
  71 get_aka_type (tree type)
  72 {
  73   if (type == error_mark_node)
  74     return type;
  75
  76   tree result;
  77   if (typedef_variant_p (type))
  78     {
  79       /* Saying that "foo" is also known as "struct foo" or
  80          "struct <anonymous>" is unlikely to be useful, since users of
  81          structure-like types would already know that they're structures.
  82          The same applies to unions and enums; in general, printing the
  83          tag is only useful if it has a different name.  */
  84       tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
  85       tree_code code = TREE_CODE (orig_type);
  86       tree orig_id = TYPE_IDENTIFIER (orig_type);
  87       if ((code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
  88           && (!orig_id || TYPE_IDENTIFIER (type) == orig_id))
  89         return type;
  90
  91       if (!user_facing_original_type_p (type))
  92         return type;
  93
  94       result = get_aka_type (orig_type);
  95     }
  96   else
  97     {
  98       tree canonical = TYPE_CANONICAL (type);
  99       if (canonical && TREE_CODE (type) != TREE_CODE (canonical))
 100         return canonical;
 101
 102       /* Recursive calls might choose a middle ground between TYPE
 103          (which has no typedefs stripped) and CANONICAL (which has
 104          all typedefs stripped).  So try to reuse TYPE or CANONICAL if
 105          convenient, but be prepared to create a new type if necessary.  */
 106       switch (TREE_CODE (type))
 107         {
 108         case POINTER_TYPE:
 109         case REFERENCE_TYPE:
 110           {
 111             tree target_type = get_aka_type (TREE_TYPE (type));
 112
 113             if (target_type == TREE_TYPE (type))
 114               return type;
 115
 116             if (canonical && target_type == TREE_TYPE (canonical))
 117               return canonical;
 118
 119             result = (TREE_CODE (type) == POINTER_TYPE
 120                       ? build_pointer_type (target_type)
 121                       : build_reference_type (target_type));
 122             break;
 123           }
 124
 125         case ARRAY_TYPE:
 126           {
 127             tree element_type = get_aka_type (TREE_TYPE (type));
 128             tree index_type = (TYPE_DOMAIN (type)
 129                                ? get_aka_type (TYPE_DOMAIN (type))
 130                                : NULL_TREE);
 131
 132             if (element_type == TREE_TYPE (type)
 133                 && index_type == TYPE_DOMAIN (type))
 134               return type;
 135
 136             if (canonical
 137                 && element_type == TREE_TYPE (canonical)
 138                 && index_type == TYPE_DOMAIN (canonical))
 139               return canonical;
 140
 141             result = build_array_type (element_type, index_type,
 142                                        TYPE_TYPELESS_STORAGE (type));
 143             break;
 144           }
 145
 146         case FUNCTION_TYPE:
 147           {
 148             tree return_type = get_aka_type (TREE_TYPE (type));
 149
 150             tree args = TYPE_ARG_TYPES (type);
 151             if (args == error_mark_node)
 152               return type;
 153
 154             auto_vec<tree, 32> arg_types;
 155             bool type_ok_p = true;
 156             while (args && args != void_list_node)
 157               {
 158                 tree arg_type = get_aka_type (TREE_VALUE (args));
 159                 arg_types.safe_push (arg_type);
 160                 type_ok_p &= (arg_type == TREE_VALUE (args));
 161                 args = TREE_CHAIN (args);
 162               }
 163
 164             if (type_ok_p && return_type == TREE_TYPE (type))
 165               return type;
 166
 167             unsigned int i;
 168             tree arg_type;
 169             FOR_EACH_VEC_ELT_REVERSE (arg_types, i, arg_type)
 170               args = tree_cons (NULL_TREE, arg_type, args);
 171             result = build_function_type (return_type, args);
 172             break;
 173           }
 174
 175         default:
 176           return canonical ? canonical : type;
 177         }
 178     }
 179   return build_type_attribute_qual_variant (result, TYPE_ATTRIBUTES (type),
 180                                             TYPE_QUALS (type));
 181 }
 182
 183 /* Print T to CPP.  */
 184
 185 static void
 186 print_type (c_pretty_printer *cpp, tree t, bool *quoted)
 187 {
 188   gcc_assert (TYPE_P (t));
 189   struct obstack *ob = pp_buffer (cpp)->obstack;
 190   char *p = (char *) obstack_base (ob);
 191   /* Remember the end of the initial dump.  */
 192   int len = obstack_object_size (ob);
 193
 194   tree name = TYPE_NAME (t);
 195   if (name && TREE_CODE (name) == TYPE_DECL && DECL_NAME (name))
 196     pp_identifier (cpp, lang_hooks.decl_printable_name (name, 2));
 197   else
 198     cpp->type_id (t);
 199
 200   /* If we're printing a type that involves typedefs, also print the
 201      stripped version.  But sometimes the stripped version looks
 202      exactly the same, so we don't want it after all.  To avoid
 203      printing it in that case, we play ugly obstack games.  */
 204   tree aka_type = get_aka_type (t);
 205   if (aka_type != t)
 206     {
 207       c_pretty_printer cpp2;
 208       /* Print the stripped version into a temporary printer.  */
 209       cpp2.type_id (aka_type);
 210       struct obstack *ob2 = cpp2.buffer->obstack;
 211       /* Get the stripped version from the temporary printer.  */
 212       const char *aka = (char *) obstack_base (ob2);
 213       int aka_len = obstack_object_size (ob2);
 214       int type1_len = obstack_object_size (ob) - len;
 215
 216       /* If they are identical, bail out.  */
 217       if (aka_len == type1_len && memcmp (p + len, aka, aka_len) == 0)
 218         return;
 219
 220       /* They're not, print the stripped version now.  */
 221       if (*quoted)
 222         pp_end_quote (cpp, pp_show_color (cpp));
 223       pp_c_whitespace (cpp);
 224       pp_left_brace (cpp);
 225       pp_c_ws_string (cpp, _("aka"));
 226       pp_c_whitespace (cpp);
 227       if (*quoted)
 228         pp_begin_quote (cpp, pp_show_color (cpp));
 229       cpp->type_id (aka_type);
 230       if (*quoted)
 231         pp_end_quote (cpp, pp_show_color (cpp));
 232       pp_right_brace (cpp);
 233       /* No further closing quotes are needed.  */
 234       *quoted = false;
 235     }
 236 }
 237
 238 /* Called during diagnostic message formatting process to print a
 239    source-level entity onto BUFFER.  The meaning of the format specifiers
 240    is as follows:
 241    %D: a general decl,
 242    %E: an identifier or expression,
 243    %F: a function declaration,
 244    %G: a Gimple statement,
 245    %K: a CALL_EXPR,
 246    %T: a type.
 247    %V: a list of type qualifiers from a tree.
 248    %v: an explicit list of type qualifiers
 249    %#v: an explicit list of type qualifiers of a function type.
 250
 251    Please notice when called, the `%' part was already skipped by the
 252    diagnostic machinery.  */
 253 static bool
 254 c_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
 255                 int precision, bool wide, bool set_locus, bool hash,
 256                 bool *quoted, const char **)
 257 {
 258   tree t = NULL_TREE;
 259   // FIXME: the next cast should be a dynamic_cast, when it is permitted.
 260   c_pretty_printer *cpp = (c_pretty_printer *) pp;
 261   pp->padding = pp_none;
 262
 263   if (precision != 0 || wide)
 264     return false;
 265
 266   if (*spec == 'G')
 267     {
 268       percent_G_format (text);
 269       return true;
 270     }
 271
 272   if (*spec == 'K')
 273     {
 274       t = va_arg (*text->args_ptr, tree);
 275       percent_K_format (text, EXPR_LOCATION (t), TREE_BLOCK (t));
 276       return true;
 277     }
 278
 279   if (*spec != 'v')
 280     {
 281       t = va_arg (*text->args_ptr, tree);
 282       if (set_locus)
 283         text->set_location (0, DECL_SOURCE_LOCATION (t),
 284                             SHOW_RANGE_WITH_CARET);
 285     }
 286
 287   switch (*spec)
 288     {
 289     case 'D':
 290       if (VAR_P (t) && DECL_HAS_DEBUG_EXPR_P (t))
 291         {
 292           t = DECL_DEBUG_EXPR (t);
 293           if (!DECL_P (t))
 294             {
 295               cpp->expression (t);
 296               return true;
 297             }
 298         }
 299       /* FALLTHRU */
 300
 301     case 'F':
 302       if (DECL_NAME (t))
 303         {
 304           pp_identifier (cpp, lang_hooks.decl_printable_name (t, 2));
 305           return true;
 306         }
 307       break;
 308
 309     case 'T':
 310       print_type (cpp, t, quoted);
 311       return true;
 312
 313     case 'E':
 314       if (TREE_CODE (t) == IDENTIFIER_NODE)
 315         pp_identifier (cpp, IDENTIFIER_POINTER (t));
 316       else
 317         cpp->expression (t);
 318       return true;
 319
 320     case 'V':
 321       pp_c_type_qualifier_list (cpp, t);
 322       return true;
 323
 324     case 'v':
 325       pp_c_cv_qualifiers (cpp, va_arg (*text->args_ptr, int), hash);
 326       return true;
 327
 328     default:
 329       return false;
 330     }
 331
 332   pp_string (cpp, _("({anonymous})"));
 333   return true;
 334 }
 335
 336 /* C-specific implementation of range_label::get_text () vfunc for
 337    range_label_for_type_mismatch.  */
 338
 339 label_text
 340 range_label_for_type_mismatch::get_text (unsigned /*range_idx*/) const
 341 {
 342   if (m_labelled_type == NULL_TREE)
 343     return label_text::borrow (NULL);
 344
 345   c_pretty_printer cpp;
 346   bool quoted = false;
 347   print_type (&cpp, m_labelled_type, &quoted);
 348   return label_text::take (xstrdup (pp_formatted_text (&cpp)));
 349 }
 350
 351
 352 /* In C and ObjC, all decls have "C" linkage.  */
 353 bool
 354 has_c_linkage (const_tree decl ATTRIBUTE_UNUSED)
 355 {
 356   return true;
 357 }
 358
 359 void
 360 c_initialize_diagnostics (diagnostic_context *context)
 361 {
 362   pretty_printer *base = context->printer;
 363   c_pretty_printer *pp = XNEW (c_pretty_printer);
 364   context->printer = new (pp) c_pretty_printer ();
 365
 366   /* It is safe to free this object because it was previously XNEW()'d.  */
 367   base->~pretty_printer ();
 368   XDELETE (base);
 369
 370   c_common_diagnostics_set_defaults (context);
 371   diagnostic_format_decoder (context) = &c_tree_printer;
 372 }
 373
 374 int
 375 c_types_compatible_p (tree x, tree y)
 376 {
 377   return comptypes (TYPE_MAIN_VARIANT (x), TYPE_MAIN_VARIANT (y));
 378 }
 379
 380 /* Determine if the type is a vla type for the backend.  */
 381
 382 bool
 383 c_vla_unspec_p (tree x, tree fn ATTRIBUTE_UNUSED)
 384 {
 385   return c_vla_type_p (x);
 386 }
 387
 388 /* Special routine to get the alias set of T for C.  */
 389
 390 alias_set_type
 391 c_get_alias_set (tree t)
 392 {
 393   /* Allow aliasing between enumeral types and the underlying
 394      integer type.  This is required since those are compatible types.  */
 395   if (TREE_CODE (t) == ENUMERAL_TYPE)
 396     {
 397       tree t1 = c_common_type_for_size (tree_to_uhwi (TYPE_SIZE (t)),
 398                                         /* short-cut commoning to signed
 399                                            type.  */
 400                                         false);
 401       return get_alias_set (t1);
 402     }
 403
 404   return c_common_get_alias_set (t);
 405 }