sdcc/support/cpp/gcc/c/c-objc-common.cc

   1 /* Some code common to C and ObjC front ends.
   2    Copyright (C) 2001-2022 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 // sdcpp #include "gimple-pretty-print.h"
  28 #include "langhooks.h"
  29 // sdcpp #include "c-objc-common.h"
  30 #include "gcc-rich-location.h"
  31 #include "stringpool.h"
  32 #include "attribs.h"
  33
  34 #if 0 // sdcpp
  35 static bool c_tree_printer (pretty_printer *, text_info *, const char *,
  36                             int, bool, bool, bool, bool *, const char **);
  37
  38 bool
  39 c_missing_noreturn_ok_p (tree decl)
  40 {
  41   /* A missing noreturn is not ok for freestanding implementations and
  42      ok for the `main' function in hosted implementations.  */
  43   return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
  44 }
  45
  46 /* Called from check_global_declaration.  */
  47
  48 bool
  49 c_warn_unused_global_decl (const_tree decl)
  50 {
  51   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
  52     return false;
  53   if (DECL_IN_SYSTEM_HEADER (decl))
  54     return false;
  55
  56   return true;
  57 }
  58 #endif // sdcpp
  59
  60 /* Initialization common to C and Objective-C front ends.  */
  61 bool
  62 c_objc_common_init (void)
  63 {
  64   // sdcpp c_init_decl_processing ();
  65
  66   return c_common_init ();
  67 }
  68
  69 /* Decide whether it's worth saying that TYPE is also known as some other
  70    type.  Return the other type if so, otherwise return TYPE.  */
  71
  72 #if 0 // sdcpp
  73 static tree
  74 get_aka_type (tree type)
  75 {
  76   if (type == error_mark_node)
  77     return type;
  78
  79   tree result;
  80   if (typedef_variant_p (type))
  81     {
  82       /* Saying that "foo" is also known as "struct foo" or
  83          "struct <anonymous>" is unlikely to be useful, since users of
  84          structure-like types would already know that they're structures.
  85          The same applies to unions and enums; in general, printing the
  86          tag is only useful if it has a different name.  */
  87       tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
  88       tree_code code = TREE_CODE (orig_type);
  89       tree orig_id = TYPE_IDENTIFIER (orig_type);
  90       if ((code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
  91           && (!orig_id || TYPE_IDENTIFIER (type) == orig_id))
  92         return type;
  93
  94       if (!user_facing_original_type_p (type))
  95         return type;
  96
  97       result = get_aka_type (orig_type);
  98     }
  99   else
 100     {
 101       tree canonical = TYPE_CANONICAL (type);
 102       if (canonical && TREE_CODE (type) != TREE_CODE (canonical))
 103         return canonical;
 104
 105       /* Recursive calls might choose a middle ground between TYPE
 106          (which has no typedefs stripped) and CANONICAL (which has
 107          all typedefs stripped).  So try to reuse TYPE or CANONICAL if
 108          convenient, but be prepared to create a new type if necessary.  */
 109       switch (TREE_CODE (type))
 110         {
 111         case POINTER_TYPE:
 112         case REFERENCE_TYPE:
 113           {
 114             tree target_type = get_aka_type (TREE_TYPE (type));
 115
 116             if (target_type == TREE_TYPE (type))
 117               return type;
 118
 119             if (canonical && target_type == TREE_TYPE (canonical))
 120               return canonical;
 121
 122             result = (TREE_CODE (type) == POINTER_TYPE
 123                       ? build_pointer_type (target_type)
 124                       : build_reference_type (target_type));
 125             break;
 126           }
 127
 128         case ARRAY_TYPE:
 129           {
 130             tree element_type = get_aka_type (TREE_TYPE (type));
 131             tree index_type = (TYPE_DOMAIN (type)
 132                                ? get_aka_type (TYPE_DOMAIN (type))
 133                                : NULL_TREE);
 134
 135             if (element_type == TREE_TYPE (type)
 136                 && index_type == TYPE_DOMAIN (type))
 137               return type;
 138
 139             if (canonical
 140                 && element_type == TREE_TYPE (canonical)
 141                 && index_type == TYPE_DOMAIN (canonical))
 142               return canonical;
 143
 144             result = build_array_type (element_type, index_type,
 145                                        TYPE_TYPELESS_STORAGE (type));
 146             break;
 147           }
 148
 149         case FUNCTION_TYPE:
 150           {
 151             tree return_type = get_aka_type (TREE_TYPE (type));
 152
 153             tree args = TYPE_ARG_TYPES (type);
 154             if (args == error_mark_node)
 155               return type;
 156
 157             auto_vec<tree, 32> arg_types;
 158             bool type_ok_p = true;
 159             while (args && args != void_list_node)
 160               {
 161                 tree arg_type = get_aka_type (TREE_VALUE (args));
 162                 arg_types.safe_push (arg_type);
 163                 type_ok_p &= (arg_type == TREE_VALUE (args));
 164                 args = TREE_CHAIN (args);
 165               }
 166
 167             if (type_ok_p && return_type == TREE_TYPE (type))
 168               return type;
 169
 170             unsigned int i;
 171             tree arg_type;
 172             FOR_EACH_VEC_ELT_REVERSE (arg_types, i, arg_type)
 173               args = tree_cons (NULL_TREE, arg_type, args);
 174             result = build_function_type (return_type, args);
 175             break;
 176           }
 177
 178         default:
 179           return canonical ? canonical : type;
 180         }
 181     }
 182   return build_type_attribute_qual_variant (result, TYPE_ATTRIBUTES (type),
 183                                             TYPE_QUALS (type));
 184 }
 185
 186 /* Print T to CPP.  */
 187
 188 static void
 189 print_type (c_pretty_printer *cpp, tree t, bool *quoted)
 190 {
 191   if (t == error_mark_node)
 192     {
 193       pp_string (cpp, _("{erroneous}"));
 194       return;
 195     }
 196
 197   gcc_assert (TYPE_P (t));
 198   struct obstack *ob = pp_buffer (cpp)->obstack;
 199   char *p = (char *) obstack_base (ob);
 200   /* Remember the end of the initial dump.  */
 201   int len = obstack_object_size (ob);
 202
 203   tree name = TYPE_NAME (t);
 204   if (name && TREE_CODE (name) == TYPE_DECL && DECL_NAME (name))
 205     pp_identifier (cpp, lang_hooks.decl_printable_name (name, 2));
 206   else
 207     cpp->type_id (t);
 208
 209   /* If we're printing a type that involves typedefs, also print the
 210      stripped version.  But sometimes the stripped version looks
 211      exactly the same, so we don't want it after all.  To avoid
 212      printing it in that case, we play ugly obstack games.  */
 213   tree aka_type = get_aka_type (t);
 214   if (aka_type != t)
 215     {
 216       c_pretty_printer cpp2;
 217       /* Print the stripped version into a temporary printer.  */
 218       cpp2.type_id (aka_type);
 219       struct obstack *ob2 = cpp2.buffer->obstack;
 220       /* Get the stripped version from the temporary printer.  */
 221       const char *aka = (char *) obstack_base (ob2);
 222       int aka_len = obstack_object_size (ob2);
 223       int type1_len = obstack_object_size (ob) - len;
 224
 225       /* If they are identical, bail out.  */
 226       if (aka_len == type1_len && memcmp (p + len, aka, aka_len) == 0)
 227         return;
 228
 229       /* They're not, print the stripped version now.  */
 230       if (*quoted)
 231         pp_end_quote (cpp, pp_show_color (cpp));
 232       pp_c_whitespace (cpp);
 233       pp_left_brace (cpp);
 234       pp_c_ws_string (cpp, _("aka"));
 235       pp_c_whitespace (cpp);
 236       if (*quoted)
 237         pp_begin_quote (cpp, pp_show_color (cpp));
 238       cpp->type_id (aka_type);
 239       if (*quoted)
 240         pp_end_quote (cpp, pp_show_color (cpp));
 241       pp_right_brace (cpp);
 242       /* No further closing quotes are needed.  */
 243       *quoted = false;
 244     }
 245 }
 246
 247 /* Called during diagnostic message formatting process to print a
 248    source-level entity onto BUFFER.  The meaning of the format specifiers
 249    is as follows:
 250    %D: a general decl,
 251    %E: an identifier or expression,
 252    %F: a function declaration,
 253    %T: a type.
 254    %V: a list of type qualifiers from a tree.
 255    %v: an explicit list of type qualifiers
 256    %#v: an explicit list of type qualifiers of a function type.
 257
 258    Please notice when called, the `%' part was already skipped by the
 259    diagnostic machinery.  */
 260 static bool
 261 c_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
 262                 int precision, bool wide, bool set_locus, bool hash,
 263                 bool *quoted, const char **)
 264 {
 265 #if 0 //sdcpp
 266         (void) pp; (void) text; (void) spec; (void) precision; (void) wide;
 267         (void) set_locus; (void) hash; (void) quoted;
 268 #else // sdcpp
 269   tree t = NULL_TREE;
 270   // FIXME: the next cast should be a dynamic_cast, when it is permitted.
 271   c_pretty_printer *cpp = (c_pretty_printer *) pp;
 272   pp->padding = pp_none;
 273
 274   if (precision != 0 || wide)
 275     return false;
 276
 277   if (*spec != 'v')
 278     {
 279       t = va_arg (*text->args_ptr, tree);
 280       if (set_locus)
 281         text->set_location (0, DECL_SOURCE_LOCATION (t),
 282                             SHOW_RANGE_WITH_CARET);
 283     }
 284
 285   switch (*spec)
 286     {
 287     case 'D':
 288       if (VAR_P (t) && DECL_HAS_DEBUG_EXPR_P (t))
 289         {
 290           t = DECL_DEBUG_EXPR (t);
 291           if (!DECL_P (t))
 292             {
 293               cpp->expression (t);
 294               return true;
 295             }
 296         }
 297       /* FALLTHRU */
 298
 299     case 'F':
 300       if (DECL_NAME (t))
 301         {
 302           pp_identifier (cpp, lang_hooks.decl_printable_name (t, 2));
 303           return true;
 304         }
 305       break;
 306
 307     case 'T':
 308       print_type (cpp, t, quoted);
 309       return true;
 310
 311     case 'E':
 312       if (TREE_CODE (t) == IDENTIFIER_NODE)
 313         pp_identifier (cpp, IDENTIFIER_POINTER (t));
 314       else
 315         cpp->expression (t);
 316       return true;
 317
 318     case 'V':
 319       pp_c_type_qualifier_list (cpp, t);
 320       return true;
 321
 322     case 'v':
 323       pp_c_cv_qualifiers (cpp, va_arg (*text->args_ptr, int), hash);
 324       return true;
 325
 326     default:
 327       return false;
 328     }
 329
 330   pp_string (cpp, _("({anonymous})"));
 331 #endif //sdcpp
 332   return true;
 333 }
 334
 335 /* C-specific implementation of range_label::get_text () vfunc for
 336    range_label_for_type_mismatch.  */
 337
 338 label_text
 339 range_label_for_type_mismatch::get_text (unsigned /*range_idx*/) const
 340 {
 341   if (m_labelled_type == NULL_TREE)
 342     return label_text::borrow (NULL);
 343
 344   c_pretty_printer cpp;
 345   bool quoted = false;
 346   print_type (&cpp, m_labelled_type, &quoted);
 347   return label_text::take (xstrdup (pp_formatted_text (&cpp)));
 348 }
 349
 350
 351 /* In C and ObjC, all decls have "C" linkage.  */
 352 bool
 353 has_c_linkage (const_tree decl ATTRIBUTE_UNUSED)
 354 {
 355   return true;
 356 }
 357
 358 void
 359 c_initialize_diagnostics (diagnostic_context *context)
 360 {
 361   pretty_printer *base = context->printer;
 362   c_pretty_printer *pp = XNEW (c_pretty_printer);
 363   context->printer = new (pp) c_pretty_printer ();
 364
 365   /* It is safe to free this object because it was previously XNEW()'d.  */
 366   base->~pretty_printer ();
 367   XDELETE (base);
 368
 369   c_common_diagnostics_set_defaults (context);
 370   diagnostic_format_decoder (context) = &c_tree_printer;
 371 }
 372
 373 int
 374 c_types_compatible_p (tree x, tree y)
 375 {
 376   return comptypes (TYPE_MAIN_VARIANT (x), TYPE_MAIN_VARIANT (y));
 377 }
 378
 379 /* Determine if the type is a vla type for the backend.  */
 380
 381 bool
 382 c_vla_unspec_p (tree x, tree fn ATTRIBUTE_UNUSED)
 383 {
 384   return c_vla_type_p (x);
 385 }
 386
 387 /* Special routine to get the alias set of T for C.  */
 388
 389 alias_set_type
 390 c_get_alias_set (tree t)
 391 {
 392   /* Allow aliasing between enumeral types and the underlying
 393      integer type.  This is required since those are compatible types.  */
 394   if (TREE_CODE (t) == ENUMERAL_TYPE)
 395     {
 396       tree t1 = c_common_type_for_size (tree_to_uhwi (TYPE_SIZE (t)),
 397                                         /* short-cut commoning to signed
 398                                            type.  */
 399                                         false);
 400       return get_alias_set (t1);
 401     }
 402
 403   return c_common_get_alias_set (t);
 404 }
 405 #endif // sdcpp