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