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 "tree-upc.h"
  34 #include "c-tree.h"
  35 #include "intl.h"
  36 #include "c-family/c-pretty-print.h"
  37 #include "diagnostic.h"
  38 #include "tree-pretty-print.h"
  39 #include "langhooks.h"
  40 #include "c-objc-common.h"
  41 #include "c-upc-lang.h"
  42 #include "c-family/c-upc.h"
  43
  44 #include <new>                          // For placement new.
  45
  46 static bool c_tree_printer (pretty_printer *, text_info *, const char *,
  47                             int, bool, bool, bool);
  48
  49 bool
  50 c_missing_noreturn_ok_p (tree decl)
  51 {
  52   /* A missing noreturn is not ok for freestanding implementations and
  53      ok for the `main' function in hosted implementations.  */
  54   return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
  55 }
  56
  57 /* Called from check_global_declarations.  */
  58
  59 bool
  60 c_warn_unused_global_decl (const_tree decl)
  61 {
  62   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
  63     return false;
  64   if (DECL_IN_SYSTEM_HEADER (decl))
  65     return false;
  66
  67   return true;
  68 }
  69
  70 /* Initialization common to C and Objective-C front ends.  */
  71 bool
  72 c_objc_common_init (void)
  73 {
  74   c_init_decl_processing ();
  75
  76   if (c_common_init () == false)
  77     return false;
  78
  79   if (flag_upc)
  80     upc_lang_init ();
  81
  82   return true;
  83
  84 }
  85
  86 /* Called during diagnostic message formatting process to print a
  87    source-level entity onto BUFFER.  The meaning of the format specifiers
  88    is as follows:
  89    %D: a general decl,
  90    %E: an identifier or expression,
  91    %F: a function declaration,
  92    %T: a type.
  93    %V: a list of type qualifiers from a tree.
  94    %v: an explicit list of type qualifiers
  95    %#v: an explicit list of type qualifiers of a function type.
  96
  97    Please notice when called, the `%' part was already skipped by the
  98    diagnostic machinery.  */
  99 static bool
 100 c_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
 101                 int precision, bool wide, bool set_locus, bool hash)
 102 {
 103   tree t = NULL_TREE;
 104   tree name;
 105   // FIXME: the next cast should be a dynamic_cast, when it is permitted.
 106   c_pretty_printer *cpp = (c_pretty_printer *) pp;
 107   pp->padding = pp_none;
 108
 109   if (precision != 0 || wide)
 110     return false;
 111
 112   if (*spec == 'K')
 113     {
 114       percent_K_format (text);
 115       return true;
 116     }
 117
 118   if (*spec != 'v')
 119     {
 120       t = va_arg (*text->args_ptr, tree);
 121       if (set_locus && text->locus)
 122         *text->locus = DECL_SOURCE_LOCATION (t);
 123     }
 124
 125   switch (*spec)
 126     {
 127     case 'D':
 128       if (TREE_CODE (t) == VAR_DECL && DECL_HAS_DEBUG_EXPR_P (t))
 129         {
 130           t = DECL_DEBUG_EXPR (t);
 131           if (!DECL_P (t))
 132             {
 133               cpp->expression (t);
 134               return true;
 135             }
 136         }
 137       /* FALLTHRU */
 138
 139     case 'F':
 140       if (DECL_NAME (t))
 141         {
 142           pp_identifier (cpp, lang_hooks.decl_printable_name (t, 2));
 143           return true;
 144         }
 145       break;
 146
 147     case 'T':
 148       {
 149         gcc_assert (TYPE_P (t));
 150         struct obstack *ob = pp_buffer (cpp)->obstack;
 151         char *p = (char *) obstack_base (ob);
 152         /* Remember the end of the initial dump.  */
 153         int len = obstack_object_size (ob);
 154
 155         name = TYPE_NAME (t);
 156         if (name && TREE_CODE (name) == TYPE_DECL && DECL_NAME (name))
 157           pp_identifier (cpp, lang_hooks.decl_printable_name (name, 2));
 158         else
 159           cpp->type_id (t);
 160
 161         /* If we're printing a type that involves typedefs, also print the
 162            stripped version.  But sometimes the stripped version looks
 163            exactly the same, so we don't want it after all.  To avoid
 164            printing it in that case, we play ugly obstack games.  */
 165         if (TYPE_CANONICAL (t) && t != TYPE_CANONICAL (t))
 166           {
 167             c_pretty_printer cpp2;
 168             /* Print the stripped version into a temporary printer.  */
 169             cpp2.type_id (TYPE_CANONICAL (t));
 170             struct obstack *ob2 = cpp2.buffer->obstack;
 171             /* Get the stripped version from the temporary printer.  */
 172             const char *aka = (char *) obstack_base (ob2);
 173             int aka_len = obstack_object_size (ob2);
 174             int type1_len = obstack_object_size (ob) - len;
 175
 176             /* If they are identical, bail out.  */
 177             if (aka_len == type1_len && memcmp (p + len, aka, aka_len) == 0)
 178               return true;
 179
 180             /* They're not, print the stripped version now.  */
 181             pp_c_whitespace (cpp);
 182             pp_left_brace (cpp);
 183             pp_c_ws_string (cpp, _("aka"));
 184             pp_c_whitespace (cpp);
 185             cpp->type_id (TYPE_CANONICAL (t));
 186             pp_right_brace (cpp);
 187           }
 188         return true;
 189       }
 190
 191     case 'E':
 192       if (TREE_CODE (t) == IDENTIFIER_NODE)
 193         pp_identifier (cpp, IDENTIFIER_POINTER (t));
 194       else
 195         cpp->expression (t);
 196       return true;
 197
 198     case 'V':
 199       pp_c_type_qualifier_list (cpp, t);
 200       return true;
 201
 202     case 'v':
 203       pp_c_cv_qualifiers (cpp, va_arg (*text->args_ptr, int), hash);
 204       return true;
 205
 206     default:
 207       return false;
 208     }
 209
 210   pp_string (cpp, _("({anonymous})"));
 211   return true;
 212 }
 213
 214 /* In C and ObjC, all decls have "C" linkage.  */
 215 bool
 216 has_c_linkage (const_tree decl ATTRIBUTE_UNUSED)
 217 {
 218   return true;
 219 }
 220
 221 void
 222 c_initialize_diagnostics (diagnostic_context *context)
 223 {
 224   pretty_printer *base = context->printer;
 225   c_pretty_printer *pp = XNEW (c_pretty_printer);
 226   context->printer = new (pp) c_pretty_printer ();
 227
 228   /* It is safe to free this object because it was previously XNEW()'d.  */
 229   base->~pretty_printer ();
 230   XDELETE (base);
 231
 232   c_common_diagnostics_set_defaults (context);
 233   diagnostic_format_decoder (context) = &c_tree_printer;
 234 }
 235
 236 /* Check for the possible need to convert UPC-specific types.  */
 237
 238 static int
 239 upc_types_compatible_p (tree x, tree y)
 240 {
 241   if (POINTER_TYPE_P (x) && POINTER_TYPE_P (y))
 242     {
 243       const tree ttx = TREE_TYPE (x);
 244       const tree tty = TREE_TYPE (y);
 245       if (upc_shared_type_p (ttx) && upc_shared_type_p (tty))
 246         {
 247           tree bx, by, sx, sy;
 248           int x_has_zero_phase, y_has_zero_phase;
 249           int result;
 250           /* If both types are generic UPC pointers-to-shared,
 251              then they're compatible.  */
 252           if (VOID_TYPE_P (ttx) && VOID_TYPE_P (tty))
 253             return 1;
 254           /* Intermediate conversions to (shared void *) (defined
 255              to be a "generic pointer-to-shared" in the UPC
 256              specification) cannot always be optimized away.
 257              For example,
 258                p1 = (shared void *) p2;
 259              preserves the phase of p2, when assigning to p1.
 260              We need to be conservative, and not consider conversions
 261              involving a generic UPC pointer-to-shared value to be
 262              equivalent.  */
 263           if (VOID_TYPE_P (ttx) != VOID_TYPE_P (tty))
 264             return 0;
 265           bx = upc_get_block_factor (ttx);
 266           by = upc_get_block_factor (tty);
 267           sx = TYPE_SIZE (ttx);
 268           sy = TYPE_SIZE (tty);
 269           x_has_zero_phase = (integer_zerop (bx) || integer_onep (bx));
 270           y_has_zero_phase = (integer_zerop (by) || integer_onep (by));
 271           /* Normalize type size so that 0 => NULL. */
 272           if (sx && integer_zerop (sx))
 273             sx = NULL_TREE;
 274           if (sy && integer_zerop (sy))
 275             sy = NULL_TREE;
 276           /* If the target types have the same UPC block size
 277              (or they both have a phase value of zero)
 278              and the same size and the target types are
 279              otherwise compatible, then the pointer-to-shared
 280              types are compatible. */
 281           result = (tree_int_cst_equal (bx, by)
 282                     || (x_has_zero_phase && y_has_zero_phase))
 283                    && tree_int_cst_equal (sx, sy);
 284           return result;
 285         }
 286       /* If one operand has a UPC shared type,
 287          and the other operand's type is not a UPC shared type,
 288          then they aren't equivalent.  */
 289       else if (upc_shared_type_p (ttx) != upc_shared_type_p (tty))
 290         return 0;
 291     }
 292   else if (upc_shared_type_p (x) || upc_shared_type_p (y))
 293     {
 294       /* In UPC, blocking factors can be applied to
 295          non-pointer objects/types. They're compatible
 296          if the block sizes are equal.  */
 297       const tree bx = upc_get_block_factor (x);
 298       const tree by = upc_get_block_factor (y);
 299       return tree_int_cst_equal (bx, by)
 300         && c_types_compatible_p (TYPE_MAIN_VARIANT (x),
 301                                  TYPE_MAIN_VARIANT (y));
 302     }
 303   /* Otherwise, they're not compatible.
 304      comptypes() should be called before this function
 305      in order to implement a full "C" compatibility check.  */
 306   return 0;
 307 }
 308
 309 int
 310 c_types_compatible_p (tree x, tree y)
 311 {
 312   int result;
 313   result = comptypes (TYPE_MAIN_VARIANT (x), TYPE_MAIN_VARIANT (y));
 314   if (!result && flag_upc)
 315     result = upc_types_compatible_p (x, y);
 316   return result;
 317 }
 318
 319 /* Determine if the type is a vla type for the backend.  */
 320
 321 bool
 322 c_vla_unspec_p (tree x, tree fn ATTRIBUTE_UNUSED)
 323 {
 324   return c_vla_type_p (x);
 325 }