gcc/langhooks.c

   1 /* Default language-specific hooks.
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
   3    Free Software Foundation, Inc.
   4    Contributed by Alexandre Oliva  <aoliva@redhat.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "intl.h"
  26 #include "tm.h"
  27 #include "toplev.h"
  28 #include "tree.h"
  29 #include "tree-inline.h"
  30 #include "tree-gimple.h"
  31 #include "rtl.h"
  32 #include "insn-config.h"
  33 #include "integrate.h"
  34 #include "flags.h"
  35 #include "langhooks.h"
  36 #include "target.h"
  37 #include "langhooks-def.h"
  38 #include "ggc.h"
  39 #include "diagnostic.h"
  40
  41 /* Do nothing; in many cases the default hook.  */
  42
  43 void
  44 lhd_do_nothing (void)
  45 {
  46 }
  47
  48 /* Do nothing (tree).  */
  49
  50 void
  51 lhd_do_nothing_t (tree ARG_UNUSED (t))
  52 {
  53 }
  54
  55 /* Do nothing (int).  */
  56
  57 void
  58 lhd_do_nothing_i (int ARG_UNUSED (i))
  59 {
  60 }
  61
  62 /* Do nothing (int, int, int).  Return NULL_TREE.  */
  63
  64 tree
  65 lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i),
  66                                      int ARG_UNUSED (j),
  67                                      int ARG_UNUSED (k))
  68 {
  69   return NULL_TREE;
  70 }
  71
  72 /* Do nothing (function).  */
  73
  74 void
  75 lhd_do_nothing_f (struct function * ARG_UNUSED (f))
  76 {
  77 }
  78
  79 /* Do nothing (return the tree node passed).  */
  80
  81 tree
  82 lhd_return_tree (tree t)
  83 {
  84   return t;
  85 }
  86
  87 /* Do nothing (return NULL_TREE).  */
  88
  89 tree
  90 lhd_return_null_tree_v (void)
  91 {
  92   return NULL_TREE;
  93 }
  94
  95 /* Do nothing (return NULL_TREE).  */
  96
  97 tree
  98 lhd_return_null_tree (tree ARG_UNUSED (t))
  99 {
 100   return NULL_TREE;
 101 }
 102
 103 /* The default post options hook.  */
 104
 105 bool
 106 lhd_post_options (const char ** ARG_UNUSED (pfilename))
 107 {
 108   return false;
 109 }
 110
 111 /* Called from by print-tree.c.  */
 112
 113 void
 114 lhd_print_tree_nothing (FILE * ARG_UNUSED (file),
 115                         tree ARG_UNUSED (node),
 116                         int ARG_UNUSED (indent))
 117 {
 118 }
 119
 120 /* Called from staticp.  */
 121
 122 tree
 123 lhd_staticp (tree ARG_UNUSED (exp))
 124 {
 125   return NULL;
 126 }
 127
 128 /* Called from check_global_declarations.  */
 129
 130 bool
 131 lhd_warn_unused_global_decl (tree decl)
 132 {
 133   /* This is what used to exist in check_global_declarations.  Probably
 134      not many of these actually apply to non-C languages.  */
 135
 136   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
 137     return false;
 138   if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl))
 139     return false;
 140   if (DECL_IN_SYSTEM_HEADER (decl))
 141     return false;
 142
 143   return true;
 144 }
 145
 146 /* Set the DECL_ASSEMBLER_NAME for DECL.  */
 147 void
 148 lhd_set_decl_assembler_name (tree decl)
 149 {
 150   tree id;
 151
 152   /* The language-independent code should never use the
 153      DECL_ASSEMBLER_NAME for lots of DECLs.  Only FUNCTION_DECLs and
 154      VAR_DECLs for variables with static storage duration need a real
 155      DECL_ASSEMBLER_NAME.  */
 156   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
 157               || (TREE_CODE (decl) == VAR_DECL
 158                   && (TREE_STATIC (decl)
 159                       || DECL_EXTERNAL (decl)
 160                       || TREE_PUBLIC (decl))));
 161
 162   /* By default, assume the name to use in assembly code is the same
 163      as that used in the source language.  (That's correct for C, and
 164      GCC used to set DECL_ASSEMBLER_NAME to the same value as
 165      DECL_NAME in build_decl, so this choice provides backwards
 166      compatibility with existing front-ends.  This assumption is wrapped
 167      in a target hook, to allow for target-specific modification of the
 168      identifier.
 169
 170      Can't use just the variable's own name for a variable whose scope
 171      is less than the whole compilation.  Concatenate a distinguishing
 172      number - we use the DECL_UID.  */
 173
 174   if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE)
 175     id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
 176   else
 177     {
 178       const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
 179       char *label;
 180
 181       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
 182       id = get_identifier (label);
 183     }
 184   SET_DECL_ASSEMBLER_NAME (decl, id);
 185
 186 }
 187
 188 /* Type promotion for variable arguments.  */
 189 tree
 190 lhd_type_promotes_to (tree ARG_UNUSED (type))
 191 {
 192   gcc_unreachable ();
 193 }
 194
 195 /* Registration of machine- or os-specific builtin types.  */
 196 void
 197 lhd_register_builtin_type (tree ARG_UNUSED (type),
 198                            const char * ARG_UNUSED (name))
 199 {
 200 }
 201
 202 /* Invalid use of an incomplete type.  */
 203 void
 204 lhd_incomplete_type_error (tree ARG_UNUSED (value), tree type)
 205 {
 206   gcc_assert (TREE_CODE (type) == ERROR_MARK);
 207   return;
 208 }
 209
 210 /* Provide a default routine for alias sets that always returns -1.  This
 211    is used by languages that don't need to do anything special.  */
 212
 213 HOST_WIDE_INT
 214 lhd_get_alias_set (tree ARG_UNUSED (t))
 215 {
 216   return -1;
 217 }
 218
 219 /* This is the default expand_expr function.  */
 220
 221 rtx
 222 lhd_expand_expr (tree ARG_UNUSED (t), rtx ARG_UNUSED (r),
 223                  enum machine_mode ARG_UNUSED (mm),
 224                  int ARG_UNUSED (em),
 225                  rtx * ARG_UNUSED (a))
 226 {
 227   gcc_unreachable ();
 228 }
 229
 230 /* The default language-specific function for expanding a decl.  After
 231    the language-independent cases are handled, this function will be
 232    called.  If this function is not defined, it is assumed that
 233    declarations other than those for variables and labels do not require
 234    any RTL generation.  */
 235
 236 int
 237 lhd_expand_decl (tree ARG_UNUSED (t))
 238 {
 239   return 0;
 240 }
 241
 242 /* This is the default decl_printable_name function.  */
 243
 244 const char *
 245 lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
 246 {
 247   gcc_assert (decl && DECL_NAME (decl));
 248   return IDENTIFIER_POINTER (DECL_NAME (decl));
 249 }
 250
 251 /* This is the default dwarf_name function.  */
 252
 253 const char *
 254 lhd_dwarf_name (tree t, int verbosity)
 255 {
 256   gcc_assert (DECL_P (t));
 257
 258   return lang_hooks.decl_printable_name (t, verbosity);
 259 }
 260
 261 /* This compares two types for equivalence ("compatible" in C-based languages).
 262    This routine should only return 1 if it is sure.  It should not be used
 263    in contexts where erroneously returning 0 causes problems.  */
 264
 265 int
 266 lhd_types_compatible_p (tree x, tree y)
 267 {
 268   return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
 269 }
 270
 271 /* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
 272    after handling common cases, but before walking code-specific
 273    sub-trees.  If this hook is overridden for a language, it should
 274    handle language-specific tree codes, as well as language-specific
 275    information associated to common tree codes.  If a tree node is
 276    completely handled within this function, it should set *SUBTREES to
 277    0, so that generic handling isn't attempted.  The generic handling
 278    cannot deal with language-specific tree codes, so make sure it is
 279    set properly.  Both SUBTREES and *SUBTREES is guaranteed to be
 280    nonzero when the function is called.  */
 281
 282 tree
 283 lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 284                                  int *subtrees ATTRIBUTE_UNUSED,
 285                                  walk_tree_fn func ATTRIBUTE_UNUSED,
 286                                  void *data ATTRIBUTE_UNUSED,
 287                                  struct pointer_set_t *pset ATTRIBUTE_UNUSED)
 288 {
 289   return NULL_TREE;
 290 }
 291
 292 /* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
 293    determine whether there are language-specific reasons for not
 294    inlining a given function.  */
 295
 296 int
 297 lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp)
 298 {
 299   if (flag_really_no_inline
 300       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
 301     return 1;
 302
 303   return 0;
 304 }
 305
 306 /* lang_hooks.tree_inlining.disregard_inline_limits is called to
 307    determine whether a function should be considered for inlining even
 308    if it would exceed inlining limits.  */
 309
 310 int
 311 lhd_tree_inlining_disregard_inline_limits (tree fn)
 312 {
 313   if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
 314     return 1;
 315
 316   return 0;
 317 }
 318
 319 /* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
 320    whether VT is an automatic variable defined in function FT.  */
 321
 322 int
 323 lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn)
 324 {
 325   return (DECL_P (var) && DECL_CONTEXT (var) == fn
 326           && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
 327                && ! TREE_STATIC (var))
 328               || TREE_CODE (var) == LABEL_DECL
 329               || TREE_CODE (var) == RESULT_DECL));
 330 }
 331
 332 /* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
 333    nodes.  Returns nonzero if it does not want the usual dumping of the
 334    second argument.  */
 335
 336 bool
 337 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
 338 {
 339   return false;
 340 }
 341
 342 /* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
 343    language-specific way.  */
 344
 345 int
 346 lhd_tree_dump_type_quals (tree t)
 347 {
 348   return TYPE_QUALS (t);
 349 }
 350
 351 /* lang_hooks.expr_size: Determine the size of the value of an expression T
 352    in a language-specific way.  Returns a tree for the size in bytes.  */
 353
 354 tree
 355 lhd_expr_size (tree exp)
 356 {
 357   if (DECL_P (exp)
 358       && DECL_SIZE_UNIT (exp) != 0)
 359     return DECL_SIZE_UNIT (exp);
 360   else
 361     return size_in_bytes (TREE_TYPE (exp));
 362 }
 363
 364 /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
 365
 366 int
 367 lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
 368                    tree *post_p ATTRIBUTE_UNUSED)
 369 {
 370   return GS_UNHANDLED;
 371 }
 372
 373 /* lang_hooks.tree_size: Determine the size of a tree with code C,
 374    which is a language-specific tree code in category tcc_constant or
 375    tcc_exceptional.  The default expects never to be called.  */
 376 size_t
 377 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
 378 {
 379   gcc_unreachable ();
 380 }
 381
 382 /* Return true if decl, which is a function decl, may be called by a
 383    sibcall.  */
 384
 385 bool
 386 lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
 387 {
 388   return true;
 389 }
 390
 391 /* Return the COMDAT group into which DECL should be placed.  */
 392
 393 const char *
 394 lhd_comdat_group (tree decl)
 395 {
 396   return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 397 }
 398
 399 /* lang_hooks.decls.final_write_globals: perform final processing on
 400    global variables.  */
 401 void
 402 write_global_declarations (void)
 403 {
 404   /* Really define vars that have had only a tentative definition.
 405      Really output inline functions that must actually be callable
 406      and have not been output so far.  */
 407
 408   tree globals = lang_hooks.decls.getdecls ();
 409   int len = list_length (globals);
 410   tree *vec = XNEWVEC (tree, len);
 411   int i;
 412   tree decl;
 413
 414   /* Process the decls in reverse order--earliest first.
 415      Put them into VEC from back to front, then take out from front.  */
 416
 417   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
 418     vec[len - i - 1] = decl;
 419
 420   wrapup_global_declarations (vec, len);
 421   check_global_declarations (vec, len);
 422   emit_debug_global_declarations (vec, len);
 423
 424   /* Clean up.  */
 425   free (vec);
 426 }
 427
 428 /* Called to perform language-specific initialization of CTX.  */
 429 void
 430 lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
 431 {
 432 }
 433
 434 /* The default function to print out name of current function that caused
 435    an error.  */
 436 void
 437 lhd_print_error_function (diagnostic_context *context, const char *file)
 438 {
 439   if (diagnostic_last_function_changed (context))
 440     {
 441       const char *old_prefix = context->printer->prefix;
 442       char *new_prefix = file ? file_name_as_prefix (file) : NULL;
 443
 444       pp_set_prefix (context->printer, new_prefix);
 445
 446       if (current_function_decl == NULL)
 447         pp_printf (context->printer, _("At top level:"));
 448       else
 449         {
 450           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
 451             pp_printf
 452               (context->printer, _("In member function %qs:"),
 453                lang_hooks.decl_printable_name (current_function_decl, 2));
 454           else
 455             pp_printf
 456               (context->printer, _("In function %qs:"),
 457                lang_hooks.decl_printable_name (current_function_decl, 2));
 458         }
 459
 460       diagnostic_set_last_function (context);
 461       pp_flush (context->printer);
 462       context->printer->prefix = old_prefix;
 463       free ((char*) new_prefix);
 464     }
 465 }
 466
 467 tree
 468 lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
 469                             int *walk_subtrees ATTRIBUTE_UNUSED,
 470                             tree decl ATTRIBUTE_UNUSED)
 471 {
 472   return NULL;
 473 }
 474
 475 tree
 476 lhd_make_node (enum tree_code code)
 477 {
 478   return make_node (code);
 479 }
 480
 481 HOST_WIDE_INT
 482 lhd_to_target_charset (HOST_WIDE_INT c)
 483 {
 484   return c;
 485 }
 486
 487 tree
 488 lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED,
 489                   bool *ti ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
 490 {
 491   return expr;
 492 }
 493
 494 /* Return sharing kind if OpenMP sharing attribute of DECL is
 495    predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise.  */
 496
 497 enum omp_clause_default_kind
 498 lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
 499 {
 500   if (DECL_ARTIFICIAL (decl))
 501     return OMP_CLAUSE_DEFAULT_SHARED;
 502   return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
 503 }
 504
 505 /* Generate code to copy SRC to DST.  */
 506
 507 tree
 508 lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
 509 {
 510   return build_gimple_modify_stmt (dst, src);
 511 }
 512
 513 /* Register language specific type size variables as potentially OpenMP
 514    firstprivate variables.  */
 515
 516 void
 517 lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED,
 518                                    tree t ATTRIBUTE_UNUSED)
 519 {
 520 }
 521
 522 tree
 523 add_builtin_function (const char *name,
 524                       tree type,
 525                       int function_code,
 526                       enum built_in_class cl,
 527                       const char *library_name,
 528                       tree attrs)
 529 {
 530   tree   id = get_identifier (name);
 531   tree decl = build_decl (FUNCTION_DECL, id, type);
 532
 533   TREE_PUBLIC (decl)         = 1;
 534   DECL_EXTERNAL (decl)       = 1;
 535   DECL_BUILT_IN_CLASS (decl) = cl;
 536   DECL_FUNCTION_CODE (decl)  = function_code;
 537
 538   if (library_name)
 539     {
 540       tree libname = get_identifier (library_name);
 541       SET_DECL_ASSEMBLER_NAME (decl, libname);
 542     }
 543
 544   /* Possibly apply some default attributes to this built-in function.  */
 545   if (attrs)
 546     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
 547   else
 548     decl_attributes (&decl, NULL_TREE, 0);
 549
 550   return lang_hooks.builtin_function (decl);
 551
 552 }
 553
 554 tree
 555 lhd_builtin_function (tree decl)
 556 {
 557   lang_hooks.decls.pushdecl (decl);
 558   return decl;
 559 }