gcc/c/c-objc-common.c

   1 /* Some code common to C and ObjC front ends.
   2    Copyright (C) 2001-2018 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
  31 static bool c_tree_printer (pretty_printer *, text_info *, const char *,
  32                             int, bool, bool, bool, bool *, const char **);
  33
  34 bool
  35 c_missing_noreturn_ok_p (tree decl)
  36 {
  37   /* A missing noreturn is not ok for freestanding implementations and
  38      ok for the `main' function in hosted implementations.  */
  39   return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
  40 }
  41
  42 /* Called from check_global_declaration.  */
  43
  44 bool
  45 c_warn_unused_global_decl (const_tree decl)
  46 {
  47   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
  48     return false;
  49   if (DECL_IN_SYSTEM_HEADER (decl))
  50     return false;
  51
  52   return true;
  53 }
  54
  55 /* Initialization common to C and Objective-C front ends.  */
  56 bool
  57 c_objc_common_init (void)
  58 {
  59   c_init_decl_processing ();
  60
  61   return c_common_init ();
  62 }
  63
  64 /* Called during diagnostic message formatting process to print a
  65    source-level entity onto BUFFER.  The meaning of the format specifiers
  66    is as follows:
  67    %D: a general decl,
  68    %E: an identifier or expression,
  69    %F: a function declaration,
  70    %G: a Gimple call statement,
  71    %K: a CALL_EXPR,
  72    %T: a type.
  73    %V: a list of type qualifiers from a tree.
  74    %v: an explicit list of type qualifiers
  75    %#v: an explicit list of type qualifiers of a function type.
  76
  77    Please notice when called, the `%' part was already skipped by the
  78    diagnostic machinery.  */
  79 static bool
  80 c_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
  81                 int precision, bool wide, bool set_locus, bool hash,
  82                 bool *quoted, const char **)
  83 {
  84   tree t = NULL_TREE;
  85   tree name;
  86   // FIXME: the next cast should be a dynamic_cast, when it is permitted.
  87   c_pretty_printer *cpp = (c_pretty_printer *) pp;
  88   pp->padding = pp_none;
  89
  90   if (precision != 0 || wide)
  91     return false;
  92
  93   if (*spec == 'G')
  94     {
  95       percent_G_format (text);
  96       return true;
  97     }
  98
  99   if (*spec == 'K')
 100     {
 101       t = va_arg (*text->args_ptr, tree);
 102       percent_K_format (text, t);
 103       return true;
 104     }
 105
 106   if (*spec != 'v')
 107     {
 108       t = va_arg (*text->args_ptr, tree);
 109       if (set_locus)
 110         text->set_location (0, DECL_SOURCE_LOCATION (t), true);
 111     }
 112
 113   switch (*spec)
 114     {
 115     case 'D':
 116       if (VAR_P (t) && DECL_HAS_DEBUG_EXPR_P (t))
 117         {
 118           t = DECL_DEBUG_EXPR (t);
 119           if (!DECL_P (t))
 120             {
 121               cpp->expression (t);
 122               return true;
 123             }
 124         }
 125       /* FALLTHRU */
 126
 127     case 'F':
 128       if (DECL_NAME (t))
 129         {
 130           pp_identifier (cpp, lang_hooks.decl_printable_name (t, 2));
 131           return true;
 132         }
 133       break;
 134
 135     case 'T':
 136       {
 137         gcc_assert (TYPE_P (t));
 138         struct obstack *ob = pp_buffer (cpp)->obstack;
 139         char *p = (char *) obstack_base (ob);
 140         /* Remember the end of the initial dump.  */
 141         int len = obstack_object_size (ob);
 142
 143         name = TYPE_NAME (t);
 144         if (name && TREE_CODE (name) == TYPE_DECL && DECL_NAME (name))
 145           pp_identifier (cpp, lang_hooks.decl_printable_name (name, 2));
 146         else
 147           cpp->type_id (t);
 148
 149         /* If we're printing a type that involves typedefs, also print the
 150            stripped version.  But sometimes the stripped version looks
 151            exactly the same, so we don't want it after all.  To avoid
 152            printing it in that case, we play ugly obstack games.  */
 153         if (TYPE_CANONICAL (t) && t != TYPE_CANONICAL (t))
 154           {
 155             c_pretty_printer cpp2;
 156             /* Print the stripped version into a temporary printer.  */
 157             cpp2.type_id (TYPE_CANONICAL (t));
 158             struct obstack *ob2 = cpp2.buffer->obstack;
 159             /* Get the stripped version from the temporary printer.  */
 160             const char *aka = (char *) obstack_base (ob2);
 161             int aka_len = obstack_object_size (ob2);
 162             int type1_len = obstack_object_size (ob) - len;
 163
 164             /* If they are identical, bail out.  */
 165             if (aka_len == type1_len && memcmp (p + len, aka, aka_len) == 0)
 166               return true;
 167
 168             /* They're not, print the stripped version now.  */
 169             if (*quoted)
 170               pp_end_quote (pp, pp_show_color (pp));
 171             pp_c_whitespace (cpp);
 172             pp_left_brace (cpp);
 173             pp_c_ws_string (cpp, _("aka"));
 174             pp_c_whitespace (cpp);
 175             if (*quoted)
 176               pp_begin_quote (pp, pp_show_color (pp));
 177             cpp->type_id (TYPE_CANONICAL (t));
 178             if (*quoted)
 179               pp_end_quote (pp, pp_show_color (pp));
 180             pp_right_brace (cpp);
 181             /* No further closing quotes are needed.  */
 182             *quoted = false;
 183           }
 184         return true;
 185       }
 186
 187     case 'E':
 188       if (TREE_CODE (t) == IDENTIFIER_NODE)
 189         pp_identifier (cpp, IDENTIFIER_POINTER (t));
 190       else
 191         cpp->expression (t);
 192       return true;
 193
 194     case 'V':
 195       pp_c_type_qualifier_list (cpp, t);
 196       return true;
 197
 198     case 'v':
 199       pp_c_cv_qualifiers (cpp, va_arg (*text->args_ptr, int), hash);
 200       return true;
 201
 202     default:
 203       return false;
 204     }
 205
 206   pp_string (cpp, _("({anonymous})"));
 207   return true;
 208 }
 209
 210 /* In C and ObjC, all decls have "C" linkage.  */
 211 bool
 212 has_c_linkage (const_tree decl ATTRIBUTE_UNUSED)
 213 {
 214   return true;
 215 }
 216
 217 void
 218 c_initialize_diagnostics (diagnostic_context *context)
 219 {
 220   pretty_printer *base = context->printer;
 221   c_pretty_printer *pp = XNEW (c_pretty_printer);
 222   context->printer = new (pp) c_pretty_printer ();
 223
 224   /* It is safe to free this object because it was previously XNEW()'d.  */
 225   base->~pretty_printer ();
 226   XDELETE (base);
 227
 228   c_common_diagnostics_set_defaults (context);
 229   diagnostic_format_decoder (context) = &c_tree_printer;
 230 }
 231
 232 int
 233 c_types_compatible_p (tree x, tree y)
 234 {
 235   return comptypes (TYPE_MAIN_VARIANT (x), TYPE_MAIN_VARIANT (y));
 236 }
 237
 238 /* Determine if the type is a vla type for the backend.  */
 239
 240 bool
 241 c_vla_unspec_p (tree x, tree fn ATTRIBUTE_UNUSED)
 242 {
 243   return c_vla_type_p (x);
 244 }