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