LCOV - code coverage report
Current view: top level - gcc/jit - dummy-frontend.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 60 75 80.0 %
Date: 2020-03-28 11:57:23 Functions: 7 10 70.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* jit.c -- Dummy "frontend" for use during JIT-compilation.
       2                 :            :    Copyright (C) 2013-2020 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 "jit-playback.h"
      24                 :            : #include "stor-layout.h"
      25                 :            : #include "debug.h"
      26                 :            : #include "langhooks.h"
      27                 :            : #include "langhooks-def.h"
      28                 :            : #include "diagnostic.h"
      29                 :            : 
      30                 :            : 
      31                 :            : #include <mpfr.h>
      32                 :            : 
      33                 :            : /* Language-dependent contents of a type.  */
      34                 :            : 
      35                 :            : struct GTY(()) lang_type
      36                 :            : {
      37                 :            :   char dummy;
      38                 :            : };
      39                 :            : 
      40                 :            : /* Language-dependent contents of a decl.  */
      41                 :            : 
      42                 :            : struct GTY((variable_size)) lang_decl
      43                 :            : {
      44                 :            :   char dummy;
      45                 :            : };
      46                 :            : 
      47                 :            : /* Language-dependent contents of an identifier.  This must include a
      48                 :            :    tree_identifier.  */
      49                 :            : 
      50                 :            : struct GTY(()) lang_identifier
      51                 :            : {
      52                 :            :   struct tree_identifier common;
      53                 :            : };
      54                 :            : 
      55                 :            : /* The resulting tree type.  */
      56                 :            : 
      57                 :            : union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
      58                 :            :            chain_next ("CODE_CONTAINS_STRUCT (TREE_CODE (&%h.generic), TS_COMMON) ? ((union lang_tree_node *) TREE_CHAIN (&%h.generic)) : NULL")))
      59                 :            : lang_tree_node
      60                 :            : {
      61                 :            :   union tree_node GTY((tag ("0"),
      62                 :            :                        desc ("tree_node_structure (&%h)"))) generic;
      63                 :            :   struct lang_identifier GTY((tag ("1"))) identifier;
      64                 :            : };
      65                 :            : 
      66                 :            : /* We don't use language_function.  */
      67                 :            : 
      68                 :            : struct GTY(()) language_function
      69                 :            : {
      70                 :            :   int dummy;
      71                 :            : };
      72                 :            : 
      73                 :            : /* GC-marking callback for use from jit_root_tab.
      74                 :            : 
      75                 :            :    If there's an active playback context, call its marking method
      76                 :            :    so that it can mark any pointers it references.  */
      77                 :            : 
      78                 :     329736 : static void my_ggc_walker (void *)
      79                 :            : {
      80                 :     329736 :   if (gcc::jit::active_playback_ctxt)
      81                 :     329736 :     gcc::jit::active_playback_ctxt->gt_ggc_mx ();
      82                 :     329736 : }
      83                 :            : 
      84                 :            : const char *dummy;
      85                 :            : 
      86                 :            : struct ggc_root_tab jit_root_tab[] =
      87                 :            :   {
      88                 :            :     {
      89                 :            :       &dummy, 1, 0, my_ggc_walker, NULL
      90                 :            :     },
      91                 :            :     LAST_GGC_ROOT_TAB
      92                 :            :   };
      93                 :            : 
      94                 :            : /* JIT-specific implementation of diagnostic callbacks.  */
      95                 :            : 
      96                 :            : /* Implementation of "begin_diagnostic".  */
      97                 :            : 
      98                 :            : static void
      99                 :         15 : jit_begin_diagnostic (diagnostic_context */*context*/,
     100                 :            :                       diagnostic_info */*diagnostic*/)
     101                 :            : {
     102                 :         15 :   gcc_assert (gcc::jit::active_playback_ctxt);
     103                 :         15 :   JIT_LOG_SCOPE (gcc::jit::active_playback_ctxt->get_logger ());
     104                 :            : 
     105                 :            :   /* No-op (apart from logging); the real error-handling is done in the
     106                 :            :      "end_diagnostic" hook.  */
     107                 :         15 : }
     108                 :            : 
     109                 :            : /* Implementation of "end_diagnostic".  */
     110                 :            : 
     111                 :            : static void
     112                 :         15 : jit_end_diagnostic (diagnostic_context *context,
     113                 :            :                     diagnostic_info *diagnostic,
     114                 :            :                     diagnostic_t)
     115                 :            : {
     116                 :         15 :   gcc_assert (gcc::jit::active_playback_ctxt);
     117                 :         30 :   JIT_LOG_SCOPE (gcc::jit::active_playback_ctxt->get_logger ());
     118                 :            : 
     119                 :            :   /* Delegate to the playback context (and thence to the
     120                 :            :      recording context).  */
     121                 :         15 :   gcc::jit::active_playback_ctxt->add_diagnostic (context, diagnostic);
     122                 :         15 : }
     123                 :            : 
     124                 :            : /* Language hooks.  */
     125                 :            : 
     126                 :            : static bool
     127                 :        883 : jit_langhook_init (void)
     128                 :            : {
     129                 :        883 :   gcc_assert (gcc::jit::active_playback_ctxt);
     130                 :        883 :   JIT_LOG_SCOPE (gcc::jit::active_playback_ctxt->get_logger ());
     131                 :            : 
     132                 :        883 :   static bool registered_root_tab = false;
     133                 :        883 :   if (!registered_root_tab)
     134                 :            :     {
     135                 :         69 :       ggc_register_root_tab (jit_root_tab);
     136                 :         69 :       registered_root_tab = true;
     137                 :            :     }
     138                 :            : 
     139                 :        883 :   gcc_assert (global_dc);
     140                 :        883 :   global_dc->begin_diagnostic = jit_begin_diagnostic;
     141                 :        883 :   global_dc->end_diagnostic = jit_end_diagnostic;
     142                 :            : 
     143                 :        883 :   build_common_tree_nodes (false);
     144                 :            : 
     145                 :            :   /* I don't know why this has to be done explicitly.  */
     146                 :        883 :   void_list_node = build_tree_list (NULL_TREE, void_type_node);
     147                 :            : 
     148                 :        883 :   build_common_builtin_nodes ();
     149                 :            : 
     150                 :            :   /* The default precision for floating point numbers.  This is used
     151                 :            :      for floating point constants with abstract type.  This may
     152                 :            :      eventually be controllable by a command line option.  */
     153                 :        883 :   mpfr_set_default_prec (256);
     154                 :            : 
     155                 :        883 :   return true;
     156                 :            : }
     157                 :            : 
     158                 :            : static void
     159                 :        883 : jit_langhook_parse_file (void)
     160                 :            : {
     161                 :            :   /* Replay the activity by the client, recorded on the context.  */
     162                 :        883 :   gcc_assert (gcc::jit::active_playback_ctxt);
     163                 :        883 :   gcc::jit::active_playback_ctxt->replay ();
     164                 :        883 : }
     165                 :            : 
     166                 :            : static tree
     167                 :       8763 : jit_langhook_type_for_mode (machine_mode mode, int unsignedp)
     168                 :            : {
     169                 :            :   /* Build any vector types here (see PR 46805).  */
     170                 :       8763 :   if (VECTOR_MODE_P (mode))
     171                 :            :     {
     172                 :          0 :       tree inner;
     173                 :            : 
     174                 :          0 :       inner = jit_langhook_type_for_mode (GET_MODE_INNER (mode), unsignedp);
     175                 :          0 :       if (inner != NULL_TREE)
     176                 :          0 :         return build_vector_type_for_mode (inner, mode);
     177                 :            :       return NULL_TREE;
     178                 :            :     }
     179                 :            : 
     180                 :       8763 :   if (mode == TYPE_MODE (float_type_node))
     181                 :         50 :     return float_type_node;
     182                 :            : 
     183                 :       8713 :   if (mode == TYPE_MODE (double_type_node))
     184                 :        444 :     return double_type_node;
     185                 :            : 
     186                 :       8269 :   if (mode == TYPE_MODE (intQI_type_node))
     187                 :        790 :     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
     188                 :       7479 :   if (mode == TYPE_MODE (intHI_type_node))
     189                 :         60 :     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
     190                 :       7419 :   if (mode == TYPE_MODE (intSI_type_node))
     191                 :       2689 :     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
     192                 :       4730 :   if (mode == TYPE_MODE (intDI_type_node))
     193                 :       1198 :     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
     194                 :       3532 :   if (mode == TYPE_MODE (intTI_type_node))
     195                 :          0 :     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
     196                 :            : 
     197                 :       3532 :   if (mode == TYPE_MODE (integer_type_node))
     198                 :          0 :     return unsignedp ? unsigned_type_node : integer_type_node;
     199                 :            : 
     200                 :       3532 :   if (mode == TYPE_MODE (long_integer_type_node))
     201                 :          0 :     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
     202                 :            : 
     203                 :       3532 :   if (mode == TYPE_MODE (long_long_integer_type_node))
     204                 :          0 :     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
     205                 :            : 
     206                 :       3532 :   if (COMPLEX_MODE_P (mode))
     207                 :            :     {
     208                 :       3532 :       if (mode == TYPE_MODE (complex_float_type_node))
     209                 :        883 :         return complex_float_type_node;
     210                 :       2649 :       if (mode == TYPE_MODE (complex_double_type_node))
     211                 :        883 :         return complex_double_type_node;
     212                 :       1766 :       if (mode == TYPE_MODE (complex_long_double_type_node))
     213                 :        883 :         return complex_long_double_type_node;
     214                 :        883 :       if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
     215                 :          0 :         return complex_integer_type_node;
     216                 :            :     }
     217                 :            : 
     218                 :            :   /* gcc_unreachable */
     219                 :            :   return NULL;
     220                 :            : }
     221                 :            : 
     222                 :            : /* Record a builtin function.  We just ignore builtin functions.  */
     223                 :            : 
     224                 :            : static tree
     225                 :      22765 : jit_langhook_builtin_function (tree decl)
     226                 :            : {
     227                 :      22765 :   return decl;
     228                 :            : }
     229                 :            : 
     230                 :            : static bool
     231                 :          0 : jit_langhook_global_bindings_p (void)
     232                 :            : {
     233                 :          0 :   gcc_unreachable ();
     234                 :            :   return true;
     235                 :            : }
     236                 :            : 
     237                 :            : static tree
     238                 :          0 : jit_langhook_pushdecl (tree decl ATTRIBUTE_UNUSED)
     239                 :            : {
     240                 :          0 :   gcc_unreachable ();
     241                 :            : }
     242                 :            : 
     243                 :            : static tree
     244                 :          0 : jit_langhook_getdecls (void)
     245                 :            : {
     246                 :          0 :   return NULL;
     247                 :            : }
     248                 :            : 
     249                 :            : #undef LANG_HOOKS_NAME
     250                 :            : #define LANG_HOOKS_NAME         "libgccjit"
     251                 :            : 
     252                 :            : #undef LANG_HOOKS_INIT
     253                 :            : #define LANG_HOOKS_INIT         jit_langhook_init
     254                 :            : 
     255                 :            : #undef LANG_HOOKS_PARSE_FILE
     256                 :            : #define LANG_HOOKS_PARSE_FILE           jit_langhook_parse_file
     257                 :            : 
     258                 :            : #undef LANG_HOOKS_TYPE_FOR_MODE
     259                 :            : #define LANG_HOOKS_TYPE_FOR_MODE        jit_langhook_type_for_mode
     260                 :            : 
     261                 :            : #undef LANG_HOOKS_BUILTIN_FUNCTION
     262                 :            : #define LANG_HOOKS_BUILTIN_FUNCTION     jit_langhook_builtin_function
     263                 :            : 
     264                 :            : #undef LANG_HOOKS_GLOBAL_BINDINGS_P
     265                 :            : #define LANG_HOOKS_GLOBAL_BINDINGS_P    jit_langhook_global_bindings_p
     266                 :            : 
     267                 :            : #undef LANG_HOOKS_PUSHDECL
     268                 :            : #define LANG_HOOKS_PUSHDECL             jit_langhook_pushdecl
     269                 :            : 
     270                 :            : #undef LANG_HOOKS_GETDECLS
     271                 :            : #define LANG_HOOKS_GETDECLS             jit_langhook_getdecls
     272                 :            : 
     273                 :            : struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
     274                 :            : 
     275                 :            : #include "gt-jit-dummy-frontend.h"
     276                 :            : #include "gtype-jit.h"

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.