gcc/c/c-objc-common.c

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