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