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