gcc/langhooks.c

   1 /* Default language-specific hooks.
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   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 "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 NULL_TREE).  */
  80
  81 tree
  82 lhd_return_null_tree_v (void)
  83 {
  84   return NULL_TREE;
  85 }
  86
  87 /* Do nothing (return NULL_TREE).  */
  88
  89 tree
  90 lhd_return_null_tree (tree ARG_UNUSED (t))
  91 {
  92   return NULL_TREE;
  93 }
  94
  95 /* Do nothing (return NULL_TREE).  */
  96
  97 tree
  98 lhd_return_null_const_tree (const_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 (const_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_DECLARED_INLINE_P (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 (const_tree ARG_UNUSED (value), const_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 alias_set_type
 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 /* This is the default decl_printable_name function.  */
 231
 232 const char *
 233 lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
 234 {
 235   gcc_assert (decl && DECL_NAME (decl));
 236   return IDENTIFIER_POINTER (DECL_NAME (decl));
 237 }
 238
 239 /* This is the default dwarf_name function.  */
 240
 241 const char *
 242 lhd_dwarf_name (tree t, int verbosity)
 243 {
 244   gcc_assert (DECL_P (t));
 245
 246   return lang_hooks.decl_printable_name (t, verbosity);
 247 }
 248
 249 /* This compares two types for equivalence ("compatible" in C-based languages).
 250    This routine should only return 1 if it is sure.  It should not be used
 251    in contexts where erroneously returning 0 causes problems.  */
 252
 253 int
 254 lhd_types_compatible_p (tree x, tree y)
 255 {
 256   return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
 257 }
 258
 259 /* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
 260    nodes.  Returns nonzero if it does not want the usual dumping of the
 261    second argument.  */
 262
 263 bool
 264 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
 265 {
 266   return false;
 267 }
 268
 269 /* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
 270    language-specific way.  */
 271
 272 int
 273 lhd_tree_dump_type_quals (const_tree t)
 274 {
 275   return TYPE_QUALS (t);
 276 }
 277
 278 /* lang_hooks.expr_size: Determine the size of the value of an expression T
 279    in a language-specific way.  Returns a tree for the size in bytes.  */
 280
 281 tree
 282 lhd_expr_size (const_tree exp)
 283 {
 284   if (DECL_P (exp)
 285       && DECL_SIZE_UNIT (exp) != 0)
 286     return DECL_SIZE_UNIT (exp);
 287   else
 288     return size_in_bytes (TREE_TYPE (exp));
 289 }
 290
 291 /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
 292
 293 int
 294 lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED,
 295                    gimple_seq *pre_p ATTRIBUTE_UNUSED,
 296                    gimple_seq *post_p ATTRIBUTE_UNUSED)
 297 {
 298   return GS_UNHANDLED;
 299 }
 300
 301 /* lang_hooks.tree_size: Determine the size of a tree with code C,
 302    which is a language-specific tree code in category tcc_constant or
 303    tcc_exceptional.  The default expects never to be called.  */
 304 size_t
 305 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
 306 {
 307   gcc_unreachable ();
 308 }
 309
 310 /* Return true if decl, which is a function decl, may be called by a
 311    sibcall.  */
 312
 313 bool
 314 lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED)
 315 {
 316   return true;
 317 }
 318
 319 /* Return the COMDAT group into which DECL should be placed.  */
 320
 321 const char *
 322 lhd_comdat_group (tree decl)
 323 {
 324   return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 325 }
 326
 327 /* lang_hooks.decls.final_write_globals: perform final processing on
 328    global variables.  */
 329 void
 330 write_global_declarations (void)
 331 {
 332   /* Really define vars that have had only a tentative definition.
 333      Really output inline functions that must actually be callable
 334      and have not been output so far.  */
 335
 336   tree globals = lang_hooks.decls.getdecls ();
 337   int len = list_length (globals);
 338   tree *vec = XNEWVEC (tree, len);
 339   int i;
 340   tree decl;
 341
 342   /* Process the decls in reverse order--earliest first.
 343      Put them into VEC from back to front, then take out from front.  */
 344
 345   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
 346     vec[len - i - 1] = decl;
 347
 348   wrapup_global_declarations (vec, len);
 349   check_global_declarations (vec, len);
 350   emit_debug_global_declarations (vec, len);
 351
 352   /* Clean up.  */
 353   free (vec);
 354 }
 355
 356 /* Called to perform language-specific initialization of CTX.  */
 357 void
 358 lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
 359 {
 360 }
 361
 362 /* The default function to print out name of current function that caused
 363    an error.  */
 364 void
 365 lhd_print_error_function (diagnostic_context *context, const char *file,
 366                           diagnostic_info *diagnostic)
 367 {
 368   if (diagnostic_last_function_changed (context, diagnostic))
 369     {
 370       const char *old_prefix = context->printer->prefix;
 371       tree abstract_origin = diagnostic->abstract_origin;
 372       char *new_prefix = (file && abstract_origin == NULL)
 373                          ? file_name_as_prefix (file) : NULL;
 374
 375       pp_set_prefix (context->printer, new_prefix);
 376
 377       if (current_function_decl == NULL)
 378         pp_printf (context->printer, _("At top level:"));
 379       else
 380         {
 381           tree fndecl, ao;
 382
 383           if (abstract_origin)
 384             {
 385               ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
 386               while (TREE_CODE (ao) == BLOCK
 387                      && BLOCK_ABSTRACT_ORIGIN (ao)
 388                      && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
 389                 ao = BLOCK_ABSTRACT_ORIGIN (ao);
 390               gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
 391               fndecl = ao;
 392             }
 393           else
 394             fndecl = current_function_decl;
 395
 396           if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
 397             pp_printf
 398               (context->printer, _("In member function %qs"),
 399                lang_hooks.decl_printable_name (fndecl, 2));
 400           else
 401             pp_printf
 402               (context->printer, _("In function %qs"),
 403                lang_hooks.decl_printable_name (fndecl, 2));
 404
 405           while (abstract_origin)
 406             {
 407               location_t *locus;
 408               tree block = abstract_origin;
 409
 410               locus = &BLOCK_SOURCE_LOCATION (block);
 411               fndecl = NULL;
 412               block = BLOCK_SUPERCONTEXT (block);
 413               while (block && TREE_CODE (block) == BLOCK
 414                      && BLOCK_ABSTRACT_ORIGIN (block))
 415                 {
 416                   ao = BLOCK_ABSTRACT_ORIGIN (block);
 417
 418                   while (TREE_CODE (ao) == BLOCK
 419                          && BLOCK_ABSTRACT_ORIGIN (ao)
 420                          && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
 421                     ao = BLOCK_ABSTRACT_ORIGIN (ao);
 422
 423                   if (TREE_CODE (ao) == FUNCTION_DECL)
 424                     {
 425                       fndecl = ao;
 426                       break;
 427                     }
 428                   else if (TREE_CODE (ao) != BLOCK)
 429                     break;
 430
 431                   block = BLOCK_SUPERCONTEXT (block);
 432                 }
 433               if (fndecl)
 434                 abstract_origin = block;
 435               else
 436                 {
 437                   while (block && TREE_CODE (block) == BLOCK)
 438                     block = BLOCK_SUPERCONTEXT (block);
 439
 440                   if (block && TREE_CODE (block) == FUNCTION_DECL)
 441                     fndecl = block;
 442                   abstract_origin = NULL;
 443                 }
 444               if (fndecl)
 445                 {
 446                   expanded_location s = expand_location (*locus);
 447                   pp_character (context->printer, ',');
 448                   pp_newline (context->printer);
 449                   if (s.file != NULL)
 450                     {
 451                       if (flag_show_column && s.column != 0)
 452                         pp_printf (context->printer,
 453                                    _("    inlined from %qs at %s:%d:%d"),
 454                                    lang_hooks.decl_printable_name (fndecl, 2),
 455                                    s.file, s.line, s.column);
 456                       else
 457                         pp_printf (context->printer,
 458                                    _("    inlined from %qs at %s:%d"),
 459                                    lang_hooks.decl_printable_name (fndecl, 2),
 460                                    s.file, s.line);
 461
 462                     }
 463                   else
 464                     pp_printf (context->printer, _("    inlined from %qs"),
 465                                lang_hooks.decl_printable_name (fndecl, 2));
 466                 }
 467             }
 468           pp_character (context->printer, ':');
 469         }
 470
 471       diagnostic_set_last_function (context, diagnostic);
 472       pp_flush (context->printer);
 473       context->printer->prefix = old_prefix;
 474       free ((char*) new_prefix);
 475     }
 476 }
 477
 478 tree
 479 lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
 480                             int *walk_subtrees ATTRIBUTE_UNUSED)
 481 {
 482   return NULL;
 483 }
 484
 485 tree
 486 lhd_make_node (enum tree_code code)
 487 {
 488   return make_node (code);
 489 }
 490
 491 HOST_WIDE_INT
 492 lhd_to_target_charset (HOST_WIDE_INT c)
 493 {
 494   return c;
 495 }
 496
 497 tree
 498 lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
 499 {
 500   return expr;
 501 }
 502
 503 /* Return sharing kind if OpenMP sharing attribute of DECL is
 504    predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise.  */
 505
 506 enum omp_clause_default_kind
 507 lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
 508 {
 509   if (DECL_ARTIFICIAL (decl))
 510     return OMP_CLAUSE_DEFAULT_SHARED;
 511   return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
 512 }
 513
 514 /* Generate code to copy SRC to DST.  */
 515
 516 tree
 517 lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
 518 {
 519   return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
 520 }
 521
 522 /* Register language specific type size variables as potentially OpenMP
 523    firstprivate variables.  */
 524
 525 void
 526 lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED,
 527                                    tree t ATTRIBUTE_UNUSED)
 528 {
 529 }
 530
 531 /* Common function for add_builtin_function and
 532    add_builtin_function_ext_scope.  */
 533 static tree
 534 add_builtin_function_common (const char *name,
 535                              tree type,
 536                              int function_code,
 537                              enum built_in_class cl,
 538                              const char *library_name,
 539                              tree attrs,
 540                              tree (*hook) (tree))
 541 {
 542   tree   id = get_identifier (name);
 543   tree decl = build_decl (FUNCTION_DECL, id, type);
 544
 545   TREE_PUBLIC (decl)         = 1;
 546   DECL_EXTERNAL (decl)       = 1;
 547   DECL_BUILT_IN_CLASS (decl) = cl;
 548
 549   DECL_FUNCTION_CODE (decl)  = -1;
 550   gcc_assert (DECL_FUNCTION_CODE (decl) >= function_code);
 551   DECL_FUNCTION_CODE (decl)  = function_code;
 552
 553   if (library_name)
 554     {
 555       tree libname = get_identifier (library_name);
 556       SET_DECL_ASSEMBLER_NAME (decl, libname);
 557     }
 558
 559   /* Possibly apply some default attributes to this built-in function.  */
 560   if (attrs)
 561     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
 562   else
 563     decl_attributes (&decl, NULL_TREE, 0);
 564
 565   return hook (decl);
 566
 567 }
 568
 569 /* Create a builtin function.  */
 570
 571 tree
 572 add_builtin_function (const char *name,
 573                       tree type,
 574                       int function_code,
 575                       enum built_in_class cl,
 576                       const char *library_name,
 577                       tree attrs)
 578 {
 579   return add_builtin_function_common (name, type, function_code, cl,
 580                                       library_name, attrs,
 581                                       lang_hooks.builtin_function);
 582 }
 583
 584 /* Like add_builtin_function, but make sure the scope is the external scope.
 585    This is used to delay putting in back end builtin functions until the ISA
 586    that defines the builtin is declared via function specific target options,
 587    which can save memory for machines like the x86_64 that have multiple ISAs.
 588    If this points to the same function as builtin_function, the backend must
 589    add all of the builtins at program initialization time.  */
 590
 591 tree
 592 add_builtin_function_ext_scope (const char *name,
 593                                 tree type,
 594                                 int function_code,
 595                                 enum built_in_class cl,
 596                                 const char *library_name,
 597                                 tree attrs)
 598 {
 599   return add_builtin_function_common (name, type, function_code, cl,
 600                                       library_name, attrs,
 601                                       lang_hooks.builtin_function_ext_scope);
 602 }
 603
 604 tree
 605 lhd_builtin_function (tree decl)
 606 {
 607   lang_hooks.decls.pushdecl (decl);
 608   return decl;
 609 }