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);
  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 {
  80   tree t = NULL_TREE;
  81   tree name;
  82   // FIXME: the next cast should be a dynamic_cast, when it is permitted.
  83   c_pretty_printer *cpp = (c_pretty_printer *) pp;
  84   pp->padding = pp_none;
  85
  86   if (precision != 0 || wide)
  87     return false;
  88
  89   if (*spec == 'K')
  90     {
  91       percent_K_format (text);
  92       return true;
  93     }
  94
  95   if (*spec != 'v')
  96     {
  97       t = va_arg (*text->args_ptr, tree);
  98       if (set_locus)
  99         text->set_location (0, DECL_SOURCE_LOCATION (t), true);
 100     }
 101
 102   switch (*spec)
 103     {
 104     case 'D':
 105       if (VAR_P (t) && DECL_HAS_DEBUG_EXPR_P (t))
 106         {
 107           t = DECL_DEBUG_EXPR (t);
 108           if (!DECL_P (t))
 109             {
 110               cpp->expression (t);
 111               return true;
 112             }
 113         }
 114       /* FALLTHRU */
 115
 116     case 'F':
 117       if (DECL_NAME (t))
 118         {
 119           pp_identifier (cpp, lang_hooks.decl_printable_name (t, 2));
 120           return true;
 121         }
 122       break;
 123
 124     case 'T':
 125       {
 126         gcc_assert (TYPE_P (t));
 127         struct obstack *ob = pp_buffer (cpp)->obstack;
 128         char *p = (char *) obstack_base (ob);
 129         /* Remember the end of the initial dump.  */
 130         int len = obstack_object_size (ob);
 131
 132         name = TYPE_NAME (t);
 133         if (name && TREE_CODE (name) == TYPE_DECL && DECL_NAME (name))
 134           pp_identifier (cpp, lang_hooks.decl_printable_name (name, 2));
 135         else
 136           cpp->type_id (t);
 137
 138         /* If we're printing a type that involves typedefs, also print the
 139            stripped version.  But sometimes the stripped version looks
 140            exactly the same, so we don't want it after all.  To avoid
 141            printing it in that case, we play ugly obstack games.  */
 142         if (TYPE_CANONICAL (t) && t != TYPE_CANONICAL (t))
 143           {
 144             c_pretty_printer cpp2;
 145             /* Print the stripped version into a temporary printer.  */
 146             cpp2.type_id (TYPE_CANONICAL (t));
 147             struct obstack *ob2 = cpp2.buffer->obstack;
 148             /* Get the stripped version from the temporary printer.  */
 149             const char *aka = (char *) obstack_base (ob2);
 150             int aka_len = obstack_object_size (ob2);
 151             int type1_len = obstack_object_size (ob) - len;
 152
 153             /* If they are identical, bail out.  */
 154             if (aka_len == type1_len && memcmp (p + len, aka, aka_len) == 0)
 155               return true;
 156
 157             /* They're not, print the stripped version now.  */
 158             pp_c_whitespace (cpp);
 159             pp_left_brace (cpp);
 160             pp_c_ws_string (cpp, _("aka"));
 161             pp_c_whitespace (cpp);
 162             cpp->type_id (TYPE_CANONICAL (t));
 163             pp_right_brace (cpp);
 164           }
 165         return true;
 166       }
 167
 168     case 'E':
 169       if (TREE_CODE (t) == IDENTIFIER_NODE)
 170         pp_identifier (cpp, IDENTIFIER_POINTER (t));
 171       else
 172         cpp->expression (t);
 173       return true;
 174
 175     case 'V':
 176       pp_c_type_qualifier_list (cpp, t);
 177       return true;
 178
 179     case 'v':
 180       pp_c_cv_qualifiers (cpp, va_arg (*text->args_ptr, int), hash);
 181       return true;
 182
 183     default:
 184       return false;
 185     }
 186
 187   pp_string (cpp, _("({anonymous})"));
 188   return true;
 189 }
 190
 191 /* In C and ObjC, all decls have "C" linkage.  */
 192 bool
 193 has_c_linkage (const_tree decl ATTRIBUTE_UNUSED)
 194 {
 195   return true;
 196 }
 197
 198 void
 199 c_initialize_diagnostics (diagnostic_context *context)
 200 {
 201   pretty_printer *base = context->printer;
 202   c_pretty_printer *pp = XNEW (c_pretty_printer);
 203   context->printer = new (pp) c_pretty_printer ();
 204
 205   /* It is safe to free this object because it was previously XNEW()'d.  */
 206   base->~pretty_printer ();
 207   XDELETE (base);
 208
 209   c_common_diagnostics_set_defaults (context);
 210   diagnostic_format_decoder (context) = &c_tree_printer;
 211 }
 212
 213 int
 214 c_types_compatible_p (tree x, tree y)
 215 {
 216   return comptypes (TYPE_MAIN_VARIANT (x), TYPE_MAIN_VARIANT (y));
 217 }
 218
 219 /* Determine if the type is a vla type for the backend.  */
 220
 221 bool
 222 c_vla_unspec_p (tree x, tree fn ATTRIBUTE_UNUSED)
 223 {
 224   return c_vla_type_p (x);
 225 }