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 /* This is the default expand_expr function.  */
 221
 222 rtx
 223 lhd_expand_expr (tree ARG_UNUSED (t), rtx ARG_UNUSED (r),
 224                  enum machine_mode ARG_UNUSED (mm),
 225                  int ARG_UNUSED (em),
 226                  rtx * ARG_UNUSED (a))
 227 {
 228   gcc_unreachable ();
 229 }
 230
 231 /* The default language-specific function for expanding a decl.  After
 232    the language-independent cases are handled, this function will be
 233    called.  If this function is not defined, it is assumed that
 234    declarations other than those for variables and labels do not require
 235    any RTL generation.  */
 236
 237 int
 238 lhd_expand_decl (tree ARG_UNUSED (t))
 239 {
 240   return 0;
 241 }
 242
 243 /* This is the default decl_printable_name function.  */
 244
 245 const char *
 246 lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
 247 {
 248   gcc_assert (decl && DECL_NAME (decl));
 249   return IDENTIFIER_POINTER (DECL_NAME (decl));
 250 }
 251
 252 /* This is the default dwarf_name function.  */
 253
 254 const char *
 255 lhd_dwarf_name (tree t, int verbosity)
 256 {
 257   gcc_assert (DECL_P (t));
 258
 259   return lang_hooks.decl_printable_name (t, verbosity);
 260 }
 261
 262 /* This compares two types for equivalence ("compatible" in C-based languages).
 263    This routine should only return 1 if it is sure.  It should not be used
 264    in contexts where erroneously returning 0 causes problems.  */
 265
 266 int
 267 lhd_types_compatible_p (tree x, tree y)
 268 {
 269   return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
 270 }
 271
 272 /* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
 273    after handling common cases, but before walking code-specific
 274    sub-trees.  If this hook is overridden for a language, it should
 275    handle language-specific tree codes, as well as language-specific
 276    information associated to common tree codes.  If a tree node is
 277    completely handled within this function, it should set *SUBTREES to
 278    0, so that generic handling isn't attempted.  The generic handling
 279    cannot deal with language-specific tree codes, so make sure it is
 280    set properly.  Both SUBTREES and *SUBTREES is guaranteed to be
 281    nonzero when the function is called.  */
 282
 283 tree
 284 lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 285                                  int *subtrees ATTRIBUTE_UNUSED,
 286                                  walk_tree_fn func ATTRIBUTE_UNUSED,
 287                                  void *data ATTRIBUTE_UNUSED,
 288                                  struct pointer_set_t *pset ATTRIBUTE_UNUSED)
 289 {
 290   return NULL_TREE;
 291 }
 292
 293 /* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
 294    determine whether there are language-specific reasons for not
 295    inlining a given function.  */
 296
 297 int
 298 lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp)
 299 {
 300   if (flag_really_no_inline
 301       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
 302     return 1;
 303
 304   return 0;
 305 }
 306
 307 /* lang_hooks.tree_inlining.disregard_inline_limits is called to
 308    determine whether a function should be considered for inlining even
 309    if it would exceed inlining limits.  */
 310
 311 int
 312 lhd_tree_inlining_disregard_inline_limits (tree fn)
 313 {
 314   if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
 315     return 1;
 316
 317   return 0;
 318 }
 319
 320 /* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
 321    whether VT is an automatic variable defined in function FT.  */
 322
 323 int
 324 lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn)
 325 {
 326   return (DECL_P (var) && DECL_CONTEXT (var) == fn
 327           && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
 328                && ! TREE_STATIC (var))
 329               || TREE_CODE (var) == LABEL_DECL
 330               || TREE_CODE (var) == RESULT_DECL));
 331 }
 332
 333 /* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
 334    language-specific conversion before assigning VALUE to PARM.  */
 335
 336 tree
 337 lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED,
 338                                              tree value,
 339                                              tree fndecl ATTRIBUTE_UNUSED,
 340                                              int argnum ATTRIBUTE_UNUSED)
 341 {
 342   return value;
 343 }
 344
 345 /* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
 346    nodes.  Returns nonzero if it does not want the usual dumping of the
 347    second argument.  */
 348
 349 bool
 350 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
 351 {
 352   return false;
 353 }
 354
 355 /* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
 356    language-specific way.  */
 357
 358 int
 359 lhd_tree_dump_type_quals (tree t)
 360 {
 361   return TYPE_QUALS (t);
 362 }
 363
 364 /* lang_hooks.expr_size: Determine the size of the value of an expression T
 365    in a language-specific way.  Returns a tree for the size in bytes.  */
 366
 367 tree
 368 lhd_expr_size (tree exp)
 369 {
 370   if (DECL_P (exp)
 371       && DECL_SIZE_UNIT (exp) != 0)
 372     return DECL_SIZE_UNIT (exp);
 373   else
 374     return size_in_bytes (TREE_TYPE (exp));
 375 }
 376
 377 /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
 378
 379 int
 380 lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
 381                    tree *post_p ATTRIBUTE_UNUSED)
 382 {
 383   return GS_UNHANDLED;
 384 }
 385
 386 /* lang_hooks.tree_size: Determine the size of a tree with code C,
 387    which is a language-specific tree code in category tcc_constant or
 388    tcc_exceptional.  The default expects never to be called.  */
 389 size_t
 390 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
 391 {
 392   gcc_unreachable ();
 393 }
 394
 395 /* Return true if decl, which is a function decl, may be called by a
 396    sibcall.  */
 397
 398 bool
 399 lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
 400 {
 401   return true;
 402 }
 403
 404 /* Return the COMDAT group into which DECL should be placed.  */
 405
 406 const char *
 407 lhd_comdat_group (tree decl)
 408 {
 409   return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 410 }
 411
 412 /* lang_hooks.decls.final_write_globals: perform final processing on
 413    global variables.  */
 414 void
 415 write_global_declarations (void)
 416 {
 417   /* Really define vars that have had only a tentative definition.
 418      Really output inline functions that must actually be callable
 419      and have not been output so far.  */
 420
 421   tree globals = lang_hooks.decls.getdecls ();
 422   int len = list_length (globals);
 423   tree *vec = XNEWVEC (tree, len);
 424   int i;
 425   tree decl;
 426
 427   /* Process the decls in reverse order--earliest first.
 428      Put them into VEC from back to front, then take out from front.  */
 429
 430   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
 431     vec[len - i - 1] = decl;
 432
 433   wrapup_global_declarations (vec, len);
 434   check_global_declarations (vec, len);
 435   emit_debug_global_declarations (vec, len);
 436
 437   /* Clean up.  */
 438   free (vec);
 439 }
 440
 441 /* Called to perform language-specific initialization of CTX.  */
 442 void
 443 lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
 444 {
 445 }
 446
 447 /* The default function to print out name of current function that caused
 448    an error.  */
 449 void
 450 lhd_print_error_function (diagnostic_context *context, const char *file)
 451 {
 452   if (diagnostic_last_function_changed (context))
 453     {
 454       const char *old_prefix = context->printer->prefix;
 455       char *new_prefix = file ? file_name_as_prefix (file) : NULL;
 456
 457       pp_set_prefix (context->printer, new_prefix);
 458
 459       if (current_function_decl == NULL)
 460         pp_printf (context->printer, _("At top level:"));
 461       else
 462         {
 463           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
 464             pp_printf
 465               (context->printer, _("In member function %qs:"),
 466                lang_hooks.decl_printable_name (current_function_decl, 2));
 467           else
 468             pp_printf
 469               (context->printer, _("In function %qs:"),
 470                lang_hooks.decl_printable_name (current_function_decl, 2));
 471         }
 472
 473       diagnostic_set_last_function (context);
 474       pp_flush (context->printer);
 475       context->printer->prefix = old_prefix;
 476       free ((char*) new_prefix);
 477     }
 478 }
 479
 480 tree
 481 lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
 482                             int *walk_subtrees ATTRIBUTE_UNUSED,
 483                             tree decl ATTRIBUTE_UNUSED)
 484 {
 485   return NULL;
 486 }
 487
 488 tree
 489 lhd_make_node (enum tree_code code)
 490 {
 491   return make_node (code);
 492 }
 493
 494 HOST_WIDE_INT
 495 lhd_to_target_charset (HOST_WIDE_INT c)
 496 {
 497   return c;
 498 }
 499
 500 tree
 501 lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED,
 502                   bool *ti ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
 503 {
 504   return expr;
 505 }
 506
 507 /* Return sharing kind if OpenMP sharing attribute of DECL is
 508    predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise.  */
 509
 510 enum omp_clause_default_kind
 511 lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
 512 {
 513   if (DECL_ARTIFICIAL (decl))
 514     return OMP_CLAUSE_DEFAULT_SHARED;
 515   return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
 516 }
 517
 518 /* Generate code to copy SRC to DST.  */
 519
 520 tree
 521 lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
 522 {
 523   return build_gimple_modify_stmt (dst, src);
 524 }
 525
 526 /* Register language specific type size variables as potentially OpenMP
 527    firstprivate variables.  */
 528
 529 void
 530 lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED,
 531                                    tree t ATTRIBUTE_UNUSED)
 532 {
 533 }
 534
 535 tree
 536 add_builtin_function (const char *name,
 537                       tree type,
 538                       int function_code,
 539                       enum built_in_class cl,
 540                       const char *library_name,
 541                       tree attrs)
 542 {
 543   tree   id = get_identifier (name);
 544   tree decl = build_decl (FUNCTION_DECL, id, type);
 545
 546   TREE_PUBLIC (decl)         = 1;
 547   DECL_EXTERNAL (decl)       = 1;
 548   DECL_BUILT_IN_CLASS (decl) = cl;
 549   DECL_FUNCTION_CODE (decl)  = function_code;
 550
 551   if (library_name)
 552     {
 553       tree libname = get_identifier (library_name);
 554       SET_DECL_ASSEMBLER_NAME (decl, libname);
 555     }
 556
 557   /* Possibly apply some default attributes to this built-in function.  */
 558   if (attrs)
 559     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
 560   else
 561     decl_attributes (&decl, NULL_TREE, 0);
 562
 563   return lang_hooks.builtin_function (decl);
 564
 565 }
 566
 567 tree
 568 lhd_builtin_function (tree decl)
 569 {
 570   lang_hooks.decls.pushdecl (decl);
 571   return decl;
 572 }
 573
 574 /* If TYPE is an integral type, return an equivalent type which is
 575     unsigned iff UNSIGNEDP is true.  If TYPE is not an integral type,
 576     return TYPE itself.  */
 577
 578 tree
 579 get_signed_or_unsigned_type (int unsignedp, tree type)
 580 {
 581   return lang_hooks.types.signed_or_unsigned_type(unsignedp, type);
 582 }
 583
 584 /* Default implementation of the signed_or_unsigned_type language hook */
 585
 586 tree
 587 lhd_signed_or_unsigned_type (int unsignedp, tree type)
 588 {
 589   if (!INTEGRAL_TYPE_P (type) || TYPE_UNSIGNED (type) == unsignedp)
 590     return type;
 591
 592   return lang_hooks.types.type_for_size (TYPE_PRECISION (type), unsignedp);
 593 }