gcc/c/c-objc-common.c

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