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